github.com/ice-blockchain/go/src@v0.0.0-20240403114104-1564d284e521/encoding/gob/encoder_test.go (about) 1 // Copyright 2009 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 5 package gob 6 7 import ( 8 "bytes" 9 "encoding/hex" 10 "fmt" 11 "io" 12 "math" 13 "reflect" 14 "sort" 15 "strings" 16 "testing" 17 ) 18 19 // Test basic operations in a safe manner. 20 func TestBasicEncoderDecoder(t *testing.T) { 21 var values = []any{ 22 true, 23 int(123), 24 int8(123), 25 int16(-12345), 26 int32(123456), 27 int64(-1234567), 28 uint(123), 29 uint8(123), 30 uint16(12345), 31 uint32(123456), 32 uint64(1234567), 33 uintptr(12345678), 34 float32(1.2345), 35 float64(1.2345678), 36 complex64(1.2345 + 2.3456i), 37 complex128(1.2345678 + 2.3456789i), 38 []byte("hello"), 39 string("hello"), 40 } 41 for _, value := range values { 42 b := new(bytes.Buffer) 43 enc := NewEncoder(b) 44 err := enc.Encode(value) 45 if err != nil { 46 t.Error("encoder fail:", err) 47 } 48 dec := NewDecoder(b) 49 result := reflect.New(reflect.TypeOf(value)) 50 err = dec.Decode(result.Interface()) 51 if err != nil { 52 t.Fatalf("error decoding %T: %v:", reflect.TypeOf(value), err) 53 } 54 if !reflect.DeepEqual(value, result.Elem().Interface()) { 55 t.Fatalf("%T: expected %v got %v", value, value, result.Elem().Interface()) 56 } 57 } 58 } 59 60 func TestEncodeIntSlice(t *testing.T) { 61 62 s8 := []int8{1, 5, 12, 22, 35, 51, 70, 92, 117} 63 s16 := []int16{145, 176, 210, 247, 287, 330, 376, 425, 477} 64 s32 := []int32{532, 590, 651, 715, 782, 852, 925, 1001, 1080} 65 s64 := []int64{1162, 1247, 1335, 1426, 1520, 1617, 1717, 1820, 1926} 66 67 t.Run("int8", func(t *testing.T) { 68 var sink bytes.Buffer 69 enc := NewEncoder(&sink) 70 enc.Encode(s8) 71 72 dec := NewDecoder(&sink) 73 res := make([]int8, 9) 74 dec.Decode(&res) 75 76 if !reflect.DeepEqual(s8, res) { 77 t.Fatalf("EncodeIntSlice: expected %v, got %v", s8, res) 78 } 79 }) 80 81 t.Run("int16", func(t *testing.T) { 82 var sink bytes.Buffer 83 enc := NewEncoder(&sink) 84 enc.Encode(s16) 85 86 dec := NewDecoder(&sink) 87 res := make([]int16, 9) 88 dec.Decode(&res) 89 90 if !reflect.DeepEqual(s16, res) { 91 t.Fatalf("EncodeIntSlice: expected %v, got %v", s16, res) 92 } 93 }) 94 95 t.Run("int32", func(t *testing.T) { 96 var sink bytes.Buffer 97 enc := NewEncoder(&sink) 98 enc.Encode(s32) 99 100 dec := NewDecoder(&sink) 101 res := make([]int32, 9) 102 dec.Decode(&res) 103 104 if !reflect.DeepEqual(s32, res) { 105 t.Fatalf("EncodeIntSlice: expected %v, got %v", s32, res) 106 } 107 }) 108 109 t.Run("int64", func(t *testing.T) { 110 var sink bytes.Buffer 111 enc := NewEncoder(&sink) 112 enc.Encode(s64) 113 114 dec := NewDecoder(&sink) 115 res := make([]int64, 9) 116 dec.Decode(&res) 117 118 if !reflect.DeepEqual(s64, res) { 119 t.Fatalf("EncodeIntSlice: expected %v, got %v", s64, res) 120 } 121 }) 122 123 } 124 125 type ET0 struct { 126 A int 127 B string 128 } 129 130 type ET2 struct { 131 X string 132 } 133 134 type ET1 struct { 135 A int 136 Et2 *ET2 137 Next *ET1 138 } 139 140 // Like ET1 but with a different name for a field 141 type ET3 struct { 142 A int 143 Et2 *ET2 144 DifferentNext *ET1 145 } 146 147 // Like ET1 but with a different type for a field 148 type ET4 struct { 149 A int 150 Et2 float64 151 Next int 152 } 153 154 func TestEncoderDecoder(t *testing.T) { 155 b := new(bytes.Buffer) 156 enc := NewEncoder(b) 157 et0 := new(ET0) 158 et0.A = 7 159 et0.B = "gobs of fun" 160 err := enc.Encode(et0) 161 if err != nil { 162 t.Error("encoder fail:", err) 163 } 164 //fmt.Printf("% x %q\n", b, b) 165 //Debug(b) 166 dec := NewDecoder(b) 167 newEt0 := new(ET0) 168 err = dec.Decode(newEt0) 169 if err != nil { 170 t.Fatal("error decoding ET0:", err) 171 } 172 173 if !reflect.DeepEqual(et0, newEt0) { 174 t.Fatalf("invalid data for et0: expected %+v; got %+v", *et0, *newEt0) 175 } 176 if b.Len() != 0 { 177 t.Error("not at eof;", b.Len(), "bytes left") 178 } 179 // t.FailNow() 180 181 b = new(bytes.Buffer) 182 enc = NewEncoder(b) 183 et1 := new(ET1) 184 et1.A = 7 185 et1.Et2 = new(ET2) 186 err = enc.Encode(et1) 187 if err != nil { 188 t.Error("encoder fail:", err) 189 } 190 dec = NewDecoder(b) 191 newEt1 := new(ET1) 192 err = dec.Decode(newEt1) 193 if err != nil { 194 t.Fatal("error decoding ET1:", err) 195 } 196 197 if !reflect.DeepEqual(et1, newEt1) { 198 t.Fatalf("invalid data for et1: expected %+v; got %+v", *et1, *newEt1) 199 } 200 if b.Len() != 0 { 201 t.Error("not at eof;", b.Len(), "bytes left") 202 } 203 204 enc.Encode(et1) 205 newEt1 = new(ET1) 206 err = dec.Decode(newEt1) 207 if err != nil { 208 t.Fatal("round 2: error decoding ET1:", err) 209 } 210 if !reflect.DeepEqual(et1, newEt1) { 211 t.Fatalf("round 2: invalid data for et1: expected %+v; got %+v", *et1, *newEt1) 212 } 213 if b.Len() != 0 { 214 t.Error("round 2: not at eof;", b.Len(), "bytes left") 215 } 216 217 // Now test with a running encoder/decoder pair that we recognize a type mismatch. 218 err = enc.Encode(et1) 219 if err != nil { 220 t.Error("round 3: encoder fail:", err) 221 } 222 newEt2 := new(ET2) 223 err = dec.Decode(newEt2) 224 if err == nil { 225 t.Fatal("round 3: expected `bad type' error decoding ET2") 226 } 227 } 228 229 // Run one value through the encoder/decoder, but use the wrong type. 230 // Input is always an ET1; we compare it to whatever is under 'e'. 231 func badTypeCheck(e any, shouldFail bool, msg string, t *testing.T) { 232 b := new(bytes.Buffer) 233 enc := NewEncoder(b) 234 et1 := new(ET1) 235 et1.A = 7 236 et1.Et2 = new(ET2) 237 err := enc.Encode(et1) 238 if err != nil { 239 t.Error("encoder fail:", err) 240 } 241 dec := NewDecoder(b) 242 err = dec.Decode(e) 243 if shouldFail && err == nil { 244 t.Error("expected error for", msg) 245 } 246 if !shouldFail && err != nil { 247 t.Error("unexpected error for", msg, err) 248 } 249 } 250 251 // Test that we recognize a bad type the first time. 252 func TestWrongTypeDecoder(t *testing.T) { 253 badTypeCheck(new(ET2), true, "no fields in common", t) 254 badTypeCheck(new(ET3), false, "different name of field", t) 255 badTypeCheck(new(ET4), true, "different type of field", t) 256 } 257 258 // Types not supported at top level by the Encoder. 259 var unsupportedValues = []any{ 260 make(chan int), 261 func(a int) bool { return true }, 262 } 263 264 func TestUnsupported(t *testing.T) { 265 var b bytes.Buffer 266 enc := NewEncoder(&b) 267 for _, v := range unsupportedValues { 268 err := enc.Encode(v) 269 if err == nil { 270 t.Errorf("expected error for %T; got none", v) 271 } 272 } 273 } 274 275 func encAndDec(in, out any) error { 276 b := new(bytes.Buffer) 277 enc := NewEncoder(b) 278 err := enc.Encode(in) 279 if err != nil { 280 return err 281 } 282 dec := NewDecoder(b) 283 err = dec.Decode(out) 284 if err != nil { 285 return err 286 } 287 return nil 288 } 289 290 func TestTypeToPtrType(t *testing.T) { 291 // Encode a T, decode a *T 292 type Type0 struct { 293 A int 294 } 295 t0 := Type0{7} 296 t0p := new(Type0) 297 if err := encAndDec(t0, t0p); err != nil { 298 t.Error(err) 299 } 300 } 301 302 func TestPtrTypeToType(t *testing.T) { 303 // Encode a *T, decode a T 304 type Type1 struct { 305 A uint 306 } 307 t1p := &Type1{17} 308 var t1 Type1 309 if err := encAndDec(t1, t1p); err != nil { 310 t.Error(err) 311 } 312 } 313 314 func TestTypeToPtrPtrPtrPtrType(t *testing.T) { 315 type Type2 struct { 316 A ****float64 317 } 318 t2 := Type2{} 319 t2.A = new(***float64) 320 *t2.A = new(**float64) 321 **t2.A = new(*float64) 322 ***t2.A = new(float64) 323 ****t2.A = 27.4 324 t2pppp := new(***Type2) 325 if err := encAndDec(t2, t2pppp); err != nil { 326 t.Fatal(err) 327 } 328 if ****(****t2pppp).A != ****t2.A { 329 t.Errorf("wrong value after decode: %g not %g", ****(****t2pppp).A, ****t2.A) 330 } 331 } 332 333 func TestSlice(t *testing.T) { 334 type Type3 struct { 335 A []string 336 } 337 t3p := &Type3{[]string{"hello", "world"}} 338 var t3 Type3 339 if err := encAndDec(t3, t3p); err != nil { 340 t.Error(err) 341 } 342 } 343 344 func TestValueError(t *testing.T) { 345 // Encode a *T, decode a T 346 type Type4 struct { 347 A int 348 } 349 t4p := &Type4{3} 350 var t4 Type4 // note: not a pointer. 351 if err := encAndDec(t4p, t4); err == nil || !strings.Contains(err.Error(), "pointer") { 352 t.Error("expected error about pointer; got", err) 353 } 354 } 355 356 func TestArray(t *testing.T) { 357 type Type5 struct { 358 A [3]string 359 B [3]byte 360 } 361 type Type6 struct { 362 A [2]string // can't hold t5.a 363 } 364 t5 := Type5{[3]string{"hello", ",", "world"}, [3]byte{1, 2, 3}} 365 var t5p Type5 366 if err := encAndDec(t5, &t5p); err != nil { 367 t.Error(err) 368 } 369 var t6 Type6 370 if err := encAndDec(t5, &t6); err == nil { 371 t.Error("should fail with mismatched array sizes") 372 } 373 } 374 375 func TestRecursiveMapType(t *testing.T) { 376 type recursiveMap map[string]recursiveMap 377 r1 := recursiveMap{"A": recursiveMap{"B": nil, "C": nil}, "D": nil} 378 r2 := make(recursiveMap) 379 if err := encAndDec(r1, &r2); err != nil { 380 t.Error(err) 381 } 382 } 383 384 func TestRecursiveSliceType(t *testing.T) { 385 type recursiveSlice []recursiveSlice 386 r1 := recursiveSlice{0: recursiveSlice{0: nil}, 1: nil} 387 r2 := make(recursiveSlice, 0) 388 if err := encAndDec(r1, &r2); err != nil { 389 t.Error(err) 390 } 391 } 392 393 // Regression test for bug: must send zero values inside arrays 394 func TestDefaultsInArray(t *testing.T) { 395 type Type7 struct { 396 B []bool 397 I []int 398 S []string 399 F []float64 400 } 401 t7 := Type7{ 402 []bool{false, false, true}, 403 []int{0, 0, 1}, 404 []string{"hi", "", "there"}, 405 []float64{0, 0, 1}, 406 } 407 var t7p Type7 408 if err := encAndDec(t7, &t7p); err != nil { 409 t.Error(err) 410 } 411 } 412 413 var testInt int 414 var testFloat32 float32 415 var testString string 416 var testSlice []string 417 var testMap map[string]int 418 var testArray [7]int 419 420 type SingleTest struct { 421 in any 422 out any 423 err string 424 } 425 426 var singleTests = []SingleTest{ 427 {17, &testInt, ""}, 428 {float32(17.5), &testFloat32, ""}, 429 {"bike shed", &testString, ""}, 430 {[]string{"bike", "shed", "paint", "color"}, &testSlice, ""}, 431 {map[string]int{"seven": 7, "twelve": 12}, &testMap, ""}, 432 {[7]int{4, 55, 0, 0, 0, 0, 0}, &testArray, ""}, // case that once triggered a bug 433 {[7]int{4, 55, 1, 44, 22, 66, 1234}, &testArray, ""}, 434 435 // Decode errors 436 {172, &testFloat32, "type"}, 437 } 438 439 func TestSingletons(t *testing.T) { 440 b := new(bytes.Buffer) 441 enc := NewEncoder(b) 442 dec := NewDecoder(b) 443 for _, test := range singleTests { 444 b.Reset() 445 err := enc.Encode(test.in) 446 if err != nil { 447 t.Errorf("error encoding %v: %s", test.in, err) 448 continue 449 } 450 err = dec.Decode(test.out) 451 switch { 452 case err != nil && test.err == "": 453 t.Errorf("error decoding %v: %s", test.in, err) 454 continue 455 case err == nil && test.err != "": 456 t.Errorf("expected error decoding %v: %s", test.in, test.err) 457 continue 458 case err != nil && test.err != "": 459 if !strings.Contains(err.Error(), test.err) { 460 t.Errorf("wrong error decoding %v: wanted %s, got %v", test.in, test.err, err) 461 } 462 continue 463 } 464 // Get rid of the pointer in the rhs 465 val := reflect.ValueOf(test.out).Elem().Interface() 466 if !reflect.DeepEqual(test.in, val) { 467 t.Errorf("decoding singleton: expected %v got %v", test.in, val) 468 } 469 } 470 } 471 472 func TestStructNonStruct(t *testing.T) { 473 type Struct struct { 474 A string 475 } 476 type NonStruct string 477 s := Struct{"hello"} 478 var sp Struct 479 if err := encAndDec(s, &sp); err != nil { 480 t.Error(err) 481 } 482 var ns NonStruct 483 if err := encAndDec(s, &ns); err == nil { 484 t.Error("should get error for struct/non-struct") 485 } else if !strings.Contains(err.Error(), "type") { 486 t.Error("for struct/non-struct expected type error; got", err) 487 } 488 // Now try the other way 489 var nsp NonStruct 490 if err := encAndDec(ns, &nsp); err != nil { 491 t.Error(err) 492 } 493 if err := encAndDec(ns, &s); err == nil { 494 t.Error("should get error for non-struct/struct") 495 } else if !strings.Contains(err.Error(), "type") { 496 t.Error("for non-struct/struct expected type error; got", err) 497 } 498 } 499 500 type interfaceIndirectTestI interface { 501 F() bool 502 } 503 504 type interfaceIndirectTestT struct{} 505 506 func (this *interfaceIndirectTestT) F() bool { 507 return true 508 } 509 510 // A version of a bug reported on golang-nuts. Also tests top-level 511 // slice of interfaces. The issue was registering *T caused T to be 512 // stored as the concrete type. 513 func TestInterfaceIndirect(t *testing.T) { 514 Register(&interfaceIndirectTestT{}) 515 b := new(bytes.Buffer) 516 w := []interfaceIndirectTestI{&interfaceIndirectTestT{}} 517 err := NewEncoder(b).Encode(w) 518 if err != nil { 519 t.Fatal("encode error:", err) 520 } 521 522 var r []interfaceIndirectTestI 523 err = NewDecoder(b).Decode(&r) 524 if err != nil { 525 t.Fatal("decode error:", err) 526 } 527 } 528 529 // Now follow various tests that decode into things that can't represent the 530 // encoded value, all of which should be legal. 531 532 // Also, when the ignored object contains an interface value, it may define 533 // types. Make sure that skipping the value still defines the types by using 534 // the encoder/decoder pair to send a value afterwards. If an interface 535 // is sent, its type in the test is always NewType0, so this checks that the 536 // encoder and decoder don't skew with respect to type definitions. 537 538 type Struct0 struct { 539 I any 540 } 541 542 type NewType0 struct { 543 S string 544 } 545 546 type ignoreTest struct { 547 in, out any 548 } 549 550 var ignoreTests = []ignoreTest{ 551 // Decode normal struct into an empty struct 552 {&struct{ A int }{23}, &struct{}{}}, 553 // Decode normal struct into a nil. 554 {&struct{ A int }{23}, nil}, 555 // Decode singleton string into a nil. 556 {"hello, world", nil}, 557 // Decode singleton slice into a nil. 558 {[]int{1, 2, 3, 4}, nil}, 559 // Decode struct containing an interface into a nil. 560 {&Struct0{&NewType0{"value0"}}, nil}, 561 // Decode singleton slice of interfaces into a nil. 562 {[]any{"hi", &NewType0{"value1"}, 23}, nil}, 563 } 564 565 func TestDecodeIntoNothing(t *testing.T) { 566 Register(new(NewType0)) 567 for i, test := range ignoreTests { 568 b := new(bytes.Buffer) 569 enc := NewEncoder(b) 570 err := enc.Encode(test.in) 571 if err != nil { 572 t.Errorf("%d: encode error %s:", i, err) 573 continue 574 } 575 dec := NewDecoder(b) 576 err = dec.Decode(test.out) 577 if err != nil { 578 t.Errorf("%d: decode error: %s", i, err) 579 continue 580 } 581 // Now see if the encoder and decoder are in a consistent state. 582 str := fmt.Sprintf("Value %d", i) 583 err = enc.Encode(&NewType0{str}) 584 if err != nil { 585 t.Fatalf("%d: NewType0 encode error: %s", i, err) 586 } 587 ns := new(NewType0) 588 err = dec.Decode(ns) 589 if err != nil { 590 t.Fatalf("%d: NewType0 decode error: %s", i, err) 591 } 592 if ns.S != str { 593 t.Fatalf("%d: expected %q got %q", i, str, ns.S) 594 } 595 } 596 } 597 598 func TestIgnoreRecursiveType(t *testing.T) { 599 // It's hard to build a self-contained test for this because 600 // we can't build compatible types in one package with 601 // different items so something is ignored. Here is 602 // some data that represents, according to debug.go: 603 // type definition { 604 // slice "recursiveSlice" id=106 605 // elem id=106 606 // } 607 data := []byte{ 608 0x1d, 0xff, 0xd3, 0x02, 0x01, 0x01, 0x0e, 0x72, 609 0x65, 0x63, 0x75, 0x72, 0x73, 0x69, 0x76, 0x65, 610 0x53, 0x6c, 0x69, 0x63, 0x65, 0x01, 0xff, 0xd4, 611 0x00, 0x01, 0xff, 0xd4, 0x00, 0x00, 0x07, 0xff, 612 0xd4, 0x00, 0x02, 0x01, 0x00, 0x00, 613 } 614 dec := NewDecoder(bytes.NewReader(data)) 615 // Issue 10415: This caused infinite recursion. 616 err := dec.Decode(nil) 617 if err != nil { 618 t.Fatal(err) 619 } 620 } 621 622 // Another bug from golang-nuts, involving nested interfaces. 623 type Bug0Outer struct { 624 Bug0Field any 625 } 626 627 type Bug0Inner struct { 628 A int 629 } 630 631 func TestNestedInterfaces(t *testing.T) { 632 var buf bytes.Buffer 633 e := NewEncoder(&buf) 634 d := NewDecoder(&buf) 635 Register(new(Bug0Outer)) 636 Register(new(Bug0Inner)) 637 f := &Bug0Outer{&Bug0Outer{&Bug0Inner{7}}} 638 var v any = f 639 err := e.Encode(&v) 640 if err != nil { 641 t.Fatal("Encode:", err) 642 } 643 err = d.Decode(&v) 644 if err != nil { 645 t.Fatal("Decode:", err) 646 } 647 // Make sure it decoded correctly. 648 outer1, ok := v.(*Bug0Outer) 649 if !ok { 650 t.Fatalf("v not Bug0Outer: %T", v) 651 } 652 outer2, ok := outer1.Bug0Field.(*Bug0Outer) 653 if !ok { 654 t.Fatalf("v.Bug0Field not Bug0Outer: %T", outer1.Bug0Field) 655 } 656 inner, ok := outer2.Bug0Field.(*Bug0Inner) 657 if !ok { 658 t.Fatalf("v.Bug0Field.Bug0Field not Bug0Inner: %T", outer2.Bug0Field) 659 } 660 if inner.A != 7 { 661 t.Fatalf("final value %d; expected %d", inner.A, 7) 662 } 663 } 664 665 // The bugs keep coming. We forgot to send map subtypes before the map. 666 667 type Bug1Elem struct { 668 Name string 669 Id int 670 } 671 672 type Bug1StructMap map[string]Bug1Elem 673 674 func TestMapBug1(t *testing.T) { 675 in := make(Bug1StructMap) 676 in["val1"] = Bug1Elem{"elem1", 1} 677 in["val2"] = Bug1Elem{"elem2", 2} 678 679 b := new(bytes.Buffer) 680 enc := NewEncoder(b) 681 err := enc.Encode(in) 682 if err != nil { 683 t.Fatal("encode:", err) 684 } 685 dec := NewDecoder(b) 686 out := make(Bug1StructMap) 687 err = dec.Decode(&out) 688 if err != nil { 689 t.Fatal("decode:", err) 690 } 691 if !reflect.DeepEqual(in, out) { 692 t.Errorf("mismatch: %v %v", in, out) 693 } 694 } 695 696 func TestGobMapInterfaceEncode(t *testing.T) { 697 m := map[string]any{ 698 "up": uintptr(0), 699 "i0": []int{-1}, 700 "i1": []int8{-1}, 701 "i2": []int16{-1}, 702 "i3": []int32{-1}, 703 "i4": []int64{-1}, 704 "u0": []uint{1}, 705 "u1": []uint8{1}, 706 "u2": []uint16{1}, 707 "u3": []uint32{1}, 708 "u4": []uint64{1}, 709 "f0": []float32{1}, 710 "f1": []float64{1}, 711 "c0": []complex64{complex(2, -2)}, 712 "c1": []complex128{complex(2, float64(-2))}, 713 "us": []uintptr{0}, 714 "bo": []bool{false}, 715 "st": []string{"s"}, 716 } 717 enc := NewEncoder(new(bytes.Buffer)) 718 err := enc.Encode(m) 719 if err != nil { 720 t.Errorf("encode map: %s", err) 721 } 722 } 723 724 func TestSliceReusesMemory(t *testing.T) { 725 buf := new(bytes.Buffer) 726 // Bytes 727 { 728 x := []byte("abcd") 729 enc := NewEncoder(buf) 730 err := enc.Encode(x) 731 if err != nil { 732 t.Errorf("bytes: encode: %s", err) 733 } 734 // Decode into y, which is big enough. 735 y := []byte("ABCDE") 736 addr := &y[0] 737 dec := NewDecoder(buf) 738 err = dec.Decode(&y) 739 if err != nil { 740 t.Fatal("bytes: decode:", err) 741 } 742 if !bytes.Equal(x, y) { 743 t.Errorf("bytes: expected %q got %q\n", x, y) 744 } 745 if addr != &y[0] { 746 t.Errorf("bytes: unnecessary reallocation") 747 } 748 } 749 // general slice 750 { 751 x := []rune("abcd") 752 enc := NewEncoder(buf) 753 err := enc.Encode(x) 754 if err != nil { 755 t.Errorf("ints: encode: %s", err) 756 } 757 // Decode into y, which is big enough. 758 y := []rune("ABCDE") 759 addr := &y[0] 760 dec := NewDecoder(buf) 761 err = dec.Decode(&y) 762 if err != nil { 763 t.Fatal("ints: decode:", err) 764 } 765 if !reflect.DeepEqual(x, y) { 766 t.Errorf("ints: expected %q got %q\n", x, y) 767 } 768 if addr != &y[0] { 769 t.Errorf("ints: unnecessary reallocation") 770 } 771 } 772 } 773 774 // Used to crash: negative count in recvMessage. 775 func TestBadCount(t *testing.T) { 776 b := []byte{0xfb, 0xa5, 0x82, 0x2f, 0xca, 0x1} 777 if err := NewDecoder(bytes.NewReader(b)).Decode(nil); err == nil { 778 t.Error("expected error from bad count") 779 } else if err.Error() != errBadCount.Error() { 780 t.Error("expected bad count error; got", err) 781 } 782 } 783 784 // Verify that sequential Decoders built on a single input will 785 // succeed if the input implements ReadByte and there is no 786 // type information in the stream. 787 func TestSequentialDecoder(t *testing.T) { 788 b := new(bytes.Buffer) 789 enc := NewEncoder(b) 790 const count = 10 791 for i := 0; i < count; i++ { 792 s := fmt.Sprintf("%d", i) 793 if err := enc.Encode(s); err != nil { 794 t.Error("encoder fail:", err) 795 } 796 } 797 for i := 0; i < count; i++ { 798 dec := NewDecoder(b) 799 var s string 800 if err := dec.Decode(&s); err != nil { 801 t.Fatal("decoder fail:", err) 802 } 803 if s != fmt.Sprintf("%d", i) { 804 t.Fatalf("decode expected %d got %s", i, s) 805 } 806 } 807 } 808 809 // Should be able to have unrepresentable fields (chan, func, *chan etc.); we just ignore them. 810 type Bug2 struct { 811 A int 812 C chan int 813 CP *chan int 814 F func() 815 FPP **func() 816 } 817 818 func TestChanFuncIgnored(t *testing.T) { 819 c := make(chan int) 820 f := func() {} 821 fp := &f 822 b0 := Bug2{23, c, &c, f, &fp} 823 var buf bytes.Buffer 824 enc := NewEncoder(&buf) 825 if err := enc.Encode(b0); err != nil { 826 t.Fatal("error encoding:", err) 827 } 828 var b1 Bug2 829 err := NewDecoder(&buf).Decode(&b1) 830 if err != nil { 831 t.Fatal("decode:", err) 832 } 833 if b1.A != b0.A { 834 t.Fatalf("got %d want %d", b1.A, b0.A) 835 } 836 if b1.C != nil || b1.CP != nil || b1.F != nil || b1.FPP != nil { 837 t.Fatal("unexpected value for chan or func") 838 } 839 } 840 841 func TestSliceIncompatibility(t *testing.T) { 842 var in = []byte{1, 2, 3} 843 var out []int 844 if err := encAndDec(in, &out); err == nil { 845 t.Error("expected compatibility error") 846 } 847 } 848 849 // Mutually recursive slices of structs caused problems. 850 type Bug3 struct { 851 Num int 852 Children []*Bug3 853 } 854 855 func TestGobPtrSlices(t *testing.T) { 856 in := []*Bug3{ 857 {1, nil}, 858 {2, nil}, 859 } 860 b := new(bytes.Buffer) 861 err := NewEncoder(b).Encode(&in) 862 if err != nil { 863 t.Fatal("encode:", err) 864 } 865 866 var out []*Bug3 867 err = NewDecoder(b).Decode(&out) 868 if err != nil { 869 t.Fatal("decode:", err) 870 } 871 if !reflect.DeepEqual(in, out) { 872 t.Fatalf("got %v; wanted %v", out, in) 873 } 874 } 875 876 // getDecEnginePtr cached engine for ut.base instead of ut.user so we passed 877 // a *map and then tried to reuse its engine to decode the inner map. 878 func TestPtrToMapOfMap(t *testing.T) { 879 Register(make(map[string]any)) 880 subdata := make(map[string]any) 881 subdata["bar"] = "baz" 882 data := make(map[string]any) 883 data["foo"] = subdata 884 885 b := new(bytes.Buffer) 886 err := NewEncoder(b).Encode(data) 887 if err != nil { 888 t.Fatal("encode:", err) 889 } 890 var newData map[string]any 891 err = NewDecoder(b).Decode(&newData) 892 if err != nil { 893 t.Fatal("decode:", err) 894 } 895 if !reflect.DeepEqual(data, newData) { 896 t.Fatalf("expected %v got %v", data, newData) 897 } 898 } 899 900 // Test that untyped nils generate an error, not a panic. 901 // See Issue 16204. 902 func TestCatchInvalidNilValue(t *testing.T) { 903 encodeErr, panicErr := encodeAndRecover(nil) 904 if panicErr != nil { 905 t.Fatalf("panicErr=%v, should not panic encoding untyped nil", panicErr) 906 } 907 if encodeErr == nil { 908 t.Errorf("got err=nil, want non-nil error when encoding untyped nil value") 909 } else if !strings.Contains(encodeErr.Error(), "nil value") { 910 t.Errorf("expected 'nil value' error; got err=%v", encodeErr) 911 } 912 } 913 914 // A top-level nil pointer generates a panic with a helpful string-valued message. 915 func TestTopLevelNilPointer(t *testing.T) { 916 var ip *int 917 encodeErr, panicErr := encodeAndRecover(ip) 918 if encodeErr != nil { 919 t.Fatal("error in encode:", encodeErr) 920 } 921 if panicErr == nil { 922 t.Fatal("top-level nil pointer did not panic") 923 } 924 errMsg := panicErr.Error() 925 if !strings.Contains(errMsg, "nil pointer") { 926 t.Fatal("expected nil pointer error, got:", errMsg) 927 } 928 } 929 930 func encodeAndRecover(value any) (encodeErr, panicErr error) { 931 defer func() { 932 e := recover() 933 if e != nil { 934 switch err := e.(type) { 935 case error: 936 panicErr = err 937 default: 938 panicErr = fmt.Errorf("%v", err) 939 } 940 } 941 }() 942 943 encodeErr = NewEncoder(io.Discard).Encode(value) 944 return 945 } 946 947 func TestNilPointerPanics(t *testing.T) { 948 var ( 949 nilStringPtr *string 950 intMap = make(map[int]int) 951 intMapPtr = &intMap 952 nilIntMapPtr *map[int]int 953 zero int 954 nilBoolChannel chan bool 955 nilBoolChannelPtr *chan bool 956 nilStringSlice []string 957 stringSlice = make([]string, 1) 958 nilStringSlicePtr *[]string 959 ) 960 961 testCases := []struct { 962 value any 963 mustPanic bool 964 }{ 965 {nilStringPtr, true}, 966 {intMap, false}, 967 {intMapPtr, false}, 968 {nilIntMapPtr, true}, 969 {zero, false}, 970 {nilStringSlice, false}, 971 {stringSlice, false}, 972 {nilStringSlicePtr, true}, 973 {nilBoolChannel, false}, 974 {nilBoolChannelPtr, true}, 975 } 976 977 for _, tt := range testCases { 978 _, panicErr := encodeAndRecover(tt.value) 979 if tt.mustPanic { 980 if panicErr == nil { 981 t.Errorf("expected panic with input %#v, did not panic", tt.value) 982 } 983 continue 984 } 985 if panicErr != nil { 986 t.Fatalf("expected no panic with input %#v, got panic=%v", tt.value, panicErr) 987 } 988 } 989 } 990 991 func TestNilPointerInsideInterface(t *testing.T) { 992 var ip *int 993 si := struct { 994 I any 995 }{ 996 I: ip, 997 } 998 buf := new(bytes.Buffer) 999 err := NewEncoder(buf).Encode(si) 1000 if err == nil { 1001 t.Fatal("expected error, got none") 1002 } 1003 errMsg := err.Error() 1004 if !strings.Contains(errMsg, "nil pointer") || !strings.Contains(errMsg, "interface") { 1005 t.Fatal("expected error about nil pointer and interface, got:", errMsg) 1006 } 1007 } 1008 1009 type Bug4Public struct { 1010 Name string 1011 Secret Bug4Secret 1012 } 1013 1014 type Bug4Secret struct { 1015 a int // error: no exported fields. 1016 } 1017 1018 // Test that a failed compilation doesn't leave around an executable encoder. 1019 // Issue 3723. 1020 func TestMultipleEncodingsOfBadType(t *testing.T) { 1021 x := Bug4Public{ 1022 Name: "name", 1023 Secret: Bug4Secret{1}, 1024 } 1025 buf := new(bytes.Buffer) 1026 enc := NewEncoder(buf) 1027 err := enc.Encode(x) 1028 if err == nil { 1029 t.Fatal("first encoding: expected error") 1030 } 1031 buf.Reset() 1032 enc = NewEncoder(buf) 1033 err = enc.Encode(x) 1034 if err == nil { 1035 t.Fatal("second encoding: expected error") 1036 } 1037 if !strings.Contains(err.Error(), "no exported fields") { 1038 t.Errorf("expected error about no exported fields; got %v", err) 1039 } 1040 } 1041 1042 // There was an error check comparing the length of the input with the 1043 // length of the slice being decoded. It was wrong because the next 1044 // thing in the input might be a type definition, which would lead to 1045 // an incorrect length check. This test reproduces the corner case. 1046 1047 type Z struct { 1048 } 1049 1050 func Test29ElementSlice(t *testing.T) { 1051 Register(Z{}) 1052 src := make([]any, 100) // Size needs to be bigger than size of type definition. 1053 for i := range src { 1054 src[i] = Z{} 1055 } 1056 buf := new(bytes.Buffer) 1057 err := NewEncoder(buf).Encode(src) 1058 if err != nil { 1059 t.Fatalf("encode: %v", err) 1060 return 1061 } 1062 1063 var dst []any 1064 err = NewDecoder(buf).Decode(&dst) 1065 if err != nil { 1066 t.Errorf("decode: %v", err) 1067 return 1068 } 1069 } 1070 1071 // Don't crash, just give error when allocating a huge slice. 1072 // Issue 8084. 1073 func TestErrorForHugeSlice(t *testing.T) { 1074 // Encode an int slice. 1075 buf := new(bytes.Buffer) 1076 slice := []int{1, 1, 1, 1, 1, 1, 1, 1, 1, 1} 1077 err := NewEncoder(buf).Encode(slice) 1078 if err != nil { 1079 t.Fatal("encode:", err) 1080 } 1081 // Reach into the buffer and smash the count to make the encoded slice very long. 1082 buf.Bytes()[buf.Len()-len(slice)-1] = 0xfa 1083 // Decode and see error. 1084 err = NewDecoder(buf).Decode(&slice) 1085 if err == nil { 1086 t.Fatal("decode: no error") 1087 } 1088 if !strings.Contains(err.Error(), "slice too big") { 1089 t.Fatalf("decode: expected slice too big error, got %s", err.Error()) 1090 } 1091 } 1092 1093 type badDataTest struct { 1094 input string // The input encoded as a hex string. 1095 error string // A substring of the error that should result. 1096 data any // What to decode into. 1097 } 1098 1099 var badDataTests = []badDataTest{ 1100 {"", "EOF", nil}, 1101 {"7F6869", "unexpected EOF", nil}, 1102 {"036e6f77206973207468652074696d6520666f7220616c6c20676f6f64206d656e", "unknown type id", new(ET2)}, 1103 {"0424666f6f", "field numbers out of bounds", new(ET2)}, // Issue 6323. 1104 {"05100028557b02027f8302", "interface encoding", nil}, // Issue 10270. 1105 // Issue 10273. 1106 {"130a00fb5dad0bf8ff020263e70002fa28020202a89859", "slice length too large", nil}, 1107 {"0f1000fb285d003316020735ff023a65c5", "interface encoding", nil}, 1108 {"03fffb0616fffc00f902ff02ff03bf005d02885802a311a8120228022c028ee7", "GobDecoder", nil}, 1109 // Issue 10491. 1110 {"10fe010f020102fe01100001fe010e000016fe010d030102fe010e00010101015801fe01100000000bfe011000f85555555555555555", "exceeds input size", nil}, 1111 } 1112 1113 // TestBadData tests that various problems caused by malformed input 1114 // are caught as errors and do not cause panics. 1115 func TestBadData(t *testing.T) { 1116 for i, test := range badDataTests { 1117 data, err := hex.DecodeString(test.input) 1118 if err != nil { 1119 t.Fatalf("#%d: hex error: %s", i, err) 1120 } 1121 d := NewDecoder(bytes.NewReader(data)) 1122 err = d.Decode(test.data) 1123 if err == nil { 1124 t.Errorf("decode: no error") 1125 continue 1126 } 1127 if !strings.Contains(err.Error(), test.error) { 1128 t.Errorf("#%d: decode: expected %q error, got %s", i, test.error, err.Error()) 1129 } 1130 } 1131 } 1132 1133 func TestDecodeErrorMultipleTypes(t *testing.T) { 1134 type Test struct { 1135 A string 1136 B int 1137 } 1138 var b bytes.Buffer 1139 NewEncoder(&b).Encode(Test{"one", 1}) 1140 1141 var result, result2 Test 1142 dec := NewDecoder(&b) 1143 err := dec.Decode(&result) 1144 if err != nil { 1145 t.Errorf("decode: unexpected error %v", err) 1146 } 1147 1148 b.Reset() 1149 NewEncoder(&b).Encode(Test{"two", 2}) 1150 err = dec.Decode(&result2) 1151 if err == nil { 1152 t.Errorf("decode: expected duplicate type error, got nil") 1153 } else if !strings.Contains(err.Error(), "duplicate type") { 1154 t.Errorf("decode: expected duplicate type error, got %s", err.Error()) 1155 } 1156 } 1157 1158 // Issue 24075 1159 func TestMarshalFloatMap(t *testing.T) { 1160 nan1 := math.NaN() 1161 nan2 := math.Float64frombits(math.Float64bits(nan1) ^ 1) // A different NaN in the same class. 1162 1163 in := map[float64]string{ 1164 nan1: "a", 1165 nan1: "b", 1166 nan2: "c", 1167 } 1168 1169 var b bytes.Buffer 1170 enc := NewEncoder(&b) 1171 if err := enc.Encode(in); err != nil { 1172 t.Errorf("Encode : %v", err) 1173 } 1174 1175 out := map[float64]string{} 1176 dec := NewDecoder(&b) 1177 if err := dec.Decode(&out); err != nil { 1178 t.Fatalf("Decode : %v", err) 1179 } 1180 1181 type mapEntry struct { 1182 keyBits uint64 1183 value string 1184 } 1185 readMap := func(m map[float64]string) (entries []mapEntry) { 1186 for k, v := range m { 1187 entries = append(entries, mapEntry{math.Float64bits(k), v}) 1188 } 1189 sort.Slice(entries, func(i, j int) bool { 1190 ei, ej := entries[i], entries[j] 1191 if ei.keyBits != ej.keyBits { 1192 return ei.keyBits < ej.keyBits 1193 } 1194 return ei.value < ej.value 1195 }) 1196 return entries 1197 } 1198 1199 got := readMap(out) 1200 want := readMap(in) 1201 if !reflect.DeepEqual(got, want) { 1202 t.Fatalf("\nEncode: %v\nDecode: %v", want, got) 1203 } 1204 } 1205 1206 func TestDecodePartial(t *testing.T) { 1207 type T struct { 1208 X []int 1209 Y string 1210 } 1211 1212 var buf bytes.Buffer 1213 t1 := T{X: []int{1, 2, 3}, Y: "foo"} 1214 t2 := T{X: []int{4, 5, 6}, Y: "bar"} 1215 enc := NewEncoder(&buf) 1216 1217 t1start := 0 1218 if err := enc.Encode(&t1); err != nil { 1219 t.Fatal(err) 1220 } 1221 1222 t2start := buf.Len() 1223 if err := enc.Encode(&t2); err != nil { 1224 t.Fatal(err) 1225 } 1226 1227 data := buf.Bytes() 1228 for i := 0; i <= len(data); i++ { 1229 bufr := bytes.NewReader(data[:i]) 1230 1231 // Decode both values, stopping at the first error. 1232 var t1b, t2b T 1233 dec := NewDecoder(bufr) 1234 var err error 1235 err = dec.Decode(&t1b) 1236 if err == nil { 1237 err = dec.Decode(&t2b) 1238 } 1239 1240 switch i { 1241 case t1start, t2start: 1242 // Either the first or the second Decode calls had zero input. 1243 if err != io.EOF { 1244 t.Errorf("%d/%d: expected io.EOF: %v", i, len(data), err) 1245 } 1246 case len(data): 1247 // We reached the end of the entire input. 1248 if err != nil { 1249 t.Errorf("%d/%d: unexpected error: %v", i, len(data), err) 1250 } 1251 if !reflect.DeepEqual(t1b, t1) { 1252 t.Fatalf("t1 value mismatch: got %v, want %v", t1b, t1) 1253 } 1254 if !reflect.DeepEqual(t2b, t2) { 1255 t.Fatalf("t2 value mismatch: got %v, want %v", t2b, t2) 1256 } 1257 default: 1258 // In between, we must see io.ErrUnexpectedEOF. 1259 // The decoder used to erroneously return io.EOF in some cases here, 1260 // such as if the input was cut off right after some type specs, 1261 // but before any value was actually transmitted. 1262 if err != io.ErrUnexpectedEOF { 1263 t.Errorf("%d/%d: expected io.ErrUnexpectedEOF: %v", i, len(data), err) 1264 } 1265 } 1266 } 1267 } 1268 1269 func TestDecoderOverflow(t *testing.T) { 1270 // Issue 55337. 1271 dec := NewDecoder(bytes.NewReader([]byte{ 1272 0x12, 0xff, 0xff, 0x2, 0x2, 0x20, 0x0, 0xf8, 0x7f, 0xff, 0xff, 0xff, 1273 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x20, 0x20, 0x20, 0x20, 0x20, 1274 })) 1275 var r interface{} 1276 err := dec.Decode(r) 1277 if err == nil { 1278 t.Fatalf("expected an error") 1279 } 1280 }