summaryrefslogtreecommitdiff
path: root/test
diff options
context:
space:
mode:
Diffstat (limited to 'test')
-rw-r--r--test/bigdecimal/test_bigdecimal.rb523
-rw-r--r--test/bigdecimal/test_bigdecimal_util.rb4
2 files changed, 285 insertions, 242 deletions
diff --git a/test/bigdecimal/test_bigdecimal.rb b/test/bigdecimal/test_bigdecimal.rb
index 7b2bc76f2a..6d0430dfc7 100644
--- a/test/bigdecimal/test_bigdecimal.rb
+++ b/test/bigdecimal/test_bigdecimal.rb
@@ -2,6 +2,8 @@
require_relative "testbase"
require 'bigdecimal/math'
+require 'thread'
+
class TestBigDecimal < Test::Unit::TestCase
include TestBigDecimalBase
@@ -127,61 +129,73 @@ class TestBigDecimal < Test::Unit::TestCase
}.join
end
+ def test_s_ver
+ assert_warning(/BigDecimal\.ver is deprecated; use BigDecimal::VERSION instead/) do
+ BigDecimal.ver
+ end
+ end
+
+ def test_s_new
+ assert_warning(/BigDecimal.new is deprecated/) do
+ BigDecimal.new("1")
+ end
+ end
+
def test_new
- assert_equal(1, BigDecimal.new("1"))
- assert_equal(1, BigDecimal.new("1", 1))
- assert_equal(1, BigDecimal.new(" 1 "))
- assert_equal(111, BigDecimal.new("1_1_1_"))
- assert_equal(10**(-1), BigDecimal.new("1E-1"), '#4825')
+ assert_equal(1, BigDecimal("1"))
+ assert_equal(1, BigDecimal("1", 1))
+ assert_equal(1, BigDecimal(" 1 "))
+ assert_equal(111, BigDecimal("1_1_1_"))
+ assert_equal(10**(-1), BigDecimal("1E-1"), '#4825')
- assert_raise(ArgumentError, /"_1_1_1"/) { BigDecimal.new("_1_1_1") }
+ assert_raise(ArgumentError, /"_1_1_1"/) { BigDecimal("_1_1_1") }
BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, false)
BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false)
- assert_positive_infinite(BigDecimal.new("Infinity"))
- assert_negative_infinite(BigDecimal.new("-Infinity"))
- assert_nan(BigDecimal.new("NaN"))
- assert_positive_infinite(BigDecimal.new("1E1111111111111111111"))
+ assert_positive_infinite(BigDecimal("Infinity"))
+ assert_negative_infinite(BigDecimal("-Infinity"))
+ assert_nan(BigDecimal("NaN"))
+ assert_positive_infinite(BigDecimal("1E1111111111111111111"))
end
def test_new_with_integer
- assert_equal(BigDecimal("1"), BigDecimal.new(1))
- assert_equal(BigDecimal("-1"), BigDecimal.new(-1))
- assert_equal(BigDecimal((2**100).to_s), BigDecimal.new(2**100))
- assert_equal(BigDecimal((-2**100).to_s), BigDecimal.new(-2**100))
+ assert_equal(BigDecimal("1"), BigDecimal(1))
+ assert_equal(BigDecimal("-1"), BigDecimal(-1))
+ assert_equal(BigDecimal((2**100).to_s), BigDecimal(2**100))
+ assert_equal(BigDecimal((-2**100).to_s), BigDecimal(-2**100))
end
def test_new_with_rational
- assert_equal(BigDecimal("0.333333333333333333333"), BigDecimal.new(1.quo(3), 21))
- assert_equal(BigDecimal("-0.333333333333333333333"), BigDecimal.new(-1.quo(3), 21))
- assert_raise(ArgumentError) { BigDecimal.new(1.quo(3)) }
+ assert_equal(BigDecimal("0.333333333333333333333"), BigDecimal(1.quo(3), 21))
+ assert_equal(BigDecimal("-0.333333333333333333333"), BigDecimal(-1.quo(3), 21))
+ assert_raise(ArgumentError) { BigDecimal(1.quo(3)) }
end
def test_new_with_float
assert_equal(BigDecimal("0.1235"), BigDecimal(0.1234567, 4))
assert_equal(BigDecimal("-0.1235"), BigDecimal(-0.1234567, 4))
- assert_raise(ArgumentError) { BigDecimal.new(0.1) }
- assert_raise(ArgumentError) { BigDecimal.new(0.1, Float::DIG + 2) }
- assert_nothing_raised { BigDecimal.new(0.1, Float::DIG + 1) }
+ assert_raise(ArgumentError) { BigDecimal(0.1) }
+ assert_raise(ArgumentError) { BigDecimal(0.1, Float::DIG + 2) }
+ assert_nothing_raised { BigDecimal(0.1, Float::DIG + 1) }
end
def test_new_with_big_decimal
- assert_equal(BigDecimal(1), BigDecimal.new(BigDecimal(1)))
- assert_equal(BigDecimal('+0'), BigDecimal.new(BigDecimal('+0')))
- assert_equal(BigDecimal('-0'), BigDecimal.new(BigDecimal('-0')))
+ assert_equal(BigDecimal(1), BigDecimal(BigDecimal(1)))
+ assert_equal(BigDecimal('+0'), BigDecimal(BigDecimal('+0')))
+ assert_equal(BigDecimal('-0'), BigDecimal(BigDecimal('-0')))
BigDecimal.save_exception_mode do
BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, false)
BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false)
- assert_positive_infinite(BigDecimal.new(BigDecimal('Infinity')))
- assert_negative_infinite(BigDecimal.new(BigDecimal('-Infinity')))
- assert_nan(BigDecimal(BigDecimal.new('NaN')))
+ assert_positive_infinite(BigDecimal(BigDecimal('Infinity')))
+ assert_negative_infinite(BigDecimal(BigDecimal('-Infinity')))
+ assert_nan(BigDecimal(BigDecimal('NaN')))
end
end
def test_new_with_tainted_string
Thread.new {
$SAFE = 1
- BigDecimal.new('1'.taint)
+ BigDecimal('1'.taint)
}.join
end
@@ -283,16 +297,16 @@ class TestBigDecimal < Test::Unit::TestCase
end
def test_exception_nan
- _test_mode(BigDecimal::EXCEPTION_NaN) { BigDecimal.new("NaN") }
+ _test_mode(BigDecimal::EXCEPTION_NaN) { BigDecimal("NaN") }
end
def test_exception_infinity
- _test_mode(BigDecimal::EXCEPTION_INFINITY) { BigDecimal.new("Infinity") }
+ _test_mode(BigDecimal::EXCEPTION_INFINITY) { BigDecimal("Infinity") }
end
def test_exception_underflow
_test_mode(BigDecimal::EXCEPTION_UNDERFLOW) do
- x = BigDecimal.new("0.1")
+ x = BigDecimal("0.1")
100.times do
x *= x
end
@@ -301,7 +315,7 @@ class TestBigDecimal < Test::Unit::TestCase
def test_exception_overflow
_test_mode(BigDecimal::EXCEPTION_OVERFLOW) do
- x = BigDecimal.new("10")
+ x = BigDecimal("10")
100.times do
x *= x
end
@@ -310,17 +324,17 @@ class TestBigDecimal < Test::Unit::TestCase
def test_exception_zerodivide
BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, false)
- _test_mode(BigDecimal::EXCEPTION_ZERODIVIDE) { 1 / BigDecimal.new("0") }
- _test_mode(BigDecimal::EXCEPTION_ZERODIVIDE) { -1 / BigDecimal.new("0") }
+ _test_mode(BigDecimal::EXCEPTION_ZERODIVIDE) { 1 / BigDecimal("0") }
+ _test_mode(BigDecimal::EXCEPTION_ZERODIVIDE) { -1 / BigDecimal("0") }
end
def test_round_up
- n4 = BigDecimal.new("4") # n4 / 9 = 0.44444...
- n5 = BigDecimal.new("5") # n5 / 9 = 0.55555...
- n6 = BigDecimal.new("6") # n6 / 9 = 0.66666...
+ n4 = BigDecimal("4") # n4 / 9 = 0.44444...
+ n5 = BigDecimal("5") # n5 / 9 = 0.55555...
+ n6 = BigDecimal("6") # n6 / 9 = 0.66666...
m4, m5, m6 = -n4, -n5, -n6
- n2h = BigDecimal.new("2.5")
- n3h = BigDecimal.new("3.5")
+ n2h = BigDecimal("2.5")
+ n3h = BigDecimal("3.5")
m2h, m3h = -n2h, -n3h
BigDecimal.mode(BigDecimal::ROUND_MODE, BigDecimal::ROUND_UP)
@@ -412,25 +426,25 @@ class TestBigDecimal < Test::Unit::TestCase
BigDecimal.mode(BigDecimal::EXCEPTION_INFINITY, false)
BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false)
- assert_equal(true, BigDecimal.new("0").zero?)
- assert_equal(true, BigDecimal.new("-0").zero?)
- assert_equal(false, BigDecimal.new("1").zero?)
- assert_equal(true, BigDecimal.new("0E200000000000000").zero?)
- assert_equal(false, BigDecimal.new("Infinity").zero?)
- assert_equal(false, BigDecimal.new("-Infinity").zero?)
- assert_equal(false, BigDecimal.new("NaN").zero?)
+ assert_equal(true, BigDecimal("0").zero?)
+ assert_equal(true, BigDecimal("-0").zero?)
+ assert_equal(false, BigDecimal("1").zero?)
+ assert_equal(true, BigDecimal("0E200000000000000").zero?)
+ assert_equal(false, BigDecimal("Infinity").zero?)
+ assert_equal(false, BigDecimal("-Infinity").zero?)
+ assert_equal(false, BigDecimal("NaN").zero?)
end
def test_nonzero_p
BigDecimal.mode(BigDecimal::EXCEPTION_INFINITY, false)
BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false)
- assert_equal(nil, BigDecimal.new("0").nonzero?)
- assert_equal(nil, BigDecimal.new("-0").nonzero?)
- assert_equal(BigDecimal.new("1"), BigDecimal.new("1").nonzero?)
- assert_positive_infinite(BigDecimal.new("Infinity").nonzero?)
- assert_negative_infinite(BigDecimal.new("-Infinity").nonzero?)
- assert_nan(BigDecimal.new("NaN").nonzero?)
+ assert_equal(nil, BigDecimal("0").nonzero?)
+ assert_equal(nil, BigDecimal("-0").nonzero?)
+ assert_equal(BigDecimal("1"), BigDecimal("1").nonzero?)
+ assert_positive_infinite(BigDecimal("Infinity").nonzero?)
+ assert_negative_infinite(BigDecimal("-Infinity").nonzero?)
+ assert_nan(BigDecimal("NaN").nonzero?)
end
def test_double_fig
@@ -438,8 +452,8 @@ class TestBigDecimal < Test::Unit::TestCase
end
def test_cmp
- n1 = BigDecimal.new("1")
- n2 = BigDecimal.new("2")
+ n1 = BigDecimal("1")
+ n2 = BigDecimal("2")
assert_equal( 0, n1 <=> n1)
assert_equal( 1, n2 <=> n1)
assert_equal(-1, n1 <=> n2)
@@ -452,16 +466,16 @@ class TestBigDecimal < Test::Unit::TestCase
assert_operator(n2, :>=, n1)
assert_operator(n1, :>=, n1)
- assert_operator(BigDecimal.new("-0"), :==, BigDecimal.new("0"))
- assert_operator(BigDecimal.new("0"), :<, BigDecimal.new("1"))
- assert_operator(BigDecimal.new("1"), :>, BigDecimal.new("0"))
- assert_operator(BigDecimal.new("1"), :>, BigDecimal.new("-1"))
- assert_operator(BigDecimal.new("-1"), :<, BigDecimal.new("1"))
- assert_operator(BigDecimal.new((2**100).to_s), :>, BigDecimal.new("1"))
- assert_operator(BigDecimal.new("1"), :<, BigDecimal.new((2**100).to_s))
+ assert_operator(BigDecimal("-0"), :==, BigDecimal("0"))
+ assert_operator(BigDecimal("0"), :<, BigDecimal("1"))
+ assert_operator(BigDecimal("1"), :>, BigDecimal("0"))
+ assert_operator(BigDecimal("1"), :>, BigDecimal("-1"))
+ assert_operator(BigDecimal("-1"), :<, BigDecimal("1"))
+ assert_operator(BigDecimal((2**100).to_s), :>, BigDecimal("1"))
+ assert_operator(BigDecimal("1"), :<, BigDecimal((2**100).to_s))
BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, false)
- inf = BigDecimal.new("Infinity")
+ inf = BigDecimal("Infinity")
assert_operator(inf, :>, 1)
assert_operator(1, :<, inf)
@@ -484,25 +498,25 @@ class TestBigDecimal < Test::Unit::TestCase
end
def test_cmp_nan
- n1 = BigDecimal.new("1")
+ n1 = BigDecimal("1")
BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false)
- assert_equal(nil, BigDecimal.new("NaN") <=> n1)
- assert_equal(false, BigDecimal.new("NaN") > n1)
- assert_equal(nil, BigDecimal.new("NaN") <=> BigDecimal.new("NaN"))
- assert_equal(false, BigDecimal.new("NaN") == BigDecimal.new("NaN"))
+ assert_equal(nil, BigDecimal("NaN") <=> n1)
+ assert_equal(false, BigDecimal("NaN") > n1)
+ assert_equal(nil, BigDecimal("NaN") <=> BigDecimal("NaN"))
+ assert_equal(false, BigDecimal("NaN") == BigDecimal("NaN"))
end
def test_cmp_failing_coercion
- n1 = BigDecimal.new("1")
+ n1 = BigDecimal("1")
assert_equal(nil, n1 <=> nil)
assert_raise(ArgumentError){n1 > nil}
end
def test_cmp_coerce
- n1 = BigDecimal.new("1")
- n2 = BigDecimal.new("2")
- o1 = Object.new; def o1.coerce(x); [x, BigDecimal.new("1")]; end
- o2 = Object.new; def o2.coerce(x); [x, BigDecimal.new("2")]; end
+ n1 = BigDecimal("1")
+ n2 = BigDecimal("2")
+ o1 = Object.new; def o1.coerce(x); [x, BigDecimal("1")]; end
+ o2 = Object.new; def o2.coerce(x); [x, BigDecimal("2")]; end
assert_equal( 0, n1 <=> o1)
assert_equal( 1, n2 <=> o1)
assert_equal(-1, n1 <=> o2)
@@ -522,16 +536,16 @@ class TestBigDecimal < Test::Unit::TestCase
end
def test_cmp_bignum
- assert_operator(BigDecimal.new((2**100).to_s), :==, 2**100)
+ assert_operator(BigDecimal((2**100).to_s), :==, 2**100)
end
def test_cmp_data
d = Time.now; def d.coerce(x); [x, x]; end
- assert_operator(BigDecimal.new((2**100).to_s), :==, d)
+ assert_operator(BigDecimal((2**100).to_s), :==, d)
end
def test_precs
- a = BigDecimal.new("1").precs
+ a = BigDecimal("1").precs
assert_instance_of(Array, a)
assert_equal(2, a.size)
assert_kind_of(Integer, a[0])
@@ -540,14 +554,13 @@ class TestBigDecimal < Test::Unit::TestCase
def test_hash
a = []
- b = BigDecimal.new("1")
+ b = BigDecimal("1")
10.times { a << b *= 10 }
h = {}
a.each_with_index {|x, i| h[x] = i }
a.each_with_index do |x, i|
assert_equal(i, h[x])
end
- assert_instance_of(String, b.hash.to_s)
end
def test_marshal
@@ -563,7 +576,7 @@ class TestBigDecimal < Test::Unit::TestCase
BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, false)
BigDecimal.mode(BigDecimal::EXCEPTION_ZERODIVIDE, false)
- x = BigDecimal.new("0")
+ x = BigDecimal("0")
assert_equal(true, x.finite?)
assert_equal(nil, x.infinite?)
assert_equal(false, x.nan?)
@@ -587,15 +600,15 @@ class TestBigDecimal < Test::Unit::TestCase
BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, false)
BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false)
- x = BigDecimal.new("0")
+ x = BigDecimal("0")
assert_kind_of(Integer, x.to_i)
assert_equal(0, x.to_i)
assert_raise(FloatDomainError){( 1 / x).to_i}
assert_raise(FloatDomainError){(-1 / x).to_i}
assert_raise(FloatDomainError) {( 0 / x).to_i}
- x = BigDecimal.new("1")
+ x = BigDecimal("1")
assert_equal(1, x.to_i)
- x = BigDecimal.new((2**100).to_s)
+ x = BigDecimal((2**100).to_s)
assert_equal(2**100, x.to_i)
end
@@ -604,18 +617,18 @@ class TestBigDecimal < Test::Unit::TestCase
BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false)
BigDecimal.mode(BigDecimal::EXCEPTION_ZERODIVIDE, false)
- x = BigDecimal.new("0")
+ x = BigDecimal("0")
assert_instance_of(Float, x.to_f)
assert_equal(0.0, x.to_f)
assert_equal( 1.0 / 0.0, ( 1 / x).to_f)
assert_equal(-1.0 / 0.0, (-1 / x).to_f)
assert_nan(( 0 / x).to_f)
- x = BigDecimal.new("1")
+ x = BigDecimal("1")
assert_equal(1.0, x.to_f)
- x = BigDecimal.new((2**100).to_s)
+ x = BigDecimal((2**100).to_s)
assert_equal((2**100).to_f, x.to_f)
- x = BigDecimal.new("1" + "0" * 10000)
- assert_equal(0, BigDecimal.new("-0").to_f)
+ x = BigDecimal("1" + "0" * 10000)
+ assert_equal(0, BigDecimal("-0").to_f)
BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, true)
assert_raise(FloatDomainError) { x.to_f }
@@ -663,23 +676,23 @@ class TestBigDecimal < Test::Unit::TestCase
BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, false)
BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false)
- x = BigDecimal.new("0")
+ x = BigDecimal("0")
assert_kind_of(Rational, x.to_r)
assert_equal(0, x.to_r)
assert_raise(FloatDomainError) {( 1 / x).to_r}
assert_raise(FloatDomainError) {(-1 / x).to_r}
assert_raise(FloatDomainError) {( 0 / x).to_r}
- assert_equal(1, BigDecimal.new("1").to_r)
- assert_equal(Rational(3, 2), BigDecimal.new("1.5").to_r)
- assert_equal((2**100).to_r, BigDecimal.new((2**100).to_s).to_r)
+ assert_equal(1, BigDecimal("1").to_r)
+ assert_equal(Rational(3, 2), BigDecimal("1.5").to_r)
+ assert_equal((2**100).to_r, BigDecimal((2**100).to_s).to_r)
end
def test_coerce
- a, b = BigDecimal.new("1").coerce(1.0)
+ a, b = BigDecimal("1").coerce(1.0)
assert_instance_of(BigDecimal, a)
assert_instance_of(BigDecimal, b)
- assert_equal(2, 1 + BigDecimal.new("1"), '[ruby-core:25697]')
+ assert_equal(2, 1 + BigDecimal("1"), '[ruby-core:25697]')
a, b = BigDecimal("1").coerce(1.quo(10))
assert_equal(BigDecimal("0.1"), a, '[ruby-core:34318]')
@@ -688,12 +701,12 @@ class TestBigDecimal < Test::Unit::TestCase
assert_equal(BigDecimal("0." + "3"*a.precs[0]), a)
assert_nothing_raised(TypeError, '#7176') do
- BigDecimal.new('1') + Rational(1)
+ BigDecimal('1') + Rational(1)
end
end
def test_uplus
- x = BigDecimal.new("1")
+ x = BigDecimal("1")
assert_equal(x, x.send(:+@))
end
@@ -701,26 +714,26 @@ class TestBigDecimal < Test::Unit::TestCase
BigDecimal.mode(BigDecimal::EXCEPTION_INFINITY, false)
BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false)
- assert_equal(BigDecimal.new("-1"), BigDecimal.new("1").send(:-@))
- assert_equal(BigDecimal.new("-0"), BigDecimal.new("0").send(:-@))
- assert_equal(BigDecimal.new("0"), BigDecimal.new("-0").send(:-@))
- assert_equal(BigDecimal.new("-Infinity"), BigDecimal.new("Infinity").send(:-@))
- assert_equal(BigDecimal.new("Infinity"), BigDecimal.new("-Infinity").send(:-@))
- assert_equal(true, BigDecimal.new("NaN").send(:-@).nan?)
+ assert_equal(BigDecimal("-1"), BigDecimal("1").send(:-@))
+ assert_equal(BigDecimal("-0"), BigDecimal("0").send(:-@))
+ assert_equal(BigDecimal("0"), BigDecimal("-0").send(:-@))
+ assert_equal(BigDecimal("-Infinity"), BigDecimal("Infinity").send(:-@))
+ assert_equal(BigDecimal("Infinity"), BigDecimal("-Infinity").send(:-@))
+ assert_equal(true, BigDecimal("NaN").send(:-@).nan?)
end
def test_add
- x = BigDecimal.new("1")
- assert_equal(BigDecimal.new("2"), x + x)
- assert_equal(1, BigDecimal.new("0") + 1)
+ x = BigDecimal("1")
+ assert_equal(BigDecimal("2"), x + x)
+ assert_equal(1, BigDecimal("0") + 1)
assert_equal(1, x + 0)
- assert_equal(BigDecimal::SIGN_POSITIVE_ZERO, (BigDecimal.new("0") + 0).sign)
- assert_equal(BigDecimal::SIGN_POSITIVE_ZERO, (BigDecimal.new("-0") + 0).sign)
- assert_equal(BigDecimal::SIGN_NEGATIVE_ZERO, (BigDecimal.new("-0") + BigDecimal.new("-0")).sign)
+ assert_equal(BigDecimal::SIGN_POSITIVE_ZERO, (BigDecimal("0") + 0).sign)
+ assert_equal(BigDecimal::SIGN_POSITIVE_ZERO, (BigDecimal("-0") + 0).sign)
+ assert_equal(BigDecimal::SIGN_NEGATIVE_ZERO, (BigDecimal("-0") + BigDecimal("-0")).sign)
- x = BigDecimal.new((2**100).to_s)
- assert_equal(BigDecimal.new((2**100+1).to_s), x + 1)
+ x = BigDecimal((2**100).to_s)
+ assert_equal(BigDecimal((2**100+1).to_s), x + 1)
BigDecimal.mode(BigDecimal::EXCEPTION_INFINITY, false)
inf = BigDecimal("Infinity")
@@ -732,17 +745,17 @@ class TestBigDecimal < Test::Unit::TestCase
end
def test_sub
- x = BigDecimal.new("1")
- assert_equal(BigDecimal.new("0"), x - x)
- assert_equal(-1, BigDecimal.new("0") - 1)
+ x = BigDecimal("1")
+ assert_equal(BigDecimal("0"), x - x)
+ assert_equal(-1, BigDecimal("0") - 1)
assert_equal(1, x - 0)
- assert_equal(BigDecimal::SIGN_POSITIVE_ZERO, (BigDecimal.new("0") - 0).sign)
- assert_equal(BigDecimal::SIGN_NEGATIVE_ZERO, (BigDecimal.new("-0") - 0).sign)
- assert_equal(BigDecimal::SIGN_POSITIVE_ZERO, (BigDecimal.new("-0") - BigDecimal.new("-0")).sign)
+ assert_equal(BigDecimal::SIGN_POSITIVE_ZERO, (BigDecimal("0") - 0).sign)
+ assert_equal(BigDecimal::SIGN_NEGATIVE_ZERO, (BigDecimal("-0") - 0).sign)
+ assert_equal(BigDecimal::SIGN_POSITIVE_ZERO, (BigDecimal("-0") - BigDecimal("-0")).sign)
- x = BigDecimal.new((2**100).to_s)
- assert_equal(BigDecimal.new((2**100-1).to_s), x - 1)
+ x = BigDecimal((2**100).to_s)
+ assert_equal(BigDecimal((2**100-1).to_s), x - 1)
BigDecimal.mode(BigDecimal::EXCEPTION_INFINITY, false)
inf = BigDecimal("Infinity")
@@ -754,19 +767,19 @@ class TestBigDecimal < Test::Unit::TestCase
end
def test_sub_with_float
- assert_kind_of(BigDecimal, BigDecimal.new("3") - 1.0)
+ assert_kind_of(BigDecimal, BigDecimal("3") - 1.0)
end
def test_sub_with_rational
- assert_kind_of(BigDecimal, BigDecimal.new("3") - 1.quo(3))
+ assert_kind_of(BigDecimal, BigDecimal("3") - 1.quo(3))
end
def test_mult
- x = BigDecimal.new((2**100).to_s)
- assert_equal(BigDecimal.new((2**100 * 3).to_s), (x * 3).to_i)
+ x = BigDecimal((2**100).to_s)
+ assert_equal(BigDecimal((2**100 * 3).to_s), (x * 3).to_i)
assert_equal(x, (x * 1).to_i)
assert_equal(x, (BigDecimal("1") * x).to_i)
- assert_equal(BigDecimal.new((2**200).to_s), (x * x).to_i)
+ assert_equal(BigDecimal((2**200).to_s), (x * x).to_i)
BigDecimal.mode(BigDecimal::EXCEPTION_INFINITY, false)
inf = BigDecimal("Infinity")
@@ -778,11 +791,11 @@ class TestBigDecimal < Test::Unit::TestCase
end
def test_mult_with_float
- assert_kind_of(BigDecimal, BigDecimal.new("3") * 1.5)
+ assert_kind_of(BigDecimal, BigDecimal("3") * 1.5)
end
def test_mult_with_rational
- assert_kind_of(BigDecimal, BigDecimal.new("3") * 1.quo(3))
+ assert_kind_of(BigDecimal, BigDecimal("3") * 1.quo(3))
end
def test_mult_with_nil
@@ -792,39 +805,39 @@ class TestBigDecimal < Test::Unit::TestCase
end
def test_div
- x = BigDecimal.new((2**100).to_s)
- assert_equal(BigDecimal.new((2**100 / 3).to_s), (x / 3).to_i)
- assert_equal(BigDecimal::SIGN_POSITIVE_ZERO, (BigDecimal.new("0") / 1).sign)
- assert_equal(BigDecimal::SIGN_NEGATIVE_ZERO, (BigDecimal.new("-0") / 1).sign)
- assert_equal(2, BigDecimal.new("2") / 1)
- assert_equal(-2, BigDecimal.new("2") / -1)
+ x = BigDecimal((2**100).to_s)
+ assert_equal(BigDecimal((2**100 / 3).to_s), (x / 3).to_i)
+ assert_equal(BigDecimal::SIGN_POSITIVE_ZERO, (BigDecimal("0") / 1).sign)
+ assert_equal(BigDecimal::SIGN_NEGATIVE_ZERO, (BigDecimal("-0") / 1).sign)
+ assert_equal(2, BigDecimal("2") / 1)
+ assert_equal(-2, BigDecimal("2") / -1)
assert_equal(BigDecimal('1486.868686869'), BigDecimal('1472.0') / BigDecimal('0.99'), '[ruby-core:59365] [#9316]')
assert_equal(4.124045235, BigDecimal('0.9932') / (700 * BigDecimal('0.344045') / BigDecimal('1000.0')), '[#9305]')
BigDecimal.mode(BigDecimal::EXCEPTION_INFINITY, false)
- assert_positive_zero(BigDecimal.new("1.0") / BigDecimal.new("Infinity"))
- assert_negative_zero(BigDecimal.new("-1.0") / BigDecimal.new("Infinity"))
- assert_negative_zero(BigDecimal.new("1.0") / BigDecimal.new("-Infinity"))
- assert_positive_zero(BigDecimal.new("-1.0") / BigDecimal.new("-Infinity"))
+ assert_positive_zero(BigDecimal("1.0") / BigDecimal("Infinity"))
+ assert_negative_zero(BigDecimal("-1.0") / BigDecimal("Infinity"))
+ assert_negative_zero(BigDecimal("1.0") / BigDecimal("-Infinity"))
+ assert_positive_zero(BigDecimal("-1.0") / BigDecimal("-Infinity"))
BigDecimal.mode(BigDecimal::EXCEPTION_INFINITY, true)
BigDecimal.mode(BigDecimal::EXCEPTION_ZERODIVIDE, false)
- assert_raise_with_message(FloatDomainError, "Computation results to 'Infinity'") { BigDecimal.new("1") / 0 }
- assert_raise_with_message(FloatDomainError, "Computation results to '-Infinity'") { BigDecimal.new("-1") / 0 }
+ assert_raise_with_message(FloatDomainError, "Computation results to 'Infinity'") { BigDecimal("1") / 0 }
+ assert_raise_with_message(FloatDomainError, "Computation results to '-Infinity'") { BigDecimal("-1") / 0 }
end
def test_div_with_float
- assert_kind_of(BigDecimal, BigDecimal.new("3") / 1.5)
+ assert_kind_of(BigDecimal, BigDecimal("3") / 1.5)
end
def test_div_with_rational
- assert_kind_of(BigDecimal, BigDecimal.new("3") / 1.quo(3))
+ assert_kind_of(BigDecimal, BigDecimal("3") / 1.quo(3))
end
def test_mod
- x = BigDecimal.new((2**100).to_s)
+ x = BigDecimal((2**100).to_s)
assert_equal(1, x % 3)
assert_equal(2, (-x) % 3)
assert_equal(-2, x % -3)
@@ -832,15 +845,15 @@ class TestBigDecimal < Test::Unit::TestCase
end
def test_mod_with_float
- assert_kind_of(BigDecimal, BigDecimal.new("3") % 1.5)
+ assert_kind_of(BigDecimal, BigDecimal("3") % 1.5)
end
def test_mod_with_rational
- assert_kind_of(BigDecimal, BigDecimal.new("3") % 1.quo(3))
+ assert_kind_of(BigDecimal, BigDecimal("3") % 1.quo(3))
end
def test_remainder
- x = BigDecimal.new((2**100).to_s)
+ x = BigDecimal((2**100).to_s)
assert_equal(1, x.remainder(3))
assert_equal(-1, (-x).remainder(3))
assert_equal(1, x.remainder(-3))
@@ -848,47 +861,47 @@ class TestBigDecimal < Test::Unit::TestCase
end
def test_remainder_with_float
- assert_kind_of(BigDecimal, BigDecimal.new("3").remainder(1.5))
+ assert_kind_of(BigDecimal, BigDecimal("3").remainder(1.5))
end
def test_remainder_with_rational
- assert_kind_of(BigDecimal, BigDecimal.new("3").remainder(1.quo(3)))
+ assert_kind_of(BigDecimal, BigDecimal("3").remainder(1.quo(3)))
end
def test_divmod
- x = BigDecimal.new((2**100).to_s)
+ x = BigDecimal((2**100).to_s)
assert_equal([(x / 3).floor, 1], x.divmod(3))
assert_equal([(-x / 3).floor, 2], (-x).divmod(3))
- assert_equal([0, 0], BigDecimal.new("0").divmod(2))
+ assert_equal([0, 0], BigDecimal("0").divmod(2))
BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false)
- assert_raise(ZeroDivisionError){BigDecimal.new("0").divmod(0)}
+ assert_raise(ZeroDivisionError){BigDecimal("0").divmod(0)}
end
def test_add_bigdecimal
- x = BigDecimal.new((2**100).to_s)
+ x = BigDecimal((2**100).to_s)
assert_equal(3000000000000000000000000000000, x.add(x, 1))
assert_equal(2500000000000000000000000000000, x.add(x, 2))
assert_equal(2540000000000000000000000000000, x.add(x, 3))
end
def test_sub_bigdecimal
- x = BigDecimal.new((2**100).to_s)
+ x = BigDecimal((2**100).to_s)
assert_equal(1000000000000000000000000000000, x.sub(1, 1))
assert_equal(1300000000000000000000000000000, x.sub(1, 2))
assert_equal(1270000000000000000000000000000, x.sub(1, 3))
end
def test_mult_bigdecimal
- x = BigDecimal.new((2**100).to_s)
+ x = BigDecimal((2**100).to_s)
assert_equal(4000000000000000000000000000000, x.mult(3, 1))
assert_equal(3800000000000000000000000000000, x.mult(3, 2))
assert_equal(3800000000000000000000000000000, x.mult(3, 3))
end
def test_div_bigdecimal
- x = BigDecimal.new((2**100).to_s)
+ x = BigDecimal((2**100).to_s)
assert_equal(422550200076076467165567735125, x.div(3))
assert_equal(400000000000000000000000000000, x.div(3, 1))
assert_equal(420000000000000000000000000000, x.div(3, 2))
@@ -900,49 +913,49 @@ class TestBigDecimal < Test::Unit::TestCase
end
def test_abs_bigdecimal
- x = BigDecimal.new((2**100).to_s)
+ x = BigDecimal((2**100).to_s)
assert_equal(1267650600228229401496703205376, x.abs)
- x = BigDecimal.new("-" + (2**100).to_s)
+ x = BigDecimal("-" + (2**100).to_s)
assert_equal(1267650600228229401496703205376, x.abs)
- x = BigDecimal.new("0")
+ x = BigDecimal("0")
assert_equal(0, x.abs)
- x = BigDecimal.new("-0")
+ x = BigDecimal("-0")
assert_equal(0, x.abs)
BigDecimal.mode(BigDecimal::EXCEPTION_INFINITY, false)
- x = BigDecimal.new("Infinity")
- assert_equal(BigDecimal.new("Infinity"), x.abs)
- x = BigDecimal.new("-Infinity")
- assert_equal(BigDecimal.new("Infinity"), x.abs)
+ x = BigDecimal("Infinity")
+ assert_equal(BigDecimal("Infinity"), x.abs)
+ x = BigDecimal("-Infinity")
+ assert_equal(BigDecimal("Infinity"), x.abs)
BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false)
- x = BigDecimal.new("NaN")
+ x = BigDecimal("NaN")
assert_nan(x.abs)
end
def test_sqrt_bigdecimal
- x = BigDecimal.new("0.09")
+ x = BigDecimal("0.09")
assert_in_delta(0.3, x.sqrt(1), 0.001)
- x = BigDecimal.new((2**100).to_s)
+ x = BigDecimal((2**100).to_s)
y = BigDecimal("1125899906842624")
e = y.exponent
assert_equal(true, (x.sqrt(100) - y).abs < BigDecimal("1E#{e-100}"))
assert_equal(true, (x.sqrt(200) - y).abs < BigDecimal("1E#{e-200}"))
assert_equal(true, (x.sqrt(300) - y).abs < BigDecimal("1E#{e-300}"))
- x = BigDecimal.new("-" + (2**100).to_s)
+ x = BigDecimal("-" + (2**100).to_s)
assert_raise_with_message(FloatDomainError, "sqrt of negative value") { x.sqrt(1) }
- x = BigDecimal.new((2**200).to_s)
+ x = BigDecimal((2**200).to_s)
assert_equal(2**100, x.sqrt(1))
BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, false)
BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false)
- assert_raise_with_message(FloatDomainError, "sqrt of 'NaN'(Not a Number)") { BigDecimal.new("NaN").sqrt(1) }
- assert_raise_with_message(FloatDomainError, "sqrt of negative value") { BigDecimal.new("-Infinity").sqrt(1) }
+ assert_raise_with_message(FloatDomainError, "sqrt of 'NaN'(Not a Number)") { BigDecimal("NaN").sqrt(1) }
+ assert_raise_with_message(FloatDomainError, "sqrt of negative value") { BigDecimal("-Infinity").sqrt(1) }
- assert_equal(0, BigDecimal.new("0").sqrt(1))
- assert_equal(0, BigDecimal.new("-0").sqrt(1))
- assert_equal(1, BigDecimal.new("1").sqrt(1))
- assert_positive_infinite(BigDecimal.new("Infinity").sqrt(1))
+ assert_equal(0, BigDecimal("0").sqrt(1))
+ assert_equal(0, BigDecimal("-0").sqrt(1))
+ assert_equal(1, BigDecimal("1").sqrt(1))
+ assert_positive_infinite(BigDecimal("Infinity").sqrt(1))
end
def test_sqrt_5266
@@ -960,26 +973,26 @@ class TestBigDecimal < Test::Unit::TestCase
end
def test_fix
- x = BigDecimal.new("1.1")
+ x = BigDecimal("1.1")
assert_equal(1, x.fix)
assert_kind_of(BigDecimal, x.fix)
end
def test_frac
- x = BigDecimal.new("1.1")
+ x = BigDecimal("1.1")
assert_equal(0.1, x.frac)
- assert_equal(0.1, BigDecimal.new("0.1").frac)
+ assert_equal(0.1, BigDecimal("0.1").frac)
BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false)
- assert_nan(BigDecimal.new("NaN").frac)
+ assert_nan(BigDecimal("NaN").frac)
end
def test_round
- assert_equal(3, BigDecimal.new("3.14159").round)
- assert_equal(9, BigDecimal.new("8.7").round)
- assert_equal(3.142, BigDecimal.new("3.14159").round(3))
- assert_equal(13300.0, BigDecimal.new("13345.234").round(-2))
+ assert_equal(3, BigDecimal("3.14159").round)
+ assert_equal(9, BigDecimal("8.7").round)
+ assert_equal(3.142, BigDecimal("3.14159").round(3))
+ assert_equal(13300.0, BigDecimal("13345.234").round(-2))
- x = BigDecimal.new("111.111")
+ x = BigDecimal("111.111")
assert_equal(111 , x.round)
assert_equal(111.1 , x.round(1))
assert_equal(111.11 , x.round(2))
@@ -990,7 +1003,7 @@ class TestBigDecimal < Test::Unit::TestCase
assert_equal( 0 , x.round(-3))
assert_equal( 0 , x.round(-4))
- x = BigDecimal.new("2.5")
+ x = BigDecimal("2.5")
assert_equal(3, x.round(0, BigDecimal::ROUND_UP))
assert_equal(2, x.round(0, BigDecimal::ROUND_DOWN))
assert_equal(3, x.round(0, BigDecimal::ROUND_HALF_UP))
@@ -1000,19 +1013,28 @@ class TestBigDecimal < Test::Unit::TestCase
assert_equal(2, x.round(0, BigDecimal::ROUND_FLOOR))
assert_raise(ArgumentError) { x.round(0, 256) }
+ x = BigDecimal("-2.5")
+ assert_equal(-3, x.round(0, BigDecimal::ROUND_UP))
+ assert_equal(-2, x.round(0, BigDecimal::ROUND_DOWN))
+ assert_equal(-3, x.round(0, BigDecimal::ROUND_HALF_UP))
+ assert_equal(-2, x.round(0, BigDecimal::ROUND_HALF_DOWN))
+ assert_equal(-2, x.round(0, BigDecimal::ROUND_HALF_EVEN))
+ assert_equal(-2, x.round(0, BigDecimal::ROUND_CEILING))
+ assert_equal(-3, x.round(0, BigDecimal::ROUND_FLOOR))
+
ROUNDING_MODE_MAP.each do |const, sym|
assert_equal(x.round(0, const), x.round(0, sym))
end
bug3803 = '[ruby-core:32136]'
15.times do |n|
- x = BigDecimal.new("5#{'0'*n}1")
+ x = BigDecimal("5#{'0'*n}1")
assert_equal(10**(n+2), x.round(-(n+2), BigDecimal::ROUND_HALF_DOWN), bug3803)
assert_equal(10**(n+2), x.round(-(n+2), BigDecimal::ROUND_HALF_EVEN), bug3803)
- x = BigDecimal.new("0.5#{'0'*n}1")
+ x = BigDecimal("0.5#{'0'*n}1")
assert_equal(1, x.round(0, BigDecimal::ROUND_HALF_DOWN), bug3803)
assert_equal(1, x.round(0, BigDecimal::ROUND_HALF_EVEN), bug3803)
- x = BigDecimal.new("-0.5#{'0'*n}1")
+ x = BigDecimal("-0.5#{'0'*n}1")
assert_equal(-1, x.round(0, BigDecimal::ROUND_HALF_DOWN), bug3803)
assert_equal(-1, x.round(0, BigDecimal::ROUND_HALF_EVEN), bug3803)
end
@@ -1082,7 +1104,7 @@ class TestBigDecimal < Test::Unit::TestCase
end
def test_round_half_nil
- x = BigDecimal.new("2.5")
+ x = BigDecimal("2.5")
BigDecimal.save_rounding_mode do
BigDecimal.mode(BigDecimal::ROUND_MODE, BigDecimal::ROUND_UP)
@@ -1126,61 +1148,66 @@ class TestBigDecimal < Test::Unit::TestCase
end
def test_truncate
- assert_equal(3, BigDecimal.new("3.14159").truncate)
- assert_equal(8, BigDecimal.new("8.7").truncate)
- assert_equal(3.141, BigDecimal.new("3.14159").truncate(3))
- assert_equal(13300.0, BigDecimal.new("13345.234").truncate(-2))
+ assert_equal(3, BigDecimal("3.14159").truncate)
+ assert_equal(8, BigDecimal("8.7").truncate)
+ assert_equal(3.141, BigDecimal("3.14159").truncate(3))
+ assert_equal(13300.0, BigDecimal("13345.234").truncate(-2))
+
+ assert_equal(-3, BigDecimal("-3.14159").truncate)
+ assert_equal(-8, BigDecimal("-8.7").truncate)
+ assert_equal(-3.141, BigDecimal("-3.14159").truncate(3))
+ assert_equal(-13300.0, BigDecimal("-13345.234").truncate(-2))
end
def test_floor
- assert_equal(3, BigDecimal.new("3.14159").floor)
- assert_equal(-10, BigDecimal.new("-9.1").floor)
- assert_equal(3.141, BigDecimal.new("3.14159").floor(3))
- assert_equal(13300.0, BigDecimal.new("13345.234").floor(-2))
+ assert_equal(3, BigDecimal("3.14159").floor)
+ assert_equal(-10, BigDecimal("-9.1").floor)
+ assert_equal(3.141, BigDecimal("3.14159").floor(3))
+ assert_equal(13300.0, BigDecimal("13345.234").floor(-2))
end
def test_ceil
- assert_equal(4, BigDecimal.new("3.14159").ceil)
- assert_equal(-9, BigDecimal.new("-9.1").ceil)
- assert_equal(3.142, BigDecimal.new("3.14159").ceil(3))
- assert_equal(13400.0, BigDecimal.new("13345.234").ceil(-2))
+ assert_equal(4, BigDecimal("3.14159").ceil)
+ assert_equal(-9, BigDecimal("-9.1").ceil)
+ assert_equal(3.142, BigDecimal("3.14159").ceil(3))
+ assert_equal(13400.0, BigDecimal("13345.234").ceil(-2))
end
def test_to_s
- assert_equal('-123.45678 90123 45678 9', BigDecimal.new('-123.45678901234567890').to_s('5F'))
- assert_equal('+123.45678901 23456789', BigDecimal.new('123.45678901234567890').to_s('+8F'))
- assert_equal(' 123.4567890123456789', BigDecimal.new('123.45678901234567890').to_s(' F'))
- assert_equal('0.1234567890123456789e3', BigDecimal.new('123.45678901234567890').to_s)
- assert_equal('0.12345 67890 12345 6789e3', BigDecimal.new('123.45678901234567890').to_s(5))
+ assert_equal('-123.45678 90123 45678 9', BigDecimal('-123.45678901234567890').to_s('5F'))
+ assert_equal('+123.45678901 23456789', BigDecimal('123.45678901234567890').to_s('+8F'))
+ assert_equal(' 123.4567890123456789', BigDecimal('123.45678901234567890').to_s(' F'))
+ assert_equal('0.1234567890123456789e3', BigDecimal('123.45678901234567890').to_s)
+ assert_equal('0.12345 67890 12345 6789e3', BigDecimal('123.45678901234567890').to_s(5))
end
def test_split
- x = BigDecimal.new('-123.45678901234567890')
+ x = BigDecimal('-123.45678901234567890')
assert_equal([-1, "1234567890123456789", 10, 3], x.split)
- assert_equal([1, "0", 10, 0], BigDecimal.new("0").split)
- assert_equal([-1, "0", 10, 0], BigDecimal.new("-0").split)
+ assert_equal([1, "0", 10, 0], BigDecimal("0").split)
+ assert_equal([-1, "0", 10, 0], BigDecimal("-0").split)
BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, false)
BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false)
- assert_equal([0, "NaN", 10, 0], BigDecimal.new("NaN").split)
- assert_equal([1, "Infinity", 10, 0], BigDecimal.new("Infinity").split)
- assert_equal([-1, "Infinity", 10, 0], BigDecimal.new("-Infinity").split)
+ assert_equal([0, "NaN", 10, 0], BigDecimal("NaN").split)
+ assert_equal([1, "Infinity", 10, 0], BigDecimal("Infinity").split)
+ assert_equal([-1, "Infinity", 10, 0], BigDecimal("-Infinity").split)
end
def test_exponent
- x = BigDecimal.new('-123.45678901234567890')
+ x = BigDecimal('-123.45678901234567890')
assert_equal(3, x.exponent)
end
def test_inspect
- assert_equal("0.123456789012e0", BigDecimal.new("0.123456789012").inspect)
- assert_equal("0.123456789012e4", BigDecimal.new("1234.56789012").inspect)
- assert_equal("0.123456789012e-4", BigDecimal.new("0.0000123456789012").inspect)
+ assert_equal("0.123456789012e0", BigDecimal("0.123456789012").inspect)
+ assert_equal("0.123456789012e4", BigDecimal("1234.56789012").inspect)
+ assert_equal("0.123456789012e-4", BigDecimal("0.0000123456789012").inspect)
end
def test_power
assert_nothing_raised(TypeError, '[ruby-core:47632]') do
- 1000.times { BigDecimal.new('1001.10')**0.75 }
+ 1000.times { BigDecimal('1001.10')**0.75 }
end
end
@@ -1379,7 +1406,7 @@ class TestBigDecimal < Test::Unit::TestCase
def test_limit
BigDecimal.limit(1)
- x = BigDecimal.new("3")
+ x = BigDecimal("3")
assert_equal(90, x ** 4) # OK? must it be 80?
# 3 * 3 * 3 * 3 = 10 * 3 * 3 = 30 * 3 = 90 ???
assert_raise(ArgumentError) { BigDecimal.limit(-1) }
@@ -1409,19 +1436,19 @@ class TestBigDecimal < Test::Unit::TestCase
BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false)
BigDecimal.mode(BigDecimal::EXCEPTION_ZERODIVIDE, false)
- assert_equal(BigDecimal::SIGN_POSITIVE_ZERO, BigDecimal.new("0").sign)
- assert_equal(BigDecimal::SIGN_NEGATIVE_ZERO, BigDecimal.new("-0").sign)
- assert_equal(BigDecimal::SIGN_POSITIVE_FINITE, BigDecimal.new("1").sign)
- assert_equal(BigDecimal::SIGN_NEGATIVE_FINITE, BigDecimal.new("-1").sign)
- assert_equal(BigDecimal::SIGN_POSITIVE_INFINITE, (BigDecimal.new("1") / 0).sign)
- assert_equal(BigDecimal::SIGN_NEGATIVE_INFINITE, (BigDecimal.new("-1") / 0).sign)
- assert_equal(BigDecimal::SIGN_NaN, (BigDecimal.new("0") / 0).sign)
+ assert_equal(BigDecimal::SIGN_POSITIVE_ZERO, BigDecimal("0").sign)
+ assert_equal(BigDecimal::SIGN_NEGATIVE_ZERO, BigDecimal("-0").sign)
+ assert_equal(BigDecimal::SIGN_POSITIVE_FINITE, BigDecimal("1").sign)
+ assert_equal(BigDecimal::SIGN_NEGATIVE_FINITE, BigDecimal("-1").sign)
+ assert_equal(BigDecimal::SIGN_POSITIVE_INFINITE, (BigDecimal("1") / 0).sign)
+ assert_equal(BigDecimal::SIGN_NEGATIVE_INFINITE, (BigDecimal("-1") / 0).sign)
+ assert_equal(BigDecimal::SIGN_NaN, (BigDecimal("0") / 0).sign)
end
def test_inf
BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, false)
BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false)
- inf = BigDecimal.new("Infinity")
+ inf = BigDecimal("Infinity")
assert_equal(inf, inf + inf)
assert_nan((inf + (-inf)))
@@ -1448,14 +1475,14 @@ class TestBigDecimal < Test::Unit::TestCase
def test_to_special_string
BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, false)
BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false)
- nan = BigDecimal.new("NaN")
+ nan = BigDecimal("NaN")
assert_equal("NaN", nan.to_s)
- inf = BigDecimal.new("Infinity")
+ inf = BigDecimal("Infinity")
assert_equal("Infinity", inf.to_s)
assert_equal(" Infinity", inf.to_s(" "))
assert_equal("+Infinity", inf.to_s("+"))
assert_equal("-Infinity", (-inf).to_s)
- pzero = BigDecimal.new("0")
+ pzero = BigDecimal("0")
assert_equal("0.0", pzero.to_s)
assert_equal(" 0.0", pzero.to_s(" "))
assert_equal("+0.0", pzero.to_s("+"))
@@ -1471,15 +1498,15 @@ class TestBigDecimal < Test::Unit::TestCase
end
def test_ctov
- assert_equal(0.1, BigDecimal.new("1E-1"))
- assert_equal(10, BigDecimal.new("1E+1"))
- assert_equal(1, BigDecimal.new("+1"))
+ assert_equal(0.1, BigDecimal("1E-1"))
+ assert_equal(10, BigDecimal("1E+1"))
+ assert_equal(1, BigDecimal("+1"))
BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, false)
- assert_equal(BigDecimal::SIGN_POSITIVE_INFINITE, BigDecimal.new("1E1" + "0" * 10000).sign)
- assert_equal(BigDecimal::SIGN_NEGATIVE_INFINITE, BigDecimal.new("-1E1" + "0" * 10000).sign)
- assert_equal(BigDecimal::SIGN_POSITIVE_ZERO, BigDecimal.new("1E-1" + "0" * 10000).sign)
- assert_equal(BigDecimal::SIGN_NEGATIVE_ZERO, BigDecimal.new("-1E-1" + "0" * 10000).sign)
+ assert_equal(BigDecimal::SIGN_POSITIVE_INFINITE, BigDecimal("1E1" + "0" * 10000).sign)
+ assert_equal(BigDecimal::SIGN_NEGATIVE_INFINITE, BigDecimal("-1E1" + "0" * 10000).sign)
+ assert_equal(BigDecimal::SIGN_POSITIVE_ZERO, BigDecimal("1E-1" + "0" * 10000).sign)
+ assert_equal(BigDecimal::SIGN_NEGATIVE_ZERO, BigDecimal("-1E-1" + "0" * 10000).sign)
end
def test_split_under_gc_stress
@@ -1488,7 +1515,7 @@ class TestBigDecimal < Test::Unit::TestCase
assert_in_out_err(%w[-rbigdecimal --disable-gems], <<-EOS, expect, [], bug3258)
GC.stress = true
10.upto(20) do |i|
- p BigDecimal.new("1"+"0"*i).split
+ p BigDecimal("1"+"0"*i).split
end
EOS
end
@@ -1496,7 +1523,7 @@ class TestBigDecimal < Test::Unit::TestCase
def test_coerce_under_gc_stress
assert_in_out_err(%w[-rbigdecimal --disable-gems], <<-EOS, [], [])
expect = ":too_long_to_embed_as_string can't be coerced into BigDecimal"
- b = BigDecimal.new("1")
+ b = BigDecimal("1")
GC.stress = true
10.times do
begin
@@ -1749,21 +1776,37 @@ class TestBigDecimal < Test::Unit::TestCase
EOS
end
+ def test_clone
+ assert_warning(/BigDecimal#clone is deprecated/) do
+ BigDecimal(0).clone
+ end
+ end
+
def test_dup
- [1, -1, 2**100, -2**100].each do |i|
- x = BigDecimal(i)
- assert_equal(x, x.dup)
+ assert_warning(/BigDecimal#dup is deprecated/) do
+ [1, -1, 2**100, -2**100].each do |i|
+ x = BigDecimal(i)
+ assert_equal(x, x.dup)
+ end
end
end
def test_dup_subclass
- c = Class.new(BigDecimal)
- x = c.new(1)
- y = x.dup
- assert_equal(1, y)
- assert_kind_of(c, y)
+ assert_warning(/BigDecimal#dup is deprecated/) do
+ c = Class.new(BigDecimal)
+ x = c.new(1)
+ y = x.dup
+ assert_equal(1, y)
+ assert_kind_of(c, y)
+ end
end
+ def test_to_d
+ bug6093 = '[ruby-core:42969]'
+ code = "exit(BigDecimal('10.0') == 10.0.to_d)"
+ assert_ruby_status(%w[-rbigdecimal -rbigdecimal/util -rmathn -], code, bug6093)
+ end if RUBY_VERSION < '2.5' # mathn was removed from Ruby 2.5
+
def test_bug6406
assert_in_out_err(%w[-rbigdecimal --disable-gems], <<-EOS, [], [])
Thread.current.keys.to_s
@@ -1784,7 +1827,7 @@ class TestBigDecimal < Test::Unit::TestCase
end
def test_no_memory_leak_initialize
- assert_no_memory_leak("BigDecimal.new")
+ assert_no_memory_leak("BigDecimal()")
end
def test_no_memory_leak_global_new
diff --git a/test/bigdecimal/test_bigdecimal_util.rb b/test/bigdecimal/test_bigdecimal_util.rb
index 35adddddef..fd457f6bf5 100644
--- a/test/bigdecimal/test_bigdecimal_util.rb
+++ b/test/bigdecimal/test_bigdecimal_util.rb
@@ -50,11 +50,11 @@ class TestBigDecimalUtil < Test::Unit::TestCase
end
def test_String_to_d
- assert_equal("2.5".to_d, BigDecimal.new('2.5'))
+ assert_equal("2.5".to_d, BigDecimal('2.5'))
end
def test_invalid_String_to_d
- assert_equal("invalid".to_d, BigDecimal.new('0.0'))
+ assert_equal("invalid".to_d, BigDecimal('0.0'))
end
end
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-23 17:08:51 +0000