require_relative '../../spec_helper'

ruby_version_is ""..."3.4" do
  require 'bigdecimal'

  describe "BigDecimal" do
    it "is not defined unless it is required" do
      ruby_exe('puts Object.const_defined?(:BigDecimal)').should == "false\n"
    end
  end

  describe "Kernel#BigDecimal" do

    it "creates a new object of class BigDecimal" do
      BigDecimal("3.14159").should be_kind_of(BigDecimal)
      (0..9).each {|i|
        BigDecimal("1#{i}").should == 10 + i
        BigDecimal("-1#{i}").should == -10 - i
        BigDecimal("1E#{i}").should == 10**i
        BigDecimal("1000000E-#{i}").should == 10**(6-i).to_f
        # ^ to_f to avoid Rational type
      }
      (1..9).each {|i|
        BigDecimal("100.#{i}").to_s.should =~ /\A0\.100#{i}E3\z/i
        BigDecimal("-100.#{i}").to_s.should =~ /\A-0\.100#{i}E3\z/i
      }
    end

    it "BigDecimal(Rational) with bigger-than-double numerator" do
      rational = 99999999999999999999/100r
      rational.numerator.should > 2**64
      BigDecimal(rational, 100).to_s.should == "0.99999999999999999999e18"
    end

    it "accepts significant digits >= given precision" do
      suppress_warning do
        BigDecimal("3.1415923", 10).precs[1].should >= 10
      end
    end

    it "determines precision from initial value" do
      pi_string = "3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196442881097566593014782083152134043"
      suppress_warning {
        BigDecimal(pi_string).precs[1]
      }.should >= pi_string.size-1
    end

    it "ignores leading and trailing whitespace" do
      BigDecimal("  \t\n \r1234\t\r\n ").should == BigDecimal("1234")
      BigDecimal("  \t\n \rNaN   \n").should.nan?
      BigDecimal("  \t\n \rInfinity   \n").infinite?.should == 1
      BigDecimal("  \t\n \r-Infinity   \n").infinite?.should == -1
    end

    it "coerces the value argument with #to_str" do
      initial = mock("value")
      initial.should_receive(:to_str).and_return("123")
      BigDecimal(initial).should == BigDecimal("123")
    end

    it "does not ignores trailing garbage" do
      -> { BigDecimal("123E45ruby") }.should raise_error(ArgumentError)
      -> { BigDecimal("123x45") }.should raise_error(ArgumentError)
      -> { BigDecimal("123.4%E5") }.should raise_error(ArgumentError)
      -> { BigDecimal("1E2E3E4E5E") }.should raise_error(ArgumentError)
    end

    it "raises ArgumentError for invalid strings" do
      -> { BigDecimal("ruby") }.should raise_error(ArgumentError)
      -> { BigDecimal("  \t\n \r-\t\t\tInfinity   \n") }.should raise_error(ArgumentError)
    end

    it "allows omitting the integer part" do
      BigDecimal(".123").should == BigDecimal("0.123")
    end

    it "process underscores as Float()" do
      reference = BigDecimal("12345.67E89")

      BigDecimal("12_345.67E89").should == reference
      -> { BigDecimal("1_2_3_4_5_._6____7_E89") }.should raise_error(ArgumentError)
      -> { BigDecimal("12345_.67E_8__9_") }.should raise_error(ArgumentError)
    end

    it "accepts NaN and [+-]Infinity" do
      BigDecimal("NaN").should.nan?

      pos_inf = BigDecimal("Infinity")
      pos_inf.should_not.finite?
      pos_inf.should > 0
      pos_inf.should == BigDecimal("+Infinity")

      neg_inf = BigDecimal("-Infinity")
      neg_inf.should_not.finite?
      neg_inf.should < 0
    end

    describe "with exception: false" do
      it "returns nil for invalid strings" do
        BigDecimal("invalid", exception: false).should be_nil
        BigDecimal("0invalid", exception: false).should be_nil
        BigDecimal("invalid0", exception: false).should be_nil
        BigDecimal("0.", exception: false).should be_nil
      end
    end

    describe "accepts NaN and [+-]Infinity as Float values" do
      it "works without an explicit precision" do
        BigDecimal(Float::NAN).should.nan?

        pos_inf = BigDecimal(Float::INFINITY)
        pos_inf.should_not.finite?
        pos_inf.should > 0
        pos_inf.should == BigDecimal("+Infinity")

        neg_inf = BigDecimal(-Float::INFINITY)
        neg_inf.should_not.finite?
        neg_inf.should < 0
      end

      it "works with an explicit precision" do
        BigDecimal(Float::NAN, Float::DIG).should.nan?

        pos_inf = BigDecimal(Float::INFINITY, Float::DIG)
        pos_inf.should_not.finite?
        pos_inf.should > 0
        pos_inf.should == BigDecimal("+Infinity")

        neg_inf = BigDecimal(-Float::INFINITY, Float::DIG)
        neg_inf.should_not.finite?
        neg_inf.should < 0
      end
    end

    it "allows for [eEdD] as exponent separator" do
      reference = BigDecimal("12345.67E89")

      BigDecimal("12345.67e89").should == reference
      BigDecimal("12345.67E89").should == reference
      BigDecimal("12345.67d89").should == reference
      BigDecimal("12345.67D89").should == reference
    end

    it "allows for varying signs" do
      reference = BigDecimal("123.456E1")

      BigDecimal("+123.456E1").should == reference
      BigDecimal("-123.456E1").should == -reference
      BigDecimal("123.456E+1").should == reference
      BigDecimal("12345.6E-1").should == reference
      BigDecimal("+123.456E+1").should == reference
      BigDecimal("+12345.6E-1").should == reference
      BigDecimal("-123.456E+1").should == -reference
      BigDecimal("-12345.6E-1").should == -reference
    end

    it "raises ArgumentError when Float is used without precision" do
      -> { BigDecimal(1.0) }.should raise_error(ArgumentError)
    end

    it "returns appropriate BigDecimal zero for signed zero" do
      BigDecimal(-0.0, Float::DIG).sign.should == -1
      BigDecimal(0.0, Float::DIG).sign.should == 1
    end

    it "pre-coerces long integers" do
      BigDecimal(3).add(1 << 50, 3).should == BigDecimal('0.113e16')
    end

    it "does not call to_s when calling inspect" do
      value = BigDecimal('44.44')
      value.to_s.should == '0.4444e2'
      value.inspect.should == '0.4444e2'

      ruby_exe( <<-'EOF').should == "cheese 0.4444e2"
        require 'bigdecimal'
        module BigDecimalOverride
          def to_s; "cheese"; end
        end
        BigDecimal.prepend BigDecimalOverride
        value = BigDecimal('44.44')
        print "#{value.to_s} #{value.inspect}"
      EOF
    end

    describe "when interacting with Rational" do
      before :each do
        @a = BigDecimal('166.666666666')
        @b = Rational(500, 3)
        @c = @a - @b
      end

      # Check the input is as we understand it

      it "has the LHS print as expected" do
        @a.to_s.should == "0.166666666666e3"
        @a.to_f.to_s.should == "166.666666666"
        Float(@a).to_s.should == "166.666666666"
      end

      it "has the RHS print as expected" do
        @b.to_s.should == "500/3"
        @b.to_f.to_s.should == "166.66666666666666"
        Float(@b).to_s.should == "166.66666666666666"
      end

      it "has the expected precision on the LHS" do
        suppress_warning { @a.precs[0] }.should == 18
      end

      it "has the expected maximum precision on the LHS" do
        suppress_warning { @a.precs[1] }.should == 27
      end

      it "produces the expected result when done via Float" do
        (Float(@a) - Float(@b)).to_s.should == "-6.666596163995564e-10"
      end

      it "produces the expected result when done via to_f" do
        (@a.to_f - @b.to_f).to_s.should == "-6.666596163995564e-10"
      end

      # Check underlying methods work as we understand

      it "BigDecimal precision is the number of digits rounded up to a multiple of nine" do
        1.upto(100) do |n|
          b = BigDecimal('4' * n)
          precs, _ = suppress_warning { b.precs }
          (precs >= 9).should be_true
          (precs >= n).should be_true
          (precs % 9).should == 0
        end
        suppress_warning { BigDecimal('NaN').precs[0] }.should == 9
      end

      it "BigDecimal maximum precision is nine more than precision except for abnormals" do
        1.upto(100) do |n|
          b = BigDecimal('4' * n)
          precs, max = suppress_warning { b.precs }
          max.should == precs + 9
        end
        suppress_warning { BigDecimal('NaN').precs[1] }.should == 9
      end

      it "BigDecimal(Rational, 18) produces the result we expect" do
        BigDecimal(@b, 18).to_s.should == "0.166666666666666667e3"
      end

      it "BigDecimal(Rational, BigDecimal.precs[0]) produces the result we expect" do
        BigDecimal(@b, suppress_warning { @a.precs[0] }).to_s.should == "0.166666666666666667e3"
      end

      # Check the top-level expression works as we expect

      it "produces a BigDecimal" do
        @c.class.should == BigDecimal
      end

      it "produces the expected result" do
        @c.should == BigDecimal("-0.666667e-9")
        @c.to_s.should == "-0.666667e-9"
      end

      it "produces the correct class for other arithmetic operators" do
        (@a + @b).class.should == BigDecimal
        (@a * @b).class.should == BigDecimal
        (@a / @b).class.should == BigDecimal
        (@a % @b).class.should == BigDecimal
      end
    end
  end
end
