rubysl-bigdecimal 1.0.0

data/spec/mult_spec.rb

@@ -0,0 +1,23 @@
+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

data/spec/multiply_spec.rb

@@ -0,0 +1,25 @@
+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

data/spec/nan_spec.rb

@@ -0,0 +1,22 @@
+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

data/spec/new_spec.rb

@@ -0,0 +1,120 @@
+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)
+    }
+    (1..9).each {|i|
+      BigDecimal.new("100.#{i}").to_s.should == "0.100#{i}E3"
+      BigDecimal.new("-100.#{i}").to_s.should == "-0.100#{i}E3"
+    }
+  end
+
+  ruby_bug "1589", "1.8.6.368" do
+    ruby_version_is '' ... '1.9.3' do
+      platform_is :wordsize => 32 do
+        it "doesn't segfault when using a very large string to build the number" do
+          BigDecimal.new("1" + "0"*10000000)._dump.should == "10000008:0.1E10000001"
+        end
+      end
+
+      platform_is :wordsize => 64 do
+        it "doesn't segfault when using a very large string to build the number" do
+          BigDecimal.new("1" + "0"*10000000)._dump.should == "10000017:0.1E10000001"
+        end
+      end
+    end
+
+    ruby_version_is '1.9.3' do
+      it "doesn't segfault when using a very large string to build the number" do
+        BigDecimal.new("1" + "0"*10000000)._dump.should == "10000017:0.1E10000001"
+      end
+    end
+  end
+
+  it "Number of significant digits >= given precision" do
+    pi_string = "3.1415923"
+    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
+    BigDecimal.new("  \t\n \r-\t\t\tInfinity   \n").should == 0.0
+  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
+
+  it "treats invalid strings as 0.0" do
+    BigDecimal.new("ruby").should == BigDecimal.new("0.0")
+  end
+
+  it "allows omitting the integer part" do
+    BigDecimal.new(".123").should == BigDecimal.new("0.123")
+    ruby_version_is "1.8.6.5000" do
+    BigDecimal.new("-.123").should == BigDecimal.new("-0.123")
+  end
+  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
+
+end

data/spec/nonzero_spec.rb

@@ -0,0 +1,28 @@
+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

data/spec/plus_spec.rb

@@ -0,0 +1,49 @@
+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")
+# can't do it this way because * isn't implemented yet
+#    (@frac_1 + @frac_1).should == 2 * @frac_1
+  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

data/spec/power_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path('../shared/power', __FILE__)
+
+describe "BigDecimal#power" do
+  it_behaves_like(:bigdecimal_power, :power)
+end

data/spec/precs_spec.rb

@@ -0,0 +1,48 @@
+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
+

data/spec/quo_spec.rb

@@ -0,0 +1,12 @@
+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
+

data/spec/remainder_spec.rb

@@ -0,0 +1,83 @@
+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

data/spec/round_spec.rb

@@ -0,0 +1,193 @@
+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
+
+  ruby_bug "redmine:3803/4567", "1.9.2" do
+    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
+  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
+
+  ruby_bug "redmine:3803/4567", "1.9.2" do
+    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
+  end
+end