| // 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" |
| "os" |
| "reflect" |
| "strings" |
| "testing" |
| ) |
| |
| type T struct { |
| X string |
| Y int |
| } |
| |
| type tx struct { |
| x int |
| } |
| |
| var txType = reflect.TypeOf((*tx)(nil)).Elem() |
| |
| // A type that can unmarshal itself. |
| |
| type unmarshaler struct { |
| T bool |
| } |
| |
| func (u *unmarshaler) UnmarshalJSON(b []byte) os.Error { |
| *u = unmarshaler{true} // All we need to see that UnmarshalJson is called. |
| return nil |
| } |
| |
| var ( |
| um0, um1 unmarshaler // target2 of unmarshaling |
| ump = &um1 |
| umtrue = unmarshaler{true} |
| ) |
| |
| type badTag struct { |
| X string |
| Y string "y" |
| Z string "@#*%(#@" |
| } |
| |
| type unmarshalTest struct { |
| in string |
| ptr interface{} |
| out interface{} |
| err os.Error |
| } |
| |
| 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)}}, |
| |
| // skip invalid tags |
| {`{"X":"a", "y":"b", "Z":"c"}`, new(badTag), badTag{"a", "b", "c"}, nil}, |
| |
| // syntax errors |
| {`{"X": "foo", "Y"}`, nil, nil, &SyntaxError{"invalid character '}' after object key", 17}}, |
| |
| // 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}, |
| |
| // 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}, |
| } |
| |
| 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)) |
| return |
| } |
| |
| b, err = Marshal(pallValue) |
| if err != nil { |
| t.Fatalf("Marshal pallValue: %v", err) |
| } |
| if string(b) != pallValueCompact { |
| t.Errorf("Marshal pallValueCompact") |
| diff(t, b, []byte(pallValueCompact)) |
| return |
| } |
| } |
| |
| func TestMarshalBadUTF8(t *testing.T) { |
| 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 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) { |
| 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)) |
| return |
| 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 |
| } |
| } |
| |
| func TestLargeByteSlice(t *testing.T) { |
| s0 := make([]byte, 2000) |
| for i := range s0 { |
| s0[i] = byte(i) |
| } |
| b, err := Marshal(s0) |
| if err != nil { |
| t.Fatalf("Marshal: %v", err) |
| } |
| var s1 []byte |
| if err := Unmarshal(b, &s1); err != nil { |
| t.Fatalf("Unmarshal: %v", err) |
| } |
| if bytes.Compare(s0, s1) != 0 { |
| t.Errorf("Marshal large byte slice") |
| diff(t, s0, s1) |
| } |
| } |
| |
| type Xint struct { |
| X int |
| } |
| |
| func TestUnmarshalInterface(t *testing.T) { |
| var xint Xint |
| var i interface{} = &xint |
| if err := Unmarshal([]byte(`{"X":1}`), &i); err != nil { |
| t.Fatalf("Unmarshal: %v", err) |
| } |
| if xint.X != 1 { |
| t.Fatalf("Did not write to xint") |
| } |
| } |
| |
| func TestUnmarshalPtrPtr(t *testing.T) { |
| var xint Xint |
| pxint := &xint |
| if err := Unmarshal([]byte(`{"X":1}`), &pxint); err != nil { |
| t.Fatalf("Unmarshal: %v", err) |
| } |
| if xint.X != 1 { |
| t.Fatalf("Did not write to xint") |
| } |
| } |
| |
| func TestHTMLEscape(t *testing.T) { |
| b, err := MarshalForHTML("foobarbaz<>&quux") |
| if err != nil { |
| t.Fatalf("MarshalForHTML error: %v", err) |
| } |
| if !bytes.Equal(b, []byte(`"foobarbaz\u003c\u003e\u0026quux"`)) { |
| t.Fatalf("Unexpected encoding of \"<>&\": %s", b) |
| } |
| } |
| |
| func noSpace(c int) int { |
| if isSpace(c) { |
| return -1 |
| } |
| return c |
| } |
| |
| type All struct { |
| Bool bool |
| Int int |
| Int8 int8 |
| Int16 int16 |
| Int32 int32 |
| Int64 int64 |
| Uint uint |
| Uint8 uint8 |
| Uint16 uint16 |
| Uint32 uint32 |
| Uint64 uint64 |
| Uintptr uintptr |
| Float32 float32 |
| Float64 float64 |
| |
| Foo string "bar" |
| |
| PBool *bool |
| PInt *int |
| PInt8 *int8 |
| PInt16 *int16 |
| PInt32 *int32 |
| PInt64 *int64 |
| PUint *uint |
| PUint8 *uint8 |
| PUint16 *uint16 |
| PUint32 *uint32 |
| PUint64 *uint64 |
| PUintptr *uintptr |
| PFloat32 *float32 |
| PFloat64 *float64 |
| |
| String string |
| PString *string |
| |
| Map map[string]Small |
| MapP map[string]*Small |
| PMap *map[string]Small |
| PMapP *map[string]*Small |
| |
| EmptyMap map[string]Small |
| NilMap map[string]Small |
| |
| Slice []Small |
| SliceP []*Small |
| PSlice *[]Small |
| PSliceP *[]*Small |
| |
| EmptySlice []Small |
| NilSlice []Small |
| |
| StringSlice []string |
| ByteSlice []byte |
| |
| Small Small |
| PSmall *Small |
| PPSmall **Small |
| |
| Interface interface{} |
| PInterface *interface{} |
| |
| unexported int |
| } |
| |
| type Small struct { |
| Tag string |
| } |
| |
| var allValue = All{ |
| Bool: true, |
| Int: 2, |
| Int8: 3, |
| Int16: 4, |
| Int32: 5, |
| Int64: 6, |
| Uint: 7, |
| Uint8: 8, |
| Uint16: 9, |
| Uint32: 10, |
| Uint64: 11, |
| Uintptr: 12, |
| Float32: 14.1, |
| Float64: 15.1, |
| Foo: "foo", |
| String: "16", |
| Map: map[string]Small{ |
| "17": {Tag: "tag17"}, |
| "18": {Tag: "tag18"}, |
| }, |
| MapP: map[string]*Small{ |
| "19": &Small{Tag: "tag19"}, |
| "20": nil, |
| }, |
| EmptyMap: map[string]Small{}, |
| Slice: []Small{{Tag: "tag20"}, {Tag: "tag21"}}, |
| SliceP: []*Small{&Small{Tag: "tag22"}, nil, &Small{Tag: "tag23"}}, |
| EmptySlice: []Small{}, |
| StringSlice: []string{"str24", "str25", "str26"}, |
| ByteSlice: []byte{27, 28, 29}, |
| Small: Small{Tag: "tag30"}, |
| PSmall: &Small{Tag: "tag31"}, |
| Interface: 5.2, |
| } |
| |
| var pallValue = All{ |
| PBool: &allValue.Bool, |
| PInt: &allValue.Int, |
| PInt8: &allValue.Int8, |
| PInt16: &allValue.Int16, |
| PInt32: &allValue.Int32, |
| PInt64: &allValue.Int64, |
| PUint: &allValue.Uint, |
| PUint8: &allValue.Uint8, |
| PUint16: &allValue.Uint16, |
| PUint32: &allValue.Uint32, |
| PUint64: &allValue.Uint64, |
| PUintptr: &allValue.Uintptr, |
| PFloat32: &allValue.Float32, |
| PFloat64: &allValue.Float64, |
| PString: &allValue.String, |
| PMap: &allValue.Map, |
| PMapP: &allValue.MapP, |
| PSlice: &allValue.Slice, |
| PSliceP: &allValue.SliceP, |
| PPSmall: &allValue.PSmall, |
| PInterface: &allValue.Interface, |
| } |
| |
| var allValueIndent = `{ |
| "Bool": true, |
| "Int": 2, |
| "Int8": 3, |
| "Int16": 4, |
| "Int32": 5, |
| "Int64": 6, |
| "Uint": 7, |
| "Uint8": 8, |
| "Uint16": 9, |
| "Uint32": 10, |
| "Uint64": 11, |
| "Uintptr": 12, |
| "Float32": 14.1, |
| "Float64": 15.1, |
| "bar": "foo", |
| "PBool": null, |
| "PInt": null, |
| "PInt8": null, |
| "PInt16": null, |
| "PInt32": null, |
| "PInt64": null, |
| "PUint": null, |
| "PUint8": null, |
| "PUint16": null, |
| "PUint32": null, |
| "PUint64": null, |
| "PUintptr": null, |
| "PFloat32": null, |
| "PFloat64": null, |
| "String": "16", |
| "PString": null, |
| "Map": { |
| "17": { |
| "Tag": "tag17" |
| }, |
| "18": { |
| "Tag": "tag18" |
| } |
| }, |
| "MapP": { |
| "19": { |
| "Tag": "tag19" |
| }, |
| "20": null |
| }, |
| "PMap": null, |
| "PMapP": null, |
| "EmptyMap": {}, |
| "NilMap": null, |
| "Slice": [ |
| { |
| "Tag": "tag20" |
| }, |
| { |
| "Tag": "tag21" |
| } |
| ], |
| "SliceP": [ |
| { |
| "Tag": "tag22" |
| }, |
| null, |
| { |
| "Tag": "tag23" |
| } |
| ], |
| "PSlice": null, |
| "PSliceP": null, |
| "EmptySlice": [], |
| "NilSlice": [], |
| "StringSlice": [ |
| "str24", |
| "str25", |
| "str26" |
| ], |
| "ByteSlice": "Gxwd", |
| "Small": { |
| "Tag": "tag30" |
| }, |
| "PSmall": { |
| "Tag": "tag31" |
| }, |
| "PPSmall": null, |
| "Interface": 5.2, |
| "PInterface": null |
| }` |
| |
| var allValueCompact = strings.Map(noSpace, allValueIndent) |
| |
| var pallValueIndent = `{ |
| "Bool": false, |
| "Int": 0, |
| "Int8": 0, |
| "Int16": 0, |
| "Int32": 0, |
| "Int64": 0, |
| "Uint": 0, |
| "Uint8": 0, |
| "Uint16": 0, |
| "Uint32": 0, |
| "Uint64": 0, |
| "Uintptr": 0, |
| "Float32": 0, |
| "Float64": 0, |
| "bar": "", |
| "PBool": true, |
| "PInt": 2, |
| "PInt8": 3, |
| "PInt16": 4, |
| "PInt32": 5, |
| "PInt64": 6, |
| "PUint": 7, |
| "PUint8": 8, |
| "PUint16": 9, |
| "PUint32": 10, |
| "PUint64": 11, |
| "PUintptr": 12, |
| "PFloat32": 14.1, |
| "PFloat64": 15.1, |
| "String": "", |
| "PString": "16", |
| "Map": null, |
| "MapP": null, |
| "PMap": { |
| "17": { |
| "Tag": "tag17" |
| }, |
| "18": { |
| "Tag": "tag18" |
| } |
| }, |
| "PMapP": { |
| "19": { |
| "Tag": "tag19" |
| }, |
| "20": null |
| }, |
| "EmptyMap": null, |
| "NilMap": null, |
| "Slice": [], |
| "SliceP": [], |
| "PSlice": [ |
| { |
| "Tag": "tag20" |
| }, |
| { |
| "Tag": "tag21" |
| } |
| ], |
| "PSliceP": [ |
| { |
| "Tag": "tag22" |
| }, |
| null, |
| { |
| "Tag": "tag23" |
| } |
| ], |
| "EmptySlice": [], |
| "NilSlice": [], |
| "StringSlice": [], |
| "ByteSlice": "", |
| "Small": { |
| "Tag": "" |
| }, |
| "PSmall": null, |
| "PPSmall": { |
| "Tag": "tag31" |
| }, |
| "Interface": null, |
| "PInterface": 5.2 |
| }` |
| |
| var pallValueCompact = strings.Map(noSpace, pallValueIndent) |