code review 6202068: encoding/json: Adding json.NumberConverter for cust...

src/pkg/encoding/json/decode_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 json
 
 import (
         "bytes"
-        "errors"
         "fmt"
         "reflect"
         "strings"
         "testing"
 )
 
 type T struct {
         X string
         Y int
         Z int `json:"-"`
 }
 
 type U struct {
         Alphabet string `json:"alpha"`
+}
+
+type V struct {
+        F1 interface{}
+        F2 int32
+        F3 Number
+}
+
+// ifaceNumAsFloat64/ifaceNumAsNumber are used to test unmarshalling with and
+// without UseNumber
+var ifaceNumAsFloat64 = map[string]interface{}{
+        "k1": float64(1),
+        "k2": "s",
+        "k3": []interface{}{float64(1), float64(2.0), float64(3e-3)},
+        "k4": map[string]interface{}{"kk1": "s", "kk2": float64(2)},
+}
+
+var ifaceNumAsNumber = map[string]interface{}{
+        "k1": Number("1"),
+        "k2": "s",
+        "k3": []interface{}{Number("1"), Number("2.0"), Number("3e-3")},
+        "k4": map[string]interface{}{"kk1": "s", "kk2": Number("2")},
 }
 
 type tx struct {
         x int
 }
 
 var txType = reflect.TypeOf((*tx)(nil)).Elem()
 
 // A type that can unmarshal itself.
 
