rubysl-bigdecimal 1.0.0

data/spec/double_fig_spec.rb

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

data/spec/eql_spec.rb

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

data/spec/equal_value_spec.rb

@@ -0,0 +1,6 @@
+require File.expand_path('../shared/eql.rb', __FILE__)
+
+
+describe "BigDecimal#==" do
+  it_behaves_like(:bigdecimal_eql, :==)
+end

data/spec/exponent_spec.rb

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

data/spec/finite_spec.rb

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

data/spec/fix_spec.rb

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

data/spec/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

data/spec/floor_spec.rb

@@ -0,0 +1,109 @@
+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
+
+  ruby_version_is "" ... "1.9" do
+    it "returns the same value, if self is special value" do
+      @infinity.floor.should == @infinity
+      @infinity_neg.floor.should == @infinity_neg
+      @nan.floor.nan?.should == true
+    end
+  end
+
+  ruby_version_is "1.9" do
+    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
+  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.
+      (-@one.div(@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|
+      (-@three.div(@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

data/spec/frac_spec.rb

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

data/spec/gt_spec.rb

@@ -0,0 +1,86 @@
+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
+
+  ruby_bug "redmine:2349", "1.8.7" do
+    it "properly handles NaN values" do
+      @values += [@infinity, @infinity_neg, @nan]
+      @values.each { |val|
+        (@nan > val).should == false
+        (val > @nan).should == false
+      }
+    end
+  end
+
+  ruby_bug "redmine:2349", "1.8.7" do
+    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
+end

data/spec/gte_spec.rb

@@ -0,0 +1,90 @@
+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
+
+  ruby_bug "redmine:2349", "1.8.7" do
+    it "properly handles NaN values" do
+      @values += [@infinity, @infinity_neg, @nan]
+      @values.each { |val|
+        (@nan >= val).should == false
+        (val >= @nan).should == false
+      }
+    end
+  end
+
+  ruby_bug "redmine:2349", "1.8.7" do
+    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
+end