diff options
Diffstat (limited to 'spec/ruby/core/integer')
27 files changed, 405 insertions, 225 deletions
diff --git a/spec/ruby/core/integer/bit_and_spec.rb b/spec/ruby/core/integer/bit_and_spec.rb index 15a8026855..e7face39ac 100644 --- a/spec/ruby/core/integer/bit_and_spec.rb +++ b/spec/ruby/core/integer/bit_and_spec.rb @@ -30,7 +30,7 @@ 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 @@ -55,24 +55,24 @@ describe "Integer#&" do @bignum = bignum_value(5) (@bignum & 3).should == 1 (@bignum & 52).should == 4 - (@bignum & bignum_value(9921)).should == 9223372036854775809 + (@bignum & bignum_value(9921)).should == 18446744073709551617 ((2*bignum_value) & 1).should == 0 - ((2*bignum_value) & (2*bignum_value)).should == 18446744073709551616 + ((2*bignum_value) & (2*bignum_value)).should == 36893488147419103232 end it "returns self bitwise AND other when one operand is negative" do ((2*bignum_value) & -1).should == (2*bignum_value) ((4*bignum_value) & -1).should == (4*bignum_value) - (@bignum & -0xffffffffffffff5).should == 9223372036854775809 + (@bignum & -0xffffffffffffff5).should == 18446744073709551617 (@bignum & -@bignum).should == 1 - (@bignum & -0x8000000000000000).should == 9223372036854775808 + (@bignum & -0x8000000000000000).should == 18446744073709551616 end it "returns self bitwise AND other when both operands are negative" do - (-@bignum & -0x4000000000000005).should == -13835058055282163717 - (-@bignum & -@bignum).should == -9223372036854775813 - (-@bignum & -0x4000000000000000).should == -13835058055282163712 + (-@bignum & -0x4000000000000005).should == -23058430092136939525 + (-@bignum & -@bignum).should == -18446744073709551621 + (-@bignum & -0x4000000000000000).should == -23058430092136939520 end it "returns self bitwise AND other when both are negative and a multiple in bitsize of Fixnum::MIN" do diff --git a/spec/ruby/core/integer/bit_or_spec.rb b/spec/ruby/core/integer/bit_or_spec.rb index e486eeec10..fdf8a191e5 100644 --- a/spec/ruby/core/integer/bit_or_spec.rb +++ b/spec/ruby/core/integer/bit_or_spec.rb @@ -7,13 +7,34 @@ describe "Integer#|" do (5 | 4).should == 5 (5 | 6).should == 7 (248 | 4096).should == 4344 - (0xffff | bignum_value + 0xf0f0).should == 0x8000_0000_0000_ffff + (0xffff | bignum_value + 0xf0f0).should == 0x1_0000_0000_0000_ffff + end + + it "returns self bitwise OR other when one operand is negative" do + ((1 << 33) | -1).should == -1 + (-1 | (1 << 33)).should == -1 + + ((-(1<<33)-1) | 5).should == -8589934593 + (5 | (-(1<<33)-1)).should == -8589934593 + end + + it "returns self bitwise OR other when both operands are negative" do + (-5 | -1).should == -1 + (-3 | -4).should == -3 + (-12 | -13).should == -9 + (-13 | -12).should == -9 end it "returns self bitwise OR a bignum" do (-1 | 2**64).should == -1 end + it "coerces the rhs and calls #coerce" do + 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) end @@ -32,20 +53,20 @@ describe "Integer#|" do end it "returns self bitwise OR other" do - (@bignum | 2).should == 9223372036854775819 - (@bignum | 9).should == 9223372036854775819 - (@bignum | bignum_value).should == 9223372036854775819 + (@bignum | 2).should == 18446744073709551627 + (@bignum | 9).should == 18446744073709551627 + (@bignum | bignum_value).should == 18446744073709551627 end it "returns self bitwise OR other when one operand is negative" do - (@bignum | -0x40000000000000000).should == -64563604257983430645 + (@bignum | -0x40000000000000000).should == -55340232221128654837 (@bignum | -@bignum).should == -1 (@bignum | -0x8000000000000000).should == -9223372036854775797 end it "returns self bitwise OR other when both operands are negative" do (-@bignum | -0x4000000000000005).should == -1 - (-@bignum | -@bignum).should == -9223372036854775819 + (-@bignum | -@bignum).should == -18446744073709551627 (-@bignum | -0x4000000000000000).should == -11 end diff --git a/spec/ruby/core/integer/bit_xor_spec.rb b/spec/ruby/core/integer/bit_xor_spec.rb index ac8826a52f..1f46bc52f3 100644 --- a/spec/ruby/core/integer/bit_xor_spec.rb +++ b/spec/ruby/core/integer/bit_xor_spec.rb @@ -5,13 +5,34 @@ describe "Integer#^" do it "returns self bitwise EXCLUSIVE OR other" do (3 ^ 5).should == 6 (-2 ^ -255).should == 255 - (5 ^ bignum_value + 0xffff_ffff).should == 0x8000_0000_ffff_fffa + (5 ^ bignum_value + 0xffff_ffff).should == 0x1_0000_0000_ffff_fffa + end + + it "returns self bitwise XOR other when one operand is negative" do + ((1 << 33) ^ -1).should == -8589934593 + (-1 ^ (1 << 33)).should == -8589934593 + + ((-(1<<33)-1) ^ 5).should == -8589934598 + (5 ^ (-(1<<33)-1)).should == -8589934598 + end + + it "returns self bitwise XOR other when both operands are negative" do + (-5 ^ -1).should == 4 + (-3 ^ -4).should == 1 + (-12 ^ -13).should == 7 + (-13 ^ -12).should == 7 end it "returns self bitwise EXCLUSIVE OR a bignum" do (-1 ^ 2**64).should == -18446744073709551617 end + it "coerces the rhs and calls #coerce" do + 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) end @@ -30,21 +51,21 @@ describe "Integer#^" do end it "returns self bitwise EXCLUSIVE OR other" do - (@bignum ^ 2).should == 9223372036854775824 + (@bignum ^ 2).should == 18446744073709551632 (@bignum ^ @bignum).should == 0 - (@bignum ^ 14).should == 9223372036854775836 + (@bignum ^ 14).should == 18446744073709551644 end it "returns self bitwise EXCLUSIVE OR other when one operand is negative" do - (@bignum ^ -0x40000000000000000).should == -64563604257983430638 + (@bignum ^ -0x40000000000000000).should == -55340232221128654830 (@bignum ^ -@bignum).should == -4 - (@bignum ^ -0x8000000000000000).should == -18446744073709551598 + (@bignum ^ -0x8000000000000000).should == -27670116110564327406 end it "returns self bitwise EXCLUSIVE OR other when both operands are negative" do - (-@bignum ^ -0x40000000000000000).should == 64563604257983430638 + (-@bignum ^ -0x40000000000000000).should == 55340232221128654830 (-@bignum ^ -@bignum).should == 0 - (-@bignum ^ -0x4000000000000000).should == 13835058055282163694 + (-@bignum ^ -0x4000000000000000).should == 23058430092136939502 end it "returns self bitwise EXCLUSIVE OR other when all bits are 1 and other value is negative" do diff --git a/spec/ruby/core/integer/ceildiv_spec.rb b/spec/ruby/core/integer/ceildiv_spec.rb new file mode 100644 index 0000000000..18d07c66d0 --- /dev/null +++ b/spec/ruby/core/integer/ceildiv_spec.rb @@ -0,0 +1,22 @@ +require_relative '../../spec_helper' + +describe "Integer#ceildiv" do + ruby_version_is '3.2' 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 +end diff --git a/spec/ruby/core/integer/chr_spec.rb b/spec/ruby/core/integer/chr_spec.rb index 9f105e4241..8fe20ff812 100644 --- a/spec/ruby/core/integer/chr_spec.rb +++ b/spec/ruby/core/integer/chr_spec.rb @@ -11,7 +11,11 @@ describe "Integer#chr without argument" do it "raises a RangeError is self is less than 0" do -> { -1.chr }.should raise_error(RangeError) - -> { -bignum_value.chr }.should raise_error(RangeError) + -> { (-bignum_value).chr }.should raise_error(RangeError) + end + + it "raises a RangeError if self is too large" do + -> { 2206368128.chr(Encoding::UTF_8) }.should raise_error(RangeError) end describe "when Encoding.default_internal is nil" do @@ -162,7 +166,7 @@ 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) + -> { (-bignum_value).chr(Encoding::EUC_JP) }.should raise_error(RangeError) end it "raises a RangeError if self is too large" do @@ -219,38 +223,35 @@ 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, "US-ASCII"], - [0x0100, "BINARY"], - [0x0100, "EUC-JP"], - [0xA1A0, "EUC-JP"], - [0xA1, "EUC-JP"], - [0x80, "SHIFT_JIS"], - [0xE0, "SHIFT_JIS"], - [0x0100, "ISO-8859-9"], - [620, "TIS-620"], - [0xD800, "UTF-8"], - [0xDBFF, "UTF-8"], - [0xDC00, "UTF-8"], - [0xDFFF, "UTF-8"], - [0xD800, "UTF-16"], - [0xDBFF, "UTF-16"], - [0xDC00, "UTF-16"], - [0xDFFF, "UTF-16"], - ].each do |integer, encoding_name| - -> { integer.chr(encoding_name) }.should raise_error(RangeError) - end + -> { 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) + # 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) + # 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) end - ruby_version_is "2.7" do - it 'returns a String encoding self interpreted as a codepoint in the CESU-8 encoding' do - # see more details here https://en.wikipedia.org/wiki/CESU-8 - # code points from U+0000 to U+FFFF is encoded in the same way as in UTF-8 - 0x0045.chr(Encoding::CESU_8).bytes.should == 0x0045.chr(Encoding::UTF_8).bytes + it 'returns a String encoding self interpreted as a codepoint in the CESU-8 encoding' do + # see more details here https://en.wikipedia.org/wiki/CESU-8 + # code points from U+0000 to U+FFFF is encoded in the same way as in UTF-8 + 0x0045.chr(Encoding::CESU_8).bytes.should == 0x0045.chr(Encoding::UTF_8).bytes - # code points in range from U+10000 to U+10FFFF is CESU-8 data containing a 6-byte surrogate pair, - # which decodes to a 4-byte UTF-8 string - 0x10400.chr(Encoding::CESU_8).bytes.should != 0x10400.chr(Encoding::UTF_8).bytes - 0x10400.chr(Encoding::CESU_8).bytes.to_a.should == [0xED, 0xA0, 0x81, 0xED, 0xB0, 0x80] - end + # code points in range from U+10000 to U+10FFFF is CESU-8 data containing a 6-byte surrogate pair, + # which decodes to a 4-byte UTF-8 string + 0x10400.chr(Encoding::CESU_8).bytes.should != 0x10400.chr(Encoding::UTF_8).bytes + 0x10400.chr(Encoding::CESU_8).bytes.to_a.should == [0xED, 0xA0, 0x81, 0xED, 0xB0, 0x80] end end diff --git a/spec/ruby/core/integer/coerce_spec.rb b/spec/ruby/core/integer/coerce_spec.rb index f1f3256032..1d6dc9713f 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 @@ -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/complement_spec.rb b/spec/ruby/core/integer/complement_spec.rb index eafa5c263f..baf5e6c457 100644 --- a/spec/ruby/core/integer/complement_spec.rb +++ b/spec/ruby/core/integer/complement_spec.rb @@ -12,9 +12,9 @@ describe "Integer#~" do context "bignum" do it "returns self with each bit flipped" do - (~bignum_value(48)).should == -9223372036854775857 - (~(-bignum_value(21))).should == 9223372036854775828 - (~bignum_value(1)).should == -9223372036854775810 + (~bignum_value(48)).should == -18446744073709551665 + (~(-bignum_value(21))).should == 18446744073709551636 + (~bignum_value(1)).should == -18446744073709551618 end end end diff --git a/spec/ruby/core/integer/div_spec.rb b/spec/ruby/core/integer/div_spec.rb index bc1c4363d4..2eb9c0623b 100644 --- a/spec/ruby/core/integer/div_spec.rb +++ b/spec/ruby/core/integer/div_spec.rb @@ -70,8 +70,8 @@ describe "Integer#div" do end it "returns self divided by other" do - @bignum.div(4).should == 2305843009213693974 - @bignum.div(Rational(4, 1)).should == 2305843009213693974 + @bignum.div(4).should == 4611686018427387926 + @bignum.div(Rational(4, 1)).should == 4611686018427387926 @bignum.div(bignum_value(2)).should == 1 (-(10**50)).div(-(10**40 + 1)).should == 9999999999 @@ -124,11 +124,11 @@ describe "Integer#div" do end it "returns a result of integer division of self by a float argument" do - @bignum.div(4294967295.5).should eql(2147483648) + @bignum.div(4294967295.5).should eql(4294967296) not_supported_on :opal do - @bignum.div(4294967295.0).should eql(2147483648) + @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((-bignum_value(88)).to_f).should eql(-1) end end @@ -143,4 +143,12 @@ describe "Integer#div" do -> { @bignum.div(-0) }.should raise_error(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 5ac2dc538d..a878c4668c 100644 --- a/spec/ruby/core/integer/divide_spec.rb +++ b/spec/ruby/core/integer/divide_spec.rb @@ -47,7 +47,7 @@ describe "Integer#/" do end it "returns self divided by other" do - (@bignum / 4).should == 2305843009213693974 + (@bignum / 4).should == 4611686018427387926 (@bignum / bignum_value(2)).should == 1 @@ -60,15 +60,15 @@ describe "Integer#/" do it "returns self divided by Float" do not_supported_on :opal do - (bignum_value(88) / 4294967295.0).should be_close(2147483648.5, TOLERANCE) + (bignum_value(88) / 4294967295.0).should be_close(4294967297.0, TOLERANCE) end - (bignum_value(88) / 4294967295.5).should be_close(2147483648.25, TOLERANCE) + (bignum_value(88) / 4294967295.5).should be_close(4294967296.5, TOLERANCE) end it "returns result the same class as the argument" do - (@bignum / 4).should == 2305843009213693974 - (@bignum / 4.0).should be_close(2305843009213693974, TOLERANCE) - (@bignum / Rational(4, 1)).should == Rational(2305843009213693974, 1) + (@bignum / 4).should == 4611686018427387926 + (@bignum / 4.0).should be_close(4611686018427387926, TOLERANCE) + (@bignum / Rational(4, 1)).should == Rational(4611686018427387926, 1) end it "does NOT raise ZeroDivisionError if other is zero and is a Float" do diff --git a/spec/ruby/core/integer/divmod_spec.rb b/spec/ruby/core/integer/divmod_spec.rb index d88925caad..7a489e9344 100644 --- a/spec/ruby/core/integer/divmod_spec.rb +++ b/spec/ruby/core/integer/divmod_spec.rb @@ -46,16 +46,16 @@ describe "Integer#divmod" do # assert(0 < b ? (0 <= r && r < b) : (b < r && r <= 0)) # So, r is always between 0 and b. it "returns an Array containing quotient and modulus obtained from dividing self by the given argument" do - @bignum.divmod(4).should == [2305843009213693965, 3] - @bignum.divmod(13).should == [709490156681136604, 11] + @bignum.divmod(4).should == [4611686018427387917, 3] + @bignum.divmod(13).should == [1418980313362273205, 6] - @bignum.divmod(4.5).should == [2049638230412172288, 3.5] + @bignum.divmod(4.5).should == [4099276460824344576, 2.5] not_supported_on :opal do - @bignum.divmod(4.0).should == [2305843009213693952, 0.0] - @bignum.divmod(13.0).should == [709490156681136640, 8.0] + @bignum.divmod(4.0).should == [4611686018427387904, 0.0] + @bignum.divmod(13.0).should == [1418980313362273280, 3.0] - @bignum.divmod(2.0).should == [4611686018427387904, 0.0] + @bignum.divmod(2.0).should == [9223372036854775808, 0.0] end @bignum.divmod(bignum_value).should == [1, 55] diff --git a/spec/ruby/core/integer/element_reference_spec.rb b/spec/ruby/core/integer/element_reference_spec.rb index 7197ecdc03..cb7e0dc9b0 100644 --- a/spec/ruby/core/integer/element_reference_spec.rb +++ b/spec/ruby/core/integer/element_reference_spec.rb @@ -79,81 +79,79 @@ describe "Integer#[]" do 3[bignum_value.to_f].should == 0 end - ruby_version_is "2.7" do - context "when index and length passed" do - it "returns specified number of bits from specified position" do - 0b101001101[2, 4].should == 0b0011 - 0b101001101[2, 5].should == 0b10011 - 0b101001101[2, 7].should == 0b1010011 - end + context "when index and length passed" do + it "returns specified number of bits from specified position" do + 0b101001101[2, 4].should == 0b0011 + 0b101001101[2, 5].should == 0b10011 + 0b101001101[2, 7].should == 0b1010011 + end - it "ensures n[i, len] equals to (n >> i) & ((1 << len) - 1)" do - n = 0b101001101; i = 2; len = 4 - n[i, len].should == (n >> i) & ((1 << len) - 1) - end + it "ensures n[i, len] equals to (n >> i) & ((1 << len) - 1)" do + n = 0b101001101; i = 2; len = 4 + n[i, len].should == (n >> i) & ((1 << len) - 1) + end - it "moves start position to the most significant bits when negative index passed" do - 0b000001[-1, 4].should == 0b10 - 0b000001[-2, 4].should == 0b100 - 0b000001[-3, 4].should == 0b1000 - end + it "moves start position to the most significant bits when negative index passed" do + 0b000001[-1, 4].should == 0b10 + 0b000001[-2, 4].should == 0b100 + 0b000001[-3, 4].should == 0b1000 + end - it "ignores negative length" do - 0b101001101[1, -1].should == 0b10100110 - 0b101001101[2, -1].should == 0b1010011 - 0b101001101[3, -1].should == 0b101001 + it "ignores negative length" do + 0b101001101[1, -1].should == 0b10100110 + 0b101001101[2, -1].should == 0b1010011 + 0b101001101[3, -1].should == 0b101001 - 0b101001101[3, -5].should == 0b101001 - 0b101001101[3, -15].should == 0b101001 - 0b101001101[3, -125].should == 0b101001 - end + 0b101001101[3, -5].should == 0b101001 + 0b101001101[3, -15].should == 0b101001 + 0b101001101[3, -125].should == 0b101001 end + end - context "when range passed" do - it "returns bits specified by range" do - 0b101001101[2..5].should == 0b0011 - 0b101001101[2..6].should == 0b10011 - 0b101001101[2..8].should == 0b1010011 - end + context "when range passed" do + it "returns bits specified by range" do + 0b101001101[2..5].should == 0b0011 + 0b101001101[2..6].should == 0b10011 + 0b101001101[2..8].should == 0b1010011 + end - it "ensures n[i..j] equals to (n >> i) & ((1 << (j - i + 1)) - 1)" do - n = 0b101001101; i = 2; j = 5 - n[i..j].should == (n >> i) & ((1 << (j - i + 1)) - 1) - end + it "ensures n[i..j] equals to (n >> i) & ((1 << (j - i + 1)) - 1)" do + n = 0b101001101; i = 2; j = 5 + n[i..j].should == (n >> i) & ((1 << (j - i + 1)) - 1) + end - it "ensures n[i..] equals to (n >> i)" do - eval("0b101001101[3..]").should == 0b101001101 >> 3 - end + it "ensures n[i..] equals to (n >> i)" do + eval("0b101001101[3..]").should == 0b101001101 >> 3 + end - it "moves lower boundary to the most significant bits when negative value passed" do - 0b000001[-1, 4].should == 0b10 - 0b000001[-2, 4].should == 0b100 - 0b000001[-3, 4].should == 0b1000 - end + it "moves lower boundary to the most significant bits when negative value passed" do + 0b000001[-1, 4].should == 0b10 + 0b000001[-2, 4].should == 0b100 + 0b000001[-3, 4].should == 0b1000 + end - it "ignores upper boundary smaller than lower boundary" do - 0b101001101[4..1].should == 0b10100 - 0b101001101[4..2].should == 0b10100 - 0b101001101[-4..-5].should == 0b1010011010000 - end + it "ignores upper boundary smaller than lower boundary" do + 0b101001101[4..1].should == 0b10100 + 0b101001101[4..2].should == 0b10100 + 0b101001101[-4..-5].should == 0b1010011010000 + 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/) + 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/) + context "when passed (..i)" do + it "returns 0 if all i bits equal 0" do + eval("0b10000[..1]").should == 0 + eval("0b10000[..2]").should == 0 + eval("0b10000[..3]").should == 0 end - context "when passed (..i)" do - it "returns 0 if all i bits equal 0" do - eval("0b10000[..1]").should == 0 - eval("0b10000[..2]").should == 0 - eval("0b10000[..3]").should == 0 - end - - 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/) - end + 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/) end end end diff --git a/spec/ruby/core/integer/fdiv_spec.rb b/spec/ruby/core/integer/fdiv_spec.rb index 6de170278f..d9ea2fdf8d 100644 --- a/spec/ruby/core/integer/fdiv_spec.rb +++ b/spec/ruby/core/integer/fdiv_spec.rb @@ -9,6 +9,57 @@ describe "Integer#fdiv" do 8.fdiv(bignum_value).should be_close(8.673617379884035e-19, TOLERANCE) end + it "performs floating-point division between self bignum and a bignum" do + num = 1000000000000000000000000000000000048148248609680896326399448564623182963452541226153892315137780403285956264146010000000000000000000000000000000000048148248609680896326399448564623182963452541226153892315137780403285956264146010000000000000000000000000000000000048148248609680896326399448564623182963452541226153892315137780403285956264146009 + den = 2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 + num.fdiv(den).should == 500.0 + end + + it "rounds to the correct value for bignums" do + den = 9 * 10**342 + + num = 1 * 10**344 + num.fdiv(den).should == 11.11111111111111 + + num = 1 * 10**343 + num.fdiv(den).should == 1.1111111111111112 + + num = 1 * 10**342 + num.fdiv(den).should == 0.1111111111111111 + + num = 2 * 10**342 + num.fdiv(den).should == 0.2222222222222222 + + num = 3 * 10**342 + num.fdiv(den).should == 0.3333333333333333 + + num = 4 * 10**342 + num.fdiv(den).should == 0.4444444444444444 + + num = 5 * 10**342 + num.fdiv(den).should == 0.5555555555555556 + + num = 6 * 10**342 + num.fdiv(den).should == 0.6666666666666666 + + num = 7 * 10**342 + num.fdiv(den).should == 0.7777777777777778 + + num = 8 * 10**342 + num.fdiv(den).should == 0.8888888888888888 + + num = 9 * 10**342 + num.fdiv(den).should == 1.0 + + num = -5 * 10**342 + num.fdiv(den).should == -0.5555555555555556 + end + + it "rounds to the correct float for bignum denominators" do + 1.fdiv(10**324).should == 0.0 + 1.fdiv(10**323).should == 1.0e-323 + end + it "performs floating-point division between self and a Float" do 8.fdiv(9.0).should be_close(0.888888888888889, TOLERANCE) end diff --git a/spec/ruby/core/integer/left_shift_spec.rb b/spec/ruby/core/integer/left_shift_spec.rb index 2b8c26223b..0781371d93 100644 --- a/spec/ruby/core/integer/left_shift_spec.rb +++ b/spec/ruby/core/integer/left_shift_spec.rb @@ -96,7 +96,7 @@ describe "Integer#<< (with n << m)" do context "bignum" do before :each do - @bignum = bignum_value * 16 + @bignum = bignum_value * 8 # 2 ** 67 end it "returns n shifted left m bits when n > 0, m > 0" do @@ -127,10 +127,6 @@ describe "Integer#<< (with n << m)" do (@bignum << -68).should == 0 end - it "returns 0 when m < 0 and m is a Bignum" do - (@bignum << -bignum_value).should == 0 - end - 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) @@ -165,4 +161,53 @@ describe "Integer#<< (with n << m)" do -> { @bignum << "4" }.should raise_error(TypeError) end end + + context "when m is a bignum or larger than int" do + it "returns -1 when m < 0 and n < 0" do + (-1 << -bignum_value).should == -1 + (-1 << -(2**40)).should == -1 + + (-bignum_value << -bignum_value).should == -1 + (-bignum_value << -(2**40)).should == -1 + end + + it "returns 0 when m < 0 and n >= 0" do + (0 << -bignum_value).should == 0 + (1 << -bignum_value).should == 0 + (bignum_value << -bignum_value).should == 0 + + (0 << -(2**40)).should == 0 + (1 << -(2**40)).should == 0 + (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 + end + + it "returns 0 when m > 0 bignum and n == 0" do + (0 << bignum_value).should == 0 + 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_error(RangeError, 'shift width too big') + -> { (-1 << exp) }.should raise_error(RangeError, 'shift width too big') + -> { (bignum_value << exp) }.should raise_error(RangeError, 'shift width too big') + -> { (-bignum_value << exp) }.should raise_error(RangeError, 'shift width too big') + } + end + end end diff --git a/spec/ruby/core/integer/minus_spec.rb b/spec/ruby/core/integer/minus_spec.rb index ce50c8752f..aadf416a05 100644 --- a/spec/ruby/core/integer/minus_spec.rb +++ b/spec/ruby/core/integer/minus_spec.rb @@ -10,7 +10,7 @@ describe "Integer#-" do (9237212 - 5_280).should == 9231932 (781 - 0.5).should == 780.5 - (2_560_496 - bignum_value).should == -9223372036852215312 + (2_560_496 - bignum_value).should == -18446744073706991120 end it "raises a TypeError when given a non-Integer" do @@ -29,8 +29,8 @@ describe "Integer#-" do end it "returns self minus the given Integer" do - (@bignum - 9).should == 9223372036854776113 - (@bignum - 12.57).should be_close(9223372036854776109.43, TOLERANCE) + (@bignum - 9).should == 18446744073709551921 + (@bignum - 12.57).should be_close(18446744073709551917.43, TOLERANCE) (@bignum - bignum_value(42)).should == 272 end diff --git a/spec/ruby/core/integer/multiply_spec.rb b/spec/ruby/core/integer/multiply_spec.rb index d1e9c2640d..5037d27458 100644 --- a/spec/ruby/core/integer/multiply_spec.rb +++ b/spec/ruby/core/integer/multiply_spec.rb @@ -10,7 +10,7 @@ describe "Integer#*" do (1342177 * 800).should == 1073741600 (65536 * 65536).should == 4294967296 - (256 * bignum_value).should == 2361183241434822606848 + (256 * bignum_value).should == 4722366482869645213696 (6712 * 0.25).should == 1678.0 end @@ -32,8 +32,8 @@ describe "Integer#*" do it "returns self multiplied by the given Integer" do (@bignum * (1/bignum_value(0xffff).to_f)).should be_close(1.0, TOLERANCE) (@bignum * (1/bignum_value(0xffff).to_f)).should be_close(1.0, TOLERANCE) - (@bignum * 10).should == 92233720368547765800 - (@bignum * (@bignum - 40)).should == 85070591730234629737795195287525433200 + (@bignum * 10).should == 184467440737095523880 + (@bignum * (@bignum - 40)).should == 340282366920938491207277694290934407024 end it "raises a TypeError when given a non-Integer" do diff --git a/spec/ruby/core/integer/plus_spec.rb b/spec/ruby/core/integer/plus_spec.rb index 511a436872..d01a76ab58 100644 --- a/spec/ruby/core/integer/plus_spec.rb +++ b/spec/ruby/core/integer/plus_spec.rb @@ -9,7 +9,7 @@ describe "Integer#+" do (491 + 2).should == 493 (90210 + 10).should == 90220 - (9 + bignum_value).should == 9223372036854775817 + (9 + bignum_value).should == 18446744073709551625 (1001 + 5.219).should == 1006.219 end @@ -29,9 +29,9 @@ describe "Integer#+" do end it "returns self plus the given Integer" do - (@bignum + 4).should == 9223372036854775888 - (@bignum + 4.2).should be_close(9223372036854775888.2, TOLERANCE) - (@bignum + bignum_value(3)).should == 18446744073709551695 + (@bignum + 4).should == 18446744073709551696 + (@bignum + 4.2).should be_close(18446744073709551696.2, TOLERANCE) + (@bignum + bignum_value(3)).should == 36893488147419103311 end it "raises a TypeError when given a non-Integer" do diff --git a/spec/ruby/core/integer/remainder_spec.rb b/spec/ruby/core/integer/remainder_spec.rb index cd10dad6f2..96268b3af5 100644 --- a/spec/ruby/core/integer/remainder_spec.rb +++ b/spec/ruby/core/integer/remainder_spec.rb @@ -33,7 +33,7 @@ describe "Integer#remainder" do it "returns the remainder of dividing self by other" do a = bignum_value(79) a.remainder(2).should == 1 - a.remainder(97.345).should be_close(46.5674996147722, TOLERANCE) + a.remainder(97.345).should be_close(93.1349992295444, TOLERANCE) a.remainder(bignum_value).should == 79 end diff --git a/spec/ruby/core/integer/right_shift_spec.rb b/spec/ruby/core/integer/right_shift_spec.rb index c8e3f45f21..e91613d8d1 100644 --- a/spec/ruby/core/integer/right_shift_spec.rb +++ b/spec/ruby/core/integer/right_shift_spec.rb @@ -52,10 +52,6 @@ describe "Integer#>> (with n >> m)" do (-7 >> 64).should == -1 end - it "returns 0 when m is a bignum" do - (3 >> bignum_value).should == 0 - end - 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) @@ -96,7 +92,7 @@ describe "Integer#>> (with n >> m)" do context "bignum" do before :each do - @bignum = bignum_value * 16 + @bignum = bignum_value * 8 # 2 ** 67 end it "returns n shifted right m bits when n > 0, m > 0" do @@ -153,10 +149,6 @@ describe "Integer#>> (with n >> m)" do (@bignum >> 68).should == 0 end - it "returns 0 when m is a Bignum" do - (@bignum >> bignum_value).should == 0 - end - 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) @@ -191,4 +183,53 @@ describe "Integer#>> (with n >> m)" do -> { @bignum >> "4" }.should raise_error(TypeError) end end + + context "when m is a bignum or larger than int" do + it "returns -1 when m > 0 and n < 0" do + (-1 >> bignum_value).should == -1 + (-1 >> (2**40)).should == -1 + + (-bignum_value >> bignum_value).should == -1 + (-bignum_value >> (2**40)).should == -1 + end + + it "returns 0 when m > 0 and n >= 0" do + (0 >> bignum_value).should == 0 + (1 >> bignum_value).should == 0 + (bignum_value >> bignum_value).should == 0 + + (0 >> (2**40)).should == 0 + (1 >> (2**40)).should == 0 + (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 + end + + it "returns 0 when m < 0 bignum and n == 0" do + (0 >> -bignum_value).should == 0 + 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_error(RangeError, 'shift width too big') + -> { (-1 >> exp) }.should raise_error(RangeError, 'shift width too big') + -> { (bignum_value >> exp) }.should raise_error(RangeError, 'shift width too big') + -> { (-bignum_value >> exp) }.should raise_error(RangeError, 'shift width too big') + } + end + end end diff --git a/spec/ruby/core/integer/shared/abs.rb b/spec/ruby/core/integer/shared/abs.rb index 946aa21864..43844c9065 100644 --- a/spec/ruby/core/integer/shared/abs.rb +++ b/spec/ruby/core/integer/shared/abs.rb @@ -11,8 +11,8 @@ describe :integer_abs, shared: true do context "bignum" do it "returns the absolute bignum value" do - bignum_value(39).send(@method).should == 9223372036854775847 - (-bignum_value(18)).send(@method).should == 9223372036854775826 + bignum_value(39).send(@method).should == 18446744073709551655 + (-bignum_value(18)).send(@method).should == 18446744073709551634 end end end diff --git a/spec/ruby/core/integer/shared/arithmetic_coerce.rb b/spec/ruby/core/integer/shared/arithmetic_coerce.rb index 4c0cbcb999..1260192df1 100644 --- a/spec/ruby/core/integer/shared/arithmetic_coerce.rb +++ b/spec/ruby/core/integer/shared/arithmetic_coerce.rb @@ -1,25 +1,5 @@ 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") diff --git a/spec/ruby/core/integer/shared/exponent.rb b/spec/ruby/core/integer/shared/exponent.rb index f949c514c8..15df518b7e 100644 --- a/spec/ruby/core/integer/shared/exponent.rb +++ b/spec/ruby/core/integer/shared/exponent.rb @@ -30,11 +30,13 @@ describe :integer_exponent, shared: true do (-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) end it "can raise 1 to a bignum safely" do @@ -96,8 +98,8 @@ describe :integer_exponent, shared: true do end it "returns self raised to other power" do - (@bignum.send(@method, 4)).should == 7237005577332262361485077344629993318496048279512298547155833600056910050625 - (@bignum.send(@method, 1.2)).should be_close(57262152889751597425762.57804, TOLERANCE) + (@bignum.send(@method, 4)).should == 115792089237316196603666111261383895964500887398800252671052694326794607293761 + (@bignum.send(@method, 1.3)).should be_close(11109528802438156839288832.0, TOLERANCE) end it "raises a TypeError when given a non-Integer" do @@ -116,8 +118,9 @@ describe :integer_exponent, shared: true do end it "returns a complex number when negative and raised to a fractional power" do - ((-@bignum).send(@method, (1.0/3))) .should be_close(Complex(1048576,1816186.907597341), TOLERANCE) - ((-@bignum).send(@method, Rational(1,3))).should be_close(Complex(1048576,1816186.907597341), TOLERANCE) + (-bignum_value).send(@method, (1.0/2)).should be_close(Complex(0.0, 4294967296.0), TOLERANCE) + (-@bignum).send(@method, (1.0/3)) .should be_close(Complex(1321122.9748145656, 2288252.1154253655), TOLERANCE) + (-@bignum).send(@method, Rational(1,3)).should be_close(Complex(1321122.9748145656, 2288252.1154253655), TOLERANCE) end end end diff --git a/spec/ruby/core/integer/shared/modulo.rb b/spec/ruby/core/integer/shared/modulo.rb index b06d81e17d..f678a10806 100644 --- a/spec/ruby/core/integer/shared/modulo.rb +++ b/spec/ruby/core/integer/shared/modulo.rb @@ -48,11 +48,11 @@ describe :integer_modulo, shared: true do end it "returns the modulus obtained from dividing self by the given argument" do - @bignum.send(@method, 5).should == 3 - @bignum.send(@method, -5).should == -2 - @bignum.send(@method, -100).should == -92 - @bignum.send(@method, 2.22).should be_close(0.780180180180252, TOLERANCE) - @bignum.send(@method, bignum_value(10)).should == 9223372036854775808 + @bignum.send(@method, 5).should == 1 + @bignum.send(@method, -5).should == -4 + @bignum.send(@method, -100).should == -84 + @bignum.send(@method, 2.22).should be_close(1.5603603603605034, TOLERANCE) + @bignum.send(@method, bignum_value(10)).should == 18446744073709551616 end it "raises a ZeroDivisionError when the given argument is 0" do diff --git a/spec/ruby/core/integer/to_f_spec.rb b/spec/ruby/core/integer/to_f_spec.rb index 06092eaa92..9f1df9ada9 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(13_835_069_737_789_292_544.00) - bignum_value(0x8000_0000_0000_0ccc).to_f.should eql(18_446_744_073_709_555_712.00) - (-bignum_value(99)).to_f.should eql(-9_223_372_036_854_775_808.00) + 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_s_spec.rb b/spec/ruby/core/integer/to_s_spec.rb index 7988bfde7a..ca08dad95c 100644 --- a/spec/ruby/core/integer/to_s_spec.rb +++ b/spec/ruby/core/integer/to_s_spec.rb @@ -68,9 +68,9 @@ describe "Integer#to_s" do describe "when given no base" do it "returns self converted to a String using base 10" do - bignum_value(9).to_s.should == "9223372036854775817" - bignum_value.to_s.should == "9223372036854775808" - (-bignum_value(675)).to_s.should == "-9223372036854776483" + bignum_value(9).to_s.should == "18446744073709551625" + bignum_value.to_s.should == "18446744073709551616" + (-bignum_value(675)).to_s.should == "-18446744073709552291" end end diff --git a/spec/ruby/core/integer/try_convert_spec.rb b/spec/ruby/core/integer/try_convert_spec.rb index 45c66eec79..4bc7d3851a 100644 --- a/spec/ruby/core/integer/try_convert_spec.rb +++ b/spec/ruby/core/integer/try_convert_spec.rb @@ -28,7 +28,17 @@ ruby_version_is "3.1" do 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) + -> { + Integer.try_convert obj + }.should raise_error(TypeError, "can't convert MockObject to 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_error(TypeError, "can't convert MockObject to Integer (MockObject#to_int gives String)") end it "does not rescue exceptions raised by #to_int" do diff --git a/spec/ruby/core/integer/uminus_spec.rb b/spec/ruby/core/integer/uminus_spec.rb index b6b110dec4..7a9cfe89bf 100644 --- a/spec/ruby/core/integer/uminus_spec.rb +++ b/spec/ruby/core/integer/uminus_spec.rb @@ -20,11 +20,11 @@ describe "Integer#-@" do context "bignum" do it "returns self as a negative value" do - bignum_value.send(:-@).should == -9223372036854775808 - (-bignum_value).send(:-@).should == 9223372036854775808 + bignum_value.send(:-@).should == -18446744073709551616 + (-bignum_value).send(:-@).should == 18446744073709551616 - bignum_value(921).send(:-@).should == -9223372036854776729 - (-bignum_value(921).send(:-@)).should == 9223372036854776729 + bignum_value(921).send(:-@).should == -18446744073709552537 + (-bignum_value(921).send(:-@)).should == 18446744073709552537 end end end 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 |