1
2
3
18
19 package sonic
20
21 import (
22 `bytes`
23 `encoding`
24 `encoding/json`
25 `errors`
26 `fmt`
27 `image`
28 `math`
29 `math/big`
30 `math/rand`
31 `net`
32 `reflect`
33 `strconv`
34 `strings`
35 `testing`
36 `time`
37 `unsafe`
38
39 `github.com/bytedance/sonic/decoder`
40 `github.com/bytedance/sonic/internal/native/types`
41 `github.com/davecgh/go-spew/spew`
42 `github.com/stretchr/testify/assert`
43 )
44
45 type T struct {
46 X string
47 Y int
48 Z int `json:"-"`
49 }
50
51 type U struct {
52 Alphabet string `json:"alpha"`
53 }
54
55 type V struct {
56 F1 interface{}
57 F2 int32
58 F3 json.Number
59 F4 *VOuter
60 }
61
62 type VOuter struct {
63 V V
64 }
65
66 type W struct {
67 S SS
68 }
69
70 type P struct {
71 PP PP
72 }
73
74 type PP struct {
75 T T
76 Ts []T
77 }
78
79 type SS string
80
81 func (*SS) UnmarshalJSON(_ []byte) error {
82 return &json.UnmarshalTypeError{Value: "number", Type: reflect.TypeOf(SS(""))}
83 }
84
85
86
87 var ifaceNumAsFloat64 = map[string]interface{}{
88 "k1": float64(1),
89 "k2": "s",
90 "k3": []interface{}{float64(1), 2.0, 3e-3},
91 "k4": map[string]interface{}{"kk1": "s", "kk2": float64(2)},
92 }
93
94 var ifaceNumAsNumber = map[string]interface{}{
95 "k1": json.Number("1"),
96 "k2": "s",
97 "k3": []interface{}{json.Number("1"), json.Number("2.0"), json.Number("3e-3")},
98 "k4": map[string]interface{}{"kk1": "s", "kk2": json.Number("2")},
99 }
100
101 type tx struct {
102 x int
103 }
104
105 type u8 uint8
106
107
108
109 type unmarshaler struct {
110 T bool
111 }
112
113 func (u *unmarshaler) UnmarshalJSON(_ []byte) error {
114 *u = unmarshaler{true}
115 return nil
116 }
117
118 type ustruct struct {
119 M unmarshaler
120 }
121
122 type unmarshalerText struct {
123 A, B string
124 }
125
126
127 func (u unmarshalerText) MarshalText() ([]byte, error) {
128 return []byte(u.A + ":" + u.B), nil
129 }
130
131 func (u *unmarshalerText) UnmarshalText(b []byte) error {
132 pos := bytes.IndexByte(b, ':')
133 if pos == -1 {
134 return errors.New("missing separator")
135 }
136 u.A, u.B = string(b[:pos]), string(b[pos+1:])
137 return nil
138 }
139
140 var _ encoding.TextUnmarshaler = (*unmarshalerText)(nil)
141
142 type ustructText struct {
143 M unmarshalerText
144 }
145
146
147 type u8marshal uint8
148
149 func (u8 u8marshal) MarshalText() ([]byte, error) {
150 return []byte(fmt.Sprintf("u%d", u8)), nil
151 }
152
153 var errMissingU8Prefix = errors.New("missing 'u' prefix")
154
155 func (u8 *u8marshal) UnmarshalText(b []byte) error {
156 if !bytes.HasPrefix(b, []byte{'u'}) {
157 return errMissingU8Prefix
158 }
159 n, err := strconv.Atoi(string(b[1:]))
160 if err != nil {
161 return err
162 }
163 *u8 = u8marshal(n)
164 return nil
165 }
166
167 var _ encoding.TextUnmarshaler = (*u8marshal)(nil)
168
169 var (
170 umtrue = unmarshaler{true}
171 umslice = []unmarshaler{{true}}
172 umstruct = ustruct{unmarshaler{true}}
173
174 umtrueXY = unmarshalerText{"x", "y"}
175 umsliceXY = []unmarshalerText{{"x", "y"}}
176 umstructXY = ustructText{unmarshalerText{"x", "y"}}
177
178 ummapXY = map[unmarshalerText]bool{{"x", "y"}: true}
179 )
180
181
182
183 type Point struct {
184 Z int
185 }
186
187 type Top struct {
188 Level0 int
189 Embed0
190 *Embed0a
191 *Embed0b `json:"e,omitempty"`
192 Embed0c `json:"-"`
193 Loop
194 Embed0p
195 Embed0q
196 embed
197 }
198
199 type Embed0 struct {
200 Level1a int
201 Level1b int
202 Level1c int
203 Level1d int
204 Level1e int `json:"x"`
205 }
206
207 type Embed0a struct {
208 Level1a int `json:"Level1a,omitempty"`
209 Level1b int `json:"LEVEL1B,omitempty"`
210 Level1c int `json:"-"`
211 Level1d int
212 Level1f int `json:"x"`
213 }
214
215 type Embed0b Embed0
216
217 type Embed0c Embed0
218
219 type Embed0p struct {
220 image.Point
221 }
222
223 type Embed0q struct {
224 Point
225 }
226
227 type embed struct {
228 Q int
229 }
230
231 type Loop struct {
232 Loop1 int `json:",omitempty"`
233 Loop2 int `json:",omitempty"`
234 *Loop
235 }
236
237
238
239 type S5 struct {
240 S6
241 S7
242 S8
243 }
244
245 type S6 struct {
246 X int
247 }
248
249 type S7 S6
250
251 type S8 struct {
252 S9
253 }
254
255 type S9 struct {
256 X int
257 Y int
258 }
259
260
261
262 type S10 struct {
263 S11
264 S12
265 S13
266 }
267
268 type S11 struct {
269 S6
270 }
271
272 type S12 struct {
273 S6
274 }
275
276 type S13 struct {
277 S8
278 }
279
280 type Ambig struct {
281
282 First int `json:"HELLO"`
283 Second int `json:"Hello"`
284 }
285
286 type XYZ struct {
287 X interface{}
288 Y interface{}
289 Z interface{}
290 }
291
292 type byteWithMarshalJSON byte
293
294 func (b byteWithMarshalJSON) MarshalJSON() ([]byte, error) {
295 return []byte(fmt.Sprintf(`"Z%.2x"`, byte(b))), nil
296 }
297
298 func (b *byteWithMarshalJSON) UnmarshalJSON(data []byte) error {
299 if len(data) != 5 || data[0] != '"' || data[1] != 'Z' || data[4] != '"' {
300 return fmt.Errorf("bad quoted string")
301 }
302 i, err := strconv.ParseInt(string(data[2:4]), 16, 8)
303 if err != nil {
304 return fmt.Errorf("bad hex")
305 }
306 *b = byteWithMarshalJSON(i)
307 return nil
308 }
309
310 type byteWithPtrMarshalJSON byte
311
312 func (b *byteWithPtrMarshalJSON) MarshalJSON() ([]byte, error) {
313 return byteWithMarshalJSON(*b).MarshalJSON()
314 }
315
316 func (b *byteWithPtrMarshalJSON) UnmarshalJSON(data []byte) error {
317 return (*byteWithMarshalJSON)(b).UnmarshalJSON(data)
318 }
319
320 type byteWithMarshalText byte
321
322 func (b byteWithMarshalText) MarshalText() ([]byte, error) {
323 return []byte(fmt.Sprintf(`Z%.2x`, byte(b))), nil
324 }
325
326 func (b *byteWithMarshalText) UnmarshalText(data []byte) error {
327 if len(data) != 3 || data[0] != 'Z' {
328 return fmt.Errorf("bad quoted string")
329 }
330 i, err := strconv.ParseInt(string(data[1:3]), 16, 8)
331 if err != nil {
332 return fmt.Errorf("bad hex")
333 }
334 *b = byteWithMarshalText(i)
335 return nil
336 }
337
338 type byteWithPtrMarshalText byte
339
340 func (b *byteWithPtrMarshalText) MarshalText() ([]byte, error) {
341 return byteWithMarshalText(*b).MarshalText()
342 }
343
344 func (b *byteWithPtrMarshalText) UnmarshalText(data []byte) error {
345 return (*byteWithMarshalText)(b).UnmarshalText(data)
346 }
347
348 type intWithMarshalJSON int
349
350 func (b intWithMarshalJSON) MarshalJSON() ([]byte, error) {
351 return []byte(fmt.Sprintf(`"Z%.2x"`, int(b))), nil
352 }
353
354 func (b *intWithMarshalJSON) UnmarshalJSON(data []byte) error {
355 if len(data) != 5 || data[0] != '"' || data[1] != 'Z' || data[4] != '"' {
356 return fmt.Errorf("bad quoted string")
357 }
358 i, err := strconv.ParseInt(string(data[2:4]), 16, 8)
359 if err != nil {
360 return fmt.Errorf("bad hex")
361 }
362 *b = intWithMarshalJSON(i)
363 return nil
364 }
365
366 type intWithPtrMarshalJSON int
367
368 func (b *intWithPtrMarshalJSON) MarshalJSON() ([]byte, error) {
369 return intWithMarshalJSON(*b).MarshalJSON()
370 }
371
372 func (b *intWithPtrMarshalJSON) UnmarshalJSON(data []byte) error {
373 return (*intWithMarshalJSON)(b).UnmarshalJSON(data)
374 }
375
376 type intWithMarshalText int
377
378 func (b intWithMarshalText) MarshalText() ([]byte, error) {
379 return []byte(fmt.Sprintf(`Z%.2x`, int(b))), nil
380 }
381
382 func (b *intWithMarshalText) UnmarshalText(data []byte) error {
383 if len(data) != 3 || data[0] != 'Z' {
384 return fmt.Errorf("bad quoted string")
385 }
386 i, err := strconv.ParseInt(string(data[1:3]), 16, 8)
387 if err != nil {
388 return fmt.Errorf("bad hex")
389 }
390 *b = intWithMarshalText(i)
391 return nil
392 }
393
394 type intWithPtrMarshalText int
395
396 func (b *intWithPtrMarshalText) MarshalText() ([]byte, error) {
397 return intWithMarshalText(*b).MarshalText()
398 }
399
400 func (b *intWithPtrMarshalText) UnmarshalText(data []byte) error {
401 return (*intWithMarshalText)(b).UnmarshalText(data)
402 }
403
404 type mapStringToStringData struct {
405 Data map[string]string `json:"data"`
406 }
407
408 type unmarshalTest struct {
409 in string
410 ptr interface{}
411 out interface{}
412 err error
413 useNumber bool
414 golden bool
415 disallowUnknownFields bool
416 validateString bool
417 }
418
419 type B struct {
420 B bool `json:",string"`
421 }
422
423 type DoublePtr struct {
424 I **int
425 J **int
426 }
427
428 type JsonSyntaxError struct {
429 Msg string
430 Offset int64
431 }
432
433 func (self *JsonSyntaxError) err() *json.SyntaxError {
434 return (*json.SyntaxError)(unsafe.Pointer(self))
435 }
436
437 var unmarshalTests = []unmarshalTest{
438
439 {in: `true`, ptr: new(bool), out: true},
440 {in: `1`, ptr: new(int), out: 1},
441 {in: `1.2`, ptr: new(float64), out: 1.2},
442 {in: `-5`, ptr: new(int16), out: int16(-5)},
443 {in: `2`, ptr: new(json.Number), out: json.Number("2"), useNumber: true},
444 {in: `2`, ptr: new(json.Number), out: json.Number("2")},
445 {in: `2`, ptr: new(interface{}), out: 2.0},
446 {in: `2`, ptr: new(interface{}), out: json.Number("2"), useNumber: true},
447 {in: `"a\u1234"`, ptr: new(string), out: "a\u1234"},
448 {in: `"http:\/\/"`, ptr: new(string), out: "http://"},
449 {in: `"g-clef: \uD834\uDD1E"`, ptr: new(string), out: "g-clef: \U0001D11E"},
450 {in: `"invalid: \uD834x\uDD1E"`, ptr: new(string), out: "invalid: \uFFFDx\uFFFD"},
451 {in: "null", ptr: new(interface{}), out: nil},
452 {in: `{"X": [1,2,3], "Y": 4}`, ptr: new(T), out: T{Y: 4}, err: &json.UnmarshalTypeError{Value: "array", Type: reflect.TypeOf(""), Offset: 7, Struct: "T", Field: "X"}},
453 {in: `{"X": 23}`, ptr: new(T), out: T{}, err: &json.UnmarshalTypeError{Value: "number", Type: reflect.TypeOf(""), Offset: 8, Struct: "T", Field: "X"}},
454 {in: `{"x": 1}`, ptr: new(tx), out: tx{}},
455 {in: `{"x": 1}`, ptr: new(tx), err: fmt.Errorf("json: unknown field \"x\""), disallowUnknownFields: true},
456 {in: `{"S": 23}`, ptr: new(W), out: W{}, err: &json.UnmarshalTypeError{Value: "number", Type: reflect.TypeOf(SS("")), Struct: "W", Field: "S"}},
457 {in: `{"F1":1,"F2":2,"F3":3}`, ptr: new(V), out: V{F1: float64(1), F2: int32(2), F3: json.Number("3")}},
458 {in: `{"F1":1,"F2":2,"F3":3}`, ptr: new(V), out: V{F1: json.Number("1"), F2: int32(2), F3: json.Number("3")}, useNumber: true},
459 {in: `{"k1":1,"k2":"s","k3":[1,2.0,3e-3],"k4":{"kk1":"s","kk2":2}}`, ptr: new(interface{}), out: ifaceNumAsFloat64},
460 {in: `{"k1":1,"k2":"s","k3":[1,2.0,3e-3],"k4":{"kk1":"s","kk2":2}}`, ptr: new(interface{}), out: ifaceNumAsNumber, useNumber: true},
461
462
463 {in: "\n true ", ptr: new(bool), out: true},
464 {in: "\t 1 ", ptr: new(int), out: 1},
465 {in: "\r 1.2 ", ptr: new(float64), out: 1.2},
466 {in: "\t -5 \n", ptr: new(int16), out: int16(-5)},
467 {in: "\t \"a\\u1234\" \n", ptr: new(string), out: "a\u1234"},
468
469
470 {in: `{"Y": 1, "Z": 2}`, ptr: new(T), out: T{Y: 1}},
471 {in: `{"Y": 1, "Z": 2}`, ptr: new(T), err: fmt.Errorf("json: unknown field \"Z\""), disallowUnknownFields: true},
472
473 {in: `{"alpha": "abc", "alphabet": "xyz"}`, ptr: new(U), out: U{Alphabet: "abc"}},
474 {in: `{"alpha": "abc", "alphabet": "xyz"}`, ptr: new(U), err: fmt.Errorf("json: unknown field \"alphabet\""), disallowUnknownFields: true},
475 {in: `{"alpha": "abc"}`, ptr: new(U), out: U{Alphabet: "abc"}},
476 {in: `{"alphabet": "xyz"}`, ptr: new(U), out: U{}},
477 {in: `{"alphabet": "xyz"}`, ptr: new(U), err: fmt.Errorf("json: unknown field \"alphabet\""), disallowUnknownFields: true},
478
479
480 {in: `{"X": "foo", "Y"}`, err: (&JsonSyntaxError{"invalid character '}' after object key", 17}).err()},
481 {in: `[1, 2, 3+]`, err: (&JsonSyntaxError{"invalid character '+' after array element", 9}).err()},
482 {in: `{"X":12x}`, err: (&JsonSyntaxError{"invalid character 'x' after object key:value pair", 8}).err(), useNumber: true},
483 {in: `[2, 3`, err: (&JsonSyntaxError{Msg: "unexpected end of JSON input", Offset: 5}).err()},
484 {in: `{"F3": -}`, ptr: new(V), out: V{F3: json.Number("-")}, err: (&JsonSyntaxError{Msg: "invalid character '}' in numeric literal", Offset: 9}).err()},
485
486
487 {in: "\x01 42", err: (&JsonSyntaxError{"invalid character '\\x01' looking for beginning of value", 1}).err()},
488 {in: " 42 \x01", err: (&JsonSyntaxError{"invalid character '\\x01' after top-level value", 5}).err()},
489 {in: "\x01 true", err: (&JsonSyntaxError{"invalid character '\\x01' looking for beginning of value", 1}).err()},
490 {in: " false \x01", err: (&JsonSyntaxError{"invalid character '\\x01' after top-level value", 8}).err()},
491 {in: "\x01 1.2", err: (&JsonSyntaxError{"invalid character '\\x01' looking for beginning of value", 1}).err()},
492 {in: " 3.4 \x01", err: (&JsonSyntaxError{"invalid character '\\x01' after top-level value", 6}).err()},
493 {in: "\x01 \"string\"", err: (&JsonSyntaxError{"invalid character '\\x01' looking for beginning of value", 1}).err()},
494 {in: " \"string\" \x01", err: (&JsonSyntaxError{"invalid character '\\x01' after top-level value", 11}).err()},
495
496
497 {in: `[1, 2, 3]`, ptr: new([3]int), out: [3]int{1, 2, 3}},
498 {in: `[1, 2, 3]`, ptr: new([1]int), out: [1]int{1}},
499 {in: `[1, 2, 3]`, ptr: new([5]int), out: [5]int{1, 2, 3, 0, 0}},
500 {in: `[1, 2, 3]`, ptr: new(MustNotUnmarshalJSON), err: errors.New("MustNotUnmarshalJSON was used")},
501
502
503 {in: `[]`, ptr: new([]interface{}), out: []interface{}{}},
504 {in: `null`, ptr: new([]interface{}), out: []interface{}(nil)},
505 {in: `{"T":[]}`, ptr: new(map[string]interface{}), out: map[string]interface{}{"T": []interface{}{}}},
506 {in: `{"T":null}`, ptr: new(map[string]interface{}), out: map[string]interface{}{"T": interface{}(nil)}},
507
508
509 {in: allValueIndent, ptr: new(All), out: allValue},
510 {in: allValueCompact, ptr: new(All), out: allValue},
511 {in: allValueIndent, ptr: new(*All), out: &allValue},
512 {in: allValueCompact, ptr: new(*All), out: &allValue},
513 {in: pallValueIndent, ptr: new(All), out: pallValue},
514 {in: pallValueCompact, ptr: new(All), out: pallValue},
515 {in: pallValueIndent, ptr: new(*All), out: &pallValue},
516 {in: pallValueCompact, ptr: new(*All), out: &pallValue},
517
518
519 {in: `{"T":false}`, ptr: new(unmarshaler), out: umtrue},
520 {in: `{"T":false}`, ptr: new(*unmarshaler), out: &umtrue},
521 {in: `[{"T":false}]`, ptr: new([]unmarshaler), out: umslice},
522 {in: `[{"T":false}]`, ptr: new(*[]unmarshaler), out: &umslice},
523 {in: `{"M":{"T":"x:y"}}`, ptr: new(ustruct), out: umstruct},
524
525
526 {in: `"x:y"`, ptr: new(unmarshalerText), out: umtrueXY},
527 {in: `"x:y"`, ptr: new(*unmarshalerText), out: &umtrueXY},
528 {in: `["x:y"]`, ptr: new([]unmarshalerText), out: umsliceXY},
529 {in: `["x:y"]`, ptr: new(*[]unmarshalerText), out: &umsliceXY},
530 {in: `{"M":"x:y"}`, ptr: new(ustructText), out: umstructXY},
531
532
533 {
534 in: `{"-1":"a","0":"b","1":"c"}`,
535 ptr: new(map[int]string),
536 out: map[int]string{-1: "a", 0: "b", 1: "c"},
537 },
538 {
539 in: `{"0":"a","10":"c","9":"b"}`,
540 ptr: new(map[u8]string),
541 out: map[u8]string{0: "a", 9: "b", 10: "c"},
542 },
543 {
544 in: `{"-9223372036854775808":"min","9223372036854775807":"max"}`,
545 ptr: new(map[int64]string),
546 out: map[int64]string{math.MinInt64: "min", math.MaxInt64: "max"},
547 },
548 {
549 in: `{"18446744073709551615":"max"}`,
550 ptr: new(map[uint64]string),
551 out: map[uint64]string{math.MaxUint64: "max"},
552 },
553 {
554 in: `{"0":false,"10":true}`,
555 ptr: new(map[uintptr]bool),
556 out: map[uintptr]bool{0: false, 10: true},
557 },
558
559
560
561 {
562 in: `{"u2":4}`,
563 ptr: new(map[u8marshal]int),
564 out: map[u8marshal]int{2: 4},
565 },
566 {
567 in: `{"2":4}`,
568 ptr: new(map[u8marshal]int),
569 err: errMissingU8Prefix,
570 },
571
572
573 {
574 in: `{"abc":"abc"}`,
575 ptr: new(map[int]string),
576 err: &json.UnmarshalTypeError{Value: "number abc", Type: reflect.TypeOf(0), Offset: 2},
577 },
578 {
579 in: `{"256":"abc"}`,
580 ptr: new(map[uint8]string),
581 err: &json.UnmarshalTypeError{Value: "number 256", Type: reflect.TypeOf(uint8(0)), Offset: 2},
582 },
583 {
584 in: `{"128":"abc"}`,
585 ptr: new(map[int8]string),
586 err: &json.UnmarshalTypeError{Value: "number 128", Type: reflect.TypeOf(int8(0)), Offset: 2},
587 },
588 {
589 in: `{"-1":"abc"}`,
590 ptr: new(map[uint8]string),
591 err: &json.UnmarshalTypeError{Value: "number -1", Type: reflect.TypeOf(uint8(0)), Offset: 2},
592 },
593 {
594 in: `{"F":{"a":2,"3":4}}`,
595 ptr: new(map[string]map[int]int),
596 err: &json.UnmarshalTypeError{Value: "number a", Type: reflect.TypeOf(0), Offset: 7},
597 },
598 {
599 in: `{"F":{"a":2,"3":4}}`,
600 ptr: new(map[string]map[uint]int),
601 err: &json.UnmarshalTypeError{Value: "number a", Type: reflect.TypeOf(uint(0)), Offset: 7},
602 },
603
604
605 {in: `{"x:y":true}`, ptr: new(map[unmarshalerText]bool), out: ummapXY},
606
607 {in: `{"x:y":false,"x:y":true}`, ptr: new(map[unmarshalerText]bool), out: ummapXY},
608
609 {
610 in: `{
611 "Level0": 1,
612 "Level1b": 2,
613 "Level1c": 3,
614 "x": 4,
615 "Level1a": 5,
616 "LEVEL1B": 6,
617 "e": {
618 "Level1a": 8,
619 "Level1b": 9,
620 "Level1c": 10,
621 "Level1d": 11,
622 "x": 12
623 },
624 "Loop1": 13,
625 "Loop2": 14,
626 "X": 15,
627 "Y": 16,
628 "Z": 17,
629 "Q": 18
630 }`,
631 ptr: new(Top),
632 out: Top{
633 Level0: 1,
634 Embed0: Embed0{
635 Level1b: 2,
636 Level1c: 3,
637 },
638 Embed0a: &Embed0a{
639 Level1a: 5,
640 Level1b: 6,
641 },
642 Embed0b: &Embed0b{
643 Level1a: 8,
644 Level1b: 9,
645 Level1c: 10,
646 Level1d: 11,
647 Level1e: 12,
648 },
649 Loop: Loop{
650 Loop1: 13,
651 Loop2: 14,
652 },
653 Embed0p: Embed0p{
654 Point: image.Point{X: 15, Y: 16},
655 },
656 Embed0q: Embed0q{
657 Point: Point{Z: 17},
658 },
659 embed: embed{
660 Q: 18,
661 },
662 },
663 },
664 {
665 in: `{"hello": 1}`,
666 ptr: new(Ambig),
667 out: Ambig{First: 1},
668 },
669
670 {
671 in: `{"X": 1,"Y":2}`,
672 ptr: new(S5),
673 out: S5{S8: S8{S9: S9{Y: 2}}},
674 },
675 {
676 in: `{"X": 1,"Y":2}`,
677 ptr: new(S5),
678 err: fmt.Errorf("json: unknown field \"X\""),
679 disallowUnknownFields: true,
680 },
681 {
682 in: `{"X": 1,"Y":2}`,
683 ptr: new(S10),
684 out: S10{S13: S13{S8: S8{S9: S9{Y: 2}}}},
685 },
686 {
687 in: `{"X": 1,"Y":2}`,
688 ptr: new(S10),
689 err: fmt.Errorf("json: unknown field \"X\""),
690 disallowUnknownFields: true,
691 },
692 {
693 in: `{"I": 0, "I": null, "J": null}`,
694 ptr: new(DoublePtr),
695 out: DoublePtr{I: nil, J: nil},
696 },
697
698
699 {
700 in: "\"hello\xffworld\"",
701 ptr: new(string),
702 out: "hello\xffworld",
703 validateString: false,
704 },
705 {
706 in: "\"hello\xc2\xc2world\"",
707 ptr: new(string),
708 out: "hello\xc2\xc2world",
709 validateString: false,
710 },
711 {
712 in: "\"hello\xc2\xffworld\"",
713 ptr: new(string),
714 out: "hello\xc2\xffworld",
715 },
716 {
717 in: "\"hello\\ud800world\"",
718 ptr: new(string),
719 out: "hello\ufffdworld",
720 },
721 {
722 in: "\"hello\\ud800\\ud800world\"",
723 ptr: new(string),
724 out: "hello\ufffd\ufffdworld",
725 },
726 {
727 in: "\"hello\xed\xa0\x80\xed\xb0\x80world\"",
728 ptr: new(string),
729 out: "hello\xed\xa0\x80\xed\xb0\x80world",
730 },
731
732
733 {
734 in: `{"2009-11-10T23:00:00Z": "hello world"}`,
735 ptr: new(map[time.Time]string),
736 out: map[time.Time]string{time.Date(2009, 11, 10, 23, 0, 0, 0, time.UTC): "hello world"},
737 },
738
739
740 {
741 in: `{"2009-11-10T23:00:00Z": "hello world"}`,
742 ptr: new(map[Point]string),
743 err: &json.UnmarshalTypeError{Value: "object", Type: reflect.TypeOf(map[Point]string{}), Offset: 1},
744 },
745 {
746 in: `{"asdf": "hello world"}`,
747 ptr: new(map[unmarshaler]string),
748 err: &json.UnmarshalTypeError{Value: "object", Type: reflect.TypeOf(map[unmarshaler]string{}), Offset: 1},
749 },
750
751
752
753
754
755
756
757
758 {
759 in: `"AQID"`,
760 ptr: new([]byteWithMarshalJSON),
761 out: []byteWithMarshalJSON{1, 2, 3},
762 },
763 {
764 in: `["Z01","Z02","Z03"]`,
765 ptr: new([]byteWithMarshalJSON),
766 out: []byteWithMarshalJSON{1, 2, 3},
767 golden: true,
768 },
769 {
770 in: `"AQID"`,
771 ptr: new([]byteWithMarshalText),
772 out: []byteWithMarshalText{1, 2, 3},
773 },
774 {
775 in: `["Z01","Z02","Z03"]`,
776 ptr: new([]byteWithMarshalText),
777 out: []byteWithMarshalText{1, 2, 3},
778 golden: true,
779 },
780 {
781 in: `"AQID"`,
782 ptr: new([]byteWithPtrMarshalJSON),
783 out: []byteWithPtrMarshalJSON{1, 2, 3},
784 },
785 {
786 in: `["Z01","Z02","Z03"]`,
787 ptr: new([]byteWithPtrMarshalJSON),
788 out: []byteWithPtrMarshalJSON{1, 2, 3},
789 golden: true,
790 },
791 {
792 in: `"AQID"`,
793 ptr: new([]byteWithPtrMarshalText),
794 out: []byteWithPtrMarshalText{1, 2, 3},
795 },
796 {
797 in: `["Z01","Z02","Z03"]`,
798 ptr: new([]byteWithPtrMarshalText),
799 out: []byteWithPtrMarshalText{1, 2, 3},
800 golden: true,
801 },
802
803
804 {
805 in: `["Z01","Z02","Z03"]`,
806 ptr: new([]intWithMarshalJSON),
807 out: []intWithMarshalJSON{1, 2, 3},
808 golden: true,
809 },
810 {
811 in: `["Z01","Z02","Z03"]`,
812 ptr: new([]intWithMarshalText),
813 out: []intWithMarshalText{1, 2, 3},
814 golden: true,
815 },
816 {
817 in: `["Z01","Z02","Z03"]`,
818 ptr: new([]intWithPtrMarshalJSON),
819 out: []intWithPtrMarshalJSON{1, 2, 3},
820 golden: true,
821 },
822 {
823 in: `["Z01","Z02","Z03"]`,
824 ptr: new([]intWithPtrMarshalText),
825 out: []intWithPtrMarshalText{1, 2, 3},
826 golden: true,
827 },
828
829 {in: `0.000001`, ptr: new(float64), out: 0.000001, golden: true},
830 {in: `1e-7`, ptr: new(float64), out: 1e-7, golden: true},
831 {in: `100000000000000000000`, ptr: new(float64), out: 100000000000000000000.0, golden: true},
832 {in: `1e+21`, ptr: new(float64), out: 1e21, golden: true},
833 {in: `-0.000001`, ptr: new(float64), out: -0.000001, golden: true},
834 {in: `-1e-7`, ptr: new(float64), out: -1e-7, golden: true},
835 {in: `-100000000000000000000`, ptr: new(float64), out: -100000000000000000000.0, golden: true},
836 {in: `-1e+21`, ptr: new(float64), out: -1e21, golden: true},
837 {in: `999999999999999900000`, ptr: new(float64), out: 999999999999999900000.0, golden: true},
838 {in: `9007199254740992`, ptr: new(float64), out: 9007199254740992.0, golden: true},
839 {in: `9007199254740993`, ptr: new(float64), out: 9007199254740992.0, golden: false},
840
841 {
842 in: `{"V": {"F2": "hello"}}`,
843 ptr: new(VOuter),
844 err: &json.UnmarshalTypeError{
845 Value: "string",
846 Struct: "V",
847 Field: "V.F2",
848 Type: reflect.TypeOf(int32(0)),
849 Offset: 20,
850 },
851 },
852 {
853 in: `{"V": {"F4": {}, "F2": "hello"}}`,
854 ptr: new(VOuter),
855 err: &json.UnmarshalTypeError{
856 Value: "string",
857 Struct: "V",
858 Field: "V.F2",
859 Type: reflect.TypeOf(int32(0)),
860 Offset: 30,
861 },
862 },
863
864
865
866 {in: `{"B":"true"}`, ptr: new(B), out: B{true}, golden: true},
867 {in: `{"B":"false"}`, ptr: new(B), out: B{false}, golden: true},
868 {in: `{"B": "maybe"}`, ptr: new(B), err: errors.New(`json: invalid use of ,string struct tag, trying to unmarshal "maybe" into bool`)},
869 {in: `{"B": "tru"}`, ptr: new(B), err: errors.New(`json: invalid use of ,string struct tag, trying to unmarshal "tru" into bool`)},
870 {in: `{"B": "False"}`, ptr: new(B), err: errors.New(`json: invalid use of ,string struct tag, trying to unmarshal "False" into bool`)},
871 {in: `{"B": "null"}`, ptr: new(B), out: B{false}},
872 {in: `{"B": "nul"}`, ptr: new(B), err: errors.New(`json: invalid use of ,string struct tag, trying to unmarshal "nul" into bool`)},
873 {in: `{"B": [2, 3]}`, ptr: new(B), err: errors.New(`json: invalid use of ,string struct tag, trying to unmarshal unquoted value into bool`)},
874
875
876 {
877 in: `{
878 "Level0": 1,
879 "Level1b": 2,
880 "Level1c": 3,
881 "x": 4,
882 "Level1a": 5,
883 "LEVEL1B": 6,
884 "e": {
885 "Level1a": 8,
886 "Level1b": 9,
887 "Level1c": 10,
888 "Level1d": 11,
889 "x": 12
890 },
891 "Loop1": 13,
892 "Loop2": 14,
893 "X": 15,
894 "Y": 16,
895 "Z": 17,
896 "Q": 18,
897 "extra": true
898 }`,
899 ptr: new(Top),
900 err: fmt.Errorf("json: unknown field \"extra\""),
901 disallowUnknownFields: true,
902 },
903 {
904 in: `{
905 "Level0": 1,
906 "Level1b": 2,
907 "Level1c": 3,
908 "x": 4,
909 "Level1a": 5,
910 "LEVEL1B": 6,
911 "e": {
912 "Level1a": 8,
913 "Level1b": 9,
914 "Level1c": 10,
915 "Level1d": 11,
916 "x": 12,
917 "extra": null
918 },
919 "Loop1": 13,
920 "Loop2": 14,
921 "X": 15,
922 "Y": 16,
923 "Z": 17,
924 "Q": 18
925 }`,
926 ptr: new(Top),
927 err: fmt.Errorf("json: unknown field \"extra\""),
928 disallowUnknownFields: true,
929 },
930
931
932 {
933 in: `{"data":{"test1": "bob", "test2": 123}}`,
934 ptr: new(mapStringToStringData),
935 err: &json.UnmarshalTypeError{Value: "number", Type: reflect.TypeOf(""), Offset: 37, Struct: "mapStringToStringData", Field: "data"},
936 },
937 {
938 in: `{"data":{"test1": 123, "test2": "bob"}}`,
939 ptr: new(mapStringToStringData),
940 err: &json.UnmarshalTypeError{Value: "number", Type: reflect.TypeOf(""), Offset: 21, Struct: "mapStringToStringData", Field: "data"},
941 },
942
943
944 {
945 in: `[1, 2, 3]`,
946 ptr: new(MustNotUnmarshalText),
947 err: &json.UnmarshalTypeError{Value: "array", Type: reflect.TypeOf(&MustNotUnmarshalText{}), Offset: 1},
948 },
949 {
950 in: `{"foo": "bar"}`,
951 ptr: new(MustNotUnmarshalText),
952 err: &json.UnmarshalTypeError{Value: "object", Type: reflect.TypeOf(&MustNotUnmarshalText{}), Offset: 1},
953 },
954
955 {
956 in: `{"PP": {"T": {"Y": "bad-type"}}}`,
957 ptr: new(P),
958 err: &json.UnmarshalTypeError{
959 Value: "string",
960 Struct: "T",
961 Field: "PP.T.Y",
962 Type: reflect.TypeOf(0),
963 Offset: 29,
964 },
965 },
966 {
967 in: `{"Ts": [{"Y": 1}, {"Y": 2}, {"Y": "bad-type"}]}`,
968 ptr: new(PP),
969 err: &json.UnmarshalTypeError{
970 Value: "string",
971 Struct: "T",
972 Field: "Ts.Y",
973 Type: reflect.TypeOf(0),
974 Offset: 29,
975 },
976 },
977
978 {
979 in: `invalid`,
980 ptr: new(json.Number),
981 err: (&JsonSyntaxError{
982 Msg: "invalid character 'i' looking for beginning of value",
983 Offset: 1,
984 }).err(),
985 },
986 {
987 in: `"invalid"`,
988 ptr: new(json.Number),
989 err: fmt.Errorf("json: invalid number literal, trying to unmarshal %q into Number", `"invalid"`),
990 },
991 {
992 in: `{"A":"invalid"}`,
993 ptr: new(struct{ A json.Number }),
994 err: fmt.Errorf("json: invalid number literal, trying to unmarshal %q into Number", `"invalid"`),
995 },
996 {
997 in: `{"A":"invalid"}`,
998 ptr: new(struct {
999 A json.Number `json:",string"`
1000 }),
1001 err: fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into json.Number", `invalid`),
1002 },
1003 {
1004 in: `{"A":"invalid"}`,
1005 ptr: new(map[string]json.Number),
1006 err: fmt.Errorf("json: invalid number literal, trying to unmarshal %q into Number", `"invalid"`),
1007 },
1008 {in: `\u`, ptr: new(interface{}), err: fmt.Errorf("json: invald char"), validateString: true},
1009 {in: `\u`, ptr: new(string), err: fmt.Errorf("json: invald char"), validateString: true},
1010
1011 {in: "\"\x00\"", ptr: new(interface{}), err: fmt.Errorf("json: invald char"), validateString: true},
1012 {in: "\"\x00\"", ptr: new(string), err: fmt.Errorf("json: invald char"), validateString: true},
1013 {in: "\"\xff\"", ptr: new(interface{}), out: interface{}("\ufffd"), validateString: true},
1014 {in: "\"\xff\"", ptr: new(string), out: "\ufffd", validateString: true},
1015 {in: "\"\x00\"", ptr: new(interface{}), out: interface{}("\x00"), validateString: false},
1016 {in: "\"\x00\"", ptr: new(string), out: "\x00", validateString: false},
1017 {in: "\"\xff\"", ptr: new(interface{}), out: interface{}("\xff"), validateString: false},
1018 {in: "\"\xff\"", ptr: new(string), out: "\xff", validateString: false},
1019 }
1020
1021 func trim(b []byte) []byte {
1022 if len(b) > 20 {
1023 return b[0:20]
1024 }
1025 return b
1026 }
1027
1028 func diff(t *testing.T, a, b []byte) {
1029 for i := 0; ; i++ {
1030 if i >= len(a) || i >= len(b) || a[i] != b[i] {
1031 j := i - 10
1032 if j < 0 {
1033 j = 0
1034 }
1035 t.Errorf("diverge at %d: «%s» vs «%s»", i, trim(a[j:]), trim(b[j:]))
1036 return
1037 }
1038 }
1039 }
1040
1041 func TestMarshal(t *testing.T) {
1042 b, err := Marshal(allValue)
1043 if err != nil {
1044 t.Fatalf("Marshal allValue: %v", err)
1045 }
1046 if string(b) != allValueCompact {
1047 t.Errorf("Marshal allValueCompact")
1048 diff(t, b, []byte(allValueCompact))
1049 return
1050 }
1051
1052 b, err = Marshal(pallValue)
1053 if err != nil {
1054 t.Fatalf("Marshal pallValue: %v", err)
1055 }
1056 if string(b) != pallValueCompact {
1057 t.Errorf("Marshal pallValueCompact")
1058 diff(t, b, []byte(pallValueCompact))
1059 return
1060 }
1061 }
1062
1063 func TestMarshalNumberZeroVal(t *testing.T) {
1064 var n json.Number
1065 out, err := Marshal(n)
1066 if err != nil {
1067 t.Fatal(err)
1068 }
1069 outStr := string(out)
1070 if outStr != "0" {
1071 t.Fatalf("Invalid zero val for json.Number: %q", outStr)
1072 }
1073 }
1074
1075 func TestMarshalEmbeds(t *testing.T) {
1076 top := &Top{
1077 Level0: 1,
1078 Embed0: Embed0{
1079 Level1b: 2,
1080 Level1c: 3,
1081 },
1082 Embed0a: &Embed0a{
1083 Level1a: 5,
1084 Level1b: 6,
1085 },
1086 Embed0b: &Embed0b{
1087 Level1a: 8,
1088 Level1b: 9,
1089 Level1c: 10,
1090 Level1d: 11,
1091 Level1e: 12,
1092 },
1093 Loop: Loop{
1094 Loop1: 13,
1095 Loop2: 14,
1096 },
1097 Embed0p: Embed0p{
1098 Point: image.Point{X: 15, Y: 16},
1099 },
1100 Embed0q: Embed0q{
1101 Point: Point{Z: 17},
1102 },
1103 embed: embed{
1104 Q: 18,
1105 },
1106 }
1107 b, err := Marshal(top)
1108 if err != nil {
1109 t.Fatal(err)
1110 }
1111 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}"
1112 if string(b) != want {
1113 t.Errorf("Wrong marshal result.\n got: %q\nwant: %q", b, want)
1114 }
1115 }
1116
1117 func TestUnmarshal(t *testing.T) {
1118 for i, tt := range unmarshalTests {
1119 t.Log(i, tt.in)
1120 if !json.Valid([]byte(tt.in)) {
1121 continue
1122 }
1123 if tt.ptr == nil {
1124 continue
1125 }
1126
1127 typ := reflect.TypeOf(tt.ptr)
1128 if typ.Kind() != reflect.Ptr {
1129 t.Errorf("#%d: unmarshalTest.ptr %T is not a pointer type", i, tt.ptr)
1130 continue
1131 }
1132 typ = typ.Elem()
1133
1134
1135 v := reflect.New(typ)
1136
1137 if !reflect.DeepEqual(tt.ptr, v.Interface()) {
1138
1139
1140
1141
1142
1143
1144 t.Errorf("#%d: unmarshalTest.ptr %#v is not a pointer to a zero value", i, tt.ptr)
1145 continue
1146 }
1147
1148 dec := decoder.NewDecoder(tt.in)
1149 if tt.useNumber {
1150 dec.UseNumber()
1151 }
1152 if tt.disallowUnknownFields {
1153 dec.DisallowUnknownFields()
1154 }
1155 if tt.validateString {
1156 dec.ValidateString()
1157 }
1158 if err := dec.Decode(v.Interface()); (err == nil) != (tt.err == nil) {
1159 spew.Dump(tt)
1160 t.Fatalf("#%d: %v, want %v", i, err, tt.err)
1161 continue
1162 } else if err != nil {
1163 continue
1164 }
1165 if !reflect.DeepEqual(v.Elem().Interface(), tt.out) {
1166 t.Errorf("#%d: mismatch\nhave: %#+v\nwant: %#+v", i, v.Elem().Interface(), tt.out)
1167 data, _ := Marshal(v.Elem().Interface())
1168 println(string(data))
1169 data, _ = Marshal(tt.out)
1170 println(string(data))
1171 continue
1172 }
1173
1174
1175 if tt.err == nil {
1176 enc, err := Marshal(v.Interface())
1177 if err != nil {
1178 t.Errorf("#%d: error re-marshaling: %v", i, err)
1179 continue
1180 }
1181 if tt.golden && !bytes.Equal(enc, []byte(tt.in)) {
1182 t.Errorf("#%d: remarshal mismatch:\nhave: %s\nwant: %s", i, enc, []byte(tt.in))
1183 }
1184 vv := reflect.New(reflect.TypeOf(tt.ptr).Elem())
1185 dec = decoder.NewDecoder(string(enc))
1186 if tt.useNumber {
1187 dec.UseNumber()
1188 }
1189 if err := dec.Decode(vv.Interface()); err != nil {
1190 t.Errorf("#%d: error re-unmarshaling %#q: %v", i, enc, err)
1191 continue
1192 }
1193 if !reflect.DeepEqual(v.Elem().Interface(), vv.Elem().Interface()) {
1194 t.Errorf("#%d: mismatch\nhave: %#+v\nwant: %#+v", i, v.Elem().Interface(), vv.Elem().Interface())
1195 t.Errorf(" In: %q", strings.Map(noSpace, tt.in))
1196 t.Errorf("Marshal: %q", strings.Map(noSpace, string(enc)))
1197 continue
1198 }
1199 }
1200 }
1201 }
1202
1203 var jsonBig []byte
1204
1205 func initBig() {
1206 n := 10000
1207 if testing.Short() {
1208 n = 100
1209 }
1210 b, err := Marshal(genValue(n))
1211 if err != nil {
1212 panic(err)
1213 }
1214 jsonBig = b
1215 }
1216
1217 func genValue(n int) interface{} {
1218 if n > 1 {
1219 switch rand.Intn(2) {
1220 case 0:
1221 return genArray(n)
1222 case 1:
1223 return genMap(n)
1224 }
1225 }
1226 switch rand.Intn(3) {
1227 case 0:
1228 return rand.Intn(2) == 0
1229 case 1:
1230 return float64(rand.Uint64()) / 4294967296
1231 case 2:
1232 return genString(30)
1233 }
1234 panic("unreachable")
1235 }
1236
1237 func genString(stddev float64) string {
1238 n := int(math.Abs(rand.NormFloat64()*stddev + stddev/2))
1239 c := make([]rune, n)
1240 for i := range c {
1241 f := math.Abs(rand.NormFloat64()*64 + 32)
1242 if f > 0x10ffff {
1243 f = 0x10ffff
1244 }
1245 c[i] = rune(f)
1246 }
1247 return string(c)
1248 }
1249
1250 func genArray(n int) []interface{} {
1251 f := int(math.Abs(rand.NormFloat64()) * math.Min(10, float64(n/2)))
1252 if f > n {
1253 f = n
1254 }
1255 if f < 1 {
1256 f = 1
1257 }
1258 x := make([]interface{}, f)
1259 for i := range x {
1260 x[i] = genValue(((i+1)*n)/f - (i*n)/f)
1261 }
1262 return x
1263 }
1264
1265 func genMap(n int) map[string]interface{} {
1266 f := int(math.Abs(rand.NormFloat64()) * math.Min(10, float64(n/2)))
1267 if f > n {
1268 f = n
1269 }
1270 if n > 0 && f == 0 {
1271 f = 1
1272 }
1273 x := make(map[string]interface{})
1274 x[genString(10)] = genValue(n/f)
1275 return x
1276 }
1277
1278 func TestUnmarshalMarshal(t *testing.T) {
1279 initBig()
1280 var v interface{}
1281 if err := Unmarshal(jsonBig, &v); err != nil {
1282 if e, ok := err.(decoder.SyntaxError); ok {
1283 println(e.Description())
1284 }
1285 t.Fatalf("Unmarshal: %v", err)
1286 }
1287 b, err := Marshal(v)
1288 if err != nil {
1289 t.Fatalf("Marshal: %v", err)
1290 }
1291 if !bytes.Equal(jsonBig, b) {
1292 t.Errorf("Marshal jsonBig")
1293 diff(t, b, jsonBig)
1294 println(string(b))
1295 println(string(jsonBig))
1296 return
1297 }
1298 }
1299
1300 var numberTests = []struct {
1301 in string
1302 i int64
1303 intErr string
1304 f float64
1305 floatErr string
1306 }{
1307 {in: "-1.23e1", intErr: "strconv.ParseInt: parsing \"-1.23e1\": invalid syntax", f: -1.23e1},
1308 {in: "-12", i: -12, f: -12.0},
1309 {in: "1e1000", intErr: "strconv.ParseInt: parsing \"1e1000\": invalid syntax", floatErr: "strconv.ParseFloat: parsing \"1e1000\": value out of range"},
1310 }
1311
1312
1313 func TestNumberAccessors(t *testing.T) {
1314 for _, tt := range numberTests {
1315 n := json.Number(tt.in)
1316 if s := n.String(); s != tt.in {
1317 t.Errorf("json.Number(%q).String() is %q", tt.in, s)
1318 }
1319 if i, err := n.Int64(); err == nil && tt.intErr == "" && i != tt.i {
1320 t.Errorf("json.Number(%q).Int64() is %d", tt.in, i)
1321 } else if (err == nil && tt.intErr != "") || (err != nil && err.Error() != tt.intErr) {
1322 t.Errorf("json.Number(%q).Int64() wanted error %q but got: %v", tt.in, tt.intErr, err)
1323 }
1324 if f, err := n.Float64(); err == nil && tt.floatErr == "" && f != tt.f {
1325 t.Errorf("json.Number(%q).Float64() is %g", tt.in, f)
1326 } else if (err == nil && tt.floatErr != "") || (err != nil && err.Error() != tt.floatErr) {
1327 t.Errorf("json.Number(%q).Float64() wanted error %q but got: %v", tt.in, tt.floatErr, err)
1328 }
1329 }
1330 }
1331
1332 func TestLargeByteSlice(t *testing.T) {
1333 s0 := make([]byte, 2000)
1334 for i := range s0 {
1335 s0[i] = byte(i)
1336 }
1337 b, err := Marshal(s0)
1338 if err != nil {
1339 t.Fatalf("Marshal: %v", err)
1340 }
1341 var s1 []byte
1342 if err := Unmarshal(b, &s1); err != nil {
1343 t.Fatalf("Unmarshal: %v", err)
1344 }
1345 if !bytes.Equal(s0, s1) {
1346 t.Errorf("Marshal large byte slice")
1347 diff(t, s0, s1)
1348 }
1349 }
1350
1351 type Xint struct {
1352 X int
1353 }
1354
1355 func TestUnmarshalPtrPtr(t *testing.T) {
1356 var xint Xint
1357 pxint := &xint
1358 if err := Unmarshal([]byte(`{"X":1}`), &pxint); err != nil {
1359 t.Fatalf("Unmarshal: %v", err)
1360 }
1361 if xint.X != 1 {
1362 t.Fatalf("Did not write to xint")
1363 }
1364 }
1365
1366 func isSpace(c byte) bool {
1367 return c <= ' ' && (c == ' ' || c == '\t' || c == '\r' || c == '\n')
1368 }
1369
1370 func noSpace(c rune) rune {
1371 if isSpace(byte(c)) {
1372 return -1
1373 }
1374 return c
1375 }
1376
1377 type All struct {
1378 Bool bool
1379 Int int
1380 Int8 int8
1381 Int16 int16
1382 Int32 int32
1383 Int64 int64
1384 Uint uint
1385 Uint8 uint8
1386 Uint16 uint16
1387 Uint32 uint32
1388 Uint64 uint64
1389 Uintptr uintptr
1390 Float32 float32
1391 Float64 float64
1392
1393 Foo string `json:"bar"`
1394 Foo2 string `json:"bar2,dummyopt"`
1395
1396 IntStr int64 `json:",string"`
1397 UintptrStr uintptr `json:",string"`
1398
1399 PBool *bool
1400 PInt *int
1401 PInt8 *int8
1402 PInt16 *int16
1403 PInt32 *int32
1404 PInt64 *int64
1405 PUint *uint
1406 PUint8 *uint8
1407 PUint16 *uint16
1408 PUint32 *uint32
1409 PUint64 *uint64
1410 PUintptr *uintptr
1411 PFloat32 *float32
1412 PFloat64 *float64
1413
1414 String string
1415 PString *string
1416
1417 Map map[string]Small
1418 MapP map[string]*Small
1419 MapPNil map[string]*Small
1420 PMap *map[string]Small
1421 PMapP *map[string]*Small
1422 PMapPNil *map[string]*Small
1423
1424 EmptyMap map[string]Small
1425 NilMap map[string]Small
1426
1427 Slice []Small
1428 SliceP []*Small
1429 PSlice *[]Small
1430 PSliceP *[]*Small
1431
1432 EmptySlice []Small
1433 NilSlice []Small
1434
1435 StringSlice []string
1436 ByteSlice []byte
1437
1438 Small Small
1439 PSmall *Small
1440 PPSmall **Small
1441
1442 Interface interface{}
1443 PInterface *interface{}
1444
1445 unexported int
1446 }
1447
1448 type Small struct {
1449 Tag string
1450 }
1451
1452 var allValue = All{
1453 Bool: true,
1454 Int: 2,
1455 Int8: 3,
1456 Int16: 4,
1457 Int32: 5,
1458 Int64: 6,
1459 Uint: 7,
1460 Uint8: 8,
1461 Uint16: 9,
1462 Uint32: 10,
1463 Uint64: 11,
1464 Uintptr: 12,
1465 Float32: 14.25,
1466 Float64: 15.25,
1467 Foo: "foo",
1468 Foo2: "foo2",
1469 IntStr: 42,
1470 UintptrStr: 44,
1471 String: "16",
1472 Map: map[string]Small{
1473 "17": {Tag: "tag17"},
1474 },
1475 MapP: map[string]*Small{
1476 "18": {Tag: "tag19"},
1477 },
1478 MapPNil: map[string]*Small{
1479 "19": nil,
1480 },
1481 EmptyMap: map[string]Small{},
1482 Slice: []Small{{Tag: "tag20"}, {Tag: "tag21"}},
1483 SliceP: []*Small{{Tag: "tag22"}, nil, {Tag: "tag23"}},
1484 EmptySlice: []Small{},
1485 StringSlice: []string{"str24", "str25", "str26"},
1486 ByteSlice: []byte{27, 28, 29},
1487 Small: Small{Tag: "tag30"},
1488 PSmall: &Small{Tag: "tag31"},
1489 Interface: 5.2,
1490 }
1491
1492 var pallValue = All{
1493 PBool: &allValue.Bool,
1494 PInt: &allValue.Int,
1495 PInt8: &allValue.Int8,
1496 PInt16: &allValue.Int16,
1497 PInt32: &allValue.Int32,
1498 PInt64: &allValue.Int64,
1499 PUint: &allValue.Uint,
1500 PUint8: &allValue.Uint8,
1501 PUint16: &allValue.Uint16,
1502 PUint32: &allValue.Uint32,
1503 PUint64: &allValue.Uint64,
1504 PUintptr: &allValue.Uintptr,
1505 PFloat32: &allValue.Float32,
1506 PFloat64: &allValue.Float64,
1507 PString: &allValue.String,
1508 PMap: &allValue.Map,
1509 PMapP: &allValue.MapP,
1510 PMapPNil: &allValue.MapPNil,
1511 PSlice: &allValue.Slice,
1512 PSliceP: &allValue.SliceP,
1513 PPSmall: &allValue.PSmall,
1514 PInterface: &allValue.Interface,
1515 }
1516
1517 var allValueIndent = `{
1518 "Bool": true,
1519 "Int": 2,
1520 "Int8": 3,
1521 "Int16": 4,
1522 "Int32": 5,
1523 "Int64": 6,
1524 "Uint": 7,
1525 "Uint8": 8,
1526 "Uint16": 9,
1527 "Uint32": 10,
1528 "Uint64": 11,
1529 "Uintptr": 12,
1530 "Float32": 14.25,
1531 "Float64": 15.25,
1532 "bar": "foo",
1533 "bar2": "foo2",
1534 "IntStr": "42",
1535 "UintptrStr": "44",
1536 "PBool": null,
1537 "PInt": null,
1538 "PInt8": null,
1539 "PInt16": null,
1540 "PInt32": null,
1541 "PInt64": null,
1542 "PUint": null,
1543 "PUint8": null,
1544 "PUint16": null,
1545 "PUint32": null,
1546 "PUint64": null,
1547 "PUintptr": null,
1548 "PFloat32": null,
1549 "PFloat64": null,
1550 "String": "16",
1551 "PString": null,
1552 "Map": {
1553 "17": {
1554 "Tag": "tag17"
1555 }
1556 },
1557 "MapP": {
1558 "18": {
1559 "Tag": "tag19"
1560 }
1561 },
1562 "MapPNil": {
1563 "19": null
1564 },
1565 "PMap": null,
1566 "PMapP": null,
1567 "PMapPNil": null,
1568 "EmptyMap": {},
1569 "NilMap": null,
1570 "Slice": [
1571 {
1572 "Tag": "tag20"
1573 },
1574 {
1575 "Tag": "tag21"
1576 }
1577 ],
1578 "SliceP": [
1579 {
1580 "Tag": "tag22"
1581 },
1582 null,
1583 {
1584 "Tag": "tag23"
1585 }
1586 ],
1587 "PSlice": null,
1588 "PSliceP": null,
1589 "EmptySlice": [],
1590 "NilSlice": null,
1591 "StringSlice": [
1592 "str24",
1593 "str25",
1594 "str26"
1595 ],
1596 "ByteSlice": "Gxwd",
1597 "Small": {
1598 "Tag": "tag30"
1599 },
1600 "PSmall": {
1601 "Tag": "tag31"
1602 },
1603 "PPSmall": null,
1604 "Interface": 5.2,
1605 "PInterface": null
1606 }`
1607
1608 var allValueCompact = strings.Map(noSpace, allValueIndent)
1609
1610 var pallValueIndent = `{
1611 "Bool": false,
1612 "Int": 0,
1613 "Int8": 0,
1614 "Int16": 0,
1615 "Int32": 0,
1616 "Int64": 0,
1617 "Uint": 0,
1618 "Uint8": 0,
1619 "Uint16": 0,
1620 "Uint32": 0,
1621 "Uint64": 0,
1622 "Uintptr": 0,
1623 "Float32": 0,
1624 "Float64": 0,
1625 "bar": "",
1626 "bar2": "",
1627 "IntStr": "0",
1628 "UintptrStr": "0",
1629 "PBool": true,
1630 "PInt": 2,
1631 "PInt8": 3,
1632 "PInt16": 4,
1633 "PInt32": 5,
1634 "PInt64": 6,
1635 "PUint": 7,
1636 "PUint8": 8,
1637 "PUint16": 9,
1638 "PUint32": 10,
1639 "PUint64": 11,
1640 "PUintptr": 12,
1641 "PFloat32": 14.25,
1642 "PFloat64": 15.25,
1643 "String": "",
1644 "PString": "16",
1645 "Map": null,
1646 "MapP": null,
1647 "MapPNil": null,
1648 "PMap": {
1649 "17": {
1650 "Tag": "tag17"
1651 }
1652 },
1653 "PMapP": {
1654 "18": {
1655 "Tag": "tag19"
1656 }
1657 },
1658 "PMapPNil": {
1659 "19": null
1660 },
1661 "EmptyMap": null,
1662 "NilMap": null,
1663 "Slice": null,
1664 "SliceP": null,
1665 "PSlice": [
1666 {
1667 "Tag": "tag20"
1668 },
1669 {
1670 "Tag": "tag21"
1671 }
1672 ],
1673 "PSliceP": [
1674 {
1675 "Tag": "tag22"
1676 },
1677 null,
1678 {
1679 "Tag": "tag23"
1680 }
1681 ],
1682 "EmptySlice": null,
1683 "NilSlice": null,
1684 "StringSlice": null,
1685 "ByteSlice": null,
1686 "Small": {
1687 "Tag": ""
1688 },
1689 "PSmall": null,
1690 "PPSmall": {
1691 "Tag": "tag31"
1692 },
1693 "Interface": null,
1694 "PInterface": 5.2
1695 }`
1696
1697 var pallValueCompact = strings.Map(noSpace, pallValueIndent)
1698
1699 func TestRefUnmarshal(t *testing.T) {
1700 type S struct {
1701
1702 R0 Ref
1703 R1 *Ref
1704 R2 RefText
1705 R3 *RefText
1706 }
1707 want := S{
1708 R0: 12,
1709 R1: new(Ref),
1710 R2: 13,
1711 R3: new(RefText),
1712 }
1713 *want.R1 = 12
1714 *want.R3 = 13
1715
1716 var got S
1717 if err := Unmarshal([]byte(`{"R0":"ref","R1":"ref","R2":"ref","R3":"ref"}`), &got); err != nil {
1718 t.Fatalf("Unmarshal: %v", err)
1719 }
1720 if !reflect.DeepEqual(got, want) {
1721 t.Errorf("got %+v, want %+v", got, want)
1722 }
1723 }
1724
1725
1726
1727 func TestEmptyString(t *testing.T) {
1728 type T2 struct {
1729 Number1 int `json:",string"`
1730 Number2 string `json:",string"`
1731 Pass bool `json:",string"`
1732 }
1733 data := `{"Number1":"1", "Number2":"","Pass":"true"}`
1734 var t2, t3 T2
1735 t2.Number2 = "a"
1736 t3.Number2 = "a"
1737 err := Unmarshal([]byte(data), &t2)
1738 if err == nil {
1739 t.Fatal("Decode: did not return error")
1740 }
1741 println(err.Error())
1742 err2 := json.Unmarshal([]byte(data), &t3)
1743 assert.Equal(t, err == nil, err2 == nil)
1744 assert.Equal(t, t3, t2)
1745 }
1746
1747
1748
1749 func TestNullString(t *testing.T) {
1750 type T struct {
1751 A int `json:",string"`
1752 B int `json:",string"`
1753 C *int `json:",string"`
1754 }
1755 data := []byte(`{"A": "1", "B": null, "C": null}`)
1756 var s T
1757 s.B = 1
1758 s.C = new(int)
1759 *s.C = 2
1760 err := Unmarshal(data, &s)
1761 if err != nil {
1762 t.Fatalf("Unmarshal: %v", err)
1763 }
1764 if s.B != 1 || s.C != nil {
1765 t.Fatalf("after Unmarshal, s.B=%d, s.C=%p, want 1, nil", s.B, s.C)
1766 }
1767 }
1768
1769 type NullTest struct {
1770 Bool bool
1771 Int int
1772 Int8 int8
1773 Int16 int16
1774 Int32 int32
1775 Int64 int64
1776 Uint uint
1777 Uint8 uint8
1778 Uint16 uint16
1779 Uint32 uint32
1780 Uint64 uint64
1781 Float32 float32
1782 Float64 float64
1783 String string
1784 PBool *bool
1785 Map map[string]string
1786 Slice []string
1787 Interface interface{}
1788
1789 PRaw *json.RawMessage
1790 PTime *time.Time
1791 PBigInt *big.Int
1792 PText *MustNotUnmarshalText
1793 PBuffer *bytes.Buffer
1794 PStruct *struct{}
1795
1796 Raw json.RawMessage
1797 Time time.Time
1798 BigInt big.Int
1799 Text MustNotUnmarshalText
1800 Buffer bytes.Buffer
1801 Struct struct{}
1802 }
1803
1804
1805
1806 func TestUnmarshalNulls(t *testing.T) {
1807
1808
1809
1810
1811
1812
1813 jsonData := []byte(`{
1814 "Bool" : null,
1815 "Int" : null,
1816 "Int8" : null,
1817 "Int16" : null,
1818 "Int32" : null,
1819 "Int64" : null,
1820 "Uint" : null,
1821 "Uint8" : null,
1822 "Uint16" : null,
1823 "Uint32" : null,
1824 "Uint64" : null,
1825 "Float32" : null,
1826 "Float64" : null,
1827 "String" : null,
1828 "PBool": null,
1829 "Map": null,
1830 "Slice": null,
1831 "Interface": null,
1832 "PRaw": null,
1833 "PTime": null,
1834 "PBigInt": null,
1835 "PText": null,
1836 "PBuffer": null,
1837 "PStruct": null,
1838 "Raw": null,
1839 "Time": null,
1840 "BigInt": null,
1841 "Text": null,
1842 "Buffer": null,
1843 "Struct": null
1844 }`)
1845 nulls := NullTest{
1846 Bool: true,
1847 Int: 2,
1848 Int8: 3,
1849 Int16: 4,
1850 Int32: 5,
1851 Int64: 6,
1852 Uint: 7,
1853 Uint8: 8,
1854 Uint16: 9,
1855 Uint32: 10,
1856 Uint64: 11,
1857 Float32: 12.1,
1858 Float64: 13.1,
1859 String: "14",
1860 PBool: new(bool),
1861 Map: map[string]string{},
1862 Slice: []string{},
1863 Interface: new(MustNotUnmarshalJSON),
1864 PRaw: new(json.RawMessage),
1865 PTime: new(time.Time),
1866 PBigInt: new(big.Int),
1867 PText: new(MustNotUnmarshalText),
1868 PStruct: new(struct{}),
1869 PBuffer: new(bytes.Buffer),
1870 Raw: json.RawMessage("123"),
1871 Time: time.Unix(123456789, 0),
1872 BigInt: *big.NewInt(123),
1873 }
1874
1875 before := nulls.Time.String()
1876
1877 err := Unmarshal(jsonData, &nulls)
1878 if err != nil {
1879 t.Errorf("Unmarshal of null values failed: %v", err)
1880 }
1881 if !nulls.Bool || nulls.Int != 2 || nulls.Int8 != 3 || nulls.Int16 != 4 || nulls.Int32 != 5 || nulls.Int64 != 6 ||
1882 nulls.Uint != 7 || nulls.Uint8 != 8 || nulls.Uint16 != 9 || nulls.Uint32 != 10 || nulls.Uint64 != 11 ||
1883 nulls.Float32 != 12.1 || nulls.Float64 != 13.1 || nulls.String != "14" {
1884 t.Errorf("Unmarshal of null values affected primitives")
1885 }
1886
1887 if nulls.PBool != nil {
1888 t.Errorf("Unmarshal of null did not clear nulls.PBool")
1889 }
1890 if nulls.Map != nil {
1891 t.Errorf("Unmarshal of null did not clear nulls.Map")
1892 }
1893 if nulls.Slice != nil {
1894 t.Errorf("Unmarshal of null did not clear nulls.Slice")
1895 }
1896 if nulls.Interface != nil {
1897 t.Errorf("Unmarshal of null did not clear nulls.Interface")
1898 }
1899 if nulls.PRaw != nil {
1900 t.Errorf("Unmarshal of null did not clear nulls.PRaw")
1901 }
1902 if nulls.PTime != nil {
1903 t.Errorf("Unmarshal of null did not clear nulls.PTime")
1904 }
1905 if nulls.PBigInt != nil {
1906 t.Errorf("Unmarshal of null did not clear nulls.PBigInt")
1907 }
1908 if nulls.PText != nil {
1909 t.Errorf("Unmarshal of null did not clear nulls.PText")
1910 }
1911 if nulls.PBuffer != nil {
1912 t.Errorf("Unmarshal of null did not clear nulls.PBuffer")
1913 }
1914 if nulls.PStruct != nil {
1915 t.Errorf("Unmarshal of null did not clear nulls.PStruct")
1916 }
1917
1918 if string(nulls.Raw) != "null" {
1919 t.Errorf("Unmarshal of json.RawMessage null did not record null: %v", string(nulls.Raw))
1920 }
1921 if nulls.Time.String() != before {
1922 t.Errorf("Unmarshal of time.Time null set time to %v", nulls.Time.String())
1923 }
1924 if nulls.BigInt.String() != "123" {
1925 t.Errorf("Unmarshal of big.Int null set int to %v", nulls.BigInt.String())
1926 }
1927 }
1928
1929 type MustNotUnmarshalJSON struct{}
1930
1931 func (x MustNotUnmarshalJSON) UnmarshalJSON(_ []byte) error {
1932 return errors.New("MustNotUnmarshalJSON was used")
1933 }
1934
1935 type MustNotUnmarshalText struct{}
1936
1937 func (x MustNotUnmarshalText) UnmarshalText(_ []byte) error {
1938 return errors.New("MustNotUnmarshalText was used")
1939 }
1940
1941 func TestStringKind(t *testing.T) {
1942 type stringKind string
1943
1944 var m1, m2 map[stringKind]int
1945 m1 = map[stringKind]int{
1946 "foo": 42,
1947 }
1948
1949 data, err := Marshal(m1)
1950 if err != nil {
1951 t.Errorf("Unexpected error marshaling: %v", err)
1952 }
1953
1954 err = Unmarshal(data, &m2)
1955 if err != nil {
1956 t.Errorf("Unexpected error unmarshaling: %v", err)
1957 }
1958
1959 if !reflect.DeepEqual(m1, m2) {
1960 t.Error("Items should be equal after encoding and then decoding")
1961 }
1962 }
1963
1964
1965
1966
1967 func TestByteKind(t *testing.T) {
1968 type byteKind []byte
1969
1970 a := byteKind("hello")
1971
1972 data, err := Marshal(a)
1973 if err != nil {
1974 t.Error(err)
1975 }
1976 var b byteKind
1977 err = Unmarshal(data, &b)
1978 if err != nil {
1979 t.Fatal(err)
1980 }
1981 if !reflect.DeepEqual(a, b) {
1982 t.Errorf("expected %v == %v", a, b)
1983 }
1984 }
1985
1986
1987
1988 func TestSliceOfCustomByte(t *testing.T) {
1989 type Uint8 uint8
1990
1991 a := []Uint8("hello")
1992
1993 data, err := Marshal(a)
1994 if err != nil {
1995 t.Fatal(err)
1996 }
1997 var b []Uint8
1998 err = Unmarshal(data, &b)
1999 if err != nil {
2000 t.Fatal(err)
2001 }
2002 if !reflect.DeepEqual(a, b) {
2003 t.Fatalf("expected %v == %v", a, b)
2004 }
2005 }
2006
2007 var decodeTypeErrorTests = []struct {
2008 dest interface{}
2009 src string
2010 }{
2011 {new(error), `{}`},
2012 {new(error), `[]`},
2013 {new(error), `""`},
2014 {new(error), `123`},
2015 {new(error), `true`},
2016 }
2017
2018 func TestUnmarshalTypeError(t *testing.T) {
2019 for _, item := range decodeTypeErrorTests {
2020 err := Unmarshal([]byte(item.src), item.dest)
2021 if _, ok := err.(*json.UnmarshalTypeError); !ok {
2022 if _, ok = err.(decoder.SyntaxError); !ok {
2023 t.Errorf("expected type error for Unmarshal(%q, type %T): got %T",
2024 item.src, item.dest, err)
2025 }
2026 }
2027 }
2028 }
2029
2030 var decodeMismatchErrorTests = []struct {
2031 dest interface{}
2032 src string
2033 }{
2034 {new(int), `{}`},
2035 {new(string), `{}`},
2036 {new(bool), `{}`},
2037 {new([]byte), `{}`},
2038 }
2039
2040 func TestMismatchTypeError(t *testing.T) {
2041 for _, item := range decodeMismatchErrorTests {
2042 err := Unmarshal([]byte(item.src), item.dest)
2043 if _, ok := err.(*decoder.MismatchTypeError); !ok {
2044 if _, ok = err.(decoder.SyntaxError); !ok {
2045 t.Errorf("expected mismatch error for Unmarshal(%q, type %T): got %T",
2046 item.src, item.dest, err)
2047 }
2048 }
2049 }
2050 }
2051
2052 var unmarshalSyntaxTests = []string{
2053 "tru",
2054 "fals",
2055 "nul",
2056 "123e",
2057 `"hello`,
2058 `[1,2,3`,
2059 `{"key":1`,
2060 `{"key":1,`,
2061 }
2062
2063 func TestUnmarshalSyntax(t *testing.T) {
2064 var x interface{}
2065 for _, src := range unmarshalSyntaxTests {
2066 err := Unmarshal([]byte(src), &x)
2067 if _, ok := err.(decoder.SyntaxError); !ok {
2068 t.Errorf("expected syntax error for Unmarshal(%q): got %T", src, err)
2069 }
2070 }
2071 }
2072
2073
2074
2075
2076 type unexportedFields struct {
2077 Name string
2078 m map[string]interface{} `json:"-"`
2079 m2 map[string]interface{} `json:"abcd"`
2080
2081 s []int `json:"-"`
2082 }
2083
2084 func TestUnmarshalUnexported(t *testing.T) {
2085 input := `{"Name": "Bob", "m": {"x": 123}, "m2": {"y": 456}, "abcd": {"z": 789}, "s": [2, 3]}`
2086 want := &unexportedFields{Name: "Bob"}
2087
2088 out := &unexportedFields{}
2089 err := Unmarshal([]byte(input), out)
2090 if err != nil {
2091 t.Errorf("got error %v, expected nil", err)
2092 }
2093 if !reflect.DeepEqual(out, want) {
2094 t.Errorf("got %q, want %q", out, want)
2095 }
2096 }
2097
2098
2099
2100 type Time3339 time.Time
2101
2102 func (t *Time3339) UnmarshalJSON(b []byte) error {
2103 if len(b) < 2 || b[0] != '"' || b[len(b)-1] != '"' {
2104 return fmt.Errorf("types: failed to unmarshal non-string value %q as an RFC 3339 time", b)
2105 }
2106 tm, err := time.Parse(time.RFC3339, string(b[1:len(b)-1]))
2107 if err != nil {
2108 return err
2109 }
2110 *t = Time3339(tm)
2111 return nil
2112 }
2113
2114 func TestUnmarshalJSONLiteralError(t *testing.T) {
2115 var t3 Time3339
2116 err := Unmarshal([]byte(`"0000-00-00T00:00:00Z"`), &t3)
2117 if err == nil {
2118 t.Fatalf("expected error; got time %v", time.Time(t3))
2119 }
2120 if !strings.Contains(err.Error(), "range") {
2121 t.Errorf("got err = %v; want out of range error", err)
2122 }
2123 }
2124
2125
2126
2127
2128 func TestSkipArrayObjects(t *testing.T) {
2129 s := `[{}]`
2130 var dest [0]interface{}
2131
2132 err := Unmarshal([]byte(s), &dest)
2133 if err != nil {
2134 t.Errorf("got error %q, want nil", err)
2135 }
2136 }
2137
2138
2139
2140
2141 func TestPrefilled(t *testing.T) {
2142
2143 var prefillTests = []struct {
2144 in string
2145 ptr interface{}
2146 out interface{}
2147 }{
2148 {
2149 in: `{"X": 1, "Y": 2}`,
2150 ptr: &XYZ{X: float32(3), Y: int16(4), Z: 1.5},
2151 out: &XYZ{X: float64(1), Y: float64(2), Z: 1.5},
2152 },
2153 {
2154 in: `{"X": 1, "Y": 2}`,
2155 ptr: &map[string]interface{}{"X": float32(3), "Y": int16(4), "Z": 1.5},
2156 out: &map[string]interface{}{"X": float64(1), "Y": float64(2), "Z": 1.5},
2157 },
2158 {
2159 in: `[2]`,
2160 ptr: &[]int{1},
2161 out: &[]int{2},
2162 },
2163 {
2164 in: `[2, 3]`,
2165 ptr: &[]int{1},
2166 out: &[]int{2, 3},
2167 },
2168 {
2169 in: `[2, 3]`,
2170 ptr: &[...]int{1},
2171 out: &[...]int{2},
2172 },
2173 {
2174 in: `[3]`,
2175 ptr: &[...]int{1, 2},
2176 out: &[...]int{3, 0},
2177 },
2178 }
2179
2180 for _, tt := range prefillTests {
2181 ptrstr := fmt.Sprintf("%v", tt.ptr)
2182 err := Unmarshal([]byte(tt.in), tt.ptr)
2183 if err != nil {
2184 t.Errorf("Unmarshal: %v", err)
2185 }
2186 if !reflect.DeepEqual(tt.ptr, tt.out) {
2187 t.Errorf("Unmarshal(%#q, %s): have %v, want %v", tt.in, ptrstr, tt.ptr, tt.out)
2188 }
2189 }
2190 }
2191
2192 var invalidUnmarshalTests = []struct {
2193 v interface{}
2194 want string
2195 }{
2196 {nil, "json: Unmarshal(nil)"},
2197 {struct{}{}, "json: Unmarshal(non-pointer struct {})"},
2198 {(*int)(nil), "json: Unmarshal(nil *int)"},
2199 }
2200
2201 func TestInvalidUnmarshal(t *testing.T) {
2202 buf := []byte(`{"a":"1"}`)
2203 for _, tt := range invalidUnmarshalTests {
2204 err := Unmarshal(buf, tt.v)
2205 if err == nil {
2206 t.Errorf("Unmarshal expecting error, got nil")
2207 continue
2208 }
2209 if got := err.Error(); got != tt.want {
2210 t.Errorf("Unmarshal = %q; want %q", got, tt.want)
2211 }
2212 }
2213 }
2214
2215 var invalidUnmarshalTextTests = []struct {
2216 v interface{}
2217 want string
2218 }{
2219 {nil, "json: Unmarshal(nil)"},
2220 {struct{}{}, "json: Unmarshal(non-pointer struct {})"},
2221 {(*int)(nil), "json: Unmarshal(nil *int)"},
2222 {new(net.IP), "json: cannot unmarshal number into Go value of type *net.IP"},
2223 }
2224
2225 func TestInvalidUnmarshalText(t *testing.T) {
2226 buf := []byte(`123`)
2227 for _, tt := range invalidUnmarshalTextTests {
2228 err := Unmarshal(buf, tt.v)
2229 if err == nil {
2230 t.Errorf("Unmarshal expecting error, got nil")
2231 continue
2232 }
2233 }
2234 }
2235
2236
2237
2238 func TestInvalidStringOption(t *testing.T) {
2239 num := 0
2240 item := struct {
2241 T time.Time `json:",string"`
2242 M map[string]string `json:",string"`
2243 S []string `json:",string"`
2244 A [1]string `json:",string"`
2245 I interface{} `json:",string"`
2246 P *int `json:",string"`
2247 }{M: make(map[string]string), S: make([]string, 0), I: num, P: &num}
2248
2249 data, err := Marshal(item)
2250 if err != nil {
2251 t.Fatalf("Marshal: %v", err)
2252 }
2253 err = Unmarshal(data, &item)
2254 if err != nil {
2255 t.Fatalf("Unmarshal: %v", err)
2256 }
2257 }
2258
2259 func TestUnmarshalErrorAfterMultipleJSON(t *testing.T) {
2260 tests := []struct {
2261 in string
2262 err error
2263 }{{
2264 in: `1 false null :`,
2265 err: (&JsonSyntaxError{"invalid character ':' looking for beginning of value", 13}).err(),
2266 }, {
2267 in: `1 [] [,]`,
2268 err: (&JsonSyntaxError{"invalid character ',' looking for beginning of value", 6}).err(),
2269 }, {
2270 in: `1 [] [true:]`,
2271 err: (&JsonSyntaxError{"invalid character ':' after array element", 10}).err(),
2272 }, {
2273 in: `1 {} {"x"=}`,
2274 err: (&JsonSyntaxError{"invalid character '=' after object key", 13}).err(),
2275 }, {
2276 in: `falsetruenul#`,
2277 err: (&JsonSyntaxError{"invalid character '#' in literal null (expecting 'l')", 12}).err(),
2278 }}
2279 for i, tt := range tests {
2280 dec := decoder.NewDecoder(tt.in)
2281 var err error
2282 for {
2283 var v interface{}
2284 if err = dec.Decode(&v); err != nil {
2285 break
2286 }
2287 }
2288 if v, ok := err.(decoder.SyntaxError); !ok {
2289 t.Errorf("#%d: got %#v, want %#v", i, err, tt.err)
2290 } else if v.Pos != int(tt.err.(*json.SyntaxError).Offset) {
2291 t.Errorf("#%d: got %#v, want %#v", i, err, tt.err)
2292 println(v.Description())
2293 }
2294 }
2295 }
2296
2297 type unmarshalPanic struct{}
2298
2299 func (unmarshalPanic) UnmarshalJSON([]byte) error { panic(0xdead) }
2300
2301 func TestUnmarshalPanic(t *testing.T) {
2302 defer func() {
2303 if got := recover(); !reflect.DeepEqual(got, 0xdead) {
2304 t.Errorf("panic() = (%T)(%v), want 0xdead", got, got)
2305 }
2306 }()
2307 _ = Unmarshal([]byte("{}"), &unmarshalPanic{})
2308 t.Fatalf("Unmarshal should have panicked")
2309 }
2310
2311
2312
2313 func TestUnmarshalRecursivePointer(t *testing.T) {
2314 var v interface{}
2315 v = &v
2316 data := []byte(`{"a": "b"}`)
2317
2318 if err := Unmarshal(data, v); err != nil {
2319 t.Fatal(err)
2320 }
2321 }
2322
2323 type textUnmarshalerString string
2324
2325 func (m *textUnmarshalerString) UnmarshalText(text []byte) error {
2326 *m = textUnmarshalerString(strings.ToLower(string(text)))
2327 return nil
2328 }
2329
2330
2331
2332 func TestUnmarshalMapWithTextUnmarshalerStringKey(t *testing.T) {
2333 var p map[textUnmarshalerString]string
2334 if err := Unmarshal([]byte(`{"FOO": "1"}`), &p); err != nil {
2335 t.Fatalf("Unmarshal unexpected error: %v", err)
2336 }
2337
2338 if _, ok := p["foo"]; !ok {
2339 t.Errorf(`Key "foo" does not exist in map: %v`, p)
2340 }
2341 }
2342
2343 func TestUnmarshalRescanLiteralMangledUnquote(t *testing.T) {
2344
2345 var p map[textUnmarshalerString]string
2346 if err := Unmarshal([]byte(`{"开源":"12345开源"}`), &p); err != nil {
2347 t.Fatalf("Unmarshal unexpected error: %v", err)
2348 }
2349 if _, ok := p["开源"]; !ok {
2350 t.Errorf(`Key "开源" does not exist in map: %v`, p)
2351 }
2352
2353
2354 type T struct {
2355 F1 string `json:"F1,string"`
2356 }
2357 t1 := T{"aaa\tbbb"}
2358
2359 b, err := Marshal(t1)
2360 if err != nil {
2361 t.Fatalf("Marshal unexpected error: %v", err)
2362 }
2363 var t2 T
2364 if err := Unmarshal(b, &t2); err != nil {
2365 t.Fatalf("Unmarshal unexpected error: %v", err)
2366 }
2367 if t1 != t2 {
2368 t.Errorf("Marshal and Unmarshal roundtrip mismatch: want %q got %q", t1, t2)
2369 }
2370
2371
2372 input := map[textUnmarshalerString]string{"FOO": "", `"`: ""}
2373
2374 encoded, err := Marshal(input)
2375 if err != nil {
2376 t.Fatalf("Marshal unexpected error: %v", err)
2377 }
2378 var got map[textUnmarshalerString]string
2379 if err := Unmarshal(encoded, &got); err != nil {
2380 t.Fatalf("Unmarshal unexpected error: %v", err)
2381 }
2382 want := map[textUnmarshalerString]string{"foo": "", `"`: ""}
2383 if !reflect.DeepEqual(want, got) {
2384 t.Fatalf("Unexpected roundtrip result:\nwant: %q\ngot: %q", want, got)
2385 }
2386 }
2387
2388 func TestUnmarshalMaxDepth(t *testing.T) {
2389 const (
2390 _MaxDepth = types.MAX_RECURSE
2391 _OverMaxDepth = types.MAX_RECURSE + 1
2392 _UnderMaxDepth = types.MAX_RECURSE - 2
2393 )
2394 testcases := []struct {
2395 name string
2396 data string
2397 errMaxDepth bool
2398 }{
2399 {
2400 name: "ArrayUnderMaxNestingDepth",
2401 data: `{"a":` + strings.Repeat(`[`, _UnderMaxDepth) + `0` + strings.Repeat(`]`, _UnderMaxDepth) + `}`,
2402 errMaxDepth: false,
2403 },
2404 {
2405 name: "ArrayOverMaxNestingDepth",
2406 data: `{"a":` + strings.Repeat(`[`, _OverMaxDepth) + `0` + strings.Repeat(`]`, _OverMaxDepth) + `}`,
2407 errMaxDepth: true,
2408 },
2409 {
2410 name: "ArrayOverStackDepth",
2411 data: `{"a":` + strings.Repeat(`[`, 3000000) + `0` + strings.Repeat(`]`, 3000000) + `}`,
2412 errMaxDepth: true,
2413 },
2414 {
2415 name: "ObjectUnderMaxNestingDepth",
2416 data: `{"a":` + strings.Repeat(`{"a":`, _UnderMaxDepth) + `0` + strings.Repeat(`}`, _UnderMaxDepth) + `}`,
2417 errMaxDepth: false,
2418 },
2419 {
2420 name: "ObjectOverMaxNestingDepth",
2421 data: `{"a":` + strings.Repeat(`{"a":`, _OverMaxDepth) + `0` + strings.Repeat(`}`, _OverMaxDepth) + `}`,
2422 errMaxDepth: true,
2423 },
2424 {
2425 name: "ObjectOverStackDepth",
2426 data: `{"a":` + strings.Repeat(`{"a":`, 3000000) + `0` + strings.Repeat(`}`, 3000000) + `}`,
2427 errMaxDepth: true,
2428 },
2429 }
2430
2431 targets := []struct {
2432 name string
2433 newValue func() interface{}
2434 }{
2435 {
2436 name: "unstructured",
2437 newValue: func() interface{} {
2438 var v interface{}
2439 return &v
2440 },
2441 },
2442 {
2443 name: "typed named field",
2444 newValue: func() interface{} {
2445 v := struct {
2446 A interface{} `json:"a"`
2447 }{}
2448 return &v
2449 },
2450 },
2451 {
2452 name: "typed missing field",
2453 newValue: func() interface{} {
2454 v := struct {
2455 B interface{} `json:"b"`
2456 }{}
2457 return &v
2458 },
2459 },
2460 {
2461 name: "custom unmarshaler",
2462 newValue: func() interface{} {
2463 v := unmarshaler{}
2464 return &v
2465 },
2466 },
2467 }
2468
2469 for _, tc := range testcases {
2470 for _, target := range targets {
2471 t.Run(target.name+"-"+tc.name, func(t *testing.T) {
2472 err := Unmarshal([]byte(tc.data), target.newValue())
2473 if !tc.errMaxDepth {
2474 if err != nil {
2475 t.Errorf("unexpected error: %v", err)
2476 }
2477 } else {
2478 if err == nil {
2479 t.Errorf("expected error containing 'exceeded max depth', got none")
2480 } else if !strings.Contains(err.Error(), "exceeded max depth") {
2481 t.Errorf("expected error containing 'exceeded max depth', got: %v", err)
2482 }
2483 }
2484 })
2485 }
2486 }
2487 }
2488
2489
2490 type ChargeToolPacingBucketItemTcc struct {
2491 _ [128]byte
2492 T string `json:"T"`
2493 }
2494
2495 type ChargeToolPacingParamsForDataRead struct {
2496 Bucket2Item map[int64]ChargeToolPacingBucketItemTcc `json:"bucket_to_item"`
2497 }
2498
2499 var panicStr = `
2500 {
2501 "bucket_to_item": {
2502 "102" : {
2503 "T": "xxxx"
2504 }
2505 }
2506 }
2507 `
2508
2509 func TestChangeTool(t *testing.T) {
2510 dataForRaw := ChargeToolPacingParamsForDataRead{}
2511
2512 err := Unmarshal([]byte(panicStr), &dataForRaw)
2513 if err != nil {
2514 t.Fatalf("err %+v\n", err)
2515 }
2516 t.Logf("%#v\n", dataForRaw)
2517 t.Logf("%#v\n", &dataForRaw.Bucket2Item)
2518 a := dataForRaw.Bucket2Item[102]
2519 if a.T != "xxxx" {
2520 t.Fatalf("exp:%v, got:%v", "xxxx", a.T)
2521 }
2522
2523 }
2524
2525 func TestDecoder_LongestInvalidUtf8(t *testing.T) {
2526 for _, data := range([]string{
2527 "\"" + strings.Repeat("\x80", 4096) + "\"",
2528 "\"" + strings.Repeat("\x80", 4095) + "\"",
2529 "\"" + strings.Repeat("\x80", 4097) + "\"",
2530 "\"" + strings.Repeat("\x80", 12345) + "\"",
2531 }) {
2532 testDecodeInvalidUtf8(t, []byte(data))
2533 }
2534 }
2535
2536 func testDecodeInvalidUtf8(t *testing.T, data []byte) {
2537 var sgot, jgot string
2538 serr := ConfigStd.Unmarshal(data, &sgot)
2539 jerr := json.Unmarshal(data, &jgot)
2540 assert.Equal(t, serr != nil, jerr != nil)
2541 if jerr == nil {
2542 assert.Equal(t, sgot, jgot)
2543 }
2544 }
2545
2546 func needEscape(b byte) bool {
2547 return b == '"' || b == '\\' || b < '\x20'
2548 }
2549
2550 func genRandJsonBytes(length int) []byte {
2551 var buf bytes.Buffer
2552 buf.WriteByte('"')
2553 for j := 0; j < length; j++ {
2554 r := rand.Intn(0xff + 1)
2555 if needEscape(byte(r)) {
2556 buf.WriteByte('\\')
2557 }
2558 buf.WriteByte(byte(r))
2559 }
2560 buf.WriteByte('"')
2561 return buf.Bytes()
2562 }
2563
2564 func genRandJsonRune(length int) []byte {
2565 var buf bytes.Buffer
2566 buf.WriteByte('"')
2567 for j := 0; j < length; j++ {
2568 r := rand.Intn(0x10FFFF + 1)
2569 if r < 0x80 && needEscape(byte(r)) {
2570 buf.WriteByte('\\')
2571 buf.WriteByte(byte(r))
2572 } else {
2573 buf.WriteRune(rune(r))
2574 }
2575 }
2576 buf.WriteByte('"')
2577 return buf.Bytes()
2578 }
2579
2580 func TestDecoder_RandomInvalidUtf8(t *testing.T) {
2581 nums := 1000
2582 maxLen := 1000
2583 for i := 0; i < nums; i++ {
2584 length := rand.Intn(maxLen)
2585 testDecodeInvalidUtf8(t, genRandJsonBytes(length))
2586 testDecodeInvalidUtf8(t, genRandJsonRune(length))
2587 }
2588 }
2589
2590
2591 type atofTest struct {
2592 in string
2593 out string
2594 err error
2595 }
2596
2597
2598
2599 var atoftests = []atofTest{
2600 {"1.234e", "", nil},
2601 {"1i", "1", nil},
2602 {"1", "1", nil},
2603 {"1e23", "1e+23", nil},
2604 {"1E23", "1e+23", nil},
2605 {"100000000000000000000000", "1e+23", nil},
2606 {"1e-100", "1e-100", nil},
2607 {"123456700", "1.234567e+08", nil},
2608 {"99999999999999974834176", "9.999999999999997e+22", nil},
2609 {"100000000000000000000001", "1.0000000000000001e+23", nil},
2610 {"100000000000000008388608", "1.0000000000000001e+23", nil},
2611 {"100000000000000016777215", "1.0000000000000001e+23", nil},
2612 {"100000000000000016777216", "1.0000000000000003e+23", nil},
2613 {"-1", "-1", nil},
2614 {"-0.1", "-0.1", nil},
2615 {"-0", "-0", nil},
2616 {"1e-20", "1e-20", nil},
2617 {"625e-3", "0.625", nil},
2618
2619
2620 {"0", "0", nil},
2621 {"0e0", "0", nil},
2622 {"-0e0", "-0", nil},
2623 {"0e-0", "0", nil},
2624 {"-0e-0", "-0", nil},
2625 {"0e+0", "0", nil},
2626 {"-0e+0", "-0", nil},
2627 {"0e+01234567890123456789", "0", nil},
2628 {"0.00e-01234567890123456789", "0", nil},
2629 {"-0e+01234567890123456789", "-0", nil},
2630 {"-0.00e-01234567890123456789", "-0", nil},
2631
2632 {"0e291", "0", nil},
2633 {"0e292", "0", nil},
2634 {"0e347", "0", nil},
2635 {"0e348", "0", nil},
2636 {"-0e291", "-0", nil},
2637 {"-0e292", "-0", nil},
2638 {"-0e347", "-0", nil},
2639 {"-0e348", "-0", nil},
2640
2641
2642 {"1.7976931348623157e308", "1.7976931348623157e+308", nil},
2643 {"-1.7976931348623157e308", "-1.7976931348623157e+308", nil},
2644
2645
2646
2647 {"1.7976931348623158e308", "1.7976931348623157e+308", nil},
2648 {"-1.7976931348623158e308", "-1.7976931348623157e+308", nil},
2649
2650
2651 {"1e308", "1e+308", nil},
2652
2653
2654 {"1e-305", "1e-305", nil},
2655 {"1e-306", "1e-306", nil},
2656 {"1e-307", "1e-307", nil},
2657 {"1e-308", "1e-308", nil},
2658 {"1e-309", "1e-309", nil},
2659 {"1e-310", "1e-310", nil},
2660 {"1e-322", "1e-322", nil},
2661
2662 {"5e-324", "5e-324", nil},
2663 {"4e-324", "5e-324", nil},
2664 {"3e-324", "5e-324", nil},
2665
2666 {"2e-324", "0", nil},
2667
2668 {"1e-350", "0", nil},
2669 {"1e-400000", "0", nil},
2670
2671
2672 {"1e-4294967296", "0", nil},
2673 {"1e-18446744073709551616", "0", nil},
2674
2675
2676 {"2.2250738585072012e-308", "2.2250738585072014e-308", nil},
2677
2678 {"2.2250738585072011e-308", "2.225073858507201e-308", nil},
2679
2680
2681 {"4.630813248087435e+307", "4.630813248087435e+307", nil},
2682
2683
2684 {"22.222222222222222", "22.22222222222222", nil},
2685 {"2." + strings.Repeat("2", 800) + "e+1", "22.22222222222222", nil},
2686
2687
2688
2689 {"1.00000000000000011102230246251565404236316680908203125", "1", nil},
2690
2691 {"1.00000000000000011102230246251565404236316680908203124", "1", nil},
2692
2693 {"1.00000000000000011102230246251565404236316680908203126", "1.0000000000000002", nil},
2694
2695 {"1.00000000000000011102230246251565404236316680908203125" + strings.Repeat("0", 10000) + "1", "1.0000000000000002", nil},
2696
2697
2698
2699 {"1.00000000000000033306690738754696212708950042724609375", "1.0000000000000004", nil},
2700
2701
2702
2703 {"1090544144181609348671888949248", "1.0905441441816093e+30", nil},
2704
2705
2706 {"9223372036854775807", "9223372036854775807", nil},
2707 {"9223372036854775808", "9223372036854775808", nil},
2708 {"-9223372036854775808", "-9223372036854775808", nil},
2709 {"-9223372036854775809", "-9223372036854775809", nil},
2710 }
2711
2712 func TestDecodeFloat(t *testing.T) {
2713 for i, tt := range atoftests {
2714
2715 var sonicout, stdout float64
2716 sonicerr := decoder.NewDecoder(tt.in).Decode(&sonicout)
2717 stderr := json.NewDecoder(strings.NewReader(tt.in)).Decode(&stdout)
2718 if !reflect.DeepEqual(sonicout, stdout) {
2719 t.Fatalf("Test %d, %#v\ngot:\n %#v\nexp:\n %#v\n", i, tt.in, sonicout, stdout)
2720 }
2721 if !reflect.DeepEqual(sonicerr == nil, stderr == nil) {
2722 t.Fatalf("Test %d, %#v\ngot:\n %#v\nexp:\n %#v\n", i, tt.in, sonicerr, stderr)
2723 }
2724 }
2725 }
2726
2727
2728 type useInt64Test struct {
2729 in string
2730 out int64
2731 }
2732
2733 type useFloatTest struct {
2734 in string
2735 out float64
2736 }
2737
2738 var useinttest = []useInt64Test{
2739
2740 {"0", 0},
2741 {"1", 1},
2742 {"-1", -1},
2743 {"100", 100},
2744
2745 {"-9223372036854775807", -9223372036854775807},
2746 {"-9223372036854775808", -9223372036854775808},
2747 {"9223372036854775807", 9223372036854775807},
2748 {"9223372036854775806", 9223372036854775806},
2749 }
2750
2751 var usefloattest = []useFloatTest{
2752
2753 {"-9223372036854775809", -9223372036854775809},
2754 {"9223372036854775808", 9223372036854775808},
2755 {"1e2", 1e2},
2756 {"1e-20", 1e-20},
2757 {"1.0", 1},
2758 }
2759
2760 func TestUseInt64(t *testing.T) {
2761 for i, tt := range useinttest {
2762 var sout interface{}
2763 dc := decoder.NewDecoder(tt.in)
2764 dc.UseInt64()
2765 serr := dc.Decode(&sout)
2766 if !reflect.DeepEqual(sout, tt.out) {
2767 t.Errorf("Test %d, %#v\ngot:\n %#v\nexp:\n %#v\n", i, tt.in, sout, tt.in)
2768 }
2769 if serr != nil {
2770 t.Errorf("Test %d, %#v\ngot:\n %#v\nexp:\n nil\n", i, tt, serr)
2771 }
2772 }
2773
2774 for i, tt := range usefloattest {
2775 var sout interface{}
2776 dc := decoder.NewDecoder(tt.in)
2777 dc.UseInt64()
2778
2779 serr := dc.Decode(&sout)
2780 if !reflect.DeepEqual(sout, tt.out) {
2781 t.Errorf("Test %d, %#v\ngot:\n %#v\nexp:\n %#v\n", i, tt.in, sout, tt.in)
2782 }
2783 if serr != nil {
2784 t.Errorf("Test %d, %#v\ngot:\n %#v\nexp:\n nil\n", i, tt, serr)
2785 }
2786 }
2787 }
2788
2789 func TestUseNumber(t *testing.T) {
2790 for i, tt := range useinttest {
2791 var sout interface{}
2792 dc := decoder.NewDecoder(tt.in)
2793 dc.UseNumber()
2794 serr := dc.Decode(&sout)
2795 if !reflect.DeepEqual(sout, json.Number(tt.in)) {
2796 t.Errorf("Test %d, %#v\ngot:\n %#v\nexp:\n %#v\n", i, tt.in, sout, tt.out)
2797 }
2798 if serr != nil {
2799 t.Errorf("Test %d, %#v\ngot:\n %#v\nexp:\n nil\n", i, tt, serr)
2800 }
2801 }
2802
2803 for i, tt := range usefloattest {
2804 var sout interface{}
2805 dc := decoder.NewDecoder(tt.in)
2806 dc.UseNumber()
2807 serr := dc.Decode(&sout)
2808 if !reflect.DeepEqual(sout, json.Number(tt.in)) {
2809 t.Errorf("Test %d, %#v\ngot:\n %#v\nexp:\n %#v\n", i, tt.in, sout, tt.out)
2810 }
2811 if serr != nil {
2812 t.Errorf("Test %d, %#v\ngot:\n %#v\nexp:\n nil\n", i, tt, serr)
2813 }
2814 }
2815 }
2816
View as plain text