diff options
Diffstat (limited to 'spec/ruby/core/integer/shared')
| -rw-r--r-- | spec/ruby/core/integer/shared/arithmetic_coerce.rb | 11 | ||||
| -rw-r--r-- | spec/ruby/core/integer/shared/comparison_coerce.rb | 11 | ||||
| -rw-r--r-- | spec/ruby/core/integer/shared/exponent.rb | 162 | ||||
| -rw-r--r-- | spec/ruby/core/integer/shared/integer_ceil_precision.rb | 54 | ||||
| -rw-r--r-- | spec/ruby/core/integer/shared/integer_floor_precision.rb | 42 | ||||
| -rw-r--r-- | spec/ruby/core/integer/shared/integer_rounding.rb | 19 | ||||
| -rw-r--r-- | spec/ruby/core/integer/shared/next.rb | 25 | ||||
| -rw-r--r-- | spec/ruby/core/integer/shared/to_i.rb | 8 |
8 files changed, 303 insertions, 29 deletions
diff --git a/spec/ruby/core/integer/shared/arithmetic_coerce.rb b/spec/ruby/core/integer/shared/arithmetic_coerce.rb new file mode 100644 index 0000000000..561b18fe52 --- /dev/null +++ b/spec/ruby/core/integer/shared/arithmetic_coerce.rb @@ -0,0 +1,11 @@ +require_relative '../fixtures/classes' + +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(IntegerSpecs::CoerceError) + end +end diff --git a/spec/ruby/core/integer/shared/comparison_coerce.rb b/spec/ruby/core/integer/shared/comparison_coerce.rb new file mode 100644 index 0000000000..4bb7404183 --- /dev/null +++ b/spec/ruby/core/integer/shared/comparison_coerce.rb @@ -0,0 +1,11 @@ +require_relative '../fixtures/classes' + +describe :integer_comparison_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(IntegerSpecs::CoerceError) + end +end diff --git a/spec/ruby/core/integer/shared/exponent.rb b/spec/ruby/core/integer/shared/exponent.rb new file mode 100644 index 0000000000..0be13859f9 --- /dev/null +++ b/spec/ruby/core/integer/shared/exponent.rb @@ -0,0 +1,162 @@ +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 + + 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 + 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, 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, 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 + end + + it "can raise -1 to a bignum safely" do + (-1).send(@method, 4611686018427387904).should.eql?(1) + (-1).send(@method, 4611686018427387905).should.eql?(-1) + end + + 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(ZeroDivisionError) + -> { 0.send(@method, Rational(-1, 1)) }.should.raise(ZeroDivisionError) + end + + it "returns Float::INFINITY for 0 ** -1.0" do + 0.send(@method, -1.0).should == Float::INFINITY + end + + it "raises a TypeError when given a non-numeric power" do + -> { 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 + num_2 = mock("2") + num_13 = mock("13") + num_2.should_receive(:coerce).with(13).and_return([num_13, num_2]) + num_13.should_receive(:**).with(num_2).and_return(169) + + 13.send(@method, num_2).should == 169 + end + + it "returns Float when power is Float" do + 2.send(@method, 2.0).should == 4.0 + end + + it "returns Rational when power is Rational" do + 2.send(@method, Rational(2, 1)).should == Rational(4, 1) + end + + it "returns a complex number when negative and raised to a fractional power" do + (-8).send(@method, 1.0/3) .should be_close(Complex(1, 1.73205), TOLERANCE) + (-8).send(@method, Rational(1, 3)).should be_close(Complex(1, 1.73205), TOLERANCE) + end + end + + context "bignum" do + before :each do + @bignum = bignum_value(47) + end + + it "returns self raised to other power" do + (@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 + -> { @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 + (-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/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 new file mode 100644 index 0000000000..92f2a2327c --- /dev/null +++ b/spec/ruby/core/integer/shared/integer_rounding.rb @@ -0,0 +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) + 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) + 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) + end + end +end diff --git a/spec/ruby/core/integer/shared/next.rb b/spec/ruby/core/integer/shared/next.rb deleted file mode 100644 index 85b83d6965..0000000000 --- a/spec/ruby/core/integer/shared/next.rb +++ /dev/null @@ -1,25 +0,0 @@ -describe :integer_next, shared: true do - it "returns the next larger positive Fixnum" do - 2.send(@method).should == 3 - end - - it "returns the next larger negative Fixnum" do - (-2).send(@method).should == -1 - end - - it "returns the next larger positive Bignum" do - bignum_value.send(@method).should == bignum_value(1) - end - - it "returns the next larger negative Bignum" do - (-bignum_value(1)).send(@method).should == -bignum_value - end - - it "overflows a Fixnum to a Bignum" do - fixnum_max.send(@method).should == fixnum_max + 1 - end - - it "underflows a Bignum to a Fixnum" do - (fixnum_min - 1).send(@method).should == fixnum_min - 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 |