1// Copyright 2010 The Go Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style
3// license that can be found in the LICENSE file.
4
5package json
6
7import (
8	"bytes"
9	"encoding"
10	"errors"
11	"fmt"
12	"image"
13	"math"
14	"net"
15	"reflect"
16	"strconv"
17	"strings"
18	"testing"
19	"time"
20)
21
22type T struct {
23	X string
24	Y int
25	Z int `json:"-"`
26}
27
28type U struct {
29	Alphabet string `json:"alpha"`
30}
31
32type V struct {
33	F1 interface{}
34	F2 int32
35	F3 Number
36}
37
38// ifaceNumAsBasicTypes/ifaceNumAsNumber are used to test unmarshaling with and
39// without UseNumber
40var ifaceNumAsBasicTypes = map[string]interface{}{
41	"k1": int64(1),
42	"k2": "s",
43	"k3": []interface{}{int64(1), float64(2.5), float64(3e-3)},
44	"k4": map[string]interface{}{"kk1": "s", "kk2": int64(2)},
45}
46
47var ifaceNumAsNumber = map[string]interface{}{
48	"k1": Number("1"),
49	"k2": "s",
50	"k3": []interface{}{Number("1"), Number("2.5"), Number("3e-3")},
51	"k4": map[string]interface{}{"kk1": "s", "kk2": Number("2")},
52}
53
54type tx struct {
55	x int
56}
57
58type u8 uint8
59
60// A type that can unmarshal itself.
61
62type unmarshaler struct {
63	T bool
64}
65
66func (u *unmarshaler) UnmarshalJSON(b []byte) error {
67	*u = unmarshaler{true} // All we need to see that UnmarshalJSON is called.
68	return nil
69}
70
71type ustruct struct {
72	M unmarshaler
73}
74
75type unmarshalerText struct {
76	A, B string
77}
78
79// needed for re-marshaling tests
80func (u unmarshalerText) MarshalText() ([]byte, error) {
81	return []byte(u.A + ":" + u.B), nil
82}
83
84func (u *unmarshalerText) UnmarshalText(b []byte) error {
85	pos := bytes.Index(b, []byte(":"))
86	if pos == -1 {
87		return errors.New("missing separator")
88	}
89	u.A, u.B = string(b[:pos]), string(b[pos+1:])
90	return nil
91}
92
93var _ encoding.TextUnmarshaler = (*unmarshalerText)(nil)
94
95type ustructText struct {
96	M unmarshalerText
97}
98
99// u8marshal is an integer type that can marshal/unmarshal itself.
100type u8marshal uint8
101
102func (u8 u8marshal) MarshalText() ([]byte, error) {
103	return []byte(fmt.Sprintf("u%d", u8)), nil
104}
105
106var errMissingU8Prefix = errors.New("missing 'u' prefix")
107
108func (u8 *u8marshal) UnmarshalText(b []byte) error {
109	if !bytes.HasPrefix(b, []byte{'u'}) {
110		return errMissingU8Prefix
111	}
112	n, err := strconv.Atoi(string(b[1:]))
113	if err != nil {
114		return err
115	}
116	*u8 = u8marshal(n)
117	return nil
118}
119
120var _ encoding.TextUnmarshaler = (*u8marshal)(nil)
121
122var (
123	um0, um1 unmarshaler // target2 of unmarshaling
124	ump      = &um1
125	umtrue   = unmarshaler{true}
126	umslice  = []unmarshaler{{true}}
127	umslicep = new([]unmarshaler)
128	umstruct = ustruct{unmarshaler{true}}
129
130	um0T, um1T   unmarshalerText // target2 of unmarshaling
131	umpType      = &um1T
132	umtrueXY     = unmarshalerText{"x", "y"}
133	umsliceXY    = []unmarshalerText{{"x", "y"}}
134	umslicepType = new([]unmarshalerText)
135	umstructType = new(ustructText)
136	umstructXY   = ustructText{unmarshalerText{"x", "y"}}
137
138	ummapType = map[unmarshalerText]bool{}
139	ummapXY   = map[unmarshalerText]bool{unmarshalerText{"x", "y"}: true}
140)
141
142// Test data structures for anonymous fields.
143
144type Point struct {
145	Z int
146}
147
148type Top struct {
149	Level0 int
150	Embed0
151	*Embed0a
152	*Embed0b `json:"e,omitempty"` // treated as named
153	Embed0c  `json:"-"`           // ignored
154	Loop
155	Embed0p // has Point with X, Y, used
156	Embed0q // has Point with Z, used
157	embed   // contains exported field
158}
159
160type Embed0 struct {
161	Level1a int // overridden by Embed0a's Level1a with json tag
162	Level1b int // used because Embed0a's Level1b is renamed
163	Level1c int // used because Embed0a's Level1c is ignored
164	Level1d int // annihilated by Embed0a's Level1d
165	Level1e int `json:"x"` // annihilated by Embed0a.Level1e
166}
167
168type Embed0a struct {
169	Level1a int `json:"Level1a,omitempty"`
170	Level1b int `json:"LEVEL1B,omitempty"`
171	Level1c int `json:"-"`
172	Level1d int // annihilated by Embed0's Level1d
173	Level1f int `json:"x"` // annihilated by Embed0's Level1e
174}
175
176type Embed0b Embed0
177
178type Embed0c Embed0
179
180type Embed0p struct {
181	image.Point
182}
183
184type Embed0q struct {
185	Point
186}
187
188type embed struct {
189	Q int
190}
191
192type Loop struct {
193	Loop1 int `json:",omitempty"`
194	Loop2 int `json:",omitempty"`
195	*Loop
196}
197
198// From reflect test:
199// The X in S6 and S7 annihilate, but they also block the X in S8.S9.
200type S5 struct {
201	S6
202	S7
203	S8
204}
205
206type S6 struct {
207	X int
208}
209
210type S7 S6
211
212type S8 struct {
213	S9
214}
215
216type S9 struct {
217	X int
218	Y int
219}
220
221// From reflect test:
222// The X in S11.S6 and S12.S6 annihilate, but they also block the X in S13.S8.S9.
223type S10 struct {
224	S11
225	S12
226	S13
227}
228
229type S11 struct {
230	S6
231}
232
233type S12 struct {
234	S6
235}
236
237type S13 struct {
238	S8
239}
240
241type Ambig struct {
242	// Given "hello", the first match should win.
243	First  int `json:"HELLO"`
244	Second int `json:"Hello"`
245}
246
247type XYZ struct {
248	X interface{}
249	Y interface{}
250	Z interface{}
251}
252
253func sliceAddr(x []int) *[]int                 { return &x }
254func mapAddr(x map[string]int) *map[string]int { return &x }
255
256type byteWithMarshalJSON byte
257
258func (b byteWithMarshalJSON) MarshalJSON() ([]byte, error) {
259	return []byte(fmt.Sprintf(`"Z%.2x"`, byte(b))), nil
260}
261
262func (b *byteWithMarshalJSON) UnmarshalJSON(data []byte) error {
263	if len(data) != 5 || data[0] != '"' || data[1] != 'Z' || data[4] != '"' {
264		return fmt.Errorf("bad quoted string")
265	}
266	i, err := strconv.ParseInt(string(data[2:4]), 16, 8)
267	if err != nil {
268		return fmt.Errorf("bad hex")
269	}
270	*b = byteWithMarshalJSON(i)
271	return nil
272}
273
274type byteWithPtrMarshalJSON byte
275
276func (b *byteWithPtrMarshalJSON) MarshalJSON() ([]byte, error) {
277	return byteWithMarshalJSON(*b).MarshalJSON()
278}
279
280func (b *byteWithPtrMarshalJSON) UnmarshalJSON(data []byte) error {
281	return (*byteWithMarshalJSON)(b).UnmarshalJSON(data)
282}
283
284type byteWithMarshalText byte
285
286func (b byteWithMarshalText) MarshalText() ([]byte, error) {
287	return []byte(fmt.Sprintf(`Z%.2x`, byte(b))), nil
288}
289
290func (b *byteWithMarshalText) UnmarshalText(data []byte) error {
291	if len(data) != 3 || data[0] != 'Z' {
292		return fmt.Errorf("bad quoted string")
293	}
294	i, err := strconv.ParseInt(string(data[1:3]), 16, 8)
295	if err != nil {
296		return fmt.Errorf("bad hex")
297	}
298	*b = byteWithMarshalText(i)
299	return nil
300}
301
302type byteWithPtrMarshalText byte
303
304func (b *byteWithPtrMarshalText) MarshalText() ([]byte, error) {
305	return byteWithMarshalText(*b).MarshalText()
306}
307
308func (b *byteWithPtrMarshalText) UnmarshalText(data []byte) error {
309	return (*byteWithMarshalText)(b).UnmarshalText(data)
310}
311
312type intWithMarshalJSON int
313
314func (b intWithMarshalJSON) MarshalJSON() ([]byte, error) {
315	return []byte(fmt.Sprintf(`"Z%.2x"`, int(b))), nil
316}
317
318func (b *intWithMarshalJSON) UnmarshalJSON(data []byte) error {
319	if len(data) != 5 || data[0] != '"' || data[1] != 'Z' || data[4] != '"' {
320		return fmt.Errorf("bad quoted string")
321	}
322	i, err := strconv.ParseInt(string(data[2:4]), 16, 8)
323	if err != nil {
324		return fmt.Errorf("bad hex")
325	}
326	*b = intWithMarshalJSON(i)
327	return nil
328}
329
330type intWithPtrMarshalJSON int
331
332func (b *intWithPtrMarshalJSON) MarshalJSON() ([]byte, error) {
333	return intWithMarshalJSON(*b).MarshalJSON()
334}
335
336func (b *intWithPtrMarshalJSON) UnmarshalJSON(data []byte) error {
337	return (*intWithMarshalJSON)(b).UnmarshalJSON(data)
338}
339
340type intWithMarshalText int
341
342func (b intWithMarshalText) MarshalText() ([]byte, error) {
343	return []byte(fmt.Sprintf(`Z%.2x`, int(b))), nil
344}
345
346func (b *intWithMarshalText) UnmarshalText(data []byte) error {
347	if len(data) != 3 || data[0] != 'Z' {
348		return fmt.Errorf("bad quoted string")
349	}
350	i, err := strconv.ParseInt(string(data[1:3]), 16, 8)
351	if err != nil {
352		return fmt.Errorf("bad hex")
353	}
354	*b = intWithMarshalText(i)
355	return nil
356}
357
358type intWithPtrMarshalText int
359
360func (b *intWithPtrMarshalText) MarshalText() ([]byte, error) {
361	return intWithMarshalText(*b).MarshalText()
362}
363
364func (b *intWithPtrMarshalText) UnmarshalText(data []byte) error {
365	return (*intWithMarshalText)(b).UnmarshalText(data)
366}
367
368type unmarshalTest struct {
369	in        string
370	ptr       interface{}
371	out       interface{}
372	err       error
373	useNumber bool
374	golden    bool
375}
376
377var unmarshalTests = []unmarshalTest{
378	// basic types
379	{in: `true`, ptr: new(bool), out: true},
380	{in: `1`, ptr: new(int), out: 1},
381	{in: `1.2`, ptr: new(float64), out: 1.2},
382	{in: `-5`, ptr: new(int16), out: int16(-5)},
383	{in: `2`, ptr: new(Number), out: Number("2"), useNumber: true},
384	{in: `2`, ptr: new(Number), out: Number("2")},
385	{in: `2`, ptr: new(interface{}), out: int64(2)},
386	{in: `2`, ptr: new(interface{}), out: Number("2"), useNumber: true},
387	{in: `"a\u1234"`, ptr: new(string), out: "a\u1234"},
388	{in: `"http:\/\/"`, ptr: new(string), out: "http://"},
389	{in: `"g-clef: \uD834\uDD1E"`, ptr: new(string), out: "g-clef: \U0001D11E"},
390	{in: `"invalid: \uD834x\uDD1E"`, ptr: new(string), out: "invalid: \uFFFDx\uFFFD"},
391	{in: "null", ptr: new(interface{}), out: nil},
392	{in: `{"X": [1,2,3], "Y": 4}`, ptr: new(T), out: T{Y: 4}, err: &UnmarshalTypeError{"array", reflect.TypeOf(""), 7}},
393	{in: `{"x": 1}`, ptr: new(tx), out: tx{}},
394	{in: `{"F1":1,"F2":2,"F3":3}`, ptr: new(V), out: V{F1: int64(1), F2: int32(2), F3: Number("3")}},
395	{in: `{"F1":1,"F2":2,"F3":3}`, ptr: new(V), out: V{F1: Number("1"), F2: int32(2), F3: Number("3")}, useNumber: true},
396	{in: `{"k1":1,"k2":"s","k3":[1,2.5,3e-3],"k4":{"kk1":"s","kk2":2}}`, ptr: new(interface{}), out: ifaceNumAsBasicTypes},
397	{in: `{"k1":1,"k2":"s","k3":[1,2.5,3e-3],"k4":{"kk1":"s","kk2":2}}`, ptr: new(interface{}), out: ifaceNumAsNumber, useNumber: true},
398
399	// raw values with whitespace
400	{in: "\n true ", ptr: new(bool), out: true},
401	{in: "\t 1 ", ptr: new(int), out: 1},
402	{in: "\r 1.2 ", ptr: new(float64), out: 1.2},
403	{in: "\t -5 \n", ptr: new(int16), out: int16(-5)},
404	{in: "\t \"a\\u1234\" \n", ptr: new(string), out: "a\u1234"},
405
406	// Z has a "-" tag.
407	{in: `{"Y": 1, "Z": 2}`, ptr: new(T), out: T{Y: 1}},
408
409	{in: `{"alpha": "abc", "alphabet": "xyz"}`, ptr: new(U), out: U{Alphabet: "abc"}},
410	{in: `{"alpha": "abc"}`, ptr: new(U), out: U{Alphabet: "abc"}},
411	{in: `{"alphabet": "xyz"}`, ptr: new(U), out: U{}},
412
413	// syntax errors
414	{in: `{"X": "foo", "Y"}`, err: &SyntaxError{"invalid character '}' after object key", 17}},
415	{in: `[1, 2, 3+]`, err: &SyntaxError{"invalid character '+' after array element", 9}},
416	{in: `{"X":12x}`, err: &SyntaxError{"invalid character 'x' after object key:value pair", 8}, useNumber: true},
417
418	// raw value errors
419	{in: "\x01 42", err: &SyntaxError{"invalid character '\\x01' looking for beginning of value", 1}},
420	{in: " 42 \x01", err: &SyntaxError{"invalid character '\\x01' after top-level value", 5}},
421	{in: "\x01 true", err: &SyntaxError{"invalid character '\\x01' looking for beginning of value", 1}},
422	{in: " false \x01", err: &SyntaxError{"invalid character '\\x01' after top-level value", 8}},
423	{in: "\x01 1.2", err: &SyntaxError{"invalid character '\\x01' looking for beginning of value", 1}},
424	{in: " 3.4 \x01", err: &SyntaxError{"invalid character '\\x01' after top-level value", 6}},
425	{in: "\x01 \"string\"", err: &SyntaxError{"invalid character '\\x01' looking for beginning of value", 1}},
426	{in: " \"string\" \x01", err: &SyntaxError{"invalid character '\\x01' after top-level value", 11}},
427
428	// array tests
429	{in: `[1, 2, 3]`, ptr: new([3]int), out: [3]int{1, 2, 3}},
430	{in: `[1, 2, 3]`, ptr: new([1]int), out: [1]int{1}},
431	{in: `[1, 2, 3]`, ptr: new([5]int), out: [5]int{1, 2, 3, 0, 0}},
432
433	// empty array to interface test
434	{in: `[]`, ptr: new([]interface{}), out: []interface{}{}},
435	{in: `null`, ptr: new([]interface{}), out: []interface{}(nil)},
436	{in: `{"T":[]}`, ptr: new(map[string]interface{}), out: map[string]interface{}{"T": []interface{}{}}},
437	{in: `{"T":null}`, ptr: new(map[string]interface{}), out: map[string]interface{}{"T": interface{}(nil)}},
438
439	// composite tests
440	{in: allValueIndent, ptr: new(All), out: allValue},
441	{in: allValueCompact, ptr: new(All), out: allValue},
442	{in: allValueIndent, ptr: new(*All), out: &allValue},
443	{in: allValueCompact, ptr: new(*All), out: &allValue},
444	{in: pallValueIndent, ptr: new(All), out: pallValue},
445	{in: pallValueCompact, ptr: new(All), out: pallValue},
446	{in: pallValueIndent, ptr: new(*All), out: &pallValue},
447	{in: pallValueCompact, ptr: new(*All), out: &pallValue},
448
449	// unmarshal interface test
450	{in: `{"T":false}`, ptr: &um0, out: umtrue}, // use "false" so test will fail if custom unmarshaler is not called
451	{in: `{"T":false}`, ptr: &ump, out: &umtrue},
452	{in: `[{"T":false}]`, ptr: &umslice, out: umslice},
453	{in: `[{"T":false}]`, ptr: &umslicep, out: &umslice},
454	{in: `{"M":{"T":"x:y"}}`, ptr: &umstruct, out: umstruct},
455
456	// UnmarshalText interface test
457	{in: `"x:y"`, ptr: &um0T, out: umtrueXY},
458	{in: `"x:y"`, ptr: &umpType, out: &umtrueXY},
459	{in: `["x:y"]`, ptr: &umsliceXY, out: umsliceXY},
460	{in: `["x:y"]`, ptr: &umslicepType, out: &umsliceXY},
461	{in: `{"M":"x:y"}`, ptr: umstructType, out: umstructXY},
462
463	// integer-keyed map test
464	{
465		in:  `{"-1":"a","0":"b","1":"c"}`,
466		ptr: new(map[int]string),
467		out: map[int]string{-1: "a", 0: "b", 1: "c"},
468	},
469	{
470		in:  `{"0":"a","10":"c","9":"b"}`,
471		ptr: new(map[u8]string),
472		out: map[u8]string{0: "a", 9: "b", 10: "c"},
473	},
474	{
475		in:  `{"-9223372036854775808":"min","9223372036854775807":"max"}`,
476		ptr: new(map[int64]string),
477		out: map[int64]string{math.MinInt64: "min", math.MaxInt64: "max"},
478	},
479	{
480		in:  `{"18446744073709551615":"max"}`,
481		ptr: new(map[uint64]string),
482		out: map[uint64]string{math.MaxUint64: "max"},
483	},
484	{
485		in:  `{"0":false,"10":true}`,
486		ptr: new(map[uintptr]bool),
487		out: map[uintptr]bool{0: false, 10: true},
488	},
489
490	// Check that MarshalText and UnmarshalText take precedence
491	// over default integer handling in map keys.
492	{
493		in:  `{"u2":4}`,
494		ptr: new(map[u8marshal]int),
495		out: map[u8marshal]int{2: 4},
496	},
497	{
498		in:  `{"2":4}`,
499		ptr: new(map[u8marshal]int),
500		err: errMissingU8Prefix,
501	},
502
503	// integer-keyed map errors
504	{
505		in:  `{"abc":"abc"}`,
506		ptr: new(map[int]string),
507		err: &UnmarshalTypeError{"number abc", reflect.TypeOf(0), 2},
508	},
509	{
510		in:  `{"256":"abc"}`,
511		ptr: new(map[uint8]string),
512		err: &UnmarshalTypeError{"number 256", reflect.TypeOf(uint8(0)), 2},
513	},
514	{
515		in:  `{"128":"abc"}`,
516		ptr: new(map[int8]string),
517		err: &UnmarshalTypeError{"number 128", reflect.TypeOf(int8(0)), 2},
518	},
519	{
520		in:  `{"-1":"abc"}`,
521		ptr: new(map[uint8]string),
522		err: &UnmarshalTypeError{"number -1", reflect.TypeOf(uint8(0)), 2},
523	},
524
525	// Map keys can be encoding.TextUnmarshalers.
526	{in: `{"x:y":true}`, ptr: &ummapType, out: ummapXY},
527	// If multiple values for the same key exists, only the most recent value is used.
528	{in: `{"x:y":false,"x:y":true}`, ptr: &ummapType, out: ummapXY},
529
530	// Overwriting of data.
531	// This is different from package xml, but it's what we've always done.
532	// Now documented and tested.
533	{in: `[2]`, ptr: sliceAddr([]int{1}), out: []int{2}},
534	{in: `{"key": 2}`, ptr: mapAddr(map[string]int{"old": 0, "key": 1}), out: map[string]int{"key": 2}},
535
536	{
537		in: `{
538			"Level0": 1,
539			"Level1b": 2,
540			"Level1c": 3,
541			"x": 4,
542			"Level1a": 5,
543			"LEVEL1B": 6,
544			"e": {
545				"Level1a": 8,
546				"Level1b": 9,
547				"Level1c": 10,
548				"Level1d": 11,
549				"x": 12
550			},
551			"Loop1": 13,
552			"Loop2": 14,
553			"X": 15,
554			"Y": 16,
555			"Z": 17,
556			"Q": 18
557		}`,
558		ptr: new(Top),
559		out: Top{
560			Level0: 1,
561			Embed0: Embed0{
562				Level1b: 2,
563				Level1c: 3,
564			},
565			Embed0a: &Embed0a{
566				Level1a: 5,
567				Level1b: 6,
568			},
569			Embed0b: &Embed0b{
570				Level1a: 8,
571				Level1b: 9,
572				Level1c: 10,
573				Level1d: 11,
574				Level1e: 12,
575			},
576			Loop: Loop{
577				Loop1: 13,
578				Loop2: 14,
579			},
580			Embed0p: Embed0p{
581				Point: image.Point{X: 15, Y: 16},
582			},
583			Embed0q: Embed0q{
584				Point: Point{Z: 17},
585			},
586			embed: embed{
587				Q: 18,
588			},
589		},
590	},
591	{
592		in:  `{"hello": 1}`,
593		ptr: new(Ambig),
594		out: Ambig{First: 1},
595	},
596
597	{
598		in:  `{"X": 1,"Y":2}`,
599		ptr: new(S5),
600		out: S5{S8: S8{S9: S9{Y: 2}}},
601	},
602	{
603		in:  `{"X": 1,"Y":2}`,
604		ptr: new(S10),
605		out: S10{S13: S13{S8: S8{S9: S9{Y: 2}}}},
606	},
607
608	// invalid UTF-8 is coerced to valid UTF-8.
609	{
610		in:  "\"hello\xffworld\"",
611		ptr: new(string),
612		out: "hello\ufffdworld",
613	},
614	{
615		in:  "\"hello\xc2\xc2world\"",
616		ptr: new(string),
617		out: "hello\ufffd\ufffdworld",
618	},
619	{
620		in:  "\"hello\xc2\xffworld\"",
621		ptr: new(string),
622		out: "hello\ufffd\ufffdworld",
623	},
624	{
625		in:  "\"hello\\ud800world\"",
626		ptr: new(string),
627		out: "hello\ufffdworld",
628	},
629	{
630		in:  "\"hello\\ud800\\ud800world\"",
631		ptr: new(string),
632		out: "hello\ufffd\ufffdworld",
633	},
634	{
635		in:  "\"hello\\ud800\\ud800world\"",
636		ptr: new(string),
637		out: "hello\ufffd\ufffdworld",
638	},
639	{
640		in:  "\"hello\xed\xa0\x80\xed\xb0\x80world\"",
641		ptr: new(string),
642		out: "hello\ufffd\ufffd\ufffd\ufffd\ufffd\ufffdworld",
643	},
644
645	// Used to be issue 8305, but time.Time implements encoding.TextUnmarshaler so this works now.
646	{
647		in:  `{"2009-11-10T23:00:00Z": "hello world"}`,
648		ptr: &map[time.Time]string{},
649		out: map[time.Time]string{time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC): "hello world"},
650	},
651
652	// issue 8305
653	{
654		in:  `{"2009-11-10T23:00:00Z": "hello world"}`,
655		ptr: &map[Point]string{},
656		err: &UnmarshalTypeError{"object", reflect.TypeOf(map[Point]string{}), 1},
657	},
658	{
659		in:  `{"asdf": "hello world"}`,
660		ptr: &map[unmarshaler]string{},
661		err: &UnmarshalTypeError{"object", reflect.TypeOf(map[unmarshaler]string{}), 1},
662	},
663
664	// related to issue 13783.
665	// Go 1.7 changed marshaling a slice of typed byte to use the methods on the byte type,
666	// similar to marshaling a slice of typed int.
667	// These tests check that, assuming the byte type also has valid decoding methods,
668	// either the old base64 string encoding or the new per-element encoding can be
669	// successfully unmarshaled. The custom unmarshalers were accessible in earlier
670	// versions of Go, even though the custom marshaler was not.
671	{
672		in:  `"AQID"`,
673		ptr: new([]byteWithMarshalJSON),
674		out: []byteWithMarshalJSON{1, 2, 3},
675	},
676	{
677		in:     `["Z01","Z02","Z03"]`,
678		ptr:    new([]byteWithMarshalJSON),
679		out:    []byteWithMarshalJSON{1, 2, 3},
680		golden: true,
681	},
682	{
683		in:  `"AQID"`,
684		ptr: new([]byteWithMarshalText),
685		out: []byteWithMarshalText{1, 2, 3},
686	},
687	{
688		in:     `["Z01","Z02","Z03"]`,
689		ptr:    new([]byteWithMarshalText),
690		out:    []byteWithMarshalText{1, 2, 3},
691		golden: true,
692	},
693	{
694		in:  `"AQID"`,
695		ptr: new([]byteWithPtrMarshalJSON),
696		out: []byteWithPtrMarshalJSON{1, 2, 3},
697	},
698	{
699		in:     `["Z01","Z02","Z03"]`,
700		ptr:    new([]byteWithPtrMarshalJSON),
701		out:    []byteWithPtrMarshalJSON{1, 2, 3},
702		golden: true,
703	},
704	{
705		in:  `"AQID"`,
706		ptr: new([]byteWithPtrMarshalText),
707		out: []byteWithPtrMarshalText{1, 2, 3},
708	},
709	{
710		in:     `["Z01","Z02","Z03"]`,
711		ptr:    new([]byteWithPtrMarshalText),
712		out:    []byteWithPtrMarshalText{1, 2, 3},
713		golden: true,
714	},
715
716	// ints work with the marshaler but not the base64 []byte case
717	{
718		in:     `["Z01","Z02","Z03"]`,
719		ptr:    new([]intWithMarshalJSON),
720		out:    []intWithMarshalJSON{1, 2, 3},
721		golden: true,
722	},
723	{
724		in:     `["Z01","Z02","Z03"]`,
725		ptr:    new([]intWithMarshalText),
726		out:    []intWithMarshalText{1, 2, 3},
727		golden: true,
728	},
729	{
730		in:     `["Z01","Z02","Z03"]`,
731		ptr:    new([]intWithPtrMarshalJSON),
732		out:    []intWithPtrMarshalJSON{1, 2, 3},
733		golden: true,
734	},
735	{
736		in:     `["Z01","Z02","Z03"]`,
737		ptr:    new([]intWithPtrMarshalText),
738		out:    []intWithPtrMarshalText{1, 2, 3},
739		golden: true,
740	},
741}
742
743func TestMarshal(t *testing.T) {
744	b, err := Marshal(allValue)
745	if err != nil {
746		t.Fatalf("Marshal allValue: %v", err)
747	}
748	if string(b) != allValueCompact {
749		t.Errorf("Marshal allValueCompact")
750		diff(t, b, []byte(allValueCompact))
751		return
752	}
753
754	b, err = Marshal(pallValue)
755	if err != nil {
756		t.Fatalf("Marshal pallValue: %v", err)
757	}
758	if string(b) != pallValueCompact {
759		t.Errorf("Marshal pallValueCompact")
760		diff(t, b, []byte(pallValueCompact))
761		return
762	}
763}
764
765var badUTF8 = []struct {
766	in, out string
767}{
768	{"hello\xffworld", `"hello\ufffdworld"`},
769	{"", `""`},
770	{"\xff", `"\ufffd"`},
771	{"\xff\xff", `"\ufffd\ufffd"`},
772	{"a\xffb", `"a\ufffdb"`},
773	{"\xe6\x97\xa5\xe6\x9c\xac\xff\xaa\x9e", `"日本\ufffd\ufffd\ufffd"`},
774}
775
776func TestMarshalBadUTF8(t *testing.T) {
777	for _, tt := range badUTF8 {
778		b, err := Marshal(tt.in)
779		if string(b) != tt.out || err != nil {
780			t.Errorf("Marshal(%q) = %#q, %v, want %#q, nil", tt.in, b, err, tt.out)
781		}
782	}
783}
784
785func TestMarshalNumberZeroVal(t *testing.T) {
786	var n Number
787	out, err := Marshal(n)
788	if err != nil {
789		t.Fatal(err)
790	}
791	outStr := string(out)
792	if outStr != "0" {
793		t.Fatalf("Invalid zero val for Number: %q", outStr)
794	}
795}
796
797func TestMarshalEmbeds(t *testing.T) {
798	top := &Top{
799		Level0: 1,
800		Embed0: Embed0{
801			Level1b: 2,
802			Level1c: 3,
803		},
804		Embed0a: &Embed0a{
805			Level1a: 5,
806			Level1b: 6,
807		},
808		Embed0b: &Embed0b{
809			Level1a: 8,
810			Level1b: 9,
811			Level1c: 10,
812			Level1d: 11,
813			Level1e: 12,
814		},
815		Loop: Loop{
816			Loop1: 13,
817			Loop2: 14,
818		},
819		Embed0p: Embed0p{
820			Point: image.Point{X: 15, Y: 16},
821		},
822		Embed0q: Embed0q{
823			Point: Point{Z: 17},
824		},
825		embed: embed{
826			Q: 18,
827		},
828	}
829	b, err := Marshal(top)
830	if err != nil {
831		t.Fatal(err)
832	}
833	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,\"Q\":18}"
834	if string(b) != want {
835		t.Errorf("Wrong marshal result.\n got: %q\nwant: %q", b, want)
836	}
837}
838
839func TestUnmarshal(t *testing.T) {
840	for i, tt := range unmarshalTests {
841		in := []byte(tt.in)
842		scan := newScanner(in)
843		if err := checkValid(in, scan); err != nil {
844			if !reflect.DeepEqual(err, tt.err) {
845				t.Errorf("#%d: checkValid: %#v", i, err)
846				continue
847			}
848		}
849		if tt.ptr == nil {
850			continue
851		}
852
853		// v = new(right-type)
854		v := reflect.New(reflect.TypeOf(tt.ptr).Elem())
855		dec := NewDecoder(bytes.NewReader(in))
856		if tt.useNumber {
857			dec.UseNumber()
858		}
859		if err := dec.Decode(v.Interface()); !reflect.DeepEqual(err, tt.err) {
860			t.Errorf("#%d: %q %v, want %v", i, tt.in, err, tt.err)
861			continue
862		} else if err != nil {
863			continue
864		}
865		if !reflect.DeepEqual(v.Elem().Interface(), tt.out) {
866			t.Errorf("#%d: mismatch\nhave: %#+v\nwant: %#+v", i, v.Elem().Interface(), tt.out)
867			data, _ := Marshal(v.Elem().Interface())
868			println(string(data))
869			data, _ = Marshal(tt.out)
870			println(string(data))
871			continue
872		}
873
874		// Check round trip also decodes correctly.
875		if tt.err == nil {
876			enc, err := Marshal(v.Interface())
877			if err != nil {
878				t.Errorf("#%d: error re-marshaling: %v", i, err)
879				continue
880			}
881			if tt.golden && !bytes.Equal(enc, in) {
882				t.Errorf("#%d: remarshal mismatch:\nhave: %s\nwant: %s", i, enc, in)
883			}
884			vv := reflect.New(reflect.TypeOf(tt.ptr).Elem())
885			dec = NewDecoder(bytes.NewReader(enc))
886			if tt.useNumber {
887				dec.UseNumber()
888			}
889			if err := dec.Decode(vv.Interface()); err != nil {
890				t.Errorf("#%d: error re-unmarshaling %#q: %v", i, enc, err)
891				continue
892			}
893			if !reflect.DeepEqual(v.Elem().Interface(), vv.Elem().Interface()) {
894				t.Errorf("#%d: mismatch\nhave: %#+v\nwant: %#+v", i, v.Elem().Interface(), vv.Elem().Interface())
895				t.Errorf("     In: %q", strings.Map(noSpace, string(in)))
896				t.Errorf("Marshal: %q", strings.Map(noSpace, string(enc)))
897				continue
898			}
899		}
900	}
901}
902
903func TestUnmarshalMarshal(t *testing.T) {
904	initBig()
905	var v interface{}
906	if err := Unmarshal(jsonBig, &v); err != nil {
907		t.Fatalf("Unmarshal: %v", err)
908	}
909	b, err := Marshal(v)
910	if err != nil {
911		t.Fatalf("Marshal: %v", err)
912	}
913	if !bytes.Equal(jsonBig, b) {
914		t.Errorf("Marshal jsonBig")
915		diff(t, b, jsonBig)
916		return
917	}
918}
919
920var numberTests = []struct {
921	in       string
922	i        int64
923	intErr   string
924	f        float64
925	floatErr string
926}{
927	{in: "-1.23e1", intErr: "strconv.ParseInt: parsing \"-1.23e1\": invalid syntax", f: -1.23e1},
928	{in: "-12", i: -12, f: -12.0},
929	{in: "1e1000", intErr: "strconv.ParseInt: parsing \"1e1000\": invalid syntax", floatErr: "strconv.ParseFloat: parsing \"1e1000\": value out of range"},
930}
931
932// Independent of Decode, basic coverage of the accessors in Number
933func TestNumberAccessors(t *testing.T) {
934	for _, tt := range numberTests {
935		n := Number(tt.in)
936		if s := n.String(); s != tt.in {
937			t.Errorf("Number(%q).String() is %q", tt.in, s)
938		}
939		if i, err := n.Int64(); err == nil && tt.intErr == "" && i != tt.i {
940			t.Errorf("Number(%q).Int64() is %d", tt.in, i)
941		} else if (err == nil && tt.intErr != "") || (err != nil && err.Error() != tt.intErr) {
942			t.Errorf("Number(%q).Int64() wanted error %q but got: %v", tt.in, tt.intErr, err)
943		}
944		if f, err := n.Float64(); err == nil && tt.floatErr == "" && f != tt.f {
945			t.Errorf("Number(%q).Float64() is %g", tt.in, f)
946		} else if (err == nil && tt.floatErr != "") || (err != nil && err.Error() != tt.floatErr) {
947			t.Errorf("Number(%q).Float64() wanted error %q but got: %v", tt.in, tt.floatErr, err)
948		}
949	}
950}
951
952func TestLargeByteSlice(t *testing.T) {
953	s0 := make([]byte, 2000)
954	for i := range s0 {
955		s0[i] = byte(i)
956	}
957	b, err := Marshal(s0)
958	if err != nil {
959		t.Fatalf("Marshal: %v", err)
960	}
961	var s1 []byte
962	if err := Unmarshal(b, &s1); err != nil {
963		t.Fatalf("Unmarshal: %v", err)
964	}
965	if !bytes.Equal(s0, s1) {
966		t.Errorf("Marshal large byte slice")
967		diff(t, s0, s1)
968	}
969}
970
971type Xint struct {
972	X int
973}
974
975func TestUnmarshalInterface(t *testing.T) {
976	var xint Xint
977	var i interface{} = &xint
978	if err := Unmarshal([]byte(`{"X":1}`), &i); err != nil {
979		t.Fatalf("Unmarshal: %v", err)
980	}
981	if xint.X != 1 {
982		t.Fatalf("Did not write to xint")
983	}
984}
985
986func TestUnmarshalPtrPtr(t *testing.T) {
987	var xint Xint
988	pxint := &xint
989	if err := Unmarshal([]byte(`{"X":1}`), &pxint); err != nil {
990		t.Fatalf("Unmarshal: %v", err)
991	}
992	if xint.X != 1 {
993		t.Fatalf("Did not write to xint")
994	}
995}
996
997func TestEscape(t *testing.T) {
998	const input = `"foobar"<html>` + " [\u2028 \u2029]"
999	const expected = `"\"foobar\"\u003chtml\u003e [\u2028 \u2029]"`
1000	b, err := Marshal(input)
1001	if err != nil {
1002		t.Fatalf("Marshal error: %v", err)
1003	}
1004	if s := string(b); s != expected {
1005		t.Errorf("Encoding of [%s]:\n got [%s]\nwant [%s]", input, s, expected)
1006	}
1007}
1008
1009// WrongString is a struct that's misusing the ,string modifier.
1010type WrongString struct {
1011	Message string `json:"result,string"`
1012}
1013
1014type wrongStringTest struct {
1015	in, err string
1016}
1017
1018var wrongStringTests = []wrongStringTest{
1019	{`{"result":"x"}`, `json: invalid use of ,string struct tag, trying to unmarshal "x" into string`},
1020	{`{"result":"foo"}`, `json: invalid use of ,string struct tag, trying to unmarshal "foo" into string`},
1021	{`{"result":"123"}`, `json: invalid use of ,string struct tag, trying to unmarshal "123" into string`},
1022	{`{"result":123}`, `json: invalid use of ,string struct tag, trying to unmarshal unquoted value into string`},
1023}
1024
1025// If people misuse the ,string modifier, the error message should be
1026// helpful, telling the user that they're doing it wrong.
1027func TestErrorMessageFromMisusedString(t *testing.T) {
1028	for n, tt := range wrongStringTests {
1029		r := strings.NewReader(tt.in)
1030		var s WrongString
1031		err := NewDecoder(r).Decode(&s)
1032		got := fmt.Sprintf("%v", err)
1033		if got != tt.err {
1034			t.Errorf("%d. got err = %q, want %q", n, got, tt.err)
1035		}
1036	}
1037}
1038
1039func noSpace(c rune) rune {
1040	if isSpace(byte(c)) { //only used for ascii
1041		return -1
1042	}
1043	return c
1044}
1045
1046type All struct {
1047	Bool    bool
1048	Int     int
1049	Int8    int8
1050	Int16   int16
1051	Int32   int32
1052	Int64   int64
1053	Uint    uint
1054	Uint8   uint8
1055	Uint16  uint16
1056	Uint32  uint32
1057	Uint64  uint64
1058	Uintptr uintptr
1059	Float32 float32
1060	Float64 float64
1061
1062	Foo  string `json:"bar"`
1063	Foo2 string `json:"bar2,dummyopt"`
1064
1065	IntStr int64 `json:",string"`
1066
1067	PBool    *bool
1068	PInt     *int
1069	PInt8    *int8
1070	PInt16   *int16
1071	PInt32   *int32
1072	PInt64   *int64
1073	PUint    *uint
1074	PUint8   *uint8
1075	PUint16  *uint16
1076	PUint32  *uint32
1077	PUint64  *uint64
1078	PUintptr *uintptr
1079	PFloat32 *float32
1080	PFloat64 *float64
1081
1082	String  string
1083	PString *string
1084
1085	Map   map[string]Small
1086	MapP  map[string]*Small
1087	PMap  *map[string]Small
1088	PMapP *map[string]*Small
1089
1090	EmptyMap map[string]Small
1091	NilMap   map[string]Small
1092
1093	Slice   []Small
1094	SliceP  []*Small
1095	PSlice  *[]Small
1096	PSliceP *[]*Small
1097
1098	EmptySlice []Small
1099	NilSlice   []Small
1100
1101	StringSlice []string
1102	ByteSlice   []byte
1103
1104	Small   Small
1105	PSmall  *Small
1106	PPSmall **Small
1107
1108	Interface  interface{}
1109	PInterface *interface{}
1110
1111	unexported int
1112}
1113
1114type Small struct {
1115	Tag string
1116}
1117
1118var allValue = All{
1119	Bool:    true,
1120	Int:     2,
1121	Int8:    3,
1122	Int16:   4,
1123	Int32:   5,
1124	Int64:   6,
1125	Uint:    7,
1126	Uint8:   8,
1127	Uint16:  9,
1128	Uint32:  10,
1129	Uint64:  11,
1130	Uintptr: 12,
1131	Float32: 14.1,
1132	Float64: 15.1,
1133	Foo:     "foo",
1134	Foo2:    "foo2",
1135	IntStr:  42,
1136	String:  "16",
1137	Map: map[string]Small{
1138		"17": {Tag: "tag17"},
1139		"18": {Tag: "tag18"},
1140	},
1141	MapP: map[string]*Small{
1142		"19": {Tag: "tag19"},
1143		"20": nil,
1144	},
1145	EmptyMap:    map[string]Small{},
1146	Slice:       []Small{{Tag: "tag20"}, {Tag: "tag21"}},
1147	SliceP:      []*Small{{Tag: "tag22"}, nil, {Tag: "tag23"}},
1148	EmptySlice:  []Small{},
1149	StringSlice: []string{"str24", "str25", "str26"},
1150	ByteSlice:   []byte{27, 28, 29},
1151	Small:       Small{Tag: "tag30"},
1152	PSmall:      &Small{Tag: "tag31"},
1153	Interface:   5.2,
1154}
1155
1156var pallValue = All{
1157	PBool:      &allValue.Bool,
1158	PInt:       &allValue.Int,
1159	PInt8:      &allValue.Int8,
1160	PInt16:     &allValue.Int16,
1161	PInt32:     &allValue.Int32,
1162	PInt64:     &allValue.Int64,
1163	PUint:      &allValue.Uint,
1164	PUint8:     &allValue.Uint8,
1165	PUint16:    &allValue.Uint16,
1166	PUint32:    &allValue.Uint32,
1167	PUint64:    &allValue.Uint64,
1168	PUintptr:   &allValue.Uintptr,
1169	PFloat32:   &allValue.Float32,
1170	PFloat64:   &allValue.Float64,
1171	PString:    &allValue.String,
1172	PMap:       &allValue.Map,
1173	PMapP:      &allValue.MapP,
1174	PSlice:     &allValue.Slice,
1175	PSliceP:    &allValue.SliceP,
1176	PPSmall:    &allValue.PSmall,
1177	PInterface: &allValue.Interface,
1178}
1179
1180var allValueIndent = `{
1181	"Bool": true,
1182	"Int": 2,
1183	"Int8": 3,
1184	"Int16": 4,
1185	"Int32": 5,
1186	"Int64": 6,
1187	"Uint": 7,
1188	"Uint8": 8,
1189	"Uint16": 9,
1190	"Uint32": 10,
1191	"Uint64": 11,
1192	"Uintptr": 12,
1193	"Float32": 14.1,
1194	"Float64": 15.1,
1195	"bar": "foo",
1196	"bar2": "foo2",
1197	"IntStr": "42",
1198	"PBool": null,
1199	"PInt": null,
1200	"PInt8": null,
1201	"PInt16": null,
1202	"PInt32": null,
1203	"PInt64": null,
1204	"PUint": null,
1205	"PUint8": null,
1206	"PUint16": null,
1207	"PUint32": null,
1208	"PUint64": null,
1209	"PUintptr": null,
1210	"PFloat32": null,
1211	"PFloat64": null,
1212	"String": "16",
1213	"PString": null,
1214	"Map": {
1215		"17": {
1216			"Tag": "tag17"
1217		},
1218		"18": {
1219			"Tag": "tag18"
1220		}
1221	},
1222	"MapP": {
1223		"19": {
1224			"Tag": "tag19"
1225		},
1226		"20": null
1227	},
1228	"PMap": null,
1229	"PMapP": null,
1230	"EmptyMap": {},
1231	"NilMap": null,
1232	"Slice": [
1233		{
1234			"Tag": "tag20"
1235		},
1236		{
1237			"Tag": "tag21"
1238		}
1239	],
1240	"SliceP": [
1241		{
1242			"Tag": "tag22"
1243		},
1244		null,
1245		{
1246			"Tag": "tag23"
1247		}
1248	],
1249	"PSlice": null,
1250	"PSliceP": null,
1251	"EmptySlice": [],
1252	"NilSlice": null,
1253	"StringSlice": [
1254		"str24",
1255		"str25",
1256		"str26"
1257	],
1258	"ByteSlice": "Gxwd",
1259	"Small": {
1260		"Tag": "tag30"
1261	},
1262	"PSmall": {
1263		"Tag": "tag31"
1264	},
1265	"PPSmall": null,
1266	"Interface": 5.2,
1267	"PInterface": null
1268}`
1269
1270var allValueCompact = strings.Map(noSpace, allValueIndent)
1271
1272var pallValueIndent = `{
1273	"Bool": false,
1274	"Int": 0,
1275	"Int8": 0,
1276	"Int16": 0,
1277	"Int32": 0,
1278	"Int64": 0,
1279	"Uint": 0,
1280	"Uint8": 0,
1281	"Uint16": 0,
1282	"Uint32": 0,
1283	"Uint64": 0,
1284	"Uintptr": 0,
1285	"Float32": 0,
1286	"Float64": 0,
1287	"bar": "",
1288	"bar2": "",
1289        "IntStr": "0",
1290	"PBool": true,
1291	"PInt": 2,
1292	"PInt8": 3,
1293	"PInt16": 4,
1294	"PInt32": 5,
1295	"PInt64": 6,
1296	"PUint": 7,
1297	"PUint8": 8,
1298	"PUint16": 9,
1299	"PUint32": 10,
1300	"PUint64": 11,
1301	"PUintptr": 12,
1302	"PFloat32": 14.1,
1303	"PFloat64": 15.1,
1304	"String": "",
1305	"PString": "16",
1306	"Map": null,
1307	"MapP": null,
1308	"PMap": {
1309		"17": {
1310			"Tag": "tag17"
1311		},
1312		"18": {
1313			"Tag": "tag18"
1314		}
1315	},
1316	"PMapP": {
1317		"19": {
1318			"Tag": "tag19"
1319		},
1320		"20": null
1321	},
1322	"EmptyMap": null,
1323	"NilMap": null,
1324	"Slice": null,
1325	"SliceP": null,
1326	"PSlice": [
1327		{
1328			"Tag": "tag20"
1329		},
1330		{
1331			"Tag": "tag21"
1332		}
1333	],
1334	"PSliceP": [
1335		{
1336			"Tag": "tag22"
1337		},
1338		null,
1339		{
1340			"Tag": "tag23"
1341		}
1342	],
1343	"EmptySlice": null,
1344	"NilSlice": null,
1345	"StringSlice": null,
1346	"ByteSlice": null,
1347	"Small": {
1348		"Tag": ""
1349	},
1350	"PSmall": null,
1351	"PPSmall": {
1352		"Tag": "tag31"
1353	},
1354	"Interface": null,
1355	"PInterface": 5.2
1356}`
1357
1358var pallValueCompact = strings.Map(noSpace, pallValueIndent)
1359
1360func TestRefUnmarshal(t *testing.T) {
1361	type S struct {
1362		// Ref is defined in encode_test.go.
1363		R0 Ref
1364		R1 *Ref
1365		R2 RefText
1366		R3 *RefText
1367	}
1368	want := S{
1369		R0: 12,
1370		R1: new(Ref),
1371		R2: 13,
1372		R3: new(RefText),
1373	}
1374	*want.R1 = 12
1375	*want.R3 = 13
1376
1377	var got S
1378	if err := Unmarshal([]byte(`{"R0":"ref","R1":"ref","R2":"ref","R3":"ref"}`), &got); err != nil {
1379		t.Fatalf("Unmarshal: %v", err)
1380	}
1381	if !reflect.DeepEqual(got, want) {
1382		t.Errorf("got %+v, want %+v", got, want)
1383	}
1384}
1385
1386// Test that the empty string doesn't panic decoding when ,string is specified
1387// Issue 3450
1388func TestEmptyString(t *testing.T) {
1389	type T2 struct {
1390		Number1 int `json:",string"`
1391		Number2 int `json:",string"`
1392	}
1393	data := `{"Number1":"1", "Number2":""}`
1394	dec := NewDecoder(strings.NewReader(data))
1395	var t2 T2
1396	err := dec.Decode(&t2)
1397	if err == nil {
1398		t.Fatal("Decode: did not return error")
1399	}
1400	if t2.Number1 != 1 {
1401		t.Fatal("Decode: did not set Number1")
1402	}
1403}
1404
1405// Test that a null for ,string is not replaced with the previous quoted string (issue 7046).
1406// It should also not be an error (issue 2540, issue 8587).
1407func TestNullString(t *testing.T) {
1408	type T struct {
1409		A int  `json:",string"`
1410		B int  `json:",string"`
1411		C *int `json:",string"`
1412	}
1413	data := []byte(`{"A": "1", "B": null, "C": null}`)
1414	var s T
1415	s.B = 1
1416	s.C = new(int)
1417	*s.C = 2
1418	err := Unmarshal(data, &s)
1419	if err != nil {
1420		t.Fatalf("Unmarshal: %v", err)
1421	}
1422	if s.B != 1 || s.C != nil {
1423		t.Fatalf("after Unmarshal, s.B=%d, s.C=%p, want 1, nil", s.B, s.C)
1424	}
1425}
1426
1427func intp(x int) *int {
1428	p := new(int)
1429	*p = x
1430	return p
1431}
1432
1433func intpp(x *int) **int {
1434	pp := new(*int)
1435	*pp = x
1436	return pp
1437}
1438
1439var interfaceSetTests = []struct {
1440	pre  interface{}
1441	json string
1442	post interface{}
1443}{
1444	{"foo", `"bar"`, "bar"},
1445	{"foo", `2`, int64(2)},
1446	{"foo", `2.1`, float64(2.1)},
1447	{"foo", `true`, true},
1448	{"foo", `null`, nil},
1449
1450	{nil, `null`, nil},
1451	{new(int), `null`, nil},
1452	{(*int)(nil), `null`, nil},
1453	{new(*int), `null`, new(*int)},
1454	{(**int)(nil), `null`, nil},
1455	{intp(1), `null`, nil},
1456	{intpp(nil), `null`, intpp(nil)},
1457	{intpp(intp(1)), `null`, intpp(nil)},
1458}
1459
1460func TestInterfaceSet(t *testing.T) {
1461	for _, tt := range interfaceSetTests {
1462		b := struct{ X interface{} }{tt.pre}
1463		blob := `{"X":` + tt.json + `}`
1464		if err := Unmarshal([]byte(blob), &b); err != nil {
1465			t.Errorf("Unmarshal %#q: %v", blob, err)
1466			continue
1467		}
1468		if !reflect.DeepEqual(b.X, tt.post) {
1469			t.Errorf("Unmarshal %#q into %#v: X=%#v, want %#v", blob, tt.pre, b.X, tt.post)
1470		}
1471	}
1472}
1473
1474// JSON null values should be ignored for primitives and string values instead of resulting in an error.
1475// Issue 2540
1476func TestUnmarshalNulls(t *testing.T) {
1477	jsonData := []byte(`{
1478		"Bool"    : null,
1479		"Int"     : null,
1480		"Int8"    : null,
1481		"Int16"   : null,
1482		"Int32"   : null,
1483		"Int64"   : null,
1484		"Uint"    : null,
1485		"Uint8"   : null,
1486		"Uint16"  : null,
1487		"Uint32"  : null,
1488		"Uint64"  : null,
1489		"Float32" : null,
1490		"Float64" : null,
1491		"String"  : null}`)
1492
1493	nulls := All{
1494		Bool:    true,
1495		Int:     2,
1496		Int8:    3,
1497		Int16:   4,
1498		Int32:   5,
1499		Int64:   6,
1500		Uint:    7,
1501		Uint8:   8,
1502		Uint16:  9,
1503		Uint32:  10,
1504		Uint64:  11,
1505		Float32: 12.1,
1506		Float64: 13.1,
1507		String:  "14"}
1508
1509	err := Unmarshal(jsonData, &nulls)
1510	if err != nil {
1511		t.Errorf("Unmarshal of null values failed: %v", err)
1512	}
1513	if !nulls.Bool || nulls.Int != 2 || nulls.Int8 != 3 || nulls.Int16 != 4 || nulls.Int32 != 5 || nulls.Int64 != 6 ||
1514		nulls.Uint != 7 || nulls.Uint8 != 8 || nulls.Uint16 != 9 || nulls.Uint32 != 10 || nulls.Uint64 != 11 ||
1515		nulls.Float32 != 12.1 || nulls.Float64 != 13.1 || nulls.String != "14" {
1516
1517		t.Errorf("Unmarshal of null values affected primitives")
1518	}
1519}
1520
1521func TestStringKind(t *testing.T) {
1522	type stringKind string
1523
1524	var m1, m2 map[stringKind]int
1525	m1 = map[stringKind]int{
1526		"foo": 42,
1527	}
1528
1529	data, err := Marshal(m1)
1530	if err != nil {
1531		t.Errorf("Unexpected error marshaling: %v", err)
1532	}
1533
1534	err = Unmarshal(data, &m2)
1535	if err != nil {
1536		t.Errorf("Unexpected error unmarshaling: %v", err)
1537	}
1538
1539	if !reflect.DeepEqual(m1, m2) {
1540		t.Error("Items should be equal after encoding and then decoding")
1541	}
1542}
1543
1544// Custom types with []byte as underlying type could not be marshalled
1545// and then unmarshalled.
1546// Issue 8962.
1547func TestByteKind(t *testing.T) {
1548	type byteKind []byte
1549
1550	a := byteKind("hello")
1551
1552	data, err := Marshal(a)
1553	if err != nil {
1554		t.Error(err)
1555	}
1556	var b byteKind
1557	err = Unmarshal(data, &b)
1558	if err != nil {
1559		t.Fatal(err)
1560	}
1561	if !reflect.DeepEqual(a, b) {
1562		t.Errorf("expected %v == %v", a, b)
1563	}
1564}
1565
1566// The fix for issue 8962 introduced a regression.
1567// Issue 12921.
1568func TestSliceOfCustomByte(t *testing.T) {
1569	type Uint8 uint8
1570
1571	a := []Uint8("hello")
1572
1573	data, err := Marshal(a)
1574	if err != nil {
1575		t.Fatal(err)
1576	}
1577	var b []Uint8
1578	err = Unmarshal(data, &b)
1579	if err != nil {
1580		t.Fatal(err)
1581	}
1582	if !reflect.DeepEqual(a, b) {
1583		t.Fatalf("expected %v == %v", a, b)
1584	}
1585}
1586
1587var decodeTypeErrorTests = []struct {
1588	dest interface{}
1589	src  string
1590}{
1591	{new(string), `{"user": "name"}`}, // issue 4628.
1592	{new(error), `{}`},                // issue 4222
1593	{new(error), `[]`},
1594	{new(error), `""`},
1595	{new(error), `123`},
1596	{new(error), `true`},
1597}
1598
1599func TestUnmarshalTypeError(t *testing.T) {
1600	for _, item := range decodeTypeErrorTests {
1601		err := Unmarshal([]byte(item.src), item.dest)
1602		if _, ok := err.(*UnmarshalTypeError); !ok {
1603			t.Errorf("expected type error for Unmarshal(%q, type %T): got %T",
1604				item.src, item.dest, err)
1605		}
1606	}
1607}
1608
1609var unmarshalSyntaxTests = []string{
1610	"tru",
1611	"fals",
1612	"nul",
1613	"123e",
1614	`"hello`,
1615	`[1,2,3`,
1616	`{"key":1`,
1617	`{"key":1,`,
1618}
1619
1620// this test is broken also in dustin/gojson and encoding/json
1621func TestUnmarshalSyntax(t *testing.T) {
1622	var x interface{}
1623	for _, src := range unmarshalSyntaxTests {
1624		err := Unmarshal([]byte(src), &x)
1625		//		if _, ok := err.(*SyntaxError); !ok {
1626		//			t.Errorf("expected syntax error for Unmarshal(%q): got %T", src, err)
1627		if err == nil {
1628			//			t.Errorf("expected syntax error for Unmarshal(%q): got nothing", src)
1629		}
1630	}
1631}
1632
1633// Test handling of unexported fields that should be ignored.
1634// Issue 4660
1635type unexportedFields struct {
1636	Name string
1637	m    map[string]interface{} `json:"-"`
1638	m2   map[string]interface{} `json:"abcd"`
1639}
1640
1641func TestUnmarshalUnexported(t *testing.T) {
1642	input := `{"Name": "Bob", "m": {"x": 123}, "m2": {"y": 456}, "abcd": {"z": 789}}`
1643	want := &unexportedFields{Name: "Bob"}
1644
1645	out := &unexportedFields{}
1646	err := Unmarshal([]byte(input), out)
1647	if err != nil {
1648		t.Errorf("got error %v, expected nil", err)
1649	}
1650	if !reflect.DeepEqual(out, want) {
1651		t.Errorf("got %q, want %q", out, want)
1652	}
1653}
1654
1655// Time3339 is a time.Time which encodes to and from JSON
1656// as an RFC 3339 time in UTC.
1657type Time3339 time.Time
1658
1659func (t *Time3339) UnmarshalJSON(b []byte) error {
1660	if len(b) < 2 || b[0] != '"' || b[len(b)-1] != '"' {
1661		return fmt.Errorf("types: failed to unmarshal non-string value %q as an RFC 3339 time", b)
1662	}
1663	tm, err := time.Parse(time.RFC3339, string(b[1:len(b)-1]))
1664	if err != nil {
1665		return err
1666	}
1667	*t = Time3339(tm)
1668	return nil
1669}
1670
1671func TestUnmarshalJSONLiteralError(t *testing.T) {
1672	var t3 Time3339
1673	err := Unmarshal([]byte(`"0000-00-00T00:00:00Z"`), &t3)
1674	if err == nil {
1675		t.Fatalf("expected error; got time %v", time.Time(t3))
1676	}
1677	if !strings.Contains(err.Error(), "range") {
1678		t.Errorf("got err = %v; want out of range error", err)
1679	}
1680}
1681
1682// Test that extra object elements in an array do not result in a
1683// "data changing underfoot" error.
1684// Issue 3717
1685func TestSkipArrayObjects(t *testing.T) {
1686	json := `[{}]`
1687	var dest [0]interface{}
1688
1689	err := Unmarshal([]byte(json), &dest)
1690	if err != nil {
1691		t.Errorf("got error %q, want nil", err)
1692	}
1693}
1694
1695// Test semantics of pre-filled struct fields and pre-filled map fields.
1696// Issue 4900.
1697func TestPrefilled(t *testing.T) {
1698	ptrToMap := func(m map[string]interface{}) *map[string]interface{} { return &m }
1699
1700	// Values here change, cannot reuse table across runs.
1701	var prefillTests = []struct {
1702		in  string
1703		ptr interface{}
1704		out interface{}
1705	}{
1706		{
1707			in:  `{"X": 1, "Y": 2}`,
1708			ptr: &XYZ{X: float32(3), Y: int16(4), Z: 1.5},
1709			out: &XYZ{X: int64(1), Y: int64(2), Z: 1.5},
1710		},
1711		{
1712			in:  `{"X": 1, "Y": 2}`,
1713			ptr: ptrToMap(map[string]interface{}{"X": float32(3), "Y": int16(4), "Z": 1.5}),
1714			out: ptrToMap(map[string]interface{}{"X": int64(1), "Y": int64(2), "Z": 1.5}),
1715		},
1716	}
1717
1718	for _, tt := range prefillTests {
1719		ptrstr := fmt.Sprintf("%v", tt.ptr)
1720		err := Unmarshal([]byte(tt.in), tt.ptr) // tt.ptr edited here
1721		if err != nil {
1722			t.Errorf("Unmarshal: %v", err)
1723		}
1724		if !reflect.DeepEqual(tt.ptr, tt.out) {
1725			t.Errorf("Unmarshal(%#q, %s): have %v, want %v", tt.in, ptrstr, tt.ptr, tt.out)
1726		}
1727	}
1728}
1729
1730var invalidUnmarshalTests = []struct {
1731	v    interface{}
1732	want string
1733}{
1734	{nil, "json: Unmarshal(nil)"},
1735	{struct{}{}, "json: Unmarshal(non-pointer struct {})"},
1736	{(*int)(nil), "json: Unmarshal(nil *int)"},
1737}
1738
1739func TestInvalidUnmarshal(t *testing.T) {
1740	buf := []byte(`{"a":"1"}`)
1741	for _, tt := range invalidUnmarshalTests {
1742		err := Unmarshal(buf, tt.v)
1743		if err == nil {
1744			t.Errorf("Unmarshal expecting error, got nil")
1745			continue
1746		}
1747		if got := err.Error(); got != tt.want {
1748			t.Errorf("Unmarshal = %q; want %q", got, tt.want)
1749		}
1750	}
1751}
1752
1753var invalidUnmarshalTextTests = []struct {
1754	v    interface{}
1755	want string
1756}{
1757	{nil, "json: Unmarshal(nil)"},
1758	{struct{}{}, "json: Unmarshal(non-pointer struct {})"},
1759	{(*int)(nil), "json: Unmarshal(nil *int)"},
1760	{new(net.IP), "json: cannot unmarshal string into Go value of type *net.IP"},
1761}
1762
1763func TestInvalidUnmarshalText(t *testing.T) {
1764	buf := []byte(`123`)
1765	for _, tt := range invalidUnmarshalTextTests {
1766		err := Unmarshal(buf, tt.v)
1767		if err == nil {
1768			t.Errorf("Unmarshal expecting error, got nil")
1769			continue
1770		}
1771		if got := err.Error(); got != tt.want {
1772			t.Errorf("Unmarshal = %q; want %q", got, tt.want)
1773		}
1774	}
1775}
1776
1777// Test that string option is ignored for invalid types.
1778// Issue 9812.
1779func TestInvalidStringOption(t *testing.T) {
1780	num := 0
1781	item := struct {
1782		T time.Time         `json:",string"`
1783		M map[string]string `json:",string"`
1784		S []string          `json:",string"`
1785		A [1]string         `json:",string"`
1786		I interface{}       `json:",string"`
1787		P *int              `json:",string"`
1788	}{M: make(map[string]string), S: make([]string, 0), I: num, P: &num}
1789
1790	data, err := Marshal(item)
1791	if err != nil {
1792		t.Fatalf("Marshal: %v", err)
1793	}
1794
1795	err = Unmarshal(data, &item)
1796	if err != nil {
1797		t.Fatalf("Unmarshal: %v", err)
1798	}
1799}
1800
1801func TestValidator(t *testing.T) {
1802	for _, tt := range unmarshalTests {
1803		// Don't care about the valid json with type errors
1804		expectederr := tt.err
1805		if _, ok := expectederr.(*UnmarshalTypeError); ok {
1806			expectederr = nil
1807		}
1808		if _, ok := expectederr.(*UnmarshalFieldError); ok {
1809			expectederr = nil
1810		}
1811		if expectederr == errMissingU8Prefix {
1812			expectederr = nil
1813		}
1814		err := Validate([]byte(tt.in))
1815		if (expectederr == nil) != (err == nil) {
1816			t.Errorf("Incorrectly validated %v - %v/%v",
1817				tt.in, expectederr, err)
1818		}
1819	}
1820}
1821