-ruby_version_is ""..."3.4" do

- require 'abbrev'

- #test both Abbrev.abbrev and Array#abbrev in

- #the same manner, as they're more or less aliases

- #of one another

- [["Abbrev.abbrev", -> a { Abbrev.abbrev(a)}],

- ["Array#abbrev", -> a { a.abbrev}]

- ].each do |(name, func)|

- describe name do

- it "returns a hash of all unambiguous abbreviations of the array of strings passed in" do

- func.call(['ruby', 'rules']).should == {"rub" => "ruby",

- "ruby" => "ruby",

- "rul" => "rules",

- "rule" => "rules",

- "rules" => "rules"}

-

- func.call(["car", "cone"]).should == {"ca" => "car",

- "car" => "car",

- "co" => "cone",

- "con" => "cone",

- "cone" => "cone"}

- end

- it "returns an empty hash when called on an empty array" do

- func.call([]).should == {}

- end

-ruby_version_is ""..."3.4" do

- require 'base64'

-

- describe "Base64#decode64" do

- it "returns the Base64-decoded version of the given string" do

- Base64.decode64("U2VuZCByZWluZm9yY2VtZW50cw==\n").should == "Send reinforcements"

- end

- it "returns the Base64-decoded version of the given shared string" do

- Base64.decode64("base64: U2VuZCByZWluZm9yY2VtZW50cw==\n".split(" ").last).should == "Send reinforcements"

- end

- it "returns the Base64-decoded version of the given string with wrong padding" do

- Base64.decode64("XU2VuZCByZWluZm9yY2VtZW50cw===").should == "]M\x95\xB9\x90\x81\xC9\x95\xA5\xB9\x99\xBD\xC9\x8D\x95\xB5\x95\xB9\xD1\xCC".b

- end

- it "returns the Base64-decoded version of the given string that contains an invalid character" do

- Base64.decode64("%3D").should == "\xDC".b

- end

- it "returns a binary encoded string" do

- Base64.decode64("SEk=").encoding.should == Encoding::BINARY

- end

- it "decodes without padding suffix ==" do

- Base64.decode64("eyJrZXkiOnsibiI6InR0dCJ9fQ").should == "{\"key\":{\"n\":\"ttt\"}}"

- end

-ruby_version_is ""..."3.4" do

- require 'base64'

-

- describe "Base64#encode64" do

- it "returns the Base64-encoded version of the given string" do

- Base64.encode64("Now is the time for all good coders\nto learn Ruby").should ==

- "Tm93IGlzIHRoZSB0aW1lIGZvciBhbGwgZ29vZCBjb2RlcnMKdG8gbGVhcm4g\nUnVieQ==\n"

- end

- it "returns the Base64-encoded version of the given string" do

- Base64.encode64('Send reinforcements').should == "U2VuZCByZWluZm9yY2VtZW50cw==\n"

- end

- it "returns the Base64-encoded version of the given shared string" do

- Base64.encode64("Now is the time for all good coders\nto learn Ruby".split("\n").last).should ==

- "dG8gbGVhcm4gUnVieQ==\n"

- end

- it "returns a US_ASCII encoded string" do

- Base64.encode64("HI").encoding.should == Encoding::US_ASCII

- end

-ruby_version_is ""..."3.4" do

-

- require 'base64'

-

- describe "Base64#strict_decode64" do

- it "returns the Base64-decoded version of the given string" do

- Base64.strict_decode64("U2VuZCByZWluZm9yY2VtZW50cw==").should == "Send reinforcements"

- end

-

- it "returns the Base64-decoded version of the given shared string" do

- Base64.strict_decode64("base64: U2VuZCByZWluZm9yY2VtZW50cw==".split(" ").last).should == "Send reinforcements"

- end

-

- it "raises ArgumentError when the given string contains CR" do

- -> do

- Base64.strict_decode64("U2VuZCByZWluZm9yY2VtZW50cw==\r")

- end.should raise_error(ArgumentError)

- end

-

- it "raises ArgumentError when the given string contains LF" do

- -> do

- Base64.strict_decode64("U2VuZCByZWluZm9yY2VtZW50cw==\n")

- end.should raise_error(ArgumentError)

- end

-

- it "raises ArgumentError when the given string has wrong padding" do

- -> do

- Base64.strict_decode64("=U2VuZCByZWluZm9yY2VtZW50cw==")

- end.should raise_error(ArgumentError)

- end

-

- it "raises ArgumentError when the given string contains an invalid character" do

- -> do

- Base64.strict_decode64("%3D")

- end.should raise_error(ArgumentError)

- end

-

- it "returns a binary encoded string" do

- Base64.strict_decode64("SEk=").encoding.should == Encoding::BINARY

- end

-ruby_version_is ""..."3.4" do

- require 'base64'

-

- describe "Base64#strict_encode64" do

- it "returns the Base64-encoded version of the given string" do

- Base64.strict_encode64("Now is the time for all good coders\nto learn Ruby").should ==

- "Tm93IGlzIHRoZSB0aW1lIGZvciBhbGwgZ29vZCBjb2RlcnMKdG8gbGVhcm4gUnVieQ=="

- end

- it "returns the Base64-encoded version of the given shared string" do

- Base64.strict_encode64("Now is the time for all good coders\nto learn Ruby".split("\n").last).should ==

- "dG8gbGVhcm4gUnVieQ=="

- end

- it "returns a US_ASCII encoded string" do

- Base64.strict_encode64("HI").encoding.should == Encoding::US_ASCII

- end

-ruby_version_is ""..."3.4" do

- require 'base64'

-

- describe "Base64#urlsafe_decode64" do

- it "uses '_' instead of '/'" do

- decoded = Base64.urlsafe_decode64("V2hlcmUgYW0gST8gV2hvIGFtIEk_IEFtIEk_IEk_")

- decoded.should == 'Where am I? Who am I? Am I? I?'

- end

- it "uses '-' instead of '+'" do

- decoded = Base64.urlsafe_decode64('IkJlaW5nIGRpc2ludGVncmF0ZWQgbWFrZXMgbWUgdmUtcnkgYW4tZ3J5ISIgPGh1ZmYsIGh1ZmY-')

- decoded.should == '"Being disintegrated makes me ve-ry an-gry!" <huff, huff>'

- end

- it "does not require padding" do

- Base64.urlsafe_decode64("MQ").should == "1"

- end

-ruby_version_is ""..."3.4" do

- require 'base64'

-

- describe "Base64#urlsafe_encode64" do

- it "uses '_' instead of '/'" do

- encoded = Base64.urlsafe_encode64('Where am I? Who am I? Am I? I?')

- encoded.should == "V2hlcmUgYW0gST8gV2hvIGFtIEk_IEFtIEk_IEk_"

- end

- it "uses '-' instead of '+'" do

- encoded = Base64.urlsafe_encode64('"Being disintegrated makes me ve-ry an-gry!" <huff, huff>')

- encoded.should == 'IkJlaW5nIGRpc2ludGVncmF0ZWQgbWFrZXMgbWUgdmUtcnkgYW4tZ3J5ISIgPGh1ZmYsIGh1ZmY-'

- end

- it "makes padding optional" do

- Base64.urlsafe_encode64("1", padding: false).should == "MQ"

- Base64.urlsafe_encode64("1").should == "MQ=="

- end

-ruby_version_is ""..."3.4" do

- require 'bigdecimal'

- describe "BigDecimal" do

- it "is not defined unless it is required" do

- ruby_exe('puts Object.const_defined?(:BigDecimal)').should == "false\n"

- end

- describe "Kernel#BigDecimal" do

-

- it "creates a new object of class BigDecimal" do

- BigDecimal("3.14159").should be_kind_of(BigDecimal)

- (0..9).each {|i|

- BigDecimal("1#{i}").should == 10 + i

- BigDecimal("-1#{i}").should == -10 - i

- BigDecimal("1E#{i}").should == 10**i

- BigDecimal("1000000E-#{i}").should == 10**(6-i).to_f

- # ^ to_f to avoid Rational type

- }

- (1..9).each {|i|

- BigDecimal("100.#{i}").to_s.should =~ /\A0\.100#{i}E3\z/i

- BigDecimal("-100.#{i}").to_s.should =~ /\A-0\.100#{i}E3\z/i

- }

- end

- it "BigDecimal(Rational) with bigger-than-double numerator" do

- rational = 99999999999999999999/100r

- rational.numerator.should > 2**64

- BigDecimal(rational, 100).to_s.should == "0.99999999999999999999e18"

- it "accepts significant digits >= given precision" do

- suppress_warning do

- BigDecimal("3.1415923", 10).precs[1].should >= 10

- end

- end

- it "determines precision from initial value" do

- pi_string = "3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196442881097566593014782083152134043"

- suppress_warning {

- BigDecimal(pi_string).precs[1]

- }.should >= pi_string.size-1

- end

- it "ignores leading and trailing whitespace" do

- BigDecimal(" \t\n \r1234\t\r\n ").should == BigDecimal("1234")

- BigDecimal(" \t\n \rNaN \n").should.nan?

- BigDecimal(" \t\n \rInfinity \n").infinite?.should == 1

- BigDecimal(" \t\n \r-Infinity \n").infinite?.should == -1

- end

- it "coerces the value argument with #to_str" do

- initial = mock("value")

- initial.should_receive(:to_str).and_return("123")

- BigDecimal(initial).should == BigDecimal("123")

- end

- it "does not ignores trailing garbage" do

- -> { BigDecimal("123E45ruby") }.should raise_error(ArgumentError)

- -> { BigDecimal("123x45") }.should raise_error(ArgumentError)

- -> { BigDecimal("123.4%E5") }.should raise_error(ArgumentError)

- -> { BigDecimal("1E2E3E4E5E") }.should raise_error(ArgumentError)

- end

- it "raises ArgumentError for invalid strings" do

- -> { BigDecimal("ruby") }.should raise_error(ArgumentError)

- -> { BigDecimal(" \t\n \r-\t\t\tInfinity \n") }.should raise_error(ArgumentError)

- end

- it "allows omitting the integer part" do

- BigDecimal(".123").should == BigDecimal("0.123")

- end

- it "process underscores as Float()" do

- reference = BigDecimal("12345.67E89")

- BigDecimal("12_345.67E89").should == reference

- -> { BigDecimal("1_2_3_4_5_._6____7_E89") }.should raise_error(ArgumentError)

- -> { BigDecimal("12345_.67E_8__9_") }.should raise_error(ArgumentError)

- it "accepts NaN and [+-]Infinity" do

- BigDecimal("NaN").should.nan?

- pos_inf = BigDecimal("Infinity")

- neg_inf = BigDecimal("-Infinity")

- describe "with exception: false" do

- it "returns nil for invalid strings" do

- BigDecimal("invalid", exception: false).should be_nil

- BigDecimal("0invalid", exception: false).should be_nil

- BigDecimal("invalid0", exception: false).should be_nil

- BigDecimal("0.", exception: false).should be_nil

- end

- describe "accepts NaN and [+-]Infinity as Float values" do

- it "works without an explicit precision" do

- BigDecimal(Float::NAN).should.nan?

- pos_inf = BigDecimal(Float::INFINITY)

- pos_inf.should_not.finite?

- pos_inf.should > 0

- pos_inf.should == BigDecimal("+Infinity")

- neg_inf = BigDecimal(-Float::INFINITY)

- neg_inf.should_not.finite?

- neg_inf.should < 0

- end

- it "works with an explicit precision" do

- BigDecimal(Float::NAN, Float::DIG).should.nan?

- pos_inf = BigDecimal(Float::INFINITY, Float::DIG)

- pos_inf.should_not.finite?

- pos_inf.should > 0

- pos_inf.should == BigDecimal("+Infinity")

- neg_inf = BigDecimal(-Float::INFINITY, Float::DIG)

- neg_inf.should_not.finite?

- neg_inf.should < 0

- it "allows for [eEdD] as exponent separator" do

- reference = BigDecimal("12345.67E89")

- BigDecimal("12345.67e89").should == reference

- BigDecimal("12345.67E89").should == reference

- BigDecimal("12345.67d89").should == reference

- BigDecimal("12345.67D89").should == reference

- it "allows for varying signs" do

- reference = BigDecimal("123.456E1")

-

- BigDecimal("+123.456E1").should == reference

- BigDecimal("-123.456E1").should == -reference

- BigDecimal("123.456E+1").should == reference

- BigDecimal("12345.6E-1").should == reference

- BigDecimal("+123.456E+1").should == reference

- BigDecimal("+12345.6E-1").should == reference

- BigDecimal("-123.456E+1").should == -reference

- BigDecimal("-12345.6E-1").should == -reference

- it "raises ArgumentError when Float is used without precision" do

- -> { BigDecimal(1.0) }.should raise_error(ArgumentError)

- it "returns appropriate BigDecimal zero for signed zero" do

- BigDecimal(-0.0, Float::DIG).sign.should == -1

- BigDecimal(0.0, Float::DIG).sign.should == 1

- it "pre-coerces long integers" do

- BigDecimal(3).add(1 << 50, 3).should == BigDecimal('0.113e16')

- it "does not call to_s when calling inspect" do

- value = BigDecimal('44.44')

- value.to_s.should == '0.4444e2'

- value.inspect.should == '0.4444e2'

-

- ruby_exe( <<-'EOF').should == "cheese 0.4444e2"

- require 'bigdecimal'

- module BigDecimalOverride

- def to_s; "cheese"; end

- end

- BigDecimal.prepend BigDecimalOverride

- value = BigDecimal('44.44')

- print "#{value.to_s} #{value.inspect}"

- EOF

- describe "when interacting with Rational" do

- before :each do

- @a = BigDecimal('166.666666666')

- @b = Rational(500, 3)

- @c = @a - @b

- end

-

- # Check the input is as we understand it

-

- it "has the LHS print as expected" do

- @a.to_s.should == "0.166666666666e3"

- @a.to_f.to_s.should == "166.666666666"

- Float(@a).to_s.should == "166.666666666"

- end

-

- it "has the RHS print as expected" do

- @b.to_s.should == "500/3"

- @b.to_f.to_s.should == "166.66666666666666"

- Float(@b).to_s.should == "166.66666666666666"

- end

