Add in-tree mspec and ruby/spec

* For easier modifications of ruby/spec by MRI developers. * .gitignore: track changes under spec. * spec/mspec, spec/rubyspec: add in-tree mspec and ruby/spec. These files can therefore be updated like any other file in MRI. Instructions are provided in spec/README. [Feature #13156] [ruby-core:79246] git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@58595 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
author: eregon <eregon@b2dd03c8-39d4-4d8f-98ff-823fe69b080e> 2017-05-07 12:04:49 +0000
committer: eregon <eregon@b2dd03c8-39d4-4d8f-98ff-823fe69b080e> 2017-05-07 12:04:49 +0000
commit: 95e8c48dd3348503a8c7db5d0498894a1b676395 (patch)
tree: 9eef7f720314ebaff56845a74e203770e62284e4 /spec/rubyspec/library/bigdecimal
parent: ed7d803500de38186c74bce94d233e85ef51e503 (diff)
58 files changed, 3280 insertions, 0 deletions
diff --git a/spec/rubyspec/library/bigdecimal/abs_spec.rb b/spec/rubyspec/library/bigdecimal/abs_spec.rb
new file mode 100644
index 0000000000..9027abfb47
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/abs_spec.rb
@@ -0,0 +1,50 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+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.nan?.should == true # 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
+
+end
diff --git a/spec/rubyspec/library/bigdecimal/add_spec.rb b/spec/rubyspec/library/bigdecimal/add_spec.rb
new file mode 100644
index 0000000000..6136c9dccb
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/add_spec.rb
@@ -0,0 +1,179 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+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 ist 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")
+    }
+  end
+
+#  TODO:
+#  http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/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
+
+  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
+  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
+  end
+
+  it "uses the default ROUND_HALF_UP rounding if it wasn't explicitly changed" do
+    BigDecimal('0.85').add(@zero, 1).should == BigDecimal('0.9')
+    BigDecimal('-0.85').add(@zero, 1).should == BigDecimal('-0.9')
+  end
+
+  it "returns NaN if NaN is involved" do
+    @one.add(@nan, 10000).nan?.should == true
+    @nan.add(@one, 1).nan?.should == true
+  end
+
+  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
+  end
+
+  it "returns NaN if Infinity + (- Infinity)" do
+    @infinity.add(@infinity_minus, 10000).nan?.should == true
+    @infinity_minus.add(@infinity, 10000).nan?.should == true
+  end
+
+  it "raises TypeError when adds nil" do
+    lambda {
+      @one.add(nil, 10)
+    }.should raise_error(TypeError)
+    lambda {
+      @one.add(nil, 0)
+    }.should raise_error(TypeError)
+  end
+
+  it "raises TypeError when precision parameter is nil" do
+    lambda {
+      @one.add(@one, nil)
+    }.should raise_error(TypeError)
+  end
+
+  it "raises ArgumentError when precision parameter is negative" do
+    lambda {
+      @one.add(@one, -10)
+    }.should raise_error(ArgumentError)
+  end
+end
diff --git a/spec/rubyspec/library/bigdecimal/case_compare_spec.rb b/spec/rubyspec/library/bigdecimal/case_compare_spec.rb
new file mode 100644
index 0000000000..dcbde80e85
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/case_compare_spec.rb
@@ -0,0 +1,7 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../shared/eql.rb', __FILE__)
+
+
+describe "BigDecimal#===" do
+  it_behaves_like(:bigdecimal_eql, :===)
+end
diff --git a/spec/rubyspec/library/bigdecimal/ceil_spec.rb b/spec/rubyspec/library/bigdecimal/ceil_spec.rb
new file mode 100644
index 0000000000..d8829411b9
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/ceil_spec.rb
@@ -0,0 +1,104 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+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
+    lambda { @infinity.ceil }.should raise_error(FloatDomainError)
+    lambda { @infinity_neg.ceil }.should raise_error(FloatDomainError)
+    lambda { @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
+  end
+
+end
diff --git a/spec/rubyspec/library/bigdecimal/coerce_spec.rb b/spec/rubyspec/library/bigdecimal/coerce_spec.rb
new file mode 100644
index 0000000000..1c63ddf2bc
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/coerce_spec.rb
@@ -0,0 +1,26 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+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
+
+end
diff --git a/spec/rubyspec/library/bigdecimal/comparison_spec.rb b/spec/rubyspec/library/bigdecimal/comparison_spec.rb
new file mode 100644
index 0000000000..c4de8348b2
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/comparison_spec.rb
@@ -0,0 +1,81 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+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
+    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
+end
diff --git a/spec/rubyspec/library/bigdecimal/div_spec.rb b/spec/rubyspec/library/bigdecimal/div_spec.rb
new file mode 100644
index 0000000000..f8f8ac4e5e
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/div_spec.rb
@@ -0,0 +1,102 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../shared/quo', __FILE__)
+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]
+end
+
+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
+
+  it "raises FloatDomainError if NaN is involved" do
+    lambda { @one.div(@nan) }.should raise_error(FloatDomainError)
+    lambda { @nan.div(@one) }.should raise_error(FloatDomainError)
+    lambda { @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
+    lambda { @one.div(@zero) }.should raise_error(ZeroDivisionError)
+    lambda { @one.div(@zero_plus) }.should raise_error(ZeroDivisionError)
+    lambda { @one.div(@zero_minus) }.should raise_error(ZeroDivisionError)
+
+    lambda { @zero.div(@zero) }.should raise_error(ZeroDivisionError)
+    lambda { @zero_minus.div(@zero_plus) }.should raise_error(ZeroDivisionError)
+    lambda { @zero_minus.div(@zero_minus) }.should raise_error(ZeroDivisionError)
+    lambda { @zero_plus.div(@zero_minus) }.should raise_error(ZeroDivisionError)
+  end
+
+  it "returns NaN if zero is divided by zero" do
+    @zero.div(@zero, 0).nan?.should == true
+    @zero_minus.div(@zero_plus, 0).nan?.should == true
+    @zero_plus.div(@zero_minus, 0).nan?.should == true
+
+    @zero.div(@zero, 10).nan?.should == true
+    @zero_minus.div(@zero_plus, 10).nan?.should == true
+    @zero_plus.div(@zero_minus, 10).nan?.should == true
+  end
+
+  it "raises FloatDomainError if (+|-) Infinity divided by 1 and no precision given" do
+    lambda { @infinity_minus.div(@one) }.should raise_error(FloatDomainError)
+    lambda { @infinity.div(@one) }.should raise_error(FloatDomainError)
+    lambda { @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).nan?.should == true
+    @infinity_minus.div(@infinity, 1).nan?.should == true
+  end
+
+
+end
diff --git a/spec/rubyspec/library/bigdecimal/divide_spec.rb b/spec/rubyspec/library/bigdecimal/divide_spec.rb
new file mode 100644
index 0000000000..4dfe2702bb
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/divide_spec.rb
@@ -0,0 +1,7 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../shared/quo', __FILE__)
+require 'bigdecimal'
+
+describe "BigDecimal#/" do
+  it_behaves_like :bigdecimal_quo, :/, []
+end
diff --git a/spec/rubyspec/library/bigdecimal/divmod_spec.rb b/spec/rubyspec/library/bigdecimal/divmod_spec.rb
new file mode 100644
index 0000000000..839a289ab6
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/divmod_spec.rb
@@ -0,0 +1,180 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../shared/modulo', __FILE__)
+require 'bigdecimal'
+
+module DivmodSpecs
+  def self.check_both_nan(array)
+    array.length.should == 2
+    array[0].nan?.should == true
+    array[1].nan?.should == true
+  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
+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
+    end
+  end
+
+  after :all do
+    class BigDecimal
+      undef mod_part_of_divmod
+    end
+  end
+
+  it_behaves_like :bigdecimal_modulo, :mod_part_of_divmod
+
+  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)
+  end
+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.new("42")
+    b = BigDecimal.new("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
+    end
+  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
+  end
+
+  it "raises ZeroDivisionError if the divisor is zero" do
+    (@special_vals + @regular_vals + @zeroes - [@nan]).each do |val|
+      @zeroes.each do |zero|
+        lambda { val.divmod(zero) }.should raise_error(ZeroDivisionError)
+      end
+    end
+  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].nan?.should == true
+    end
+  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
+  end
+
+  it "returns an array of two zero if the diviend is zero" do
+    @zeroes.each do |zero|
+      @regular_vals.each do |val|
+        zero.divmod(val).should == [@zero, @zero]
+      end
+    end
+  end
+
+  it "raises TypeError if the argument cannot be coerced to BigDecimal" do
+    lambda {
+      @one.divmod('1')
+    }.should raise_error(TypeError)
+  end
+
+end
diff --git a/spec/rubyspec/library/bigdecimal/double_fig_spec.rb b/spec/rubyspec/library/bigdecimal/double_fig_spec.rb
new file mode 100644
index 0000000000..3ab5c2f207
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/double_fig_spec.rb
@@ -0,0 +1,9 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+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
+end
diff --git a/spec/rubyspec/library/bigdecimal/eql_spec.rb b/spec/rubyspec/library/bigdecimal/eql_spec.rb
new file mode 100644
index 0000000000..f3f525a7ba
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/eql_spec.rb
@@ -0,0 +1,6 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../shared/eql.rb', __FILE__)
+
+describe "BigDecimal#eql?" do
+  it_behaves_like(:bigdecimal_eql, :eql?)
+end
diff --git a/spec/rubyspec/library/bigdecimal/equal_value_spec.rb b/spec/rubyspec/library/bigdecimal/equal_value_spec.rb
new file mode 100644
index 0000000000..bd07217b98
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/equal_value_spec.rb
@@ -0,0 +1,7 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../shared/eql.rb', __FILE__)
+
+
+describe "BigDecimal#==" do
+  it_behaves_like(:bigdecimal_eql, :==)
+end
diff --git a/spec/rubyspec/library/bigdecimal/exponent_spec.rb b/spec/rubyspec/library/bigdecimal/exponent_spec.rb
new file mode 100644
index 0000000000..6bb678d4ed
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/exponent_spec.rb
@@ -0,0 +1,38 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../shared/power', __FILE__)
+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
+
+# 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 Fixnum" 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
+    BigDecimal("-0").exponent.should == 0
+  end
+
+end
diff --git a/spec/rubyspec/library/bigdecimal/finite_spec.rb b/spec/rubyspec/library/bigdecimal/finite_spec.rb
new file mode 100644
index 0000000000..6d6d8398fa
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/finite_spec.rb
@@ -0,0 +1,35 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+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.finite?.should == false
+    @infinity_minus.finite?.should == false
+    @nan.finite?.should == false
+  end
+
+  it "returns true for finite values" do
+    @finite_vals.each do |val|
+      val.finite?.should == true
+    end
+  end
+end
+
diff --git a/spec/rubyspec/library/bigdecimal/fix_spec.rb b/spec/rubyspec/library/bigdecimal/fix_spec.rb
new file mode 100644
index 0000000000..0a4a98c241
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/fix_spec.rb
@@ -0,0 +1,57 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+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
+  end
+
+  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.nan?.should == true
+  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
+    lambda {
+      @mixed.fix(10)
+    }.should raise_error(ArgumentError)
+  end
+
+end
diff --git a/spec/rubyspec/library/bigdecimal/fixtures/classes.rb b/spec/rubyspec/library/bigdecimal/fixtures/classes.rb
new file mode 100644
index 0000000000..06e4474cf0
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/fixtures/classes.rb
@@ -0,0 +1,17 @@
+module BigDecimalSpecs
+  # helper method to sure that the global limit is reset back
+  def self.with_limit(l)
+    old = BigDecimal.limit(l)
+    yield
+  ensure
+    BigDecimal.limit(old)
+  end
+
+  def self.with_rounding(r)
+    old = BigDecimal.mode(BigDecimal::ROUND_MODE)
+    BigDecimal.mode(BigDecimal::ROUND_MODE, r)
+    yield
+  ensure
+    BigDecimal.mode(BigDecimal::ROUND_MODE, old)
+  end
+end
diff --git a/spec/rubyspec/library/bigdecimal/floor_spec.rb b/spec/rubyspec/library/bigdecimal/floor_spec.rb
new file mode 100644
index 0000000000..0bae6e4ab0
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/floor_spec.rb
@@ -0,0 +1,100 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+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
+    lambda { @infinity.floor }.should raise_error(FloatDomainError)
+    lambda { @infinity_neg.floor }.should raise_error(FloatDomainError)
+    lambda { @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
+  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')
+  end
+
+end
diff --git a/spec/rubyspec/library/bigdecimal/frac_spec.rb b/spec/rubyspec/library/bigdecimal/frac_spec.rb
new file mode 100644
index 0000000000..9a727a70dd
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/frac_spec.rb
@@ -0,0 +1,48 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+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.nan?.should == true
+  end
+
+end
diff --git a/spec/rubyspec/library/bigdecimal/gt_spec.rb b/spec/rubyspec/library/bigdecimal/gt_spec.rb
new file mode 100644
index 0000000000..effd3ea35f
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/gt_spec.rb
@@ -0,0 +1,83 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+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
+    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")
+    @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 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
+    lambda {@zero         > nil }.should raise_error(ArgumentError)
+    lambda {@infinity     > nil }.should raise_error(ArgumentError)
+    lambda {@infinity_neg > nil }.should raise_error(ArgumentError)
+    lambda {@mixed        > nil }.should raise_error(ArgumentError)
+    lambda {@pos_int      > nil }.should raise_error(ArgumentError)
+    lambda {@neg_frac     > nil }.should raise_error(ArgumentError)
+  end
+end
diff --git a/spec/rubyspec/library/bigdecimal/gte_spec.rb b/spec/rubyspec/library/bigdecimal/gte_spec.rb
new file mode 100644
index 0000000000..28e84690ad
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/gte_spec.rb
@@ -0,0 +1,87 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+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
+    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")
+    @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 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
+    lambda {@zero         >= nil }.should raise_error(ArgumentError)
+    lambda {@infinity     >= nil }.should raise_error(ArgumentError)
+    lambda {@infinity_neg >= nil }.should raise_error(ArgumentError)
+    lambda {@mixed        >= nil }.should raise_error(ArgumentError)
+    lambda {@pos_int      >= nil }.should raise_error(ArgumentError)
+    lambda {@neg_frac     >= nil }.should raise_error(ArgumentError)
+  end
+end
diff --git a/spec/rubyspec/library/bigdecimal/infinite_spec.rb b/spec/rubyspec/library/bigdecimal/infinite_spec.rb
new file mode 100644
index 0000000000..b218ee371c
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/infinite_spec.rb
@@ -0,0 +1,32 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+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
+
+end
diff --git a/spec/rubyspec/library/bigdecimal/inspect_spec.rb b/spec/rubyspec/library/bigdecimal/inspect_spec.rb
new file mode 100644
index 0000000000..9831b2be8e
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/inspect_spec.rb
@@ -0,0 +1,47 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require 'bigdecimal'
+
+describe "BigDecimal#inspect" do
+
+  before :each do
+    @bigdec = BigDecimal.new("1234.5678")
+  end
+
+  it "returns String" do
+    @bigdec.inspect.kind_of?(String).should == true
+  end
+
+  ruby_version_is ""..."2.4" do
+    it "returns String starting with #" do
+      @bigdec.inspect[0].should == ?#
+    end
+
+    it "encloses information in angle brackets" do
+      @bigdec.inspect.should =~ /^.<.*>$/
+    end
+
+    it "is comma separated list of three items" do
+      @bigdec.inspect.should =~ /...*,.*,.*/
+    end
+
+    it "value after first comma is value as string" do
+      @bigdec.inspect.split(",")[1].should == "\'0.12345678E4\'"
+    end
+
+    it "last part is number of significant digits" do
+      signific_string = "#{@bigdec.precs[0]}(#{@bigdec.precs[1]})"
+      @bigdec.inspect.split(",")[2].should == signific_string + ">"
+    end
+
+    it "looks like this" do
+      regex = /^\#\<BigDecimal\:.*,'0\.12345678E4',[0-9]+\([0-9]+\)>$/
+      @bigdec.inspect.should =~ regex
+    end
+  end
+
+  ruby_version_is "2.4" do
+    it "looks like this" do
+      @bigdec.inspect.should == "0.12345678e4"
+    end
+  end
+end
diff --git a/spec/rubyspec/library/bigdecimal/limit_spec.rb b/spec/rubyspec/library/bigdecimal/limit_spec.rb
new file mode 100644
index 0000000000..41308abcd8
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/limit_spec.rb
@@ -0,0 +1,30 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+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)
+  end
+
+  it "use 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('3')).should == BigDecimal('2.664')
+    end
+
+    BigDecimalSpecs.with_limit(1) do
+      (BigDecimal('0.888') + BigDecimal('0')).should == BigDecimal('0.9')
+      (BigDecimal('0.888') * BigDecimal('3')).should == BigDecimal('3')
+    end
+
+    BigDecimalSpecs.with_limit(2) do
+      (BigDecimal('0.888') + BigDecimal('0')).should == BigDecimal('0.89')
+      (BigDecimal('0.888') * BigDecimal('3')).should == BigDecimal('2.7')
+    end
+  end
+end
diff --git a/spec/rubyspec/library/bigdecimal/lt_spec.rb b/spec/rubyspec/library/bigdecimal/lt_spec.rb
new file mode 100644
index 0000000000..67811c5db4
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/lt_spec.rb
@@ -0,0 +1,81 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+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
+    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")
+    @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 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
+    lambda {@zero         < nil }.should raise_error(ArgumentError)
+    lambda {@infinity     < nil }.should raise_error(ArgumentError)
+    lambda {@infinity_neg < nil }.should raise_error(ArgumentError)
+    lambda {@mixed        < nil }.should raise_error(ArgumentError)
+    lambda {@pos_int      < nil }.should raise_error(ArgumentError)
+    lambda {@neg_frac     < nil }.should raise_error(ArgumentError)
+  end
+end
diff --git a/spec/rubyspec/library/bigdecimal/lte_spec.rb b/spec/rubyspec/library/bigdecimal/lte_spec.rb
new file mode 100644
index 0000000000..61fb676245
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/lte_spec.rb
@@ -0,0 +1,87 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+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
+    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")
+    @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 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
+    lambda {@zero         <= nil }.should raise_error(ArgumentError)
+    lambda {@infinity     <= nil }.should raise_error(ArgumentError)
+    lambda {@infinity_neg <= nil }.should raise_error(ArgumentError)
+    lambda {@mixed        <= nil }.should raise_error(ArgumentError)
+    lambda {@pos_int      <= nil }.should raise_error(ArgumentError)
+    lambda {@neg_frac     <= nil }.should raise_error(ArgumentError)
+  end
+end
diff --git a/spec/rubyspec/library/bigdecimal/minus_spec.rb b/spec/rubyspec/library/bigdecimal/minus_spec.rb
new file mode 100644
index 0000000000..bdd8478465
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/minus_spec.rb
@@ -0,0 +1,58 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+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).nan?.should == true
+    (@nan - @one).nan?.should == true
+    (@nan - @nan).nan?.should == true
+    (@nan - @infinity).nan?.should == true
+    (@nan - @infinity_minus).nan?.should == true
+    (@infinity - @nan).nan?.should == true
+    (@infinity_minus - @nan).nan?.should == true
+  end
+
+  it "returns NaN both operands are infinite with the same sign" do
+    (@infinity - @infinity).nan?.should == true
+    (@infinity_minus - @infinity_minus).nan?.should == true
+  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
+
+end
diff --git a/spec/rubyspec/library/bigdecimal/mode_spec.rb b/spec/rubyspec/library/bigdecimal/mode_spec.rb
new file mode 100644
index 0000000000..d88ac61aaf
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/mode_spec.rb
@@ -0,0 +1,36 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+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).nan?.should == true
+    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)
+    lambda { BigDecimal("NaN").add(BigDecimal("1"),0) }.should raise_error(FloatDomainError)
+    BigDecimal.mode(BigDecimal::EXCEPTION_INFINITY, true)
+    lambda { BigDecimal("0").add(BigDecimal("Infinity"),0) }.should raise_error(FloatDomainError)
+    BigDecimal.mode(BigDecimal::EXCEPTION_ZERODIVIDE, true)
+    lambda { BigDecimal("1").quo(BigDecimal("0")) }.should raise_error(FloatDomainError)
+    BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, true)
+    lambda { BigDecimal("1E11111111111111111111") }.should raise_error(FloatDomainError)
+    lambda { (BigDecimal("1E1000000000000000000")**10) }.should raise_error(FloatDomainError)
+  end
+end
diff --git a/spec/rubyspec/library/bigdecimal/modulo_spec.rb b/spec/rubyspec/library/bigdecimal/modulo_spec.rb
new file mode 100644
index 0000000000..6feeb685eb
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/modulo_spec.rb
@@ -0,0 +1,12 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../shared/modulo', __FILE__)
+
+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
diff --git a/spec/rubyspec/library/bigdecimal/mult_spec.rb b/spec/rubyspec/library/bigdecimal/mult_spec.rb
new file mode 100644
index 0000000000..a140cf899a
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/mult_spec.rb
@@ -0,0 +1,24 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../shared/mult', __FILE__)
+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"
+    @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
+
+end
diff --git a/spec/rubyspec/library/bigdecimal/multiply_spec.rb b/spec/rubyspec/library/bigdecimal/multiply_spec.rb
new file mode 100644
index 0000000000..842e22eaa2
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/multiply_spec.rb
@@ -0,0 +1,26 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../shared/mult', __FILE__)
+require 'bigdecimal'
+
+describe "BigDecimal#*" do
+  it_behaves_like :bigdecimal_mult, :*, []
+end
+
+describe "BigDecimal#*" do
+  before :each do
+    @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
+end
diff --git a/spec/rubyspec/library/bigdecimal/nan_spec.rb b/spec/rubyspec/library/bigdecimal/nan_spec.rb
new file mode 100644
index 0000000000..5c291629b3
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/nan_spec.rb
@@ -0,0 +1,23 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require 'bigdecimal'
+
+describe "BigDecimal#nan?" do
+
+  it "returns true if self is not a number" do
+    BigDecimal("NaN").nan?.should == true
+  end
+
+  it "returns false if self is not a NaN" do
+    BigDecimal("Infinity").nan?.should == false
+    BigDecimal("-Infinity").nan?.should == false
+    BigDecimal("0").nan?.should == false
+    BigDecimal("+0").nan?.should == false
+    BigDecimal("-0").nan?.should == false
+    BigDecimal("2E40001").nan?.should == false
+    BigDecimal("3E-20001").nan?.should == false
+    BigDecimal("0E-200000000").nan?.should == false
+    BigDecimal("0E200000000000").nan?.should == false
+    BigDecimal("0.000000000000000000000000").nan?.should == false
+  end
+
+end
diff --git a/spec/rubyspec/library/bigdecimal/new_spec.rb b/spec/rubyspec/library/bigdecimal/new_spec.rb
new file mode 100644
index 0000000000..de3aa195ca
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/new_spec.rb
@@ -0,0 +1,109 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require 'bigdecimal'
+
+describe "BigDecimal.new" do
+
+  it "creates a new object of class BigDecimal" do
+    BigDecimal.new("3.14159").should be_kind_of(BigDecimal)
+    (0..9).each {|i|
+      BigDecimal.new("1#{i}").should == 10 + i
+      BigDecimal.new("-1#{i}").should == -10 - i
+      BigDecimal.new("1E#{i}").should == 10**i
+      BigDecimal.new("1000000E-#{i}").should == 10**(6-i).to_f
+      # ^ to_f to avoid Rational type
+    }
+    (1..9).each {|i|
+      BigDecimal.new("100.#{i}").to_s.should =~ /\A0\.100#{i}E3\z/i
+      BigDecimal.new("-100.#{i}").to_s.should =~ /\A-0\.100#{i}E3\z/i
+    }
+  end
+
+  it "accepts significant digits >= given precision" do
+    BigDecimal.new("3.1415923", 10).precs[1].should >= 10
+  end
+
+  it "determines precision from initial value" do
+    pi_string = "3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196442881097566593014782083152134043"
+    BigDecimal.new(pi_string).precs[1].should >= pi_string.size-1
+  end
+
+  it "ignores leading whitespace" do
+    BigDecimal.new("  \t\n \r1234").should == BigDecimal.new("1234")
+    BigDecimal.new("  \t\n \rNaN   \n").nan?.should == true
+    BigDecimal.new("  \t\n \rInfinity   \n").infinite?.should == 1
+    BigDecimal.new("  \t\n \r-Infinity   \n").infinite?.should == -1
+  end
+
+  it "ignores trailing garbage" do
+    BigDecimal.new("123E45ruby").should == BigDecimal.new("123E45")
+    BigDecimal.new("123x45").should == BigDecimal.new("123")
+    BigDecimal.new("123.4%E5").should == BigDecimal.new("123.4")
+    BigDecimal.new("1E2E3E4E5E").should == BigDecimal.new("100")
+  end
+
+  ruby_version_is ""..."2.4" do
+    it "treats invalid strings as 0.0" do
+      BigDecimal.new("ruby").should == BigDecimal.new("0.0")
+      BigDecimal.new("  \t\n \r-\t\t\tInfinity   \n").should == BigDecimal.new("0.0")
+    end
+  end
+
+  ruby_version_is "2.4" do
+    it "raises ArgumentError for invalid strings" do
+      lambda { BigDecimal.new("ruby") }.should raise_error(ArgumentError)
+      lambda { BigDecimal.new("  \t\n \r-\t\t\tInfinity   \n") }.should raise_error(ArgumentError)
+    end
+  end
+
+  it "allows omitting the integer part" do
+    BigDecimal.new(".123").should == BigDecimal.new("0.123")
+  end
+
+  it "allows for underscores in all parts" do
+    reference = BigDecimal.new("12345.67E89")
+
+    BigDecimal.new("12_345.67E89").should == reference
+    BigDecimal.new("1_2_3_4_5_._6____7_E89").should == reference
+    BigDecimal.new("12345_.67E_8__9_").should == reference
+  end
+
+  it "accepts NaN and [+-]Infinity" do
+    BigDecimal.new("NaN").nan?.should == true
+
+    pos_inf = BigDecimal.new("Infinity")
+    pos_inf.finite?.should == false
+    pos_inf.should > 0
+    pos_inf.should == BigDecimal.new("+Infinity")
+
+    neg_inf = BigDecimal.new("-Infinity")
+    neg_inf.finite?.should == false
+    neg_inf.should < 0
+  end
+
+  it "allows for [eEdD] as exponent separator" do
+    reference = BigDecimal.new("12345.67E89")
+
+    BigDecimal.new("12345.67e89").should == reference
+    BigDecimal.new("12345.67E89").should == reference
+    BigDecimal.new("12345.67d89").should == reference
+    BigDecimal.new("12345.67D89").should == reference
+  end
+
+  it "allows for varying signs" do
+    reference = BigDecimal.new("123.456E1")
+
+    BigDecimal.new("+123.456E1").should == reference
+    BigDecimal.new("-123.456E1").should == -reference
+    BigDecimal.new("123.456E+1").should == reference
+    BigDecimal.new("12345.6E-1").should == reference
+    BigDecimal.new("+123.456E+1").should == reference
+    BigDecimal.new("+12345.6E-1").should == reference
+    BigDecimal.new("-123.456E+1").should == -reference
+    BigDecimal.new("-12345.6E-1").should == -reference
+  end
+
+  it 'raises ArgumentError when Float is used without precision' do
+    lambda { BigDecimal(1.0) }.should raise_error(ArgumentError)
+  end
+
+end
diff --git a/spec/rubyspec/library/bigdecimal/nonzero_spec.rb b/spec/rubyspec/library/bigdecimal/nonzero_spec.rb
new file mode 100644
index 0000000000..336c72a6b2
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/nonzero_spec.rb
@@ -0,0 +1,29 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+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
+
+end
diff --git a/spec/rubyspec/library/bigdecimal/plus_spec.rb b/spec/rubyspec/library/bigdecimal/plus_spec.rb
new file mode 100644
index 0000000000..72ec282075
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/plus_spec.rb
@@ -0,0 +1,47 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+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).nan?.should == true
+    (@nan + @one).nan?.should == true
+  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).nan?.should == true
+  end
+
+end
diff --git a/spec/rubyspec/library/bigdecimal/power_spec.rb b/spec/rubyspec/library/bigdecimal/power_spec.rb
new file mode 100644
index 0000000000..f2b1a9b5c8
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/power_spec.rb
@@ -0,0 +1,6 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../shared/power', __FILE__)
+
+describe "BigDecimal#power" do
+  it_behaves_like(:bigdecimal_power, :power)
+end
diff --git a/spec/rubyspec/library/bigdecimal/precs_spec.rb b/spec/rubyspec/library/bigdecimal/precs_spec.rb
new file mode 100644
index 0000000000..c7700a3819
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/precs_spec.rb
@@ -0,0 +1,49 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+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
+    @arr.each do |x|
+      x.precs.kind_of?(Array).should == true
+      x.precs.size.should == 2
+    end
+  end
+
+  it "returns Integers as array values" do
+    @arr.each do |x|
+      x.precs[0].kind_of?(Integer).should == true
+      x.precs[1].kind_of?(Integer).should == true
+    end
+  end
+
+  it "returns the current value of significant digits as the first value" 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
+  end
+
+  it "returns the maximum number of significant digits as the second value" do
+    BigDecimal("3.14159").precs[1].should >= 6
+    BigDecimal('1').precs[1].should >= 1
+    BigDecimal('1' + '0' * 100).precs[1] >= 101
+    [@infinity, @infinity_neg, @nan, @zero, @zero_neg].each do |value|
+      value.precs[1].should >= 1
+    end
+  end
+end
+
diff --git a/spec/rubyspec/library/bigdecimal/quo_spec.rb b/spec/rubyspec/library/bigdecimal/quo_spec.rb
new file mode 100644
index 0000000000..bc27fd0f5e
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/quo_spec.rb
@@ -0,0 +1,13 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../shared/quo', __FILE__)
+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")).nan?.should == true
+    BigDecimal("NaN").quo(BigDecimal("1")).nan?.should == true
+  end
+end
+
diff --git a/spec/rubyspec/library/bigdecimal/remainder_spec.rb b/spec/rubyspec/library/bigdecimal/remainder_spec.rb
new file mode 100644
index 0000000000..796522c5c8
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/remainder_spec.rb
@@ -0,0 +1,84 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require 'bigdecimal'
+
+describe "BigDecimal#remainder" do
+
+  before :each do
+    @zero = BigDecimal("0")
+    @one = BigDecimal("0")
+    @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).nan?.should == true
+    @zero.remainder(@zero).nan?.should == true
+  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).nan?.should == true
+    @nan.remainder(@one).nan?.should == true
+    @one.remainder(@nan).nan?.should == true
+    @infinity.remainder(@nan).nan?.should == true
+    @nan.remainder(@infinity).nan?.should == true
+  end
+
+  it "returns NaN if Infinity is involved" do
+    @infinity.remainder(@infinity).nan?.should == true
+    @infinity.remainder(@one).nan?.should == true
+    @infinity.remainder(@mixed).nan?.should == true
+    @infinity.remainder(@one_minus).nan?.should == true
+    @infinity.remainder(@frac_1).nan?.should == true
+    @one.remainder(@infinity).nan?.should == true
+
+    @infinity_minus.remainder(@infinity_minus).nan?.should == true
+    @infinity_minus.remainder(@one).nan?.should == true
+    @one.remainder(@infinity_minus).nan?.should == true
+    @frac_2.remainder(@infinity_minus).nan?.should == true
+
+    @infinity.remainder(@infinity_minus).nan?.should == true
+    @infinity_minus.remainder(@infinity).nan?.should == true
+  end
+
+  it "coerces arguments to BigDecimal if possible" do
+    @one.remainder(2).should == @one
+  end
+
+
+  it "raises TypeError if the argument cannot be coerced to BigDecimal" do
+    lambda {
+      @one.remainder('2')
+    }.should raise_error(TypeError)
+  end
+
+end
diff --git a/spec/rubyspec/library/bigdecimal/round_spec.rb b/spec/rubyspec/library/bigdecimal/round_spec.rb
new file mode 100644
index 0000000000..6c1987c5d8
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/round_spec.rb
@@ -0,0 +1,202 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+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
+
+  describe "BigDecimal::ROUND_UP" do
+    it "rounds values away from zero" do
+      @p1_50.round(0, BigDecimal::ROUND_UP).should == @two
+      @p1_51.round(0, BigDecimal::ROUND_UP).should == @two
+      @p1_49.round(0, BigDecimal::ROUND_UP).should == @two
+      @n1_50.round(0, BigDecimal::ROUND_UP).should == @neg_two
+      @n1_51.round(0, BigDecimal::ROUND_UP).should == @neg_two
+      @n1_49.round(0, BigDecimal::ROUND_UP).should == @neg_two
+
+      @p2_50.round(0, BigDecimal::ROUND_UP).should == @three
+      @p2_51.round(0, BigDecimal::ROUND_UP).should == @three
+      @p2_49.round(0, BigDecimal::ROUND_UP).should == @three
+      @n2_50.round(0, BigDecimal::ROUND_UP).should == @neg_three
+      @n2_51.round(0, BigDecimal::ROUND_UP).should == @neg_three
+      @n2_49.round(0, BigDecimal::ROUND_UP).should == @neg_three
+    end
+  end
+
+  describe "BigDecimal::ROUND_DOWN" do
+    it "rounds values towards zero" do
+      @p1_50.round(0, BigDecimal::ROUND_DOWN).should == @one
+      @p1_51.round(0, BigDecimal::ROUND_DOWN).should == @one
+      @p1_49.round(0, BigDecimal::ROUND_DOWN).should == @one
+      @n1_50.round(0, BigDecimal::ROUND_DOWN).should == @neg_one
+      @n1_51.round(0, BigDecimal::ROUND_DOWN).should == @neg_one
+      @n1_49.round(0, BigDecimal::ROUND_DOWN).should == @neg_one
+
+      @p2_50.round(0, BigDecimal::ROUND_DOWN).should == @two
+      @p2_51.round(0, BigDecimal::ROUND_DOWN).should == @two
+      @p2_49.round(0, BigDecimal::ROUND_DOWN).should == @two
+      @n2_50.round(0, BigDecimal::ROUND_DOWN).should == @neg_two
+      @n2_51.round(0, BigDecimal::ROUND_DOWN).should == @neg_two
+      @n2_49.round(0, BigDecimal::ROUND_DOWN).should == @neg_two
+    end
+  end
+
+  describe "BigDecimal::ROUND_HALF_UP" do
+    it "rounds values >= 5 up, otherwise down" do
+      @p1_50.round(0, BigDecimal::ROUND_HALF_UP).should == @two
+      @p1_51.round(0, BigDecimal::ROUND_HALF_UP).should == @two
+      @p1_49.round(0, BigDecimal::ROUND_HALF_UP).should == @one
+      @n1_50.round(0, BigDecimal::ROUND_HALF_UP).should == @neg_two
+      @n1_51.round(0, BigDecimal::ROUND_HALF_UP).should == @neg_two
+      @n1_49.round(0, BigDecimal::ROUND_HALF_UP).should == @neg_one
+
+      @p2_50.round(0, BigDecimal::ROUND_HALF_UP).should == @three
+      @p2_51.round(0, BigDecimal::ROUND_HALF_UP).should == @three
+      @p2_49.round(0, BigDecimal::ROUND_HALF_UP).should == @two
+      @n2_50.round(0, BigDecimal::ROUND_HALF_UP).should == @neg_three
+      @n2_51.round(0, BigDecimal::ROUND_HALF_UP).should == @neg_three
+      @n2_49.round(0, BigDecimal::ROUND_HALF_UP).should == @neg_two
+    end
+  end
+
+  describe "BigDecimal::ROUND_HALF_DOWN" do
+    it "rounds values > 5 up, otherwise down" do
+      @p1_50.round(0, BigDecimal::ROUND_HALF_DOWN).should == @one
+      @p1_51.round(0, BigDecimal::ROUND_HALF_DOWN).should == @two
+      @p1_49.round(0, BigDecimal::ROUND_HALF_DOWN).should == @one
+      @n1_50.round(0, BigDecimal::ROUND_HALF_DOWN).should == @neg_one
+      @n1_51.round(0, BigDecimal::ROUND_HALF_DOWN).should == @neg_two
+      @n1_49.round(0, BigDecimal::ROUND_HALF_DOWN).should == @neg_one
+
+      @p2_50.round(0, BigDecimal::ROUND_HALF_DOWN).should == @two
+      @p2_51.round(0, BigDecimal::ROUND_HALF_DOWN).should == @three
+      @p2_49.round(0, BigDecimal::ROUND_HALF_DOWN).should == @two
+      @n2_50.round(0, BigDecimal::ROUND_HALF_DOWN).should == @neg_two
+      @n2_51.round(0, BigDecimal::ROUND_HALF_DOWN).should == @neg_three
+      @n2_49.round(0, BigDecimal::ROUND_HALF_DOWN).should == @neg_two
+    end
+  end
+
+  describe "BigDecimal::ROUND_CEILING" do
+    it "rounds values towards +infinity" do
+      @p1_50.round(0, BigDecimal::ROUND_CEILING).should == @two
+      @p1_51.round(0, BigDecimal::ROUND_CEILING).should == @two
+      @p1_49.round(0, BigDecimal::ROUND_CEILING).should == @two
+      @n1_50.round(0, BigDecimal::ROUND_CEILING).should == @neg_one
+      @n1_51.round(0, BigDecimal::ROUND_CEILING).should == @neg_one
+      @n1_49.round(0, BigDecimal::ROUND_CEILING).should == @neg_one
+
+      @p2_50.round(0, BigDecimal::ROUND_CEILING).should == @three
+      @p2_51.round(0, BigDecimal::ROUND_CEILING).should == @three
+      @p2_49.round(0, BigDecimal::ROUND_CEILING).should == @three
+      @n2_50.round(0, BigDecimal::ROUND_CEILING).should == @neg_two
+      @n2_51.round(0, BigDecimal::ROUND_CEILING).should == @neg_two
+      @n2_49.round(0, BigDecimal::ROUND_CEILING).should == @neg_two
+    end
+  end
+
+  describe "BigDecimal::ROUND_FLOOR" do
+    it "rounds values towards -infinity" do
+      @p1_50.round(0, BigDecimal::ROUND_FLOOR).should == @one
+      @p1_51.round(0, BigDecimal::ROUND_FLOOR).should == @one
+      @p1_49.round(0, BigDecimal::ROUND_FLOOR).should == @one
+      @n1_50.round(0, BigDecimal::ROUND_FLOOR).should == @neg_two
+      @n1_51.round(0, BigDecimal::ROUND_FLOOR).should == @neg_two
+      @n1_49.round(0, BigDecimal::ROUND_FLOOR).should == @neg_two
+
+      @p2_50.round(0, BigDecimal::ROUND_FLOOR).should == @two
+      @p2_51.round(0, BigDecimal::ROUND_FLOOR).should == @two
+      @p2_49.round(0, BigDecimal::ROUND_FLOOR).should == @two
+      @n2_50.round(0, BigDecimal::ROUND_FLOOR).should == @neg_three
+      @n2_51.round(0, BigDecimal::ROUND_FLOOR).should == @neg_three
+      @n2_49.round(0, BigDecimal::ROUND_FLOOR).should == @neg_three
+    end
+  end
+
+  describe "BigDecimal::ROUND_HALF_EVEN" do
+    it "rounds values > 5 up, < 5 down and == 5 towards even neighbor" do
+      @p1_50.round(0, BigDecimal::ROUND_HALF_EVEN).should == @two
+      @p1_51.round(0, BigDecimal::ROUND_HALF_EVEN).should == @two
+      @p1_49.round(0, BigDecimal::ROUND_HALF_EVEN).should == @one
+      @n1_50.round(0, BigDecimal::ROUND_HALF_EVEN).should == @neg_two
+      @n1_51.round(0, BigDecimal::ROUND_HALF_EVEN).should == @neg_two
+      @n1_49.round(0, BigDecimal::ROUND_HALF_EVEN).should == @neg_one
+
+      @p2_50.round(0, BigDecimal::ROUND_HALF_EVEN).should == @two
+      @p2_51.round(0, BigDecimal::ROUND_HALF_EVEN).should == @three
+      @p2_49.round(0, BigDecimal::ROUND_HALF_EVEN).should == @two
+      @n2_50.round(0, BigDecimal::ROUND_HALF_EVEN).should == @neg_two
+      @n2_51.round(0, BigDecimal::ROUND_HALF_EVEN).should == @neg_three
+      @n2_49.round(0, BigDecimal::ROUND_HALF_EVEN).should == @neg_two
+    end
+  end
+
+  it 'raise exception, if self is special value' do
+    lambda { BigDecimal('NaN').round }.should raise_error(FloatDomainError)
+    lambda { BigDecimal('Infinity').round }.should raise_error(FloatDomainError)
+    lambda { BigDecimal('-Infinity').round }.should raise_error(FloatDomainError)
+  end
+
+  it 'do not raise exception, if self is special value and precision is given' do
+    lambda { BigDecimal('NaN').round(2) }.should_not raise_error(FloatDomainError)
+    lambda { BigDecimal('Infinity').round(2) }.should_not raise_error(FloatDomainError)
+    lambda { BigDecimal('-Infinity').round(2) }.should_not raise_error(FloatDomainError)
+  end
+end
diff --git a/spec/rubyspec/library/bigdecimal/shared/eql.rb b/spec/rubyspec/library/bigdecimal/shared/eql.rb
new file mode 100644
index 0000000000..eaad272e9a
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/shared/eql.rb
@@ -0,0 +1,61 @@
+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/rubyspec/library/bigdecimal/shared/modulo.rb b/spec/rubyspec/library/bigdecimal/shared/modulo.rb
new file mode 100644
index 0000000000..78ebe8360d
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/shared/modulo.rb
@@ -0,0 +1,116 @@
+require 'bigdecimal'
+
+describe :bigdecimal_modulo, shared: true 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-9999")
+    @frac_2 = BigDecimal("0.9E-9999")
+  end
+
+  it "returns self modulo other" do
+    bd6543 = BigDecimal.new("6543.21")
+    bd5667 = BigDecimal.new("5667.19")
+    a = BigDecimal("1.0000000000000000000000000000000000000000005")
+    b = BigDecimal("1.00000000000000000000000000000000000000000005")
+
+    bd6543.send(@method, 137).should == BigDecimal("104.21")
+    bd5667.send(@method, bignum_value).should == 5667.19
+    bd6543.send(@method, BigDecimal("137.24")).should == BigDecimal("92.93")
+    bd6543.send(@method, 137).should be_close(6543.21.%(137), TOLERANCE)
+    bd6543.send(@method, 137).should == bd6543 % 137
+    bd5667.send(@method, bignum_value).should be_close(5667.19.%(0xffffffff), TOLERANCE)
+    bd5667.send(@method, bignum_value).should == bd5667.%(0xffffffff)
+    bd6543.send(@method, 137.24).should be_close(6543.21.%(137.24), TOLERANCE)
+    a.send(@method, b).should == BigDecimal("0.45E-42")
+    @zero.send(@method, @one).should == @zero
+    @zero.send(@method, @one_minus).should == @zero
+    @two.send(@method, @one).should == @zero
+    @one.send(@method, @two).should == @one
+    @frac_1.send(@method, @one).should == @frac_1
+    @frac_2.send(@method, @one).should == @frac_2
+    @one_minus.send(@method, @one_minus).should == @zero
+    @one_minus.send(@method, @one).should == @zero
+    @one_minus.send(@method, @two).should == @one
+    @one.send(@method, -@two).should == -@one
+
+    @one_minus.modulo(BigDecimal('0.9')).should == BigDecimal('0.8')
+    @one.modulo(BigDecimal('-0.9')).should == BigDecimal('-0.8')
+
+    @one_minus.modulo(BigDecimal('0.8')).should == BigDecimal('0.6')
+    @one.modulo(BigDecimal('-0.8')).should == BigDecimal('-0.6')
+
+    @one_minus.modulo(BigDecimal('0.6')).should == BigDecimal('0.2')
+    @one.modulo(BigDecimal('-0.6')).should == BigDecimal('-0.2')
+
+    @one_minus.modulo(BigDecimal('0.5')).should == @zero
+    @one.modulo(BigDecimal('-0.5')).should == @zero
+    @one_minus.modulo(BigDecimal('-0.5')).should == @zero
+
+    @one_minus.modulo(BigDecimal('0.4')).should == BigDecimal('0.2')
+    @one.modulo(BigDecimal('-0.4')).should == BigDecimal('-0.2')
+
+    @one_minus.modulo(BigDecimal('0.3')).should == BigDecimal('0.2')
+    @one_minus.modulo(BigDecimal('0.2')).should == @zero
+  end
+
+  it "returns a [Float value] when the argument is Float" do
+    @two.send(@method, 2.0).should == 0.0
+    @one.send(@method, 2.0).should == 1.0
+    res = @two.send(@method, 5.0)
+    res.kind_of?(BigDecimal).should == true
+  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
+  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_minus.send(@method, @infinity_minus).nan?.should == true
+    @infinity_minus.send(@method, @one).nan?.should == true
+
+    @infinity.send(@method, @infinity_minus).nan?.should == true
+    @infinity_minus.send(@method, @infinity).nan?.should == true
+  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
+  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)
+  end
+end
diff --git a/spec/rubyspec/library/bigdecimal/shared/mult.rb b/spec/rubyspec/library/bigdecimal/shared/mult.rb
new file mode 100644
index 0000000000..b94c9385de
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/shared/mult.rb
@@ -0,0 +1,97 @@
+require 'bigdecimal'
+
+describe :bigdecimal_mult, shared: true do
+  before :each do
+    @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"
+
+    @e3_minus = BigDecimal "3E-20001"
+    @e = BigDecimal "1.00000000000000000000123456789"
+    @tolerance = @e.sub @one, 1000
+    @tolerance2 = BigDecimal "30001E-20005"
+
+    @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 "returns zero of appropriate sign if self or argument is zero" do
+    @zero.send(@method, @zero, *@object).sign.should == BigDecimal::SIGN_POSITIVE_ZERO
+    @zero_neg.send(@method, @zero_neg, *@object).sign.should == BigDecimal::SIGN_POSITIVE_ZERO
+    @zero.send(@method, @zero_neg, *@object).sign.should == BigDecimal::SIGN_NEGATIVE_ZERO
+    @zero_neg.send(@method, @zero, *@object).sign.should == BigDecimal::SIGN_NEGATIVE_ZERO
+
+    @one.send(@method, @zero, *@object).sign.should == BigDecimal::SIGN_POSITIVE_ZERO
+    @one.send(@method, @zero_neg, *@object).sign.should == BigDecimal::SIGN_NEGATIVE_ZERO
+
+    @zero.send(@method, @one, *@object).sign.should == BigDecimal::SIGN_POSITIVE_ZERO
+    @zero.send(@method, @one_minus, *@object).sign.should == BigDecimal::SIGN_NEGATIVE_ZERO
+    @zero_neg.send(@method, @one_minus, *@object).sign.should == BigDecimal::SIGN_POSITIVE_ZERO
+    @zero_neg.send(@method, @one, *@object).sign.should == BigDecimal::SIGN_NEGATIVE_ZERO
+  end
+
+  it "returns NaN if NaN is involved" 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
+    end
+  end
+
+  it "returns zero if self or argument is zero" do
+    values = @regular_vals + @zeroes
+
+    values.each do |val|
+      @zeroes.each do |zero|
+        zero.send(@method, val, *@object).should == 0
+        zero.send(@method, val, *@object).zero?.should == true
+        val.send(@method, zero, *@object).should == 0
+        val.send(@method, zero, *@object).zero?.should == true
+      end
+    end
+  end
+
+  it "returns infinite value if self or argument is infinite" do
+    values = @regular_vals
+    infs = [@infinity, @infinity_minus]
+
+    values.each do |val|
+      infs.each do |inf|
+        inf.send(@method, val, *@object).finite?.should == false
+        val.send(@method, inf, *@object).finite?.should == false
+      end
+    end
+
+    @infinity.send(@method, @infinity, *@object).infinite?.should == 1
+    @infinity_minus.send(@method, @infinity_minus, *@object).infinite?.should == 1
+    @infinity.send(@method, @infinity_minus, *@object).infinite?.should == -1
+    @infinity_minus.send(@method, @infinity, *@object).infinite?.should == -1
+    @infinity.send(@method, @one, *@object).infinite?.should == 1
+    @infinity_minus.send(@method, @one, *@object).infinite?.should == -1
+  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
+  end
+end
diff --git a/spec/rubyspec/library/bigdecimal/shared/power.rb b/spec/rubyspec/library/bigdecimal/shared/power.rb
new file mode 100644
index 0000000000..a4848fb2e2
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/shared/power.rb
@@ -0,0 +1,72 @@
+require 'bigdecimal'
+
+describe :bigdecimal_power, shared: true do
+  it "powers of self" do
+    e3_minus = BigDecimal("3E-20001")
+    e3_minus_power_2 = BigDecimal("9E-40002")
+    e3_plus = BigDecimal("3E20001")
+    e2_plus = BigDecimal("2E40001")
+    e5_minus = BigDecimal("5E-40002")
+    e = BigDecimal("1.00000000000000000000123456789")
+    one = BigDecimal("1")
+    ten = BigDecimal("10")
+    # The tolerance is dependent upon the size of BASE_FIG
+    tolerance = BigDecimal("1E-70")
+    ten_powers = BigDecimal("1E10000")
+    pi = BigDecimal("3.14159265358979")
+    e3_minus.send(@method, 2).should == e3_minus_power_2
+    e3_plus.send(@method, 0).should == 1
+    e3_minus.send(@method, 1).should == e3_minus
+    e2_plus.send(@method, -1).should == e5_minus
+    e2_plus.send(@method, -1).should == e5_minus.power(1)
+    (e2_plus.send(@method, -1) * e5_minus.send(@method, -1)).should == 1
+    e.send(@method, 2).should == e * e
+    e.send(@method, -1).should be_close(one.div(e, 120), tolerance)
+    ten.send(@method, 10000).should == ten_powers
+    pi.send(@method, 10).should be_close(Math::PI ** 10, TOLERANCE)
+  end
+
+  it "powers of 1 equal 1" do
+    one = BigDecimal("1")
+    one.send(@method, 0).should == 1
+    one.send(@method, 1).should == 1
+    one.send(@method, 10).should == 1
+    one.send(@method, -10).should == 1
+  end
+
+  it "0 to power of 0 is 1" do
+    zero = BigDecimal("0")
+    zero.send(@method, 0).should == 1
+  end
+
+  it "0 to powers < 0 is Infinity" do
+    zero = BigDecimal("0")
+    infinity = BigDecimal("Infinity")
+    zero.send(@method, -10).should == infinity
+    zero.send(@method, -1).should == infinity
+  end
+
+  it "other powers of 0 are 0" do
+    zero = BigDecimal("0")
+    zero.send(@method, 1).should == 0
+    zero.send(@method, 10).should == 0
+  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
+  end
+
+  it "returns 0.0 if self is infinite and argument is negative" do
+    BigDecimal("Infinity").send(@method, -5).should == 0
+    BigDecimal("-Infinity").send(@method, -5).should == 0
+  end
+
+  it "returns infinite if self is infinite and argument is positive" do
+    infinity = BigDecimal("Infinity")
+    BigDecimal("Infinity").send(@method, 4).should == infinity
+    BigDecimal("-Infinity").send(@method, 4).should == infinity
+    BigDecimal("Infinity").send(@method, 5).should == infinity
+    BigDecimal("-Infinity").send(@method, 5).should == -infinity
+  end
+end
diff --git a/spec/rubyspec/library/bigdecimal/shared/quo.rb b/spec/rubyspec/library/bigdecimal/shared/quo.rb
new file mode 100644
index 0000000000..cb51c10d71
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/shared/quo.rb
@@ -0,0 +1,59 @@
+require 'bigdecimal'
+
+describe :bigdecimal_quo, shared: true do
+  before :each do
+    @one = BigDecimal("1")
+    @zero = BigDecimal("0")
+    @zero_plus = BigDecimal("+0")
+    @zero_minus = BigDecimal("-0")
+    @two = BigDecimal("2")
+    @three = BigDecimal("3")
+    @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.send(@method, @one, *@object).should == @two
+    @one.send(@method, @two, *@object).should == BigDecimal("0.5")
+    @eleven.send(@method, @three, *@object).should be_close(@three + (@two / @three), TOLERANCE)
+    @one.send(@method, @one_minus, *@object).should == @one_minus
+    @one_minus.send(@method, @one_minus, *@object).should == @one
+    @frac_2.send(@method, @frac_1, *@object).should == BigDecimal("0.9")
+    @frac_1.send(@method, @frac_1, *@object).should == @one
+    @one.send(@method, BigDecimal('-2E5555'), *@object).should == BigDecimal('-0.5E-5555')
+    @one.send(@method, BigDecimal('2E-5555'), *@object).should == BigDecimal('0.5E5555')
+  end
+
+  it "returns 0 if divided by Infinity" do
+    @zero.send(@method, @infinity, *@object).should == 0
+    @frac_2.send(@method, @infinity, *@object).should == 0
+  end
+
+  it "returns (+|-) Infinity if (+|-) Infinity divided by one" do
+    @infinity_minus.send(@method, @one, *@object).should == @infinity_minus
+    @infinity.send(@method, @one, *@object).should == @infinity
+    @infinity_minus.send(@method, @one_minus, *@object).should == @infinity
+  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
+  end
+
+  it "returns (+|-) Infinity if divided by zero" do
+    @one.send(@method, @zero, *@object).should == @infinity
+    @one.send(@method, @zero_plus, *@object).should == @infinity
+    @one.send(@method, @zero_minus, *@object).should == @infinity_minus
+  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
+  end
+end
diff --git a/spec/rubyspec/library/bigdecimal/shared/to_int.rb b/spec/rubyspec/library/bigdecimal/shared/to_int.rb
new file mode 100644
index 0000000000..729a25f511
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/shared/to_int.rb
@@ -0,0 +1,16 @@
+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
diff --git a/spec/rubyspec/library/bigdecimal/sign_spec.rb b/spec/rubyspec/library/bigdecimal/sign_spec.rb
new file mode 100644
index 0000000000..0d722987b5
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/sign_spec.rb
@@ -0,0 +1,47 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+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 positve 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
+
+end
+
diff --git a/spec/rubyspec/library/bigdecimal/split_spec.rb b/spec/rubyspec/library/bigdecimal/split_spec.rb
new file mode 100644
index 0000000000..e2ba955a3b
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/split_spec.rb
@@ -0,0 +1,88 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+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
+
+end
+
+
diff --git a/spec/rubyspec/library/bigdecimal/sqrt_spec.rb b/spec/rubyspec/library/bigdecimal/sqrt_spec.rb
new file mode 100644
index 0000000000..f677192b33
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/sqrt_spec.rb
@@ -0,0 +1,112 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+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
+    lambda {
+      @one.sqrt
+    }.should raise_error(ArgumentError)
+  end
+
+  it "raises ArgumentError if a negative number is given" do
+    lambda {
+      @one.sqrt(-1)
+    }.should raise_error(ArgumentError)
+  end
+
+  it "raises ArgumentError if 2 arguments are given" do
+    lambda {
+      @one.sqrt(1, 1)
+    }.should raise_error(ArgumentError)
+  end
+
+  it "raises TypeError if nil is given" do
+    lambda {
+      @one.sqrt(nil)
+    }.should raise_error(TypeError)
+  end
+
+  it "raises TypeError if a string is given" do
+    lambda {
+      @one.sqrt("stuff")
+    }.should raise_error(TypeError)
+  end
+
+  it "raises TypeError if a plain Object is given" do
+    lambda {
+      @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
+    lambda {
+      BigDecimal('-1').sqrt(10)
+    }.should raise_error(FloatDomainError)
+  end
+
+  it "returns positive infitinity for infinity" do
+    @infinity.sqrt(1).should == @infinity
+  end
+
+  it "raises FloatDomainError for negative infinity" do
+    lambda {
+      @infinity_minus.sqrt(1)
+    }.should raise_error(FloatDomainError)
+  end
+
+  it "raises FloatDomainError for NaN" do
+    lambda {
+      @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
+
+end
diff --git a/spec/rubyspec/library/bigdecimal/sub_spec.rb b/spec/rubyspec/library/bigdecimal/sub_spec.rb
new file mode 100644
index 0000000000..06ad3b79d2
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/sub_spec.rb
@@ -0,0 +1,53 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require 'bigdecimal'
+
+describe "BigDecimal#sub" 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 with given precision" do
+    # documentation states, that precision is optional
+    # but implementation raises ArgumentError if not given.
+
+    @two.sub(@one, 1).should == @one
+    @one.sub(@two, 1).should == @one_minus
+    @one.sub(@one_minus, 1).should == @two
+    @frac_2.sub(@frac_1, 1000000).should == BigDecimal("-0.1E-99999")
+    @frac_2.sub(@frac_1, 1).should == BigDecimal("-0.1E-99999")
+    # the above two examples puzzle me.
+    in_arow_one = BigDecimal("1.23456789")
+    in_arow_two = BigDecimal("1.2345678")
+    in_arow_one.sub(in_arow_two, 10).should == BigDecimal("0.9E-7")
+    @two.sub(@two,1).should == @zero
+    @frac_1.sub(@frac_1, 1000000).should == @zero
+  end
+
+  it "returns NaN if NaN is involved" do
+    @one.sub(@nan, 1).nan?.should == true
+    @nan.sub(@one, 1).nan?.should == true
+  end
+
+  it "returns NaN if both values are infinite with the same signs" do
+    @infinity.sub(@infinity, 1).nan?.should == true
+    @infinity_minus.sub(@infinity_minus, 1).nan?.should == true
+  end
+
+  it "returns Infinity or -Infinity if these are involved" do
+    @infinity.sub(@infinity_minus, 1).should == @infinity
+    @infinity_minus.sub(@infinity, 1).should == @infinity_minus
+    @zero.sub(@infinity, 1).should == @infinity_minus
+    @frac_2.sub( @infinity, 1).should == @infinity_minus
+    @two.sub(@infinity, 1).should == @infinity_minus
+  end
+
+end
diff --git a/spec/rubyspec/library/bigdecimal/to_f_spec.rb b/spec/rubyspec/library/bigdecimal/to_f_spec.rb
new file mode 100644
index 0000000000..b490fce4d9
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/to_f_spec.rb
@@ -0,0 +1,55 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require 'bigdecimal'
+
+describe "BigDecimal#to_f" 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")
+    @vals = [@one, @zero, @two, @three, @frac_1, @frac_2]
+    @spec_vals = [@zero_pos, @zero_neg, @nan, @infinity, @infinity_minus]
+  end
+
+  it "returns number of type float" do
+    BigDecimal("3.14159").to_f.should be_kind_of(Float)
+    @vals.each { |val| val.to_f.should be_kind_of(Float) }
+    @spec_vals.each { |val| val.to_f.should be_kind_of(Float) }
+  end
+
+  it "rounds correctly to Float precision" do
+    bigdec = BigDecimal("3.141592653589793238462643383279502884197169399375")
+    bigdec.to_f.should be_close(3.14159265358979, TOLERANCE)
+    @one.to_f.should == 1.0
+    @two.to_f.should == 2.0
+    @three.to_f.should be_close(3.0, TOLERANCE)
+    @one_minus.to_f.should == -1.0
+
+    # regression test for [ruby-talk:338957]
+    BigDecimal("10.03").to_f.should == 10.03
+  end
+
+  it "properly handles special values" do
+    @zero.to_f.should == 0
+    @zero.to_f.to_s.should == "0.0"
+
+    @nan.to_f.nan?.should == true
+
+    @infinity.to_f.infinite?.should == 1
+    @infinity_minus.to_f.infinite?.should == -1
+  end
+
+  it "remembers negative zero when converted to float" do
+    @zero_neg.to_f.should == 0
+    @zero_neg.to_f.to_s.should == "-0.0"
+  end
+end
+
diff --git a/spec/rubyspec/library/bigdecimal/to_i_spec.rb b/spec/rubyspec/library/bigdecimal/to_i_spec.rb
new file mode 100644
index 0000000000..8db69003c5
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/to_i_spec.rb
@@ -0,0 +1,7 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../shared/to_int', __FILE__)
+require 'bigdecimal'
+
+describe "BigDecimal#to_i" do
+    it_behaves_like(:bigdecimal_to_int, :to_i)
+end
diff --git a/spec/rubyspec/library/bigdecimal/to_int_spec.rb b/spec/rubyspec/library/bigdecimal/to_int_spec.rb
new file mode 100644
index 0000000000..56a60d4a03
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/to_int_spec.rb
@@ -0,0 +1,8 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../shared/to_int', __FILE__)
+require 'bigdecimal'
+
+
+describe "BigDecimal#to_int" do
+  it_behaves_like(:bigdecimal_to_int, :to_int)
+end
diff --git a/spec/rubyspec/library/bigdecimal/to_s_spec.rb b/spec/rubyspec/library/bigdecimal/to_s_spec.rb
new file mode 100644
index 0000000000..b97311c800
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/to_s_spec.rb
@@ -0,0 +1,73 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require 'bigdecimal'
+
+describe "BigDecimal#to_s" do
+
+  before :each do
+    @bigdec_str = "3.14159265358979323846264338327950288419716939937"
+    @bigneg_str = "-3.1415926535897932384626433832795028841971693993"
+    @bigdec = BigDecimal(@bigdec_str)
+    @bigneg = BigDecimal(@bigneg_str)
+  end
+
+  it "return type is of class String" do
+    @bigdec.to_s.kind_of?(String).should == true
+    @bigneg.to_s.kind_of?(String).should == true
+  end
+
+  it "the default format looks like 0.xxxxEnn" do
+    @bigdec.to_s.should =~ /^0\.[0-9]*E[0-9]*$/i
+  end
+
+  it "takes an optional argument" do
+    lambda {@bigdec.to_s("F")}.should_not raise_error()
+  end
+
+  it "starts with + if + is supplied and value is positive" do
+    @bigdec.to_s("+").should =~ /^\+.*/
+    @bigneg.to_s("+").should_not =~ /^\+.*/
+  end
+
+  it "inserts a space every n chars, 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
+    @bigdec.to_s(3).should =~ re
+
+    str1 = '-123.45678 90123 45678 9'
+    BigDecimal.new("-123.45678901234567890").to_s('5F').should ==  str1
+    # trailing zeroes removed
+    BigDecimal.new("1.00000000000").to_s('1F').should == "1.0"
+    # 0 is treated as no spaces
+    BigDecimal.new("1.2345").to_s('0F').should == "1.2345"
+  end
+
+  it "can return a leading space for values > 0" do
+    @bigdec.to_s(" F").should =~ /\ .*/
+    @bigneg.to_s(" F").should_not =~ /\ .*/
+  end
+
+  it "removes trailing spaces in floating point notation" do
+    BigDecimal.new('-123.45678901234567890').to_s('F').should == "-123.4567890123456789"
+    BigDecimal.new('1.2500').to_s('F').should == "1.25"
+    BigDecimal.new('0000.00000').to_s('F').should == "0.0"
+    BigDecimal.new('-00.000010000').to_s('F').should == "-0.00001"
+    BigDecimal.new("5.00000E-2").to_s("F").should == "0.05"
+
+    BigDecimal.new("500000").to_s("F").should == "500000.0"
+    BigDecimal.new("5E2").to_s("F").should == "500.0"
+    BigDecimal.new("-5E100").to_s("F").should == "-5" + "0" * 100 + ".0"
+  end
+
+  it "can use engineering notation" do
+    @bigdec.to_s("E").should =~ /^0\.[0-9]*E[0-9]*$/i
+  end
+
+  it "can use conventional floating point notation" do
+    @bigdec.to_s("F").should == @bigdec_str
+    @bigneg.to_s("F").should == @bigneg_str
+    str2 = "+123.45678901 23456789"
+    BigDecimal.new('123.45678901234567890').to_s('+8F').should == str2
+  end
+
+end
+
diff --git a/spec/rubyspec/library/bigdecimal/truncate_spec.rb b/spec/rubyspec/library/bigdecimal/truncate_spec.rb
new file mode 100644
index 0000000000..41f0afc8fa
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/truncate_spec.rb
@@ -0,0 +1,81 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require 'bigdecimal'
+
+describe "BigDecimal#truncate" do
+
+  before :each do
+      @arr = ['3.14159', '8.7', "0.314159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196442881097566593014782083152134043E1"]
+      @big = BigDecimal("123456.789")
+      @nan = BigDecimal('NaN')
+      @infinity = BigDecimal('Infinity')
+      @infinity_negative = BigDecimal('-Infinity')
+  end
+
+  it "returns value of type Integer." do
+    @arr.each do |x|
+      BigDecimal(x).truncate.kind_of?(Integer).should == true
+    end
+  end
+
+  it "returns the integer part as a BigDecimal if no precision given" do
+    BigDecimal(@arr[0]).truncate.should == 3
+    BigDecimal(@arr[1]).truncate.should == 8
+    BigDecimal(@arr[2]).truncate.should == 3
+    BigDecimal('0').truncate.should == 0
+    BigDecimal('0.1').truncate.should == 0
+    BigDecimal('-0.1').truncate.should == 0
+    BigDecimal('1.5').truncate.should == 1
+    BigDecimal('-1.5').truncate.should == -1
+    BigDecimal('1E10').truncate.should == BigDecimal('1E10')
+    BigDecimal('-1E10').truncate.should == BigDecimal('-1E10')
+    BigDecimal('1.8888E10').truncate.should == BigDecimal('1.8888E10')
+    BigDecimal('-1E-1').truncate.should == 0
+  end
+
+  it "returns value of given precision otherwise" do
+    BigDecimal('-1.55').truncate(1).should == BigDecimal('-1.5')
+    BigDecimal('1.55').truncate(1).should == BigDecimal('1.5')
+    BigDecimal(@arr[0]).truncate(2).should == BigDecimal("3.14")
+    BigDecimal('123.456').truncate(2).should == BigDecimal("123.45")
+    BigDecimal('123.456789').truncate(4).should == BigDecimal("123.4567")
+    BigDecimal('0.456789').truncate(10).should == BigDecimal("0.456789")
+    BigDecimal('-1E-1').truncate(1).should == BigDecimal('-0.1')
+    BigDecimal('-1E-1').truncate(2).should == BigDecimal('-0.1E0')
+    BigDecimal('-1E-1').truncate.should == BigDecimal('0')
+    BigDecimal('-1E-1').truncate(0).should == BigDecimal('0')
+    BigDecimal('-1E-1').truncate(-1).should == BigDecimal('0')
+    BigDecimal('-1E-1').truncate(-2).should == BigDecimal('0')
+
+    BigDecimal(@arr[1]).truncate(1).should == BigDecimal("8.7")
+    BigDecimal(@arr[2]).truncate(100).should == BigDecimal(\
+      "3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679")
+  end
+
+  it "sets n digits left of the decimal point to 0, if given n < 0" do
+    @big.truncate(-1).should == BigDecimal("123450.0")
+    @big.truncate(-2).should == BigDecimal("123400.0")
+    BigDecimal(@arr[2]).truncate(-1).should == 0
+  end
+
+  it "returns NaN if self is NaN" do
+    @nan.truncate(-1).nan?.should == true
+    @nan.truncate(+1).nan?.should == true
+    @nan.truncate(0).nan?.should == true
+  end
+
+  it "returns Infinity if self is infinite" do
+    @infinity.truncate(-1).should == @infinity
+    @infinity.truncate(+1).should == @infinity
+    @infinity.truncate(0).should == @infinity
+
+    @infinity_negative.truncate(-1).should == @infinity_negative
+    @infinity_negative.truncate(+1).should == @infinity_negative
+    @infinity_negative.truncate(0).should == @infinity_negative
+  end
+
+  it "returns the same value if self is special value" do
+    lambda { @nan.truncate }.should raise_error(FloatDomainError)
+    lambda { @infinity.truncate }.should raise_error(FloatDomainError)
+    lambda { @infinity_negative.truncate }.should raise_error(FloatDomainError)
+  end
+end
diff --git a/spec/rubyspec/library/bigdecimal/uminus_spec.rb b/spec/rubyspec/library/bigdecimal/uminus_spec.rb
new file mode 100644
index 0000000000..901f9f59ce
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/uminus_spec.rb
@@ -0,0 +1,58 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require 'bigdecimal'
+
+describe "BigDecimal#-@" do
+  before :each do
+    @one = BigDecimal("1")
+    @zero = BigDecimal("0")
+    @zero_pos = BigDecimal("+0")
+    @zero_neg = BigDecimal("-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")
+    @big = BigDecimal("333E99999")
+    @big_neg = BigDecimal("-333E99999")
+    @values = [@one, @zero, @zero_pos, @zero_neg, @infinity,
+      @infinity_minus, @one_minus, @frac_1, @frac_2, @big, @big_neg]
+  end
+
+  it "negates self" do
+    @one.send(:-@).should == @one_minus
+    @one_minus.send(:-@).should == @one
+    @frac_1.send(:-@).should == BigDecimal("-1E-99999")
+    @frac_2.send(:-@).should == BigDecimal("-0.9E-99999")
+    @big.send(:-@).should == @big_neg
+    @big_neg.send(:-@).should == @big
+    BigDecimal("2.221").send(:-@).should == BigDecimal("-2.221")
+    BigDecimal("2E10000").send(:-@).should == BigDecimal("-2E10000")
+    some_number = BigDecimal("2455999221.5512")
+    some_number_neg = BigDecimal("-2455999221.5512")
+    some_number.send(:-@).should == some_number_neg
+    (-BigDecimal("-5.5")).should == BigDecimal("5.5")
+    another_number = BigDecimal("-8.551551551551551551")
+    another_number_pos = BigDecimal("8.551551551551551551")
+    another_number.send(:-@).should == another_number_pos
+    @values.each do |val|
+      (val.send(:-@).send(:-@)).should == val
+    end
+  end
+
+  it "properly handles special values" do
+    @infinity.send(:-@).should == @infinity_minus
+    @infinity_minus.send(:-@).should == @infinity
+    @infinity.send(:-@).infinite?.should == -1
+    @infinity_minus.send(:-@).infinite?.should == 1
+
+    @zero.send(:-@).should == @zero
+    @zero.send(:-@).sign.should == -1
+    @zero_pos.send(:-@).should == @zero
+    @zero_pos.send(:-@).sign.should == -1
+    @zero_neg.send(:-@).should == @zero
+    @zero_neg.send(:-@).sign.should == 1
+
+    @nan.send(:-@).nan?.should == true
+  end
+end
diff --git a/spec/rubyspec/library/bigdecimal/uplus_spec.rb b/spec/rubyspec/library/bigdecimal/uplus_spec.rb
new file mode 100644
index 0000000000..00aadc723c
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/uplus_spec.rb
@@ -0,0 +1,20 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require 'bigdecimal'
+
+describe "BigDecimal#+@" do
+  it "returns the same value with same sign (twos complement)" do
+    first = BigDecimal("34.56")
+    first.send(:+@).should == first
+    second = BigDecimal("-34.56")
+    second.send(:+@).should == second
+    third = BigDecimal("0.0")
+    third.send(:+@).should == third
+    fourth = BigDecimal("2E1000000")
+    fourth.send(:+@).should == fourth
+    fifth = BigDecimal("123456789E-1000000")
+    fifth.send(:+@).should == fifth
+  end
+end
+
+
+
diff --git a/spec/rubyspec/library/bigdecimal/ver_spec.rb b/spec/rubyspec/library/bigdecimal/ver_spec.rb
new file mode 100644
index 0000000000..61b073d8f1
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/ver_spec.rb
@@ -0,0 +1,11 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require 'bigdecimal'
+
+describe "BigDecimal.ver" do
+
+  it "returns the Version number" do
+    lambda {BigDecimal.ver }.should_not raise_error()
+    BigDecimal.ver.should_not == nil
+  end
+
+end
diff --git a/spec/rubyspec/library/bigdecimal/zero_spec.rb b/spec/rubyspec/library/bigdecimal/zero_spec.rb
new file mode 100644
index 0000000000..7dbb0fa7f0
--- /dev/null
+++ b/spec/rubyspec/library/bigdecimal/zero_spec.rb
@@ -0,0 +1,28 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require 'bigdecimal'
+
+describe "BigDecimal#zero?" do
+
+  it "returns true if self does equal zero" do
+    really_small_zero = BigDecimal("0E-200000000")
+    really_big_zero = BigDecimal("0E200000000000")
+    really_small_zero.zero?.should == true
+    really_big_zero.zero?.should == true
+    BigDecimal("0.000000000000000000000000").zero?.should == true
+    BigDecimal("0").zero?.should == true
+    BigDecimal("0E0").zero?.should == true
+    BigDecimal("+0").zero?.should == true
+    BigDecimal("-0").zero?.should == true
+  end
+
+  it "returns false otherwise" do
+    BigDecimal("0000000001").zero?.should == false
+    BigDecimal("2E40001").zero?.should == false
+    BigDecimal("3E-20001").zero?.should == false
+    BigDecimal("Infinity").zero?.should == false
+    BigDecimal("-Infinity").zero?.should == false
+    BigDecimal("NaN").zero?.should == false
+  end
+
+end
+
author	eregon <eregon@b2dd03c8-39d4-4d8f-98ff-823fe69b080e>	2017-05-07 12:04:49 +0000
committer	eregon <eregon@b2dd03c8-39d4-4d8f-98ff-823fe69b080e>	2017-05-07 12:04:49 +0000
commit	95e8c48dd3348503a8c7db5d0498894a1b676395 (patch)
tree	9eef7f720314ebaff56845a74e203770e62284e4 /spec/rubyspec/library/bigdecimal
parent	ed7d803500de38186c74bce94d233e85ef51e503 (diff)