diff options
Diffstat (limited to 'spec/ruby/core/integer')
62 files changed, 857 insertions, 593 deletions
diff --git a/spec/ruby/core/integer/allbits_spec.rb b/spec/ruby/core/integer/allbits_spec.rb index edce4b15e7..6023cc32bf 100644 --- a/spec/ruby/core/integer/allbits_spec.rb +++ b/spec/ruby/core/integer/allbits_spec.rb @@ -30,8 +30,8 @@ describe "Integer#allbits?" do -> { (obj = mock('10')).should_receive(:coerce).any_number_of_times.and_return([42,10]) 13.allbits?(obj) - }.should raise_error(TypeError) - -> { 13.allbits?("10") }.should raise_error(TypeError) - -> { 13.allbits?(:symbol) }.should raise_error(TypeError) + }.should.raise(TypeError) + -> { 13.allbits?("10") }.should.raise(TypeError) + -> { 13.allbits?(:symbol) }.should.raise(TypeError) end end diff --git a/spec/ruby/core/integer/anybits_spec.rb b/spec/ruby/core/integer/anybits_spec.rb index e0449074a2..1ea47b76dc 100644 --- a/spec/ruby/core/integer/anybits_spec.rb +++ b/spec/ruby/core/integer/anybits_spec.rb @@ -29,8 +29,8 @@ describe "Integer#anybits?" do -> { (obj = mock('10')).should_receive(:coerce).any_number_of_times.and_return([42,10]) 13.anybits?(obj) - }.should raise_error(TypeError) - -> { 13.anybits?("10") }.should raise_error(TypeError) - -> { 13.anybits?(:symbol) }.should raise_error(TypeError) + }.should.raise(TypeError) + -> { 13.anybits?("10") }.should.raise(TypeError) + -> { 13.anybits?(:symbol) }.should.raise(TypeError) end end diff --git a/spec/ruby/core/integer/bit_and_spec.rb b/spec/ruby/core/integer/bit_and_spec.rb index 8de5a14aaa..4098ad7c7b 100644 --- a/spec/ruby/core/integer/bit_and_spec.rb +++ b/spec/ruby/core/integer/bit_and_spec.rb @@ -30,19 +30,19 @@ describe "Integer#&" do it "coerces the rhs and calls #coerce" do obj = mock("fixnum bit and") - obj.should_receive(:coerce).with(6).and_return([3, 6]) + obj.should_receive(:coerce).with(6).and_return([6, 3]) (6 & obj).should == 2 end it "raises a TypeError when passed a Float" do - -> { (3 & 3.4) }.should raise_error(TypeError) + -> { (3 & 3.4) }.should.raise(TypeError) end it "raises a TypeError and does not call #to_int when defined on an object" do obj = mock("fixnum bit and") obj.should_not_receive(:to_int) - -> { 3 & obj }.should raise_error(TypeError) + -> { 3 & obj }.should.raise(TypeError) end end @@ -84,14 +84,14 @@ describe "Integer#&" do end it "raises a TypeError when passed a Float" do - -> { (@bignum & 3.4) }.should raise_error(TypeError) + -> { (@bignum & 3.4) }.should.raise(TypeError) end it "raises a TypeError and does not call #to_int when defined on an object" do obj = mock("bignum bit and") obj.should_not_receive(:to_int) - -> { @bignum & obj }.should raise_error(TypeError) + -> { @bignum & obj }.should.raise(TypeError) end end end diff --git a/spec/ruby/core/integer/bit_or_spec.rb b/spec/ruby/core/integer/bit_or_spec.rb index 6f4279c170..c380cd729e 100644 --- a/spec/ruby/core/integer/bit_or_spec.rb +++ b/spec/ruby/core/integer/bit_or_spec.rb @@ -30,20 +30,20 @@ describe "Integer#|" do end it "coerces the rhs and calls #coerce" do - obj = mock("fixnum bit and") - obj.should_receive(:coerce).with(6).and_return([3, 6]) - (6 & obj).should == 2 + obj = mock("fixnum bit or") + obj.should_receive(:coerce).with(6).and_return([6, 3]) + (6 | obj).should == 7 end it "raises a TypeError when passed a Float" do - -> { (3 | 3.4) }.should raise_error(TypeError) + -> { (3 | 3.4) }.should.raise(TypeError) end it "raises a TypeError and does not call #to_int when defined on an object" do obj = mock("integer bit or") obj.should_not_receive(:to_int) - -> { 3 | obj }.should raise_error(TypeError) + -> { 3 | obj }.should.raise(TypeError) end end @@ -74,16 +74,16 @@ describe "Integer#|" do not_supported_on :opal do -> { bignum_value | bignum_value(0xffff).to_f - }.should raise_error(TypeError) + }.should.raise(TypeError) end - -> { @bignum | 9.9 }.should raise_error(TypeError) + -> { @bignum | 9.9 }.should.raise(TypeError) end it "raises a TypeError and does not call #to_int when defined on an object" do obj = mock("bignum bit or") obj.should_not_receive(:to_int) - -> { @bignum | obj }.should raise_error(TypeError) + -> { @bignum | obj }.should.raise(TypeError) end end end diff --git a/spec/ruby/core/integer/bit_xor_spec.rb b/spec/ruby/core/integer/bit_xor_spec.rb index f1150a20d5..c0cf8405f7 100644 --- a/spec/ruby/core/integer/bit_xor_spec.rb +++ b/spec/ruby/core/integer/bit_xor_spec.rb @@ -28,20 +28,20 @@ describe "Integer#^" do end it "coerces the rhs and calls #coerce" do - obj = mock("fixnum bit and") - obj.should_receive(:coerce).with(6).and_return([3, 6]) + obj = mock("fixnum bit xor") + obj.should_receive(:coerce).with(6).and_return([6, 3]) (6 ^ obj).should == 5 end it "raises a TypeError when passed a Float" do - -> { (3 ^ 3.4) }.should raise_error(TypeError) + -> { (3 ^ 3.4) }.should.raise(TypeError) end it "raises a TypeError and does not call #to_int when defined on an object" do obj = mock("integer bit xor") obj.should_not_receive(:to_int) - -> { 3 ^ obj }.should raise_error(TypeError) + -> { 3 ^ obj }.should.raise(TypeError) end end @@ -78,16 +78,16 @@ describe "Integer#^" do not_supported_on :opal do -> { bignum_value ^ bignum_value(0xffff).to_f - }.should raise_error(TypeError) + }.should.raise(TypeError) end - -> { @bignum ^ 14.5 }.should raise_error(TypeError) + -> { @bignum ^ 14.5 }.should.raise(TypeError) end it "raises a TypeError and does not call #to_int when defined on an object" do obj = mock("bignum bit xor") obj.should_not_receive(:to_int) - -> { @bignum ^ obj }.should raise_error(TypeError) + -> { @bignum ^ obj }.should.raise(TypeError) end end end diff --git a/spec/ruby/core/integer/ceil_spec.rb b/spec/ruby/core/integer/ceil_spec.rb index 13bdaf838d..395be58fbd 100644 --- a/spec/ruby/core/integer/ceil_spec.rb +++ b/spec/ruby/core/integer/ceil_spec.rb @@ -1,19 +1,13 @@ require_relative '../../spec_helper' require_relative 'shared/to_i' require_relative 'shared/integer_rounding' +require_relative 'shared/integer_ceil_precision' describe "Integer#ceil" do it_behaves_like :integer_to_i, :ceil it_behaves_like :integer_rounding_positive_precision, :ceil - context "precision argument specified as part of the ceil method is negative" do - it "returns the smallest integer greater than self with at least precision.abs trailing zeros" do - 18.ceil(-1).should eql(20) - 18.ceil(-2).should eql(100) - 18.ceil(-3).should eql(1000) - -1832.ceil(-1).should eql(-1830) - -1832.ceil(-2).should eql(-1800) - -1832.ceil(-3).should eql(-1000) - end + context "with precision" do + it_behaves_like :integer_ceil_precision, :Integer end end diff --git a/spec/ruby/core/integer/ceildiv_spec.rb b/spec/ruby/core/integer/ceildiv_spec.rb new file mode 100644 index 0000000000..91f63832f8 --- /dev/null +++ b/spec/ruby/core/integer/ceildiv_spec.rb @@ -0,0 +1,20 @@ +require_relative '../../spec_helper' + +describe "Integer#ceildiv" do + it "returns a quotient of division which is rounded up to the nearest integer" do + 0.ceildiv(3).should.eql?(0) + 1.ceildiv(3).should.eql?(1) + 3.ceildiv(3).should.eql?(1) + 4.ceildiv(3).should.eql?(2) + + 4.ceildiv(-3).should.eql?(-1) + -4.ceildiv(3).should.eql?(-1) + -4.ceildiv(-3).should.eql?(2) + + 3.ceildiv(1.2).should.eql?(3) + 3.ceildiv(6/5r).should.eql?(3) + + (10**100-11).ceildiv(10**99-1).should.eql?(10) + (10**100-9).ceildiv(10**99-1).should.eql?(11) + end +end diff --git a/spec/ruby/core/integer/chr_spec.rb b/spec/ruby/core/integer/chr_spec.rb index 8fe20ff812..72784e1833 100644 --- a/spec/ruby/core/integer/chr_spec.rb +++ b/spec/ruby/core/integer/chr_spec.rb @@ -2,20 +2,20 @@ require_relative '../../spec_helper' describe "Integer#chr without argument" do it "returns a String" do - 17.chr.should be_an_instance_of(String) + 17.chr.should.instance_of?(String) end it "returns a new String for each call" do - 82.chr.should_not equal(82.chr) + 82.chr.should_not.equal?(82.chr) end it "raises a RangeError is self is less than 0" do - -> { -1.chr }.should raise_error(RangeError) - -> { (-bignum_value).chr }.should raise_error(RangeError) + -> { -1.chr }.should.raise(RangeError, /-1 out of char range/) + -> { (-bignum_value).chr }.should.raise(RangeError, /bignum out of char range/) end it "raises a RangeError if self is too large" do - -> { 2206368128.chr(Encoding::UTF_8) }.should raise_error(RangeError) + -> { 2206368128.chr(Encoding::UTF_8) }.should.raise(RangeError, /2206368128 out of char range/) end describe "when Encoding.default_internal is nil" do @@ -48,8 +48,8 @@ describe "Integer#chr without argument" do end it "raises a RangeError is self is greater than 255" do - -> { 256.chr }.should raise_error(RangeError) - -> { bignum_value.chr }.should raise_error(RangeError) + -> { 256.chr }.should.raise(RangeError, /256 out of char range/) + -> { bignum_value.chr }.should.raise(RangeError, /bignum out of char range/) end end @@ -137,7 +137,7 @@ describe "Integer#chr without argument" do [620, "TIS-620"] ].each do |integer, encoding_name| Encoding.default_internal = Encoding.find(encoding_name) - -> { integer.chr }.should raise_error(RangeError) + -> { integer.chr }.should.raise(RangeError, /(invalid codepoint|out of char range)/) end end end @@ -146,15 +146,15 @@ end describe "Integer#chr with an encoding argument" do it "returns a String" do - 900.chr(Encoding::UTF_8).should be_an_instance_of(String) + 900.chr(Encoding::UTF_8).should.instance_of?(String) end it "returns a new String for each call" do - 8287.chr(Encoding::UTF_8).should_not equal(8287.chr(Encoding::UTF_8)) + 8287.chr(Encoding::UTF_8).should_not.equal?(8287.chr(Encoding::UTF_8)) end it "accepts a String as an argument" do - -> { 0xA4A2.chr('euc-jp') }.should_not raise_error + -> { 0xA4A2.chr('euc-jp') }.should_not.raise end it "converts a String to an Encoding as Encoding.find does" do @@ -165,12 +165,12 @@ describe "Integer#chr with an encoding argument" do # http://redmine.ruby-lang.org/issues/4869 it "raises a RangeError is self is less than 0" do - -> { -1.chr(Encoding::UTF_8) }.should raise_error(RangeError) - -> { (-bignum_value).chr(Encoding::EUC_JP) }.should raise_error(RangeError) + -> { -1.chr(Encoding::UTF_8) }.should.raise(RangeError, /-1 out of char range/) + -> { (-bignum_value).chr(Encoding::EUC_JP) }.should.raise(RangeError, /bignum out of char range/) end it "raises a RangeError if self is too large" do - -> { 2206368128.chr(Encoding::UTF_8) }.should raise_error(RangeError) + -> { 2206368128.chr(Encoding::UTF_8) }.should.raise(RangeError, /2206368128 out of char range/) end it "returns a String with the specified encoding" do @@ -223,25 +223,25 @@ describe "Integer#chr with an encoding argument" do # #5864 it "raises RangeError if self is invalid as a codepoint in the specified encoding" do - -> { 0x80.chr("US-ASCII") }.should raise_error(RangeError) - -> { 0x0100.chr("BINARY") }.should raise_error(RangeError) - -> { 0x0100.chr("EUC-JP") }.should raise_error(RangeError) - -> { 0xA1A0.chr("EUC-JP") }.should raise_error(RangeError) - -> { 0xA1.chr("EUC-JP") }.should raise_error(RangeError) - -> { 0x80.chr("SHIFT_JIS") }.should raise_error(RangeError) - -> { 0xE0.chr("SHIFT_JIS") }.should raise_error(RangeError) - -> { 0x0100.chr("ISO-8859-9") }.should raise_error(RangeError) - -> { 620.chr("TIS-620") }.should raise_error(RangeError) + -> { 0x80.chr("US-ASCII") }.should.raise(RangeError) + -> { 0x0100.chr("BINARY") }.should.raise(RangeError) + -> { 0x0100.chr("EUC-JP") }.should.raise(RangeError) + -> { 0xA1A0.chr("EUC-JP") }.should.raise(RangeError) + -> { 0xA1.chr("EUC-JP") }.should.raise(RangeError) + -> { 0x80.chr("SHIFT_JIS") }.should.raise(RangeError) + -> { 0xE0.chr("SHIFT_JIS") }.should.raise(RangeError) + -> { 0x0100.chr("ISO-8859-9") }.should.raise(RangeError) + -> { 620.chr("TIS-620") }.should.raise(RangeError) # UTF-16 surrogate range - -> { 0xD800.chr("UTF-8") }.should raise_error(RangeError) - -> { 0xDBFF.chr("UTF-8") }.should raise_error(RangeError) - -> { 0xDC00.chr("UTF-8") }.should raise_error(RangeError) - -> { 0xDFFF.chr("UTF-8") }.should raise_error(RangeError) + -> { 0xD800.chr("UTF-8") }.should.raise(RangeError) + -> { 0xDBFF.chr("UTF-8") }.should.raise(RangeError) + -> { 0xDC00.chr("UTF-8") }.should.raise(RangeError) + -> { 0xDFFF.chr("UTF-8") }.should.raise(RangeError) # UTF-16 surrogate range - -> { 0xD800.chr("UTF-16") }.should raise_error(RangeError) - -> { 0xDBFF.chr("UTF-16") }.should raise_error(RangeError) - -> { 0xDC00.chr("UTF-16") }.should raise_error(RangeError) - -> { 0xDFFF.chr("UTF-16") }.should raise_error(RangeError) + -> { 0xD800.chr("UTF-16") }.should.raise(RangeError) + -> { 0xDBFF.chr("UTF-16") }.should.raise(RangeError) + -> { 0xDC00.chr("UTF-16") }.should.raise(RangeError) + -> { 0xDFFF.chr("UTF-16") }.should.raise(RangeError) end it 'returns a String encoding self interpreted as a codepoint in the CESU-8 encoding' do diff --git a/spec/ruby/core/integer/coerce_spec.rb b/spec/ruby/core/integer/coerce_spec.rb index f1f3256032..c0e642da03 100644 --- a/spec/ruby/core/integer/coerce_spec.rb +++ b/spec/ruby/core/integer/coerce_spec.rb @@ -1,7 +1,5 @@ require_relative '../../spec_helper' -require 'bigdecimal' - describe "Integer#coerce" do context "fixnum" do describe "when given a Fixnum" do @@ -13,7 +11,7 @@ describe "Integer#coerce" do describe "when given a String" do it "raises an ArgumentError when trying to coerce with a non-number String" do - -> { 1.coerce(":)") }.should raise_error(ArgumentError) + -> { 1.coerce(":)") }.should.raise(ArgumentError) end it "returns an array containing two Floats" do @@ -23,7 +21,7 @@ describe "Integer#coerce" do end it "raises a TypeError when trying to coerce with nil" do - -> { 1.coerce(nil) }.should raise_error(TypeError) + -> { 1.coerce(nil) }.should.raise(TypeError) end it "tries to convert the given Object into a Float by using #to_f" do @@ -31,13 +29,13 @@ describe "Integer#coerce" do 2.coerce(obj).should == [1.0, 2.0] (obj = mock('0')).should_receive(:to_f).and_return('0') - -> { 2.coerce(obj).should == [1.0, 2.0] }.should raise_error(TypeError) + -> { 2.coerce(obj).should == [1.0, 2.0] }.should.raise(TypeError) end it "raises a TypeError when given an Object that does not respond to #to_f" do - -> { 1.coerce(mock('x')) }.should raise_error(TypeError) - -> { 1.coerce(1..4) }.should raise_error(TypeError) - -> { 1.coerce(:test) }.should raise_error(TypeError) + -> { 1.coerce(mock('x')) }.should.raise(TypeError) + -> { 1.coerce(1..4) }.should.raise(TypeError) + -> { 1.coerce(:test) }.should.raise(TypeError) end end @@ -46,8 +44,8 @@ describe "Integer#coerce" do a = bignum_value ary = a.coerce(2) - ary[0].should be_kind_of(Integer) - ary[1].should be_kind_of(Integer) + ary[0].should.is_a?(Integer) + ary[1].should.is_a?(Integer) ary.should == [2, a] end @@ -56,18 +54,18 @@ describe "Integer#coerce" do b = bignum_value ary = a.coerce(b) - ary[0].should be_kind_of(Integer) - ary[1].should be_kind_of(Integer) + ary[0].should.is_a?(Integer) + ary[1].should.is_a?(Integer) ary.should == [b, a] end it "raises a TypeError when not passed a Fixnum or Bignum" do a = bignum_value - -> { a.coerce(nil) }.should raise_error(TypeError) - -> { a.coerce(mock('str')) }.should raise_error(TypeError) - -> { a.coerce(1..4) }.should raise_error(TypeError) - -> { a.coerce(:test) }.should raise_error(TypeError) + -> { a.coerce(nil) }.should.raise(TypeError) + -> { a.coerce(mock('str')) }.should.raise(TypeError) + -> { a.coerce(1..4) }.should.raise(TypeError) + -> { a.coerce(:test) }.should.raise(TypeError) end it "coerces both values to Floats and returns [other, self] when passed a Float" do @@ -90,15 +88,4 @@ describe "Integer#coerce" do ary.should == [1.2, a.to_f] end end - - context "bigdecimal" do - it "produces Floats" do - x, y = 3.coerce(BigDecimal("3.4")) - x.class.should == Float - x.should == 3.4 - y.class.should == Float - y.should == 3.0 - end - end - end diff --git a/spec/ruby/core/integer/comparison_spec.rb b/spec/ruby/core/integer/comparison_spec.rb index 408c8e52ce..cc5cbe2506 100644 --- a/spec/ruby/core/integer/comparison_spec.rb +++ b/spec/ruby/core/integer/comparison_spec.rb @@ -128,17 +128,17 @@ describe "Integer#<=>" do @num.should_receive(:coerce).with(@big).and_raise(RuntimeError.new("my error")) -> { @big <=> @num - }.should raise_error(RuntimeError, "my error") + }.should.raise(RuntimeError, "my error") end it "raises an exception if #coerce raises a non-StandardError exception" do @num.should_receive(:coerce).with(@big).and_raise(Exception) - -> { @big <=> @num }.should raise_error(Exception) + -> { @big <=> @num }.should.raise(Exception) end it "returns nil if #coerce does not return an Array" do @num.should_receive(:coerce).with(@big).and_return(nil) - (@big <=> @num).should be_nil + (@big <=> @num).should == nil end it "returns -1 if the coerced value is larger" do @@ -157,6 +157,14 @@ describe "Integer#<=>" do end end + describe "with a Float" do + it "does not lose precision for values that don't fit in a double" do + (bignum_value(1) <=> bignum_value.to_f).should == 1 + (bignum_value <=> bignum_value.to_f).should == 0 + ((bignum_value - 1) <=> bignum_value.to_f).should == -1 + end + end + # The tests below are taken from matz's revision 23730 for Ruby trunk it "returns 1 when self is Infinity and other is a Bignum" do (infinity_value <=> Float::MAX.to_i*2).should == 1 diff --git a/spec/ruby/core/integer/constants_spec.rb b/spec/ruby/core/integer/constants_spec.rb index 2077ad451e..937806c72f 100644 --- a/spec/ruby/core/integer/constants_spec.rb +++ b/spec/ruby/core/integer/constants_spec.rb @@ -1,41 +1,13 @@ require_relative '../../spec_helper' describe "Fixnum" do - ruby_version_is ""..."3.2" do - it "is unified into Integer" do - suppress_warning do - Fixnum.should equal(Integer) - end - end - - it "is deprecated" do - -> { Fixnum }.should complain(/constant ::Fixnum is deprecated/) - end - end - - ruby_version_is "3.2" do - it "is no longer defined" do - Object.should_not.const_defined?(:Fixnum) - end + it "is no longer defined" do + Object.should_not.const_defined?(:Fixnum) end end describe "Bignum" do - ruby_version_is ""..."3.2" do - it "is unified into Integer" do - suppress_warning do - Bignum.should equal(Integer) - end - end - - it "is deprecated" do - -> { Bignum }.should complain(/constant ::Bignum is deprecated/) - end - end - - ruby_version_is "3.2" do - it "is no longer defined" do - Object.should_not.const_defined?(:Bignum) - end + it "is no longer defined" do + Object.should_not.const_defined?(:Bignum) end end diff --git a/spec/ruby/core/integer/digits_spec.rb b/spec/ruby/core/integer/digits_spec.rb index 3d0a64c25f..c4ebf2cd88 100644 --- a/spec/ruby/core/integer/digits_spec.rb +++ b/spec/ruby/core/integer/digits_spec.rb @@ -19,15 +19,15 @@ describe "Integer#digits" do end it "raises ArgumentError when calling with a radix less than 2" do - -> { 12345.digits(1) }.should raise_error(ArgumentError) + -> { 12345.digits(1) }.should.raise(ArgumentError) end it "raises ArgumentError when calling with a negative radix" do - -> { 12345.digits(-2) }.should raise_error(ArgumentError) + -> { 12345.digits(-2) }.should.raise(ArgumentError) end it "raises Math::DomainError when calling digits on a negative number" do - -> { -12345.digits(7) }.should raise_error(Math::DomainError) + -> { -12345.digits(7) }.should.raise(Math::DomainError) end it "returns integer values > 9 when base is above 10" do diff --git a/spec/ruby/core/integer/div_spec.rb b/spec/ruby/core/integer/div_spec.rb index 344e095179..220ca4a73e 100644 --- a/spec/ruby/core/integer/div_spec.rb +++ b/spec/ruby/core/integer/div_spec.rb @@ -46,21 +46,21 @@ describe "Integer#div" do end it "raises a ZeroDivisionError when the given argument is 0 and a Float" do - -> { 0.div(0.0) }.should raise_error(ZeroDivisionError) - -> { 10.div(0.0) }.should raise_error(ZeroDivisionError) - -> { -10.div(0.0) }.should raise_error(ZeroDivisionError) + -> { 0.div(0.0) }.should.raise(ZeroDivisionError) + -> { 10.div(0.0) }.should.raise(ZeroDivisionError) + -> { -10.div(0.0) }.should.raise(ZeroDivisionError) end it "raises a ZeroDivisionError when the given argument is 0 and not a Float" do - -> { 13.div(0) }.should raise_error(ZeroDivisionError) - -> { 13.div(-0) }.should raise_error(ZeroDivisionError) + -> { 13.div(0) }.should.raise(ZeroDivisionError) + -> { 13.div(-0) }.should.raise(ZeroDivisionError) end it "raises a TypeError when given a non-numeric argument" do - -> { 13.div(mock('10')) }.should raise_error(TypeError) - -> { 5.div("2") }.should raise_error(TypeError) - -> { 5.div(:"2") }.should raise_error(TypeError) - -> { 5.div([]) }.should raise_error(TypeError) + -> { 13.div(mock('10')) }.should.raise(TypeError) + -> { 5.div("2") }.should.raise(TypeError) + -> { 5.div(:"2") }.should.raise(TypeError) + -> { 5.div([]) }.should.raise(TypeError) end end @@ -118,29 +118,37 @@ describe "Integer#div" do end it "raises a TypeError when given a non-numeric" do - -> { @bignum.div(mock("10")) }.should raise_error(TypeError) - -> { @bignum.div("2") }.should raise_error(TypeError) - -> { @bignum.div(:symbol) }.should raise_error(TypeError) + -> { @bignum.div(mock("10")) }.should.raise(TypeError) + -> { @bignum.div("2") }.should.raise(TypeError) + -> { @bignum.div(:symbol) }.should.raise(TypeError) end it "returns a result of integer division of self by a float argument" do - @bignum.div(4294967295.5).should eql(4294967296) + @bignum.div(4294967295.5).should.eql?(4294967296) not_supported_on :opal do - @bignum.div(4294967295.0).should eql(4294967297) - @bignum.div(bignum_value(88).to_f).should eql(1) - @bignum.div((-bignum_value(88)).to_f).should eql(-1) + @bignum.div(4294967295.0).should.eql?(4294967297) + @bignum.div(bignum_value(88).to_f).should.eql?(1) + @bignum.div((-bignum_value(88)).to_f).should.eql?(-1) end end # #5490 it "raises ZeroDivisionError if the argument is 0 and is a Float" do - -> { @bignum.div(0.0) }.should raise_error(ZeroDivisionError) - -> { @bignum.div(-0.0) }.should raise_error(ZeroDivisionError) + -> { @bignum.div(0.0) }.should.raise(ZeroDivisionError) + -> { @bignum.div(-0.0) }.should.raise(ZeroDivisionError) end it "raises ZeroDivisionError if the argument is 0 and is not a Float" do - -> { @bignum.div(0) }.should raise_error(ZeroDivisionError) - -> { @bignum.div(-0) }.should raise_error(ZeroDivisionError) + -> { @bignum.div(0) }.should.raise(ZeroDivisionError) + -> { @bignum.div(-0) }.should.raise(ZeroDivisionError) + end + end + + context "rational" do + it "returns self divided by the given argument as an Integer" do + 2.div(6/5r).should == 1 + 1.div(6/5r).should == 0 + 5.div(6/5r).should == 4 end end end diff --git a/spec/ruby/core/integer/divide_spec.rb b/spec/ruby/core/integer/divide_spec.rb index a878c4668c..e75432fd83 100644 --- a/spec/ruby/core/integer/divide_spec.rb +++ b/spec/ruby/core/integer/divide_spec.rb @@ -12,6 +12,17 @@ describe "Integer#/" do it "supports dividing negative numbers" do (-1 / 10).should == -1 + (-1 / 10**10).should == -1 + (-1 / 10**20).should == -1 + end + + it "preservers sign correctly" do + (4 / 3).should == 1 + (4 / -3).should == -2 + (-4 / 3).should == -2 + (-4 / -3).should == 1 + (0 / -3).should == 0 + (0 / 3).should == 0 end it "returns result the same class as the argument" do @@ -21,7 +32,7 @@ describe "Integer#/" do end it "raises a ZeroDivisionError if the given argument is zero and not a Float" do - -> { 1 / 0 }.should raise_error(ZeroDivisionError) + -> { 1 / 0 }.should.raise(ZeroDivisionError) end it "does NOT raise ZeroDivisionError if the given argument is zero and is a Float" do @@ -35,9 +46,9 @@ describe "Integer#/" do end it "raises a TypeError when given a non-Integer" do - -> { 13 / mock('10') }.should raise_error(TypeError) - -> { 13 / "10" }.should raise_error(TypeError) - -> { 13 / :symbol }.should raise_error(TypeError) + -> { 13 / mock('10') }.should.raise(TypeError) + -> { 13 / "10" }.should.raise(TypeError) + -> { 13 / :symbol }.should.raise(TypeError) end end @@ -58,6 +69,15 @@ describe "Integer#/" do ((10**50) / -(10**40 + 1)).should == -10000000000 end + it "preservers sign correctly" do + (4 / bignum_value).should == 0 + (4 / -bignum_value).should == -1 + (-4 / bignum_value).should == -1 + (-4 / -bignum_value).should == 0 + (0 / bignum_value).should == 0 + (0 / -bignum_value).should == 0 + end + it "returns self divided by Float" do not_supported_on :opal do (bignum_value(88) / 4294967295.0).should be_close(4294967297.0, TOLERANCE) @@ -77,13 +97,30 @@ describe "Integer#/" do end it "raises a ZeroDivisionError if other is zero and not a Float" do - -> { @bignum / 0 }.should raise_error(ZeroDivisionError) + -> { @bignum / 0 }.should.raise(ZeroDivisionError) end it "raises a TypeError when given a non-numeric" do - -> { @bignum / mock('10') }.should raise_error(TypeError) - -> { @bignum / "2" }.should raise_error(TypeError) - -> { @bignum / :symbol }.should raise_error(TypeError) + -> { @bignum / mock('10') }.should.raise(TypeError) + -> { @bignum / "2" }.should.raise(TypeError) + -> { @bignum / :symbol }.should.raise(TypeError) end end + + it "coerces the RHS and calls #coerce" do + obj = mock("integer plus") + obj.should_receive(:coerce).with(6).and_return([6, 3]) + (6 / obj).should == 2 + end + + it "coerces the RHS and calls #coerce even if it's private" do + obj = Object.new + class << obj + private def coerce(n) + [n, 3] + end + end + + (6 / obj).should == 2 + end end diff --git a/spec/ruby/core/integer/divmod_spec.rb b/spec/ruby/core/integer/divmod_spec.rb index 7a489e9344..db470c5731 100644 --- a/spec/ruby/core/integer/divmod_spec.rb +++ b/spec/ruby/core/integer/divmod_spec.rb @@ -14,24 +14,24 @@ describe "Integer#divmod" do end it "raises a ZeroDivisionError when the given argument is 0" do - -> { 13.divmod(0) }.should raise_error(ZeroDivisionError) - -> { 0.divmod(0) }.should raise_error(ZeroDivisionError) - -> { -10.divmod(0) }.should raise_error(ZeroDivisionError) + -> { 13.divmod(0) }.should.raise(ZeroDivisionError) + -> { 0.divmod(0) }.should.raise(ZeroDivisionError) + -> { -10.divmod(0) }.should.raise(ZeroDivisionError) end it "raises a ZeroDivisionError when the given argument is 0 and a Float" do - -> { 0.divmod(0.0) }.should raise_error(ZeroDivisionError) - -> { 10.divmod(0.0) }.should raise_error(ZeroDivisionError) - -> { -10.divmod(0.0) }.should raise_error(ZeroDivisionError) + -> { 0.divmod(0.0) }.should.raise(ZeroDivisionError) + -> { 10.divmod(0.0) }.should.raise(ZeroDivisionError) + -> { -10.divmod(0.0) }.should.raise(ZeroDivisionError) end it "raises a TypeError when given a non-Integer" do -> { (obj = mock('10')).should_receive(:to_int).any_number_of_times.and_return(10) 13.divmod(obj) - }.should raise_error(TypeError) - -> { 13.divmod("10") }.should raise_error(TypeError) - -> { 13.divmod(:symbol) }.should raise_error(TypeError) + }.should.raise(TypeError) + -> { 13.divmod("10") }.should.raise(TypeError) + -> { 13.divmod(:symbol) }.should.raise(TypeError) end end @@ -94,24 +94,24 @@ describe "Integer#divmod" do end it "raises a ZeroDivisionError when the given argument is 0" do - -> { @bignum.divmod(0) }.should raise_error(ZeroDivisionError) - -> { (-@bignum).divmod(0) }.should raise_error(ZeroDivisionError) + -> { @bignum.divmod(0) }.should.raise(ZeroDivisionError) + -> { (-@bignum).divmod(0) }.should.raise(ZeroDivisionError) end # Behaviour established as correct in r23953 it "raises a FloatDomainError if other is NaN" do - -> { @bignum.divmod(nan_value) }.should raise_error(FloatDomainError) + -> { @bignum.divmod(nan_value) }.should.raise(FloatDomainError) end it "raises a ZeroDivisionError when the given argument is 0 and a Float" do - -> { @bignum.divmod(0.0) }.should raise_error(ZeroDivisionError) - -> { (-@bignum).divmod(0.0) }.should raise_error(ZeroDivisionError) + -> { @bignum.divmod(0.0) }.should.raise(ZeroDivisionError) + -> { (-@bignum).divmod(0.0) }.should.raise(ZeroDivisionError) end it "raises a TypeError when the given argument is not an Integer" do - -> { @bignum.divmod(mock('10')) }.should raise_error(TypeError) - -> { @bignum.divmod("10") }.should raise_error(TypeError) - -> { @bignum.divmod(:symbol) }.should raise_error(TypeError) + -> { @bignum.divmod(mock('10')) }.should.raise(TypeError) + -> { @bignum.divmod("10") }.should.raise(TypeError) + -> { @bignum.divmod(:symbol) }.should.raise(TypeError) end end end diff --git a/spec/ruby/core/integer/downto_spec.rb b/spec/ruby/core/integer/downto_spec.rb index 987704b02e..a244d3df55 100644 --- a/spec/ruby/core/integer/downto_spec.rb +++ b/spec/ruby/core/integer/downto_spec.rb @@ -27,8 +27,8 @@ describe "Integer#downto [stop] when self and stop are Integers" do end it "raises an ArgumentError for invalid endpoints" do - -> {1.downto("A") {|x| p x } }.should raise_error(ArgumentError) - -> {1.downto(nil) {|x| p x } }.should raise_error(ArgumentError) + -> {1.downto("A") {|x| p x } }.should.raise(ArgumentError) + -> {1.downto(nil) {|x| p x } }.should.raise(ArgumentError) end describe "when no block is given" do @@ -45,9 +45,9 @@ describe "Integer#downto [stop] when self and stop are Integers" do describe "size" do it "raises an ArgumentError for invalid endpoints" do enum = 1.downto("A") - -> { enum.size }.should raise_error(ArgumentError) + -> { enum.size }.should.raise(ArgumentError) enum = 1.downto(nil) - -> { enum.size }.should raise_error(ArgumentError) + -> { enum.size }.should.raise(ArgumentError) end it "returns self - stop + 1" do diff --git a/spec/ruby/core/integer/dup_spec.rb b/spec/ruby/core/integer/dup_spec.rb index 7f4d512465..3e5739ad37 100644 --- a/spec/ruby/core/integer/dup_spec.rb +++ b/spec/ruby/core/integer/dup_spec.rb @@ -3,11 +3,11 @@ require_relative '../../spec_helper' describe "Integer#dup" do it "returns self for small integers" do integer = 1_000 - integer.dup.should equal(integer) + integer.dup.should.equal?(integer) end it "returns self for large integers" do integer = 4_611_686_018_427_387_905 - integer.dup.should equal(integer) + integer.dup.should.equal?(integer) end end diff --git a/spec/ruby/core/integer/element_reference_spec.rb b/spec/ruby/core/integer/element_reference_spec.rb index cb7e0dc9b0..c69ec2315d 100644 --- a/spec/ruby/core/integer/element_reference_spec.rb +++ b/spec/ruby/core/integer/element_reference_spec.rb @@ -59,13 +59,13 @@ describe "Integer#[]" do end it "raises a TypeError when passed a String" do - -> { 3["3"] }.should raise_error(TypeError) + -> { 3["3"] }.should.raise(TypeError) end it "raises a TypeError when #to_int does not return an Integer" do obj = mock('asdf') obj.should_receive(:to_int).and_return("asdf") - -> { 3[obj] }.should raise_error(TypeError) + -> { 3[obj] }.should.raise(TypeError) end it "calls #to_int to coerce a String to a Bignum and returns 0" do @@ -137,8 +137,8 @@ describe "Integer#[]" do end it "raises FloatDomainError if any boundary is infinity" do - -> { 0x0001[3..Float::INFINITY] }.should raise_error(FloatDomainError, /Infinity/) - -> { 0x0001[-Float::INFINITY..3] }.should raise_error(FloatDomainError, /-Infinity/) + -> { 0x0001[3..Float::INFINITY] }.should.raise(FloatDomainError, /Infinity/) + -> { 0x0001[-Float::INFINITY..3] }.should.raise(FloatDomainError, /-Infinity/) end context "when passed (..i)" do @@ -151,7 +151,7 @@ describe "Integer#[]" do it "raises ArgumentError if any of i bit equals 1" do -> { eval("0b111110[..3]") - }.should raise_error(ArgumentError, /The beginless range for Integer#\[\] results in infinity/) + }.should.raise(ArgumentError, /The beginless range for Integer#\[\] results in infinity/) end end end @@ -179,10 +179,10 @@ describe "Integer#[]" do it "raises a TypeError when the given argument can't be converted to Integer" do obj = mock('asdf') - -> { @bignum[obj] }.should raise_error(TypeError) + -> { @bignum[obj] }.should.raise(TypeError) obj.should_receive(:to_int).and_return("asdf") - -> { @bignum[obj] }.should raise_error(TypeError) + -> { @bignum[obj] }.should.raise(TypeError) end end end diff --git a/spec/ruby/core/integer/eql_spec.rb b/spec/ruby/core/integer/eql_spec.rb new file mode 100644 index 0000000000..9c80173206 --- /dev/null +++ b/spec/ruby/core/integer/eql_spec.rb @@ -0,0 +1,25 @@ +require_relative '../../spec_helper' + +describe "Integer#eql?" do + context "bignum" do + it "returns true for the same value" do + bignum_value.eql?(bignum_value).should == true + end + + it "returns false for a different Integer value" do + bignum_value.eql?(bignum_value(1)).should == false + end + + it "returns false for a Float with the same numeric value" do + bignum_value.eql?(bignum_value.to_f).should == false + end + + it "returns false for a Rational with the same numeric value" do + bignum_value.eql?(Rational(bignum_value)).should == false + end + + it "returns false for a Fixnum-range Integer" do + bignum_value.eql?(42).should == false + end + end +end diff --git a/spec/ruby/core/integer/even_spec.rb b/spec/ruby/core/integer/even_spec.rb index a314cc6b19..578979320e 100644 --- a/spec/ruby/core/integer/even_spec.rb +++ b/spec/ruby/core/integer/even_spec.rb @@ -3,38 +3,38 @@ require_relative '../../spec_helper' describe "Integer#even?" do context "fixnum" do it "returns true for a Fixnum when it is an even number" do - (-2).even?.should be_true - (-1).even?.should be_false + (-2).even?.should == true + (-1).even?.should == false - 0.even?.should be_true - 1.even?.should be_false - 2.even?.should be_true + 0.even?.should == true + 1.even?.should == false + 2.even?.should == true end it "returns true for a Bignum when it is an even number" do - bignum_value(0).even?.should be_true - bignum_value(1).even?.should be_false + bignum_value(0).even?.should == true + bignum_value(1).even?.should == false - (-bignum_value(0)).even?.should be_true - (-bignum_value(1)).even?.should be_false + (-bignum_value(0)).even?.should == true + (-bignum_value(1)).even?.should == false end end context "bignum" do it "returns true if self is even and positive" do - (10000**10).even?.should be_true + (10000**10).even?.should == true end it "returns true if self is even and negative" do - (-10000**10).even?.should be_true + (-10000**10).even?.should == true end it "returns false if self is odd and positive" do - (9879**976).even?.should be_false + (9879**976).even?.should == false end it "returns false if self is odd and negative" do - (-9879**976).even?.should be_false + (-9879**976).even?.should == false end end end diff --git a/spec/ruby/core/integer/fdiv_spec.rb b/spec/ruby/core/integer/fdiv_spec.rb index d9ea2fdf8d..7854d66dec 100644 --- a/spec/ruby/core/integer/fdiv_spec.rb +++ b/spec/ruby/core/integer/fdiv_spec.rb @@ -65,8 +65,8 @@ describe "Integer#fdiv" do end it "returns NaN when the argument is NaN" do - -1.fdiv(nan_value).nan?.should be_true - 1.fdiv(nan_value).nan?.should be_true + -1.fdiv(nan_value).nan?.should == true + 1.fdiv(nan_value).nan?.should == true end it "returns Infinity when the argument is 0" do @@ -86,11 +86,11 @@ describe "Integer#fdiv" do end it "raises a TypeError when argument isn't numeric" do - -> { 1.fdiv(mock('non-numeric')) }.should raise_error(TypeError) + -> { 1.fdiv(mock('non-numeric')) }.should.raise(TypeError) end it "raises an ArgumentError when passed multiple arguments" do - -> { 1.fdiv(6,0.2) }.should raise_error(ArgumentError) + -> { 1.fdiv(6,0.2) }.should.raise(ArgumentError) end it "follows the coercion protocol" do diff --git a/spec/ruby/core/integer/fixtures/classes.rb b/spec/ruby/core/integer/fixtures/classes.rb index 6ebfbd1565..65948efb9f 100644 --- a/spec/ruby/core/integer/fixtures/classes.rb +++ b/spec/ruby/core/integer/fixtures/classes.rb @@ -1,4 +1,14 @@ module IntegerSpecs class CoerceError < StandardError end + + class CoercibleNumeric + def initialize(v) @v = v end + def coerce(other) [self.class.new(other), self] end + def >(other) @v.to_i > other.to_i end + def >=(other) @v.to_i >= other.to_i end + def <(other) @v.to_i < other.to_i end + def <=(other) @v.to_i <= other.to_i end + def to_i() @v.to_i end + end end diff --git a/spec/ruby/core/integer/floor_spec.rb b/spec/ruby/core/integer/floor_spec.rb index aaa816fdc5..8fb84d58cb 100644 --- a/spec/ruby/core/integer/floor_spec.rb +++ b/spec/ruby/core/integer/floor_spec.rb @@ -1,19 +1,13 @@ require_relative '../../spec_helper' require_relative 'shared/to_i' require_relative 'shared/integer_rounding' +require_relative 'shared/integer_floor_precision' describe "Integer#floor" do it_behaves_like :integer_to_i, :floor it_behaves_like :integer_rounding_positive_precision, :floor - context "precision argument specified as part of the floor method is negative" do - it "returns the largest integer less than self with at least precision.abs trailing zeros" do - 1832.floor(-1).should eql(1830) - 1832.floor(-2).should eql(1800) - 1832.floor(-3).should eql(1000) - -1832.floor(-1).should eql(-1840) - -1832.floor(-2).should eql(-1900) - -1832.floor(-3).should eql(-2000) - end + context "with precision" do + it_behaves_like :integer_floor_precision, :Integer end end diff --git a/spec/ruby/core/integer/gcd_spec.rb b/spec/ruby/core/integer/gcd_spec.rb index 961f1c5c2e..1fff785927 100644 --- a/spec/ruby/core/integer/gcd_spec.rb +++ b/spec/ruby/core/integer/gcd_spec.rb @@ -7,8 +7,8 @@ describe "Integer#gcd" do end it "returns an Integer" do - 36.gcd(6).should be_kind_of(Integer) - 4.gcd(20981).should be_kind_of(Integer) + 36.gcd(6).should.is_a?(Integer) + 4.gcd(20981).should.is_a?(Integer) end it "returns the greatest common divisor of self and argument" do @@ -33,13 +33,13 @@ describe "Integer#gcd" do it "accepts a Bignum argument" do bignum = 9999**99 - bignum.should be_kind_of(Integer) + bignum.should.is_a?(Integer) 99.gcd(bignum).should == 99 end it "works if self is a Bignum" do bignum = 9999**99 - bignum.should be_kind_of(Integer) + bignum.should.is_a?(Integer) bignum.gcd(99).should == 99 end @@ -55,15 +55,15 @@ describe "Integer#gcd" do end it "raises an ArgumentError if not given an argument" do - -> { 12.gcd }.should raise_error(ArgumentError) + -> { 12.gcd }.should.raise(ArgumentError) end it "raises an ArgumentError if given more than one argument" do - -> { 12.gcd(30, 20) }.should raise_error(ArgumentError) + -> { 12.gcd(30, 20) }.should.raise(ArgumentError) end it "raises a TypeError unless the argument is an Integer" do - -> { 39.gcd(3.8) }.should raise_error(TypeError) - -> { 45872.gcd([]) }.should raise_error(TypeError) + -> { 39.gcd(3.8) }.should.raise(TypeError) + -> { 45872.gcd([]) }.should.raise(TypeError) end end diff --git a/spec/ruby/core/integer/gcdlcm_spec.rb b/spec/ruby/core/integer/gcdlcm_spec.rb index ebf45e55a1..419bf9f275 100644 --- a/spec/ruby/core/integer/gcdlcm_spec.rb +++ b/spec/ruby/core/integer/gcdlcm_spec.rb @@ -7,8 +7,8 @@ describe "Integer#gcdlcm" do end it "returns an Array" do - 36.gcdlcm(6).should be_kind_of(Array) - 4.gcdlcm(20981).should be_kind_of(Array) + 36.gcdlcm(6).should.is_a?(Array) + 4.gcdlcm(20981).should.is_a?(Array) end it "returns a two-element Array" do @@ -28,26 +28,26 @@ describe "Integer#gcdlcm" do it "accepts a Bignum argument" do bignum = 91999**99 - bignum.should be_kind_of(Integer) + bignum.should.is_a?(Integer) 99.gcdlcm(bignum).should == [99.gcd(bignum), 99.lcm(bignum)] end it "works if self is a Bignum" do bignum = 9999**89 - bignum.should be_kind_of(Integer) + bignum.should.is_a?(Integer) bignum.gcdlcm(99).should == [bignum.gcd(99), bignum.lcm(99)] end it "raises an ArgumentError if not given an argument" do - -> { 12.gcdlcm }.should raise_error(ArgumentError) + -> { 12.gcdlcm }.should.raise(ArgumentError) end it "raises an ArgumentError if given more than one argument" do - -> { 12.gcdlcm(30, 20) }.should raise_error(ArgumentError) + -> { 12.gcdlcm(30, 20) }.should.raise(ArgumentError) end it "raises a TypeError unless the argument is an Integer" do - -> { 39.gcdlcm(3.8) }.should raise_error(TypeError) - -> { 45872.gcdlcm([]) }.should raise_error(TypeError) + -> { 39.gcdlcm(3.8) }.should.raise(TypeError) + -> { 45872.gcdlcm([]) }.should.raise(TypeError) end end diff --git a/spec/ruby/core/integer/gt_spec.rb b/spec/ruby/core/integer/gt_spec.rb index f0179e566d..75436144cf 100644 --- a/spec/ruby/core/integer/gt_spec.rb +++ b/spec/ruby/core/integer/gt_spec.rb @@ -17,8 +17,8 @@ describe "Integer#>" do end it "raises an ArgumentError when given a non-Integer" do - -> { 5 > "4" }.should raise_error(ArgumentError) - -> { 5 > mock('x') }.should raise_error(ArgumentError) + -> { 5 > "4" }.should.raise(ArgumentError) + -> { 5 > mock('x') }.should.raise(ArgumentError) end end @@ -36,8 +36,13 @@ describe "Integer#>" do end it "raises an ArgumentError when given a non-Integer" do - -> { @bignum > "4" }.should raise_error(ArgumentError) - -> { @bignum > mock('str') }.should raise_error(ArgumentError) + -> { @bignum > "4" }.should.raise(ArgumentError) + -> { @bignum > mock('str') }.should.raise(ArgumentError) + end + + it "dispatches the correct operator after coercion" do + (bignum_value > IntegerSpecs::CoercibleNumeric.new(1)).should == true + (bignum_value > IntegerSpecs::CoercibleNumeric.new(bignum_value * 2)).should == false end end end diff --git a/spec/ruby/core/integer/gte_spec.rb b/spec/ruby/core/integer/gte_spec.rb index 6237fc2c51..e5cb892efd 100644 --- a/spec/ruby/core/integer/gte_spec.rb +++ b/spec/ruby/core/integer/gte_spec.rb @@ -18,8 +18,8 @@ describe "Integer#>=" do end it "raises an ArgumentError when given a non-Integer" do - -> { 5 >= "4" }.should raise_error(ArgumentError) - -> { 5 >= mock('x') }.should raise_error(ArgumentError) + -> { 5 >= "4" }.should.raise(ArgumentError) + -> { 5 >= mock('x') }.should.raise(ArgumentError) end end @@ -36,8 +36,13 @@ describe "Integer#>=" do end it "raises an ArgumentError when given a non-Integer" do - -> { @bignum >= "4" }.should raise_error(ArgumentError) - -> { @bignum >= mock('str') }.should raise_error(ArgumentError) + -> { @bignum >= "4" }.should.raise(ArgumentError) + -> { @bignum >= mock('str') }.should.raise(ArgumentError) + end + + it "dispatches the correct operator after coercion" do + (bignum_value >= IntegerSpecs::CoercibleNumeric.new(1)).should == true + (bignum_value >= IntegerSpecs::CoercibleNumeric.new(bignum_value * 2)).should == false end end end diff --git a/spec/ruby/core/integer/integer_spec.rb b/spec/ruby/core/integer/integer_spec.rb index 2d5d2e3e92..19a962d548 100644 --- a/spec/ruby/core/integer/integer_spec.rb +++ b/spec/ruby/core/integer/integer_spec.rb @@ -6,8 +6,8 @@ describe "Integer" do end it "is the class of both small and large integers" do - 42.class.should equal(Integer) - bignum_value.class.should equal(Integer) + 42.class.should.equal?(Integer) + bignum_value.class.should.equal?(Integer) end end diff --git a/spec/ruby/core/integer/lcm_spec.rb b/spec/ruby/core/integer/lcm_spec.rb index 296a001c8c..6659247d1e 100644 --- a/spec/ruby/core/integer/lcm_spec.rb +++ b/spec/ruby/core/integer/lcm_spec.rb @@ -7,8 +7,8 @@ describe "Integer#lcm" do end it "returns an Integer" do - 36.lcm(6).should be_kind_of(Integer) - 4.lcm(20981).should be_kind_of(Integer) + 36.lcm(6).should.is_a?(Integer) + 4.lcm(20981).should.is_a?(Integer) end it "returns the least common multiple of self and argument" do @@ -33,26 +33,26 @@ describe "Integer#lcm" do it "accepts a Bignum argument" do bignum = 9999**99 - bignum.should be_kind_of(Integer) + bignum.should.is_a?(Integer) 99.lcm(bignum).should == bignum end it "works if self is a Bignum" do bignum = 9999**99 - bignum.should be_kind_of(Integer) + bignum.should.is_a?(Integer) bignum.lcm(99).should == bignum end it "raises an ArgumentError if not given an argument" do - -> { 12.lcm }.should raise_error(ArgumentError) + -> { 12.lcm }.should.raise(ArgumentError) end it "raises an ArgumentError if given more than one argument" do - -> { 12.lcm(30, 20) }.should raise_error(ArgumentError) + -> { 12.lcm(30, 20) }.should.raise(ArgumentError) end it "raises a TypeError unless the argument is an Integer" do - -> { 39.lcm(3.8) }.should raise_error(TypeError) - -> { 45872.lcm([]) }.should raise_error(TypeError) + -> { 39.lcm(3.8) }.should.raise(TypeError) + -> { 45872.lcm([]) }.should.raise(TypeError) end end diff --git a/spec/ruby/core/integer/left_shift_spec.rb b/spec/ruby/core/integer/left_shift_spec.rb index 135af90421..7eedb91228 100644 --- a/spec/ruby/core/integer/left_shift_spec.rb +++ b/spec/ruby/core/integer/left_shift_spec.rb @@ -58,13 +58,13 @@ describe "Integer#<< (with n << m)" do it "returns a Bignum == fixnum_max * 2 when fixnum_max << 1 and n > 0" do result = fixnum_max << 1 - result.should be_an_instance_of(Integer) + result.should.instance_of?(Integer) result.should == fixnum_max * 2 end it "returns a Bignum == fixnum_min * 2 when fixnum_min << 1 and n < 0" do result = fixnum_min << 1 - result.should be_an_instance_of(Integer) + result.should.instance_of?(Integer) result.should == fixnum_min * 2 end @@ -82,15 +82,15 @@ describe "Integer#<< (with n << m)" do obj = mock("a string") obj.should_receive(:to_int).and_return("asdf") - -> { 3 << obj }.should raise_error(TypeError) + -> { 3 << obj }.should.raise(TypeError) end it "raises a TypeError when passed nil" do - -> { 3 << nil }.should raise_error(TypeError) + -> { 3 << nil }.should.raise(TypeError) end it "raises a TypeError when passed a String" do - -> { 3 << "4" }.should raise_error(TypeError) + -> { 3 << "4" }.should.raise(TypeError) end end @@ -129,13 +129,13 @@ describe "Integer#<< (with n << m)" do it "returns a Fixnum == fixnum_max when (fixnum_max * 2) << -1 and n > 0" do result = (fixnum_max * 2) << -1 - result.should be_an_instance_of(Integer) + result.should.instance_of?(Integer) result.should == fixnum_max end it "returns a Fixnum == fixnum_min when (fixnum_min * 2) << -1 and n < 0" do result = (fixnum_min * 2) << -1 - result.should be_an_instance_of(Integer) + result.should.instance_of?(Integer) result.should == fixnum_min end @@ -150,15 +150,15 @@ describe "Integer#<< (with n << m)" do obj = mock("a string") obj.should_receive(:to_int).and_return("asdf") - -> { @bignum << obj }.should raise_error(TypeError) + -> { @bignum << obj }.should.raise(TypeError) end it "raises a TypeError when passed nil" do - -> { @bignum << nil }.should raise_error(TypeError) + -> { @bignum << nil }.should.raise(TypeError) end it "raises a TypeError when passed a String" do - -> { @bignum << "4" }.should raise_error(TypeError) + -> { @bignum << "4" }.should.raise(TypeError) end end @@ -181,31 +181,31 @@ describe "Integer#<< (with n << m)" do (bignum_value << -(2**40)).should == 0 end - ruby_bug "#18517", ""..."3.2" do - it "returns 0 when m > 0 long and n == 0" do - (0 << (2**40)).should == 0 - end + it "returns 0 when m > 0 long and n == 0" do + (0 << (2**40)).should == 0 end it "returns 0 when m > 0 bignum and n == 0" do (0 << bignum_value).should == 0 end - ruby_bug "#18518", ""..."3.3" do - it "raises NoMemoryError when m > 0 and n != 0" do - coerce_long = mock("long") - coerce_long.stub!(:to_int).and_return(2**40) - coerce_bignum = mock("bignum") - coerce_bignum.stub!(:to_int).and_return(bignum_value) - exps = [2**40, bignum_value, coerce_long, coerce_bignum] - - exps.each { |exp| - -> { (1 << exp) }.should raise_error(NoMemoryError) - -> { (-1 << exp) }.should raise_error(NoMemoryError) - -> { (bignum_value << exp) }.should raise_error(NoMemoryError) - -> { (-bignum_value << exp) }.should raise_error(NoMemoryError) - } - end + it "raises RangeError when m > 0 and n != 0" do + # https://bugs.ruby-lang.org/issues/18518#note-9 + limit = RUBY_ENGINE == 'ruby' ? 2**67 : 2**32 + + coerce_long = mock("long") + coerce_long.stub!(:to_int).and_return(limit) + coerce_bignum = mock("bignum") + coerce_bignum.stub!(:to_int).and_return(bignum_value) + exps = [limit, coerce_long] + exps << bignum_value << coerce_bignum if bignum_value >= limit + + exps.each { |exp| + -> { (1 << exp) }.should.raise(RangeError, 'shift width too big') + -> { (-1 << exp) }.should.raise(RangeError, 'shift width too big') + -> { (bignum_value << exp) }.should.raise(RangeError, 'shift width too big') + -> { (-bignum_value << exp) }.should.raise(RangeError, 'shift width too big') + } end end end diff --git a/spec/ruby/core/integer/lt_spec.rb b/spec/ruby/core/integer/lt_spec.rb index c182f82555..dd1391d093 100644 --- a/spec/ruby/core/integer/lt_spec.rb +++ b/spec/ruby/core/integer/lt_spec.rb @@ -17,8 +17,8 @@ describe "Integer#<" do end it "raises an ArgumentError when given a non-Integer" do - -> { 5 < "4" }.should raise_error(ArgumentError) - -> { 5 < mock('x') }.should raise_error(ArgumentError) + -> { 5 < "4" }.should.raise(ArgumentError) + -> { 5 < mock('x') }.should.raise(ArgumentError) end end @@ -38,8 +38,13 @@ describe "Integer#<" do end it "raises an ArgumentError when given a non-Integer" do - -> { @bignum < "4" }.should raise_error(ArgumentError) - -> { @bignum < mock('str') }.should raise_error(ArgumentError) + -> { @bignum < "4" }.should.raise(ArgumentError) + -> { @bignum < mock('str') }.should.raise(ArgumentError) + end + + it "dispatches the correct operator after coercion" do + (bignum_value < IntegerSpecs::CoercibleNumeric.new(bignum_value * 2)).should == true + (bignum_value < IntegerSpecs::CoercibleNumeric.new(1)).should == false end end end diff --git a/spec/ruby/core/integer/lte_spec.rb b/spec/ruby/core/integer/lte_spec.rb index 65b71d77f2..9ef1c9f604 100644 --- a/spec/ruby/core/integer/lte_spec.rb +++ b/spec/ruby/core/integer/lte_spec.rb @@ -18,8 +18,8 @@ describe "Integer#<=" do end it "raises an ArgumentError when given a non-Integer" do - -> { 5 <= "4" }.should raise_error(ArgumentError) - -> { 5 <= mock('x') }.should raise_error(ArgumentError) + -> { 5 <= "4" }.should.raise(ArgumentError) + -> { 5 <= mock('x') }.should.raise(ArgumentError) end end @@ -46,8 +46,13 @@ describe "Integer#<=" do end it "raises an ArgumentError when given a non-Integer" do - -> { @bignum <= "4" }.should raise_error(ArgumentError) - -> { @bignum <= mock('str') }.should raise_error(ArgumentError) + -> { @bignum <= "4" }.should.raise(ArgumentError) + -> { @bignum <= mock('str') }.should.raise(ArgumentError) + end + + it "dispatches the correct operator after coercion" do + (bignum_value <= IntegerSpecs::CoercibleNumeric.new(bignum_value * 2)).should == true + (bignum_value <= IntegerSpecs::CoercibleNumeric.new(1)).should == false end end end diff --git a/spec/ruby/core/integer/minus_spec.rb b/spec/ruby/core/integer/minus_spec.rb index aadf416a05..5fd3a81a72 100644 --- a/spec/ruby/core/integer/minus_spec.rb +++ b/spec/ruby/core/integer/minus_spec.rb @@ -17,9 +17,9 @@ describe "Integer#-" do -> { (obj = mock('10')).should_receive(:to_int).any_number_of_times.and_return(10) 13 - obj - }.should raise_error(TypeError) - -> { 13 - "10" }.should raise_error(TypeError) - -> { 13 - :symbol }.should raise_error(TypeError) + }.should.raise(TypeError) + -> { 13 - "10" }.should.raise(TypeError) + -> { 13 - :symbol }.should.raise(TypeError) end end @@ -35,9 +35,26 @@ describe "Integer#-" do end it "raises a TypeError when given a non-Integer" do - -> { @bignum - mock('10') }.should raise_error(TypeError) - -> { @bignum - "10" }.should raise_error(TypeError) - -> { @bignum - :symbol }.should raise_error(TypeError) + -> { @bignum - mock('10') }.should.raise(TypeError) + -> { @bignum - "10" }.should.raise(TypeError) + -> { @bignum - :symbol }.should.raise(TypeError) end end + + it "coerces the RHS and calls #coerce" do + obj = mock("integer plus") + obj.should_receive(:coerce).with(5).and_return([5, 10]) + (5 - obj).should == -5 + end + + it "coerces the RHS and calls #coerce even if it's private" do + obj = Object.new + class << obj + private def coerce(n) + [n, 10] + end + end + + (5 - obj).should == -5 + end end diff --git a/spec/ruby/core/integer/multiply_spec.rb b/spec/ruby/core/integer/multiply_spec.rb index 5037d27458..7f30eebaa5 100644 --- a/spec/ruby/core/integer/multiply_spec.rb +++ b/spec/ruby/core/integer/multiply_spec.rb @@ -18,9 +18,9 @@ describe "Integer#*" do -> { (obj = mock('10')).should_receive(:to_int).any_number_of_times.and_return(10) 13 * obj - }.should raise_error(TypeError) - -> { 13 * "10" }.should raise_error(TypeError) - -> { 13 * :symbol }.should raise_error(TypeError) + }.should.raise(TypeError) + -> { 13 * "10" }.should.raise(TypeError) + -> { 13 * :symbol }.should.raise(TypeError) end end @@ -37,9 +37,9 @@ describe "Integer#*" do end it "raises a TypeError when given a non-Integer" do - -> { @bignum * mock('10') }.should raise_error(TypeError) - -> { @bignum * "10" }.should raise_error(TypeError) - -> { @bignum * :symbol }.should raise_error(TypeError) + -> { @bignum * mock('10') }.should.raise(TypeError) + -> { @bignum * "10" }.should.raise(TypeError) + -> { @bignum * :symbol }.should.raise(TypeError) end end end diff --git a/spec/ruby/core/integer/nobits_spec.rb b/spec/ruby/core/integer/nobits_spec.rb index 685759ffa3..f1a3aca9d5 100644 --- a/spec/ruby/core/integer/nobits_spec.rb +++ b/spec/ruby/core/integer/nobits_spec.rb @@ -29,8 +29,8 @@ describe "Integer#nobits?" do -> { (obj = mock('10')).should_receive(:coerce).any_number_of_times.and_return([42,10]) 13.nobits?(obj) - }.should raise_error(TypeError) - -> { 13.nobits?("10") }.should raise_error(TypeError) - -> { 13.nobits?(:symbol) }.should raise_error(TypeError) + }.should.raise(TypeError) + -> { 13.nobits?("10") }.should.raise(TypeError) + -> { 13.nobits?(:symbol) }.should.raise(TypeError) end end diff --git a/spec/ruby/core/integer/odd_spec.rb b/spec/ruby/core/integer/odd_spec.rb index dd779fa44b..f9e50ec790 100644 --- a/spec/ruby/core/integer/odd_spec.rb +++ b/spec/ruby/core/integer/odd_spec.rb @@ -3,36 +3,36 @@ require_relative '../../spec_helper' describe "Integer#odd?" do context "fixnum" do it "returns true when self is an odd number" do - (-2).odd?.should be_false - (-1).odd?.should be_true + (-2).odd?.should == false + (-1).odd?.should == true - 0.odd?.should be_false - 1.odd?.should be_true - 2.odd?.should be_false + 0.odd?.should == false + 1.odd?.should == true + 2.odd?.should == false - bignum_value(0).odd?.should be_false - bignum_value(1).odd?.should be_true + bignum_value(0).odd?.should == false + bignum_value(1).odd?.should == true - (-bignum_value(0)).odd?.should be_false - (-bignum_value(1)).odd?.should be_true + (-bignum_value(0)).odd?.should == false + (-bignum_value(1)).odd?.should == true end end context "bignum" do it "returns true if self is odd and positive" do - (987279**19).odd?.should be_true + (987279**19).odd?.should == true end it "returns true if self is odd and negative" do - (-9873389**97).odd?.should be_true + (-9873389**97).odd?.should == true end it "returns false if self is even and positive" do - (10000000**10).odd?.should be_false + (10000000**10).odd?.should == false end it "returns false if self is even and negative" do - (-1000000**100).odd?.should be_false + (-1000000**100).odd?.should == false end end end diff --git a/spec/ruby/core/integer/ord_spec.rb b/spec/ruby/core/integer/ord_spec.rb index bcb57bea98..8b7dfe460d 100644 --- a/spec/ruby/core/integer/ord_spec.rb +++ b/spec/ruby/core/integer/ord_spec.rb @@ -2,16 +2,16 @@ require_relative '../../spec_helper' describe "Integer#ord" do it "returns self" do - 20.ord.should eql(20) - 40.ord.should eql(40) + 20.ord.should.eql?(20) + 40.ord.should.eql?(40) - 0.ord.should eql(0) - (-10).ord.should eql(-10) + 0.ord.should.eql?(0) + (-10).ord.should.eql?(-10) - ?a.ord.should eql(97) - ?Z.ord.should eql(90) + ?a.ord.should.eql?(97) + ?Z.ord.should.eql?(90) - bignum_value.ord.should eql(bignum_value) - (-bignum_value).ord.should eql(-bignum_value) + bignum_value.ord.should.eql?(bignum_value) + (-bignum_value).ord.should.eql?(-bignum_value) end end diff --git a/spec/ruby/core/integer/plus_spec.rb b/spec/ruby/core/integer/plus_spec.rb index d01a76ab58..b684377bd5 100644 --- a/spec/ruby/core/integer/plus_spec.rb +++ b/spec/ruby/core/integer/plus_spec.rb @@ -17,9 +17,9 @@ describe "Integer#+" do -> { (obj = mock('10')).should_receive(:to_int).any_number_of_times.and_return(10) 13 + obj - }.should raise_error(TypeError) - -> { 13 + "10" }.should raise_error(TypeError) - -> { 13 + :symbol }.should raise_error(TypeError) + }.should.raise(TypeError) + -> { 13 + "10" }.should.raise(TypeError) + -> { 13 + :symbol }.should.raise(TypeError) end end @@ -35,9 +35,9 @@ describe "Integer#+" do end it "raises a TypeError when given a non-Integer" do - -> { @bignum + mock('10') }.should raise_error(TypeError) - -> { @bignum + "10" }.should raise_error(TypeError) - -> { @bignum + :symbol}.should raise_error(TypeError) + -> { @bignum + mock('10') }.should.raise(TypeError) + -> { @bignum + "10" }.should.raise(TypeError) + -> { @bignum + :symbol}.should.raise(TypeError) end end @@ -55,4 +55,21 @@ describe "Integer#+" do RUBY ruby_exe(code).should == "-1" end + + it "coerces the RHS and calls #coerce" do + obj = mock("integer plus") + obj.should_receive(:coerce).with(6).and_return([6, 3]) + (6 + obj).should == 9 + end + + it "coerces the RHS and calls #coerce even if it's private" do + obj = Object.new + class << obj + private def coerce(n) + [n, 3] + end + end + + (6 + obj).should == 9 + end end diff --git a/spec/ruby/core/integer/pow_spec.rb b/spec/ruby/core/integer/pow_spec.rb index 4712911095..12a3839c40 100644 --- a/spec/ruby/core/integer/pow_spec.rb +++ b/spec/ruby/core/integer/pow_spec.rb @@ -16,36 +16,36 @@ describe "Integer#pow" do end it "works well with bignums" do - 2.pow(61, 5843009213693951).should eql 3697379018277258 - 2.pow(62, 5843009213693952).should eql 1551748822859776 - 2.pow(63, 5843009213693953).should eql 3103497645717974 - 2.pow(64, 5843009213693954).should eql 363986077738838 + 2.pow(61, 5843009213693951).should.eql? 3697379018277258 + 2.pow(62, 5843009213693952).should.eql? 1551748822859776 + 2.pow(63, 5843009213693953).should.eql? 3103497645717974 + 2.pow(64, 5843009213693954).should.eql? 363986077738838 end it "handles sign like #divmod does" do - 2.pow(5, 12).should == 8 - 2.pow(5, -12).should == -4 - -2.pow(5, 12).should == 4 + 2.pow(5, 12).should == 8 + 2.pow(5, -12).should == -4 + -2.pow(5, 12).should == 4 -2.pow(5, -12).should == -8 end it "ensures all arguments are integers" do - -> { 2.pow(5, 12.0) }.should raise_error(TypeError, /2nd argument not allowed unless all arguments are integers/) - -> { 2.pow(5, Rational(12, 1)) }.should raise_error(TypeError, /2nd argument not allowed unless all arguments are integers/) + -> { 2.pow(5, 12.0) }.should.raise(TypeError, /2nd argument not allowed unless all arguments are integers/) + -> { 2.pow(5, Rational(12, 1)) }.should.raise(TypeError, /2nd argument not allowed unless all arguments are integers/) end it "raises TypeError for non-numeric value" do - -> { 2.pow(5, "12") }.should raise_error(TypeError) - -> { 2.pow(5, []) }.should raise_error(TypeError) - -> { 2.pow(5, nil) }.should raise_error(TypeError) + -> { 2.pow(5, "12") }.should.raise(TypeError) + -> { 2.pow(5, []) }.should.raise(TypeError) + -> { 2.pow(5, nil) }.should.raise(TypeError) end it "raises a ZeroDivisionError when the given argument is 0" do - -> { 2.pow(5, 0) }.should raise_error(ZeroDivisionError) + -> { 2.pow(5, 0) }.should.raise(ZeroDivisionError) end it "raises a RangeError when the first argument is negative and the second argument is present" do - -> { 2.pow(-5, 1) }.should raise_error(RangeError) + -> { 2.pow(-5, 1) }.should.raise(RangeError) end end end diff --git a/spec/ruby/core/integer/pred_spec.rb b/spec/ruby/core/integer/pred_spec.rb index 86750ebfd1..fce536b5a2 100644 --- a/spec/ruby/core/integer/pred_spec.rb +++ b/spec/ruby/core/integer/pred_spec.rb @@ -2,10 +2,10 @@ require_relative '../../spec_helper' describe "Integer#pred" do it "returns the Integer equal to self - 1" do - 0.pred.should eql(-1) - -1.pred.should eql(-2) - bignum_value.pred.should eql(bignum_value(-1)) - fixnum_min.pred.should eql(fixnum_min - 1) - 20.pred.should eql(19) + 0.pred.should.eql?(-1) + -1.pred.should.eql?(-2) + bignum_value.pred.should.eql?(bignum_value(-1)) + fixnum_min.pred.should.eql?(fixnum_min - 1) + 20.pred.should.eql?(19) end end diff --git a/spec/ruby/core/integer/rationalize_spec.rb b/spec/ruby/core/integer/rationalize_spec.rb index 09d741af33..272eca6911 100644 --- a/spec/ruby/core/integer/rationalize_spec.rb +++ b/spec/ruby/core/integer/rationalize_spec.rb @@ -12,7 +12,7 @@ describe "Integer#rationalize" do it "returns a Rational object" do @numbers.each do |number| - number.rationalize.should be_an_instance_of(Rational) + number.rationalize.should.instance_of?(Rational) end end @@ -33,7 +33,7 @@ describe "Integer#rationalize" do end it "raises ArgumentError when passed more than one argument" do - -> { 1.rationalize(0.1, 0.1) }.should raise_error(ArgumentError) - -> { 1.rationalize(0.1, 0.1, 2) }.should raise_error(ArgumentError) + -> { 1.rationalize(0.1, 0.1) }.should.raise(ArgumentError) + -> { 1.rationalize(0.1, 0.1, 2) }.should.raise(ArgumentError) end end diff --git a/spec/ruby/core/integer/remainder_spec.rb b/spec/ruby/core/integer/remainder_spec.rb index 96268b3af5..deb81fb2a5 100644 --- a/spec/ruby/core/integer/remainder_spec.rb +++ b/spec/ruby/core/integer/remainder_spec.rb @@ -15,17 +15,17 @@ describe "Integer#remainder" do end it "keeps sign of self" do - 5.remainder( 3).should == 2 - 5.remainder(-3).should == 2 + 5.remainder( 3).should == 2 + 5.remainder(-3).should == 2 -5.remainder( 3).should == -2 -5.remainder(-3).should == -2 end it "raises TypeError if passed non-numeric argument" do - -> { 5.remainder("3") }.should raise_error(TypeError) - -> { 5.remainder(:"3") }.should raise_error(TypeError) - -> { 5.remainder([]) }.should raise_error(TypeError) - -> { 5.remainder(nil) }.should raise_error(TypeError) + -> { 5.remainder("3") }.should.raise(TypeError) + -> { 5.remainder(:"3") }.should.raise(TypeError) + -> { 5.remainder([]) }.should.raise(TypeError) + -> { 5.remainder(nil) }.should.raise(TypeError) end end @@ -38,14 +38,14 @@ describe "Integer#remainder" do end it "raises a ZeroDivisionError if other is zero and not a Float" do - -> { bignum_value(66).remainder(0) }.should raise_error(ZeroDivisionError) + -> { bignum_value(66).remainder(0) }.should.raise(ZeroDivisionError) end it "does raises ZeroDivisionError if other is zero and a Float" do a = bignum_value(7) b = bignum_value(32) - -> { a.remainder(0.0) }.should raise_error(ZeroDivisionError) - -> { b.remainder(-0.0) }.should raise_error(ZeroDivisionError) + -> { a.remainder(0.0) }.should.raise(ZeroDivisionError) + -> { b.remainder(-0.0) }.should.raise(ZeroDivisionError) end end end diff --git a/spec/ruby/core/integer/right_shift_spec.rb b/spec/ruby/core/integer/right_shift_spec.rb index 81405667b2..4281d3b7ab 100644 --- a/spec/ruby/core/integer/right_shift_spec.rb +++ b/spec/ruby/core/integer/right_shift_spec.rb @@ -54,13 +54,13 @@ describe "Integer#>> (with n >> m)" do it "returns a Bignum == fixnum_max * 2 when fixnum_max >> -1 and n > 0" do result = fixnum_max >> -1 - result.should be_an_instance_of(Integer) + result.should.instance_of?(Integer) result.should == fixnum_max * 2 end it "returns a Bignum == fixnum_min * 2 when fixnum_min >> -1 and n < 0" do result = fixnum_min >> -1 - result.should be_an_instance_of(Integer) + result.should.instance_of?(Integer) result.should == fixnum_min * 2 end @@ -78,15 +78,15 @@ describe "Integer#>> (with n >> m)" do obj = mock("a string") obj.should_receive(:to_int).and_return("asdf") - -> { 3 >> obj }.should raise_error(TypeError) + -> { 3 >> obj }.should.raise(TypeError) end it "raises a TypeError when passed nil" do - -> { 3 >> nil }.should raise_error(TypeError) + -> { 3 >> nil }.should.raise(TypeError) end it "raises a TypeError when passed a String" do - -> { 3 >> "4" }.should raise_error(TypeError) + -> { 3 >> "4" }.should.raise(TypeError) end end @@ -151,13 +151,13 @@ describe "Integer#>> (with n >> m)" do it "returns a Fixnum == fixnum_max when (fixnum_max * 2) >> 1 and n > 0" do result = (fixnum_max * 2) >> 1 - result.should be_an_instance_of(Integer) + result.should.instance_of?(Integer) result.should == fixnum_max end it "returns a Fixnum == fixnum_min when (fixnum_min * 2) >> 1 and n < 0" do result = (fixnum_min * 2) >> 1 - result.should be_an_instance_of(Integer) + result.should.instance_of?(Integer) result.should == fixnum_min end @@ -172,15 +172,15 @@ describe "Integer#>> (with n >> m)" do obj = mock("a string") obj.should_receive(:to_int).and_return("asdf") - -> { @bignum >> obj }.should raise_error(TypeError) + -> { @bignum >> obj }.should.raise(TypeError) end it "raises a TypeError when passed nil" do - -> { @bignum >> nil }.should raise_error(TypeError) + -> { @bignum >> nil }.should.raise(TypeError) end it "raises a TypeError when passed a String" do - -> { @bignum >> "4" }.should raise_error(TypeError) + -> { @bignum >> "4" }.should.raise(TypeError) end end @@ -203,31 +203,31 @@ describe "Integer#>> (with n >> m)" do (bignum_value >> (2**40)).should == 0 end - ruby_bug "#18517", ""..."3.2" do - it "returns 0 when m < 0 long and n == 0" do - (0 >> -(2**40)).should == 0 - end + it "returns 0 when m < 0 long and n == 0" do + (0 >> -(2**40)).should == 0 end it "returns 0 when m < 0 bignum and n == 0" do (0 >> -bignum_value).should == 0 end - ruby_bug "#18518", ""..."3.3" do - it "raises NoMemoryError when m < 0 and n != 0" do - coerce_long = mock("long") - coerce_long.stub!(:to_int).and_return(-(2**40)) - coerce_bignum = mock("bignum") - coerce_bignum.stub!(:to_int).and_return(-bignum_value) - exps = [-(2**40), -bignum_value, coerce_long, coerce_bignum] - - exps.each { |exp| - -> { (1 >> exp) }.should raise_error(NoMemoryError) - -> { (-1 >> exp) }.should raise_error(NoMemoryError) - -> { (bignum_value >> exp) }.should raise_error(NoMemoryError) - -> { (-bignum_value >> exp) }.should raise_error(NoMemoryError) - } - end + it "raises RangeError when m < 0 and n != 0" do + # https://bugs.ruby-lang.org/issues/18518#note-9 + limit = RUBY_ENGINE == 'ruby' ? 2**67 : 2**32 + + coerce_long = mock("long") + coerce_long.stub!(:to_int).and_return(-limit) + coerce_bignum = mock("bignum") + coerce_bignum.stub!(:to_int).and_return(-bignum_value) + exps = [-limit, coerce_long] + exps << -bignum_value << coerce_bignum if bignum_value >= limit + + exps.each { |exp| + -> { (1 >> exp) }.should.raise(RangeError, 'shift width too big') + -> { (-1 >> exp) }.should.raise(RangeError, 'shift width too big') + -> { (bignum_value >> exp) }.should.raise(RangeError, 'shift width too big') + -> { (-bignum_value >> exp) }.should.raise(RangeError, 'shift width too big') + } end end end diff --git a/spec/ruby/core/integer/round_spec.rb b/spec/ruby/core/integer/round_spec.rb index 45ac126fd3..a3f11e7a76 100644 --- a/spec/ruby/core/integer/round_spec.rb +++ b/spec/ruby/core/integer/round_spec.rb @@ -8,39 +8,37 @@ describe "Integer#round" do # redmine:5228 it "returns itself rounded if passed a negative value" do - +249.round(-2).should eql(+200) - -249.round(-2).should eql(-200) - (+25 * 10**70 - 1).round(-71).should eql(+20 * 10**70) - (-25 * 10**70 + 1).round(-71).should eql(-20 * 10**70) + +249.round(-2).should.eql?(+200) + -249.round(-2).should.eql?(-200) + (+25 * 10**70 - 1).round(-71).should.eql?(+20 * 10**70) + (-25 * 10**70 + 1).round(-71).should.eql?(-20 * 10**70) end it "returns itself rounded to nearest if passed a negative value" do - +250.round(-2).should eql(+300) - -250.round(-2).should eql(-300) - (+25 * 10**70).round(-71).should eql(+30 * 10**70) - (-25 * 10**70).round(-71).should eql(-30 * 10**70) + +250.round(-2).should.eql?(+300) + -250.round(-2).should.eql?(-300) + (+25 * 10**70).round(-71).should.eql?(+30 * 10**70) + (-25 * 10**70).round(-71).should.eql?(-30 * 10**70) end - platform_is_not wordsize: 32 do - it "raises a RangeError when passed a big negative value" do - -> { 42.round(fixnum_min) }.should raise_error(RangeError) - end + it "raises a RangeError when passed a big negative value" do + -> { 42.round(min_long - 1) }.should.raise(RangeError) end it "raises a RangeError when passed Float::INFINITY" do - -> { 42.round(Float::INFINITY) }.should raise_error(RangeError) + -> { 42.round(Float::INFINITY) }.should.raise(RangeError) end it "raises a RangeError when passed a beyond signed int" do - -> { 42.round(1<<31) }.should raise_error(RangeError) + -> { 42.round(1<<31) }.should.raise(RangeError) end it "raises a TypeError when passed a String" do - -> { 42.round("4") }.should raise_error(TypeError) + -> { 42.round("4") }.should.raise(TypeError) end it "raises a TypeError when its argument cannot be converted to an Integer" do - -> { 42.round(nil) }.should raise_error(TypeError) + -> { 42.round(nil) }.should.raise(TypeError) end it "calls #to_int on the argument to convert it to an Integer" do @@ -52,32 +50,32 @@ describe "Integer#round" do it "raises a TypeError when #to_int does not return an Integer" do obj = mock("Object") obj.stub!(:to_int).and_return([]) - -> { 42.round(obj) }.should raise_error(TypeError) + -> { 42.round(obj) }.should.raise(TypeError) end it "returns different rounded values depending on the half option" do - 25.round(-1, half: :up).should eql(30) - 25.round(-1, half: :down).should eql(20) - 25.round(-1, half: :even).should eql(20) - 25.round(-1, half: nil).should eql(30) - 35.round(-1, half: :up).should eql(40) - 35.round(-1, half: :down).should eql(30) - 35.round(-1, half: :even).should eql(40) - 35.round(-1, half: nil).should eql(40) - (-25).round(-1, half: :up).should eql(-30) - (-25).round(-1, half: :down).should eql(-20) - (-25).round(-1, half: :even).should eql(-20) - (-25).round(-1, half: nil).should eql(-30) + 25.round(-1, half: :up).should.eql?(30) + 25.round(-1, half: :down).should.eql?(20) + 25.round(-1, half: :even).should.eql?(20) + 25.round(-1, half: nil).should.eql?(30) + 35.round(-1, half: :up).should.eql?(40) + 35.round(-1, half: :down).should.eql?(30) + 35.round(-1, half: :even).should.eql?(40) + 35.round(-1, half: nil).should.eql?(40) + (-25).round(-1, half: :up).should.eql?(-30) + (-25).round(-1, half: :down).should.eql?(-20) + (-25).round(-1, half: :even).should.eql?(-20) + (-25).round(-1, half: nil).should.eql?(-30) end it "returns itself if passed a positive precision and the half option" do - 35.round(1, half: :up).should eql(35) - 35.round(1, half: :down).should eql(35) - 35.round(1, half: :even).should eql(35) + 35.round(1, half: :up).should.eql?(35) + 35.round(1, half: :down).should.eql?(35) + 35.round(1, half: :even).should.eql?(35) end it "raises ArgumentError for an unknown rounding mode" do - -> { 42.round(-1, half: :foo) }.should raise_error(ArgumentError, /invalid rounding mode: foo/) - -> { 42.round(1, half: :foo) }.should raise_error(ArgumentError, /invalid rounding mode: foo/) + -> { 42.round(-1, half: :foo) }.should.raise(ArgumentError, /invalid rounding mode: foo/) + -> { 42.round(1, half: :foo) }.should.raise(ArgumentError, /invalid rounding mode: foo/) end end diff --git a/spec/ruby/core/integer/shared/arithmetic_coerce.rb b/spec/ruby/core/integer/shared/arithmetic_coerce.rb index 4c0cbcb999..561b18fe52 100644 --- a/spec/ruby/core/integer/shared/arithmetic_coerce.rb +++ b/spec/ruby/core/integer/shared/arithmetic_coerce.rb @@ -1,31 +1,11 @@ require_relative '../fixtures/classes' -describe :integer_arithmetic_coerce_rescue, shared: true do - it "rescues exception (StandardError and subclasses) raised in other#coerce and raises TypeError" do - b = mock("numeric with failed #coerce") - b.should_receive(:coerce).and_raise(IntegerSpecs::CoerceError) - - # e.g. 1 + b - -> { 1.send(@method, b) }.should raise_error(TypeError, /MockObject can't be coerced into Integer/) - end - - it "does not rescue Exception and StandardError siblings raised in other#coerce" do - [Exception, NoMemoryError].each do |exception| - b = mock("numeric with failed #coerce") - b.should_receive(:coerce).and_raise(exception) - - # e.g. 1 + b - -> { 1.send(@method, b) }.should raise_error(exception) - end - end -end - describe :integer_arithmetic_coerce_not_rescue, shared: true do it "does not rescue exception raised in other#coerce" do b = mock("numeric with failed #coerce") b.should_receive(:coerce).and_raise(IntegerSpecs::CoerceError) # e.g. 1 + b - -> { 1.send(@method, b) }.should raise_error(IntegerSpecs::CoerceError) + -> { 1.send(@method, b) }.should.raise(IntegerSpecs::CoerceError) end end diff --git a/spec/ruby/core/integer/shared/comparison_coerce.rb b/spec/ruby/core/integer/shared/comparison_coerce.rb index af52f5e99b..4bb7404183 100644 --- a/spec/ruby/core/integer/shared/comparison_coerce.rb +++ b/spec/ruby/core/integer/shared/comparison_coerce.rb @@ -6,6 +6,6 @@ describe :integer_comparison_coerce_not_rescue, shared: true do b.should_receive(:coerce).and_raise(IntegerSpecs::CoerceError) # e.g. 1 > b - -> { 1.send(@method, b) }.should raise_error(IntegerSpecs::CoerceError) + -> { 1.send(@method, b) }.should.raise(IntegerSpecs::CoerceError) end end diff --git a/spec/ruby/core/integer/shared/equal.rb b/spec/ruby/core/integer/shared/equal.rb index ecee17831c..c621ba3f81 100644 --- a/spec/ruby/core/integer/shared/equal.rb +++ b/spec/ruby/core/integer/shared/equal.rb @@ -54,5 +54,10 @@ describe :integer_equal, shared: true do @bignum.send(@method, obj).should == true @bignum.send(@method, obj).should == false end + + it "does not lose precision when comparing with a Float" do + (bignum_value(1).send(@method, bignum_value.to_f)).should == false + (bignum_value.send(@method, bignum_value.to_f)).should == true + end end end diff --git a/spec/ruby/core/integer/shared/exponent.rb b/spec/ruby/core/integer/shared/exponent.rb index 15df518b7e..0be13859f9 100644 --- a/spec/ruby/core/integer/shared/exponent.rb +++ b/spec/ruby/core/integer/shared/exponent.rb @@ -1,62 +1,78 @@ describe :integer_exponent, shared: true do context "fixnum" do it "returns self raised to the given power" do - 2.send(@method, 0).should eql 1 - 2.send(@method, 1).should eql 2 - 2.send(@method, 2).should eql 4 + 2.send(@method, 0).should.eql? 1 + 2.send(@method, 1).should.eql? 2 + 2.send(@method, 2).should.eql? 4 - 9.send(@method, 0.5).should eql 3.0 - 9.send(@method, Rational(1, 2)).should eql 3.0 + 9.send(@method, 0.5).should.eql? 3.0 + 9.send(@method, Rational(1, 2)).should.eql? 3.0 5.send(@method, -1).to_f.to_s.should == '0.2' - 2.send(@method, 40).should eql 1099511627776 + 2.send(@method, 40).should.eql? 1099511627776 end it "overflows the answer to a bignum transparently" do - 2.send(@method, 29).should eql 536870912 - 2.send(@method, 30).should eql 1073741824 - 2.send(@method, 31).should eql 2147483648 - 2.send(@method, 32).should eql 4294967296 + 2.send(@method, 29).should.eql? 536870912 + 2.send(@method, 30).should.eql? 1073741824 + 2.send(@method, 31).should.eql? 2147483648 + 2.send(@method, 32).should.eql? 4294967296 - 2.send(@method, 61).should eql 2305843009213693952 - 2.send(@method, 62).should eql 4611686018427387904 - 2.send(@method, 63).should eql 9223372036854775808 - 2.send(@method, 64).should eql 18446744073709551616 - 8.send(@method, 23).should eql 590295810358705651712 + 2.send(@method, 61).should.eql? 2305843009213693952 + 2.send(@method, 62).should.eql? 4611686018427387904 + 2.send(@method, 63).should.eql? 9223372036854775808 + 2.send(@method, 64).should.eql? 18446744073709551616 + 8.send(@method, 23).should.eql? 590295810358705651712 end it "raises negative numbers to the given power" do - (-2).send(@method, 29).should eql(-536870912) - (-2).send(@method, 30).should eql(1073741824) - (-2).send(@method, 31).should eql(-2147483648) - (-2).send(@method, 32).should eql(4294967296) - (-2).send(@method, 33).should eql(-8589934592) + (-2).send(@method, 29).should.eql?(-536870912) + (-2).send(@method, 30).should.eql?(1073741824) + (-2).send(@method, 31).should.eql?(-2147483648) + (-2).send(@method, 32).should.eql?(4294967296) + (-2).send(@method, 33).should.eql?(-8589934592) - (-2).send(@method, 61).should eql(-2305843009213693952) - (-2).send(@method, 62).should eql(4611686018427387904) - (-2).send(@method, 63).should eql(-9223372036854775808) - (-2).send(@method, 64).should eql(18446744073709551616) - (-2).send(@method, 65).should eql(-36893488147419103232) + (-2).send(@method, 61).should.eql?(-2305843009213693952) + (-2).send(@method, 62).should.eql?(4611686018427387904) + (-2).send(@method, 63).should.eql?(-9223372036854775808) + (-2).send(@method, 64).should.eql?(18446744073709551616) + (-2).send(@method, 65).should.eql?(-36893488147419103232) end it "can raise 1 to a bignum safely" do - 1.send(@method, 4611686018427387904).should eql 1 + 1.send(@method, 4611686018427387904).should.eql? 1 end it "can raise -1 to a bignum safely" do - (-1).send(@method, 4611686018427387904).should eql(1) - (-1).send(@method, 4611686018427387905).should eql(-1) + (-1).send(@method, 4611686018427387904).should.eql?(1) + (-1).send(@method, 4611686018427387905).should.eql?(-1) end - it "returns Float::INFINITY when the number is too big" do - -> { - 2.send(@method, 427387904).should == Float::INFINITY - }.should complain(/warning: in a\*\*b, b may be too big/) + ruby_version_is ""..."3.4" do + it "returns Float::INFINITY when the number is too big" do + -> { + 2.send(@method, 427387904).should == Float::INFINITY + }.should complain(/warning: in a\*\*b, b may be too big/) + end + end + + ruby_version_is "3.4" do + it "returns an Integer for results larger than the old 32MB limit" do + # 2 ** 40000000 requires 40000001 bits + # This exceeds the old 32MB limit but is within the new 16GB limit + result = 2.send(@method, 40000000) + result.should.is_a?(Integer) + result.bit_length.should == 40000001 + end + + it "raises an ArgumentError when the result size exceeds the limit" do + -> { 100000000.send(@method, 1000000000) }.should.raise(ArgumentError) + end end it "raises a ZeroDivisionError for 0 ** -1" do - -> { 0.send(@method, -1) }.should raise_error(ZeroDivisionError) - -> { 0.send(@method, Rational(-1, 1)) }.should raise_error(ZeroDivisionError) + -> { 0.send(@method, -1) }.should.raise(ZeroDivisionError) + -> { 0.send(@method, Rational(-1, 1)) }.should.raise(ZeroDivisionError) end it "returns Float::INFINITY for 0 ** -1.0" do @@ -64,9 +80,9 @@ describe :integer_exponent, shared: true do end it "raises a TypeError when given a non-numeric power" do - -> { 13.send(@method, "10") }.should raise_error(TypeError) - -> { 13.send(@method, :symbol) }.should raise_error(TypeError) - -> { 13.send(@method, nil) }.should raise_error(TypeError) + -> { 13.send(@method, "10") }.should.raise(TypeError) + -> { 13.send(@method, :symbol) }.should.raise(TypeError) + -> { 13.send(@method, nil) }.should.raise(TypeError) end it "coerces power and calls #**" do @@ -103,18 +119,38 @@ describe :integer_exponent, shared: true do end it "raises a TypeError when given a non-Integer" do - -> { @bignum.send(@method, mock('10')) }.should raise_error(TypeError) - -> { @bignum.send(@method, "10") }.should raise_error(TypeError) - -> { @bignum.send(@method, :symbol) }.should raise_error(TypeError) - end - - it "switch to a Float when the values is too big" do - flt = nil - -> { - flt = @bignum.send(@method, @bignum) - }.should complain(/warning: in a\*\*b, b may be too big/) - flt.should be_kind_of(Float) - flt.infinite?.should == 1 + -> { @bignum.send(@method, mock('10')) }.should.raise(TypeError) + -> { @bignum.send(@method, "10") }.should.raise(TypeError) + -> { @bignum.send(@method, :symbol) }.should.raise(TypeError) + end + + ruby_version_is ""..."3.4" do + it "switch to a Float when the values is too big" do + flt = nil + -> { + flt = @bignum.send(@method, @bignum) + }.should complain(/warning: in a\*\*b, b may be too big/) + flt.should.is_a?(Float) + flt.infinite?.should == 1 + end + end + + ruby_version_is "3.4" do + it "returns an Integer for large Bignum results exceeding the old limit" do + # (2 ** 70) ** 500000 requires 35000001 bits + # This exceeds the old 32MB limit but is within the new 16GB limit + bignum_base = 2 ** 70 + result = bignum_base.send(@method, 500000) + result.should.is_a?(Integer) + result.bit_length.should == 35000001 + end + + it "raises an ArgumentError when Bignum result exceeds the limit" do + # @bignum ** @bignum would require enormous memory + -> { + @bignum.send(@method, @bignum) + }.should.raise(ArgumentError) + end end it "returns a complex number when negative and raised to a fractional power" do diff --git a/spec/ruby/core/integer/shared/integer_ceil_precision.rb b/spec/ruby/core/integer/shared/integer_ceil_precision.rb new file mode 100644 index 0000000000..b23c17937f --- /dev/null +++ b/spec/ruby/core/integer/shared/integer_ceil_precision.rb @@ -0,0 +1,54 @@ +describe :integer_ceil_precision, shared: true do + context "precision is zero" do + it "returns Integer equal to self" do + send(@method, 0).ceil(0).should.eql?(0) + send(@method, 123).ceil(0).should.eql?(123) + send(@method, -123).ceil(0).should.eql?(-123) + end + end + + context "precision is positive" do + it "returns self" do + send(@method, 0).ceil(1).should.eql?(send(@method, 0)) + send(@method, 0).ceil(10).should.eql?(send(@method, 0)) + + send(@method, 123).ceil(10).should.eql?(send(@method, 123)) + send(@method, -123).ceil(10).should.eql?(send(@method, -123)) + end + end + + context "precision is negative" do + it "always returns 0 when self is 0" do + send(@method, 0).ceil(-1).should.eql?(0) + send(@method, 0).ceil(-10).should.eql?(0) + end + + it "returns Integer equal to self if there are already at least precision.abs trailing zeros" do + send(@method, 10).ceil(-1).should.eql?(10) + send(@method, 100).ceil(-1).should.eql?(100) + send(@method, 100).ceil(-2).should.eql?(100) + send(@method, -10).ceil(-1).should.eql?(-10) + send(@method, -100).ceil(-1).should.eql?(-100) + send(@method, -100).ceil(-2).should.eql?(-100) + end + + it "returns smallest Integer greater than self with at least precision.abs trailing zeros" do + send(@method, 123).ceil(-1).should.eql?(130) + send(@method, 123).ceil(-2).should.eql?(200) + send(@method, 123).ceil(-3).should.eql?(1000) + + send(@method, -123).ceil(-1).should.eql?(-120) + send(@method, -123).ceil(-2).should.eql?(-100) + send(@method, -123).ceil(-3).should.eql?(0) + + send(@method, 100).ceil(-3).should.eql?(1000) + send(@method, -100).ceil(-3).should.eql?(0) + end + + # Bug #20654 + it "returns 10**precision.abs when precision.abs has more digits than self" do + send(@method, 123).ceil(-20).should.eql?(100000000000000000000) + send(@method, 123).ceil(-50).should.eql?(100000000000000000000000000000000000000000000000000) + end + end +end diff --git a/spec/ruby/core/integer/shared/integer_floor_precision.rb b/spec/ruby/core/integer/shared/integer_floor_precision.rb new file mode 100644 index 0000000000..6247907d4c --- /dev/null +++ b/spec/ruby/core/integer/shared/integer_floor_precision.rb @@ -0,0 +1,42 @@ +describe :integer_floor_precision, shared: true do + context "precision is zero" do + it "returns integer self" do + send(@method, 0).floor(0).should.eql?(0) + send(@method, 123).floor(0).should.eql?(123) + send(@method, -123).floor(0).should.eql?(-123) + end + end + + context "precision is positive" do + it "returns self" do + send(@method, 0).floor(1).should.eql?(send(@method, 0)) + send(@method, 0).floor(10).should.eql?(send(@method, 0)) + + send(@method, 123).floor(10).should.eql?(send(@method, 123)) + send(@method, -123).floor(10).should.eql?(send(@method, -123)) + end + end + + context "precision is negative" do + it "always returns 0 when self is 0" do + send(@method, 0).floor(-1).should.eql?(0) + send(@method, 0).floor(-10).should.eql?(0) + end + + it "returns largest integer less than self with at least precision.abs trailing zeros" do + send(@method, 123).floor(-1).should.eql?(120) + send(@method, 123).floor(-2).should.eql?(100) + send(@method, 123).floor(-3).should.eql?(0) + + send(@method, -123).floor(-1).should.eql?(-130) + send(@method, -123).floor(-2).should.eql?(-200) + send(@method, -123).floor(-3).should.eql?(-1000) + end + + # Bug #20654 + it "returns -(10**precision.abs) when self is negative and precision.abs is larger than the number digits of self" do + send(@method, -123).floor(-20).should.eql?(-100000000000000000000) + send(@method, -123).floor(-50).should.eql?(-100000000000000000000000000000000000000000000000000) + end + end +end diff --git a/spec/ruby/core/integer/shared/integer_rounding.rb b/spec/ruby/core/integer/shared/integer_rounding.rb index 56d1819f84..92f2a2327c 100644 --- a/spec/ruby/core/integer/shared/integer_rounding.rb +++ b/spec/ruby/core/integer/shared/integer_rounding.rb @@ -1,19 +1,19 @@ describe :integer_rounding_positive_precision, shared: true do it "returns self if not passed a precision" do [2, -4, 10**70, -10**100].each do |v| - v.send(@method).should eql(v) + v.send(@method).should.eql?(v) end end it "returns self if passed a precision of zero" do [2, -4, 10**70, -10**100].each do |v| - v.send(@method, 0).should eql(v) + v.send(@method, 0).should.eql?(v) end end it "returns itself if passed a positive precision" do [2, -4, 10**70, -10**100].each do |v| - v.send(@method, 42).should eql(v) + v.send(@method, 42).should.eql?(v) end end end diff --git a/spec/ruby/core/integer/shared/modulo.rb b/spec/ruby/core/integer/shared/modulo.rb index f678a10806..d0b5e26ed5 100644 --- a/spec/ruby/core/integer/shared/modulo.rb +++ b/spec/ruby/core/integer/shared/modulo.rb @@ -1,6 +1,12 @@ describe :integer_modulo, shared: true do context "fixnum" do it "returns the modulus obtained from dividing self by the given argument" do + # test all possible combinations: + # - integer/double/bignum argument + # - positive/negative argument + # - positive/negative self + # - self greater/smaller than argument + 13.send(@method, 4).should == 1 4.send(@method, 13).should == 4 @@ -16,59 +22,93 @@ describe :integer_modulo, shared: true do (200).send(@method, -256).should == -56 (1000).send(@method, -512).should == -24 + 13.send(@method, -4.0).should == -3.0 + 4.send(@method, -13.0).should == -9.0 + + -13.send(@method, -4.0).should == -1.0 + -4.send(@method, -13.0).should == -4.0 + + -13.send(@method, 4.0).should == 3.0 + -4.send(@method, 13.0).should == 9.0 + 1.send(@method, 2.0).should == 1.0 200.send(@method, bignum_value).should == 200 + + 4.send(@method, bignum_value(10)).should == 4 + 4.send(@method, -bignum_value(10)).should == -18446744073709551622 + -4.send(@method, bignum_value(10)).should == 18446744073709551622 + -4.send(@method, -bignum_value(10)).should == -4 end it "raises a ZeroDivisionError when the given argument is 0" do - -> { 13.send(@method, 0) }.should raise_error(ZeroDivisionError) - -> { 0.send(@method, 0) }.should raise_error(ZeroDivisionError) - -> { -10.send(@method, 0) }.should raise_error(ZeroDivisionError) + -> { 13.send(@method, 0) }.should.raise(ZeroDivisionError) + -> { 0.send(@method, 0) }.should.raise(ZeroDivisionError) + -> { -10.send(@method, 0) }.should.raise(ZeroDivisionError) end it "raises a ZeroDivisionError when the given argument is 0 and a Float" do - -> { 0.send(@method, 0.0) }.should raise_error(ZeroDivisionError) - -> { 10.send(@method, 0.0) }.should raise_error(ZeroDivisionError) - -> { -10.send(@method, 0.0) }.should raise_error(ZeroDivisionError) + -> { 0.send(@method, 0.0) }.should.raise(ZeroDivisionError) + -> { 10.send(@method, 0.0) }.should.raise(ZeroDivisionError) + -> { -10.send(@method, 0.0) }.should.raise(ZeroDivisionError) end it "raises a TypeError when given a non-Integer" do -> { (obj = mock('10')).should_receive(:to_int).any_number_of_times.and_return(10) 13.send(@method, obj) - }.should raise_error(TypeError) - -> { 13.send(@method, "10") }.should raise_error(TypeError) - -> { 13.send(@method, :symbol) }.should raise_error(TypeError) + }.should.raise(TypeError) + -> { 13.send(@method, "10") }.should.raise(TypeError) + -> { 13.send(@method, :symbol) }.should.raise(TypeError) end end context "bignum" do before :each do - @bignum = bignum_value + @bignum = bignum_value(10) end it "returns the modulus obtained from dividing self by the given argument" do + # test all possible combinations: + # - integer/double/bignum argument + # - positive/negative argument + # - positive/negative self + # - self greater/smaller than argument + @bignum.send(@method, 5).should == 1 @bignum.send(@method, -5).should == -4 - @bignum.send(@method, -100).should == -84 + (-@bignum).send(@method, 5).should == 4 + (-@bignum).send(@method, -5).should == -1 + @bignum.send(@method, 2.22).should be_close(1.5603603603605034, TOLERANCE) - @bignum.send(@method, bignum_value(10)).should == 18446744073709551616 + @bignum.send(@method, -2.22).should be_close(-0.6596396396394968, TOLERANCE) + (-@bignum).send(@method, 2.22).should be_close(0.6596396396394968, TOLERANCE) + (-@bignum).send(@method, -2.22).should be_close(-1.5603603603605034, TOLERANCE) + + @bignum.send(@method, @bignum + 10).should == 18446744073709551626 + @bignum.send(@method, -(@bignum + 10)).should == -10 + (-@bignum).send(@method, @bignum + 10).should == 10 + (-@bignum).send(@method, -(@bignum + 10)).should == -18446744073709551626 + + (@bignum + 10).send(@method, @bignum).should == 10 + (@bignum + 10).send(@method, -@bignum).should == -18446744073709551616 + (-(@bignum + 10)).send(@method, @bignum).should == 18446744073709551616 + (-(@bignum + 10)).send(@method, -@bignum).should == -10 end it "raises a ZeroDivisionError when the given argument is 0" do - -> { @bignum.send(@method, 0) }.should raise_error(ZeroDivisionError) - -> { (-@bignum).send(@method, 0) }.should raise_error(ZeroDivisionError) + -> { @bignum.send(@method, 0) }.should.raise(ZeroDivisionError) + -> { (-@bignum).send(@method, 0) }.should.raise(ZeroDivisionError) end it "raises a ZeroDivisionError when the given argument is 0 and a Float" do - -> { @bignum.send(@method, 0.0) }.should raise_error(ZeroDivisionError) - -> { -@bignum.send(@method, 0.0) }.should raise_error(ZeroDivisionError) + -> { @bignum.send(@method, 0.0) }.should.raise(ZeroDivisionError) + -> { -@bignum.send(@method, 0.0) }.should.raise(ZeroDivisionError) end it "raises a TypeError when given a non-Integer" do - -> { @bignum.send(@method, mock('10')) }.should raise_error(TypeError) - -> { @bignum.send(@method, "10") }.should raise_error(TypeError) - -> { @bignum.send(@method, :symbol) }.should raise_error(TypeError) + -> { @bignum.send(@method, mock('10')) }.should.raise(TypeError) + -> { @bignum.send(@method, "10") }.should.raise(TypeError) + -> { @bignum.send(@method, :symbol) }.should.raise(TypeError) end end end diff --git a/spec/ruby/core/integer/shared/to_i.rb b/spec/ruby/core/integer/shared/to_i.rb index 7b974cd3a7..2b6a50484a 100644 --- a/spec/ruby/core/integer/shared/to_i.rb +++ b/spec/ruby/core/integer/shared/to_i.rb @@ -1,8 +1,8 @@ describe :integer_to_i, shared: true do it "returns self" do - 10.send(@method).should eql(10) - (-15).send(@method).should eql(-15) - bignum_value.send(@method).should eql(bignum_value) - (-bignum_value).send(@method).should eql(-bignum_value) + 10.send(@method).should.eql?(10) + (-15).send(@method).should.eql?(-15) + bignum_value.send(@method).should.eql?(bignum_value) + (-bignum_value).send(@method).should.eql?(-bignum_value) end end diff --git a/spec/ruby/core/integer/size_spec.rb b/spec/ruby/core/integer/size_spec.rb index a134e82384..725e9eb062 100644 --- a/spec/ruby/core/integer/size_spec.rb +++ b/spec/ruby/core/integer/size_spec.rb @@ -1,7 +1,7 @@ require_relative '../../spec_helper' describe "Integer#size" do - platform_is wordsize: 32 do + platform_is c_long_size: 32 do it "returns the number of bytes in the machine representation of self" do -1.size.should == 4 0.size.should == 4 @@ -9,7 +9,7 @@ describe "Integer#size" do end end - platform_is wordsize: 64 do + platform_is c_long_size: 64 do it "returns the number of bytes in the machine representation of self" do -1.size.should == 8 0.size.should == 8 diff --git a/spec/ruby/core/integer/sqrt_spec.rb b/spec/ruby/core/integer/sqrt_spec.rb index 4149ca2cc9..bf90ea747e 100644 --- a/spec/ruby/core/integer/sqrt_spec.rb +++ b/spec/ruby/core/integer/sqrt_spec.rb @@ -2,7 +2,7 @@ require_relative '../../spec_helper' describe "Integer.sqrt" do it "returns an integer" do - Integer.sqrt(10).should be_kind_of(Integer) + Integer.sqrt(10).should.is_a?(Integer) end it "returns the integer square root of the argument" do @@ -14,7 +14,7 @@ describe "Integer.sqrt" do end it "raises a Math::DomainError if the argument is negative" do - -> { Integer.sqrt(-4) }.should raise_error(Math::DomainError) + -> { Integer.sqrt(-4) }.should.raise(Math::DomainError) end it "accepts any argument that can be coerced to Integer" do @@ -26,6 +26,6 @@ describe "Integer.sqrt" do end it "raises a TypeError if the argument cannot be coerced to Integer" do - -> { Integer.sqrt("test") }.should raise_error(TypeError) + -> { Integer.sqrt("test") }.should.raise(TypeError) end end diff --git a/spec/ruby/core/integer/to_f_spec.rb b/spec/ruby/core/integer/to_f_spec.rb index 9f1df9ada9..0681236095 100644 --- a/spec/ruby/core/integer/to_f_spec.rb +++ b/spec/ruby/core/integer/to_f_spec.rb @@ -11,9 +11,9 @@ describe "Integer#to_f" do context "bignum" do it "returns self converted to a Float" do - bignum_value(0x4000_0aa0_0bb0_0000).to_f.should eql(23_058_441_774_644_068_352.0) - bignum_value(0x8000_0000_0000_0ccc).to_f.should eql(27_670_116_110_564_330_700.0) - (-bignum_value(99)).to_f.should eql(-18_446_744_073_709_551_715.0) + bignum_value(0x4000_0aa0_0bb0_0000).to_f.should.eql?(23_058_441_774_644_068_352.0) + bignum_value(0x8000_0000_0000_0ccc).to_f.should.eql?(27_670_116_110_564_330_700.0) + (-bignum_value(99)).to_f.should.eql?(-18_446_744_073_709_551_715.0) end it "converts number close to Float::MAX without exceeding MAX or producing NaN" do diff --git a/spec/ruby/core/integer/to_r_spec.rb b/spec/ruby/core/integer/to_r_spec.rb index 7732bedca1..2649c7c78d 100644 --- a/spec/ruby/core/integer/to_r_spec.rb +++ b/spec/ruby/core/integer/to_r_spec.rb @@ -2,7 +2,7 @@ require_relative '../../spec_helper' describe "Integer#to_r" do it "returns a Rational object" do - 309.to_r.should be_an_instance_of(Rational) + 309.to_r.should.instance_of?(Rational) end it "constructs a rational number with self as the numerator" do @@ -15,12 +15,12 @@ describe "Integer#to_r" do it "works even if self is a Bignum" do bignum = 99999**999 - bignum.should be_an_instance_of(Integer) + bignum.should.instance_of?(Integer) bignum.to_r.should == Rational(bignum, 1) end it "raises an ArgumentError if given any arguments" do - -> { 287.to_r(2) }.should raise_error(ArgumentError) - -> { 9102826.to_r(309, [], 71) }.should raise_error(ArgumentError) + -> { 287.to_r(2) }.should.raise(ArgumentError) + -> { 9102826.to_r(309, [], 71) }.should.raise(ArgumentError) end end diff --git a/spec/ruby/core/integer/to_s_spec.rb b/spec/ruby/core/integer/to_s_spec.rb index ca08dad95c..4970a2a12f 100644 --- a/spec/ruby/core/integer/to_s_spec.rb +++ b/spec/ruby/core/integer/to_s_spec.rb @@ -13,10 +13,10 @@ describe "Integer#to_s" do end it "raises an ArgumentError if the base is less than 2 or higher than 36" do - -> { 123.to_s(-1) }.should raise_error(ArgumentError) - -> { 123.to_s(0) }.should raise_error(ArgumentError) - -> { 123.to_s(1) }.should raise_error(ArgumentError) - -> { 123.to_s(37) }.should raise_error(ArgumentError) + -> { 123.to_s(-1) }.should.raise(ArgumentError) + -> { 123.to_s(0) }.should.raise(ArgumentError) + -> { 123.to_s(1) }.should.raise(ArgumentError) + -> { 123.to_s(37) }.should.raise(ArgumentError) end end @@ -39,12 +39,12 @@ describe "Integer#to_s" do it "returns a String in US-ASCII encoding when Encoding.default_internal is nil" do Encoding.default_internal = nil - 1.to_s.encoding.should equal(Encoding::US_ASCII) + 1.to_s.encoding.should.equal?(Encoding::US_ASCII) end it "returns a String in US-ASCII encoding when Encoding.default_internal is not nil" do Encoding.default_internal = Encoding::IBM437 - 1.to_s.encoding.should equal(Encoding::US_ASCII) + 1.to_s.encoding.should.equal?(Encoding::US_ASCII) end end @@ -59,10 +59,10 @@ describe "Integer#to_s" do end it "raises an ArgumentError if the base is less than 2 or higher than 36" do - -> { 123.to_s(-1) }.should raise_error(ArgumentError) - -> { 123.to_s(0) }.should raise_error(ArgumentError) - -> { 123.to_s(1) }.should raise_error(ArgumentError) - -> { 123.to_s(37) }.should raise_error(ArgumentError) + -> { 123.to_s(-1) }.should.raise(ArgumentError) + -> { 123.to_s(0) }.should.raise(ArgumentError) + -> { 123.to_s(1) }.should.raise(ArgumentError) + -> { 123.to_s(37) }.should.raise(ArgumentError) end end @@ -84,12 +84,12 @@ describe "Integer#to_s" do it "returns a String in US-ASCII encoding when Encoding.default_internal is nil" do Encoding.default_internal = nil - bignum_value.to_s.encoding.should equal(Encoding::US_ASCII) + bignum_value.to_s.encoding.should.equal?(Encoding::US_ASCII) end it "returns a String in US-ASCII encoding when Encoding.default_internal is not nil" do Encoding.default_internal = Encoding::IBM437 - bignum_value.to_s.encoding.should equal(Encoding::US_ASCII) + bignum_value.to_s.encoding.should.equal?(Encoding::US_ASCII) end end end diff --git a/spec/ruby/core/integer/truncate_spec.rb b/spec/ruby/core/integer/truncate_spec.rb index db16e74be4..b95c183cf3 100644 --- a/spec/ruby/core/integer/truncate_spec.rb +++ b/spec/ruby/core/integer/truncate_spec.rb @@ -8,12 +8,12 @@ describe "Integer#truncate" do context "precision argument specified as part of the truncate method is negative" do it "returns an integer with at least precision.abs trailing zeros" do - 1832.truncate(-1).should eql(1830) - 1832.truncate(-2).should eql(1800) - 1832.truncate(-3).should eql(1000) - -1832.truncate(-1).should eql(-1830) - -1832.truncate(-2).should eql(-1800) - -1832.truncate(-3).should eql(-1000) + 1832.truncate(-1).should.eql?(1830) + 1832.truncate(-2).should.eql?(1800) + 1832.truncate(-3).should.eql?(1000) + -1832.truncate(-1).should.eql?(-1830) + -1832.truncate(-2).should.eql?(-1800) + -1832.truncate(-3).should.eql?(-1000) end end end diff --git a/spec/ruby/core/integer/try_convert_spec.rb b/spec/ruby/core/integer/try_convert_spec.rb index 45c66eec79..8c9b4276b9 100644 --- a/spec/ruby/core/integer/try_convert_spec.rb +++ b/spec/ruby/core/integer/try_convert_spec.rb @@ -1,40 +1,48 @@ require_relative '../../spec_helper' require_relative 'fixtures/classes' -ruby_version_is "3.1" do - describe "Integer.try_convert" do - it "returns the argument if it's an Integer" do - x = 42 - Integer.try_convert(x).should equal(x) - end +describe "Integer.try_convert" do + it "returns the argument if it's an Integer" do + x = 42 + Integer.try_convert(x).should.equal?(x) + end - it "returns nil when the argument does not respond to #to_int" do - Integer.try_convert(Object.new).should be_nil - end + it "returns nil when the argument does not respond to #to_int" do + Integer.try_convert(Object.new).should == nil + end - it "sends #to_int to the argument and returns the result if it's nil" do - obj = mock("to_int") - obj.should_receive(:to_int).and_return(nil) - Integer.try_convert(obj).should be_nil - end + it "sends #to_int to the argument and returns the result if it's nil" do + obj = mock("to_int") + obj.should_receive(:to_int).and_return(nil) + Integer.try_convert(obj).should == nil + end - it "sends #to_int to the argument and returns the result if it's an Integer" do - x = 234 - obj = mock("to_int") - obj.should_receive(:to_int).and_return(x) - Integer.try_convert(obj).should equal(x) - end + it "sends #to_int to the argument and returns the result if it's an Integer" do + x = 234 + obj = mock("to_int") + obj.should_receive(:to_int).and_return(x) + Integer.try_convert(obj).should.equal?(x) + end - it "sends #to_int to the argument and raises TypeError if it's not a kind of Integer" do - obj = mock("to_int") - obj.should_receive(:to_int).and_return(Object.new) - -> { Integer.try_convert obj }.should raise_error(TypeError) - end + it "sends #to_int to the argument and raises TypeError if it's not a kind of Integer" do + obj = mock("to_int") + obj.should_receive(:to_int).and_return(Object.new) + -> { + Integer.try_convert obj + }.should raise_consistent_error(TypeError, "can't convert MockObject into Integer (MockObject#to_int gives Object)") + end + + it "responds with a different error message when it raises a TypeError, depending on the type of the non-Integer object :to_int returns" do + obj = mock("to_int") + obj.should_receive(:to_int).and_return("A String") + -> { + Integer.try_convert obj + }.should raise_consistent_error(TypeError, "can't convert MockObject into Integer (MockObject#to_int gives String)") + end - it "does not rescue exceptions raised by #to_int" do - obj = mock("to_int") - obj.should_receive(:to_int).and_raise(RuntimeError) - -> { Integer.try_convert obj }.should raise_error(RuntimeError) - end + it "does not rescue exceptions raised by #to_int" do + obj = mock("to_int") + obj.should_receive(:to_int).and_raise(RuntimeError) + -> { Integer.try_convert obj }.should.raise(RuntimeError) end end diff --git a/spec/ruby/core/integer/upto_spec.rb b/spec/ruby/core/integer/upto_spec.rb index dd6995e94b..ba63dcc9ea 100644 --- a/spec/ruby/core/integer/upto_spec.rb +++ b/spec/ruby/core/integer/upto_spec.rb @@ -27,8 +27,8 @@ describe "Integer#upto [stop] when self and stop are Integers" do end it "raises an ArgumentError for non-numeric endpoints" do - -> { 1.upto("A") {|x| p x} }.should raise_error(ArgumentError) - -> { 1.upto(nil) {|x| p x} }.should raise_error(ArgumentError) + -> { 1.upto("A") {|x| p x} }.should.raise(ArgumentError) + -> { 1.upto(nil) {|x| p x} }.should.raise(ArgumentError) end describe "when no block is given" do @@ -45,9 +45,9 @@ describe "Integer#upto [stop] when self and stop are Integers" do describe "size" do it "raises an ArgumentError for non-numeric endpoints" do enum = 1.upto("A") - -> { enum.size }.should raise_error(ArgumentError) + -> { enum.size }.should.raise(ArgumentError) enum = 1.upto(nil) - -> { enum.size }.should raise_error(ArgumentError) + -> { enum.size }.should.raise(ArgumentError) end it "returns stop - self + 1" do diff --git a/spec/ruby/core/integer/zero_spec.rb b/spec/ruby/core/integer/zero_spec.rb index 2dac50c406..bd362c4181 100644 --- a/spec/ruby/core/integer/zero_spec.rb +++ b/spec/ruby/core/integer/zero_spec.rb @@ -7,15 +7,7 @@ describe "Integer#zero?" do -1.should_not.zero? end - ruby_version_is "3.0" do - it "Integer#zero? overrides Numeric#zero?" do - 42.method(:zero?).owner.should == Integer - end - end - - ruby_version_is ""..."3.0" do - it "Integer#zero? uses Numeric#zero?" do - 42.method(:zero?).owner.should == Numeric - end + it "Integer#zero? overrides Numeric#zero?" do + 42.method(:zero?).owner.should == Integer end end |