-

- it "has the expected precision on the LHS" do

- suppress_warning { @a.precs[0] }.should == 18

- end

-

- it "has the expected maximum precision on the LHS" do

- suppress_warning { @a.precs[1] }.should == 27

- end

-

- it "produces the expected result when done via Float" do

- (Float(@a) - Float(@b)).to_s.should == "-6.666596163995564e-10"

- end

- it "produces the expected result when done via to_f" do

- (@a.to_f - @b.to_f).to_s.should == "-6.666596163995564e-10"

- end

-

- # Check underlying methods work as we understand

-

- it "BigDecimal precision is the number of digits rounded up to a multiple of nine" do

- 1.upto(100) do |n|

- b = BigDecimal('4' * n)

- precs, _ = suppress_warning { b.precs }

- (precs >= 9).should be_true

- (precs >= n).should be_true

- (precs % 9).should == 0

- end

- suppress_warning { BigDecimal('NaN').precs[0] }.should == 9

- it "BigDecimal maximum precision is nine more than precision except for abnormals" do

- 1.upto(100) do |n|

- b = BigDecimal('4' * n)

- precs, max = suppress_warning { b.precs }

- max.should == precs + 9

- end

- suppress_warning { BigDecimal('NaN').precs[1] }.should == 9

- it "BigDecimal(Rational, 18) produces the result we expect" do

- BigDecimal(@b, 18).to_s.should == "0.166666666666666667e3"

- end

- it "BigDecimal(Rational, BigDecimal.precs[0]) produces the result we expect" do

- BigDecimal(@b, suppress_warning { @a.precs[0] }).to_s.should == "0.166666666666666667e3"

- end

- # Check the top-level expression works as we expect

- it "produces a BigDecimal" do

- @c.class.should == BigDecimal

- end

- it "produces the expected result" do

- @c.should == BigDecimal("-0.666667e-9")

- @c.to_s.should == "-0.666667e-9"

- end

- it "produces the correct class for other arithmetic operators" do

- (@a + @b).class.should == BigDecimal

- (@a * @b).class.should == BigDecimal

- (@a / @b).class.should == BigDecimal

- (@a % @b).class.should == BigDecimal

- end

-ruby_version_is ""..."3.4" do

- require 'bigdecimal'

-

- describe "BigDecimal#abs" do

- before :each do

- @one = BigDecimal("1")

- @zero = BigDecimal("0")

- @zero_pos = BigDecimal("+0")

- @zero_neg = BigDecimal("-0")

- @two = BigDecimal("2")

- @three = BigDecimal("3")

- @mixed = BigDecimal("1.23456789")

- @nan = BigDecimal("NaN")

- @infinity = BigDecimal("Infinity")

- @infinity_minus = BigDecimal("-Infinity")

- @one_minus = BigDecimal("-1")

- @frac_1 = BigDecimal("1E-99999")

- @frac_2 = BigDecimal("0.9E-99999")

- end

-

- it "returns the absolute value" do

- pos_int = BigDecimal("2E5555")

- neg_int = BigDecimal("-2E5555")

- pos_frac = BigDecimal("2E-9999")

- neg_frac = BigDecimal("-2E-9999")

- pos_int.abs.should == pos_int

- neg_int.abs.should == pos_int

- pos_frac.abs.should == pos_frac

- neg_frac.abs.should == pos_frac

- @one.abs.should == 1

- @two.abs.should == 2

- @three.abs.should == 3

- @mixed.abs.should == @mixed

- @one_minus.abs.should == @one

- end

- it "properly handles special values" do

- @infinity.abs.should == @infinity

- @infinity_minus.abs.should == @infinity

- @nan.abs.should.nan? # have to do it this way, since == doesn't work on NaN

- @zero.abs.should == 0

- @zero.abs.sign.should == BigDecimal::SIGN_POSITIVE_ZERO

- @zero_pos.abs.should == 0

- @zero_pos.abs.sign.should == BigDecimal::SIGN_POSITIVE_ZERO

- @zero_neg.abs.should == 0

- @zero_neg.abs.sign.should == BigDecimal::SIGN_POSITIVE_ZERO

- end

-ruby_version_is ""..."3.4" do

- require_relative 'fixtures/classes'

-

- require 'bigdecimal'

-

- describe "BigDecimal#add" do

-

- before :each do

- @one = BigDecimal("1")

- @zero = BigDecimal("0")

- @two = BigDecimal("2")

- @three = BigDecimal("3")

- @ten = BigDecimal("10")

- @eleven = BigDecimal("11")

- @nan = BigDecimal("NaN")

- @infinity = BigDecimal("Infinity")

- @infinity_minus = BigDecimal("-Infinity")

- @one_minus = BigDecimal("-1")

- @frac_1 = BigDecimal("1E-99999")

- @frac_2 = BigDecimal("0.9E-99999")

- @frac_3 = BigDecimal("12345E10")

- @frac_4 = BigDecimal("98765E10")

- @dot_ones = BigDecimal("0.1111111111")

- end

- it "returns a + b with given precision" do

- # documentation states that precision is optional, but it ain't,

- @two.add(@one, 1).should == @three

- @one .add(@two, 1).should == @three

- @one.add(@one_minus, 1).should == @zero

- @ten.add(@one, 2).should == @eleven

- @zero.add(@one, 1).should == @one

- @frac_2.add(@frac_1, 10000).should == BigDecimal("1.9E-99999")

- @frac_1.add(@frac_1, 10000).should == BigDecimal("2E-99999")

- @frac_3.add(@frac_4, 0).should == BigDecimal("0.11111E16")

- @frac_3.add(@frac_4, 1).should == BigDecimal("0.1E16")

- @frac_3.add(@frac_4, 2).should == BigDecimal("0.11E16")

- @frac_3.add(@frac_4, 3).should == BigDecimal("0.111E16")

- @frac_3.add(@frac_4, 4).should == BigDecimal("0.1111E16")

- @frac_3.add(@frac_4, 5).should == BigDecimal("0.11111E16")

- @frac_3.add(@frac_4, 6).should == BigDecimal("0.11111E16")

- end

- it "returns a + [Fixnum value] with given precision" do

- (1..10).each {|precision|

- @dot_ones.add(0, precision).should == BigDecimal("0." + "1" * precision)

- }

- BigDecimal("0.88").add(0, 1).should == BigDecimal("0.9")

- end

- it "returns a + [Bignum value] with given precision" do

- bignum = 10000000000000000000

- (1..20).each {|precision|

- @dot_ones.add(bignum, precision).should == BigDecimal("0.1E20")

- }

- (21..30).each {|precision|

- @dot_ones.add(bignum, precision).should == BigDecimal(

- "0.10000000000000000000" + "1" * (precision - 20) + "E20")

- }

- # TODO:

- # https://blade.ruby-lang.org/ruby-core/17374

- #

- # This doesn't work on MRI and looks like a bug to me:

- # one can use BigDecimal + Float, but not Bigdecimal.add(Float)

- #

- # it "returns a + [Float value] with given precision" do

- # (1..10).each {|precision|

- # @dot_ones.add(0.0, precision).should == BigDecimal("0." + "1" * precision)

- # }

- #

- # BigDecimal("0.88").add(0.0, 1).should == BigDecimal("0.9")

- # end

-

- describe "with Object" do

- it "tries to coerce the other operand to self" do

- object = mock("Object")

- object.should_receive(:coerce).with(@frac_3).and_return([@frac_3, @frac_4])

- @frac_3.add(object, 1).should == BigDecimal("0.1E16")

- end

- describe "with Rational" do

- it "produces a BigDecimal" do

- (@three + Rational(500, 2)).should == BigDecimal("0.253e3")

- end

- it "favors the precision specified in the second argument over the global limit" do

- BigDecimalSpecs.with_limit(1) do

- BigDecimal('0.888').add(@zero, 3).should == BigDecimal('0.888')

- end

-

- BigDecimalSpecs.with_limit(2) do

- BigDecimal('0.888').add(@zero, 1).should == BigDecimal('0.9')

- end

- it "uses the current rounding mode if rounding is needed" do

- BigDecimalSpecs.with_rounding(BigDecimal::ROUND_UP) do

- BigDecimal('0.111').add(@zero, 1).should == BigDecimal('0.2')

- BigDecimal('-0.111').add(@zero, 1).should == BigDecimal('-0.2')

- end

- BigDecimalSpecs.with_rounding(BigDecimal::ROUND_DOWN) do

- BigDecimal('0.999').add(@zero, 1).should == BigDecimal('0.9')

- BigDecimal('-0.999').add(@zero, 1).should == BigDecimal('-0.9')

- end

- BigDecimalSpecs.with_rounding(BigDecimal::ROUND_HALF_UP) do

- BigDecimal('0.85').add(@zero, 1).should == BigDecimal('0.9')

- BigDecimal('-0.85').add(@zero, 1).should == BigDecimal('-0.9')

- end

- BigDecimalSpecs.with_rounding(BigDecimal::ROUND_HALF_DOWN) do

- BigDecimal('0.85').add(@zero, 1).should == BigDecimal('0.8')

- BigDecimal('-0.85').add(@zero, 1).should == BigDecimal('-0.8')

- end

- BigDecimalSpecs.with_rounding(BigDecimal::ROUND_HALF_EVEN) do

- BigDecimal('0.75').add(@zero, 1).should == BigDecimal('0.8')

- BigDecimal('0.85').add(@zero, 1).should == BigDecimal('0.8')

- BigDecimal('-0.75').add(@zero, 1).should == BigDecimal('-0.8')

- BigDecimal('-0.85').add(@zero, 1).should == BigDecimal('-0.8')

- end

- BigDecimalSpecs.with_rounding(BigDecimal::ROUND_CEILING) do

- BigDecimal('0.85').add(@zero, 1).should == BigDecimal('0.9')

- BigDecimal('-0.85').add(@zero, 1).should == BigDecimal('-0.8')

- end

- BigDecimalSpecs.with_rounding(BigDecimal::ROUND_FLOOR) do

- BigDecimal('0.85').add(@zero, 1).should == BigDecimal('0.8')

- BigDecimal('-0.85').add(@zero, 1).should == BigDecimal('-0.9')

- end

-

- it "uses the default ROUND_HALF_UP rounding if it wasn't explicitly changed" do

-

- it "returns NaN if NaN is involved" do

- @one.add(@nan, 10000).should.nan?

- @nan.add(@one, 1).should.nan?

-

- it "returns Infinity or -Infinity if these are involved" do

- @zero.add(@infinity, 1).should == @infinity

- @frac_2.add(@infinity, 1).should == @infinity

- @one_minus.add(@infinity, 1).should == @infinity

- @two.add(@infinity, 1).should == @infinity

-

- @zero.add(@infinity_minus, 1).should == @infinity_minus

- @frac_2.add(@infinity_minus, 1).should == @infinity_minus

- @one_minus.add(@infinity_minus, 1).should == @infinity_minus

- @two.add(@infinity_minus, 1).should == @infinity_minus

-

- @infinity.add(@zero, 1).should == @infinity

- @infinity.add(@frac_2, 1).should == @infinity

- @infinity.add(@one_minus, 1).should == @infinity

- @infinity.add(@two, 1).should == @infinity

-

- @infinity_minus.add(@zero, 1).should == @infinity_minus

- @infinity_minus.add(@frac_2, 1).should == @infinity_minus

- @infinity_minus.add(@one_minus, 1).should == @infinity_minus

- @infinity_minus.add(@two, 1).should == @infinity_minus

-

- @infinity.add(@infinity, 10000).should == @infinity

- @infinity_minus.add(@infinity_minus, 10000).should == @infinity_minus

-

- it "returns NaN if Infinity + (- Infinity)" do

- @infinity.add(@infinity_minus, 10000).should.nan?

- @infinity_minus.add(@infinity, 10000).should.nan?

-

- it "raises TypeError when adds nil" do

- -> {

- @one.add(nil, 10)

- }.should raise_error(TypeError)

- -> {

- @one.add(nil, 0)

- }.should raise_error(TypeError)

- it "raises TypeError when precision parameter is nil" do

- -> {

- @one.add(@one, nil)

- }.should raise_error(TypeError)

- end

- it "raises ArgumentError when precision parameter is negative" do

- -> {

- @one.add(@one, -10)

- }.should raise_error(ArgumentError)

- end

-ruby_version_is ""..."3.4" do

- require_relative 'shared/eql'

-

- describe "BigDecimal#===" do

- it_behaves_like :bigdecimal_eql, :===

- end

-ruby_version_is ""..."3.4" do

- require 'bigdecimal'

-

- describe "BigDecimal#ceil" do

- before :each do

- @zero = BigDecimal("0")

- @one = BigDecimal("1")

- @three = BigDecimal("3")

- @four = BigDecimal("4")

- @mixed = BigDecimal("1.23456789")

- @mixed_big = BigDecimal("1.23456789E100")

- @pos_int = BigDecimal("2E5555")

- @neg_int = BigDecimal("-2E5555")

- @pos_frac = BigDecimal("2E-9999")

- @neg_frac = BigDecimal("-2E-9999")

-

- @infinity = BigDecimal("Infinity")

- @infinity_neg = BigDecimal("-Infinity")

- @nan = BigDecimal("NaN")

- @zero_pos = BigDecimal("+0")

- @zero_neg = BigDecimal("-0")

- end

- it "returns an Integer, if n is unspecified" do

- @mixed.ceil.kind_of?(Integer).should == true

- end

- it "returns a BigDecimal, if n is specified" do

- @pos_int.ceil(2).kind_of?(BigDecimal).should == true

- end

- it "returns the smallest integer greater or equal to self, if n is unspecified" do

- @pos_int.ceil.should == @pos_int

- @neg_int.ceil.should == @neg_int

- @pos_frac.ceil.should == BigDecimal("1")

- @neg_frac.ceil.should == @zero

- @zero.ceil.should == 0

- @zero_pos.ceil.should == @zero_pos

- @zero_neg.ceil.should == @zero_neg

-

-

- BigDecimal('2.3').ceil.should == 3

- BigDecimal('2.5').ceil.should == 3

- BigDecimal('2.9999').ceil.should == 3

- BigDecimal('-2.3').ceil.should == -2

