code review 6211079: math/big: implement JSON un/marshaling support for Ints

src/pkg/math/big/rat_test.go

 // Copyright 2010 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package big
 
 import (
         "bytes"
         "encoding/gob"
         "fmt"
@@ skipping 369 matching lines @@
                 if x.RatString() != test.out {
                         t.Errorf("#%d got %s want %s", i, x.RatString(), test.out)
                 }
         }
 }
 
 func TestRatGobEncoding(t *testing.T) {
         var medium bytes.Buffer
         enc := gob.NewEncoder(&medium)
         dec := gob.NewDecoder(&medium)
-        for i, test := range encodingTests {
-                for j := 0; j < 4; j++ {
-                        medium.Reset() // empty buffer for each test case (in case of failures)
-                        stest := test
-                        if j&1 != 0 {
-                                // negative numbers
-                                stest = "-" + test
-                        }
-                        if j%2 != 0 {
-                                // fractions
-                                stest = stest + "." + test
-                        }
-                        var tx Rat
-                        tx.SetString(stest)
-                        if err := enc.Encode(&tx); err != nil {
-                                t.Errorf("#%d%c: encoding failed: %s", i, 'a'+j, err)
-                        }
-                        var rx Rat
-                        if err := dec.Decode(&rx); err != nil {
-                                t.Errorf("#%d%c: decoding failed: %s", i, 'a'+j, err)
-                        }
-                        if rx.Cmp(&tx) != 0 {
-                                t.Errorf("#%d%c: transmission failed: got %s want %s", i, 'a'+j, &rx, &tx)
-                        }
+        for _, test := range encodingTests {
+                medium.Reset() // empty buffer for each test case (in case of failures)
+                var tx Rat
+                tx.SetString(test + ".14159265")
+                if err := enc.Encode(&tx); err != nil {
+                        t.Errorf("encoding of %s failed: %s", &tx, err)
+                }
+                var rx Rat
+                if err := dec.Decode(&rx); err != nil {
+                        t.Errorf("decoding of %s failed: %s", &tx, err)
+                }
+                if rx.Cmp(&tx) != 0 {
+                        t.Errorf("transmission of %s failed: got %s want %s", &tx, &rx, &tx)
                 }
         }
 }
 
 func TestIssue2379(t *testing.T) {
         // 1) no aliasing
         q := NewRat(3, 2)
         x := new(Rat)
         x.SetFrac(NewInt(3), NewInt(2))
         if x.Cmp(q) != 0 {
@@ skipping 23 matching lines @@
 
         // 5) numerator and denominator are the same
         q = NewRat(1, 1)
         x = new(Rat)
         n := NewInt(7)
         x.SetFrac(n, n)
         if x.Cmp(q) != 0 {
                 t.Errorf("5) got %s want %s", x, q)
         }
 }