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