- BigDecimal('-2.5').ceil.should == -2

- BigDecimal('-2.9999').ceil.should == -2

- end

- it "raise exception, if self is special value" do

- -> { @infinity.ceil }.should raise_error(FloatDomainError)

- -> { @infinity_neg.ceil }.should raise_error(FloatDomainError)

- -> { @nan.ceil }.should raise_error(FloatDomainError)

- end

- it "returns n digits right of the decimal point if given n > 0" do

- @mixed.ceil(1).should == BigDecimal("1.3")

- @mixed.ceil(5).should == BigDecimal("1.23457")

-

- BigDecimal("-0.03").ceil(1).should == BigDecimal("0")

- BigDecimal("0.03").ceil(1).should == BigDecimal("0.1")

-

- BigDecimal("23.45").ceil(0).should == BigDecimal('24')

- BigDecimal("23.45").ceil(1).should == BigDecimal('23.5')

- BigDecimal("23.45").ceil(2).should == BigDecimal('23.45')

-

- BigDecimal("-23.45").ceil(0).should == BigDecimal('-23')

- BigDecimal("-23.45").ceil(1).should == BigDecimal('-23.4')

- BigDecimal("-23.45").ceil(2).should == BigDecimal('-23.45')

-

- BigDecimal("2E-10").ceil(0).should == @one

- BigDecimal("2E-10").ceil(9).should == BigDecimal('1E-9')

- BigDecimal("2E-10").ceil(10).should == BigDecimal('2E-10')

- BigDecimal("2E-10").ceil(11).should == BigDecimal('2E-10')

-

- (1..10).each do |n|

- # 0.4, 0.34, 0.334, etc.

- (@one.div(@three,20)).ceil(n).should == BigDecimal("0.#{'3'*(n-1)}4")

- # 1.4, 1.34, 1.334, etc.

- (@four.div(@three,20)).ceil(n).should == BigDecimal("1.#{'3'*(n-1)}4")

- (BigDecimal('31').div(@three,20)).ceil(n).should == BigDecimal("10.#{'3'*(n-1)}4")

- end

- (1..10).each do |n|

- # -0.4, -0.34, -0.334, etc.

- ([email protected](@three,20)).ceil(n).should == BigDecimal("-0.#{'3'* n}")

- end

- (1..10).each do |n|

- (@three.div(@one,20)).ceil(n).should == @three

- end

- (1..10).each do |n|

- ([email protected](@one,20)).ceil(n).should == -@three

- end

- end

- it "sets n digits left of the decimal point to 0, if given n < 0" do

- BigDecimal("13345.234").ceil(-2).should == BigDecimal("13400.0")

- @mixed_big.ceil(-99).should == BigDecimal("0.13E101")

- @mixed_big.ceil(-100).should == BigDecimal("0.2E101")

- @mixed_big.ceil(-95).should == BigDecimal("0.123457E101")

- BigDecimal("1E10").ceil(-30).should == BigDecimal('1E30')

- BigDecimal("-1E10").ceil(-30).should == @zero

-ruby_version_is ""..."3.4" do

- require_relative 'shared/clone'

-

- describe "BigDecimal#dup" do

- it_behaves_like :bigdecimal_clone, :clone

- end

-ruby_version_is ""..."3.4" do

- require 'bigdecimal'

- describe "BigDecimal#coerce" do

-

- it "returns [other, self] both as BigDecimal" do

- one = BigDecimal("1.0")

- five_point_28 = BigDecimal("5.28")

- zero_minus = BigDecimal("-0.0")

- some_value = 32434234234234234234

-

- BigDecimal("1.2").coerce(1).should == [one, BigDecimal("1.2")]

- five_point_28.coerce(1.0).should == [one, BigDecimal("5.28")]

- one.coerce(one).should == [one, one]

- one.coerce(2.5).should == [2.5, one]

- BigDecimal("1").coerce(3.14).should == [3.14, one]

- a, b = zero_minus.coerce(some_value)

- a.should == BigDecimal(some_value.to_s)

- b.should == zero_minus

- a, b = one.coerce(some_value)

- a.should == BigDecimal(some_value.to_s)

- b.to_f.should be_close(1.0, TOLERANCE) # can we take out the to_f once BigDecimal#- is implemented?

- b.should == one

- end

-ruby_version_is ""..."3.4" do

- require 'bigdecimal'

- describe "BigDecimal#<=>" do

- before :each do

- @zero = BigDecimal("0")

- @zero_pos = BigDecimal("+0")

- @zero_neg = BigDecimal("-0")

- @mixed = BigDecimal("1.23456789")

- @mixed_big = BigDecimal("1.23456789E100")

- @pos_int = BigDecimal("2E5555")

- @neg_int = BigDecimal("-2E5555")

- @pos_frac = BigDecimal("2E-9999")

- @neg_frac = BigDecimal("-2E-9999")

-

- @int_mock = mock('123')

- class << @int_mock

- def coerce(other)

- return [other, BigDecimal('123')]

- end

- def >=(other)

- BigDecimal('123') >= other

- end

- @values = [@mixed, @pos_int, @neg_int, @pos_frac, @neg_frac,

- -2**32, -2**31, -2**30, -2**16, -2**8, -100, -10, -1,

- @zero , 1, 2, 10, 2**8, 2**16, 2**32, @int_mock, @zero_pos, @zero_neg]

- @infinity = BigDecimal("Infinity")

- @infinity_neg = BigDecimal("-Infinity")

- @nan = BigDecimal("NaN")

- end

- it "returns 0 if a == b" do

- (@pos_int <=> @pos_int).should == 0

- (@neg_int <=> @neg_int).should == 0

- (@pos_frac <=> @pos_frac).should == 0

- (@neg_frac <=> @neg_frac).should == 0

- (@zero <=> @zero).should == 0

- (@infinity <=> @infinity).should == 0

- (@infinity_neg <=> @infinity_neg).should == 0

- end

- it "returns 1 if a > b" do

- (@pos_int <=> @neg_int).should == 1

- (@pos_frac <=> @neg_frac).should == 1

- (@pos_frac <=> @zero).should == 1

- @values.each { |val|

- (@infinity <=> val).should == 1

- }

- end

- it "returns -1 if a < b" do

- (@zero <=> @pos_frac).should == -1

- (@neg_int <=> @pos_frac).should == -1

- (@pos_frac <=> @pos_int).should == -1

- @values.each { |val|

- (@infinity_neg <=> val).should == -1

- }

- end

- it "returns nil if NaN is involved" do

- @values += [@infinity, @infinity_neg, @nan]

- @values << nil

- @values << Object.new

- @values.each { |val|

- (@nan <=> val).should == nil

- }

- end

- it "returns nil if the argument is nil" do

- (@zero <=> nil).should == nil

- (@infinity <=> nil).should == nil

- (@infinity_neg <=> nil).should == nil

- (@mixed <=> nil).should == nil

- (@pos_int <=> nil).should == nil

- (@neg_frac <=> nil).should == nil

- end

-ruby_version_is ""..."3.4" do

- require 'bigdecimal'

-

- describe "BigDecimal constants" do

- it "defines a VERSION value" do

- BigDecimal.const_defined?(:VERSION).should be_true

- end

- it "has a BASE value" do

- # The actual one is decided based on HAVE_INT64_T in MRI,

- # which is hard to check here.

- [10000, 1000000000].should include(BigDecimal::BASE)

- end

- it "has a NaN value" do

- BigDecimal::NAN.nan?.should be_true

- end

- it "has an INFINITY value" do

- BigDecimal::INFINITY.infinite?.should == 1

- end

- describe "exception-related constants" do

- [

- [:EXCEPTION_ALL, 0xff],

- [:EXCEPTION_INFINITY, 0x01],

- [:EXCEPTION_NaN, 0x02],

- [:EXCEPTION_UNDERFLOW, 0x04],

- [:EXCEPTION_OVERFLOW, 0x01],

- [:EXCEPTION_ZERODIVIDE, 0x10]

- ].each do |const, value|

- it "has a #{const} value" do

- BigDecimal.const_get(const).should == value

- end

- describe "rounding-related constants" do

- [

- [:ROUND_MODE, 0x100],

- [:ROUND_UP, 1],

- [:ROUND_DOWN, 2],

- [:ROUND_HALF_UP, 3],

- [:ROUND_HALF_DOWN, 4],

- [:ROUND_CEILING, 5],

- [:ROUND_FLOOR, 6],

- [:ROUND_HALF_EVEN, 7]

- ].each do |const, value|

- it "has a #{const} value" do

- BigDecimal.const_get(const).should == value

- end

- describe "sign-related constants" do

- [

- [:SIGN_NaN, 0],

- [:SIGN_POSITIVE_ZERO, 1],

- [:SIGN_NEGATIVE_ZERO, -1],

- [:SIGN_POSITIVE_FINITE, 2],

- [:SIGN_NEGATIVE_FINITE, -2],

- [:SIGN_POSITIVE_INFINITE, 3],

- [:SIGN_NEGATIVE_INFINITE, -3]

- ].each do |const, value|

- it "has a #{const} value" do

- BigDecimal.const_get(const).should == value

- end

-ruby_version_is ""..."3.4" do

- require_relative 'shared/quo'

- require 'bigdecimal'

-

- describe "BigDecimal#div with precision set to 0" do

- # TODO: figure out if there is a better way to do these

- # shared specs rather than sending [0]. See other specs

- # that share :bigdecimal_quo.

- it_behaves_like :bigdecimal_quo, :div, [0]

- describe "BigDecimal#div" do

-

- before :each do

- @one = BigDecimal("1")

- @zero = BigDecimal("0")

- @zero_plus = BigDecimal("+0")

- @zero_minus = BigDecimal("-0")

- @two = BigDecimal("2")

- @three = BigDecimal("3")

- @nan = BigDecimal("NaN")

- @infinity = BigDecimal("Infinity")

- @infinity_minus = BigDecimal("-Infinity")

- @one_minus = BigDecimal("-1")

- @frac_1 = BigDecimal("1E-99999")

- @frac_2 = BigDecimal("0.9E-99999")

- end

-

- it "returns a / b with optional precision" do

- @two.div(@one).should == @two

- @one.div(@two).should == @zero

- # ^^ is this really intended for a class with arbitrary precision?

- @one.div(@two, 1).should == BigDecimal("0.5")

- @one.div(@one_minus).should == @one_minus

- @one_minus.div(@one_minus).should == @one

- @frac_2.div(@frac_1, 1).should == BigDecimal("0.9")

- @frac_1.div(@frac_1).should == @one

-

- res = "0." + "3" * 1000

- (1..100).each { |idx|

- @one.div(@three, idx).to_s("F").should == "0." + res[2, idx]

- }

- end

- describe "with Object" do

- it "tries to coerce the other operand to self" do

- object = mock("Object")

- object.should_receive(:coerce).with(@one).and_return([@one, @two])

- @one.div(object).should == @zero

- end

- it "raises FloatDomainError if NaN is involved" do

- -> { @one.div(@nan) }.should raise_error(FloatDomainError)

- -> { @nan.div(@one) }.should raise_error(FloatDomainError)

- -> { @nan.div(@nan) }.should raise_error(FloatDomainError)

- end

- it "returns 0 if divided by Infinity and no precision given" do

- @zero.div(@infinity).should == 0

- @frac_2.div(@infinity).should == 0

- end

- it "returns 0 if divided by Infinity with given precision" do

- @zero.div(@infinity, 0).should == 0

- @frac_2.div(@infinity, 1).should == 0

- @zero.div(@infinity, 100000).should == 0

- @frac_2.div(@infinity, 100000).should == 0

- end

- it "raises ZeroDivisionError if divided by zero and no precision given" do

- -> { @one.div(@zero) }.should raise_error(ZeroDivisionError)

- -> { @one.div(@zero_plus) }.should raise_error(ZeroDivisionError)

- -> { @one.div(@zero_minus) }.should raise_error(ZeroDivisionError)

- -> { @zero.div(@zero) }.should raise_error(ZeroDivisionError)

- -> { @zero_minus.div(@zero_plus) }.should raise_error(ZeroDivisionError)

- -> { @zero_minus.div(@zero_minus) }.should raise_error(ZeroDivisionError)

- -> { @zero_plus.div(@zero_minus) }.should raise_error(ZeroDivisionError)

- end

- it "returns NaN if zero is divided by zero" do

- @zero.div(@zero, 0).should.nan?

- @zero_minus.div(@zero_plus, 0).should.nan?

- @zero_plus.div(@zero_minus, 0).should.nan?

- @zero.div(@zero, 10).should.nan?

- @zero_minus.div(@zero_plus, 10).should.nan?

- @zero_plus.div(@zero_minus, 10).should.nan?

- end

- it "raises FloatDomainError if (+|-) Infinity divided by 1 and no precision given" do

- -> { @infinity_minus.div(@one) }.should raise_error(FloatDomainError)

- -> { @infinity.div(@one) }.should raise_error(FloatDomainError)

- -> { @infinity_minus.div(@one_minus) }.should raise_error(FloatDomainError)

- end

- it "returns (+|-)Infinity if (+|-)Infinity by 1 and precision given" do

- @infinity_minus.div(@one, 0).should == @infinity_minus

- @infinity.div(@one, 0).should == @infinity

- @infinity_minus.div(@one_minus, 0).should == @infinity

- end

- it "returns NaN if Infinity / ((+|-) Infinity)" do

- @infinity.div(@infinity_minus, 100000).should.nan?

- @infinity_minus.div(@infinity, 1).should.nan?

- end

- end

-ruby_version_is ""..."3.4" do

- require_relative 'shared/quo'

- require 'bigdecimal'

- describe "BigDecimal#/" do

- it_behaves_like :bigdecimal_quo, :/, []

-

- before :each do

- @three = BigDecimal("3")

- end

- describe "with Rational" do

- it "produces a BigDecimal" do

- (@three / Rational(500, 2)).should == BigDecimal("0.12e-1")

- end

-

-ruby_version_is ""..."3.4" do

- require_relative 'shared/modulo'

- require 'bigdecimal'

-

- module DivmodSpecs

- def self.check_both_nan(array)

- array.length.should == 2

- array[0].should.nan?

- array[1].should.nan?

