Fix dump/load bigdecimal with few or large precs (#362)

Dumped string should include Prec instead of MaxPrec.
Don't trust MaxPrec of the dumped string.

Author: tompng

ext/bigdecimal/bigdecimal.c

@@ -844,7 +844,7 @@ BigDecimal_dump(int argc, VALUE *argv, VALUE self)
     GUARD_OBJ(v, GetBDValueMust(self));
     dump = rb_str_new(0, VpNumOfChars(v.real, "E")+50);
     psz = RSTRING_PTR(dump);
-    snprintf(psz, RSTRING_LEN(dump), "%"PRIuSIZE":", VpMaxPrec(v.real)*VpBaseFig());
+    snprintf(psz, RSTRING_LEN(dump), "%"PRIuSIZE":", VpPrec(v.real)*VpBaseFig());
     len = strlen(psz);
     VpToString(v.real, psz+len, RSTRING_LEN(dump)-len, 0, 0);
     rb_str_resize(dump, strlen(psz));
@@ -861,22 +861,15 @@ BigDecimal_load(VALUE self, VALUE str)
     BDVALUE v;
     unsigned char *pch;
     unsigned char ch;
-    unsigned long m=0;
 
     pch = (unsigned char *)StringValueCStr(str);
-    /* First get max prec */
+    /* First skip max prec. Don't trust the value. */
     while((*pch) != (unsigned char)'\0' && (ch = *pch++) != (unsigned char)':') {
         if(!ISDIGIT(ch)) {
             rb_raise(rb_eTypeError, "load failed: invalid character in the marshaled string");
         }
-        m = m*10 + (unsigned long)(ch-'0');
-    }
-    if (m > VpBaseFig()) m -= VpBaseFig();
-    GUARD_OBJ(v, bdvalue_nonnullable(CreateFromString(m, (char *)pch, self, true, true)));
-    m /= VpBaseFig();
-    if (m && v.real->MaxPrec > m) {
-        v.real->MaxPrec = m+1;
     }
+    GUARD_OBJ(v, bdvalue_nonnullable(CreateFromString(0, (char *)pch, self, true, true)));
     return CheckGetValue(v);
 }
 

test/bigdecimal/test_bigdecimal.rb

@@ -760,6 +760,31 @@ def test_marshal
     assert_raise(TypeError) { Marshal.load(s) }
   end
 
+  def test_dump_extra_high_maxprec
+    m = BigDecimal(2 ** 1000)
+    n = BigDecimal(2) ** 1000
+    # Even if two bigdecimals have different MaxPrec,
+    # _dump should return same string if they represent the same value.
+    assert_equal(m._dump, n._dump)
+  end
+
+  def test_load_invalid_precision
+    $VERBOSE, verbose = nil, $VERBOSE
+    dumped = BigDecimal('1' * 1000)._dump
+    n = BigDecimal._load(dumped)
+    digits_part = dumped.split(':').last
+    too_few_precs = BigDecimal._load('100:' + digits_part)
+    assert_equal(1000, too_few_precs.precision)
+    assert_equal(n, too_few_precs)
+    assert_equal(n.precs, too_few_precs.precs)
+    too_large_precs = BigDecimal._load('999999999999:' + digits_part)
+    assert_equal(1000, too_large_precs.precision)
+    assert_equal(n, too_large_precs)
+    assert_equal(n.precs, too_large_precs.precs)
+  ensure
+    $VERBOSE = verbose
+  end
+
   def test_finite_infinite_nan
     BigDecimal.mode(BigDecimal::EXCEPTION_OVERFLOW, false)
     BigDecimal.mode(BigDecimal::EXCEPTION_ZERODIVIDE, false)