Source file src/encoding/gob/encoder_test.go

     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  }
  1281  

View as plain text