- end

- def self.check_both_bigdecimal(array)

- array.length.should == 2

- array[0].kind_of?(BigDecimal).should == true

- array[1].kind_of?(BigDecimal).should == true

- end

- # TODO: figure out a way to do the shared specs with helpers instead

- # of spec'ing a method that does not really exist

- describe "BigDecimal#mod_part_of_divmod" do

- # BigDecimal#divmod[1] behaves exactly like #modulo

- before :all do

- class BigDecimal

- def mod_part_of_divmod(arg)

- divmod(arg)[1]

- end

- after :all do

- class BigDecimal

- undef mod_part_of_divmod

- end

- it_behaves_like :bigdecimal_modulo, :mod_part_of_divmod

- it "raises ZeroDivisionError if other is zero" do

- bd5667 = BigDecimal("5667.19")

- -> { bd5667.mod_part_of_divmod(0) }.should raise_error(ZeroDivisionError)

- -> { bd5667.mod_part_of_divmod(BigDecimal("0")) }.should raise_error(ZeroDivisionError)

- -> { @zero.mod_part_of_divmod(@zero) }.should raise_error(ZeroDivisionError)

- end

- describe "BigDecimal#divmod" do

-

- before :each do

- @a = BigDecimal("42.00000000000000000001")

-

- @zero = BigDecimal("0")

- @zero_pos = BigDecimal("+0")

- @zero_neg = BigDecimal("-0")

-

- @one = BigDecimal("1")

- @mixed = BigDecimal("1.23456789")

- @pos_int = BigDecimal("2E5555")

- @neg_int = BigDecimal("-2E5555")

- @pos_frac = BigDecimal("2E-9999")

- @neg_frac = BigDecimal("-2E-9999")

- @nan = BigDecimal("NaN")

- @infinity = BigDecimal("Infinity")

- @infinity_minus = BigDecimal("-Infinity")

- @one_minus = BigDecimal("-1")

- @frac_1 = BigDecimal("1E-99999")

- @frac_2 = BigDecimal("0.9E-99999")

-

- @special_vals = [@infinity, @infinity_minus, @nan]

- @regular_vals = [

- @one, @mixed, @pos_int, @neg_int, @pos_frac,

- @neg_frac, @one_minus, @frac_1, @frac_2]

- @zeroes = [@zero, @zero_pos, @zero_neg]

- end

- it "divides value, returns an array" do

- res = @a.divmod(5)

- res.kind_of?(Array).should == true

- end

- it "array contains quotient and modulus as BigDecimal" do

- res = @a.divmod(5)

- DivmodSpecs.check_both_bigdecimal(res)

- res[0].should == BigDecimal('0.8E1')

- res[1].should == BigDecimal('2.00000000000000000001')

- BigDecimal('1').divmod(BigDecimal('2')).should == [0, 1]

- BigDecimal('2').divmod(BigDecimal('1')).should == [2, 0]

- BigDecimal('1').divmod(BigDecimal('-2')).should == [-1, -1]

- BigDecimal('2').divmod(BigDecimal('-1')).should == [-2, 0]

- BigDecimal('-1').divmod(BigDecimal('2')).should == [-1, 1]

- BigDecimal('-2').divmod(BigDecimal('1')).should == [-2, 0]

- end

- it "can be reversed with * and +" do

- # Example taken from BigDecimal documentation

- a = BigDecimal("42")

- b = BigDecimal("9")

- q, m = a.divmod(b)

- c = q * b + m

- a.should == c

-

- values = [@one, @one_minus, BigDecimal('2'), BigDecimal('-2'),

- BigDecimal('5'), BigDecimal('-5'), BigDecimal('10'), BigDecimal('-10'),

- BigDecimal('20'), BigDecimal('-20'), BigDecimal('100'), BigDecimal('-100'),

- BigDecimal('1.23456789E10'), BigDecimal('-1.23456789E10')

- ]

-

- # TODO: file MRI bug:

- # BigDecimal('1').divmod(BigDecimal('3E-9'))[0] #=> 0.3E9,

- # but really should be 0.333333333E9

- values << BigDecimal('1E-10')

- values << BigDecimal('-1E-10')

- values << BigDecimal('2E55')

- values << BigDecimal('-2E55')

- values << BigDecimal('2E-5555')

- values << BigDecimal('-2E-5555')

-

-

- values_and_zeroes = values + @zeroes

- values_and_zeroes.each do |val1|

- values.each do |val2|

- res = val1.divmod(val2)

- DivmodSpecs.check_both_bigdecimal(res)

- res[0].should == ((val1/val2).floor)

- res[1].should == (val1 - res[0] * val2)

- end

- it "returns an array of two NaNs if NaN is involved" do

- (@special_vals + @regular_vals + @zeroes).each do |val|

- DivmodSpecs.check_both_nan(val.divmod(@nan))

- DivmodSpecs.check_both_nan(@nan.divmod(val))

- end

- it "raises ZeroDivisionError if the divisor is zero" do

- (@special_vals + @regular_vals + @zeroes - [@nan]).each do |val|

- @zeroes.each do |zero|

- -> { val.divmod(zero) }.should raise_error(ZeroDivisionError)

- end

- it "returns an array of Infinity and NaN if the dividend is Infinity" do

- @regular_vals.each do |val|

- array = @infinity.divmod(val)

- array.length.should == 2

- array[0].infinite?.should == (val > 0 ? 1 : -1)

- array[1].should.nan?

- end

- it "returns an array of zero and the dividend if the divisor is Infinity" do

- @regular_vals.each do |val|

- array = val.divmod(@infinity)

- array.length.should == 2

- array[0].should == @zero

- array[1].should == val

- end

- it "returns an array of two zero if the dividend is zero" do

- @zeroes.each do |zero|

- @regular_vals.each do |val|

- zero.divmod(val).should == [@zero, @zero]

- end

- it "raises TypeError if the argument cannot be coerced to BigDecimal" do

- -> {

- @one.divmod('1')

- }.should raise_error(TypeError)

- end

-

-ruby_version_is ""..."3.4" do

- require 'bigdecimal'

-

- describe "BigDecimal.double_fig" do

- # The result depends on the CPU and OS

- it "returns the number of digits a Float number is allowed to have" do

- BigDecimal.double_fig.should_not == nil

- end

-ruby_version_is ""..."3.4" do

- require_relative 'shared/clone'

-

- describe "BigDecimal#dup" do

- it_behaves_like :bigdecimal_clone, :dup

- end

-ruby_version_is ""..."3.4" do

- require_relative 'shared/eql'

-

- describe "BigDecimal#eql?" do

- it_behaves_like :bigdecimal_eql, :eql?

- end

-ruby_version_is ""..."3.4" do

- require_relative 'shared/eql'

-

- describe "BigDecimal#==" do

- it_behaves_like :bigdecimal_eql, :==

- end

-ruby_version_is ""..."3.4" do

- require_relative 'shared/power'

- require 'bigdecimal'

-

- describe "BigDecimal#**" do

- it_behaves_like :bigdecimal_power, :**

- end

-

- describe "BigDecimal#exponent" do

- it "returns an Integer" do

- BigDecimal("2E100000000").exponent.kind_of?(Integer).should == true

- BigDecimal("2E-999").exponent.kind_of?(Integer).should == true

- end

- it "is n if number can be represented as 0.xxx*10**n" do

- BigDecimal("2E1000").exponent.should == 1001

- BigDecimal("1234567E10").exponent.should == 17

- end

- it "returns 0 if self is 0" do

- BigDecimal("0").exponent.should == 0

- BigDecimal("+0").exponent.should == 0

- BigDecimal("-0").exponent.should == 0

- end

-ruby_version_is ""..."3.4" do

- require 'bigdecimal'

-

- describe "BigDecimal#finite?" do

- before :each do

- @one = BigDecimal("1")

- @zero = BigDecimal("0")

- @zero_pos = BigDecimal("+0")

- @zero_neg = BigDecimal("-0")

- @two = BigDecimal("2")

- @three = BigDecimal("3")

- @nan = BigDecimal("NaN")

- @infinity = BigDecimal("Infinity")

- @infinity_minus = BigDecimal("-Infinity")

- @one_minus = BigDecimal("-1")

- @frac_1 = BigDecimal("1E-99999")

- @frac_2 = BigDecimal("0.9E-99999")

- @big = BigDecimal("2E40001")

- @finite_vals = [@one, @zero, @zero_pos, @zero_neg, @two,

- @three, @frac_1, @frac_2, @big, @one_minus]

- end

- it "is false if Infinity or NaN" do

- @infinity.should_not.finite?

- @infinity_minus.should_not.finite?

- @nan.should_not.finite?

- end

- it "returns true for finite values" do

- @finite_vals.each do |val|

- val.should.finite?

- end

-

-ruby_version_is ""..."3.4" do

- require 'bigdecimal'

-

- describe "BigDecimal#fix" do

- before :each do

- @zero = BigDecimal("0")

- @mixed = BigDecimal("1.23456789")

- @pos_int = BigDecimal("2E5555")

- @neg_int = BigDecimal("-2E5555")

- @pos_frac = BigDecimal("2E-9999")

- @neg_frac = BigDecimal("-2E-9999")

-

- @infinity = BigDecimal("Infinity")

- @infinity_neg = BigDecimal("-Infinity")

- @nan = BigDecimal("NaN")

- @zero_pos = BigDecimal("+0")

- @zero_neg = BigDecimal("-0")

- end

-

- it "returns a BigDecimal" do

- BigDecimal("2E100000000").fix.kind_of?(BigDecimal).should == true

- BigDecimal("2E-999").kind_of?(BigDecimal).should == true

- it "returns the integer part of the absolute value" do

- a = BigDecimal("2E1000")

- a.fix.should == a

- b = BigDecimal("-2E1000")

- b.fix.should == b

- BigDecimal("0.123456789E5").fix.should == BigDecimal("0.12345E5")

- BigDecimal("-0.123456789E5").fix.should == BigDecimal("-0.12345E5")

- end

- it "correctly handles special values" do

- @infinity.fix.should == @infinity

- @infinity_neg.fix.should == @infinity_neg

- @nan.fix.should.nan?

- end

- it "returns 0 if the absolute value is < 1" do

- BigDecimal("0.99999").fix.should == 0

- BigDecimal("-0.99999").fix.should == 0

- BigDecimal("0.000000001").fix.should == 0

- BigDecimal("-0.00000001").fix.should == 0

- BigDecimal("-1000000").fix.should_not == 0

- @zero.fix.should == 0

- @zero_pos.fix.should == @zero_pos

- @zero_neg.fix.should == @zero_neg

- end

- it "does not allow any arguments" do

- -> {

- @mixed.fix(10)

- }.should raise_error(ArgumentError)

- end

-ruby_version_is ""..."3.4" do

- require 'bigdecimal'

- describe "BigDecimal#floor" do

- before :each do

- @one = BigDecimal("1")

- @three = BigDecimal("3")

- @four = BigDecimal("4")

- @zero = BigDecimal("0")

- @mixed = BigDecimal("1.23456789")

- @mixed_big = BigDecimal("1.23456789E100")

- @pos_int = BigDecimal("2E5555")

- @neg_int = BigDecimal("-2E5555")

- @pos_frac = BigDecimal("2E-9999")

- @neg_frac = BigDecimal("-2E-9999")

-

- @infinity = BigDecimal("Infinity")

- @infinity_neg = BigDecimal("-Infinity")

- @nan = BigDecimal("NaN")

- @zero_pos = BigDecimal("+0")

- @zero_neg = BigDecimal("-0")

- end

- it "returns the greatest integer smaller or equal to self" do

- @pos_int.floor.should == @pos_int

- @neg_int.floor.should == @neg_int

- @pos_frac.floor.should == @zero

- @neg_frac.floor.should == BigDecimal("-1")

- @zero.floor.should == 0

- @zero_pos.floor.should == @zero_pos

- @zero_neg.floor.should == @zero_neg

- BigDecimal('2.3').floor.should == 2

- BigDecimal('2.5').floor.should == 2

- BigDecimal('2.9999').floor.should == 2

- BigDecimal('-2.3').floor.should == -3

- BigDecimal('-2.5').floor.should == -3

- BigDecimal('-2.9999').floor.should == -3

- BigDecimal('0.8').floor.should == 0

- BigDecimal('-0.8').floor.should == -1

- end

- it "raise exception, if self is special value" do

- -> { @infinity.floor }.should raise_error(FloatDomainError)

- -> { @infinity_neg.floor }.should raise_error(FloatDomainError)

- -> { @nan.floor }.should raise_error(FloatDomainError)

- end

- it "returns n digits right of the decimal point if given n > 0" do

- @mixed.floor(1).should == BigDecimal("1.2")

- @mixed.floor(5).should == BigDecimal("1.23456")

- BigDecimal("-0.03").floor(1).should == BigDecimal("-0.1")

- BigDecimal("0.03").floor(1).should == BigDecimal("0")

- BigDecimal("23.45").floor(0).should == BigDecimal('23')

- BigDecimal("23.45").floor(1).should == BigDecimal('23.4')

- BigDecimal("23.45").floor(2).should == BigDecimal('23.45')

- BigDecimal("-23.45").floor(0).should == BigDecimal('-24')

- BigDecimal("-23.45").floor(1).should == BigDecimal('-23.5')

- BigDecimal("-23.45").floor(2).should == BigDecimal('-23.45')

- BigDecimal("2E-10").floor(0).should == @zero

- BigDecimal("2E-10").floor(9).should == @zero

- BigDecimal("2E-10").floor(10).should == BigDecimal('2E-10')

- BigDecimal("2E-10").floor(11).should == BigDecimal('2E-10')

- (1..10).each do |n|

- # 0.3, 0.33, 0.333, etc.

- (@one.div(@three,20)).floor(n).should == BigDecimal("0.#{'3'*n}")

- # 1.3, 1.33, 1.333, etc.

- (@four.div(@three,20)).floor(n).should == BigDecimal("1.#{'3'*n}")

- (BigDecimal('31').div(@three,20)).floor(n).should == BigDecimal("10.#{'3'*n}")

- end

- (1..10).each do |n|

- # -0.4, -0.34, -0.334, etc.

