6 files changed, 65 insertions, 128 deletions

diff --git a/spec/ruby/library/bigdecimal/shared/eql.rb b/spec/ruby/library/bigdecimal/shared/eql.rb
deleted file mode 100644
index eaad272e9a..0000000000
--- a/spec/ruby/library/bigdecimal/shared/eql.rb
+++ /dev/null
@@ -1,61 +0,0 @@
-require 'bigdecimal'
-
-describe :bigdecimal_eql, shared: true do
-  before :each do
-    @bg6543_21 = BigDecimal.new("6543.21")
-    @bg5667_19 = BigDecimal.new("5667.19")
-    @a = BigDecimal("1.0000000000000000000000000000000000000000005")
-    @b = BigDecimal("1.00000000000000000000000000000000000000000005")
-    @bigint = BigDecimal("1000.0")
-    @nan = BigDecimal("NaN")
-    @infinity = BigDecimal("Infinity")
-    @infinity_minus = BigDecimal("-Infinity")
-  end
-
-  it "tests for equality" do
-    @bg6543_21.send(@method, @bg6543_21).should == true
-    @a.send(@method, @a).should == true
-    @a.send(@method, @b).should == false
-    @bg6543_21.send(@method, @a).should == false
-    @bigint.send(@method, 1000).should == true
-  end
-
-  it "returns false for NaN as it is never equal to any number" do
-    @nan.send(@method, @nan).should == false
-    @a.send(@method, @nan).should == false
-    @nan.send(@method, @a).should == false
-    @nan.send(@method, @infinity).should == false
-    @nan.send(@method, @infinity_minus).should == false
-    @infinity.send(@method, @nan).should == false
-    @infinity_minus.send(@method, @nan).should == false
-  end
-
-  it "returns true for infinity values with the same sign" do
-    @infinity.send(@method, @infinity).should == true
-    @infinity.send(@method, BigDecimal("Infinity")).should == true
-    BigDecimal("Infinity").send(@method, @infinity).should == true
-
-    @infinity_minus.send(@method, @infinity_minus).should == true
-    @infinity_minus.send(@method, BigDecimal("-Infinity")).should == true
-    BigDecimal("-Infinity").send(@method, @infinity_minus).should == true
-  end
-
-  it "returns false for infinity values with different signs" do
-    @infinity.send(@method, @infinity_minus).should == false
-    @infinity_minus.send(@method, @infinity).should == false
-  end
-
-  it "returns false when infinite value compared to finite one" do
-    @infinity.send(@method, @a).should == false
-    @infinity_minus.send(@method, @a).should == false
-
-    @a.send(@method, @infinity).should == false
-    @a.send(@method, @infinity_minus).should == false
-  end
-
-  it "returns false when compared objects that can not be coerced into BigDecimal" do
-    @infinity.send(@method, nil).should == false
-    @bigint.send(@method, nil).should == false
-    @nan.send(@method, nil).should == false
-  end
-end
diff --git a/spec/ruby/library/bigdecimal/shared/modulo.rb b/spec/ruby/library/bigdecimal/shared/modulo.rb
index 78ebe8360d..5b5e3503c4 100644
--- a/spec/ruby/library/bigdecimal/shared/modulo.rb
+++ b/spec/ruby/library/bigdecimal/shared/modulo.rb
@@ -18,8 +18,8 @@ describe :bigdecimal_modulo, shared: true do
   end
 
   it "returns self modulo other" do
-    bd6543 = BigDecimal.new("6543.21")
-    bd5667 = BigDecimal.new("5667.19")
+    bd6543 = BigDecimal("6543.21")
+    bd5667 = BigDecimal("5667.19")
     a = BigDecimal("1.0000000000000000000000000000000000000000005")
     b = BigDecimal("1.00000000000000000000000000000000000000000005")
 
@@ -70,47 +70,52 @@ describe :bigdecimal_modulo, shared: true do
     res.kind_of?(BigDecimal).should == true
   end
 
+  describe "with Object" do
+    it "tries to coerce the other operand to self" do
+      bd6543 = BigDecimal("6543.21")
+      object = mock("Object")
+      object.should_receive(:coerce).with(bd6543).and_return([bd6543, 137])
+      bd6543.send(@method, object, *@object).should == BigDecimal("104.21")
+    end
+  end
+
   it "returns NaN if NaN is involved" do
-    @nan.send(@method, @nan).nan?.should == true
-    @nan.send(@method, @one).nan?.should == true
-    @one.send(@method, @nan).nan?.should == true
-    @infinity.send(@method, @nan).nan?.should == true
-    @nan.send(@method, @infinity).nan?.should == true
+    @nan.send(@method, @nan).should.nan?
+    @nan.send(@method, @one).should.nan?
+    @one.send(@method, @nan).should.nan?
+    @infinity.send(@method, @nan).should.nan?
+    @nan.send(@method, @infinity).should.nan?
   end
 
   it "returns NaN if the dividend is Infinity" do