@@ skipping 13 matching lines @@
 var (
         um0, um1 unmarshaler // target2 of unmarshaling
         ump      = &um1
         umtrue   = unmarshaler{true}
         umslice  = []unmarshaler{{true}}
         umslicep = new([]unmarshaler)
         umstruct = ustruct{unmarshaler{true}}
 )
 
 type unmarshalTest struct {
-        in  string
-        ptr interface{}
-        out interface{}
-        err error
+        in        string
+        ptr       interface{}
+        out       interface{}
+        err       error
+        useNumber bool
 }
 
 var unmarshalTests = []unmarshalTest{
         // basic types
-        {`true`, new(bool), true, nil},
-        {`1`, new(int), 1, nil},
-        {`1.2`, new(float64), 1.2, nil},
-        {`-5`, new(int16), int16(-5), nil},
-        {`"a\u1234"`, new(string), "a\u1234", nil},
-        {`"http:\/\/"`, new(string), "http://", nil},
-        {`"g-clef: \uD834\uDD1E"`, new(string), "g-clef: \U0001D11E", nil},
-        {`"invalid: \uD834x\uDD1E"`, new(string), "invalid: \uFFFDx\uFFFD", nil},
-        {"null", new(interface{}), nil, nil},
-        {`{"X": [1,2,3], "Y": 4}`, new(T), T{Y: 4}, &UnmarshalTypeError{"array", reflect.TypeOf("")}},
-        {`{"x": 1}`, new(tx), tx{}, &UnmarshalFieldError{"x", txType, txType.Field(0)}},
+        {in: `true`, ptr: new(bool), out: true},
+        {in: `1`, ptr: new(int), out: 1},
+        {in: `1.2`, ptr: new(float64), out: 1.2},
+        {in: `-5`, ptr: new(int16), out: int16(-5)},
+        {in: `2`, ptr: new(Number), out: Number("2"), useNumber: true},
+        {in: `2`, ptr: new(Number), out: Number("2")},
+        {in: `2`, ptr: new(interface{}), out: float64(2.0)},
+        {in: `2`, ptr: new(interface{}), out: Number("2"), useNumber: true},
+        {in: `"a\u1234"`, ptr: new(string), out: "a\u1234"},
+        {in: `"http:\/\/"`, ptr: new(string), out: "http://"},
+        {in: `"g-clef: \uD834\uDD1E"`, ptr: new(string), out: "g-clef: \U0001D11E"},
+        {in: `"invalid: \uD834x\uDD1E"`, ptr: new(string), out: "invalid: \uFFFDx\uFFFD"},
+        {in: "null", ptr: new(interface{}), out: nil},
+        {in: `{"X": [1,2,3], "Y": 4}`, ptr: new(T), out: T{Y: 4}, err: &UnmarshalTypeError{"array", reflect.TypeOf("")}},
+        {in: `{"x": 1}`, ptr: new(tx), out: tx{}, err: &UnmarshalFieldError{"x", txType, txType.Field(0)}},
+        {in: `{"F1":1,"F2":2,"F3":3}`, ptr: new(V), out: V{F1: float64(1), F2: int32(2), F3: Number("3")}},
+        {in: `{"F1":1,"F2":2,"F3":3}`, ptr: new(V), out: V{F1: Number("1"), F2: int32(2), F3: Number("3")}, useNumber: true},
+        {in: `{"k1":1,"k2":"s","k3":[1,2.0,3e-3],"k4":{"kk1":"s","kk2":2}}`, ptr: new(interface{}), out: ifaceNumAsFloat64},
+        {in: `{"k1":1,"k2":"s","k3":[1,2.0,3e-3],"k4":{"kk1":"s","kk2":2}}`, ptr: new(interface{}), out: ifaceNumAsNumber, useNumber: true},
 
         // Z has a "-" tag.
-        {`{"Y": 1, "Z": 2}`, new(T), T{Y: 1}, nil},
-
-        {`{"alpha": "abc", "alphabet": "xyz"}`, new(U), U{Alphabet: "abc"}, nil},
-        {`{"alpha": "abc"}`, new(U), U{Alphabet: "abc"}, nil},
-        {`{"alphabet": "xyz"}`, new(U), U{}, nil},
+        {in: `{"Y": 1, "Z": 2}`, ptr: new(T), out: T{Y: 1}},
+
+        {in: `{"alpha": "abc", "alphabet": "xyz"}`, ptr: new(U), out: U{Alphabet: "abc"}},
+        {in: `{"alpha": "abc"}`, ptr: new(U), out: U{Alphabet: "abc"}},
+        {in: `{"alphabet": "xyz"}`, ptr: new(U), out: U{}},
 
         // syntax errors
-        {`{"X": "foo", "Y"}`, nil, nil, &SyntaxError{"invalid character '}' after object key", 17}},
-        {`[1, 2, 3+]`, nil, nil, &SyntaxError{"invalid character '+' after array element", 9}},
+        {in: `{"X": "foo", "Y"}`, err: &SyntaxError{"invalid character '}' after object key", 17}},
+        {in: `[1, 2, 3+]`, err: &SyntaxError{"invalid character '+' after array element", 9}},
+        {in: `{"X":12x}`, err: &SyntaxError{"invalid character 'x' after object key:value pair", 8}, useNumber: true},
 
         // array tests
-        {`[1, 2, 3]`, new([3]int), [3]int{1, 2, 3}, nil},
-        {`[1, 2, 3]`, new([1]int), [1]int{1}, nil},
-        {`[1, 2, 3]`, new([5]int), [5]int{1, 2, 3, 0, 0}, nil},
+        {in: `[1, 2, 3]`, ptr: new([3]int), out: [3]int{1, 2, 3}},
+        {in: `[1, 2, 3]`, ptr: new([1]int), out: [1]int{1}},
+        {in: `[1, 2, 3]`, ptr: new([5]int), out: [5]int{1, 2, 3, 0, 0}},
 
         // composite tests
-        {allValueIndent, new(All), allValue, nil},
-        {allValueCompact, new(All), allValue, nil},
-        {allValueIndent, new(*All), &allValue, nil},
-        {allValueCompact, new(*All), &allValue, nil},
-        {pallValueIndent, new(All), pallValue, nil},
-        {pallValueCompact, new(All), pallValue, nil},
-        {pallValueIndent, new(*All), &pallValue, nil},
-        {pallValueCompact, new(*All), &pallValue, nil},
+        {in: allValueIndent, ptr: new(All), out: allValue},
+        {in: allValueCompact, ptr: new(All), out: allValue},
+        {in: allValueIndent, ptr: new(*All), out: &allValue},
+        {in: allValueCompact, ptr: new(*All), out: &allValue},
+        {in: pallValueIndent, ptr: new(All), out: pallValue},
+        {in: pallValueCompact, ptr: new(All), out: pallValue},
+        {in: pallValueIndent, ptr: new(*All), out: &pallValue},
+        {in: pallValueCompact, ptr: new(*All), out: &pallValue},
 
         // unmarshal interface test
-        {`{"T":false}`, &um0, umtrue, nil}, // use "false" so test will fail if custom unmarshaler is not called
-        {`{"T":false}`, &ump, &umtrue, nil},
-        {`[{"T":false}]`, &umslice, umslice, nil},
-        {`[{"T":false}]`, &umslicep, &umslice, nil},
-        {`{"M":{"T":false}}`, &umstruct, umstruct, nil},
+        {in: `{"T":false}`, ptr: &um0, out: umtrue}, // use "false" so test will fail if custom unmarshaler is not called
+        {in: `{"T":false}`, ptr: &ump, out: &umtrue},
+        {in: `[{"T":false}]`, ptr: &umslice, out: umslice},
+        {in: `[{"T":false}]`, ptr: &umslicep, out: &umslice},
+        {in: `{"M":{"T":false}}`, ptr: &umstruct, out: umstruct},
 }
 
 func TestMarshal(t *testing.T) {
         b, err := Marshal(allValue)
         if err != nil {
                 t.Fatalf("Marshal allValue: %v", err)
         }
         if string(b) != allValueCompact {
                 t.Errorf("Marshal allValueCompact")
                 diff(t, b, []byte(allValueCompact))
@@ skipping 15 matching lines @@
         s := "hello\xffworld"
         b, err := Marshal(s)
         if err == nil {
                 t.Fatal("Marshal bad UTF8: no error")
         }
         if len(b) != 0 {
                 t.Fatal("Marshal returned data")
         }
         if _, ok := err.(*InvalidUTF8Error); !ok {
                 t.Fatalf("Marshal did not return InvalidUTF8Error: %T %v", err, err)
+        }
+}
+
+func TestMarshalNumberZeroVal(t *testing.T) {
+        var n Number
+        out, err := Marshal(n)
+        if err != nil {
+                t.Fatal(err)
+        }
+        outStr := string(out)
+        if outStr != "0" {
+                t.Fatalf("Invalid zero val for Number: %q", outStr)
         }
 }
 
 func TestUnmarshal(t *testing.T) {
         for i, tt := range unmarshalTests {
                 var scan scanner
                 in := []byte(tt.in)
                 if err := checkValid(in, &scan); err != nil {
                         if !reflect.DeepEqual(err, tt.err) {
                                 t.Errorf("#%d: checkValid: %#v", i, err)
                                 continue
                         }
                 }
                 if tt.ptr == nil {
                         continue
                 }
                 // v = new(right-type)
                 v := reflect.New(reflect.TypeOf(tt.ptr).Elem())
-                if err := Unmarshal([]byte(in), v.Interface()); !reflect.DeepEqual(err, tt.err) {
+                dec := NewDecoder(bytes.NewBuffer(in))
+                if tt.useNumber {
+                        dec.UseNumber()
+                }
+                if err := dec.Decode(v.Interface()); !reflect.DeepEqual(err, tt.err) {
                         t.Errorf("#%d: %v want %v", i, err, tt.err)
                         continue
                 }
                 if !reflect.DeepEqual(v.Elem().Interface(), tt.out) {
                         t.Errorf("#%d: mismatch\nhave: %#+v\nwant: %#+v", i, v.Elem().Interface(), tt.out)
                         data, _ := Marshal(v.Elem().Interface())
                         println(string(data))
                         data, _ = Marshal(tt.out)
                         println(string(data))
                         continue
                 }
+
+                // Check round trip.
+                if tt.err == nil {
+                        enc, err := Marshal(v.Interface())
+                        if err != nil {
+                                t.Errorf("#%d: error re-marshaling: %v", i, err)
+                                continue
+                        }
+                        vv := reflect.New(reflect.TypeOf(tt.ptr).Elem())
+                        dec = NewDecoder(bytes.NewBuffer(enc))
+                        if tt.useNumber {
+                                dec.UseNumber()
+                        }
+                        if err := dec.Decode(vv.Interface()); err != nil {
+                                t.Errorf("#%d: error re-unmarshaling: %v", i, err)
+                                continue
+                        }
+                        if !reflect.DeepEqual(v.Elem().Interface(), vv.Elem().Interface()) {
+                                t.Errorf("#%d: mismatch\nhave: %#+v\nwant: %#+v", i, v.Elem().Interface(), vv.Elem().Interface())
+                                continue
+                        }
+                }
         }
 }
 
 func TestUnmarshalMarshal(t *testing.T) {
         initBig()
         var v interface{}
         if err := Unmarshal(jsonBig, &v); err != nil {
                 t.Fatalf("Unmarshal: %v", err)
         }
         b, err := Marshal(v)
         if err != nil {
                 t.Fatalf("Marshal: %v", err)
         }
         if bytes.Compare(jsonBig, b) != 0 {
                 t.Errorf("Marshal jsonBig")
                 diff(t, b, jsonBig)
                 return
         }
 }
 
-// A custom numeric type (for testing, just wraps the underlying numeric string)
-type customNum string
-
-// An implementation of NumberConverter which converts the string "1" to its
-// customNum form; any other string is treated as an invalid number
-type numConvImpl struct{}
-
-func (i *numConvImpl) ConvertNumber(s string) (interface{}, error) {
-        if s == "1" {
-                return customNum(s), nil
-        }
-        return nil, errors.New(s)
-}
-
-// test struct to hold an unmarshal, providing sufficient fields for us to test
-// that an interface{} leads to invocation of a NumberConverter handler for
-// simple named fields (F1), that it is not invoked for more strongly typed
-// fields (F2,F4), and that it is invoked deep in map[string]interface{} and in
-// []interface{} (F3)
-type numConvHolder struct {
-        F1 interface{}
-        F2 int32
-        F3 interface{}
-        F4 []int32
-}
-
-// 2 passes: first covers our various success cases; second ensures that errors
-// from a NumberConverter are propagated out and messaged meaningfully·
-func TestUnmarshalWithNumConverter(t *testing.T) {
-        in := `{"F1":1,"F2":2,"F3":{"f1":1,"f2":[1]},"F4":[1,2,3]}`
-        dec := NewDecoder(bytes.NewBufferString(in))
-        dec.SetNumberConverter(&numConvImpl{})
-        act := new(numConvHolder)
-        if err := dec.Decode(act); err == nil {
-                expct := &numConvHolder{F1: customNum("1"), F2: 2, F4: []int32{1, 2, 3}}
-                m := make(map[string]interface{})
-                m["f1"] = customNum("1")
-                m["f2"] = []interface{}{customNum("1")}
-                expct.F3 = m
-                if !reflect.DeepEqual(expct, act) {
-                        t.Fatalf("%#v != %#v", act, expct)
-                }
-        } else {
-                t.Fatal(err)
-        }
-        // now check that error from a NumberConverter causes decode to fail in the
-        // same way as an error from strconv.ParseFloat() would, either as a
-        // top-level field or in some generic composite type:
-        errTxts := []string{`{"F1":2}`, `{"F3":[2]}`, `{"F3":{"i":2}}`}
-        for _, errTxt := range errTxts {
-                dec = NewDecoder(bytes.NewBufferString(errTxt))
-                dec.SetNumberConverter(&numConvImpl{})
-                act = new(numConvHolder)
-                if err := dec.Decode(act); err == nil {
-                        t.Fatalf("no decode error")
-                } else {
-                        if err.Error() != "json: cannot unmarshal number 2 into Go value of type *json.numConvImpl" {
-                                t.Fatal(err)
-                        }
+var numberTests = []struct {
+        in       string
+        i        int64
+        intErr   string
+        f        float64
+        floatErr string
+}{
+        {in: "-1.23e1", intErr: "strconv.ParseInt: parsing \"-1.23e1\": invalid syntax", f: -1.23e1},
+        {in: "-12", i: -12, f: -12.0},
+        {in: "1e1000", intErr: "strconv.ParseInt: parsing \"1e1000\": invalid syntax", floatErr: "strconv.ParseFloat: parsing \"1e1000\": value out of range"},
+}
+
+// Independent of Decode, basic coverage of the accessors in Number
+func TestNumberAccessors(t *testing.T) {
+        for _, tt := range numberTests {
+                n := Number(tt.in)
+                if s := n.String(); s != tt.in {
+                        t.Errorf("Number(%q).String() is %q", tt.in, s)
+                }
+                if i, err := n.Int64(); err == nil && tt.intErr == "" && i != tt.i {
+                        t.Errorf("Number(%q).Int64() is %d", tt.in, i)
+                } else if (err == nil && tt.intErr != "") || (err != nil && err.Error() != tt.intErr) {
+                        t.Errorf("Number(%q).Int64() wanted error %q but got: %v", tt.in, tt.intErr, err)
+                }
+                if f, err := n.Float64(); err == nil && tt.floatErr == "" && f != tt.f {
+                        t.Errorf("Number(%q).Float64() is %g", tt.in, f)
+                } else if (err == nil && tt.floatErr != "") || (err != nil && err.Error() != tt.floatErr) {
+                        t.Errorf("Number(%q).Float64() wanted error %q but got: %v", tt.in, tt.floatErr, err)
                 }
         }
 }
 
 func TestLargeByteSlice(t *testing.T) {
         s0 := make([]byte, 2000)
         for i := range s0 {
                 s0[i] = byte(i)
         }
         b, err := Marshal(s0)
@@ skipping 459 matching lines @@
         dec := NewDecoder(strings.NewReader(data))
         var t2 T2
         err := dec.Decode(&t2)
         if err == nil {
                 t.Fatal("Decode: did not return error")
         }
         if t2.Number1 != 1 {
                 t.Fatal("Decode: did not set Number1")
         }
 }
+
+func intp(x int) *int {
+        p := new(int)
+        *p = x
+        return p
+}
+
+func intpp(x *int) **int {
+        pp := new(*int)
+        *pp = x
+        return pp
+}
+
+var interfaceSetTests = []struct {
+        pre  interface{}
+        json string
+        post interface{}
+}{
+        {"foo", `"bar"`, "bar"},
+        {"foo", `2`, 2.0},
+        {"foo", `true`, true},
+        {"foo", `null`, nil},
+
+        {nil, `null`, nil},
+        {new(int), `null`, nil},
+        {(*int)(nil), `null`, nil},
+        {new(*int), `null`, new(*int)},
+        {(**int)(nil), `null`, nil},
+        {intp(1), `null`, nil},
+        {intpp(nil), `null`, intpp(nil)},
+        {intpp(intp(1)), `null`, intpp(nil)},
+}
+
+func TestInterfaceSet(t *testing.T) {
+        for _, tt := range interfaceSetTests {
+                b := struct{ X interface{} }{tt.pre}
+                blob := `{"X":` + tt.json + `}`
+                if err := Unmarshal([]byte(blob), &b); err != nil {
+                        t.Errorf("Unmarshal %#q: %v", blob, err)
+                        continue
+                }
+                if !reflect.DeepEqual(b.X, tt.post) {
+                        t.Errorf("Unmarshal %#q into %#v: X=%#v, want %#v", blob, tt.pre, b.X, tt.post)
+                }
+        }
+}