- ([email protected](@three,20)).floor(n).should == BigDecimal("-0.#{'3'*(n-1)}4")

- end

- (1..10).each do |n|

- (@three.div(@one,20)).floor(n).should == @three

- end

- (1..10).each do |n|

- ([email protected](@one,20)).floor(n).should == -@three

- end

-

- it "sets n digits left of the decimal point to 0, if given n < 0" do

- BigDecimal("13345.234").floor(-2).should == BigDecimal("13300.0")

- @mixed_big.floor(-99).should == BigDecimal("0.12E101")

- @mixed_big.floor(-100).should == BigDecimal("0.1E101")

- @mixed_big.floor(-95).should == BigDecimal("0.123456E101")

- (1..10).each do |n|

- BigDecimal('1.8').floor(-n).should == @zero

- end

- BigDecimal("1E10").floor(-30).should == @zero

- BigDecimal("-1E10").floor(-30).should == BigDecimal('-1E30')

-ruby_version_is ""..."3.4" do

- require 'bigdecimal'

-

- describe "BigDecimal#frac" do

- before :each do

- @zero = BigDecimal("0")

- @mixed = BigDecimal("1.23456789")

- @pos_int = BigDecimal("2E5555")

- @neg_int = BigDecimal("-2E5555")

- @pos_frac = BigDecimal("2E-9999")

- @neg_frac = BigDecimal("-2E-9999")

-

- @infinity = BigDecimal("Infinity")

- @infinity_neg = BigDecimal("-Infinity")

- @nan = BigDecimal("NaN")

- @zero_pos = BigDecimal("+0")

- @zero_neg = BigDecimal("-0")

- end

-

- it "returns a BigDecimal" do

- @pos_int.frac.kind_of?(BigDecimal).should == true

- @neg_int.frac.kind_of?(BigDecimal).should == true

- @pos_frac.kind_of?(BigDecimal).should == true

- @neg_frac.kind_of?(BigDecimal).should == true

- end

-

- it "returns the fractional part of the absolute value" do

- @mixed.frac.should == BigDecimal("0.23456789")

- @pos_frac.frac.should == @pos_frac

- @neg_frac.frac.should == @neg_frac

- end

-

- it "returns 0 if the value is 0" do

- @zero.frac.should == @zero

- end

-

- it "returns 0 if the value is an integer" do

- @pos_int.frac.should == @zero

- @neg_int.frac.should == @zero

- end

-

- it "correctly handles special values" do

- @infinity.frac.should == @infinity

- @infinity_neg.frac.should == @infinity_neg

- @nan.frac.should.nan?

- end

-ruby_version_is ""..."3.4" do

- require 'bigdecimal'

- describe "BigDecimal#>" do

- before :each do

- @zero = BigDecimal("0")

- @zero_pos = BigDecimal("+0")

- @zero_neg = BigDecimal("-0")

- @mixed = BigDecimal("1.23456789")

- @pos_int = BigDecimal("2E5555")

- @neg_int = BigDecimal("-2E5555")

- @pos_frac = BigDecimal("2E-9999")

- @neg_frac = BigDecimal("-2E-9999")

-

- @int_mock = mock('123')

- class << @int_mock

- def coerce(other)

- return [other, BigDecimal('123')]

- end

- def >(other)

- BigDecimal('123') > other

- end

- @values = [@mixed, @pos_int, @neg_int, @pos_frac, @neg_frac,

- -2**32, -2**31, -2**30, -2**16, -2**8, -100, -10, -1,

- @zero , 1, 2, 10, 10.5, 2**8, 2**16, 2**32, @int_mock, @zero_pos, @zero_neg]

- @infinity = BigDecimal("Infinity")

- @infinity_neg = BigDecimal("-Infinity")

- @float_infinity = Float::INFINITY

- @float_infinity_neg = -Float::INFINITY

- @nan = BigDecimal("NaN")

- end

- it "returns true if a > b" do

- one = BigDecimal("1")

- two = BigDecimal("2")

- frac_1 = BigDecimal("1E-99999")

- frac_2 = BigDecimal("0.9E-99999")

- (@zero > one).should == false

- (two > @zero).should == true

- (frac_2 > frac_1).should == false

- (@neg_int > @pos_int).should == false

- (@pos_int > @neg_int).should == true

- (@neg_int > @pos_frac).should == false

- (@pos_frac > @neg_int).should == true

- (@zero > @zero_pos).should == false

- (@zero > @zero_neg).should == false

- (@zero_neg > @zero_pos).should == false

- (@zero_pos > @zero_neg).should == false

- end

- it "properly handles infinity values" do

- @values.each { |val|

- (val > @infinity).should == false

- (@infinity > val).should == true

- (val > @infinity_neg).should == true

- (@infinity_neg > val).should == false

- }

- (@infinity > @infinity).should == false

- (@infinity_neg > @infinity_neg).should == false

- (@infinity > @infinity_neg).should == true

- (@infinity_neg > @infinity).should == false

- end

- it "properly handles Float infinity values" do

- @values.each { |val|

- (val > @float_infinity).should == false

- (@float_infinity > val).should == true

- (val > @float_infinity_neg).should == true

- (@float_infinity_neg > val).should == false

- }

- end

- it "properly handles NaN values" do

- @values += [@infinity, @infinity_neg, @nan]

- @values.each { |val|

- (@nan > val).should == false

- (val > @nan).should == false

- }

- end

- it "raises an ArgumentError if the argument can't be coerced into a BigDecimal" do

- -> {@zero > nil }.should raise_error(ArgumentError)

- -> {@infinity > nil }.should raise_error(ArgumentError)

- -> {@infinity_neg > nil }.should raise_error(ArgumentError)

- -> {@mixed > nil }.should raise_error(ArgumentError)

- -> {@pos_int > nil }.should raise_error(ArgumentError)

- -> {@neg_frac > nil }.should raise_error(ArgumentError)

- end

-

-ruby_version_is ""..."3.4" do

- require 'bigdecimal'

-

- describe "BigDecimal#>=" do

- before :each do

- @zero = BigDecimal("0")

- @zero_pos = BigDecimal("+0")

- @zero_neg = BigDecimal("-0")

- @mixed = BigDecimal("1.23456789")

- @pos_int = BigDecimal("2E5555")

- @neg_int = BigDecimal("-2E5555")

- @pos_frac = BigDecimal("2E-9999")

- @neg_frac = BigDecimal("-2E-9999")

-

- @int_mock = mock('123')

- class << @int_mock

- def coerce(other)

- return [other, BigDecimal('123')]

- end

- def >=(other)

- BigDecimal('123') >= other

- end

- @values = [@mixed, @pos_int, @neg_int, @pos_frac, @neg_frac,

- -2**32, -2**31, -2**30, -2**16, -2**8, -100, -10, -1,

- @zero , 1, 2, 10, 10.5, 2**8, 2**16, 2**32, @int_mock, @zero_pos, @zero_neg]

- @infinity = BigDecimal("Infinity")

- @infinity_neg = BigDecimal("-Infinity")

- @float_infinity = Float::INFINITY

- @float_infinity_neg = -Float::INFINITY

- @nan = BigDecimal("NaN")

- end

- it "returns true if a >= b" do

- one = BigDecimal("1")

- two = BigDecimal("2")

- frac_1 = BigDecimal("1E-99999")

- frac_2 = BigDecimal("0.9E-99999")

- (@zero >= one).should == false

- (two >= @zero).should == true

- (frac_2 >= frac_1).should == false

- (two >= two).should == true

- (frac_1 >= frac_1).should == true

- (@neg_int >= @pos_int).should == false

- (@pos_int >= @neg_int).should == true

- (@neg_int >= @pos_frac).should == false

- (@pos_frac >= @neg_int).should == true

- (@zero >= @zero_pos).should == true

- (@zero >= @zero_neg).should == true

- (@zero_neg >= @zero_pos).should == true

- (@zero_pos >= @zero_neg).should == true

- end

- it "properly handles infinity values" do

- @values.each { |val|

- (val >= @infinity).should == false

- (@infinity >= val).should == true

- (val >= @infinity_neg).should == true

- (@infinity_neg >= val).should == false

- }

- (@infinity >= @infinity).should == true

- (@infinity_neg >= @infinity_neg).should == true

- (@infinity >= @infinity_neg).should == true

- (@infinity_neg >= @infinity).should == false

- end

- it "properly handles Float infinity values" do

- @values.each { |val|

- (val >= @float_infinity).should == false

- (@float_infinity >= val).should == true

- (val >= @float_infinity_neg).should == true

- (@float_infinity_neg >= val).should == false

- }

- end

- it "properly handles NaN values" do

- @values += [@infinity, @infinity_neg, @nan]

- @values.each { |val|

- (@nan >= val).should == false

- (val >= @nan).should == false

- }

- end

- it "returns nil if the argument is nil" do

- -> {@zero >= nil }.should raise_error(ArgumentError)

- -> {@infinity >= nil }.should raise_error(ArgumentError)

- -> {@infinity_neg >= nil }.should raise_error(ArgumentError)

- -> {@mixed >= nil }.should raise_error(ArgumentError)

- -> {@pos_int >= nil }.should raise_error(ArgumentError)

- -> {@neg_frac >= nil }.should raise_error(ArgumentError)

- end

-ruby_version_is ""..."3.4" do

- require 'bigdecimal'

-

- describe "BidDecimal#hash" do

- describe "two BigDecimal objects with the same value" do

- it "should have the same hash for ordinary values" do

- BigDecimal('1.2920').hash.should == BigDecimal('1.2920').hash

- end

- it "should have the same hash for infinite values" do

- BigDecimal("+Infinity").hash.should == BigDecimal("+Infinity").hash

- BigDecimal("-Infinity").hash.should == BigDecimal("-Infinity").hash

- end

- it "should have the same hash for NaNs" do

- BigDecimal("NaN").hash.should == BigDecimal("NaN").hash

- end

- it "should have the same hash for zero values" do

- BigDecimal("+0").hash.should == BigDecimal("+0").hash

- BigDecimal("-0").hash.should == BigDecimal("-0").hash

- end

- describe "two BigDecimal objects with numerically equal values" do

- it "should have the same hash value" do

- BigDecimal("1.2920").hash.should == BigDecimal("1.2920000").hash

- end

-ruby_version_is ""..."3.4" do

- require 'bigdecimal'

- describe "BigDecimal#infinite?" do

-

- it "returns 1 if self is Infinity" do

- BigDecimal("Infinity").infinite?.should == 1

- end

-

- it "returns -1 if self is -Infinity" do

- BigDecimal("-Infinity").infinite?.should == -1

- end

- it "returns not true otherwise" do

- e2_plus = BigDecimal("2E40001")

- e3_minus = BigDecimal("3E-20001")

- really_small_zero = BigDecimal("0E-200000000")

- really_big_zero = BigDecimal("0E200000000000")

- e3_minus.infinite?.should == nil

- e2_plus.infinite?.should == nil

- really_small_zero.infinite?.should == nil

- really_big_zero.infinite?.should == nil

- BigDecimal("0.000000000000000000000000").infinite?.should == nil

- end

- it "returns not true if self is NaN" do

- # NaN is a special value which is neither finite nor infinite.

- nan = BigDecimal("NaN")

- nan.infinite?.should == nil

- end

-ruby_version_is ""..."3.4" do

- require 'bigdecimal'

- describe "BigDecimal#inspect" do

-

- before :each do

- @bigdec = BigDecimal("1234.5678")

- end

- it "returns String" do

- @bigdec.inspect.kind_of?(String).should == true

- end

- it "looks like this" do

- @bigdec.inspect.should == "0.12345678e4"

- end

- it "does not add an exponent for zero values" do

- BigDecimal("0").inspect.should == "0.0"

- BigDecimal("+0").inspect.should == "0.0"

- BigDecimal("-0").inspect.should == "-0.0"

- end

- it "properly cases non-finite values" do

- BigDecimal("NaN").inspect.should == "NaN"

- BigDecimal("Infinity").inspect.should == "Infinity"

- BigDecimal("+Infinity").inspect.should == "Infinity"

- BigDecimal("-Infinity").inspect.should == "-Infinity"

- end

-ruby_version_is ""..."3.4" do

- require_relative 'fixtures/classes'

- require 'bigdecimal'

-

- describe "BigDecimal.limit" do

- it "returns the value before set if the passed argument is nil or is not specified" do

- old = BigDecimal.limit

- BigDecimal.limit.should == 0

- BigDecimal.limit(10).should == 0

- BigDecimal.limit.should == 10

- BigDecimal.limit(old)

- it "uses the global limit if no precision is specified" do

- BigDecimalSpecs.with_limit(0) do

- (BigDecimal('0.888') + BigDecimal('0')).should == BigDecimal('0.888')

- (BigDecimal('0.888') - BigDecimal('0')).should == BigDecimal('0.888')

- (BigDecimal('0.888') * BigDecimal('3')).should == BigDecimal('2.664')

- (BigDecimal('0.888') / BigDecimal('3')).should == BigDecimal('0.296')

- end

-

- BigDecimalSpecs.with_limit(1) do

- (BigDecimal('0.888') + BigDecimal('0')).should == BigDecimal('0.9')

- (BigDecimal('0.888') - BigDecimal('0')).should == BigDecimal('0.9')

- (BigDecimal('0.888') * BigDecimal('3')).should == BigDecimal('3')

- (BigDecimal('0.888') / BigDecimal('3')).should == BigDecimal('0.3')

- end

-

- BigDecimalSpecs.with_limit(2) do

- (BigDecimal('0.888') + BigDecimal('0')).should == BigDecimal('0.89')

- (BigDecimal('0.888') - BigDecimal('0')).should == BigDecimal('0.89')

- (BigDecimal('0.888') * BigDecimal('3')).should == BigDecimal('2.7')

- (BigDecimal('0.888') / BigDecimal('3')).should == BigDecimal('0.30')

- end

- it "picks the specified precision over global limit" do

- BigDecimalSpecs.with_limit(3) do

- BigDecimal('0.888').add(BigDecimal('0'), 2).should == BigDecimal('0.89')

- BigDecimal('0.888').sub(BigDecimal('0'), 2).should == BigDecimal('0.89')

