9 files changed, 118 insertions, 43 deletions
diff --git a/spec/ruby/library/bigdecimal/add_spec.rb b/spec/ruby/library/bigdecimal/add_spec.rb
index bea8b8f764..542713011d 100644
--- a/spec/ruby/library/bigdecimal/add_spec.rb
+++ b/spec/ruby/library/bigdecimal/add_spec.rb
@@ -24,7 +24,7 @@ describe "BigDecimal#add" do
   end
 
   it "returns a + b with given precision" do
-    # documentation states, that precision ist optional, but it ain't,
+    # 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
@@ -60,7 +60,7 @@ describe "BigDecimal#add" do
   end
 
 #  TODO:
-#  http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/17374
+#  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)
diff --git a/spec/ruby/library/bigdecimal/core_spec.rb b/spec/ruby/library/bigdecimal/core_spec.rb
new file mode 100644
index 0000000000..acee4dcf56
--- /dev/null
+++ b/spec/ruby/library/bigdecimal/core_spec.rb
@@ -0,0 +1,59 @@
+require_relative '../../spec_helper'
+require 'bigdecimal'
+
+describe "Core extension by bigdecimal" do
+  context "Integer#coerce" do
+    it "produces Floats" do
+      x, y = 3.coerce(BigDecimal("3.4"))
+      x.class.should == Float
+      x.should == 3.4
+      y.class.should == Float
+      y.should == 3.0
+    end
+  end
+
+  describe "Time.at passed BigDecimal" do
+    it "doesn't round input value" do
+      Time.at(BigDecimal('1.1')).to_f.should == 1.1
+    end
+  end
+
+  describe "BigDecimal#log" do
+    it "handles high-precision Rational arguments" do
+      result = BigDecimal('0.22314354220170971436137296411949880462556361100856391620766259404746040597133837784E0')
+      r = Rational(1_234_567_890, 987_654_321)
+      BigMath.log(r, 50).should == result
+    end
+  end
+
+  describe "Rational#coerce" do
+    it "returns the passed argument, self as Float, when given a Float" do
+      result = Rational(3, 4).coerce(1.0)
+      result.should == [1.0, 0.75]
+      result.first.is_a?(Float).should be_true
+      result.last.is_a?(Float).should be_true
+    end
+
+    it "returns the passed argument, self as Rational, when given an Integer" do
+      result = Rational(3, 4).coerce(10)
+      result.should == [Rational(10, 1), Rational(3, 4)]
+      result.first.is_a?(Rational).should be_true
+      result.last.is_a?(Rational).should be_true
+    end
+
+    it "coerces to Rational, when given a Complex" do
+      Rational(3, 4).coerce(Complex(5)).should == [Rational(5, 1), Rational(3, 4)]
+      Rational(12, 4).coerce(Complex(5, 1)).should == [Complex(5, 1), Complex(3)]
+    end
+
+    it "returns [argument, self] when given a Rational" do
+      Rational(3, 7).coerce(Rational(9, 2)).should == [Rational(9, 2), Rational(3, 7)]
+    end
+
+    it "raises an error when passed a BigDecimal" do
+      -> {
+        Rational(500, 3).coerce(BigDecimal('166.666666666'))
+      }.should raise_error(TypeError, /BigDecimal can't be coerced into Rational/)
+    end
+  end
+end
diff --git a/spec/ruby/library/bigdecimal/exponent_spec.rb b/spec/ruby/library/bigdecimal/exponent_spec.rb
index f63c4e5798..8877147955 100644
--- a/spec/ruby/library/bigdecimal/exponent_spec.rb
+++ b/spec/ruby/library/bigdecimal/exponent_spec.rb
@@ -18,17 +18,6 @@ describe "BigDecimal#exponent" do
     BigDecimal("1234567E10").exponent.should == 17
   end
 
-# commenting this spec out after discussion with Defiler, since it seems to be an MRI bug, not a real feature
-=begin
-  platform_is wordsize: 32 do
-    # TODO: write specs for both 32 and 64 bit
-    it "returns 0 if exponent can't be represented as Integer" do
-      BigDecimal("2E1000000000000000").exponent.should == 0
-      BigDecimal("-5E-999999999999999").exponent.should == 0
-    end
-  end
-=end
-
   it "returns 0 if self is 0" do
     BigDecimal("0").exponent.should == 0
     BigDecimal("+0").exponent.should == 0
diff --git a/spec/ruby/library/bigdecimal/remainder_spec.rb b/spec/ruby/library/bigdecimal/remainder_spec.rb
index 1866f665cd..bac5f37ba9 100644
--- a/spec/ruby/library/bigdecimal/remainder_spec.rb
+++ b/spec/ruby/library/bigdecimal/remainder_spec.rb
@@ -54,21 +54,23 @@ describe "BigDecimal#remainder" do
     @nan.remainder(@infinity).should.nan?
   end
 
-  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?
+  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_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?
+      @infinity.remainder(@infinity_minus).should.nan?
+      @infinity_minus.remainder(@infinity).should.nan?
+    end
   end
 
   it "coerces arguments to BigDecimal if possible" do
diff --git a/spec/ruby/library/bigdecimal/round_spec.rb b/spec/ruby/library/bigdecimal/round_spec.rb
index 501a1a7342..fba52df65d 100644
--- a/spec/ruby/library/bigdecimal/round_spec.rb
+++ b/spec/ruby/library/bigdecimal/round_spec.rb
@@ -228,7 +228,15 @@ describe "BigDecimal#round" do
     -> { BigDecimal('-Infinity').round(2) }.should_not raise_error(FloatDomainError)
   end
 
-  it "raise for a non-existent round mode" do
-    -> { @p1_50.round(0, :nonsense) }.should raise_error(ArgumentError, "invalid rounding mode")
+  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
+  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
   end
 end
diff --git a/spec/ruby/library/bigdecimal/shared/to_int.rb b/spec/ruby/library/bigdecimal/shared/to_int.rb
index 0f16251612..44b6a3c7b2 100644
--- a/spec/ruby/library/bigdecimal/shared/to_int.rb
+++ b/spec/ruby/library/bigdecimal/shared/to_int.rb
@@ -1,6 +1,6 @@
 require 'bigdecimal'
 
-describe :bigdecimal_to_int , shared: true do
+describe :bigdecimal_to_int, shared: true do
   it "raises FloatDomainError if BigDecimal is infinity or NaN" do
     -> { BigDecimal("Infinity").send(@method) }.should raise_error(FloatDomainError)
     -> { BigDecimal("NaN").send(@method) }.should raise_error(FloatDomainError)
diff --git a/spec/ruby/library/bigdecimal/sqrt_spec.rb b/spec/ruby/library/bigdecimal/sqrt_spec.rb
index d149003b9f..8fd1ec0f39 100644
--- a/spec/ruby/library/bigdecimal/sqrt_spec.rb
+++ b/spec/ruby/library/bigdecimal/sqrt_spec.rb
@@ -36,8 +36,10 @@ describe "BigDecimal#sqrt" 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
+  platform_is_not wordsize: 32 do # fails on i686
+    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
   end
 
   it "raises ArgumentError when no argument is given" do
diff --git a/spec/ruby/library/bigdecimal/to_r_spec.rb b/spec/ruby/library/bigdecimal/to_r_spec.rb
index 91d2b33993..c350beff08 100644
--- a/spec/ruby/library/bigdecimal/to_r_spec.rb
+++ b/spec/ruby/library/bigdecimal/to_r_spec.rb
@@ -13,4 +13,16 @@ describe "BigDecimal#to_r" do
     r.denominator.should eql(1000000000000000000000000)
   end
 
+  it "returns a Rational from a BigDecimal with an exponent" do
+    r = BigDecimal("1E2").to_r
+    r.numerator.should eql(100)
+    r.denominator.should eql(1)
+  end
+
+  it "returns a Rational from a negative BigDecimal with an exponent" do
+    r = BigDecimal("-1E2").to_r
+    r.numerator.should eql(-100)
+    r.denominator.should eql(1)
+  end
+
 end
diff --git a/spec/ruby/library/bigdecimal/to_s_spec.rb b/spec/ruby/library/bigdecimal/to_s_spec.rb
index 4f1054d38e..ba9f960eb3 100644
--- a/spec/ruby/library/bigdecimal/to_s_spec.rb
+++ b/spec/ruby/library/bigdecimal/to_s_spec.rb
@@ -39,20 +39,25 @@ describe "BigDecimal#to_s" do
     @bigneg.to_s("+").should_not =~ /^\+.*/
   end
 
-  it "inserts a space every n chars, if integer n is supplied" do
+  it "inserts a space every n chars to fraction part, if integer n is supplied" do
     re =\
-      /\A0\.314 159 265 358 979 323 846 264 338 327 950 288 419 716 939 937E1\z/i
+    /\A0\.314 159 265 358 979 323 846 264 338 327 950 288 419 716 939 937E1\z/i
     @bigdec.to_s(3).should =~ re
 
     str1 = '-123.45678 90123 45678 9'
     BigDecimal("-123.45678901234567890").to_s('5F').should ==  str1
-    BigDecimal('1000010').to_s('5F').should == "10000 10.0"
     # trailing zeroes removed
     BigDecimal("1.00000000000").to_s('1F').should == "1.0"
     # 0 is treated as no spaces
     BigDecimal("1.2345").to_s('0F').should == "1.2345"
   end
 
+  version_is BigDecimal::VERSION, "3.1.5" do #ruby_version_is '3.3' do
+    it "inserts a space every n chars to integer part, if integer n is supplied" do
+      BigDecimal('1000010').to_s('5F').should == "10 00010.0"
+    end
+  end
+
   it "can return a leading space for values > 0" do
     @bigdec.to_s(" F").should =~ /\ .*/
     @bigneg.to_s(" F").should_not =~ /\ .*/
@@ -83,15 +88,13 @@ describe "BigDecimal#to_s" do
     end
   end
 
-  ruby_version_is "3.0" do
-    it "returns a String in US-ASCII encoding when Encoding.default_internal is nil" do
-      Encoding.default_internal = nil
-      BigDecimal('1.23').to_s.encoding.should equal(Encoding::US_ASCII)
-    end
+  it "returns a String in US-ASCII encoding when Encoding.default_internal is nil" do
+    Encoding.default_internal = nil
+    BigDecimal('1.23').to_s.encoding.should equal(Encoding::US_ASCII)
+  end
 
-    it "returns a String in US-ASCII encoding when Encoding.default_internal is not nil" do
-      Encoding.default_internal = Encoding::IBM437
-      BigDecimal('1.23').to_s.encoding.should equal(Encoding::US_ASCII)
-    end
+  it "returns a String in US-ASCII encoding when Encoding.default_internal is not nil" do
+    Encoding.default_internal = Encoding::IBM437
+    BigDecimal('1.23').to_s.encoding.should equal(Encoding::US_ASCII)
   end
 end