bigdecimal: version 1.3.3

Import bigdecimal version 1.3.3.  The full commit log is here:

  https://github.com/ruby/bigdecimal/compare/v1.3.2...v1.3.3

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@61213 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

8 files changed, 398 insertions, 291 deletions

diff --git a/ext/bigdecimal/bigdecimal.c b/ext/bigdecimal/bigdecimal.c
index e9e6af7784..fcc29a0865 100644
--- a/ext/bigdecimal/bigdecimal.c
+++ b/ext/bigdecimal/bigdecimal.c
@@ -141,12 +141,16 @@ rb_rational_den(VALUE rat)
 static VALUE
 BigDecimal_version(VALUE self)
 {
-    /*
-     * 1.0.0: Ruby 1.8.0
-     * 1.0.1: Ruby 1.8.1
-     * 1.1.0: Ruby 1.9.3
-    */
-    return rb_str_new2("1.1.0");
+  /*
+   * 1.0.0: Ruby 1.8.0
+   * 1.0.1: Ruby 1.8.1
+   * 1.1.0: Ruby 1.9.3
+   */
+#ifndef RUBY_BIGDECIMAL_VERSION
+# error RUBY_BIGDECIMAL_VERSION is not defined
+#endif
+  rb_warning("BigDecimal.ver is deprecated; use BigDecimal::VERSION instead.");
+  return rb_str_new2(RUBY_BIGDECIMAL_VERSION);
 }
 
 /*
@@ -393,7 +397,7 @@ BigDecimal_hash(VALUE self)
  *
  * Method used to provide marshalling support.
  *
- *      inf = BigDecimal.new('Infinity')
+ *      inf = BigDecimal('Infinity')
  *        #=> Infinity
  *      BigDecimal._load(inf._dump)
  *        #=> Infinity
@@ -646,12 +650,12 @@ GetAddSubPrec(Real *a, Real *b)
 }
 
 static SIGNED_VALUE
-GetPositiveInt(VALUE v)
+GetPrecisionInt(VALUE v)
 {
     SIGNED_VALUE n;
     n = NUM2INT(v);
     if (n < 0) {
-	rb_raise(rb_eArgError, "argument must be positive");
+	rb_raise(rb_eArgError, "negative precision");
     }
     return n;
 }
@@ -876,7 +880,7 @@ BigDecimal_to_r(VALUE self)
  * be coerced into a BigDecimal value.
  *
  * e.g.
- *   a = BigDecimal.new("1.0")
+ *   a = BigDecimal("1.0")
  *   b = a / 2.0 #=> 0.5
  *
  * Note that coercing a String to a BigDecimal is not supported by default;
@@ -1165,7 +1169,7 @@ BigDecimal_comp(VALUE self, VALUE r)
  *
  * Values may be coerced to perform the comparison:
  *
- *   BigDecimal.new('1.0') == 1.0  #=> true
+ *   BigDecimal('1.0') == 1.0  #=> true
  */
 static VALUE
 BigDecimal_eq(VALUE self, VALUE r)
@@ -1527,8 +1531,8 @@ BigDecimal_remainder(VALUE self, VALUE r) /* remainder */
  *
  *   require 'bigdecimal'
  *
- *   a = BigDecimal.new("42")
- *   b = BigDecimal.new("9")
+ *   a = BigDecimal("42")
+ *   b = BigDecimal("9")
  *
  *   q, m = a.divmod(b)
  *
@@ -1571,7 +1575,7 @@ BigDecimal_div2(VALUE self, VALUE b, VALUE n)
     }
 
     /* div in BigDecimal sense */
-    ix = GetPositiveInt(n);
+    ix = GetPrecisionInt(n);
     if (ix == 0) {
         return BigDecimal_div(self, b);
     }
