1// Copyright 2011 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 "fmt" 10 "log" 11 "math" 12 "reflect" 13 "regexp" 14 "strconv" 15 "testing" 16 "unicode" 17) 18 19type Optionals struct { 20 Sr string `json:"sr"` 21 So string `json:"so,omitempty"` 22 Sw string `json:"-"` 23 24 Ir int `json:"omitempty"` // actually named omitempty, not an option 25 Io int `json:"io,omitempty"` 26 27 Slr []string `json:"slr,random"` 28 Slo []string `json:"slo,omitempty"` 29 30 Mr map[string]interface{} `json:"mr"` 31 Mo map[string]interface{} `json:",omitempty"` 32 33 Fr float64 `json:"fr"` 34 Fo float64 `json:"fo,omitempty"` 35 36 Br bool `json:"br"` 37 Bo bool `json:"bo,omitempty"` 38 39 Ur uint `json:"ur"` 40 Uo uint `json:"uo,omitempty"` 41 42 Str struct{} `json:"str"` 43 Sto struct{} `json:"sto,omitempty"` 44} 45 46var optionalsExpected = `{ 47 "sr": "", 48 "omitempty": 0, 49 "slr": null, 50 "mr": {}, 51 "fr": 0, 52 "br": false, 53 "ur": 0, 54 "str": {}, 55 "sto": {} 56}` 57 58func TestOmitEmpty(t *testing.T) { 59 var o Optionals 60 o.Sw = "something" 61 o.Mr = map[string]interface{}{} 62 o.Mo = map[string]interface{}{} 63 64 got, err := MarshalIndent(&o, "", " ") 65 if err != nil { 66 t.Fatal(err) 67 } 68 if got := string(got); got != optionalsExpected { 69 t.Errorf(" got: %s\nwant: %s\n", got, optionalsExpected) 70 } 71} 72 73type StringTag struct { 74 BoolStr bool `json:",string"` 75 IntStr int64 `json:",string"` 76 UintptrStr uintptr `json:",string"` 77 StrStr string `json:",string"` 78} 79 80var stringTagExpected = `{ 81 "BoolStr": "true", 82 "IntStr": "42", 83 "UintptrStr": "44", 84 "StrStr": "\"xzbit\"" 85}` 86 87func TestStringTag(t *testing.T) { 88 var s StringTag 89 s.BoolStr = true 90 s.IntStr = 42 91 s.UintptrStr = 44 92 s.StrStr = "xzbit" 93 got, err := MarshalIndent(&s, "", " ") 94 if err != nil { 95 t.Fatal(err) 96 } 97 if got := string(got); got != stringTagExpected { 98 t.Fatalf(" got: %s\nwant: %s\n", got, stringTagExpected) 99 } 100 101 // Verify that it round-trips. 102 var s2 StringTag 103 err = NewDecoder(bytes.NewReader(got)).Decode(&s2) 104 if err != nil { 105 t.Fatalf("Decode: %v", err) 106 } 107 if !reflect.DeepEqual(s, s2) { 108 t.Fatalf("decode didn't match.\nsource: %#v\nEncoded as:\n%s\ndecode: %#v", s, string(got), s2) 109 } 110} 111 112// byte slices are special even if they're renamed types. 113type renamedByte byte 114type renamedByteSlice []byte 115type renamedRenamedByteSlice []renamedByte 116 117func TestEncodeRenamedByteSlice(t *testing.T) { 118 s := renamedByteSlice("abc") 119 result, err := Marshal(s) 120 if err != nil { 121 t.Fatal(err) 122 } 123 expect := `"YWJj"` 124 if string(result) != expect { 125 t.Errorf(" got %s want %s", result, expect) 126 } 127 r := renamedRenamedByteSlice("abc") 128 result, err = Marshal(r) 129 if err != nil { 130 t.Fatal(err) 131 } 132 if string(result) != expect { 133 t.Errorf(" got %s want %s", result, expect) 134 } 135} 136 137var unsupportedValues = []interface{}{ 138 math.NaN(), 139 math.Inf(-1), 140 math.Inf(1), 141} 142 143func TestUnsupportedValues(t *testing.T) { 144 for _, v := range unsupportedValues { 145 if _, err := Marshal(v); err != nil { 146 if _, ok := err.(*UnsupportedValueError); !ok { 147 t.Errorf("for %v, got %T want UnsupportedValueError", v, err) 148 } 149 } else { 150 t.Errorf("for %v, expected error", v) 151 } 152 } 153} 154 155// Ref has Marshaler and Unmarshaler methods with pointer receiver. 156type Ref int 157 158func (*Ref) MarshalJSON() ([]byte, error) { 159 return []byte(`"ref"`), nil 160} 161 162func (r *Ref) UnmarshalJSON([]byte) error { 163 *r = 12 164 return nil 165} 166 167// Val has Marshaler methods with value receiver. 168type Val int 169 170func (Val) MarshalJSON() ([]byte, error) { 171 return []byte(`"val"`), nil 172} 173 174// RefText has Marshaler and Unmarshaler methods with pointer receiver. 175type RefText int 176 177func (*RefText) MarshalText() ([]byte, error) { 178 return []byte(`"ref"`), nil 179} 180 181func (r *RefText) UnmarshalText([]byte) error { 182 *r = 13 183 return nil 184} 185 186// ValText has Marshaler methods with value receiver. 187type ValText int 188 189func (ValText) MarshalText() ([]byte, error) { 190 return []byte(`"val"`), nil 191} 192 193func TestRefValMarshal(t *testing.T) { 194 var s = struct { 195 R0 Ref 196 R1 *Ref 197 R2 RefText 198 R3 *RefText 199 V0 Val 200 V1 *Val 201 V2 ValText 202 V3 *ValText 203 }{ 204 R0: 12, 205 R1: new(Ref), 206 R2: 14, 207 R3: new(RefText), 208 V0: 13, 209 V1: new(Val), 210 V2: 15, 211 V3: new(ValText), 212 } 213 const want = `{"R0":"ref","R1":"ref","R2":"\"ref\"","R3":"\"ref\"","V0":"val","V1":"val","V2":"\"val\"","V3":"\"val\""}` 214 b, err := Marshal(&s) 215 if err != nil { 216 t.Fatalf("Marshal: %v", err) 217 } 218 if got := string(b); got != want { 219 t.Errorf("got %q, want %q", got, want) 220 } 221} 222 223// C implements Marshaler and returns unescaped JSON. 224type C int 225 226func (C) MarshalJSON() ([]byte, error) { 227 return []byte(`"<&>"`), nil 228} 229 230// CText implements Marshaler and returns unescaped text. 231type CText int 232 233func (CText) MarshalText() ([]byte, error) { 234 return []byte(`"<&>"`), nil 235} 236 237func TestMarshalerEscaping(t *testing.T) { 238 var c C 239 want := `"\u003c\u0026\u003e"` 240 b, err := Marshal(c) 241 if err != nil { 242 t.Fatalf("Marshal(c): %v", err) 243 } 244 if got := string(b); got != want { 245 t.Errorf("Marshal(c) = %#q, want %#q", got, want) 246 } 247 248 var ct CText 249 want = `"\"\u003c\u0026\u003e\""` 250 b, err = Marshal(ct) 251 if err != nil { 252 t.Fatalf("Marshal(ct): %v", err) 253 } 254 if got := string(b); got != want { 255 t.Errorf("Marshal(ct) = %#q, want %#q", got, want) 256 } 257} 258 259func TestAnonymousFields(t *testing.T) { 260 tests := []struct { 261 label string // Test name 262 makeInput func() interface{} // Function to create input value 263 want string // Expected JSON output 264 }{{ 265 // Both S1 and S2 have a field named X. From the perspective of S, 266 // it is ambiguous which one X refers to. 267 // This should not serialize either field. 268 label: "AmbiguousField", 269 makeInput: func() interface{} { 270 type ( 271 S1 struct{ x, X int } 272 S2 struct{ x, X int } 273 S struct { 274 S1 275 S2 276 } 277 ) 278 return S{S1{1, 2}, S2{3, 4}} 279 }, 280 want: `{}`, 281 }, { 282 label: "DominantField", 283 // Both S1 and S2 have a field named X, but since S has an X field as 284 // well, it takes precedence over S1.X and S2.X. 285 makeInput: func() interface{} { 286 type ( 287 S1 struct{ x, X int } 288 S2 struct{ x, X int } 289 S struct { 290 S1 291 S2 292 x, X int 293 } 294 ) 295 return S{S1{1, 2}, S2{3, 4}, 5, 6} 296 }, 297 want: `{"X":6}`, 298 }, { 299 // Unexported embedded field of non-struct type should not be serialized. 300 label: "UnexportedEmbeddedInt", 301 makeInput: func() interface{} { 302 type ( 303 myInt int 304 S struct{ myInt } 305 ) 306 return S{5} 307 }, 308 want: `{}`, 309 }, { 310 // Exported embedded field of non-struct type should be serialized. 311 label: "ExportedEmbeddedInt", 312 makeInput: func() interface{} { 313 type ( 314 MyInt int 315 S struct{ MyInt } 316 ) 317 return S{5} 318 }, 319 want: `{"MyInt":5}`, 320 }, { 321 // Unexported embedded field of pointer to non-struct type 322 // should not be serialized. 323 label: "UnexportedEmbeddedIntPointer", 324 makeInput: func() interface{} { 325 type ( 326 myInt int 327 S struct{ *myInt } 328 ) 329 s := S{new(myInt)} 330 *s.myInt = 5 331 return s 332 }, 333 want: `{}`, 334 }, { 335 // Exported embedded field of pointer to non-struct type 336 // should be serialized. 337 label: "ExportedEmbeddedIntPointer", 338 makeInput: func() interface{} { 339 type ( 340 MyInt int 341 S struct{ *MyInt } 342 ) 343 s := S{new(MyInt)} 344 *s.MyInt = 5 345 return s 346 }, 347 want: `{"MyInt":5}`, 348 }, { 349 // Exported fields of embedded structs should have their 350 // exported fields be serialized regardless of whether the struct types 351 // themselves are exported. 352 label: "EmbeddedStruct", 353 makeInput: func() interface{} { 354 type ( 355 s1 struct{ x, X int } 356 S2 struct{ y, Y int } 357 S struct { 358 s1 359 S2 360 } 361 ) 362 return S{s1{1, 2}, S2{3, 4}} 363 }, 364 want: `{"X":2,"Y":4}`, 365 }, { 366 // Exported fields of pointers to embedded structs should have their 367 // exported fields be serialized regardless of whether the struct types 368 // themselves are exported. 369 label: "EmbeddedStructPointer", 370 makeInput: func() interface{} { 371 type ( 372 s1 struct{ x, X int } 373 S2 struct{ y, Y int } 374 S struct { 375 *s1 376 *S2 377 } 378 ) 379 return S{&s1{1, 2}, &S2{3, 4}} 380 }, 381 want: `{"X":2,"Y":4}`, 382 }, { 383 // Exported fields on embedded unexported structs at multiple levels 384 // of nesting should still be serialized. 385 label: "NestedStructAndInts", 386 makeInput: func() interface{} { 387 type ( 388 MyInt1 int 389 MyInt2 int 390 myInt int 391 s2 struct { 392 MyInt2 393 myInt 394 } 395 s1 struct { 396 MyInt1 397 myInt 398 s2 399 } 400 S struct { 401 s1 402 myInt 403 } 404 ) 405 return S{s1{1, 2, s2{3, 4}}, 6} 406 }, 407 want: `{"MyInt1":1,"MyInt2":3}`, 408 }, { 409 // If an anonymous struct pointer field is nil, we should ignore 410 // the embedded fields behind it. Not properly doing so may 411 // result in the wrong output or reflect panics. 412 label: "EmbeddedFieldBehindNilPointer", 413 makeInput: func() interface{} { 414 type ( 415 S2 struct{ Field string } 416 S struct{ *S2 } 417 ) 418 return S{} 419 }, 420 want: `{}`, 421 }} 422 423 for _, tt := range tests { 424 t.Run(tt.label, func(t *testing.T) { 425 b, err := Marshal(tt.makeInput()) 426 if err != nil { 427 t.Fatalf("Marshal() = %v, want nil error", err) 428 } 429 if string(b) != tt.want { 430 t.Fatalf("Marshal() = %q, want %q", b, tt.want) 431 } 432 }) 433 } 434} 435 436type BugA struct { 437 S string 438} 439 440type BugB struct { 441 BugA 442 S string 443} 444 445type BugC struct { 446 S string 447} 448 449// Legal Go: We never use the repeated embedded field (S). 450type BugX struct { 451 A int 452 BugA 453 BugB 454} 455 456// Issue 16042. Even if a nil interface value is passed in 457// as long as it implements MarshalJSON, it should be marshaled. 458type nilMarshaler string 459 460func (nm *nilMarshaler) MarshalJSON() ([]byte, error) { 461 if nm == nil { 462 return Marshal("0zenil0") 463 } 464 return Marshal("zenil:" + string(*nm)) 465} 466 467// Issue 16042. 468func TestNilMarshal(t *testing.T) { 469 testCases := []struct { 470 v interface{} 471 want string 472 }{ 473 {v: nil, want: `null`}, 474 {v: new(float64), want: `0`}, 475 {v: []interface{}(nil), want: `null`}, 476 {v: []string(nil), want: `null`}, 477 {v: map[string]string(nil), want: `null`}, 478 {v: []byte(nil), want: `null`}, 479 {v: struct{ M string }{"gopher"}, want: `{"M":"gopher"}`}, 480 {v: struct{ M Marshaler }{}, want: `{"M":null}`}, 481 {v: struct{ M Marshaler }{(*nilMarshaler)(nil)}, want: `{"M":"0zenil0"}`}, 482 {v: struct{ M interface{} }{(*nilMarshaler)(nil)}, want: `{"M":null}`}, 483 } 484 485 for _, tt := range testCases { 486 out, err := Marshal(tt.v) 487 if err != nil || string(out) != tt.want { 488 t.Errorf("Marshal(%#v) = %#q, %#v, want %#q, nil", tt.v, out, err, tt.want) 489 continue 490 } 491 } 492} 493 494// Issue 5245. 495func TestEmbeddedBug(t *testing.T) { 496 v := BugB{ 497 BugA{"A"}, 498 "B", 499 } 500 b, err := Marshal(v) 501 if err != nil { 502 t.Fatal("Marshal:", err) 503 } 504 want := `{"S":"B"}` 505 got := string(b) 506 if got != want { 507 t.Fatalf("Marshal: got %s want %s", got, want) 508 } 509 // Now check that the duplicate field, S, does not appear. 510 x := BugX{ 511 A: 23, 512 } 513 b, err = Marshal(x) 514 if err != nil { 515 t.Fatal("Marshal:", err) 516 } 517 want = `{"A":23}` 518 got = string(b) 519 if got != want { 520 t.Fatalf("Marshal: got %s want %s", got, want) 521 } 522} 523 524type BugD struct { // Same as BugA after tagging. 525 XXX string `json:"S"` 526} 527 528// BugD's tagged S field should dominate BugA's. 529type BugY struct { 530 BugA 531 BugD 532} 533 534// Test that a field with a tag dominates untagged fields. 535func TestTaggedFieldDominates(t *testing.T) { 536 v := BugY{ 537 BugA{"BugA"}, 538 BugD{"BugD"}, 539 } 540 b, err := Marshal(v) 541 if err != nil { 542 t.Fatal("Marshal:", err) 543 } 544 want := `{"S":"BugD"}` 545 got := string(b) 546 if got != want { 547 t.Fatalf("Marshal: got %s want %s", got, want) 548 } 549} 550 551// There are no tags here, so S should not appear. 552type BugZ struct { 553 BugA 554 BugC 555 BugY // Contains a tagged S field through BugD; should not dominate. 556} 557 558func TestDuplicatedFieldDisappears(t *testing.T) { 559 v := BugZ{ 560 BugA{"BugA"}, 561 BugC{"BugC"}, 562 BugY{ 563 BugA{"nested BugA"}, 564 BugD{"nested BugD"}, 565 }, 566 } 567 b, err := Marshal(v) 568 if err != nil { 569 t.Fatal("Marshal:", err) 570 } 571 want := `{}` 572 got := string(b) 573 if got != want { 574 t.Fatalf("Marshal: got %s want %s", got, want) 575 } 576} 577 578func TestStringBytes(t *testing.T) { 579 t.Parallel() 580 // Test that encodeState.stringBytes and encodeState.string use the same encoding. 581 var r []rune 582 for i := '\u0000'; i <= unicode.MaxRune; i++ { 583 r = append(r, i) 584 } 585 s := string(r) + "\xff\xff\xffhello" // some invalid UTF-8 too 586 587 for _, escapeHTML := range []bool{true, false} { 588 es := &encodeState{} 589 es.string(s, escapeHTML) 590 591 esBytes := &encodeState{} 592 esBytes.stringBytes([]byte(s), escapeHTML) 593 594 enc := es.Buffer.String() 595 encBytes := esBytes.Buffer.String() 596 if enc != encBytes { 597 i := 0 598 for i < len(enc) && i < len(encBytes) && enc[i] == encBytes[i] { 599 i++ 600 } 601 enc = enc[i:] 602 encBytes = encBytes[i:] 603 i = 0 604 for i < len(enc) && i < len(encBytes) && enc[len(enc)-i-1] == encBytes[len(encBytes)-i-1] { 605 i++ 606 } 607 enc = enc[:len(enc)-i] 608 encBytes = encBytes[:len(encBytes)-i] 609 610 if len(enc) > 20 { 611 enc = enc[:20] + "..." 612 } 613 if len(encBytes) > 20 { 614 encBytes = encBytes[:20] + "..." 615 } 616 617 t.Errorf("with escapeHTML=%t, encodings differ at %#q vs %#q", 618 escapeHTML, enc, encBytes) 619 } 620 } 621} 622 623func TestIssue10281(t *testing.T) { 624 type Foo struct { 625 N Number 626 } 627 x := Foo{Number(`invalid`)} 628 629 b, err := Marshal(&x) 630 if err == nil { 631 t.Errorf("Marshal(&x) = %#q; want error", b) 632 } 633} 634 635func TestHTMLEscape(t *testing.T) { 636 var b, want bytes.Buffer 637 m := `{"M":"<html>foo &` + "\xe2\x80\xa8 \xe2\x80\xa9" + `</html>"}` 638 want.Write([]byte(`{"M":"\u003chtml\u003efoo \u0026\u2028 \u2029\u003c/html\u003e"}`)) 639 HTMLEscape(&b, []byte(m)) 640 if !bytes.Equal(b.Bytes(), want.Bytes()) { 641 t.Errorf("HTMLEscape(&b, []byte(m)) = %s; want %s", b.Bytes(), want.Bytes()) 642 } 643} 644 645// golang.org/issue/8582 646func TestEncodePointerString(t *testing.T) { 647 type stringPointer struct { 648 N *int64 `json:"n,string"` 649 } 650 var n int64 = 42 651 b, err := Marshal(stringPointer{N: &n}) 652 if err != nil { 653 t.Fatalf("Marshal: %v", err) 654 } 655 if got, want := string(b), `{"n":"42"}`; got != want { 656 t.Errorf("Marshal = %s, want %s", got, want) 657 } 658 var back stringPointer 659 err = Unmarshal(b, &back) 660 if err != nil { 661 t.Fatalf("Unmarshal: %v", err) 662 } 663 if back.N == nil { 664 t.Fatalf("Unmarshaled nil N field") 665 } 666 if *back.N != 42 { 667 t.Fatalf("*N = %d; want 42", *back.N) 668 } 669} 670 671var encodeStringTests = []struct { 672 in string 673 out string 674}{ 675 {"\x00", `"\u0000"`}, 676 {"\x01", `"\u0001"`}, 677 {"\x02", `"\u0002"`}, 678 {"\x03", `"\u0003"`}, 679 {"\x04", `"\u0004"`}, 680 {"\x05", `"\u0005"`}, 681 {"\x06", `"\u0006"`}, 682 {"\x07", `"\u0007"`}, 683 {"\x08", `"\u0008"`}, 684 {"\x09", `"\t"`}, 685 {"\x0a", `"\n"`}, 686 {"\x0b", `"\u000b"`}, 687 {"\x0c", `"\u000c"`}, 688 {"\x0d", `"\r"`}, 689 {"\x0e", `"\u000e"`}, 690 {"\x0f", `"\u000f"`}, 691 {"\x10", `"\u0010"`}, 692 {"\x11", `"\u0011"`}, 693 {"\x12", `"\u0012"`}, 694 {"\x13", `"\u0013"`}, 695 {"\x14", `"\u0014"`}, 696 {"\x15", `"\u0015"`}, 697 {"\x16", `"\u0016"`}, 698 {"\x17", `"\u0017"`}, 699 {"\x18", `"\u0018"`}, 700 {"\x19", `"\u0019"`}, 701 {"\x1a", `"\u001a"`}, 702 {"\x1b", `"\u001b"`}, 703 {"\x1c", `"\u001c"`}, 704 {"\x1d", `"\u001d"`}, 705 {"\x1e", `"\u001e"`}, 706 {"\x1f", `"\u001f"`}, 707} 708 709func TestEncodeString(t *testing.T) { 710 for _, tt := range encodeStringTests { 711 b, err := Marshal(tt.in) 712 if err != nil { 713 t.Errorf("Marshal(%q): %v", tt.in, err) 714 continue 715 } 716 out := string(b) 717 if out != tt.out { 718 t.Errorf("Marshal(%q) = %#q, want %#q", tt.in, out, tt.out) 719 } 720 } 721} 722 723type jsonbyte byte 724 725func (b jsonbyte) MarshalJSON() ([]byte, error) { return tenc(`{"JB":%d}`, b) } 726 727type textbyte byte 728 729func (b textbyte) MarshalText() ([]byte, error) { return tenc(`TB:%d`, b) } 730 731type jsonint int 732 733func (i jsonint) MarshalJSON() ([]byte, error) { return tenc(`{"JI":%d}`, i) } 734 735type textint int 736 737func (i textint) MarshalText() ([]byte, error) { return tenc(`TI:%d`, i) } 738 739func tenc(format string, a ...interface{}) ([]byte, error) { 740 var buf bytes.Buffer 741 fmt.Fprintf(&buf, format, a...) 742 return buf.Bytes(), nil 743} 744 745// Issue 13783 746func TestEncodeBytekind(t *testing.T) { 747 testdata := []struct { 748 data interface{} 749 want string 750 }{ 751 {byte(7), "7"}, 752 {jsonbyte(7), `{"JB":7}`}, 753 {textbyte(4), `"TB:4"`}, 754 {jsonint(5), `{"JI":5}`}, 755 {textint(1), `"TI:1"`}, 756 {[]byte{0, 1}, `"AAE="`}, 757 {[]jsonbyte{0, 1}, `[{"JB":0},{"JB":1}]`}, 758 {[][]jsonbyte{{0, 1}, {3}}, `[[{"JB":0},{"JB":1}],[{"JB":3}]]`}, 759 {[]textbyte{2, 3}, `["TB:2","TB:3"]`}, 760 {[]jsonint{5, 4}, `[{"JI":5},{"JI":4}]`}, 761 {[]textint{9, 3}, `["TI:9","TI:3"]`}, 762 {[]int{9, 3}, `[9,3]`}, 763 } 764 for _, d := range testdata { 765 js, err := Marshal(d.data) 766 if err != nil { 767 t.Error(err) 768 continue 769 } 770 got, want := string(js), d.want 771 if got != want { 772 t.Errorf("got %s, want %s", got, want) 773 } 774 } 775} 776 777func TestTextMarshalerMapKeysAreSorted(t *testing.T) { 778 b, err := Marshal(map[unmarshalerText]int{ 779 {"x", "y"}: 1, 780 {"y", "x"}: 2, 781 {"a", "z"}: 3, 782 {"z", "a"}: 4, 783 }) 784 if err != nil { 785 t.Fatalf("Failed to Marshal text.Marshaler: %v", err) 786 } 787 const want = `{"a:z":3,"x:y":1,"y:x":2,"z:a":4}` 788 if string(b) != want { 789 t.Errorf("Marshal map with text.Marshaler keys: got %#q, want %#q", b, want) 790 } 791} 792 793var re = regexp.MustCompile 794 795// syntactic checks on form of marshaled floating point numbers. 796var badFloatREs = []*regexp.Regexp{ 797 re(`p`), // no binary exponential notation 798 re(`^\+`), // no leading + sign 799 re(`^-?0[^.]`), // no unnecessary leading zeros 800 re(`^-?\.`), // leading zero required before decimal point 801 re(`\.(e|$)`), // no trailing decimal 802 re(`\.[0-9]+0(e|$)`), // no trailing zero in fraction 803 re(`^-?(0|[0-9]{2,})\..*e`), // exponential notation must have normalized mantissa 804 re(`e[0-9]`), // positive exponent must be signed 805 re(`e[+-]0`), // exponent must not have leading zeros 806 re(`e-[1-6]$`), // not tiny enough for exponential notation 807 re(`e+(.|1.|20)$`), // not big enough for exponential notation 808 re(`^-?0\.0000000`), // too tiny, should use exponential notation 809 re(`^-?[0-9]{22}`), // too big, should use exponential notation 810 re(`[1-9][0-9]{16}[1-9]`), // too many significant digits in integer 811 re(`[1-9][0-9.]{17}[1-9]`), // too many significant digits in decimal 812 // below here for float32 only 813 re(`[1-9][0-9]{8}[1-9]`), // too many significant digits in integer 814 re(`[1-9][0-9.]{9}[1-9]`), // too many significant digits in decimal 815} 816 817func TestMarshalFloat(t *testing.T) { 818 t.Parallel() 819 nfail := 0 820 test := func(f float64, bits int) { 821 vf := interface{}(f) 822 if bits == 32 { 823 f = float64(float32(f)) // round 824 vf = float32(f) 825 } 826 bout, err := Marshal(vf) 827 if err != nil { 828 t.Errorf("Marshal(%T(%g)): %v", vf, vf, err) 829 nfail++ 830 return 831 } 832 out := string(bout) 833 834 // result must convert back to the same float 835 g, err := strconv.ParseFloat(out, bits) 836 if err != nil { 837 t.Errorf("Marshal(%T(%g)) = %q, cannot parse back: %v", vf, vf, out, err) 838 nfail++ 839 return 840 } 841 if f != g || fmt.Sprint(f) != fmt.Sprint(g) { // fmt.Sprint handles ±0 842 t.Errorf("Marshal(%T(%g)) = %q (is %g, not %g)", vf, vf, out, float32(g), vf) 843 nfail++ 844 return 845 } 846 847 bad := badFloatREs 848 if bits == 64 { 849 bad = bad[:len(bad)-2] 850 } 851 for _, re := range bad { 852 if re.MatchString(out) { 853 t.Errorf("Marshal(%T(%g)) = %q, must not match /%s/", vf, vf, out, re) 854 nfail++ 855 return 856 } 857 } 858 } 859 860 var ( 861 bigger = math.Inf(+1) 862 smaller = math.Inf(-1) 863 ) 864 865 var digits = "1.2345678901234567890123" 866 for i := len(digits); i >= 2; i-- { 867 for exp := -30; exp <= 30; exp++ { 868 for _, sign := range "+-" { 869 for bits := 32; bits <= 64; bits += 32 { 870 s := fmt.Sprintf("%c%se%d", sign, digits[:i], exp) 871 f, err := strconv.ParseFloat(s, bits) 872 if err != nil { 873 log.Fatal(err) 874 } 875 next := math.Nextafter 876 if bits == 32 { 877 next = func(g, h float64) float64 { 878 return float64(math.Nextafter32(float32(g), float32(h))) 879 } 880 } 881 test(f, bits) 882 test(next(f, bigger), bits) 883 test(next(f, smaller), bits) 884 if nfail > 50 { 885 t.Fatalf("stopping test early") 886 } 887 } 888 } 889 } 890 } 891 test(0, 64) 892 test(math.Copysign(0, -1), 64) 893 test(0, 32) 894 test(math.Copysign(0, -1), 32) 895} 896 897func TestMarshalRawMessageValue(t *testing.T) { 898 type ( 899 T1 struct { 900 M RawMessage `json:",omitempty"` 901 } 902 T2 struct { 903 M *RawMessage `json:",omitempty"` 904 } 905 ) 906 907 var ( 908 rawNil = RawMessage(nil) 909 rawEmpty = RawMessage([]byte{}) 910 rawText = RawMessage([]byte(`"foo"`)) 911 ) 912 913 tests := []struct { 914 in interface{} 915 want string 916 ok bool 917 }{ 918 // Test with nil RawMessage. 919 {rawNil, "null", true}, 920 {&rawNil, "null", true}, 921 {[]interface{}{rawNil}, "[null]", true}, 922 {&[]interface{}{rawNil}, "[null]", true}, 923 {[]interface{}{&rawNil}, "[null]", true}, 924 {&[]interface{}{&rawNil}, "[null]", true}, 925 {struct{ M RawMessage }{rawNil}, `{"M":null}`, true}, 926 {&struct{ M RawMessage }{rawNil}, `{"M":null}`, true}, 927 {struct{ M *RawMessage }{&rawNil}, `{"M":null}`, true}, 928 {&struct{ M *RawMessage }{&rawNil}, `{"M":null}`, true}, 929 {map[string]interface{}{"M": rawNil}, `{"M":null}`, true}, 930 {&map[string]interface{}{"M": rawNil}, `{"M":null}`, true}, 931 {map[string]interface{}{"M": &rawNil}, `{"M":null}`, true}, 932 {&map[string]interface{}{"M": &rawNil}, `{"M":null}`, true}, 933 {T1{rawNil}, "{}", true}, 934 {T2{&rawNil}, `{"M":null}`, true}, 935 {&T1{rawNil}, "{}", true}, 936 {&T2{&rawNil}, `{"M":null}`, true}, 937 938 // Test with empty, but non-nil, RawMessage. 939 {rawEmpty, "", false}, 940 {&rawEmpty, "", false}, 941 {[]interface{}{rawEmpty}, "", false}, 942 {&[]interface{}{rawEmpty}, "", false}, 943 {[]interface{}{&rawEmpty}, "", false}, 944 {&[]interface{}{&rawEmpty}, "", false}, 945 {struct{ X RawMessage }{rawEmpty}, "", false}, 946 {&struct{ X RawMessage }{rawEmpty}, "", false}, 947 {struct{ X *RawMessage }{&rawEmpty}, "", false}, 948 {&struct{ X *RawMessage }{&rawEmpty}, "", false}, 949 {map[string]interface{}{"nil": rawEmpty}, "", false}, 950 {&map[string]interface{}{"nil": rawEmpty}, "", false}, 951 {map[string]interface{}{"nil": &rawEmpty}, "", false}, 952 {&map[string]interface{}{"nil": &rawEmpty}, "", false}, 953 {T1{rawEmpty}, "{}", true}, 954 {T2{&rawEmpty}, "", false}, 955 {&T1{rawEmpty}, "{}", true}, 956 {&T2{&rawEmpty}, "", false}, 957 958 // Test with RawMessage with some text. 959 // 960 // The tests below marked with Issue6458 used to generate "ImZvbyI=" instead "foo". 961 // This behavior was intentionally changed in Go 1.8. 962 // See https://golang.org/issues/14493#issuecomment-255857318 963 {rawText, `"foo"`, true}, // Issue6458 964 {&rawText, `"foo"`, true}, 965 {[]interface{}{rawText}, `["foo"]`, true}, // Issue6458 966 {&[]interface{}{rawText}, `["foo"]`, true}, // Issue6458 967 {[]interface{}{&rawText}, `["foo"]`, true}, 968 {&[]interface{}{&rawText}, `["foo"]`, true}, 969 {struct{ M RawMessage }{rawText}, `{"M":"foo"}`, true}, // Issue6458 970 {&struct{ M RawMessage }{rawText}, `{"M":"foo"}`, true}, 971 {struct{ M *RawMessage }{&rawText}, `{"M":"foo"}`, true}, 972 {&struct{ M *RawMessage }{&rawText}, `{"M":"foo"}`, true}, 973 {map[string]interface{}{"M": rawText}, `{"M":"foo"}`, true}, // Issue6458 974 {&map[string]interface{}{"M": rawText}, `{"M":"foo"}`, true}, // Issue6458 975 {map[string]interface{}{"M": &rawText}, `{"M":"foo"}`, true}, 976 {&map[string]interface{}{"M": &rawText}, `{"M":"foo"}`, true}, 977 {T1{rawText}, `{"M":"foo"}`, true}, // Issue6458 978 {T2{&rawText}, `{"M":"foo"}`, true}, 979 {&T1{rawText}, `{"M":"foo"}`, true}, 980 {&T2{&rawText}, `{"M":"foo"}`, true}, 981 } 982 983 for i, tt := range tests { 984 b, err := Marshal(tt.in) 985 if ok := (err == nil); ok != tt.ok { 986 if err != nil { 987 t.Errorf("test %d, unexpected failure: %v", i, err) 988 } else { 989 t.Errorf("test %d, unexpected success", i) 990 } 991 } 992 if got := string(b); got != tt.want { 993 t.Errorf("test %d, Marshal(%#v) = %q, want %q", i, tt.in, got, tt.want) 994 } 995 } 996} 997 998type marshalPanic struct{} 999 1000func (marshalPanic) MarshalJSON() ([]byte, error) { panic(0xdead) } 1001 1002func TestMarshalPanic(t *testing.T) { 1003 defer func() { 1004 if got := recover(); !reflect.DeepEqual(got, 0xdead) { 1005 t.Errorf("panic() = (%T)(%v), want 0xdead", got, got) 1006 } 1007 }() 1008 Marshal(&marshalPanic{}) 1009 t.Error("Marshal should have panicked") 1010} 1011 1012func TestMarshalUncommonFieldNames(t *testing.T) { 1013 v := struct { 1014 A0, À, Aβ int 1015 }{} 1016 b, err := Marshal(v) 1017 if err != nil { 1018 t.Fatal("Marshal:", err) 1019 } 1020 want := `{"A0":0,"À":0,"Aβ":0}` 1021 got := string(b) 1022 if got != want { 1023 t.Fatalf("Marshal: got %s want %s", got, want) 1024 } 1025} 1026