2010-04-21 17:40:53 -06:00
|
|
|
// Copyright 2010 The Go Authors. All rights reserved.
|
2009-11-30 14:55:09 -07:00
|
|
|
// Use of this source code is governed by a BSD-style
|
|
|
|
// license that can be found in the LICENSE file.
|
|
|
|
|
|
|
|
package json
|
|
|
|
|
|
|
|
import (
|
2010-04-21 17:40:53 -06:00
|
|
|
"bytes"
|
2013-08-14 12:56:07 -06:00
|
|
|
"encoding"
|
2011-12-15 11:02:47 -07:00
|
|
|
"fmt"
|
2012-09-10 21:31:40 -06:00
|
|
|
"image"
|
2009-12-15 16:35:38 -07:00
|
|
|
"reflect"
|
2010-04-21 17:40:53 -06:00
|
|
|
"strings"
|
2009-12-15 16:35:38 -07:00
|
|
|
"testing"
|
2013-02-14 12:46:15 -07:00
|
|
|
"time"
|
2009-11-30 14:55:09 -07:00
|
|
|
)
|
|
|
|
|
2010-05-11 15:38:55 -06:00
|
|
|
type T struct {
|
|
|
|
X string
|
|
|
|
Y int
|
2011-09-14 16:09:43 -06:00
|
|
|
Z int `json:"-"`
|
2010-05-11 15:38:55 -06:00
|
|
|
}
|
|
|
|
|
2012-04-30 19:37:44 -06:00
|
|
|
type U struct {
|
|
|
|
Alphabet string `json:"alpha"`
|
|
|
|
}
|
|
|
|
|
2012-06-25 15:36:09 -06:00
|
|
|
type V struct {
|
|
|
|
F1 interface{}
|
|
|
|
F2 int32
|
|
|
|
F3 Number
|
|
|
|
}
|
|
|
|
|
2013-04-09 16:00:21 -06:00
|
|
|
// ifaceNumAsFloat64/ifaceNumAsNumber are used to test unmarshaling with and
|
2012-06-25 15:36:09 -06:00
|
|
|
// 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")},
|
|
|
|
}
|
|
|
|
|
2010-09-28 12:40:23 -06:00
|
|
|
type tx struct {
|
|
|
|
x int
|
|
|
|
}
|
|
|
|
|
2010-11-08 16:33:00 -07:00
|
|
|
// A type that can unmarshal itself.
|
|
|
|
|
|
|
|
type unmarshaler struct {
|
|
|
|
T bool
|
|
|
|
}
|
|
|
|
|
2011-11-01 20:04:37 -06:00
|
|
|
func (u *unmarshaler) UnmarshalJSON(b []byte) error {
|
2013-08-14 12:56:07 -06:00
|
|
|
*u = unmarshaler{true} // All we need to see that UnmarshalJSON is called.
|
2010-11-08 16:33:00 -07:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2011-08-10 07:26:51 -06:00
|
|
|
type ustruct struct {
|
|
|
|
M unmarshaler
|
|
|
|
}
|
|
|
|
|
2013-08-14 12:56:07 -06:00
|
|
|
type unmarshalerText struct {
|
|
|
|
T bool
|
|
|
|
}
|
|
|
|
|
|
|
|
// needed for re-marshaling tests
|
|
|
|
func (u *unmarshalerText) MarshalText() ([]byte, error) {
|
|
|
|
return []byte(""), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (u *unmarshalerText) UnmarshalText(b []byte) error {
|
|
|
|
*u = unmarshalerText{true} // All we need to see that UnmarshalText is called.
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
var _ encoding.TextUnmarshaler = (*unmarshalerText)(nil)
|
|
|
|
|
|
|
|
type ustructText struct {
|
|
|
|
M unmarshalerText
|
|
|
|
}
|
|
|
|
|
2010-11-08 16:33:00 -07:00
|
|
|
var (
|
|
|
|
um0, um1 unmarshaler // target2 of unmarshaling
|
|
|
|
ump = &um1
|
|
|
|
umtrue = unmarshaler{true}
|
2011-09-06 17:04:55 -06:00
|
|
|
umslice = []unmarshaler{{true}}
|
2011-08-10 07:26:51 -06:00
|
|
|
umslicep = new([]unmarshaler)
|
|
|
|
umstruct = ustruct{unmarshaler{true}}
|
2013-08-14 12:56:07 -06:00
|
|
|
|
|
|
|
um0T, um1T unmarshalerText // target2 of unmarshaling
|
|
|
|
umpT = &um1T
|
|
|
|
umtrueT = unmarshalerText{true}
|
|
|
|
umsliceT = []unmarshalerText{{true}}
|
|
|
|
umslicepT = new([]unmarshalerText)
|
|
|
|
umstructT = ustructText{unmarshalerText{true}}
|
2010-11-08 16:33:00 -07:00
|
|
|
)
|
|
|
|
|
2012-09-10 21:31:40 -06:00
|
|
|
// Test data structures for anonymous fields.
|
|
|
|
|
|
|
|
type Point struct {
|
|
|
|
Z int
|
|
|
|
}
|
|
|
|
|
|
|
|
type Top struct {
|
|
|
|
Level0 int
|
|
|
|
Embed0
|
|
|
|
*Embed0a
|
|
|
|
*Embed0b `json:"e,omitempty"` // treated as named
|
|
|
|
Embed0c `json:"-"` // ignored
|
|
|
|
Loop
|
|
|
|
Embed0p // has Point with X, Y, used
|
|
|
|
Embed0q // has Point with Z, used
|
|
|
|
}
|
|
|
|
|
|
|
|
type Embed0 struct {
|
|
|
|
Level1a int // overridden by Embed0a's Level1a with json tag
|
|
|
|
Level1b int // used because Embed0a's Level1b is renamed
|
|
|
|
Level1c int // used because Embed0a's Level1c is ignored
|
|
|
|
Level1d int // annihilated by Embed0a's Level1d
|
|
|
|
Level1e int `json:"x"` // annihilated by Embed0a.Level1e
|
|
|
|
}
|
|
|
|
|
|
|
|
type Embed0a struct {
|
|
|
|
Level1a int `json:"Level1a,omitempty"`
|
|
|
|
Level1b int `json:"LEVEL1B,omitempty"`
|
|
|
|
Level1c int `json:"-"`
|
|
|
|
Level1d int // annihilated by Embed0's Level1d
|
|
|
|
Level1f int `json:"x"` // annihilated by Embed0's Level1e
|
|
|
|
}
|
|
|
|
|
|
|
|
type Embed0b Embed0
|
|
|
|
|
|
|
|
type Embed0c Embed0
|
|
|
|
|
|
|
|
type Embed0p struct {
|
|
|
|
image.Point
|
|
|
|
}
|
|
|
|
|
|
|
|
type Embed0q struct {
|
|
|
|
Point
|
|
|
|
}
|
|
|
|
|
|
|
|
type Loop struct {
|
|
|
|
Loop1 int `json:",omitempty"`
|
|
|
|
Loop2 int `json:",omitempty"`
|
|
|
|
*Loop
|
|
|
|
}
|
|
|
|
|
|
|
|
// From reflect test:
|
|
|
|
// The X in S6 and S7 annihilate, but they also block the X in S8.S9.
|
|
|
|
type S5 struct {
|
|
|
|
S6
|
|
|
|
S7
|
|
|
|
S8
|
|
|
|
}
|
|
|
|
|
|
|
|
type S6 struct {
|
|
|
|
X int
|
|
|
|
}
|
|
|
|
|
|
|
|
type S7 S6
|
|
|
|
|
|
|
|
type S8 struct {
|
|
|
|
S9
|
|
|
|
}
|
|
|
|
|
|
|
|
type S9 struct {
|
|
|
|
X int
|
|
|
|
Y int
|
|
|
|
}
|
|
|
|
|
|
|
|
// From reflect test:
|
|
|
|
// The X in S11.S6 and S12.S6 annihilate, but they also block the X in S13.S8.S9.
|
|
|
|
type S10 struct {
|
|
|
|
S11
|
|
|
|
S12
|
|
|
|
S13
|
|
|
|
}
|
|
|
|
|
|
|
|
type S11 struct {
|
|
|
|
S6
|
|
|
|
}
|
|
|
|
|
|
|
|
type S12 struct {
|
|
|
|
S6
|
|
|
|
}
|
|
|
|
|
|
|
|
type S13 struct {
|
|
|
|
S8
|
|
|
|
}
|
|
|
|
|
2010-04-21 17:40:53 -06:00
|
|
|
type unmarshalTest struct {
|
2012-06-25 15:36:09 -06:00
|
|
|
in string
|
|
|
|
ptr interface{}
|
|
|
|
out interface{}
|
|
|
|
err error
|
|
|
|
useNumber bool
|
2009-11-30 14:55:09 -07:00
|
|
|
}
|
|
|
|
|
2012-09-10 21:31:40 -06:00
|
|
|
type Ambig struct {
|
|
|
|
// Given "hello", the first match should win.
|
|
|
|
First int `json:"HELLO"`
|
|
|
|
Second int `json:"Hello"`
|
|
|
|
}
|
|
|
|
|
2010-04-21 17:40:53 -06:00
|
|
|
var unmarshalTests = []unmarshalTest{
|
|
|
|
// basic types
|
2012-05-29 16:02:40 -06:00
|
|
|
{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)},
|
2012-06-25 15:36:09 -06:00
|
|
|
{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},
|
2012-05-29 16:02:40 -06:00
|
|
|
{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("")}},
|
2013-01-22 15:49:07 -07:00
|
|
|
{in: `{"x": 1}`, ptr: new(tx), out: tx{}},
|
2012-06-25 15:36:09 -06:00
|
|
|
{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},
|
2009-11-30 14:55:09 -07:00
|
|
|
|
2013-01-10 18:58:45 -07:00
|
|
|
// raw values with whitespace
|
|
|
|
{in: "\n true ", ptr: new(bool), out: true},
|
|
|
|
{in: "\t 1 ", ptr: new(int), out: 1},
|
|
|
|
{in: "\r 1.2 ", ptr: new(float64), out: 1.2},
|
|
|
|
{in: "\t -5 \n", ptr: new(int16), out: int16(-5)},
|
|
|
|
{in: "\t \"a\\u1234\" \n", ptr: new(string), out: "a\u1234"},
|
|
|
|
|
2011-09-14 16:09:43 -06:00
|
|
|
// Z has a "-" tag.
|
2012-05-29 16:02:40 -06:00
|
|
|
{in: `{"Y": 1, "Z": 2}`, ptr: new(T), out: T{Y: 1}},
|
2011-09-14 16:09:43 -06:00
|
|
|
|
2012-05-29 16:02:40 -06:00
|
|
|
{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{}},
|
2012-04-30 19:37:44 -06:00
|
|
|
|
2010-08-03 18:05:00 -06:00
|
|
|
// syntax errors
|
2012-05-29 16:02:40 -06:00
|
|
|
{in: `{"X": "foo", "Y"}`, err: &SyntaxError{"invalid character '}' after object key", 17}},
|
|
|
|
{in: `[1, 2, 3+]`, err: &SyntaxError{"invalid character '+' after array element", 9}},
|
2012-06-25 15:36:09 -06:00
|
|
|
{in: `{"X":12x}`, err: &SyntaxError{"invalid character 'x' after object key:value pair", 8}, useNumber: true},
|
2011-12-19 13:32:06 -07:00
|
|
|
|
2013-01-10 18:58:45 -07:00
|
|
|
// raw value errors
|
|
|
|
{in: "\x01 42", err: &SyntaxError{"invalid character '\\x01' looking for beginning of value", 1}},
|
|
|
|
{in: " 42 \x01", err: &SyntaxError{"invalid character '\\x01' after top-level value", 5}},
|
|
|
|
{in: "\x01 true", err: &SyntaxError{"invalid character '\\x01' looking for beginning of value", 1}},
|
|
|
|
{in: " false \x01", err: &SyntaxError{"invalid character '\\x01' after top-level value", 8}},
|
|
|
|
{in: "\x01 1.2", err: &SyntaxError{"invalid character '\\x01' looking for beginning of value", 1}},
|
|
|
|
{in: " 3.4 \x01", err: &SyntaxError{"invalid character '\\x01' after top-level value", 6}},
|
|
|
|
{in: "\x01 \"string\"", err: &SyntaxError{"invalid character '\\x01' looking for beginning of value", 1}},
|
|
|
|
{in: " \"string\" \x01", err: &SyntaxError{"invalid character '\\x01' after top-level value", 11}},
|
|
|
|
|
2011-12-19 13:32:06 -07:00
|
|
|
// array tests
|
2012-05-29 16:02:40 -06:00
|
|
|
{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}},
|
2010-08-03 18:05:00 -06:00
|
|
|
|
2013-01-30 10:10:32 -07:00
|
|
|
// empty array to interface test
|
|
|
|
{in: `[]`, ptr: new([]interface{}), out: []interface{}{}},
|
|
|
|
{in: `null`, ptr: new([]interface{}), out: []interface{}(nil)},
|
|
|
|
{in: `{"T":[]}`, ptr: new(map[string]interface{}), out: map[string]interface{}{"T": []interface{}{}}},
|
|
|
|
{in: `{"T":null}`, ptr: new(map[string]interface{}), out: map[string]interface{}{"T": interface{}(nil)}},
|
|
|
|
|
2010-04-21 17:40:53 -06:00
|
|
|
// composite tests
|
2012-05-29 16:02:40 -06:00
|
|
|
{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},
|
2010-11-08 16:33:00 -07:00
|
|
|
|
|
|
|
// unmarshal interface test
|
2012-05-29 16:02:40 -06:00
|
|
|
{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},
|
2012-09-10 21:31:40 -06:00
|
|
|
|
2013-08-14 12:56:07 -06:00
|
|
|
// UnmarshalText interface test
|
|
|
|
{in: `"X"`, ptr: &um0T, out: umtrueT}, // use "false" so test will fail if custom unmarshaler is not called
|
|
|
|
{in: `"X"`, ptr: &umpT, out: &umtrueT},
|
|
|
|
{in: `["X"]`, ptr: &umsliceT, out: umsliceT},
|
|
|
|
{in: `["X"]`, ptr: &umslicepT, out: &umsliceT},
|
|
|
|
{in: `{"M":"X"}`, ptr: &umstructT, out: umstructT},
|
|
|
|
|
2012-09-10 21:31:40 -06:00
|
|
|
{
|
|
|
|
in: `{
|
|
|
|
"Level0": 1,
|
|
|
|
"Level1b": 2,
|
|
|
|
"Level1c": 3,
|
|
|
|
"x": 4,
|
|
|
|
"Level1a": 5,
|
|
|
|
"LEVEL1B": 6,
|
|
|
|
"e": {
|
|
|
|
"Level1a": 8,
|
|
|
|
"Level1b": 9,
|
|
|
|
"Level1c": 10,
|
|
|
|
"Level1d": 11,
|
|
|
|
"x": 12
|
|
|
|
},
|
|
|
|
"Loop1": 13,
|
|
|
|
"Loop2": 14,
|
|
|
|
"X": 15,
|
|
|
|
"Y": 16,
|
|
|
|
"Z": 17
|
|
|
|
}`,
|
|
|
|
ptr: new(Top),
|
|
|
|
out: Top{
|
|
|
|
Level0: 1,
|
|
|
|
Embed0: Embed0{
|
|
|
|
Level1b: 2,
|
|
|
|
Level1c: 3,
|
|
|
|
},
|
|
|
|
Embed0a: &Embed0a{
|
|
|
|
Level1a: 5,
|
|
|
|
Level1b: 6,
|
|
|
|
},
|
|
|
|
Embed0b: &Embed0b{
|
|
|
|
Level1a: 8,
|
|
|
|
Level1b: 9,
|
|
|
|
Level1c: 10,
|
|
|
|
Level1d: 11,
|
|
|
|
Level1e: 12,
|
|
|
|
},
|
|
|
|
Loop: Loop{
|
|
|
|
Loop1: 13,
|
|
|
|
Loop2: 14,
|
|
|
|
},
|
|
|
|
Embed0p: Embed0p{
|
|
|
|
Point: image.Point{X: 15, Y: 16},
|
|
|
|
},
|
|
|
|
Embed0q: Embed0q{
|
|
|
|
Point: Point{Z: 17},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
in: `{"hello": 1}`,
|
|
|
|
ptr: new(Ambig),
|
|
|
|
out: Ambig{First: 1},
|
|
|
|
},
|
|
|
|
|
|
|
|
{
|
|
|
|
in: `{"X": 1,"Y":2}`,
|
|
|
|
ptr: new(S5),
|
|
|
|
out: S5{S8: S8{S9: S9{Y: 2}}},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
in: `{"X": 1,"Y":2}`,
|
|
|
|
ptr: new(S10),
|
|
|
|
out: S10{S13: S13{S8: S8{S9: S9{Y: 2}}}},
|
|
|
|
},
|
2013-02-14 12:56:01 -07:00
|
|
|
|
|
|
|
// invalid UTF-8 is coerced to valid UTF-8.
|
|
|
|
{
|
|
|
|
in: "\"hello\xffworld\"",
|
|
|
|
ptr: new(string),
|
|
|
|
out: "hello\ufffdworld",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
in: "\"hello\xc2\xc2world\"",
|
|
|
|
ptr: new(string),
|
|
|
|
out: "hello\ufffd\ufffdworld",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
in: "\"hello\xc2\xffworld\"",
|
|
|
|
ptr: new(string),
|
|
|
|
out: "hello\ufffd\ufffdworld",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
in: "\"hello\\ud800world\"",
|
|
|
|
ptr: new(string),
|
|
|
|
out: "hello\ufffdworld",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
in: "\"hello\\ud800\\ud800world\"",
|
|
|
|
ptr: new(string),
|
|
|
|
out: "hello\ufffd\ufffdworld",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
in: "\"hello\\ud800\\ud800world\"",
|
|
|
|
ptr: new(string),
|
|
|
|
out: "hello\ufffd\ufffdworld",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
in: "\"hello\xed\xa0\x80\xed\xb0\x80world\"",
|
|
|
|
ptr: new(string),
|
|
|
|
out: "hello\ufffd\ufffd\ufffd\ufffd\ufffd\ufffdworld",
|
|
|
|
},
|
2009-11-30 14:55:09 -07:00
|
|
|
}
|
|
|
|
|
2010-04-21 17:40:53 -06:00
|
|
|
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
|
|
|
|
}
|
2009-11-30 14:55:09 -07:00
|
|
|
|
2010-04-21 17:40:53 -06:00
|
|
|
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
|
|
|
|
}
|
2009-11-30 14:55:09 -07:00
|
|
|
}
|
|
|
|
|
2013-07-12 18:40:50 -06:00
|
|
|
var badUTF8 = []struct {
|
|
|
|
in, out string
|
|
|
|
}{
|
|
|
|
{"hello\xffworld", `"hello\ufffdworld"`},
|
|
|
|
{"", `""`},
|
|
|
|
{"\xff", `"\ufffd"`},
|
|
|
|
{"\xff\xff", `"\ufffd\ufffd"`},
|
|
|
|
{"a\xffb", `"a\ufffdb"`},
|
|
|
|
{"\xe6\x97\xa5\xe6\x9c\xac\xff\xaa\x9e", `"日本\ufffd\ufffd\ufffd"`},
|
|
|
|
}
|
|
|
|
|
2010-12-13 13:51:11 -07:00
|
|
|
func TestMarshalBadUTF8(t *testing.T) {
|
2013-07-12 18:40:50 -06:00
|
|
|
for _, tt := range badUTF8 {
|
|
|
|
b, err := Marshal(tt.in)
|
|
|
|
if string(b) != tt.out || err != nil {
|
|
|
|
t.Errorf("Marshal(%q) = %#q, %v, want %#q, nil", tt.in, b, err, tt.out)
|
|
|
|
}
|
2010-12-13 13:51:11 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-06-25 15:36:09 -06:00
|
|
|
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)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
encoding/json: faster encoding
The old code was caching per-type struct field info. Instead,
cache type-specific encoding funcs, tailored for that
particular type to avoid unnecessary reflection at runtime.
Once the machine is built once, future encodings of that type
just run the func.
benchmark old ns/op new ns/op delta
BenchmarkCodeEncoder 48424939 36975320 -23.64%
benchmark old MB/s new MB/s speedup
BenchmarkCodeEncoder 40.07 52.48 1.31x
Additionally, the numbers seem stable now at ~52 MB/s, whereas
the numbers for the old code were all over the place: 11 MB/s,
40 MB/s, 13 MB/s, 39 MB/s, etc. In the benchmark above I compared
against the best I saw the old code do.
R=rsc, adg
CC=gobot, golang-dev, r
https://golang.org/cl/9129044
2013-08-09 10:46:47 -06:00
|
|
|
func TestMarshalEmbeds(t *testing.T) {
|
|
|
|
top := &Top{
|
|
|
|
Level0: 1,
|
|
|
|
Embed0: Embed0{
|
|
|
|
Level1b: 2,
|
|
|
|
Level1c: 3,
|
|
|
|
},
|
|
|
|
Embed0a: &Embed0a{
|
|
|
|
Level1a: 5,
|
|
|
|
Level1b: 6,
|
|
|
|
},
|
|
|
|
Embed0b: &Embed0b{
|
|
|
|
Level1a: 8,
|
|
|
|
Level1b: 9,
|
|
|
|
Level1c: 10,
|
|
|
|
Level1d: 11,
|
|
|
|
Level1e: 12,
|
|
|
|
},
|
|
|
|
Loop: Loop{
|
|
|
|
Loop1: 13,
|
|
|
|
Loop2: 14,
|
|
|
|
},
|
|
|
|
Embed0p: Embed0p{
|
|
|
|
Point: image.Point{X: 15, Y: 16},
|
|
|
|
},
|
|
|
|
Embed0q: Embed0q{
|
|
|
|
Point: Point{Z: 17},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
b, err := Marshal(top)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
want := "{\"Level0\":1,\"Level1b\":2,\"Level1c\":3,\"Level1a\":5,\"LEVEL1B\":6,\"e\":{\"Level1a\":8,\"Level1b\":9,\"Level1c\":10,\"Level1d\":11,\"x\":12},\"Loop1\":13,\"Loop2\":14,\"X\":15,\"Y\":16,\"Z\":17}"
|
|
|
|
if string(b) != want {
|
|
|
|
t.Errorf("Wrong marshal result.\n got: %q\nwant: %q", b, want)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-04-21 17:40:53 -06:00
|
|
|
func TestUnmarshal(t *testing.T) {
|
|
|
|
for i, tt := range unmarshalTests {
|
2011-04-15 09:14:34 -06:00
|
|
|
var scan scanner
|
2010-04-21 17:40:53 -06:00
|
|
|
in := []byte(tt.in)
|
|
|
|
if err := checkValid(in, &scan); err != nil {
|
2010-08-03 18:05:00 -06:00
|
|
|
if !reflect.DeepEqual(err, tt.err) {
|
2011-04-15 09:14:34 -06:00
|
|
|
t.Errorf("#%d: checkValid: %#v", i, err)
|
2010-08-03 18:05:00 -06:00
|
|
|
continue
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if tt.ptr == nil {
|
2010-04-21 17:40:53 -06:00
|
|
|
continue
|
|
|
|
}
|
|
|
|
// v = new(right-type)
|
2011-04-25 11:39:36 -06:00
|
|
|
v := reflect.New(reflect.TypeOf(tt.ptr).Elem())
|
encoding/json: faster encoding
The old code was caching per-type struct field info. Instead,
cache type-specific encoding funcs, tailored for that
particular type to avoid unnecessary reflection at runtime.
Once the machine is built once, future encodings of that type
just run the func.
benchmark old ns/op new ns/op delta
BenchmarkCodeEncoder 48424939 36975320 -23.64%
benchmark old MB/s new MB/s speedup
BenchmarkCodeEncoder 40.07 52.48 1.31x
Additionally, the numbers seem stable now at ~52 MB/s, whereas
the numbers for the old code were all over the place: 11 MB/s,
40 MB/s, 13 MB/s, 39 MB/s, etc. In the benchmark above I compared
against the best I saw the old code do.
R=rsc, adg
CC=gobot, golang-dev, r
https://golang.org/cl/9129044
2013-08-09 10:46:47 -06:00
|
|
|
dec := NewDecoder(bytes.NewReader(in))
|
2012-06-25 15:36:09 -06:00
|
|
|
if tt.useNumber {
|
|
|
|
dec.UseNumber()
|
|
|
|
}
|
|
|
|
if err := dec.Decode(v.Interface()); !reflect.DeepEqual(err, tt.err) {
|
2010-05-11 15:38:55 -06:00
|
|
|
t.Errorf("#%d: %v want %v", i, err, tt.err)
|
2010-04-21 17:40:53 -06:00
|
|
|
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
|
|
|
|
}
|
2012-05-29 16:02:40 -06:00
|
|
|
|
|
|
|
// 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())
|
encoding/json: faster encoding
The old code was caching per-type struct field info. Instead,
cache type-specific encoding funcs, tailored for that
particular type to avoid unnecessary reflection at runtime.
Once the machine is built once, future encodings of that type
just run the func.
benchmark old ns/op new ns/op delta
BenchmarkCodeEncoder 48424939 36975320 -23.64%
benchmark old MB/s new MB/s speedup
BenchmarkCodeEncoder 40.07 52.48 1.31x
Additionally, the numbers seem stable now at ~52 MB/s, whereas
the numbers for the old code were all over the place: 11 MB/s,
40 MB/s, 13 MB/s, 39 MB/s, etc. In the benchmark above I compared
against the best I saw the old code do.
R=rsc, adg
CC=gobot, golang-dev, r
https://golang.org/cl/9129044
2013-08-09 10:46:47 -06:00
|
|
|
dec = NewDecoder(bytes.NewReader(enc))
|
2012-06-25 15:36:09 -06:00
|
|
|
if tt.useNumber {
|
|
|
|
dec.UseNumber()
|
|
|
|
}
|
|
|
|
if err := dec.Decode(vv.Interface()); err != nil {
|
2013-08-14 12:56:07 -06:00
|
|
|
t.Errorf("#%d: error re-unmarshaling %#q: %v", i, enc, err)
|
2012-05-29 16:02:40 -06:00
|
|
|
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())
|
encoding/json: faster encoding
The old code was caching per-type struct field info. Instead,
cache type-specific encoding funcs, tailored for that
particular type to avoid unnecessary reflection at runtime.
Once the machine is built once, future encodings of that type
just run the func.
benchmark old ns/op new ns/op delta
BenchmarkCodeEncoder 48424939 36975320 -23.64%
benchmark old MB/s new MB/s speedup
BenchmarkCodeEncoder 40.07 52.48 1.31x
Additionally, the numbers seem stable now at ~52 MB/s, whereas
the numbers for the old code were all over the place: 11 MB/s,
40 MB/s, 13 MB/s, 39 MB/s, etc. In the benchmark above I compared
against the best I saw the old code do.
R=rsc, adg
CC=gobot, golang-dev, r
https://golang.org/cl/9129044
2013-08-09 10:46:47 -06:00
|
|
|
t.Errorf(" In: %q", strings.Map(noSpace, string(in)))
|
|
|
|
t.Errorf("Marshal: %q", strings.Map(noSpace, string(enc)))
|
2012-05-29 16:02:40 -06:00
|
|
|
continue
|
|
|
|
}
|
|
|
|
}
|
2010-04-21 17:40:53 -06:00
|
|
|
}
|
2009-11-30 14:55:09 -07:00
|
|
|
}
|
|
|
|
|
2010-04-21 17:40:53 -06:00
|
|
|
func TestUnmarshalMarshal(t *testing.T) {
|
2011-03-26 12:25:22 -06:00
|
|
|
initBig()
|
2010-04-21 17:40:53 -06:00
|
|
|
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)
|
|
|
|
}
|
2013-01-06 16:03:49 -07:00
|
|
|
if !bytes.Equal(jsonBig, b) {
|
2010-04-21 17:40:53 -06:00
|
|
|
t.Errorf("Marshal jsonBig")
|
|
|
|
diff(t, b, jsonBig)
|
|
|
|
return
|
|
|
|
}
|
2009-11-30 14:55:09 -07:00
|
|
|
}
|
|
|
|
|
2012-06-25 15:36:09 -06:00
|
|
|
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)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-02-23 09:32:29 -07:00
|
|
|
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)
|
|
|
|
}
|
2013-01-06 16:03:49 -07:00
|
|
|
if !bytes.Equal(s0, s1) {
|
2011-02-23 09:32:29 -07:00
|
|
|
t.Errorf("Marshal large byte slice")
|
|
|
|
diff(t, s0, s1)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-04-27 11:24:00 -06:00
|
|
|
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")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-07-13 21:30:08 -06:00
|
|
|
func TestEscape(t *testing.T) {
|
2013-07-11 22:35:55 -06:00
|
|
|
const input = `"foobar"<html>` + " [\u2028 \u2029]"
|
|
|
|
const expected = `"\"foobar\"\u003chtml\u003e [\u2028 \u2029]"`
|
2011-07-13 21:30:08 -06:00
|
|
|
b, err := Marshal(input)
|
|
|
|
if err != nil {
|
|
|
|
t.Fatalf("Marshal error: %v", err)
|
|
|
|
}
|
|
|
|
if s := string(b); s != expected {
|
2013-07-11 22:35:55 -06:00
|
|
|
t.Errorf("Encoding of [%s]:\n got [%s]\nwant [%s]", input, s, expected)
|
2011-07-13 21:30:08 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-12-15 11:02:47 -07:00
|
|
|
// WrongString is a struct that's misusing the ,string modifier.
|
|
|
|
type WrongString struct {
|
|
|
|
Message string `json:"result,string"`
|
|
|
|
}
|
|
|
|
|
|
|
|
type wrongStringTest struct {
|
|
|
|
in, err string
|
|
|
|
}
|
|
|
|
|
|
|
|
var wrongStringTests = []wrongStringTest{
|
2012-01-12 15:40:29 -07:00
|
|
|
{`{"result":"x"}`, `json: invalid use of ,string struct tag, trying to unmarshal "x" into string`},
|
|
|
|
{`{"result":"foo"}`, `json: invalid use of ,string struct tag, trying to unmarshal "foo" into string`},
|
|
|
|
{`{"result":"123"}`, `json: invalid use of ,string struct tag, trying to unmarshal "123" into string`},
|
2011-12-15 11:02:47 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
// If people misuse the ,string modifier, the error message should be
|
|
|
|
// helpful, telling the user that they're doing it wrong.
|
|
|
|
func TestErrorMessageFromMisusedString(t *testing.T) {
|
|
|
|
for n, tt := range wrongStringTests {
|
|
|
|
r := strings.NewReader(tt.in)
|
|
|
|
var s WrongString
|
|
|
|
err := NewDecoder(r).Decode(&s)
|
|
|
|
got := fmt.Sprintf("%v", err)
|
|
|
|
if got != tt.err {
|
|
|
|
t.Errorf("%d. got err = %q, want %q", n, got, tt.err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-10-25 23:23:54 -06:00
|
|
|
func noSpace(c rune) rune {
|
2010-04-21 17:40:53 -06:00
|
|
|
if isSpace(c) {
|
|
|
|
return -1
|
|
|
|
}
|
|
|
|
return c
|
2009-11-30 14:55:09 -07:00
|
|
|
}
|
|
|
|
|
2010-04-21 17:40:53 -06:00
|
|
|
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
|
2009-11-30 14:55:09 -07:00
|
|
|
|
2011-08-26 02:27:33 -06:00
|
|
|
Foo string `json:"bar"`
|
|
|
|
Foo2 string `json:"bar2,dummyopt"`
|
2009-11-30 14:55:09 -07:00
|
|
|
|
2011-08-29 13:46:32 -06:00
|
|
|
IntStr int64 `json:",string"`
|
|
|
|
|
2010-04-21 17:40:53 -06:00
|
|
|
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
|
2009-11-30 14:55:09 -07:00
|
|
|
|
2010-04-21 17:40:53 -06:00
|
|
|
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{}
|
2011-01-11 17:59:33 -07:00
|
|
|
|
|
|
|
unexported int
|
2009-11-30 14:55:09 -07:00
|
|
|
}
|
|
|
|
|
2010-04-21 17:40:53 -06:00
|
|
|
type Small struct {
|
|
|
|
Tag string
|
2009-11-30 14:55:09 -07:00
|
|
|
}
|
|
|
|
|
2010-04-21 17:40:53 -06:00
|
|
|
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",
|
2011-08-26 02:27:33 -06:00
|
|
|
Foo2: "foo2",
|
2011-08-29 13:46:32 -06:00
|
|
|
IntStr: 42,
|
2010-04-21 17:40:53 -06:00
|
|
|
String: "16",
|
|
|
|
Map: map[string]Small{
|
2010-10-22 11:06:33 -06:00
|
|
|
"17": {Tag: "tag17"},
|
|
|
|
"18": {Tag: "tag18"},
|
2010-04-21 17:40:53 -06:00
|
|
|
},
|
|
|
|
MapP: map[string]*Small{
|
2011-12-02 12:14:25 -07:00
|
|
|
"19": {Tag: "tag19"},
|
2010-04-21 17:40:53 -06:00
|
|
|
"20": nil,
|
|
|
|
},
|
|
|
|
EmptyMap: map[string]Small{},
|
2010-10-22 11:06:33 -06:00
|
|
|
Slice: []Small{{Tag: "tag20"}, {Tag: "tag21"}},
|
2011-12-02 12:14:25 -07:00
|
|
|
SliceP: []*Small{{Tag: "tag22"}, nil, {Tag: "tag23"}},
|
2010-04-21 17:40:53 -06:00
|
|
|
EmptySlice: []Small{},
|
|
|
|
StringSlice: []string{"str24", "str25", "str26"},
|
|
|
|
ByteSlice: []byte{27, 28, 29},
|
|
|
|
Small: Small{Tag: "tag30"},
|
|
|
|
PSmall: &Small{Tag: "tag31"},
|
2011-01-19 21:09:00 -07:00
|
|
|
Interface: 5.2,
|
2009-11-30 14:55:09 -07:00
|
|
|
}
|
|
|
|
|
2010-04-21 17:40:53 -06:00
|
|
|
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,
|
2009-11-30 14:55:09 -07:00
|
|
|
}
|
|
|
|
|
2010-04-21 17:40:53 -06:00
|
|
|
var allValueIndent = `{
|
2010-04-27 11:24:00 -06:00
|
|
|
"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,
|
2010-04-21 17:40:53 -06:00
|
|
|
"bar": "foo",
|
2011-08-26 02:27:33 -06:00
|
|
|
"bar2": "foo2",
|
2011-08-29 13:46:32 -06:00
|
|
|
"IntStr": "42",
|
2010-04-27 11:24:00 -06:00
|
|
|
"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": {
|
2010-04-21 17:40:53 -06:00
|
|
|
"17": {
|
2010-04-27 11:24:00 -06:00
|
|
|
"Tag": "tag17"
|
2010-04-21 17:40:53 -06:00
|
|
|
},
|
|
|
|
"18": {
|
2010-04-27 11:24:00 -06:00
|
|
|
"Tag": "tag18"
|
2009-11-30 14:55:09 -07:00
|
|
|
}
|
2010-04-21 17:40:53 -06:00
|
|
|
},
|
2010-04-27 11:24:00 -06:00
|
|
|
"MapP": {
|
2010-04-21 17:40:53 -06:00
|
|
|
"19": {
|
2010-04-27 11:24:00 -06:00
|
|
|
"Tag": "tag19"
|
2010-04-21 17:40:53 -06:00
|
|
|
},
|
|
|
|
"20": null
|
|
|
|
},
|
2010-04-27 11:24:00 -06:00
|
|
|
"PMap": null,
|
|
|
|
"PMapP": null,
|
|
|
|
"EmptyMap": {},
|
|
|
|
"NilMap": null,
|
|
|
|
"Slice": [
|
2010-04-21 17:40:53 -06:00
|
|
|
{
|
2010-04-27 11:24:00 -06:00
|
|
|
"Tag": "tag20"
|
2010-04-21 17:40:53 -06:00
|
|
|
},
|
|
|
|
{
|
2010-04-27 11:24:00 -06:00
|
|
|
"Tag": "tag21"
|
2010-04-21 17:40:53 -06:00
|
|
|
}
|
|
|
|
],
|
2010-04-27 11:24:00 -06:00
|
|
|
"SliceP": [
|
2010-04-21 17:40:53 -06:00
|
|
|
{
|
2010-04-27 11:24:00 -06:00
|
|
|
"Tag": "tag22"
|
2010-04-21 17:40:53 -06:00
|
|
|
},
|
|
|
|
null,
|
|
|
|
{
|
2010-04-27 11:24:00 -06:00
|
|
|
"Tag": "tag23"
|
2010-04-21 17:40:53 -06:00
|
|
|
}
|
|
|
|
],
|
2010-04-27 11:24:00 -06:00
|
|
|
"PSlice": null,
|
|
|
|
"PSliceP": null,
|
|
|
|
"EmptySlice": [],
|
2011-10-31 11:59:23 -06:00
|
|
|
"NilSlice": null,
|
2010-04-27 11:24:00 -06:00
|
|
|
"StringSlice": [
|
2010-04-21 17:40:53 -06:00
|
|
|
"str24",
|
|
|
|
"str25",
|
|
|
|
"str26"
|
|
|
|
],
|
2011-02-23 09:32:29 -07:00
|
|
|
"ByteSlice": "Gxwd",
|
2010-04-27 11:24:00 -06:00
|
|
|
"Small": {
|
|
|
|
"Tag": "tag30"
|
2010-04-21 17:40:53 -06:00
|
|
|
},
|
2010-04-27 11:24:00 -06:00
|
|
|
"PSmall": {
|
|
|
|
"Tag": "tag31"
|
2010-04-21 17:40:53 -06:00
|
|
|
},
|
2010-04-27 11:24:00 -06:00
|
|
|
"PPSmall": null,
|
|
|
|
"Interface": 5.2,
|
|
|
|
"PInterface": null
|
2010-04-21 17:40:53 -06:00
|
|
|
}`
|
|
|
|
|
|
|
|
var allValueCompact = strings.Map(noSpace, allValueIndent)
|
|
|
|
|
|
|
|
var pallValueIndent = `{
|
2010-04-27 11:24:00 -06:00
|
|
|
"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,
|
2010-04-21 17:40:53 -06:00
|
|
|
"bar": "",
|
2011-08-26 02:27:33 -06:00
|
|
|
"bar2": "",
|
2011-08-29 13:46:32 -06:00
|
|
|
"IntStr": "0",
|
2010-04-27 11:24:00 -06:00
|
|
|
"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": {
|
2010-04-21 17:40:53 -06:00
|
|
|
"17": {
|
2010-04-27 11:24:00 -06:00
|
|
|
"Tag": "tag17"
|
2010-04-21 17:40:53 -06:00
|
|
|
},
|
|
|
|
"18": {
|
2010-04-27 11:24:00 -06:00
|
|
|
"Tag": "tag18"
|
2010-04-21 17:40:53 -06:00
|
|
|
}
|
|
|
|
},
|
2010-04-27 11:24:00 -06:00
|
|
|
"PMapP": {
|
2010-04-21 17:40:53 -06:00
|
|
|
"19": {
|
2010-04-27 11:24:00 -06:00
|
|
|
"Tag": "tag19"
|
2010-04-21 17:40:53 -06:00
|
|
|
},
|
|
|
|
"20": null
|
|
|
|
},
|
2010-04-27 11:24:00 -06:00
|
|
|
"EmptyMap": null,
|
|
|
|
"NilMap": null,
|
2011-10-31 11:59:23 -06:00
|
|
|
"Slice": null,
|
|
|
|
"SliceP": null,
|
2010-04-27 11:24:00 -06:00
|
|
|
"PSlice": [
|
2010-04-21 17:40:53 -06:00
|
|
|
{
|
2010-04-27 11:24:00 -06:00
|
|
|
"Tag": "tag20"
|
2010-04-21 17:40:53 -06:00
|
|
|
},
|
|
|
|
{
|
2010-04-27 11:24:00 -06:00
|
|
|
"Tag": "tag21"
|
2010-04-21 17:40:53 -06:00
|
|
|
}
|
|
|
|
],
|
2010-04-27 11:24:00 -06:00
|
|
|
"PSliceP": [
|
2010-04-21 17:40:53 -06:00
|
|
|
{
|
2010-04-27 11:24:00 -06:00
|
|
|
"Tag": "tag22"
|
2010-04-21 17:40:53 -06:00
|
|
|
},
|
|
|
|
null,
|
|
|
|
{
|
2010-04-27 11:24:00 -06:00
|
|
|
"Tag": "tag23"
|
2010-04-21 17:40:53 -06:00
|
|
|
}
|
|
|
|
],
|
2011-10-31 11:59:23 -06:00
|
|
|
"EmptySlice": null,
|
|
|
|
"NilSlice": null,
|
|
|
|
"StringSlice": null,
|
|
|
|
"ByteSlice": null,
|
2010-04-27 11:24:00 -06:00
|
|
|
"Small": {
|
|
|
|
"Tag": ""
|
2010-04-21 17:40:53 -06:00
|
|
|
},
|
2010-04-27 11:24:00 -06:00
|
|
|
"PSmall": null,
|
|
|
|
"PPSmall": {
|
|
|
|
"Tag": "tag31"
|
2010-04-21 17:40:53 -06:00
|
|
|
},
|
2010-04-27 11:24:00 -06:00
|
|
|
"Interface": null,
|
|
|
|
"PInterface": 5.2
|
2010-04-21 17:40:53 -06:00
|
|
|
}`
|
|
|
|
|
|
|
|
var pallValueCompact = strings.Map(noSpace, pallValueIndent)
|
2012-02-02 17:15:06 -07:00
|
|
|
|
|
|
|
func TestRefUnmarshal(t *testing.T) {
|
|
|
|
type S struct {
|
|
|
|
// Ref is defined in encode_test.go.
|
|
|
|
R0 Ref
|
|
|
|
R1 *Ref
|
2013-08-14 12:56:07 -06:00
|
|
|
R2 RefText
|
|
|
|
R3 *RefText
|
2012-02-02 17:15:06 -07:00
|
|
|
}
|
|
|
|
want := S{
|
|
|
|
R0: 12,
|
|
|
|
R1: new(Ref),
|
2013-08-14 12:56:07 -06:00
|
|
|
R2: 13,
|
|
|
|
R3: new(RefText),
|
2012-02-02 17:15:06 -07:00
|
|
|
}
|
|
|
|
*want.R1 = 12
|
2013-08-14 12:56:07 -06:00
|
|
|
*want.R3 = 13
|
2012-02-02 17:15:06 -07:00
|
|
|
|
|
|
|
var got S
|
2013-08-14 12:56:07 -06:00
|
|
|
if err := Unmarshal([]byte(`{"R0":"ref","R1":"ref","R2":"ref","R3":"ref"}`), &got); err != nil {
|
2012-02-02 17:15:06 -07:00
|
|
|
t.Fatalf("Unmarshal: %v", err)
|
|
|
|
}
|
|
|
|
if !reflect.DeepEqual(got, want) {
|
|
|
|
t.Errorf("got %+v, want %+v", got, want)
|
|
|
|
}
|
|
|
|
}
|
2012-02-18 22:27:05 -07:00
|
|
|
|
2012-05-03 15:35:44 -06:00
|
|
|
// Test that the empty string doesn't panic decoding when ,string is specified
|
|
|
|
// Issue 3450
|
|
|
|
func TestEmptyString(t *testing.T) {
|
|
|
|
type T2 struct {
|
|
|
|
Number1 int `json:",string"`
|
|
|
|
Number2 int `json:",string"`
|
|
|
|
}
|
|
|
|
data := `{"Number1":"1", "Number2":""}`
|
|
|
|
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")
|
|
|
|
}
|
|
|
|
}
|
2012-06-06 23:48:55 -06:00
|
|
|
|
|
|
|
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)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-11-12 13:35:11 -07:00
|
|
|
|
|
|
|
// JSON null values should be ignored for primitives and string values instead of resulting in an error.
|
|
|
|
// Issue 2540
|
|
|
|
func TestUnmarshalNulls(t *testing.T) {
|
|
|
|
jsonData := []byte(`{
|
|
|
|
"Bool" : null,
|
|
|
|
"Int" : null,
|
|
|
|
"Int8" : null,
|
|
|
|
"Int16" : null,
|
|
|
|
"Int32" : null,
|
|
|
|
"Int64" : null,
|
|
|
|
"Uint" : null,
|
|
|
|
"Uint8" : null,
|
|
|
|
"Uint16" : null,
|
|
|
|
"Uint32" : null,
|
|
|
|
"Uint64" : null,
|
|
|
|
"Float32" : null,
|
|
|
|
"Float64" : null,
|
|
|
|
"String" : null}`)
|
|
|
|
|
|
|
|
nulls := All{
|
|
|
|
Bool: true,
|
|
|
|
Int: 2,
|
|
|
|
Int8: 3,
|
|
|
|
Int16: 4,
|
|
|
|
Int32: 5,
|
|
|
|
Int64: 6,
|
|
|
|
Uint: 7,
|
|
|
|
Uint8: 8,
|
|
|
|
Uint16: 9,
|
|
|
|
Uint32: 10,
|
|
|
|
Uint64: 11,
|
|
|
|
Float32: 12.1,
|
|
|
|
Float64: 13.1,
|
|
|
|
String: "14"}
|
|
|
|
|
|
|
|
err := Unmarshal(jsonData, &nulls)
|
|
|
|
if err != nil {
|
|
|
|
t.Errorf("Unmarshal of null values failed: %v", err)
|
|
|
|
}
|
|
|
|
if !nulls.Bool || nulls.Int != 2 || nulls.Int8 != 3 || nulls.Int16 != 4 || nulls.Int32 != 5 || nulls.Int64 != 6 ||
|
|
|
|
nulls.Uint != 7 || nulls.Uint8 != 8 || nulls.Uint16 != 9 || nulls.Uint32 != 10 || nulls.Uint64 != 11 ||
|
|
|
|
nulls.Float32 != 12.1 || nulls.Float64 != 13.1 || nulls.String != "14" {
|
|
|
|
|
|
|
|
t.Errorf("Unmarshal of null values affected primitives")
|
|
|
|
}
|
|
|
|
}
|
2012-12-29 21:40:42 -07:00
|
|
|
|
|
|
|
func TestStringKind(t *testing.T) {
|
|
|
|
type stringKind string
|
|
|
|
|
|
|
|
var m1, m2 map[stringKind]int
|
|
|
|
m1 = map[stringKind]int{
|
|
|
|
"foo": 42,
|
|
|
|
}
|
|
|
|
|
|
|
|
data, err := Marshal(m1)
|
|
|
|
if err != nil {
|
|
|
|
t.Errorf("Unexpected error marshalling: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
err = Unmarshal(data, &m2)
|
|
|
|
if err != nil {
|
|
|
|
t.Errorf("Unexpected error unmarshalling: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
if !reflect.DeepEqual(m1, m2) {
|
|
|
|
t.Error("Items should be equal after encoding and then decoding")
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
2013-01-14 00:44:16 -07:00
|
|
|
|
|
|
|
var decodeTypeErrorTests = []struct {
|
|
|
|
dest interface{}
|
|
|
|
src string
|
|
|
|
}{
|
|
|
|
{new(string), `{"user": "name"}`}, // issue 4628.
|
|
|
|
{new(error), `{}`}, // issue 4222
|
|
|
|
{new(error), `[]`},
|
|
|
|
{new(error), `""`},
|
|
|
|
{new(error), `123`},
|
|
|
|
{new(error), `true`},
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestUnmarshalTypeError(t *testing.T) {
|
|
|
|
for _, item := range decodeTypeErrorTests {
|
|
|
|
err := Unmarshal([]byte(item.src), item.dest)
|
|
|
|
if _, ok := err.(*UnmarshalTypeError); !ok {
|
2013-01-29 14:34:18 -07:00
|
|
|
t.Errorf("expected type error for Unmarshal(%q, type %T): got %T",
|
2013-01-14 00:44:16 -07:00
|
|
|
item.src, item.dest, err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2013-01-22 15:49:07 -07:00
|
|
|
|
2013-01-29 14:34:18 -07:00
|
|
|
var unmarshalSyntaxTests = []string{
|
|
|
|
"tru",
|
|
|
|
"fals",
|
|
|
|
"nul",
|
|
|
|
"123e",
|
|
|
|
`"hello`,
|
|
|
|
`[1,2,3`,
|
|
|
|
`{"key":1`,
|
|
|
|
`{"key":1,`,
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestUnmarshalSyntax(t *testing.T) {
|
|
|
|
var x interface{}
|
|
|
|
for _, src := range unmarshalSyntaxTests {
|
|
|
|
err := Unmarshal([]byte(src), &x)
|
|
|
|
if _, ok := err.(*SyntaxError); !ok {
|
|
|
|
t.Errorf("expected syntax error for Unmarshal(%q): got %T", src, err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-22 15:49:07 -07:00
|
|
|
// Test handling of unexported fields that should be ignored.
|
|
|
|
// Issue 4660
|
|
|
|
type unexportedFields struct {
|
|
|
|
Name string
|
|
|
|
m map[string]interface{} `json:"-"`
|
|
|
|
m2 map[string]interface{} `json:"abcd"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestUnmarshalUnexported(t *testing.T) {
|
|
|
|
input := `{"Name": "Bob", "m": {"x": 123}, "m2": {"y": 456}, "abcd": {"z": 789}}`
|
|
|
|
want := &unexportedFields{Name: "Bob"}
|
|
|
|
|
|
|
|
out := &unexportedFields{}
|
|
|
|
err := Unmarshal([]byte(input), out)
|
|
|
|
if err != nil {
|
|
|
|
t.Errorf("got error %v, expected nil", err)
|
|
|
|
}
|
|
|
|
if !reflect.DeepEqual(out, want) {
|
|
|
|
t.Errorf("got %q, want %q", out, want)
|
|
|
|
}
|
|
|
|
}
|
2013-02-14 12:46:15 -07:00
|
|
|
|
|
|
|
// Time3339 is a time.Time which encodes to and from JSON
|
|
|
|
// as an RFC 3339 time in UTC.
|
|
|
|
type Time3339 time.Time
|
|
|
|
|
|
|
|
func (t *Time3339) UnmarshalJSON(b []byte) error {
|
|
|
|
if len(b) < 2 || b[0] != '"' || b[len(b)-1] != '"' {
|
2013-02-25 13:43:03 -07:00
|
|
|
return fmt.Errorf("types: failed to unmarshal non-string value %q as an RFC 3339 time", b)
|
2013-02-14 12:46:15 -07:00
|
|
|
}
|
|
|
|
tm, err := time.Parse(time.RFC3339, string(b[1:len(b)-1]))
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
*t = Time3339(tm)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestUnmarshalJSONLiteralError(t *testing.T) {
|
|
|
|
var t3 Time3339
|
|
|
|
err := Unmarshal([]byte(`"0000-00-00T00:00:00Z"`), &t3)
|
|
|
|
if err == nil {
|
|
|
|
t.Fatalf("expected error; got time %v", time.Time(t3))
|
|
|
|
}
|
|
|
|
if !strings.Contains(err.Error(), "range") {
|
|
|
|
t.Errorf("got err = %v; want out of range error", err)
|
|
|
|
}
|
|
|
|
}
|
2013-03-13 12:53:03 -06:00
|
|
|
|
|
|
|
// Test that extra object elements in an array do not result in a
|
|
|
|
// "data changing underfoot" error.
|
|
|
|
// Issue 3717
|
|
|
|
func TestSkipArrayObjects(t *testing.T) {
|
|
|
|
json := `[{}]`
|
|
|
|
var dest [0]interface{}
|
|
|
|
|
|
|
|
err := Unmarshal([]byte(json), &dest)
|
|
|
|
if err != nil {
|
|
|
|
t.Errorf("got error %q, want nil", err)
|
|
|
|
}
|
|
|
|
}
|