rubysl-bigdecimal 1.0.0

data/spec/induced_from_spec.rb

@@ -0,0 +1,36 @@
+require 'bigdecimal'
+
+ruby_version_is "" ... "1.9" do
+  describe "BigDecimal.induced_from" do
+    it "returns the passed argument when passed a BigDecimal" do
+      BigDecimal.induced_from(BigDecimal("5")).should == BigDecimal("5")
+      BigDecimal.induced_from(BigDecimal("-5")).should == BigDecimal("-5")
+      BigDecimal.induced_from(BigDecimal("Infinity")).should == BigDecimal("Infinity")
+    end
+
+    it "converts passed Fixnums to BigDecimal" do
+      BigDecimal.induced_from(5).should == BigDecimal("5")
+      BigDecimal.induced_from(-5).should == BigDecimal("-5")
+      BigDecimal.induced_from(0).should == BigDecimal("0")
+    end
+
+    it "converts passed Bignums to BigDecimal" do
+      BigDecimal.induced_from(bignum_value).should == BigDecimal(bignum_value.to_s)
+      BigDecimal.induced_from(-bignum_value).should == BigDecimal((-bignum_value).to_s)
+    end
+
+    it "does not try to convert non-Integers to Integer using #to_i" do
+      obj = mock("Not converted to Integer")
+      obj.should_not_receive(:to_i)
+      lambda { BigDecimal.induced_from(obj) }.should raise_error(TypeError)
+    end
+
+    it "raises a TypeError when passed a non-Integer" do
+      lambda { BigDecimal.induced_from(2.0) }.should raise_error(TypeError)
+      lambda { BigDecimal.induced_from("2") }.should raise_error(TypeError)
+      lambda { BigDecimal.induced_from(:symbol) }.should raise_error(TypeError)
+      lambda { BigDecimal.induced_from(nil) }.should raise_error(TypeError)
+      lambda { BigDecimal.induced_from(Object.new) }.should raise_error(TypeError)
+    end
+  end
+end

data/spec/infinite_spec.rb

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

data/spec/inspect_spec.rb

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

data/spec/limit_spec.rb

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

data/spec/lt_spec.rb

@@ -0,0 +1,84 @@
+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
+
+  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/lte_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 == 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
+
+  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/minus_spec.rb

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

data/spec/mode_spec.rb

@@ -0,0 +1,64 @@
+require 'bigdecimal'
+
+describe "BigDecimal.mode" do
+  #the default value of BigDecimal exception constants is false
+  after :all 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
+
+  ruby_version_is "" ... "1.9" do
+    it "returns zero when too big" do
+      BigDecimal("1E11111111111111111111").zero?.should == true
+      (BigDecimal("1E11111111111")*BigDecimal("1E11111111111")).zero?.should == true
+    end
+  end
+
+  ruby_version_is "1.9" ... "1.9.3" do
+    it "returns Infinity when too big" do
+      BigDecimal("1E11111111111111111111").should == BigDecimal("Infinity")
+      (BigDecimal("1E11111111111")*BigDecimal("1E11111111111")).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("1E11111111111")*BigDecimal("1E11111111111")) }.should raise_error(FloatDomainError)
+    end
+  end
+
+  ruby_version_is "1.9.3" do
+    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
+end

data/spec/modulo_spec.rb

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