- BigDecimal('0.888').mult(BigDecimal('3'), 2).should == BigDecimal('2.7')

- BigDecimal('0.888').div(BigDecimal('3'), 2).should == BigDecimal('0.30')

- end

- it "picks the global precision when limit 0 specified" do

- BigDecimalSpecs.with_limit(3) do

- BigDecimal('0.8888').add(BigDecimal('0'), 0).should == BigDecimal('0.889')

- BigDecimal('0.8888').sub(BigDecimal('0'), 0).should == BigDecimal('0.889')

- BigDecimal('0.888').mult(BigDecimal('3'), 0).should == BigDecimal('2.66')

- BigDecimal('0.8888').div(BigDecimal('3'), 0).should == BigDecimal('0.296')

- end

-ruby_version_is ""..."3.4" do

- require 'bigdecimal'

- describe "BigDecimal#<" do

- before :each do

- @zero = BigDecimal("0")

- @zero_pos = BigDecimal("+0")

- @zero_neg = BigDecimal("-0")

- @mixed = BigDecimal("1.23456789")

- @pos_int = BigDecimal("2E5555")

- @neg_int = BigDecimal("-2E5555")

- @pos_frac = BigDecimal("2E-9999")

- @neg_frac = BigDecimal("-2E-9999")

-

- @int_mock = mock('123')

- class << @int_mock

- def coerce(other)

- return [other, BigDecimal('123')]

- end

- def <(other)

- BigDecimal('123') < other

- end

- @values = [@mixed, @pos_int, @neg_int, @pos_frac, @neg_frac,

- -2**32, -2**31, -2**30, -2**16, -2**8, -100, -10, -1,

- @zero , 1, 2, 10, 10.5, 2**8, 2**16, 2**32, @int_mock, @zero_pos, @zero_neg]

- @infinity = BigDecimal("Infinity")

- @infinity_neg = BigDecimal("-Infinity")

- @float_infinity = Float::INFINITY

- @float_infinity_neg = -Float::INFINITY

- @nan = BigDecimal("NaN")

- end

- it "returns true if a < b" do

- one = BigDecimal("1")

- two = BigDecimal("2")

- frac_1 = BigDecimal("1E-99999")

- frac_2 = BigDecimal("0.9E-99999")

- (@zero < one).should == true

- (two < @zero).should == false

- (frac_2 < frac_1).should == true

- (@neg_int < @pos_int).should == true

- (@pos_int < @neg_int).should == false

- (@neg_int < @pos_frac).should == true

- (@pos_frac < @neg_int).should == false

- (@zero < @zero_pos).should == false

- (@zero < @zero_neg).should == false

- (@zero_neg < @zero_pos).should == false

- (@zero_pos < @zero_neg).should == false

- end

- it "properly handles infinity values" do

- @values.each { |val|

- (val < @infinity).should == true

- (@infinity < val).should == false

- (val < @infinity_neg).should == false

- (@infinity_neg < val).should == true

- }

- (@infinity < @infinity).should == false

- (@infinity_neg < @infinity_neg).should == false

- (@infinity < @infinity_neg).should == false

- (@infinity_neg < @infinity).should == true

- end

- it "properly handles Float infinity values" do

- @values.each { |val|

- (val < @float_infinity).should == true

- (@float_infinity < val).should == false

- (val < @float_infinity_neg).should == false

- (@float_infinity_neg < val).should == true

- }

- end

- it "properly handles NaN values" do

- @values += [@infinity, @infinity_neg, @nan]

- @values.each { |val|

- (@nan < val).should == false

- (val < @nan).should == false

- }

- end

- it "raises an ArgumentError if the argument can't be coerced into a BigDecimal" do

- -> {@zero < nil }.should raise_error(ArgumentError)

- -> {@infinity < nil }.should raise_error(ArgumentError)

- -> {@infinity_neg < nil }.should raise_error(ArgumentError)

- -> {@mixed < nil }.should raise_error(ArgumentError)

- -> {@pos_int < nil }.should raise_error(ArgumentError)

- -> {@neg_frac < nil }.should raise_error(ArgumentError)

- end

-

-ruby_version_is ""..."3.4" do

- require 'bigdecimal'

-

- describe "BigDecimal#<=" do

- before :each do

- @zero = BigDecimal("0")

- @zero_pos = BigDecimal("+0")

- @zero_neg = BigDecimal("-0")

- @mixed = BigDecimal("1.23456789")

- @pos_int = BigDecimal("2E5555")

- @neg_int = BigDecimal("-2E5555")

- @pos_frac = BigDecimal("2E-9999")

- @neg_frac = BigDecimal("-2E-9999")

-

- @int_mock = mock('123')

- class << @int_mock

- def coerce(other)

- return [other, BigDecimal('123')]

- end

- def <=(other)

- BigDecimal('123') <= other

- end

- @values = [@mixed, @pos_int, @neg_int, @pos_frac, @neg_frac,

- -2**32, -2**31, -2**30, -2**16, -2**8, -100, -10, -1,

- @zero , 1, 2, 10, 10.5, 2**8, 2**16, 2**32, @int_mock, @zero_pos, @zero_neg]

- @infinity = BigDecimal("Infinity")

- @infinity_neg = BigDecimal("-Infinity")

- @float_infinity = Float::INFINITY

- @float_infinity_neg = -Float::INFINITY

- @nan = BigDecimal("NaN")

- end

- it "returns true if a <= b" do

- one = BigDecimal("1")

- two = BigDecimal("2")

- frac_1 = BigDecimal("1E-99999")

- frac_2 = BigDecimal("0.9E-99999")

- (@zero <= one).should == true

- (two <= @zero).should == false

- (frac_2 <= frac_1).should == true

- (two <= two).should == true

- (frac_1 <= frac_1).should == true

- (@neg_int <= @pos_int).should == true

- (@pos_int <= @neg_int).should == false

- (@neg_int <= @pos_frac).should == true

- (@pos_frac <= @neg_int).should == false

- (@zero <= @zero_pos).should == true

- (@zero <= @zero_neg).should == true

- (@zero_neg <= @zero_pos).should == true

- (@zero_pos <= @zero_neg).should == true

- end

- it "properly handles infinity values" do

- @values.each { |val|

- (val <= @infinity).should == true

- (@infinity <= val).should == false

- (val <= @infinity_neg).should == false

- (@infinity_neg <= val).should == true

- }

- (@infinity <= @infinity).should == true

- (@infinity_neg <= @infinity_neg).should == true

- (@infinity <= @infinity_neg).should == false

- (@infinity_neg <= @infinity).should == true

- end

- it "properly handles Float infinity values" do

- @values.each { |val|

- (val <= @float_infinity).should == true

- (@float_infinity <= val).should == false

- (val <= @float_infinity_neg).should == false

- (@float_infinity_neg <= val).should == true

- }

- end

- it "properly handles NaN values" do

- @values += [@infinity, @infinity_neg, @nan]

- @values.each { |val|

- (@nan <= val).should == false

- (val <= @nan).should == false

- }

- end

- it "raises an ArgumentError if the argument can't be coerced into a BigDecimal" do

- -> {@zero <= nil }.should raise_error(ArgumentError)

- -> {@infinity <= nil }.should raise_error(ArgumentError)

- -> {@infinity_neg <= nil }.should raise_error(ArgumentError)

- -> {@mixed <= nil }.should raise_error(ArgumentError)

- -> {@pos_int <= nil }.should raise_error(ArgumentError)

- -> {@neg_frac <= nil }.should raise_error(ArgumentError)

- end

-ruby_version_is ""..."3.4" do

- require 'bigdecimal'

- describe "BigDecimal#-" do

-

- before :each do

- @one = BigDecimal("1")

- @zero = BigDecimal("0")

- @two = BigDecimal("2")

- @nan = BigDecimal("NaN")

- @infinity = BigDecimal("Infinity")

- @infinity_minus = BigDecimal("-Infinity")

- @one_minus = BigDecimal("-1")

- @frac_1 = BigDecimal("1E-99999")

- @frac_2 = BigDecimal("0.9E-99999")

- end

- it "returns a - b" do

- (@two - @one).should == @one

- (@one - @two).should == @one_minus

- (@one - @one_minus).should == @two

- (@frac_2 - @frac_1).should == BigDecimal("-0.1E-99999")

- (@two - @two).should == @zero

- (@frac_1 - @frac_1).should == @zero

- (BigDecimal('1.23456789') - BigDecimal('1.2')).should == BigDecimal("0.03456789")

- end

- it "returns NaN if NaN is involved" do

- (@one - @nan).should.nan?

- (@nan - @one).should.nan?

- (@nan - @nan).should.nan?

- (@nan - @infinity).should.nan?

- (@nan - @infinity_minus).should.nan?

- (@infinity - @nan).should.nan?

- (@infinity_minus - @nan).should.nan?

- end

- it "returns NaN both operands are infinite with the same sign" do

- (@infinity - @infinity).should.nan?

- (@infinity_minus - @infinity_minus).should.nan?

- end

- it "returns Infinity or -Infinity if these are involved" do

- (@infinity - @infinity_minus).should == @infinity

- (@infinity_minus - @infinity).should == @infinity_minus

- (@infinity - @zero).should == @infinity

- (@infinity - @frac_2).should == @infinity

- (@infinity - @two).should == @infinity

- (@infinity - @one_minus).should == @infinity

- (@zero - @infinity).should == @infinity_minus

- (@frac_2 - @infinity).should == @infinity_minus

- (@two - @infinity).should == @infinity_minus

- (@one_minus - @infinity).should == @infinity_minus

- end

- describe "with Object" do

- it "tries to coerce the other operand to self" do

- object = mock("Object")

- object.should_receive(:coerce).with(@one).and_return([@one, BigDecimal("42")])

- (@one - object).should == BigDecimal("-41")

- end

-

-ruby_version_is ""..."3.4" do

- require 'bigdecimal'

-

- describe "BigDecimal.mode" do

- #the default value of BigDecimal exception constants is false

- after :each do

- BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false)

- BigDecimal.mode(BigDecimal::EXCEPTION_INFINITY, false)

- BigDecimal.mode(BigDecimal::EXCEPTION_UNDERFLOW, false)

- BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, false)

- BigDecimal.mode(BigDecimal::EXCEPTION_ZERODIVIDE, false)

- end

- it "returns the appropriate value and continue the computation if the flag is false" do

- BigDecimal("NaN").add(BigDecimal("1"),0).should.nan?

- BigDecimal("0").add(BigDecimal("Infinity"),0).should == BigDecimal("Infinity")

- BigDecimal("1").quo(BigDecimal("0")).should == BigDecimal("Infinity")

- end

- it "returns Infinity when too big" do

- BigDecimal("1E11111111111111111111").should == BigDecimal("Infinity")

- (BigDecimal("1E1000000000000000000")**10).should == BigDecimal("Infinity")

- end

- it "raise an exception if the flag is true" do

- BigDecimal.mode(BigDecimal::EXCEPTION_NaN, true)

- -> { BigDecimal("NaN").add(BigDecimal("1"),0) }.should raise_error(FloatDomainError)

- BigDecimal.mode(BigDecimal::EXCEPTION_INFINITY, true)

- -> { BigDecimal("0").add(BigDecimal("Infinity"),0) }.should raise_error(FloatDomainError)

- BigDecimal.mode(BigDecimal::EXCEPTION_ZERODIVIDE, true)

- -> { BigDecimal("1").quo(BigDecimal("0")) }.should raise_error(FloatDomainError)

- BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, true)

- -> { BigDecimal("1E11111111111111111111") }.should raise_error(FloatDomainError)

- -> { (BigDecimal("1E1000000000000000000")**10) }.should raise_error(FloatDomainError)

- end

-ruby_version_is ""..."3.4" do

- require_relative 'shared/modulo'

-

- describe "BigDecimal#%" do

- it_behaves_like :bigdecimal_modulo, :%

- it_behaves_like :bigdecimal_modulo_zerodivisionerror, :%

- end

- describe "BigDecimal#modulo" do

- it_behaves_like :bigdecimal_modulo, :modulo

- it_behaves_like :bigdecimal_modulo_zerodivisionerror, :modulo

- end

-ruby_version_is ""..."3.4" do

- require_relative 'shared/mult'

- require 'bigdecimal'

-

- describe "BigDecimal#mult" do

- it_behaves_like :bigdecimal_mult, :mult, [10]

- end

- describe "BigDecimal#mult" do

- before :each do

- @one = BigDecimal "1"

- @e3_minus = BigDecimal("3E-20001")

- @e3_plus = BigDecimal("3E20001")

- @e = BigDecimal "1.00000000000000000000123456789"

- @tolerance = @e.sub @one, 1000

- @tolerance2 = BigDecimal "30001E-20005"

- end

- it "multiply self with other with (optional) precision" do

- @e.mult(@one, 1).should be_close(@one, @tolerance)

- @e3_minus.mult(@one, 1).should be_close(0, @tolerance2)

- end

- describe "with Object" do

- it "tries to coerce the other operand to self" do

- object = mock("Object")

- object.should_receive(:coerce).with(@e3_minus).and_return([@e3_minus, @e3_plus])

- @e3_minus.mult(object, 1).should == BigDecimal("9")

- end

-ruby_version_is ""..."3.4" do

- require_relative 'shared/mult'

- require 'bigdecimal'

- describe "BigDecimal#*" do

- it_behaves_like :bigdecimal_mult, :*, []

- describe "BigDecimal#*" do

- before :each do

- @three = BigDecimal("3")

- @e3_minus = BigDecimal("3E-20001")

- @e3_plus = BigDecimal("3E20001")

- @e = BigDecimal("1.00000000000000000000123456789")

- @one = BigDecimal("1")

- end

-

- it "multiply self with other" do

- (@one * @one).should == @one

- (@e3_minus * @e3_plus).should == BigDecimal("9")

- # Can't do this till we implement **

- # (@e3_minus * @e3_minus).should == @e3_minus ** 2

- # So let's rewrite it as:

- (@e3_minus * @e3_minus).should == BigDecimal("9E-40002")

- (@e * @one).should == @e

- end

- describe "with Object" do

- it "tries to coerce the other operand to self" do

- object = mock("Object")