-    @infinity.send(@method, @infinity).nan?.should == true
-    @infinity.send(@method, @one).nan?.should == true
-    @infinity.send(@method, @mixed).nan?.should == true
-    @infinity.send(@method, @one_minus).nan?.should == true
-    @infinity.send(@method, @frac_1).nan?.should == true
+    @infinity.send(@method, @infinity).should.nan?
+    @infinity.send(@method, @one).should.nan?
+    @infinity.send(@method, @mixed).should.nan?
+    @infinity.send(@method, @one_minus).should.nan?
+    @infinity.send(@method, @frac_1).should.nan?
 
-    @infinity_minus.send(@method, @infinity_minus).nan?.should == true
-    @infinity_minus.send(@method, @one).nan?.should == true
+    @infinity_minus.send(@method, @infinity_minus).should.nan?
+    @infinity_minus.send(@method, @one).should.nan?
 
-    @infinity.send(@method, @infinity_minus).nan?.should == true
-    @infinity_minus.send(@method, @infinity).nan?.should == true
+    @infinity.send(@method, @infinity_minus).should.nan?
+    @infinity_minus.send(@method, @infinity).should.nan?
   end
 
-  it "returns the dividend if the divisor is Infinity" do
-    @one.send(@method, @infinity).should == @one
-    @one.send(@method, @infinity_minus).should == @one
-    @frac_2.send(@method, @infinity_minus).should == @frac_2
+  version_is BigDecimal::VERSION, "3.3.0" do
+    it "returns the dividend if the divisor is Infinity and signs are same" do
+      @one.send(@method, @infinity).should == @one
+      (-@frac_2).send(@method, @infinity_minus).should == -@frac_2
+    end
+
+    it "returns the divisor if the divisor is Infinity and signs are different" do
+      (-@one).send(@method, @infinity).should == @infinity
+      @frac_2.send(@method, @infinity_minus).should == @infinity_minus
+    end
   end
 
   it "raises TypeError if the argument cannot be coerced to BigDecimal" do
-    lambda {
+    -> {
       @one.send(@method, '2')
-    }.should raise_error(TypeError)
-  end
-end
-
-describe :bigdecimal_modulo_zerodivisionerror, shared: true do
-  it "raises ZeroDivisionError if other is zero" do
-    bd5667 = BigDecimal.new("5667.19")
-
-    lambda { bd5667.send(@method, 0) }.should raise_error(ZeroDivisionError)
-    lambda { bd5667.send(@method, BigDecimal("0")) }.should raise_error(ZeroDivisionError)
-    lambda { @zero.send(@method, @zero) }.should raise_error(ZeroDivisionError)
+    }.should.raise(TypeError)
   end
 end
diff --git a/spec/ruby/library/bigdecimal/shared/mult.rb b/spec/ruby/library/bigdecimal/shared/mult.rb
index b94c9385de..c613df04c4 100644
--- a/spec/ruby/library/bigdecimal/shared/mult.rb
+++ b/spec/ruby/library/bigdecimal/shared/mult.rb
@@ -51,8 +51,8 @@ describe :bigdecimal_mult, shared: true do
     values = @regular_vals + @zeroes
 
     values.each do |val|
-      @nan.send(@method, val, *@object).nan?.should == true
-      val.send(@method, @nan, *@object).nan?.should == true
+      @nan.send(@method, val, *@object).should.nan?
+      val.send(@method, @nan, *@object).should.nan?
     end
   end
 
@@ -62,9 +62,9 @@ describe :bigdecimal_mult, shared: true do
     values.each do |val|
       @zeroes.each do |zero|
         zero.send(@method, val, *@object).should == 0
-        zero.send(@method, val, *@object).zero?.should == true
+        zero.send(@method, val, *@object).should.zero?
         val.send(@method, zero, *@object).should == 0
-        val.send(@method, zero, *@object).zero?.should == true
+        val.send(@method, zero, *@object).should.zero?
       end
     end
   end
@@ -75,8 +75,8 @@ describe :bigdecimal_mult, shared: true do
 
     values.each do |val|
       infs.each do |inf|
-        inf.send(@method, val, *@object).finite?.should == false
-        val.send(@method, inf, *@object).finite?.should == false
+        inf.send(@method, val, *@object).should_not.finite?
+        val.send(@method, inf, *@object).should_not.finite?
       end
     end
 
@@ -89,9 +89,9 @@ describe :bigdecimal_mult, shared: true do
   end
 
   it "returns NaN if the result is undefined" do
-    @zero.send(@method, @infinity, *@object).nan?.should == true
-    @zero.send(@method, @infinity_minus, *@object).nan?.should == true
-    @infinity.send(@method, @zero, *@object).nan?.should == true
-    @infinity_minus.send(@method, @zero, *@object).nan?.should == true
+    @zero.send(@method, @infinity, *@object).should.nan?
+    @zero.send(@method, @infinity_minus, *@object).should.nan?
+    @infinity.send(@method, @zero, *@object).should.nan?
+    @infinity_minus.send(@method, @zero, *@object).should.nan?
   end
 end