@@ -1640,7 +1644,7 @@ BigDecimal_add2(VALUE self, VALUE b, VALUE n)
 {
     ENTER(2);
     Real *cv;
-    SIGNED_VALUE mx = GetPositiveInt(n);
+    SIGNED_VALUE mx = GetPrecisionInt(n);
     if (mx == 0) return BigDecimal_add(self, b);
     else {
 	size_t pl = VpSetPrecLimit(0);
@@ -1670,7 +1674,7 @@ BigDecimal_sub2(VALUE self, VALUE b, VALUE n)
 {
     ENTER(2);
     Real *cv;
-    SIGNED_VALUE mx = GetPositiveInt(n);
+    SIGNED_VALUE mx = GetPrecisionInt(n);
     if (mx == 0) return BigDecimal_sub(self, b);
     else {
 	size_t pl = VpSetPrecLimit(0);
@@ -1688,7 +1692,7 @@ BigDecimal_mult2(VALUE self, VALUE b, VALUE n)
 {
     ENTER(2);
     Real *cv;
-    SIGNED_VALUE mx = GetPositiveInt(n);
+    SIGNED_VALUE mx = GetPrecisionInt(n);
     if (mx == 0) return BigDecimal_mult(self, b);
     else {
 	size_t pl = VpSetPrecLimit(0);
@@ -1742,7 +1746,7 @@ BigDecimal_sqrt(VALUE self, VALUE nFig)
     GUARD_OBJ(a, GetVpValue(self, 1));
     mx = a->Prec * (VpBaseFig() + 1);
 
-    n = GetPositiveInt(nFig) + VpDblFig() + BASE_FIG;
+    n = GetPrecisionInt(nFig) + VpDblFig() + BASE_FIG;
     if (mx <= n) mx = n;
     GUARD_OBJ(c, VpCreateRbObject(mx, "0"));
     VpSqrt(c, a);
@@ -2012,26 +2016,27 @@ BigDecimal_ceil(int argc, VALUE *argv, VALUE self)
  *
  * Examples:
  *
- *   BigDecimal.new('-123.45678901234567890').to_s('5F')
+ *   BigDecimal('-123.45678901234567890').to_s('5F')
  *     #=> '-123.45678 90123 45678 9'
  *
- *   BigDecimal.new('123.45678901234567890').to_s('+8F')
+ *   BigDecimal('123.45678901234567890').to_s('+8F')
  *     #=> '+123.45678901 23456789'
  *
- *   BigDecimal.new('123.45678901234567890').to_s(' F')
+ *   BigDecimal('123.45678901234567890').to_s(' F')
  *     #=> ' 123.4567890123456789'
  */
 static VALUE
 BigDecimal_to_s(int argc, VALUE *argv, VALUE self)
 {
     ENTER(5);
-    int   fmt = 0;   /* 0:E format */
-    int   fPlus = 0; /* =0:default,=1: set ' ' before digits ,set '+' before digits. */
+    int   fmt = 0;   /* 0: E format, 1: F format */
+    int   fPlus = 0; /* 0: default, 1: set ' ' before digits, 2: set '+' before digits. */
     Real  *vp;
     volatile VALUE str;
     char  *psz;
     char   ch;
     size_t nc, mc = 0;
+    SIGNED_VALUE m;
     VALUE  f;
 
     GUARD_OBJ(vp, GetVpValue(self, 1));
@@ -2062,7 +2067,11 @@ BigDecimal_to_s(int argc, VALUE *argv, VALUE self)
 	    }
 	}
 	else {
-	    mc = (size_t)GetPositiveInt(f);
+	    m = NUM2INT(f);
+	    if (m <= 0) {
+		rb_raise(rb_eArgError, "argument must be positive");
+	    }
+	    mc = (size_t)m;
 	}
     }
     if (fmt) {
@@ -2159,7 +2168,7 @@ BigDecimal_exponent(VALUE self)
 /* Returns debugging information about the value as a string of comma-separated
  * values in angle brackets with a leading #:
  *
- *   BigDecimal.new("1234.5678").inspect
+ *   BigDecimal("1234.5678").inspect
  *     #=> "0.12345678e4"
  *
  * The first part is the address, the second is the value as a string, and
@@ -2591,6 +2600,13 @@ static Real *BigDecimal_new(int argc, VALUE *argv);
  *                 value is omitted, this exception is raised.
  */
 static VALUE
+BigDecimal_s_new(int argc, VALUE *argv, VALUE self)
+{
+  rb_warning("BigDecimal.new is deprecated");
+  return rb_call_super(argc, argv);
+}
+
+static VALUE
 BigDecimal_initialize(int argc, VALUE *argv, VALUE self)
 {
     ENTER(1);
@@ -2626,6 +2642,20 @@ BigDecimal_initialize_copy(VALUE self, VALUE other)
     return self;
 }
 
+static VALUE
+BigDecimal_clone(VALUE self)
+{
+  rb_warning("BigDecimal#clone is deprecated.");
+  return rb_call_super(0, NULL);
+}
+
+static VALUE
+BigDecimal_dup(VALUE self)
+{
+  rb_warning("BigDecimal#dup is deprecated.");
+  return rb_call_super(0, NULL);
+}
+
 static Real *
 BigDecimal_new(int argc, VALUE *argv)
 {
@@ -2638,7 +2668,7 @@ BigDecimal_new(int argc, VALUE *argv)
         mf = 0;
     }
     else {
-        mf = GetPositiveInt(nFig);
+        mf = GetPrecisionInt(nFig);
     }
 
     switch (TYPE(iniValue)) {
@@ -2758,9 +2788,9 @@ BigDecimal_sign(VALUE self)
  *       BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, false)
  *       BigDecimal.mode(BigDecimal::EXCEPTION_NaN, false)
  *
- *       BigDecimal.new(BigDecimal('Infinity'))
- *       BigDecimal.new(BigDecimal('-Infinity'))
- *       BigDecimal(BigDecimal.new('NaN'))
+ *       BigDecimal(BigDecimal('Infinity'))
+ *       BigDecimal(BigDecimal('-Infinity'))
+ *       BigDecimal(BigDecimal('NaN'))
  *     end
  *
  * For use with the BigDecimal::EXCEPTION_*
@@ -3147,15 +3177,15 @@ get_vp_value:
  *
  *   require 'bigdecimal'
  *
- *   sum = BigDecimal.new("0")
+ *   sum = BigDecimal("0")
  *   10_000.times do
- *     sum = sum + BigDecimal.new("0.0001")
+ *     sum = sum + BigDecimal("0.0001")
  *   end
  *   print sum #=> 0.1E1
  *
  * Similarly:
  *
- *	(BigDecimal.new("1.2") - BigDecimal("1.0")) == BigDecimal("0.2") #=> true
+ *	(BigDecimal("1.2") - BigDecimal("1.0")) == BigDecimal("0.2") #=> true
  *
  *	(1.2 - 1.0) == 0.2 #=> false
  *
@@ -3169,8 +3199,8 @@ get_vp_value:
  * BigDecimal sometimes needs to return infinity, for example if you divide
  * a value by zero.
  *
- *	BigDecimal.new("1.0") / BigDecimal.new("0.0")  #=> Infinity
- *	BigDecimal.new("-1.0") / BigDecimal.new("0.0")  #=> -Infinity
+ *	BigDecimal("1.0") / BigDecimal("0.0")  #=> Infinity
+ *	BigDecimal("-1.0") / BigDecimal("0.0")  #=> -Infinity
  *
  * You can represent infinite numbers to BigDecimal using the strings
  * <code>'Infinity'</code>, <code>'+Infinity'</code> and
@@ -3183,13 +3213,13 @@ get_vp_value:
  *
  * Example:
  *
- *	BigDecimal.new("0.0") / BigDecimal.new("0.0") #=> NaN
+ *	BigDecimal("0.0") / BigDecimal("0.0") #=> NaN
  *
  * You can also create undefined values.
  *
  * NaN is never considered to be the same as any other value, even NaN itself:
  *
- *	n = BigDecimal.new('NaN')
+ *	n = BigDecimal('NaN')
  *	n == 0.0 #=> false
  *	n == n #=> false
  *
@@ -3202,11 +3232,11 @@ get_vp_value:
  * If the value which is too small to be represented is negative, a BigDecimal
  * value of negative zero is returned.
  *
- *	BigDecimal.new("1.0") / BigDecimal.new("-Infinity") #=> -0.0
+ *	BigDecimal("1.0") / BigDecimal("-Infinity") #=> -0.0
  *
  * If the value is positive, a value of positive zero is returned.
  *
- *	BigDecimal.new("1.0") / BigDecimal.new("Infinity") #=> 0.0
+ *	BigDecimal("1.0") / BigDecimal("Infinity") #=> 0.0
  *
  * (See BigDecimal.mode for how to specify limits of precision.)
  *
@@ -3261,6 +3291,7 @@ Init_bigdecimal(void)
     rb_define_global_function("BigDecimal", BigDecimal_global_new, -1);
 
     /* Class methods */
+    rb_define_singleton_method(rb_cBigDecimal, "new", BigDecimal_s_new, -1);
     rb_define_singleton_method(rb_cBigDecimal, "mode", BigDecimal_mode, -1);
     rb_define_singleton_method(rb_cBigDecimal, "limit", BigDecimal_limit, -1);
     rb_define_singleton_method(rb_cBigDecimal, "double_fig", BigDecimal_double_fig, 0);
@@ -3273,6 +3304,14 @@ Init_bigdecimal(void)
 
     /* Constants definition */
 
+#ifndef RUBY_BIGDECIMAL_VERSION
+# error RUBY_BIGDECIMAL_VERSION is not defined
+#endif
+    /*
+     * The version of bigdecimal library
+     */
+    rb_define_const(rb_cBigDecimal, "VERSION", rb_str_new2(RUBY_BIGDECIMAL_VERSION));
+
     /*
      * Base value used in internal calculations.  On a 32 bit system, BASE
      * is 10000, indicating that calculation is done in groups of 4 digits.
@@ -3409,7 +3448,8 @@ Init_bigdecimal(void)
     rb_define_method(rb_cBigDecimal, "modulo", BigDecimal_mod, 1);
     rb_define_method(rb_cBigDecimal, "remainder", BigDecimal_remainder, 1);
     rb_define_method(rb_cBigDecimal, "divmod", BigDecimal_divmod, 1);
-    /* rb_define_method(rb_cBigDecimal, "dup", BigDecimal_dup, 0); */
+    rb_define_method(rb_cBigDecimal, "clone", BigDecimal_clone, 0);
+    rb_define_method(rb_cBigDecimal, "dup", BigDecimal_dup, 0);
     rb_define_method(rb_cBigDecimal, "to_f", BigDecimal_to_f, 0);
     rb_define_method(rb_cBigDecimal, "abs", BigDecimal_abs, 0);
     rb_define_method(rb_cBigDecimal, "sqrt", BigDecimal_sqrt, 1);
@@ -5348,7 +5388,7 @@ VpSzMantissa(Real *a,char *psz)
 
 VP_EXPORT int
 VpToSpecialString(Real *a,char *psz,int fPlus)
-    /* fPlus =0:default, =1: set ' ' before digits , =2: set '+' before digits. */
+/* fPlus = 0: default, 1: set ' ' before digits, 2: set '+' before digits. */
 {
     if (VpIsNaN(a)) {
 	sprintf(psz,SZ_NaN);
@@ -5383,7 +5423,7 @@ VpToSpecialString(Real *a,char *psz,int fPlus)
 
 VP_EXPORT void
 VpToString(Real *a, char *psz, size_t fFmt, int fPlus)
-/* fPlus =0:default, =1: set ' ' before digits , =2:set '+' before digits. */
+/* fPlus = 0: default, 1: set ' ' before digits, 2: set '+' before digits. */
 {
     size_t i, n, ZeroSup;
     BDIGIT shift, m, e, nn;
@@ -5431,7 +5471,7 @@ VpToString(Real *a, char *psz, size_t fFmt, int fPlus)
 
 VP_EXPORT void
 VpToFString(Real *a, char *psz, size_t fFmt, int fPlus)
-/* fPlus =0:default,=1: set ' ' before digits ,set '+' before digits. */
+/* fPlus = 0: default, 1: set ' ' before digits, 2: set '+' before digits. */
 {
     size_t i, n;
     BDIGIT m, e, nn;
diff --git a/ext/bigdecimal/bigdecimal.gemspec b/ext/bigdecimal/bigdecimal.gemspec
index 4efe438fbd..c1f7da493b 100644
--- a/ext/bigdecimal/bigdecimal.gemspec
+++ b/ext/bigdecimal/bigdecimal.gemspec
@@ -1,9 +1,10 @@
 # coding: utf-8
-_VERSION = '1.3.2'
+
+bigdecimal_version = '1.3.3'
 
 Gem::Specification.new do |s|
   s.name          = "bigdecimal"
-  s.version       = _VERSION
+  s.version       = bigdecimal_version
   s.authors       = ["Kenta Murata", "Zachary Scott", "Shigeo Kobayashi"]
   s.email         = ["mrkn@mrkn.jp"]
 
@@ -31,7 +32,8 @@ Gem::Specification.new do |s|
   ]
 
   s.add_development_dependency "rake", "~> 10.0"
-  s.add_development_dependency "rake-compiler", "~> 0.9"
+  s.add_development_dependency "rake-compiler", ">= 0.9"
+  s.add_development_dependency "rake-compiler-dock", ">= 0.6.1"
   s.add_development_dependency "minitest", "~> 4.7.5"
   s.add_development_dependency "pry"
 end
diff --git a/ext/bigdecimal/bigdecimal.h b/ext/bigdecimal/bigdecimal.h
index 6182ae2374..e53a752aa5 100644
--- a/ext/bigdecimal/bigdecimal.h
+++ b/ext/bigdecimal/bigdecimal.h
@@ -142,6 +142,12 @@ rb_sym2str(VALUE sym)
 }
 #endif
 
+#ifndef ST2FIX
+# undef RB_ST2FIX
+# define RB_ST2FIX(h) LONG2FIX((long)(h))
+# define ST2FIX(h) RB_ST2FIX(h)
+#endif
+
 #ifdef vabs
 # undef vabs
 #endif
diff --git a/ext/bigdecimal/extconf.rb b/ext/bigdecimal/extconf.rb
index dccf2d2d83..4bef91eafe 100644
--- a/ext/bigdecimal/extconf.rb
+++ b/ext/bigdecimal/extconf.rb
@@ -1,6 +1,22 @@
 # frozen_string_literal: false
 require 'mkmf'
 
+case
+when File.file?(File.expand_path('../bigdecimal.gemspec', __FILE__))
+  gemspec_path = File.expand_path('../bigdecimal.gemspec', __FILE__)
+when File.file?(File.expand_path('../../../bigdecimal.gemspec', __FILE__))
+  gemspec_path = File.expand_path('../../../bigdecimal.gemspec', __FILE__)
+else
+  $stderr.puts "Unable to find bigdecimal.gemspec"
+  abort
+end
+
+bigdecimal_version =
+  IO.readlines(gemspec_path)
+    .grep(/\Abigdecimal_version\s+=\s+/)[0][/\'([\d\.]+)\'/, 1]
+
+$defs << %Q[-DRUBY_BIGDECIMAL_VERSION=\\"#{bigdecimal_version}\\"]
+
 alias __have_macro__ have_macro
 
 have_func("labs", "stdlib.h")
diff --git a/ext/bigdecimal/lib/bigdecimal/math.rb b/ext/bigdecimal/lib/bigdecimal/math.rb
index ef1a02b38f..0b9d0648bb 100644
--- a/ext/bigdecimal/lib/bigdecimal/math.rb
+++ b/ext/bigdecimal/lib/bigdecimal/math.rb
@@ -37,7 +37,7 @@ module BigMath
   # Computes the square root of +decimal+ to the specified number of digits of
   # precision, +numeric+.
   #
-  #   BigMath.sqrt(BigDecimal.new('2'), 16).to_s
+  #   BigMath.sqrt(BigDecimal('2'), 16).to_s
   #   #=> "0.1414213562373095048801688724e1"
   #
   def sqrt(x, prec)
@@ -140,7 +140,7 @@ module BigMath
   #
   # If +decimal+ is NaN, returns NaN.
   #
-  #   BigMath.atan(BigDecimal.new('-1'), 16).to_s
+  #   BigMath.atan(BigDecimal('-1'), 16).to_s
   #   #=> "-0.785398163397448309615660845819878471907514682065e0"
   #
   def atan(x, prec)
diff --git a/ext/bigdecimal/lib/bigdecimal/util.rb b/ext/bigdecimal/lib/bigdecimal/util.rb
index d32eaf561a..911fa6fe3a 100644
--- a/ext/bigdecimal/lib/bigdecimal/util.rb
+++ b/ext/bigdecimal/lib/bigdecimal/util.rb
@@ -83,7 +83,7 @@ class BigDecimal < Numeric
   #
   #     require 'bigdecimal/util'
   #
-  #     d = BigDecimal.new("3.14")
+  #     d = BigDecimal("3.14")
   #     d.to_digits                  # => "3.14"
   #
   def to_digits
@@ -103,7 +103,7 @@ class BigDecimal < Numeric
   #
   #     require 'bigdecimal/util'
   #
-  #     d = BigDecimal.new("3.14")
+  #     d = BigDecimal("3.14")
   #     d.to_d                       # => 0.314e1
   #
   def to_d
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