- object.should_receive(:coerce).with(@e3_minus).and_return([@e3_minus, @e3_plus])

- (@e3_minus * object).should == BigDecimal("9")

- end

- describe "with Rational" do

- it "produces a BigDecimal" do

- (@three * Rational(500, 2)).should == BigDecimal("0.75e3")

- end

-ruby_version_is ""..."3.4" do

- require 'bigdecimal'

- describe "BigDecimal#nan?" do

-

- it "returns true if self is not a number" do

- BigDecimal("NaN").should.nan?

- end

-

- it "returns false if self is not a NaN" do

- BigDecimal("Infinity").should_not.nan?

- BigDecimal("-Infinity").should_not.nan?

- BigDecimal("0").should_not.nan?

- BigDecimal("+0").should_not.nan?

- BigDecimal("-0").should_not.nan?

- BigDecimal("2E40001").should_not.nan?

- BigDecimal("3E-20001").should_not.nan?

- BigDecimal("0E-200000000").should_not.nan?

- BigDecimal("0E200000000000").should_not.nan?

- BigDecimal("0.000000000000000000000000").should_not.nan?

- end

-ruby_version_is ""..."3.4" do

- require 'bigdecimal'

- describe "BigDecimal#nonzero?" do

-

- it "returns self if self doesn't equal zero" do

- # documentation says, it returns true. (04/10/08)

- e2_plus = BigDecimal("2E40001")

- e3_minus = BigDecimal("3E-20001")

- infinity = BigDecimal("Infinity")

- infinity_minus = BigDecimal("-Infinity")

- nan = BigDecimal("NaN")

- infinity.nonzero?.should equal(infinity)

- infinity_minus.nonzero?.should equal(infinity_minus)

- nan.nonzero?.should equal(nan)

- e3_minus.nonzero?.should equal(e3_minus)

- e2_plus.nonzero?.should equal(e2_plus)

- end

-

- it "returns nil otherwise" do

- # documentation states, it should return false. (04/10/08)

- really_small_zero = BigDecimal("0E-200000000")

- really_big_zero = BigDecimal("0E200000000000")

- really_small_zero.nonzero?.should == nil

- really_big_zero.nonzero?.should == nil

- BigDecimal("0.000000000000000000000000").nonzero?.should == nil

- end

-ruby_version_is ""..."3.4" do

- require 'bigdecimal'

-

- describe "BigDecimal#+" do

-

- before :each do

- @one = BigDecimal("1")

- @zero = BigDecimal("0")

- @two = BigDecimal("2")

- @three = BigDecimal("3")

- @ten = BigDecimal("10")

- @eleven = BigDecimal("11")

- @nan = BigDecimal("NaN")

- @infinity = BigDecimal("Infinity")

- @infinity_minus = BigDecimal("-Infinity")

- @one_minus = BigDecimal("-1")

- @frac_1 = BigDecimal("1E-99999")

- @frac_2 = BigDecimal("0.9E-99999")

- end

-

- it "returns a + b" do

- (@two + @one).should == @three

- (@one + @two).should == @three

- (@one + @one_minus).should == @zero

- (@zero + @one).should == @one

- (@ten + @one).should == @eleven

- (@frac_1 + @frac_2).should == BigDecimal("1.9E-99999")

- (@frac_2 + @frac_1).should == BigDecimal("1.9E-99999")

- (@frac_1 + @frac_1).should == BigDecimal("2E-99999")

- end

- it "returns NaN if NaN is involved" do

- (@one + @nan).should.nan?

- (@nan + @one).should.nan?

- end

- it "returns Infinity or -Infinity if these are involved" do

- (@zero + @infinity).should == @infinity

- (@frac_2 + @infinity).should == @infinity

- (@two + @infinity_minus).should == @infinity_minus

- end

- it "returns NaN if Infinity + (- Infinity)" do

- (@infinity + @infinity_minus).should.nan?

- end

- describe "with Object" do

- it "tries to coerce the other operand to self" do

- object = mock("Object")

- object.should_receive(:coerce).with(@one).and_return([@one, BigDecimal("42")])

- (@one + object).should == BigDecimal("43")

- end

-ruby_version_is ""..."3.4" do

- require_relative 'shared/power'

-

- describe "BigDecimal#power" do

- it_behaves_like :bigdecimal_power, :power

- end

-ruby_version_is ""..."3.4" do

- require 'bigdecimal'

- describe "BigDecimal#precs" do

- before :each do

- @infinity = BigDecimal("Infinity")

- @infinity_neg = BigDecimal("-Infinity")

- @nan = BigDecimal("NaN")

- @zero = BigDecimal("0")

- @zero_neg = BigDecimal("-0")

-

- @arr = [BigDecimal("2E40001"), BigDecimal("3E-20001"),\

- @infinity, @infinity_neg, @nan, @zero, @zero_neg]

- @precision = BigDecimal::BASE.to_s.length - 1

- end

- it "returns array of two values" do

- suppress_warning do

- @arr.each do |x|

- x.precs.kind_of?(Array).should == true

- x.precs.size.should == 2

- end

- it "returns Integers as array values" do

- suppress_warning do

- @arr.each do |x|

- x.precs[0].kind_of?(Integer).should == true

- x.precs[1].kind_of?(Integer).should == true

- end

- it "returns the current value of significant digits as the first value" do

- suppress_warning do

- BigDecimal("3.14159").precs[0].should >= 6

- BigDecimal('1').precs[0].should == BigDecimal('1' + '0' * 100).precs[0]

- [@infinity, @infinity_neg, @nan, @zero, @zero_neg].each do |value|

- value.precs[0].should <= @precision

- end

- it "returns the maximum number of significant digits as the second value" do

- suppress_warning do

- BigDecimal("3.14159").precs[1].should >= 6

- BigDecimal('1').precs[1].should >= 1

- BigDecimal('1' + '0' * 100).precs[1].should >= 101

- [@infinity, @infinity_neg, @nan, @zero, @zero_neg].each do |value|

- value.precs[1].should >= 1

- end

-ruby_version_is ""..."3.4" do

- require_relative 'shared/quo'

- require 'bigdecimal'

- describe "BigDecimal#quo" do

- it_behaves_like :bigdecimal_quo, :quo, []

-

- it "returns NaN if NaN is involved" do

- BigDecimal("1").quo(BigDecimal("NaN")).should.nan?

- BigDecimal("NaN").quo(BigDecimal("1")).should.nan?

- end

-ruby_version_is ""..."3.4" do

- require 'bigdecimal'

-

- describe "BigDecimal#remainder" do

-

- before :each do

- @zero = BigDecimal("0")

- @one = BigDecimal("1")

- @three = BigDecimal("3")

- @mixed = BigDecimal("1.23456789")

- @pos_int = BigDecimal("2E5555")

- @neg_int = BigDecimal("-2E5555")

- @pos_frac = BigDecimal("2E-9999")

- @neg_frac = BigDecimal("-2E-9999")

- @nan = BigDecimal("NaN")

- @infinity = BigDecimal("Infinity")

- @infinity_minus = BigDecimal("-Infinity")

- @one_minus = BigDecimal("-1")

- @frac_1 = BigDecimal("1E-99999")

- @frac_2 = BigDecimal("0.9E-99999")

- end

-

- it "it equals modulo, if both values are of same sign" do

- BigDecimal('1234567890123456789012345679').remainder(BigDecimal('1')).should == @zero

- BigDecimal('123456789').remainder(BigDecimal('333333333333333333333333333E-50')).should == BigDecimal('0.12233333333333333333345679E-24')

-

- @mixed.remainder(@pos_frac).should == @mixed % @pos_frac

- @pos_int.remainder(@pos_frac).should == @pos_int % @pos_frac

- @neg_frac.remainder(@neg_int).should == @neg_frac % @neg_int

- @neg_int.remainder(@neg_frac).should == @neg_int % @neg_frac

- end

-

- it "means self-arg*(self/arg).truncate" do

- @mixed.remainder(@neg_frac).should == @mixed - @neg_frac * (@mixed / @neg_frac).truncate

- @pos_int.remainder(@neg_frac).should == @pos_int - @neg_frac * (@pos_int / @neg_frac).truncate

- @neg_frac.remainder(@pos_int).should == @neg_frac - @pos_int * (@neg_frac / @pos_int).truncate

- @neg_int.remainder(@pos_frac).should == @neg_int - @pos_frac * (@neg_int / @pos_frac).truncate

- end

-

- it "returns NaN used with zero" do

- @mixed.remainder(@zero).should.nan?

- @zero.remainder(@zero).should.nan?

- end

- it "returns zero if used on zero" do

- @zero.remainder(@mixed).should == @zero

- end

- it "returns NaN if NaN is involved" do

- @nan.remainder(@nan).should.nan?

- @nan.remainder(@one).should.nan?

- @one.remainder(@nan).should.nan?

- @infinity.remainder(@nan).should.nan?

- @nan.remainder(@infinity).should.nan?

- end

- version_is BigDecimal::VERSION, ""..."3.1.4" do #ruby_version_is ""..."3.3" do

- it "returns NaN if Infinity is involved" do

- @infinity.remainder(@infinity).should.nan?

- @infinity.remainder(@one).should.nan?

- @infinity.remainder(@mixed).should.nan?

- @infinity.remainder(@one_minus).should.nan?

- @infinity.remainder(@frac_1).should.nan?

- @one.remainder(@infinity).should.nan?

- @infinity_minus.remainder(@infinity_minus).should.nan?

- @infinity_minus.remainder(@one).should.nan?

- @one.remainder(@infinity_minus).should.nan?

- @frac_2.remainder(@infinity_minus).should.nan?

- @infinity.remainder(@infinity_minus).should.nan?

- @infinity_minus.remainder(@infinity).should.nan?

- end

- end

- it "coerces arguments to BigDecimal if possible" do

- @three.remainder(2).should == @one

- describe "with Object" do

- it "tries to coerce the other operand to self" do

- object = mock("Object")

- object.should_receive(:coerce).with(@three).and_return([@three, 2])

- @three.remainder(object).should == @one

- end

- end

- it "raises TypeError if the argument cannot be coerced to BigDecimal" do

- -> {

- @one.remainder('2')

- }.should raise_error(TypeError)

-ruby_version_is ""..."3.4" do

- require 'bigdecimal'

-

- describe "BigDecimal#round" do

- before :each do

- @one = BigDecimal("1")

- @two = BigDecimal("2")

- @three = BigDecimal("3")

-

- @neg_one = BigDecimal("-1")

- @neg_two = BigDecimal("-2")

- @neg_three = BigDecimal("-3")

-

- @p1_50 = BigDecimal("1.50")

- @p1_51 = BigDecimal("1.51")

- @p1_49 = BigDecimal("1.49")

- @n1_50 = BigDecimal("-1.50")

- @n1_51 = BigDecimal("-1.51")

- @n1_49 = BigDecimal("-1.49")

-

- @p2_50 = BigDecimal("2.50")

- @p2_51 = BigDecimal("2.51")

- @p2_49 = BigDecimal("2.49")

- @n2_50 = BigDecimal("-2.50")

- @n2_51 = BigDecimal("-2.51")

- @n2_49 = BigDecimal("-2.49")

- end

-

- after :each do

- BigDecimal.mode(BigDecimal::ROUND_MODE, BigDecimal::ROUND_HALF_UP)

- end

- it "uses default rounding method unless given" do

- @p1_50.round(0).should == @two

- @p1_51.round(0).should == @two

- @p1_49.round(0).should == @one

- @n1_50.round(0).should == @neg_two

- @n1_51.round(0).should == @neg_two

- @n1_49.round(0).should == @neg_one

-

- @p2_50.round(0).should == @three

- @p2_51.round(0).should == @three

- @p2_49.round(0).should == @two

- @n2_50.round(0).should == @neg_three

- @n2_51.round(0).should == @neg_three

- @n2_49.round(0).should == @neg_two

-

- BigDecimal.mode(BigDecimal::ROUND_MODE, BigDecimal::ROUND_DOWN)

-

- @p1_50.round(0).should == @one

- @p1_51.round(0).should == @one

- @p1_49.round(0).should == @one

- @n1_50.round(0).should == @neg_one

- @n1_51.round(0).should == @neg_one

- @n1_49.round(0).should == @neg_one

-

- @p2_50.round(0).should == @two

- @p2_51.round(0).should == @two

- @p2_49.round(0).should == @two

- @n2_50.round(0).should == @neg_two

- @n2_51.round(0).should == @neg_two

- @n2_49.round(0).should == @neg_two

- end

- ["BigDecimal::ROUND_UP", ":up"].each do |way|

- describe way do

- it "rounds values away from zero" do

- mode = eval(way)

-

- @p1_50.round(0, mode).should == @two

- @p1_51.round(0, mode).should == @two

- @p1_49.round(0, mode).should == @two

- @n1_50.round(0, mode).should == @neg_two

- @n1_51.round(0, mode).should == @neg_two

- @n1_49.round(0, mode).should == @neg_two

-

- @p2_50.round(0, mode).should == @three

- @p2_51.round(0, mode).should == @three

- @p2_49.round(0, mode).should == @three

- @n2_50.round(0, mode).should == @neg_three

- @n2_51.round(0, mode).should == @neg_three

- @n2_49.round(0, mode).should == @neg_three

- end

- ["BigDecimal::ROUND_DOWN", ":down", ":truncate"].each do |way|

- describe way do

- it "rounds values towards zero" do

- mode = eval(way)

-

- @p1_50.round(0, mode).should == @one

- @p1_51.round(0, mode).should == @one

- @p1_49.round(0, mode).should == @one

- @n1_50.round(0, mode).should == @neg_one

- @n1_51.round(0, mode).should == @neg_one

- @n1_49.round(0, mode).should == @neg_one

-

- @p2_50.round(0, mode).should == @two

- @p2_51.round(0, mode).should == @two

- @p2_49.round(0, mode).should == @two

- @n2_50.round(0, mode).should == @neg_two

- @n2_51.round(0, mode).should == @neg_two

- @n2_49.round(0, mode).should == @neg_two

- end

- ["BigDecimal::ROUND_HALF_UP", ":half_up", ":default"].each do |way|

- describe way do

- it "rounds values >= 5 up, otherwise down" do