diff --git a/spec/ruby/library/bigdecimal/shared/power.rb b/spec/ruby/library/bigdecimal/shared/power.rb
index a4848fb2e2..6dafb638e2 100644
--- a/spec/ruby/library/bigdecimal/shared/power.rb
+++ b/spec/ruby/library/bigdecimal/shared/power.rb
@@ -10,8 +10,8 @@ describe :bigdecimal_power, shared: true do
     e = BigDecimal("1.00000000000000000000123456789")
     one = BigDecimal("1")
     ten = BigDecimal("10")
-    # The tolerance is dependent upon the size of BASE_FIG
-    tolerance = BigDecimal("1E-70")
+    # Accuracy is at least ndigits(== 30) + DOUBLE_FIG(== 16)
+    tolerance = BigDecimal("1E-46")
     ten_powers = BigDecimal("1E10000")
     pi = BigDecimal("3.14159265358979")
     e3_minus.send(@method, 2).should == e3_minus_power_2
@@ -53,8 +53,8 @@ describe :bigdecimal_power, shared: true do
   end
 
   it "returns NaN if self is NaN" do
-    BigDecimal("NaN").send(@method, -5).nan?.should == true
-    BigDecimal("NaN").send(@method, 5).nan?.should == true
+    BigDecimal("NaN").send(@method, -5).should.nan?
+    BigDecimal("NaN").send(@method, 5).should.nan?
   end
 
   it "returns 0.0 if self is infinite and argument is negative" do
diff --git a/spec/ruby/library/bigdecimal/shared/quo.rb b/spec/ruby/library/bigdecimal/shared/quo.rb
index cb51c10d71..18ff2fe9a5 100644
--- a/spec/ruby/library/bigdecimal/shared/quo.rb
+++ b/spec/ruby/library/bigdecimal/shared/quo.rb
@@ -29,6 +29,15 @@ describe :bigdecimal_quo, shared: true do
     @one.send(@method, BigDecimal('2E-5555'), *@object).should == BigDecimal('0.5E5555')
   end
 
+  describe "with Object" do
+    it "tries to coerce the other operand to self" do
+      skip if @method == :div
+      object = mock("Object")
+      object.should_receive(:coerce).with(@one).and_return([@one, @two])
+      @one.send(@method, object, *@object).should == BigDecimal("0.5")
+    end
+  end
+
   it "returns 0 if divided by Infinity" do
     @zero.send(@method, @infinity, *@object).should == 0
     @frac_2.send(@method, @infinity, *@object).should == 0
@@ -41,8 +50,8 @@ describe :bigdecimal_quo, shared: true do
   end
 
   it "returns NaN if Infinity / ((+|-) Infinity)" do
-    @infinity.send(@method, @infinity_minus, *@object).nan?.should == true
-    @infinity_minus.send(@method, @infinity, *@object).nan?.should == true
+    @infinity.send(@method, @infinity_minus, *@object).should.nan?
+    @infinity_minus.send(@method, @infinity, *@object).should.nan?
   end
 
   it "returns (+|-) Infinity if divided by zero" do
@@ -52,8 +61,8 @@ describe :bigdecimal_quo, shared: true do
   end
 
   it "returns NaN if zero is divided by zero" do
-    @zero.send(@method, @zero, *@object).nan?.should == true
-    @zero_minus.send(@method, @zero_plus, *@object).nan?.should == true
-    @zero_plus.send(@method, @zero_minus, *@object).nan?.should == true
+    @zero.send(@method, @zero, *@object).should.nan?
+    @zero_minus.send(@method, @zero_plus, *@object).should.nan?
+    @zero_plus.send(@method, @zero_minus, *@object).should.nan?
   end
 end
diff --git a/spec/ruby/library/bigdecimal/shared/to_int.rb b/spec/ruby/library/bigdecimal/shared/to_int.rb
deleted file mode 100644
index 729a25f511..0000000000
--- a/spec/ruby/library/bigdecimal/shared/to_int.rb
+++ /dev/null
@@ -1,16 +0,0 @@
-require 'bigdecimal'
-
-describe :bigdecimal_to_int , shared: true do
-  it "raises FloatDomainError if BigDecimal is infinity or NaN" do
-    lambda { BigDecimal("Infinity").send(@method) }.should raise_error(FloatDomainError)
-    lambda { BigDecimal("NaN").send(@method) }.should raise_error(FloatDomainError)
-  end
-
-  it "returns Integer or Bignum otherwise" do
-    BigDecimal("3E-20001").send(@method).should == 0
-    BigDecimal("2E4000").send(@method).should == 2 * 10 ** 4000
-    BigDecimal("2").send(@method).should == 2
-    BigDecimal("2E10").send(@method).should == 20000000000
-    BigDecimal("3.14159").send(@method).should == 3
-  end
-end