1 files changed, 239 insertions, 0 deletions
diff --git a/spec/ruby/library/bigdecimal/BigDecimal_spec.rb b/spec/ruby/library/bigdecimal/BigDecimal_spec.rb
new file mode 100644
index 0000000000..6adebabe84
--- /dev/null
+++ b/spec/ruby/library/bigdecimal/BigDecimal_spec.rb
@@ -0,0 +1,239 @@
+require_relative '../../spec_helper'
+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
+end
+
+describe "Kernel#BigDecimal" do
+
+  it "creates a new object of class BigDecimal" do
+    BigDecimal("3.14159").should.is_a?(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"
+  end
+
+  it "accepts significant digits >= given precision" do
+    BigDecimal("3.1415923", 10).should == BigDecimal("3.1415923")
+  end
+
+  it "determines precision from initial value" do
+    pi_string = "3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196442881097566593014782083152134043"
+    BigDecimal(pi_string).precision.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(ArgumentError)
+    -> { BigDecimal("123x45") }.should.raise(ArgumentError)
+    -> { BigDecimal("123.4%E5") }.should.raise(ArgumentError)
+    -> { BigDecimal("1E2E3E4E5E") }.should.raise(ArgumentError)
+  end
+
+  it "raises ArgumentError for invalid strings" do
+    -> { BigDecimal("ruby") }.should.raise(ArgumentError)
+    -> { BigDecimal("  \t\n \r-\t\t\tInfinity   \n") }.should.raise(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(ArgumentError)
+    -> { BigDecimal("12345_.67E_8__9_") }.should.raise(ArgumentError)
+  end
+
+  it "accepts NaN and [+-]Infinity" do
+    BigDecimal("NaN").should.nan?
+
+    pos_inf = BigDecimal("Infinity")
+    pos_inf.should_not.finite?
+    pos_inf.should > 0
+    pos_inf.should == BigDecimal("+Infinity")
+
+    neg_inf = BigDecimal("-Infinity")
+    neg_inf.should_not.finite?
+    neg_inf.should < 0
+  end
+
+  describe "with exception: false" do
+    it "returns nil for invalid strings" do
+      BigDecimal("invalid", exception: false).should == nil
+      BigDecimal("0invalid", exception: false).should == nil
+      BigDecimal("invalid0", exception: false).should == nil
+      if BigDecimal::VERSION >= "3.1.9"
+        BigDecimal("0.", exception: false).to_i.should == 0
+      else
+        BigDecimal("0.", exception: false).should == nil
+      end
+    end
+  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
+    end
+  end
+
+  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
+  end
+
+  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
+  end
+
+  version_is BigDecimal::VERSION, "3.3.0" do
+    it "allows Float without precision" do
+      BigDecimal(1.2).should == BigDecimal("1.2")
+    end
+  end
+
+  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
+  end
+
+  it "pre-coerces long integers" do
+    BigDecimal(3).add(1 << 50, 3).should == BigDecimal('0.113e16')
+  end
+
+  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
+  end
+
+  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 "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(Rational, 18) produces the result we expect" do
+      BigDecimal(@b, 18).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.round(15).should == BigDecimal("-0.666667e-9")
+      @c.round(15).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
+  end
+end