- mode = eval(way)

-

- @p1_50.round(0, mode).should == @two

- @p1_51.round(0, mode).should == @two

- @p1_49.round(0, mode).should == @one

- @n1_50.round(0, mode).should == @neg_two

- @n1_51.round(0, mode).should == @neg_two

- @n1_49.round(0, mode).should == @neg_one

-

- @p2_50.round(0, mode).should == @three

- @p2_51.round(0, mode).should == @three

- @p2_49.round(0, mode).should == @two

- @n2_50.round(0, mode).should == @neg_three

- @n2_51.round(0, mode).should == @neg_three

- @n2_49.round(0, mode).should == @neg_two

- end

- ["BigDecimal::ROUND_HALF_DOWN", ":half_down"].each do |way|

- describe way do

- it "rounds values > 5 up, otherwise down" do

- mode = eval(way)

-

- @p1_50.round(0, mode).should == @one

- @p1_51.round(0, mode).should == @two

- @p1_49.round(0, mode).should == @one

- @n1_50.round(0, mode).should == @neg_one

- @n1_51.round(0, mode).should == @neg_two

- @n1_49.round(0, mode).should == @neg_one

-

- @p2_50.round(0, mode).should == @two

- @p2_51.round(0, mode).should == @three

- @p2_49.round(0, mode).should == @two

- @n2_50.round(0, mode).should == @neg_two

- @n2_51.round(0, mode).should == @neg_three

- @n2_49.round(0, mode).should == @neg_two

- end

- ["BigDecimal::ROUND_CEILING", ":ceiling", ":ceil"].each do |way|

- describe way do

- it "rounds values towards +infinity" do

- mode = eval(way)

-

- @p1_50.round(0, mode).should == @two

- @p1_51.round(0, mode).should == @two

- @p1_49.round(0, mode).should == @two

- @n1_50.round(0, mode).should == @neg_one

- @n1_51.round(0, mode).should == @neg_one

- @n1_49.round(0, mode).should == @neg_one

-

- @p2_50.round(0, mode).should == @three

- @p2_51.round(0, mode).should == @three

- @p2_49.round(0, mode).should == @three

- @n2_50.round(0, mode).should == @neg_two

- @n2_51.round(0, mode).should == @neg_two

- @n2_49.round(0, mode).should == @neg_two

- end

- ["BigDecimal::ROUND_FLOOR", ":floor"].each do |way|

- describe way do

- it "rounds values towards -infinity" do

- mode = eval(way)

-

- @p1_50.round(0, mode).should == @one

- @p1_51.round(0, mode).should == @one

- @p1_49.round(0, mode).should == @one

- @n1_50.round(0, mode).should == @neg_two

- @n1_51.round(0, mode).should == @neg_two

- @n1_49.round(0, mode).should == @neg_two

-

- @p2_50.round(0, mode).should == @two

- @p2_51.round(0, mode).should == @two

- @p2_49.round(0, mode).should == @two

- @n2_50.round(0, mode).should == @neg_three

- @n2_51.round(0, mode).should == @neg_three

- @n2_49.round(0, mode).should == @neg_three

- end

- ["BigDecimal::ROUND_HALF_EVEN", ":half_even", ":banker"].each do |way|

- describe way do

- it "rounds values > 5 up, < 5 down and == 5 towards even neighbor" do

- mode = eval(way)

-

- @p1_50.round(0, mode).should == @two

- @p1_51.round(0, mode).should == @two

- @p1_49.round(0, mode).should == @one

- @n1_50.round(0, mode).should == @neg_two

- @n1_51.round(0, mode).should == @neg_two

- @n1_49.round(0, mode).should == @neg_one

-

- @p2_50.round(0, mode).should == @two

- @p2_51.round(0, mode).should == @three

- @p2_49.round(0, mode).should == @two

- @n2_50.round(0, mode).should == @neg_two

- @n2_51.round(0, mode).should == @neg_three

- @n2_49.round(0, mode).should == @neg_two

- end

- it 'raise exception, if self is special value' do

- -> { BigDecimal('NaN').round }.should raise_error(FloatDomainError)

- -> { BigDecimal('Infinity').round }.should raise_error(FloatDomainError)

- -> { BigDecimal('-Infinity').round }.should raise_error(FloatDomainError)

- end

- it 'do not raise exception, if self is special value and precision is given' do

- -> { BigDecimal('NaN').round(2) }.should_not raise_error(FloatDomainError)

- -> { BigDecimal('Infinity').round(2) }.should_not raise_error(FloatDomainError)

- -> { BigDecimal('-Infinity').round(2) }.should_not raise_error(FloatDomainError)

- end

- version_is BigDecimal::VERSION, ''...'3.1.3' do #ruby_version_is ''...'3.2' do

- it 'raise for a non-existent round mode' do

- -> { @p1_50.round(0, :nonsense) }.should raise_error(ArgumentError, "invalid rounding mode")

- end

- version_is BigDecimal::VERSION, '3.1.3' do #ruby_version_is '3.2' do

- it 'raise for a non-existent round mode' do

- -> { @p1_50.round(0, :nonsense) }.should raise_error(ArgumentError, "invalid rounding mode (nonsense)")

- end

-ruby_version_is ""..."3.4" do

- require 'bigdecimal'

-

- describe "BigDecimal#sign" do

-

- it "defines several constants for signs" do

- # are these really correct?

- BigDecimal::SIGN_POSITIVE_INFINITE.should == 3

- BigDecimal::SIGN_NEGATIVE_INFINITE.should == -3

- BigDecimal::SIGN_POSITIVE_ZERO.should == 1

- BigDecimal::SIGN_NEGATIVE_ZERO.should == -1

- BigDecimal::SIGN_POSITIVE_FINITE.should == 2

- BigDecimal::SIGN_NEGATIVE_FINITE.should == -2

- end

-

- it "returns positive value if BigDecimal greater than 0" do

- BigDecimal("1").sign.should == BigDecimal::SIGN_POSITIVE_FINITE

- BigDecimal("1E-20000000").sign.should == BigDecimal::SIGN_POSITIVE_FINITE

- BigDecimal("1E200000000").sign.should == BigDecimal::SIGN_POSITIVE_FINITE

- BigDecimal("Infinity").sign.should == BigDecimal::SIGN_POSITIVE_INFINITE

- end

-

- it "returns negative value if BigDecimal less than 0" do

- BigDecimal("-1").sign.should == BigDecimal::SIGN_NEGATIVE_FINITE

- BigDecimal("-1E-9990000").sign.should == BigDecimal::SIGN_NEGATIVE_FINITE

- BigDecimal("-1E20000000").sign.should == BigDecimal::SIGN_NEGATIVE_FINITE

- BigDecimal("-Infinity").sign.should == BigDecimal::SIGN_NEGATIVE_INFINITE

- end

-

- it "returns positive zero if BigDecimal equals positive zero" do

- BigDecimal("0").sign.should == BigDecimal::SIGN_POSITIVE_ZERO

- BigDecimal("0E-200000000").sign.should == BigDecimal::SIGN_POSITIVE_ZERO

- BigDecimal("0E200000000").sign.should == BigDecimal::SIGN_POSITIVE_ZERO

- end

-

- it "returns negative zero if BigDecimal equals negative zero" do

- BigDecimal("-0").sign.should == BigDecimal::SIGN_NEGATIVE_ZERO

- BigDecimal("-0E-200000000").sign.should == BigDecimal::SIGN_NEGATIVE_ZERO

- BigDecimal("-0E200000000").sign.should == BigDecimal::SIGN_NEGATIVE_ZERO

- end

-

- it "returns BigDecimal::SIGN_NaN if BigDecimal is NaN" do

- BigDecimal("NaN").sign.should == BigDecimal::SIGN_NaN

- end

-ruby_version_is ""..."3.4" do

- require 'bigdecimal'

- describe "BigDecimal#split" do

- before :each do

- @arr = BigDecimal("0.314159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196442881097566593014782083152134043E1").split

- @arr_neg = BigDecimal("-0.314159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196442881097566593014782083152134043E1").split

- @digits = "922337203685477580810101333333333333333333333333333"

- @arr_big = BigDecimal("00#{@digits}000").split

- @arr_big_neg = BigDecimal("-00#{@digits}000").split

- @huge = BigDecimal('100000000000000000000000000000000000000000001E90000000').split

-

- @infinity = BigDecimal("Infinity")

- @infinity_neg = BigDecimal("-Infinity")

- @nan = BigDecimal("NaN")

- @zero = BigDecimal("0")

- @zero_neg = BigDecimal("-0")

- end

-

- it "splits BigDecimal in an array with four values" do

- @arr.size.should == 4

- end

- it "first value: 1 for numbers > 0" do

- @arr[0].should == 1

- @arr_big[0].should == 1

- @zero.split[0].should == 1

- @huge[0].should == 1

- BigDecimal("+0").split[0].should == 1

- BigDecimal("1E400").split[0].should == 1

- @infinity.split[0].should == 1

- end

- it "first value: -1 for numbers < 0" do

- @arr_neg[0].should == -1

- @arr_big_neg[0].should == -1

- @zero_neg.split[0].should == -1

- BigDecimal("-1E400").split[0].should == -1

- @infinity_neg.split[0].should == -1

- end

- it "first value: 0 if BigDecimal is NaN" do

- BigDecimal("NaN").split[0].should == 0

- end

- it "second value: a string with the significant digits" do

- string = "314159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196442881097566593014782083152134043"

- @arr[1].should == string

- @arr_big[1].should == @digits

- @arr_big_neg[1].should == @digits

- @huge[1].should == "100000000000000000000000000000000000000000001"

- @infinity.split[1].should == @infinity.to_s

- @nan.split[1].should == @nan.to_s

- @infinity_neg.split[1].should == @infinity.to_s

- @zero.split[1].should == "0"

- BigDecimal("-0").split[1].should == "0"

- end

- it "third value: the base (currently always ten)" do

- @arr[2].should == 10

- @arr_neg[2].should == 10

- @arr_big[2].should == 10

- @arr_big_neg[2].should == 10

- @huge[2].should == 10

- @infinity.split[2].should == 10

- @nan.split[2].should == 10

- @infinity_neg.split[2].should == 10

- @zero.split[2].should == 10

- @zero_neg.split[2].should == 10

- end

- it "fourth value: the exponent" do

- @arr[3].should == 1

- @arr_neg[3].should == 1

- @arr_big[3].should == 54

- @arr_big_neg[3].should == 54

- @huge[3].should == 90000045

- @infinity.split[3].should == 0

- @nan.split[3].should == 0

- @infinity_neg.split[3].should == 0

- @zero.split[3].should == 0

- @zero_neg.split[3].should == 0

- end

-ruby_version_is ""..."3.4" do

- require_relative 'fixtures/classes'

- require 'bigdecimal'

-

- describe "BigDecimal#sqrt" do

- before :each do

- @one = BigDecimal("1")

- @zero = BigDecimal("0")

- @zero_pos = BigDecimal("+0")

- @zero_neg = BigDecimal("-0")

- @two = BigDecimal("2.0")

- @three = BigDecimal("3.0")

- @nan = BigDecimal("NaN")

- @infinity = BigDecimal("Infinity")

- @infinity_minus = BigDecimal("-Infinity")

- @one_minus = BigDecimal("-1")

- @frac_1 = BigDecimal("1E-99999")

- @frac_2 = BigDecimal("0.9E-99999")

- end

-

- it "returns square root of 2 with desired precision" do

- string = "1.41421356237309504880168872420969807856967187537694807317667973799073247846210703885038753432764157"

- (1..99).each { |idx|

- @two.sqrt(idx).should be_close(BigDecimal(string), BigDecimal("1E-#{idx-1}"))

- }

- end

-

- it "returns square root of 3 with desired precision" do

- sqrt_3 = "1.732050807568877293527446341505872366942805253810380628055806979451933016908800037081146186757248575"

- (1..99).each { |idx|

- @three.sqrt(idx).should be_close(BigDecimal(sqrt_3), BigDecimal("1E-#{idx-1}"))

- }

- end

-

- it "returns square root of 121 with desired precision" do

- BigDecimal('121').sqrt(5).should be_close(11, 0.00001)

- end

-

- it "returns square root of 0.9E-99999 with desired precision" do

- @frac_2.sqrt(1).to_s.should =~ /\A0\.3E-49999\z/i

- end

-

- it "raises ArgumentError when no argument is given" do

- -> {

- @one.sqrt

- }.should raise_error(ArgumentError)

- end

-

- it "raises ArgumentError if a negative number is given" do

- -> {

- @one.sqrt(-1)

- }.should raise_error(ArgumentError)

- end

-

- it "raises ArgumentError if 2 arguments are given" do

- -> {

- @one.sqrt(1, 1)

- }.should raise_error(ArgumentError)

- end

-

- it "raises TypeError if nil is given" do

- -> {

- @one.sqrt(nil)

- }.should raise_error(TypeError)

- end

-

- it "raises TypeError if a string is given" do

- -> {

- @one.sqrt("stuff")

- }.should raise_error(TypeError)

- end

-

- it "raises TypeError if a plain Object is given" do

- -> {

- @one.sqrt(Object.new)

- }.should raise_error(TypeError)

- end

-

- it "returns 1 if precision is 0 or 1" do

- @one.sqrt(1).should == 1

- @one.sqrt(0).should == 1

- end

-

- it "raises FloatDomainError on negative values" do

- -> {

- BigDecimal('-1').sqrt(10)

- }.should raise_error(FloatDomainError)

- end

-

- it "returns positive infinity for infinity" do

- @infinity.sqrt(1).should == @infinity

- end

-

- it "raises FloatDomainError for negative infinity" do

- -> {

- @infinity_minus.sqrt(1)

- }.should raise_error(FloatDomainError)

- end

-

- it "raises FloatDomainError for NaN" do

- -> {

- @nan.sqrt(1)

- }.should raise_error(FloatDomainError)

- end

-

- it "returns 0 for 0, +0.0 and -0.0" do

- @zero.sqrt(1).should == 0

- @zero_pos.sqrt(1).should == 0

- @zero_neg.sqrt(1).should == 0

- end

-ruby_version_is ""..."3.4" do

- require 'bigdecimal'