diff options
Diffstat (limited to 'spec/ruby/core/bignum')
41 files changed, 0 insertions, 1246 deletions
diff --git a/spec/ruby/core/bignum/abs_spec.rb b/spec/ruby/core/bignum/abs_spec.rb deleted file mode 100644 index b551dd95ad..0000000000 --- a/spec/ruby/core/bignum/abs_spec.rb +++ /dev/null @@ -1,7 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) -require File.expand_path('../shared/abs', __FILE__) - -describe "Bignum#abs" do - it_behaves_like(:bignum_abs, :abs) -end - diff --git a/spec/ruby/core/bignum/bignum_spec.rb b/spec/ruby/core/bignum/bignum_spec.rb deleted file mode 100644 index 3df43aec2d..0000000000 --- a/spec/ruby/core/bignum/bignum_spec.rb +++ /dev/null @@ -1,31 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) - -describe "Bignum" do - it "includes Comparable" do - Bignum.include?(Comparable).should == true - end - - it ".allocate raises a TypeError" do - lambda do - Bignum.allocate - end.should raise_error(TypeError) - end - - it ".new is undefined" do - lambda do - Bignum.new - end.should raise_error(NoMethodError) - end - - ruby_version_is '2.4' do - it "unified into Integer" do - Bignum.should equal(Integer) - end - - it "is deprecated" do - -> { - Bignum - }.should complain(/constant ::Bignum is deprecated/) - end - end -end diff --git a/spec/ruby/core/bignum/bit_and_spec.rb b/spec/ruby/core/bignum/bit_and_spec.rb deleted file mode 100644 index 4bc5c11e1b..0000000000 --- a/spec/ruby/core/bignum/bit_and_spec.rb +++ /dev/null @@ -1,50 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) - -describe "Bignum#&" do - before :each do - @bignum = bignum_value(5) - end - - it "returns self bitwise AND other" do - @bignum = bignum_value(5) - (@bignum & 3).should == 1 - (@bignum & 52).should == 4 - (@bignum & bignum_value(9921)).should == 9223372036854775809 - - ((2*bignum_value) & 1).should == 0 - ((2*bignum_value) & (2*bignum_value)).should == 18446744073709551616 - 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 & -@bignum).should == 1 - (@bignum & -0x8000000000000000).should == 9223372036854775808 - 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 - end - - it "returns self bitwise AND other when both are negative and a multiple in bitsize of Fixnum::MIN" do - val = - ((1 << 93) - 1) - (val & val).should == val - - val = - ((1 << 126) - 1) - (val & val).should == val - end - - it "raises a TypeError when passed a Float" do - lambda { (@bignum & 3.4) }.should raise_error(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) - - lambda { @bignum & obj }.should raise_error(TypeError) - end -end diff --git a/spec/ruby/core/bignum/bit_length_spec.rb b/spec/ruby/core/bignum/bit_length_spec.rb deleted file mode 100644 index 1c4c518345..0000000000 --- a/spec/ruby/core/bignum/bit_length_spec.rb +++ /dev/null @@ -1,33 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) - -describe "Bignum#bit_length" do - it "returns the position of the leftmost bit of a positive number" do - (2**1000-1).bit_length.should == 1000 - (2**1000).bit_length.should == 1001 - (2**1000+1).bit_length.should == 1001 - - (2**10000-1).bit_length.should == 10000 - (2**10000).bit_length.should == 10001 - (2**10000+1).bit_length.should == 10001 - - (1 << 100).bit_length.should == 101 - (1 << 100).succ.bit_length.should == 101 - (1 << 100).pred.bit_length.should == 100 - (1 << 10000).bit_length.should == 10001 - end - - it "returns the position of the leftmost 0 bit of a negative number" do - (-2**10000-1).bit_length.should == 10001 - (-2**10000).bit_length.should == 10000 - (-2**10000+1).bit_length.should == 10000 - - (-2**1000-1).bit_length.should == 1001 - (-2**1000).bit_length.should == 1000 - (-2**1000+1).bit_length.should == 1000 - - ((-1 << 100)-1).bit_length.should == 101 - ((-1 << 100)-1).succ.bit_length.should == 100 - ((-1 << 100)-1).pred.bit_length.should == 101 - ((-1 << 10000)-1).bit_length.should == 10001 - end -end diff --git a/spec/ruby/core/bignum/bit_or_spec.rb b/spec/ruby/core/bignum/bit_or_spec.rb deleted file mode 100644 index 6bcb6ead6b..0000000000 --- a/spec/ruby/core/bignum/bit_or_spec.rb +++ /dev/null @@ -1,41 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) - -describe "Bignum#|" do - before :each do - @bignum = bignum_value(11) - end - - it "returns self bitwise OR other" do - (@bignum | 2).should == 9223372036854775819 - (@bignum | 9).should == 9223372036854775819 - (@bignum | bignum_value).should == 9223372036854775819 - end - - it "returns self bitwise OR other when one operand is negative" do - (@bignum | -0x40000000000000000).should == -64563604257983430645 - (@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 | -0x4000000000000000).should == -11 - end - - it "raises a TypeError when passed a Float" do - not_supported_on :opal do - lambda { - bignum_value | bignum_value(0xffff).to_f - }.should raise_error(TypeError) - end - lambda { @bignum | 9.9 }.should raise_error(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) - - lambda { @bignum | obj }.should raise_error(TypeError) - end -end diff --git a/spec/ruby/core/bignum/bit_xor_spec.rb b/spec/ruby/core/bignum/bit_xor_spec.rb deleted file mode 100644 index ef4b4e6ae3..0000000000 --- a/spec/ruby/core/bignum/bit_xor_spec.rb +++ /dev/null @@ -1,47 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) - -describe "Bignum#^" do - before :each do - @bignum = bignum_value(18) - end - - it "returns self bitwise EXCLUSIVE OR other" do - (@bignum ^ 2).should == 9223372036854775824 - (@bignum ^ @bignum).should == 0 - (@bignum ^ 14).should == 9223372036854775836 - end - - it "returns self bitwise EXCLUSIVE OR other when one operand is negative" do - (@bignum ^ -0x40000000000000000).should == -64563604257983430638 - (@bignum ^ -@bignum).should == -4 - (@bignum ^ -0x8000000000000000).should == -18446744073709551598 - end - - it "returns self bitwise EXCLUSIVE OR other when both operands are negative" do - (-@bignum ^ -0x40000000000000000).should == 64563604257983430638 - (-@bignum ^ -@bignum).should == 0 - (-@bignum ^ -0x4000000000000000).should == 13835058055282163694 - end - - it "returns self bitwise EXCLUSIVE OR other when all bits are 1 and other value is negative" do - (9903520314283042199192993791 ^ -1).should == -9903520314283042199192993792 - (784637716923335095479473677900958302012794430558004314111 ^ -1).should == - -784637716923335095479473677900958302012794430558004314112 - end - - it "raises a TypeError when passed a Float" do - not_supported_on :opal do - lambda { - bignum_value ^ bignum_value(0xffff).to_f - }.should raise_error(TypeError) - end - lambda { @bignum ^ 14.5 }.should raise_error(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) - - lambda { @bignum ^ obj }.should raise_error(TypeError) - end -end diff --git a/spec/ruby/core/bignum/case_compare_spec.rb b/spec/ruby/core/bignum/case_compare_spec.rb deleted file mode 100644 index d7e0a89487..0000000000 --- a/spec/ruby/core/bignum/case_compare_spec.rb +++ /dev/null @@ -1,6 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) -require File.expand_path('../shared/equal', __FILE__) - -describe "Bignum#===" do - it_behaves_like :bignum_equal, :=== -end diff --git a/spec/ruby/core/bignum/coerce_spec.rb b/spec/ruby/core/bignum/coerce_spec.rb deleted file mode 100644 index 40decaf51a..0000000000 --- a/spec/ruby/core/bignum/coerce_spec.rb +++ /dev/null @@ -1,65 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) - -describe "Bignum#coerce" do - it "coerces other to a Bignum and returns [other, self] when passed a Fixnum" do - a = bignum_value - ary = a.coerce(2) - - ary[0].should be_kind_of(Bignum) - ary[1].should be_kind_of(Bignum) - ary.should == [2, a] - end - - it "returns [other, self] when passed a Bignum" do - a = bignum_value - b = bignum_value - ary = a.coerce(b) - - ary[0].should be_kind_of(Bignum) - ary[1].should be_kind_of(Bignum) - ary.should == [b, a] - end - - it "raises a TypeError when not passed a Fixnum or Bignum" do - a = bignum_value - - lambda { a.coerce(nil) }.should raise_error(TypeError) - lambda { a.coerce(mock('str')) }.should raise_error(TypeError) - lambda { a.coerce(1..4) }.should raise_error(TypeError) - lambda { a.coerce(:test) }.should raise_error(TypeError) - end - - ruby_version_is ""..."2.4" do - it "raises a TypeError when passed a String" do - a = bignum_value - lambda { a.coerce("123") }.should raise_error(TypeError) - end - - it "raises a TypeError when passed a Float" do - a = bignum_value - lambda { a.coerce(12.3) }.should raise_error(TypeError) - end - end - - ruby_version_is "2.4" do - it "coerces both values to Floats and returns [other, self] when passed a Float" do - a = bignum_value - a.coerce(1.2).should == [1.2, a.to_f] - end - - it "coerces both values to Floats and returns [other, self] when passed a String" do - a = bignum_value - a.coerce("123").should == [123.0, a.to_f] - end - - it "calls #to_f to coerce other to a Float" do - b = mock("bignum value") - b.should_receive(:to_f).and_return(1.2) - - a = bignum_value - ary = a.coerce(b) - - ary.should == [1.2, a.to_f] - end - end -end diff --git a/spec/ruby/core/bignum/comparison_spec.rb b/spec/ruby/core/bignum/comparison_spec.rb deleted file mode 100644 index 435cc9aea2..0000000000 --- a/spec/ruby/core/bignum/comparison_spec.rb +++ /dev/null @@ -1,162 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) - -describe "Bignum#<=>" do - describe "with a Fixnum" do - it "returns -1 when other is larger" do - (-bignum_value <=> 2).should == -1 - end - - it "returns 1 when other is smaller" do - (bignum_value <=> 2).should == 1 - end - end - - describe "with a Bignum" do - describe "when other is negative" do - it "returns -1 when self is negative and other is larger" do - (-bignum_value(42) <=> -bignum_value).should == -1 - end - - it "returns 0 when other is equal" do - (-bignum_value <=> -bignum_value).should == 0 - end - - it "returns 1 when self is negative and other is smaller" do - (-bignum_value <=> -bignum_value(94)).should == 1 - end - - it "returns 1 when self is positive" do - (bignum_value <=> -bignum_value).should == 1 - end - end - - describe "when other is positive" do - it "returns -1 when self is negative" do - (-bignum_value <=> bignum_value).should == -1 - end - - it "returns -1 when self is positive and other is larger" do - (bignum_value <=> bignum_value(38)).should == -1 - end - - it "returns 0 when other is equal" do - (bignum_value <=> bignum_value).should == 0 - end - - it "returns 1 when other is smaller" do - (bignum_value(56) <=> bignum_value).should == 1 - end - end - end - - describe "with a Float" do - describe "when other is negative" do - it "returns -1 when self is negative and other is larger" do - (-bignum_value(0xffff) <=> -bignum_value.to_f).should == -1 - end - - it "returns 0 when other is equal" do - (-bignum_value <=> -bignum_value.to_f).should == 0 - end - - it "returns 1 when self is negative and other is smaller" do - (-bignum_value <=> -bignum_value(0xffef).to_f).should == 1 - end - - it "returns 1 when self is positive" do - (bignum_value <=> -bignum_value.to_f).should == 1 - end - end - - describe "when other is positive" do - it "returns -1 when self is negative" do - (-bignum_value <=> bignum_value.to_f).should == -1 - end - - it "returns -1 when self is positive and other is larger" do - (bignum_value <=> bignum_value(0xfffe).to_f).should == -1 - end - - it "returns 0 when other is equal" do - (bignum_value <=> bignum_value.to_f).should == 0 - end - - it "returns 1 when other is smaller" do - (bignum_value(0xfeff) <=> bignum_value.to_f).should == 1 - end - end - end - - describe "with an Object" do - before :each do - @big = bignum_value - @num = mock("value for Bignum#<=>") - end - - it "calls #coerce on other" do - @num.should_receive(:coerce).with(@big).and_return([@big.to_f, 2.5]) - @big <=> @num - end - - ruby_version_is ""..."2.5" do - it "returns nil if #coerce raises an exception" do - @num.should_receive(:coerce).with(@big).and_raise(RuntimeError) - lambda { - @result = (@big <=> @num) - }.should complain(/Numerical comparison operators will no more rescue exceptions/) - @result.should be_nil - end - end - - ruby_version_is "2.5" do - it "lets the exception go through if #coerce raises an exception" do - @num.should_receive(:coerce).with(@big).and_raise(RuntimeError.new("my error")) - lambda { - @big <=> @num - }.should raise_error(RuntimeError, "my error") - end - end - - it "raises an exception if #coerce raises a non-StandardError exception" do - @num.should_receive(:coerce).with(@big).and_raise(Exception) - lambda { @big <=> @num }.should raise_error(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 - end - - it "returns -1 if the coerced value is larger" do - @num.should_receive(:coerce).with(@big).and_return([@big, bignum_value(10)]) - (@big <=> @num).should == -1 - end - - it "returns 0 if the coerced value is equal" do - @num.should_receive(:coerce).with(@big).and_return([@big, bignum_value]) - (@big <=> @num).should == 0 - end - - it "returns 1 if the coerced value is smaller" do - @num.should_receive(:coerce).with(@big).and_return([@big, 22]) - (@big <=> @num).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 - end - - it "returns -1 when self is negative and other is Infinty" do - (-Float::MAX.to_i*2 <=> infinity_value).should == -1 - end - - it "returns 1 when self is negative and other is -Infinity" do - (-Float::MAX.to_i*2 <=> -infinity_value).should == 1 - end - - it "returns -1 when self is -Infinity and other is negative" do - (-infinity_value <=> -Float::MAX.to_i*2).should == -1 - end -end diff --git a/spec/ruby/core/bignum/complement_spec.rb b/spec/ruby/core/bignum/complement_spec.rb deleted file mode 100644 index be6bc21b19..0000000000 --- a/spec/ruby/core/bignum/complement_spec.rb +++ /dev/null @@ -1,9 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) - -describe "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 - end -end diff --git a/spec/ruby/core/bignum/div_spec.rb b/spec/ruby/core/bignum/div_spec.rb deleted file mode 100644 index 6c165289e8..0000000000 --- a/spec/ruby/core/bignum/div_spec.rb +++ /dev/null @@ -1,21 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) -require File.expand_path('../shared/divide', __FILE__) - -describe "Bignum#div" do - it_behaves_like(:bignum_divide, :div) - - it "returns a result of integer division of self by a float argument" do - bignum_value(88).div(4294967295.5).should eql(2147483648) - not_supported_on :opal do - bignum_value(88).div(4294967295.0).should eql(2147483648) - bignum_value(88).div(bignum_value(88).to_f).should eql(1) - bignum_value(88).div(-bignum_value(88).to_f).should eql(-1) - end - end - - # #5490 - it "raises ZeroDivisionError if the argument is Float zero" do - lambda { bignum_value(88).div(0.0) }.should raise_error(ZeroDivisionError) - lambda { bignum_value(88).div(-0.0) }.should raise_error(ZeroDivisionError) - end -end diff --git a/spec/ruby/core/bignum/divide_spec.rb b/spec/ruby/core/bignum/divide_spec.rb deleted file mode 100644 index b81938b707..0000000000 --- a/spec/ruby/core/bignum/divide_spec.rb +++ /dev/null @@ -1,18 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) -require File.expand_path('../shared/divide', __FILE__) - -describe "Bignum#/" do - it_behaves_like(:bignum_divide, :/) - - it "returns self divided by float" do - not_supported_on :opal do - (bignum_value(88) / 4294967295.0).should be_close(2147483648.5, TOLERANCE) - end - (bignum_value(88) / 4294967295.5).should be_close(2147483648.25, TOLERANCE) - end - - it "does NOT raise ZeroDivisionError if other is zero and is a Float" do - (bignum_value / 0.0).to_s.should == 'Infinity' - (bignum_value / -0.0).to_s.should == '-Infinity' - end -end diff --git a/spec/ruby/core/bignum/divmod_spec.rb b/spec/ruby/core/bignum/divmod_spec.rb deleted file mode 100644 index 656f23482b..0000000000 --- a/spec/ruby/core/bignum/divmod_spec.rb +++ /dev/null @@ -1,81 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) - -describe "Bignum#divmod" do - before :each do - @bignum = bignum_value(55) - end - - # Based on MRI's test/test_integer.rb (test_divmod), - # MRI maintains the following property: - # if q, r = a.divmod(b) ==> - # 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.5).should == [2049638230412172288, 3.5] - - not_supported_on :opal do - @bignum.divmod(4.0).should == [2305843009213693952, 0.0] - @bignum.divmod(13.0).should == [709490156681136640, 8.0] - - @bignum.divmod(2.0).should == [4611686018427387904, 0.0] - end - - @bignum.divmod(bignum_value).should == [1, 55] - - (-(10**50)).divmod(-(10**40 + 1)).should == [9999999999, -9999999999999999999999999999990000000001] - (10**50).divmod(10**40 + 1).should == [9999999999, 9999999999999999999999999999990000000001] - - (-10**50).divmod(10**40 + 1).should == [-10000000000, 10000000000] - (10**50).divmod(-(10**40 + 1)).should == [-10000000000, -10000000000] - end - - describe "with q = floor(x/y), a = q*b + r," do - it "returns [q,r] when a < 0, b > 0 and |a| < b" do - a = -@bignum + 1 - b = @bignum - a.divmod(b).should == [-1, 1] - end - - it "returns [q,r] when a > 0, b < 0 and a > |b|" do - b = -@bignum + 1 - a = @bignum - a.divmod(b).should == [-2, -@bignum + 2] - end - - it "returns [q,r] when a > 0, b < 0 and a < |b|" do - a = @bignum - 1 - b = -@bignum - a.divmod(b).should == [-1, -1] - end - - it "returns [q,r] when a < 0, b < 0 and |a| < |b|" do - a = -@bignum + 1 - b = -@bignum - a.divmod(b).should == [0, -@bignum + 1] - end - end - - it "raises a ZeroDivisionError when the given argument is 0" do - lambda { @bignum.divmod(0) }.should raise_error(ZeroDivisionError) - lambda { (-@bignum).divmod(0) }.should raise_error(ZeroDivisionError) - end - - # Behaviour established as correct in r23953 - it "raises a FloatDomainError if other is NaN" do - lambda { @bignum.divmod(nan_value) }.should raise_error(FloatDomainError) - end - - it "raises a ZeroDivisionError when the given argument is 0 and a Float" do - lambda { @bignum.divmod(0.0) }.should raise_error(ZeroDivisionError) - lambda { (-@bignum).divmod(0.0) }.should raise_error(ZeroDivisionError) - end - - it "raises a TypeError when the given argument is not an Integer" do - lambda { @bignum.divmod(mock('10')) }.should raise_error(TypeError) - lambda { @bignum.divmod("10") }.should raise_error(TypeError) - lambda { @bignum.divmod(:symbol) }.should raise_error(TypeError) - end -end diff --git a/spec/ruby/core/bignum/element_reference_spec.rb b/spec/ruby/core/bignum/element_reference_spec.rb deleted file mode 100644 index e5ee9e15ac..0000000000 --- a/spec/ruby/core/bignum/element_reference_spec.rb +++ /dev/null @@ -1,30 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) - -describe "Bignum#[]" do - before :each do - @bignum = bignum_value(4996) - end - - it "returns the nth bit in the binary representation of self" do - @bignum[2].should == 1 - @bignum[9.2].should == 1 - @bignum[21].should == 0 - @bignum[0xffffffff].should == 0 - @bignum[-0xffffffff].should == 0 - end - - it "tries to convert the given argument to an Integer using #to_int" do - @bignum[1.3].should == @bignum[1] - - (obj = mock('2')).should_receive(:to_int).at_least(1).and_return(2) - @bignum[obj].should == 1 - end - - it "raises a TypeError when the given argument can't be converted to Integer" do - obj = mock('asdf') - lambda { @bignum[obj] }.should raise_error(TypeError) - - obj.should_receive(:to_int).and_return("asdf") - lambda { @bignum[obj] }.should raise_error(TypeError) - end -end diff --git a/spec/ruby/core/bignum/eql_spec.rb b/spec/ruby/core/bignum/eql_spec.rb deleted file mode 100644 index c9eff9ef08..0000000000 --- a/spec/ruby/core/bignum/eql_spec.rb +++ /dev/null @@ -1,22 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) - -describe "Bignum#eql? when given a Bignum" do - it "returns true if the given argument has the same value" do - a = bignum_value(13) - a.should eql(bignum_value(13)) - (-a).should eql(-bignum_value(13)) - end -end - -describe "Bignum#eql? when given a non-Bignum" do - it "returns false" do - a = bignum_value(13) - a.should_not eql(a.to_f) - - a.should_not eql(2) - a.should_not eql(3.14) - a.should_not eql(:symbol) - a.should_not eql("String") - a.should_not eql(mock('str')) - end -end diff --git a/spec/ruby/core/bignum/equal_value_spec.rb b/spec/ruby/core/bignum/equal_value_spec.rb deleted file mode 100644 index 0117d58683..0000000000 --- a/spec/ruby/core/bignum/equal_value_spec.rb +++ /dev/null @@ -1,6 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) -require File.expand_path('../shared/equal', __FILE__) - -describe "Bignum#==" do - it_behaves_like :bignum_equal, :== -end diff --git a/spec/ruby/core/bignum/even_spec.rb b/spec/ruby/core/bignum/even_spec.rb deleted file mode 100644 index a84ea80075..0000000000 --- a/spec/ruby/core/bignum/even_spec.rb +++ /dev/null @@ -1,19 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) - -describe "Bignum#even?" do - it "returns true if self is even and positive" do - (10000**10).even?.should be_true - end - - it "returns true if self is even and negative" do - (-10000**10).even?.should be_true - end - - it "returns false if self is odd and positive" do - (9879**976).even?.should be_false - end - - it "returns false if self is odd and negative" do - (-9879**976).even?.should be_false - end -end diff --git a/spec/ruby/core/bignum/exponent_spec.rb b/spec/ruby/core/bignum/exponent_spec.rb deleted file mode 100644 index 9026c1ff3b..0000000000 --- a/spec/ruby/core/bignum/exponent_spec.rb +++ /dev/null @@ -1,29 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) - -describe "Bignum#**" do - before :each do - @bignum = bignum_value(47) - end - - it "returns self raised to other power" do - (@bignum ** 4).should == 7237005577332262361485077344629993318496048279512298547155833600056910050625 - (@bignum ** 1.2).should be_close(57262152889751597425762.57804, TOLERANCE) - end - - it "raises a TypeError when given a non-Integer" do - lambda { @bignum ** mock('10') }.should raise_error(TypeError) - lambda { @bignum ** "10" }.should raise_error(TypeError) - lambda { @bignum ** :symbol }.should raise_error(TypeError) - end - - it "switch to a Float when the values is too big" do - flt = (@bignum ** @bignum) - flt.should be_kind_of(Float) - flt.infinite?.should == 1 - end - - it "returns a complex number when negative and raised to a fractional power" do - ((-@bignum) ** (1.0/3)) .should be_close(Complex(1048576,1816186.907597341), TOLERANCE) - ((-@bignum) ** Rational(1,3)).should be_close(Complex(1048576,1816186.907597341), TOLERANCE) - end -end diff --git a/spec/ruby/core/bignum/fdiv_spec.rb b/spec/ruby/core/bignum/fdiv_spec.rb deleted file mode 100644 index 35f3ede010..0000000000 --- a/spec/ruby/core/bignum/fdiv_spec.rb +++ /dev/null @@ -1,5 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) - -describe "Bignum#fdiv" do - it "needs to be reviewed for spec completeness" -end diff --git a/spec/ruby/core/bignum/gt_spec.rb b/spec/ruby/core/bignum/gt_spec.rb deleted file mode 100644 index 5c814eedd1..0000000000 --- a/spec/ruby/core/bignum/gt_spec.rb +++ /dev/null @@ -1,20 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) - -describe "Bignum#>" do - before :each do - @bignum = bignum_value(732) - end - - it "returns true if self is greater than the given argument" do - (@bignum > (@bignum - 1)).should == true - (@bignum > 14.6).should == true - (@bignum > 10).should == true - - (@bignum > (@bignum + 500)).should == false - end - - it "raises an ArgumentError when given a non-Integer" do - lambda { @bignum > "4" }.should raise_error(ArgumentError) - lambda { @bignum > mock('str') }.should raise_error(ArgumentError) - end -end diff --git a/spec/ruby/core/bignum/gte_spec.rb b/spec/ruby/core/bignum/gte_spec.rb deleted file mode 100644 index e32ce19e0f..0000000000 --- a/spec/ruby/core/bignum/gte_spec.rb +++ /dev/null @@ -1,19 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) - -describe "Bignum#>=" do - before :each do - @bignum = bignum_value(14) - end - - it "returns true if self is greater than or equal to other" do - (@bignum >= @bignum).should == true - (@bignum >= (@bignum + 2)).should == false - (@bignum >= 5664.2).should == true - (@bignum >= 4).should == true - end - - it "raises an ArgumentError when given a non-Integer" do - lambda { @bignum >= "4" }.should raise_error(ArgumentError) - lambda { @bignum >= mock('str') }.should raise_error(ArgumentError) - end -end diff --git a/spec/ruby/core/bignum/hash_spec.rb b/spec/ruby/core/bignum/hash_spec.rb deleted file mode 100644 index bdc85c3fdc..0000000000 --- a/spec/ruby/core/bignum/hash_spec.rb +++ /dev/null @@ -1,12 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) - -describe "Bignum#hash" do - it "is provided" do - bignum_value.respond_to?(:hash).should == true - end - - it "is stable" do - bignum_value.hash.should == bignum_value.hash - bignum_value.hash.should_not == bignum_value(1).hash - end -end diff --git a/spec/ruby/core/bignum/left_shift_spec.rb b/spec/ruby/core/bignum/left_shift_spec.rb deleted file mode 100644 index 364f51b708..0000000000 --- a/spec/ruby/core/bignum/left_shift_spec.rb +++ /dev/null @@ -1,73 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) - -describe "Bignum#<< with n << m" do - before :each do - @bignum = bignum_value * 16 - end - - it "returns n shifted left m bits when n > 0, m > 0" do - (@bignum << 4).should == 2361183241434822606848 - end - - it "returns n shifted left m bits when n < 0, m > 0" do - (-@bignum << 9).should == -75557863725914323419136 - end - - it "returns n shifted right m bits when n > 0, m < 0" do - (@bignum << -1).should == 73786976294838206464 - end - - it "returns n shifted right m bits when n < 0, m < 0" do - (-@bignum << -2).should == -36893488147419103232 - end - - it "returns n when n > 0, m == 0" do - (@bignum << 0).should == @bignum - end - - it "returns n when n < 0, m == 0" do - (-@bignum << 0).should == -@bignum - end - - it "returns 0 when m < 0 and m == p where 2**p > n >= 2**(p-1)" 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(Fixnum) - 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(Fixnum) - result.should == fixnum_min - end - - it "calls #to_int to convert the argument to an Integer" do - obj = mock("4") - obj.should_receive(:to_int).and_return(4) - - (@bignum << obj).should == 2361183241434822606848 - end - - it "raises a TypeError when #to_int does not return an Integer" do - obj = mock("a string") - obj.should_receive(:to_int).and_return("asdf") - - lambda { @bignum << obj }.should raise_error(TypeError) - end - - it "raises a TypeError when passed nil" do - lambda { @bignum << nil }.should raise_error(TypeError) - end - - it "raises a TypeError when passed a String" do - lambda { @bignum << "4" }.should raise_error(TypeError) - end -end diff --git a/spec/ruby/core/bignum/lt_spec.rb b/spec/ruby/core/bignum/lt_spec.rb deleted file mode 100644 index 802c68a58b..0000000000 --- a/spec/ruby/core/bignum/lt_spec.rb +++ /dev/null @@ -1,22 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) - -describe "Bignum#<" do - before :each do - @bignum = bignum_value(32) - end - - it "returns true if self is less than the given argument" do - (@bignum < @bignum + 1).should == true - (-@bignum < -(@bignum - 1)).should == true - - (@bignum < 1).should == false - (@bignum < 5).should == false - - (@bignum < 4.999).should == false - end - - it "raises an ArgumentError when given a non-Integer" do - lambda { @bignum < "4" }.should raise_error(ArgumentError) - lambda { @bignum < mock('str') }.should raise_error(ArgumentError) - end -end diff --git a/spec/ruby/core/bignum/lte_spec.rb b/spec/ruby/core/bignum/lte_spec.rb deleted file mode 100644 index 9a1d22d3be..0000000000 --- a/spec/ruby/core/bignum/lte_spec.rb +++ /dev/null @@ -1,24 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) - -describe "Bignum#<=" do - before :each do - @bignum = bignum_value(39) - end - - it "returns true if self is less than or equal to other" do - (@bignum <= @bignum).should == true - (-@bignum <= -(@bignum - 1)).should == true - - (@bignum <= 4.999).should == false - end - - it "returns false if compares with near float" do - (@bignum <= (@bignum + 0.0)).should == false - (@bignum <= (@bignum + 0.5)).should == false - end - - it "raises an ArgumentError when given a non-Integer" do - lambda { @bignum <= "4" }.should raise_error(ArgumentError) - lambda { @bignum <= mock('str') }.should raise_error(ArgumentError) - end -end diff --git a/spec/ruby/core/bignum/magnitude_spec.rb b/spec/ruby/core/bignum/magnitude_spec.rb deleted file mode 100644 index 35b9ba6f1e..0000000000 --- a/spec/ruby/core/bignum/magnitude_spec.rb +++ /dev/null @@ -1,6 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) -require File.expand_path('../shared/abs', __FILE__) - -describe "Bignum#magnitude" do - it_behaves_like(:bignum_abs, :magnitude) -end diff --git a/spec/ruby/core/bignum/minus_spec.rb b/spec/ruby/core/bignum/minus_spec.rb deleted file mode 100644 index 754ef7fa42..0000000000 --- a/spec/ruby/core/bignum/minus_spec.rb +++ /dev/null @@ -1,19 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) - -describe "Bignum#-" do - before :each do - @bignum = bignum_value(314) - end - - it "returns self minus the given Integer" do - (@bignum - 9).should == 9223372036854776113 - (@bignum - 12.57).should be_close(9223372036854776109.43, TOLERANCE) - (@bignum - bignum_value(42)).should == 272 - end - - it "raises a TypeError when given a non-Integer" do - lambda { @bignum - mock('10') }.should raise_error(TypeError) - lambda { @bignum - "10" }.should raise_error(TypeError) - lambda { @bignum - :symbol }.should raise_error(TypeError) - end -end diff --git a/spec/ruby/core/bignum/modulo_spec.rb b/spec/ruby/core/bignum/modulo_spec.rb deleted file mode 100644 index eee1dc76a6..0000000000 --- a/spec/ruby/core/bignum/modulo_spec.rb +++ /dev/null @@ -1,10 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) -require File.expand_path('../shared/modulo', __FILE__) - -describe "Bignum#%" do - it_behaves_like(:bignum_modulo, :%) -end - -describe "Bignum#modulo" do - it_behaves_like(:bignum_modulo, :modulo) -end diff --git a/spec/ruby/core/bignum/multiply_spec.rb b/spec/ruby/core/bignum/multiply_spec.rb deleted file mode 100644 index 486e36ecbc..0000000000 --- a/spec/ruby/core/bignum/multiply_spec.rb +++ /dev/null @@ -1,20 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) - -describe "Bignum#*" do - before :each do - @bignum = bignum_value(772) - end - - 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 - end - - it "raises a TypeError when given a non-Integer" do - lambda { @bignum * mock('10') }.should raise_error(TypeError) - lambda { @bignum * "10" }.should raise_error(TypeError) - lambda { @bignum * :symbol }.should raise_error(TypeError) - end -end diff --git a/spec/ruby/core/bignum/odd_spec.rb b/spec/ruby/core/bignum/odd_spec.rb deleted file mode 100644 index 9d4c1191f6..0000000000 --- a/spec/ruby/core/bignum/odd_spec.rb +++ /dev/null @@ -1,19 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) - -describe "Bignum#odd?" do - it "returns true if self is odd and positive" do - (987279**19).odd?.should be_true - end - - it "returns true if self is odd and negative" do - (-9873389**97).odd?.should be_true - end - - it "returns false if self is even and positive" do - (10000000**10).odd?.should be_false - end - - it "returns false if self is even and negative" do - (-1000000**100).odd?.should be_false - end -end diff --git a/spec/ruby/core/bignum/plus_spec.rb b/spec/ruby/core/bignum/plus_spec.rb deleted file mode 100644 index 411e226649..0000000000 --- a/spec/ruby/core/bignum/plus_spec.rb +++ /dev/null @@ -1,19 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) - -describe "Bignum#+" do - before :each do - @bignum = bignum_value(76) - 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 - end - - it "raises a TypeError when given a non-Integer" do - lambda { @bignum + mock('10') }.should raise_error(TypeError) - lambda { @bignum + "10" }.should raise_error(TypeError) - lambda { @bignum + :symbol}.should raise_error(TypeError) - end -end diff --git a/spec/ruby/core/bignum/remainder_spec.rb b/spec/ruby/core/bignum/remainder_spec.rb deleted file mode 100644 index 59f7eb4326..0000000000 --- a/spec/ruby/core/bignum/remainder_spec.rb +++ /dev/null @@ -1,21 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) - -describe "Bignum#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(bignum_value).should == 79 - end - - it "raises a ZeroDivisionError if other is zero and not a Float" do - lambda { bignum_value(66).remainder(0) }.should raise_error(ZeroDivisionError) - end - - it "does raises ZeroDivisionError if other is zero and a Float" do - a = bignum_value(7) - b = bignum_value(32) - lambda { a.remainder(0.0) }.should raise_error(ZeroDivisionError) - lambda { b.remainder(-0.0) }.should raise_error(ZeroDivisionError) - end -end diff --git a/spec/ruby/core/bignum/right_shift_spec.rb b/spec/ruby/core/bignum/right_shift_spec.rb deleted file mode 100644 index d65f7c00a9..0000000000 --- a/spec/ruby/core/bignum/right_shift_spec.rb +++ /dev/null @@ -1,99 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) - -describe "Bignum#>> with n >> m" do - before :each do - @bignum = bignum_value * 16 - end - - it "returns n shifted right m bits when n > 0, m > 0" do - (@bignum >> 1).should == 73786976294838206464 - end - - it "returns n shifted right m bits when n < 0, m > 0" do - (-@bignum >> 2).should == -36893488147419103232 - end - - it "respects twos complement signed shifting" do - # This explicit left hand value is important because it is the - # exact bit pattern that matters, so it's important it's right - # here to show the significance. - # - - (-42949672980000000000000 >> 14).should == -2621440001220703125 - (-42949672980000000000001 >> 14).should == -2621440001220703126 - # Note the off by one -------------------- ^^^^^^^^^^^^^^^^^^^^ - # This is because even though we discard the lowest bit, in twos - # complement it would influence the bits to the left of it. - - (-42949672980000000000000 >> 15).should == -1310720000610351563 - (-42949672980000000000001 >> 15).should == -1310720000610351563 - - (-0xfffffffffffffffff >> 32).should == -68719476736 - end - - it "respects twos complement signed shifting for very large values" do - giant = 42949672980000000000000000000000000000000000000000000000000000000000000000000000000000000000 - neg = -giant - - (giant >> 84).should == 2220446050284288846538547929770901490087453566957265138626098632812 - (neg >> 84).should == -2220446050284288846538547929770901490087453566957265138626098632813 - end - - it "returns n shifted left m bits when n > 0, m < 0" do - (@bignum >> -2).should == 590295810358705651712 - end - - it "returns n shifted left m bits when n < 0, m < 0" do - (-@bignum >> -3).should == -1180591620717411303424 - end - - it "returns n when n > 0, m == 0" do - (@bignum >> 0).should == @bignum - end - - it "returns n when n < 0, m == 0" do - (-@bignum >> 0).should == -@bignum - end - - it "returns 0 when m > 0 and m == p where 2**p > n >= 2**(p-1)" 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(Fixnum) - 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(Fixnum) - result.should == fixnum_min - end - - it "calls #to_int to convert the argument to an Integer" do - obj = mock("2") - obj.should_receive(:to_int).and_return(2) - - (@bignum >> obj).should == 36893488147419103232 - end - - it "raises a TypeError when #to_int does not return an Integer" do - obj = mock("a string") - obj.should_receive(:to_int).and_return("asdf") - - lambda { @bignum >> obj }.should raise_error(TypeError) - end - - it "raises a TypeError when passed nil" do - lambda { @bignum >> nil }.should raise_error(TypeError) - end - - it "raises a TypeError when passed a String" do - lambda { @bignum >> "4" }.should raise_error(TypeError) - end -end diff --git a/spec/ruby/core/bignum/shared/abs.rb b/spec/ruby/core/bignum/shared/abs.rb deleted file mode 100644 index 35fd85060c..0000000000 --- a/spec/ruby/core/bignum/shared/abs.rb +++ /dev/null @@ -1,6 +0,0 @@ -describe :bignum_abs, shared: true do - it "returns the absolute value" do - bignum_value(39).send(@method).should == 9223372036854775847 - (-bignum_value(18)).send(@method).should == 9223372036854775826 - end -end diff --git a/spec/ruby/core/bignum/shared/divide.rb b/spec/ruby/core/bignum/shared/divide.rb deleted file mode 100644 index cbde69bbb2..0000000000 --- a/spec/ruby/core/bignum/shared/divide.rb +++ /dev/null @@ -1,27 +0,0 @@ -describe :bignum_divide, shared: true do - before :each do - @bignum = bignum_value(88) - end - - it "returns self divided by other" do - @bignum.send(@method, 4).should == 2305843009213693974 - - @bignum.send(@method, bignum_value(2)).should be_close(1, TOLERANCE) - - (-(10**50)).send(@method, -(10**40 + 1)).should == 9999999999 - (10**50).send(@method, 10**40 + 1).should == 9999999999 - - (-10**50).send(@method, 10**40 + 1).should == -10000000000 - (10**50).send(@method, -(10**40 + 1)).should == -10000000000 - end - - it "raises a ZeroDivisionError if other is zero and not a Float" do - lambda { @bignum.send(@method, 0) }.should raise_error(ZeroDivisionError) - end - - it "raises a TypeError when given a non-Integer" do - lambda { @bignum.send(@method, mock('10')) }.should raise_error(TypeError) - lambda { @bignum.send(@method, "2") }.should raise_error(TypeError) - lambda { @bignum.send(@method, :symbol) }.should raise_error(TypeError) - end -end diff --git a/spec/ruby/core/bignum/shared/equal.rb b/spec/ruby/core/bignum/shared/equal.rb deleted file mode 100644 index ffe4daf4f1..0000000000 --- a/spec/ruby/core/bignum/shared/equal.rb +++ /dev/null @@ -1,31 +0,0 @@ -describe :bignum_equal, shared: true do - before :each do - @bignum = bignum_value - end - - it "returns true if self has the same value as the given argument" do - @bignum.send(@method, @bignum).should == true - @bignum.send(@method, @bignum.to_f).should == true - - @bignum.send(@method, @bignum + 1).should == false - (@bignum + 1).send(@method, @bignum).should == false - - @bignum.send(@method, 9).should == false - @bignum.send(@method, 9.01).should == false - - @bignum.send(@method, bignum_value(10)).should == false - end - - it "calls 'other == self' if the given argument is not an Integer" do - obj = mock('not integer') - obj.should_receive(:==).and_return(true) - @bignum.send(@method, obj).should == true - end - - it "returns the result of 'other == self' as a boolean" do - obj = mock('not integer') - obj.should_receive(:==).exactly(2).times.and_return("woot", nil) - @bignum.send(@method, obj).should == true - @bignum.send(@method, obj).should == false - end -end diff --git a/spec/ruby/core/bignum/shared/modulo.rb b/spec/ruby/core/bignum/shared/modulo.rb deleted file mode 100644 index 9814e22f3b..0000000000 --- a/spec/ruby/core/bignum/shared/modulo.rb +++ /dev/null @@ -1,29 +0,0 @@ -describe :bignum_modulo, shared: true do - before :each do - @bignum = bignum_value - 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 - end - - it "raises a ZeroDivisionError when the given argument is 0" do - lambda { @bignum.send(@method, 0) }.should raise_error(ZeroDivisionError) - lambda { (-@bignum).send(@method, 0) }.should raise_error(ZeroDivisionError) - end - - it "raises a ZeroDivisionError when the given argument is 0 and a Float" do - lambda { @bignum.send(@method, 0.0) }.should raise_error(ZeroDivisionError) - lambda { -@bignum.send(@method, 0.0) }.should raise_error(ZeroDivisionError) - end - - it "raises a TypeError when given a non-Integer" do - lambda { @bignum.send(@method, mock('10')) }.should raise_error(TypeError) - lambda { @bignum.send(@method, "10") }.should raise_error(TypeError) - lambda { @bignum.send(@method, :symbol) }.should raise_error(TypeError) - end -end diff --git a/spec/ruby/core/bignum/size_spec.rb b/spec/ruby/core/bignum/size_spec.rb deleted file mode 100644 index 8629cba972..0000000000 --- a/spec/ruby/core/bignum/size_spec.rb +++ /dev/null @@ -1,16 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) - -describe "Bignum#size" do - it "returns the number of bytes required to hold the unsigned bignum data" do - # that is, n such that 256 * n <= val.abs < 256 * (n+1) - (256**7).size.should == 8 - (256**8).size.should == 9 - (256**9).size.should == 10 - (256**10).size.should == 11 - (256**10-1).size.should == 10 - (256**11).size.should == 12 - (256**12).size.should == 13 - (256**20-1).size.should == 20 - (256**40-1).size.should == 40 - end -end diff --git a/spec/ruby/core/bignum/to_f_spec.rb b/spec/ruby/core/bignum/to_f_spec.rb deleted file mode 100644 index 8d99045c95..0000000000 --- a/spec/ruby/core/bignum/to_f_spec.rb +++ /dev/null @@ -1,13 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) - -describe "Bignum#to_f" 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) - end - - it "converts number close to Float::MAX without exceeding MAX or producing NaN" do - (10**308).to_f.should == 10.0 ** 308 - end -end diff --git a/spec/ruby/core/bignum/to_s_spec.rb b/spec/ruby/core/bignum/to_s_spec.rb deleted file mode 100644 index 524639adb6..0000000000 --- a/spec/ruby/core/bignum/to_s_spec.rb +++ /dev/null @@ -1,48 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) - -describe "Bignum#to_s when given a base" do - it "returns self converted to a String using the given base" do - a = 2**64 - a.to_s(2).should == "10000000000000000000000000000000000000000000000000000000000000000" - a.to_s(8).should == "2000000000000000000000" - a.to_s(16).should == "10000000000000000" - a.to_s(32).should == "g000000000000" - end - - it "raises an ArgumentError if the base is less than 2 or higher than 36" do - lambda { 123.to_s(-1) }.should raise_error(ArgumentError) - lambda { 123.to_s(0) }.should raise_error(ArgumentError) - lambda { 123.to_s(1) }.should raise_error(ArgumentError) - lambda { 123.to_s(37) }.should raise_error(ArgumentError) - end -end - -describe "Bignum#to_s 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" - end -end - -with_feature :encoding do - describe "Bignum#to_s" do - before :each do - @internal = Encoding.default_internal - end - - after :each do - Encoding.default_internal = @internal - end - - 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) - 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) - end - end -end diff --git a/spec/ruby/core/bignum/uminus_spec.rb b/spec/ruby/core/bignum/uminus_spec.rb deleted file mode 100644 index 7ec432ac71..0000000000 --- a/spec/ruby/core/bignum/uminus_spec.rb +++ /dev/null @@ -1,11 +0,0 @@ -require File.expand_path('../../../spec_helper', __FILE__) - -describe "Bignum#-@" do - it "returns self as a negative value" do - bignum_value.send(:-@).should == -9223372036854775808 - (-bignum_value).send(:-@).should == 9223372036854775808 - - bignum_value(921).send(:-@).should == -9223372036854776729 - (-bignum_value(921).send(:-@)).should == 9223372036854776729 - end -end |