Source file src/encoding/gob/codec_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  	"errors"
    10  	"flag"
    11  	"math"
    12  	"math/rand"
    13  	"reflect"
    14  	"strings"
    15  	"testing"
    16  	"time"
    17  )
    18  
    19  var doFuzzTests = flag.Bool("gob.fuzz", false, "run the fuzz tests, which are large and very slow")
    20  
    21  // Guarantee encoding format by comparing some encodings to hand-written values
    22  type EncodeT struct {
    23  	x uint64
    24  	b []byte
    25  }
    26  
    27  var encodeT = []EncodeT{
    28  	{0x00, []byte{0x00}},
    29  	{0x0F, []byte{0x0F}},
    30  	{0xFF, []byte{0xFF, 0xFF}},
    31  	{0xFFFF, []byte{0xFE, 0xFF, 0xFF}},
    32  	{0xFFFFFF, []byte{0xFD, 0xFF, 0xFF, 0xFF}},
    33  	{0xFFFFFFFF, []byte{0xFC, 0xFF, 0xFF, 0xFF, 0xFF}},
    34  	{0xFFFFFFFFFF, []byte{0xFB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}},
    35  	{0xFFFFFFFFFFFF, []byte{0xFA, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}},
    36  	{0xFFFFFFFFFFFFFF, []byte{0xF9, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}},
    37  	{0xFFFFFFFFFFFFFFFF, []byte{0xF8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}},
    38  	{0x1111, []byte{0xFE, 0x11, 0x11}},
    39  	{0x1111111111111111, []byte{0xF8, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11}},
    40  	{0x8888888888888888, []byte{0xF8, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88}},
    41  	{1 << 63, []byte{0xF8, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
    42  }
    43  
    44  // testError is meant to be used as a deferred function to turn a panic(gobError) into a
    45  // plain test.Error call.
    46  func testError(t *testing.T) {
    47  	if e := recover(); e != nil {
    48  		t.Error(e.(gobError).err) // Will re-panic if not one of our errors, such as a runtime error.
    49  	}
    50  }
    51  
    52  func newDecBuffer(data []byte) *decBuffer {
    53  	return &decBuffer{
    54  		data: data,
    55  	}
    56  }
    57  
    58  // Test basic encode/decode routines for unsigned integers
    59  func TestUintCodec(t *testing.T) {
    60  	defer testError(t)
    61  	b := new(encBuffer)
    62  	encState := newEncoderState(b)
    63  	for _, tt := range encodeT {
    64  		b.Reset()
    65  		encState.encodeUint(tt.x)
    66  		if !bytes.Equal(tt.b, b.Bytes()) {
    67  			t.Errorf("encodeUint: %#x encode: expected % x got % x", tt.x, tt.b, b.Bytes())
    68  		}
    69  	}
    70  	for u := uint64(0); ; u = (u + 1) * 7 {
    71  		b.Reset()
    72  		encState.encodeUint(u)
    73  		decState := newDecodeState(newDecBuffer(b.Bytes()))
    74  		v := decState.decodeUint()
    75  		if u != v {
    76  			t.Errorf("Encode/Decode: sent %#x received %#x", u, v)
    77  		}
    78  		if u&(1<<63) != 0 {
    79  			break
    80  		}
    81  	}
    82  }
    83  
    84  func verifyInt(i int64, t *testing.T) {
    85  	defer testError(t)
    86  	var b = new(encBuffer)
    87  	encState := newEncoderState(b)
    88  	encState.encodeInt(i)
    89  	decState := newDecodeState(newDecBuffer(b.Bytes()))
    90  	j := decState.decodeInt()
    91  	if i != j {
    92  		t.Errorf("Encode/Decode: sent %#x received %#x", uint64(i), uint64(j))
    93  	}
    94  }
    95  
    96  // Test basic encode/decode routines for signed integers
    97  func TestIntCodec(t *testing.T) {
    98  	for u := uint64(0); ; u = (u + 1) * 7 {
    99  		// Do positive and negative values
   100  		i := int64(u)
   101  		verifyInt(i, t)
   102  		verifyInt(-i, t)
   103  		verifyInt(^i, t)
   104  		if u&(1<<63) != 0 {
   105  			break
   106  		}
   107  	}
   108  	verifyInt(-1<<63, t) // a tricky case
   109  }
   110  
   111  // The result of encoding a true boolean with field number 7
   112  var boolResult = []byte{0x07, 0x01}
   113  
   114  // The result of encoding a number 17 with field number 7
   115  var signedResult = []byte{0x07, 2 * 17}
   116  var unsignedResult = []byte{0x07, 17}
   117  var floatResult = []byte{0x07, 0xFE, 0x31, 0x40}
   118  
   119  // The result of encoding a number 17+19i with field number 7
   120  var complexResult = []byte{0x07, 0xFE, 0x31, 0x40, 0xFE, 0x33, 0x40}
   121  
   122  // The result of encoding "hello" with field number 7
   123  var bytesResult = []byte{0x07, 0x05, 'h', 'e', 'l', 'l', 'o'}
   124  
   125  func newDecodeState(buf *decBuffer) *decoderState {
   126  	d := new(decoderState)
   127  	d.b = buf
   128  	return d
   129  }
   130  
   131  func newEncoderState(b *encBuffer) *encoderState {
   132  	b.Reset()
   133  	state := &encoderState{enc: nil, b: b}
   134  	state.fieldnum = -1
   135  	return state
   136  }
   137  
   138  // Test instruction execution for encoding.
   139  // Do not run the machine yet; instead do individual instructions crafted by hand.
   140  func TestScalarEncInstructions(t *testing.T) {
   141  	var b = new(encBuffer)
   142  
   143  	// bool
   144  	{
   145  		var data bool = true
   146  		instr := &encInstr{encBool, 6, nil, 0}
   147  		state := newEncoderState(b)
   148  		instr.op(instr, state, reflect.ValueOf(data))
   149  		if !bytes.Equal(boolResult, b.Bytes()) {
   150  			t.Errorf("bool enc instructions: expected % x got % x", boolResult, b.Bytes())
   151  		}
   152  	}
   153  
   154  	// int
   155  	{
   156  		b.Reset()
   157  		var data int = 17
   158  		instr := &encInstr{encInt, 6, nil, 0}
   159  		state := newEncoderState(b)
   160  		instr.op(instr, state, reflect.ValueOf(data))
   161  		if !bytes.Equal(signedResult, b.Bytes()) {
   162  			t.Errorf("int enc instructions: expected % x got % x", signedResult, b.Bytes())
   163  		}
   164  	}
   165  
   166  	// uint
   167  	{
   168  		b.Reset()
   169  		var data uint = 17
   170  		instr := &encInstr{encUint, 6, nil, 0}
   171  		state := newEncoderState(b)
   172  		instr.op(instr, state, reflect.ValueOf(data))
   173  		if !bytes.Equal(unsignedResult, b.Bytes()) {
   174  			t.Errorf("uint enc instructions: expected % x got % x", unsignedResult, b.Bytes())
   175  		}
   176  	}
   177  
   178  	// int8
   179  	{
   180  		b.Reset()
   181  		var data int8 = 17
   182  		instr := &encInstr{encInt, 6, nil, 0}
   183  		state := newEncoderState(b)
   184  		instr.op(instr, state, reflect.ValueOf(data))
   185  		if !bytes.Equal(signedResult, b.Bytes()) {
   186  			t.Errorf("int8 enc instructions: expected % x got % x", signedResult, b.Bytes())
   187  		}
   188  	}
   189  
   190  	// uint8
   191  	{
   192  		b.Reset()
   193  		var data uint8 = 17
   194  		instr := &encInstr{encUint, 6, nil, 0}
   195  		state := newEncoderState(b)
   196  		instr.op(instr, state, reflect.ValueOf(data))
   197  		if !bytes.Equal(unsignedResult, b.Bytes()) {
   198  			t.Errorf("uint8 enc instructions: expected % x got % x", unsignedResult, b.Bytes())
   199  		}
   200  	}
   201  
   202  	// int16
   203  	{
   204  		b.Reset()
   205  		var data int16 = 17
   206  		instr := &encInstr{encInt, 6, nil, 0}
   207  		state := newEncoderState(b)
   208  		instr.op(instr, state, reflect.ValueOf(data))
   209  		if !bytes.Equal(signedResult, b.Bytes()) {
   210  			t.Errorf("int16 enc instructions: expected % x got % x", signedResult, b.Bytes())
   211  		}
   212  	}
   213  
   214  	// uint16
   215  	{
   216  		b.Reset()
   217  		var data uint16 = 17
   218  		instr := &encInstr{encUint, 6, nil, 0}
   219  		state := newEncoderState(b)
   220  		instr.op(instr, state, reflect.ValueOf(data))
   221  		if !bytes.Equal(unsignedResult, b.Bytes()) {
   222  			t.Errorf("uint16 enc instructions: expected % x got % x", unsignedResult, b.Bytes())
   223  		}
   224  	}
   225  
   226  	// int32
   227  	{
   228  		b.Reset()
   229  		var data int32 = 17
   230  		instr := &encInstr{encInt, 6, nil, 0}
   231  		state := newEncoderState(b)
   232  		instr.op(instr, state, reflect.ValueOf(data))
   233  		if !bytes.Equal(signedResult, b.Bytes()) {
   234  			t.Errorf("int32 enc instructions: expected % x got % x", signedResult, b.Bytes())
   235  		}
   236  	}
   237  
   238  	// uint32
   239  	{
   240  		b.Reset()
   241  		var data uint32 = 17
   242  		instr := &encInstr{encUint, 6, nil, 0}
   243  		state := newEncoderState(b)
   244  		instr.op(instr, state, reflect.ValueOf(data))
   245  		if !bytes.Equal(unsignedResult, b.Bytes()) {
   246  			t.Errorf("uint32 enc instructions: expected % x got % x", unsignedResult, b.Bytes())
   247  		}
   248  	}
   249  
   250  	// int64
   251  	{
   252  		b.Reset()
   253  		var data int64 = 17
   254  		instr := &encInstr{encInt, 6, nil, 0}
   255  		state := newEncoderState(b)
   256  		instr.op(instr, state, reflect.ValueOf(data))
   257  		if !bytes.Equal(signedResult, b.Bytes()) {
   258  			t.Errorf("int64 enc instructions: expected % x got % x", signedResult, b.Bytes())
   259  		}
   260  	}
   261  
   262  	// uint64
   263  	{
   264  		b.Reset()
   265  		var data uint64 = 17
   266  		instr := &encInstr{encUint, 6, nil, 0}
   267  		state := newEncoderState(b)
   268  		instr.op(instr, state, reflect.ValueOf(data))
   269  		if !bytes.Equal(unsignedResult, b.Bytes()) {
   270  			t.Errorf("uint64 enc instructions: expected % x got % x", unsignedResult, b.Bytes())
   271  		}
   272  	}
   273  
   274  	// float32
   275  	{
   276  		b.Reset()
   277  		var data float32 = 17
   278  		instr := &encInstr{encFloat, 6, nil, 0}
   279  		state := newEncoderState(b)
   280  		instr.op(instr, state, reflect.ValueOf(data))
   281  		if !bytes.Equal(floatResult, b.Bytes()) {
   282  			t.Errorf("float32 enc instructions: expected % x got % x", floatResult, b.Bytes())
   283  		}
   284  	}
   285  
   286  	// float64
   287  	{
   288  		b.Reset()
   289  		var data float64 = 17
   290  		instr := &encInstr{encFloat, 6, nil, 0}
   291  		state := newEncoderState(b)
   292  		instr.op(instr, state, reflect.ValueOf(data))
   293  		if !bytes.Equal(floatResult, b.Bytes()) {
   294  			t.Errorf("float64 enc instructions: expected % x got % x", floatResult, b.Bytes())
   295  		}
   296  	}
   297  
   298  	// bytes == []uint8
   299  	{
   300  		b.Reset()
   301  		data := []byte("hello")
   302  		instr := &encInstr{encUint8Array, 6, nil, 0}
   303  		state := newEncoderState(b)
   304  		instr.op(instr, state, reflect.ValueOf(data))
   305  		if !bytes.Equal(bytesResult, b.Bytes()) {
   306  			t.Errorf("bytes enc instructions: expected % x got % x", bytesResult, b.Bytes())
   307  		}
   308  	}
   309  
   310  	// string
   311  	{
   312  		b.Reset()
   313  		var data string = "hello"
   314  		instr := &encInstr{encString, 6, nil, 0}
   315  		state := newEncoderState(b)
   316  		instr.op(instr, state, reflect.ValueOf(data))
   317  		if !bytes.Equal(bytesResult, b.Bytes()) {
   318  			t.Errorf("string enc instructions: expected % x got % x", bytesResult, b.Bytes())
   319  		}
   320  	}
   321  }
   322  
   323  func execDec(instr *decInstr, state *decoderState, t *testing.T, value reflect.Value) {
   324  	defer testError(t)
   325  	v := int(state.decodeUint())
   326  	if v+state.fieldnum != 6 {
   327  		t.Fatalf("decoding field number %d, got %d", 6, v+state.fieldnum)
   328  	}
   329  	instr.op(instr, state, value.Elem())
   330  	state.fieldnum = 6
   331  }
   332  
   333  func newDecodeStateFromData(data []byte) *decoderState {
   334  	b := newDecBuffer(data)
   335  	state := newDecodeState(b)
   336  	state.fieldnum = -1
   337  	return state
   338  }
   339  
   340  // Test instruction execution for decoding.
   341  // Do not run the machine yet; instead do individual instructions crafted by hand.
   342  func TestScalarDecInstructions(t *testing.T) {
   343  	ovfl := errors.New("overflow")
   344  
   345  	// bool
   346  	{
   347  		var data bool
   348  		instr := &decInstr{decBool, 6, nil, ovfl}
   349  		state := newDecodeStateFromData(boolResult)
   350  		execDec(instr, state, t, reflect.ValueOf(&data))
   351  		if data != true {
   352  			t.Errorf("bool a = %v not true", data)
   353  		}
   354  	}
   355  	// int
   356  	{
   357  		var data int
   358  		instr := &decInstr{decOpTable[reflect.Int], 6, nil, ovfl}
   359  		state := newDecodeStateFromData(signedResult)
   360  		execDec(instr, state, t, reflect.ValueOf(&data))
   361  		if data != 17 {
   362  			t.Errorf("int a = %v not 17", data)
   363  		}
   364  	}
   365  
   366  	// uint
   367  	{
   368  		var data uint
   369  		instr := &decInstr{decOpTable[reflect.Uint], 6, nil, ovfl}
   370  		state := newDecodeStateFromData(unsignedResult)
   371  		execDec(instr, state, t, reflect.ValueOf(&data))
   372  		if data != 17 {
   373  			t.Errorf("uint a = %v not 17", data)
   374  		}
   375  	}
   376  
   377  	// int8
   378  	{
   379  		var data int8
   380  		instr := &decInstr{decInt8, 6, nil, ovfl}
   381  		state := newDecodeStateFromData(signedResult)
   382  		execDec(instr, state, t, reflect.ValueOf(&data))
   383  		if data != 17 {
   384  			t.Errorf("int8 a = %v not 17", data)
   385  		}
   386  	}
   387  
   388  	// uint8
   389  	{
   390  		var data uint8
   391  		instr := &decInstr{decUint8, 6, nil, ovfl}
   392  		state := newDecodeStateFromData(unsignedResult)
   393  		execDec(instr, state, t, reflect.ValueOf(&data))
   394  		if data != 17 {
   395  			t.Errorf("uint8 a = %v not 17", data)
   396  		}
   397  	}
   398  
   399  	// int16
   400  	{
   401  		var data int16
   402  		instr := &decInstr{decInt16, 6, nil, ovfl}
   403  		state := newDecodeStateFromData(signedResult)
   404  		execDec(instr, state, t, reflect.ValueOf(&data))
   405  		if data != 17 {
   406  			t.Errorf("int16 a = %v not 17", data)
   407  		}
   408  	}
   409  
   410  	// uint16
   411  	{
   412  		var data uint16
   413  		instr := &decInstr{decUint16, 6, nil, ovfl}
   414  		state := newDecodeStateFromData(unsignedResult)
   415  		execDec(instr, state, t, reflect.ValueOf(&data))
   416  		if data != 17 {
   417  			t.Errorf("uint16 a = %v not 17", data)
   418  		}
   419  	}
   420  
   421  	// int32
   422  	{
   423  		var data int32
   424  		instr := &decInstr{decInt32, 6, nil, ovfl}
   425  		state := newDecodeStateFromData(signedResult)
   426  		execDec(instr, state, t, reflect.ValueOf(&data))
   427  		if data != 17 {
   428  			t.Errorf("int32 a = %v not 17", data)
   429  		}
   430  	}
   431  
   432  	// uint32
   433  	{
   434  		var data uint32
   435  		instr := &decInstr{decUint32, 6, nil, ovfl}
   436  		state := newDecodeStateFromData(unsignedResult)
   437  		execDec(instr, state, t, reflect.ValueOf(&data))
   438  		if data != 17 {
   439  			t.Errorf("uint32 a = %v not 17", data)
   440  		}
   441  	}
   442  
   443  	// uintptr
   444  	{
   445  		var data uintptr
   446  		instr := &decInstr{decOpTable[reflect.Uintptr], 6, nil, ovfl}
   447  		state := newDecodeStateFromData(unsignedResult)
   448  		execDec(instr, state, t, reflect.ValueOf(&data))
   449  		if data != 17 {
   450  			t.Errorf("uintptr a = %v not 17", data)
   451  		}
   452  	}
   453  
   454  	// int64
   455  	{
   456  		var data int64
   457  		instr := &decInstr{decInt64, 6, nil, ovfl}
   458  		state := newDecodeStateFromData(signedResult)
   459  		execDec(instr, state, t, reflect.ValueOf(&data))
   460  		if data != 17 {
   461  			t.Errorf("int64 a = %v not 17", data)
   462  		}
   463  	}
   464  
   465  	// uint64
   466  	{
   467  		var data uint64
   468  		instr := &decInstr{decUint64, 6, nil, ovfl}
   469  		state := newDecodeStateFromData(unsignedResult)
   470  		execDec(instr, state, t, reflect.ValueOf(&data))
   471  		if data != 17 {
   472  			t.Errorf("uint64 a = %v not 17", data)
   473  		}
   474  	}
   475  
   476  	// float32
   477  	{
   478  		var data float32
   479  		instr := &decInstr{decFloat32, 6, nil, ovfl}
   480  		state := newDecodeStateFromData(floatResult)
   481  		execDec(instr, state, t, reflect.ValueOf(&data))
   482  		if data != 17 {
   483  			t.Errorf("float32 a = %v not 17", data)
   484  		}
   485  	}
   486  
   487  	// float64
   488  	{
   489  		var data float64
   490  		instr := &decInstr{decFloat64, 6, nil, ovfl}
   491  		state := newDecodeStateFromData(floatResult)
   492  		execDec(instr, state, t, reflect.ValueOf(&data))
   493  		if data != 17 {
   494  			t.Errorf("float64 a = %v not 17", data)
   495  		}
   496  	}
   497  
   498  	// complex64
   499  	{
   500  		var data complex64
   501  		instr := &decInstr{decOpTable[reflect.Complex64], 6, nil, ovfl}
   502  		state := newDecodeStateFromData(complexResult)
   503  		execDec(instr, state, t, reflect.ValueOf(&data))
   504  		if data != 17+19i {
   505  			t.Errorf("complex a = %v not 17+19i", data)
   506  		}
   507  	}
   508  
   509  	// complex128
   510  	{
   511  		var data complex128
   512  		instr := &decInstr{decOpTable[reflect.Complex128], 6, nil, ovfl}
   513  		state := newDecodeStateFromData(complexResult)
   514  		execDec(instr, state, t, reflect.ValueOf(&data))
   515  		if data != 17+19i {
   516  			t.Errorf("complex a = %v not 17+19i", data)
   517  		}
   518  	}
   519  
   520  	// bytes == []uint8
   521  	{
   522  		var data []byte
   523  		instr := &decInstr{decUint8Slice, 6, nil, ovfl}
   524  		state := newDecodeStateFromData(bytesResult)
   525  		execDec(instr, state, t, reflect.ValueOf(&data))
   526  		if string(data) != "hello" {
   527  			t.Errorf(`bytes a = %q not "hello"`, string(data))
   528  		}
   529  	}
   530  
   531  	// string
   532  	{
   533  		var data string
   534  		instr := &decInstr{decString, 6, nil, ovfl}
   535  		state := newDecodeStateFromData(bytesResult)
   536  		execDec(instr, state, t, reflect.ValueOf(&data))
   537  		if data != "hello" {
   538  			t.Errorf(`bytes a = %q not "hello"`, data)
   539  		}
   540  	}
   541  }
   542  
   543  func TestEndToEnd(t *testing.T) {
   544  	type T2 struct {
   545  		T string
   546  	}
   547  	type T3 struct {
   548  		X float64
   549  		Z *int
   550  	}
   551  	type T1 struct {
   552  		A, B, C  int
   553  		M        map[string]*float64
   554  		M2       map[int]T3
   555  		Mstring  map[string]string
   556  		Mintptr  map[int]*int
   557  		Mcomp    map[complex128]complex128
   558  		Marr     map[[2]string][2]*float64
   559  		EmptyMap map[string]int // to check that we receive a non-nil map.
   560  		N        *[3]float64
   561  		Strs     *[2]string
   562  		Int64s   *[]int64
   563  		RI       complex64
   564  		S        string
   565  		Y        []byte
   566  		T        *T2
   567  	}
   568  	pi := 3.14159
   569  	e := 2.71828
   570  	two := 2.0
   571  	meaning := 42
   572  	fingers := 5
   573  	s1 := "string1"
   574  	s2 := "string2"
   575  	var comp1 complex128 = complex(1.0, 1.0)
   576  	var comp2 complex128 = complex(1.0, 1.0)
   577  	var arr1 [2]string
   578  	arr1[0] = s1
   579  	arr1[1] = s2
   580  	var arr2 [2]string
   581  	arr2[0] = s2
   582  	arr2[1] = s1
   583  	var floatArr1 [2]*float64
   584  	floatArr1[0] = &pi
   585  	floatArr1[1] = &e
   586  	var floatArr2 [2]*float64
   587  	floatArr2[0] = &e
   588  	floatArr2[1] = &two
   589  	t1 := &T1{
   590  		A:        17,
   591  		B:        18,
   592  		C:        -5,
   593  		M:        map[string]*float64{"pi": &pi, "e": &e},
   594  		M2:       map[int]T3{4: {X: pi, Z: &meaning}, 10: {X: e, Z: &fingers}},
   595  		Mstring:  map[string]string{"pi": "3.14", "e": "2.71"},
   596  		Mintptr:  map[int]*int{meaning: &fingers, fingers: &meaning},
   597  		Mcomp:    map[complex128]complex128{comp1: comp2, comp2: comp1},
   598  		Marr:     map[[2]string][2]*float64{arr1: floatArr1, arr2: floatArr2},
   599  		EmptyMap: make(map[string]int),
   600  		N:        &[3]float64{1.5, 2.5, 3.5},
   601  		Strs:     &[2]string{s1, s2},
   602  		Int64s:   &[]int64{77, 89, 123412342134},
   603  		RI:       17 - 23i,
   604  		S:        "Now is the time",
   605  		Y:        []byte("hello, sailor"),
   606  		T:        &T2{"this is T2"},
   607  	}
   608  	b := new(bytes.Buffer)
   609  	err := NewEncoder(b).Encode(t1)
   610  	if err != nil {
   611  		t.Error("encode:", err)
   612  	}
   613  	var _t1 T1
   614  	err = NewDecoder(b).Decode(&_t1)
   615  	if err != nil {
   616  		t.Fatal("decode:", err)
   617  	}
   618  	if !reflect.DeepEqual(t1, &_t1) {
   619  		t.Errorf("encode expected %v got %v", *t1, _t1)
   620  	}
   621  	// Be absolutely sure the received map is non-nil.
   622  	if t1.EmptyMap == nil {
   623  		t.Errorf("nil map sent")
   624  	}
   625  	if _t1.EmptyMap == nil {
   626  		t.Errorf("nil map received")
   627  	}
   628  }
   629  
   630  func TestOverflow(t *testing.T) {
   631  	type inputT struct {
   632  		Maxi int64
   633  		Mini int64
   634  		Maxu uint64
   635  		Maxf float64
   636  		Minf float64
   637  		Maxc complex128
   638  		Minc complex128
   639  	}
   640  	var it inputT
   641  	var err error
   642  	b := new(bytes.Buffer)
   643  	enc := NewEncoder(b)
   644  	dec := NewDecoder(b)
   645  
   646  	// int8
   647  	b.Reset()
   648  	it = inputT{
   649  		Maxi: math.MaxInt8 + 1,
   650  	}
   651  	type outi8 struct {
   652  		Maxi int8
   653  		Mini int8
   654  	}
   655  	var o1 outi8
   656  	enc.Encode(it)
   657  	err = dec.Decode(&o1)
   658  	if err == nil || err.Error() != `value for "Maxi" out of range` {
   659  		t.Error("wrong overflow error for int8:", err)
   660  	}
   661  	it = inputT{
   662  		Mini: math.MinInt8 - 1,
   663  	}
   664  	b.Reset()
   665  	enc.Encode(it)
   666  	err = dec.Decode(&o1)
   667  	if err == nil || err.Error() != `value for "Mini" out of range` {
   668  		t.Error("wrong underflow error for int8:", err)
   669  	}
   670  
   671  	// int16
   672  	b.Reset()
   673  	it = inputT{
   674  		Maxi: math.MaxInt16 + 1,
   675  	}
   676  	type outi16 struct {
   677  		Maxi int16
   678  		Mini int16
   679  	}
   680  	var o2 outi16
   681  	enc.Encode(it)
   682  	err = dec.Decode(&o2)
   683  	if err == nil || err.Error() != `value for "Maxi" out of range` {
   684  		t.Error("wrong overflow error for int16:", err)
   685  	}
   686  	it = inputT{
   687  		Mini: math.MinInt16 - 1,
   688  	}
   689  	b.Reset()
   690  	enc.Encode(it)
   691  	err = dec.Decode(&o2)
   692  	if err == nil || err.Error() != `value for "Mini" out of range` {
   693  		t.Error("wrong underflow error for int16:", err)
   694  	}
   695  
   696  	// int32
   697  	b.Reset()
   698  	it = inputT{
   699  		Maxi: math.MaxInt32 + 1,
   700  	}
   701  	type outi32 struct {
   702  		Maxi int32
   703  		Mini int32
   704  	}
   705  	var o3 outi32
   706  	enc.Encode(it)
   707  	err = dec.Decode(&o3)
   708  	if err == nil || err.Error() != `value for "Maxi" out of range` {
   709  		t.Error("wrong overflow error for int32:", err)
   710  	}
   711  	it = inputT{
   712  		Mini: math.MinInt32 - 1,
   713  	}
   714  	b.Reset()
   715  	enc.Encode(it)
   716  	err = dec.Decode(&o3)
   717  	if err == nil || err.Error() != `value for "Mini" out of range` {
   718  		t.Error("wrong underflow error for int32:", err)
   719  	}
   720  
   721  	// uint8
   722  	b.Reset()
   723  	it = inputT{
   724  		Maxu: math.MaxUint8 + 1,
   725  	}
   726  	type outu8 struct {
   727  		Maxu uint8
   728  	}
   729  	var o4 outu8
   730  	enc.Encode(it)
   731  	err = dec.Decode(&o4)
   732  	if err == nil || err.Error() != `value for "Maxu" out of range` {
   733  		t.Error("wrong overflow error for uint8:", err)
   734  	}
   735  
   736  	// uint16
   737  	b.Reset()
   738  	it = inputT{
   739  		Maxu: math.MaxUint16 + 1,
   740  	}
   741  	type outu16 struct {
   742  		Maxu uint16
   743  	}
   744  	var o5 outu16
   745  	enc.Encode(it)
   746  	err = dec.Decode(&o5)
   747  	if err == nil || err.Error() != `value for "Maxu" out of range` {
   748  		t.Error("wrong overflow error for uint16:", err)
   749  	}
   750  
   751  	// uint32
   752  	b.Reset()
   753  	it = inputT{
   754  		Maxu: math.MaxUint32 + 1,
   755  	}
   756  	type outu32 struct {
   757  		Maxu uint32
   758  	}
   759  	var o6 outu32
   760  	enc.Encode(it)
   761  	err = dec.Decode(&o6)
   762  	if err == nil || err.Error() != `value for "Maxu" out of range` {
   763  		t.Error("wrong overflow error for uint32:", err)
   764  	}
   765  
   766  	// float32
   767  	b.Reset()
   768  	it = inputT{
   769  		Maxf: math.MaxFloat32 * 2,
   770  	}
   771  	type outf32 struct {
   772  		Maxf float32
   773  		Minf float32
   774  	}
   775  	var o7 outf32
   776  	enc.Encode(it)
   777  	err = dec.Decode(&o7)
   778  	if err == nil || err.Error() != `value for "Maxf" out of range` {
   779  		t.Error("wrong overflow error for float32:", err)
   780  	}
   781  
   782  	// complex64
   783  	b.Reset()
   784  	it = inputT{
   785  		Maxc: complex(math.MaxFloat32*2, math.MaxFloat32*2),
   786  	}
   787  	type outc64 struct {
   788  		Maxc complex64
   789  		Minc complex64
   790  	}
   791  	var o8 outc64
   792  	enc.Encode(it)
   793  	err = dec.Decode(&o8)
   794  	if err == nil || err.Error() != `value for "Maxc" out of range` {
   795  		t.Error("wrong overflow error for complex64:", err)
   796  	}
   797  }
   798  
   799  func TestNesting(t *testing.T) {
   800  	type RT struct {
   801  		A    string
   802  		Next *RT
   803  	}
   804  	rt := new(RT)
   805  	rt.A = "level1"
   806  	rt.Next = new(RT)
   807  	rt.Next.A = "level2"
   808  	b := new(bytes.Buffer)
   809  	NewEncoder(b).Encode(rt)
   810  	var drt RT
   811  	dec := NewDecoder(b)
   812  	err := dec.Decode(&drt)
   813  	if err != nil {
   814  		t.Fatal("decoder error:", err)
   815  	}
   816  	if drt.A != rt.A {
   817  		t.Errorf("nesting: encode expected %v got %v", *rt, drt)
   818  	}
   819  	if drt.Next == nil {
   820  		t.Errorf("nesting: recursion failed")
   821  	}
   822  	if drt.Next.A != rt.Next.A {
   823  		t.Errorf("nesting: encode expected %v got %v", *rt.Next, *drt.Next)
   824  	}
   825  }
   826  
   827  // These three structures have the same data with different indirections
   828  type T0 struct {
   829  	A int
   830  	B int
   831  	C int
   832  	D int
   833  }
   834  type T1 struct {
   835  	A int
   836  	B *int
   837  	C **int
   838  	D ***int
   839  }
   840  type T2 struct {
   841  	A ***int
   842  	B **int
   843  	C *int
   844  	D int
   845  }
   846  
   847  func TestAutoIndirection(t *testing.T) {
   848  	// First transfer t1 into t0
   849  	var t1 T1
   850  	t1.A = 17
   851  	t1.B = new(int)
   852  	*t1.B = 177
   853  	t1.C = new(*int)
   854  	*t1.C = new(int)
   855  	**t1.C = 1777
   856  	t1.D = new(**int)
   857  	*t1.D = new(*int)
   858  	**t1.D = new(int)
   859  	***t1.D = 17777
   860  	b := new(bytes.Buffer)
   861  	enc := NewEncoder(b)
   862  	enc.Encode(t1)
   863  	dec := NewDecoder(b)
   864  	var t0 T0
   865  	dec.Decode(&t0)
   866  	if t0.A != 17 || t0.B != 177 || t0.C != 1777 || t0.D != 17777 {
   867  		t.Errorf("t1->t0: expected {17 177 1777 17777}; got %v", t0)
   868  	}
   869  
   870  	// Now transfer t2 into t0
   871  	var t2 T2
   872  	t2.D = 17777
   873  	t2.C = new(int)
   874  	*t2.C = 1777
   875  	t2.B = new(*int)
   876  	*t2.B = new(int)
   877  	**t2.B = 177
   878  	t2.A = new(**int)
   879  	*t2.A = new(*int)
   880  	**t2.A = new(int)
   881  	***t2.A = 17
   882  	b.Reset()
   883  	enc.Encode(t2)
   884  	t0 = T0{}
   885  	dec.Decode(&t0)
   886  	if t0.A != 17 || t0.B != 177 || t0.C != 1777 || t0.D != 17777 {
   887  		t.Errorf("t2->t0 expected {17 177 1777 17777}; got %v", t0)
   888  	}
   889  
   890  	// Now transfer t0 into t1
   891  	t0 = T0{17, 177, 1777, 17777}
   892  	b.Reset()
   893  	enc.Encode(t0)
   894  	t1 = T1{}
   895  	dec.Decode(&t1)
   896  	if t1.A != 17 || *t1.B != 177 || **t1.C != 1777 || ***t1.D != 17777 {
   897  		t.Errorf("t0->t1 expected {17 177 1777 17777}; got {%d %d %d %d}", t1.A, *t1.B, **t1.C, ***t1.D)
   898  	}
   899  
   900  	// Now transfer t0 into t2
   901  	b.Reset()
   902  	enc.Encode(t0)
   903  	t2 = T2{}
   904  	dec.Decode(&t2)
   905  	if ***t2.A != 17 || **t2.B != 177 || *t2.C != 1777 || t2.D != 17777 {
   906  		t.Errorf("t0->t2 expected {17 177 1777 17777}; got {%d %d %d %d}", ***t2.A, **t2.B, *t2.C, t2.D)
   907  	}
   908  
   909  	// Now do t2 again but without pre-allocated pointers.
   910  	b.Reset()
   911  	enc.Encode(t0)
   912  	***t2.A = 0
   913  	**t2.B = 0
   914  	*t2.C = 0
   915  	t2.D = 0
   916  	dec.Decode(&t2)
   917  	if ***t2.A != 17 || **t2.B != 177 || *t2.C != 1777 || t2.D != 17777 {
   918  		t.Errorf("t0->t2 expected {17 177 1777 17777}; got {%d %d %d %d}", ***t2.A, **t2.B, *t2.C, t2.D)
   919  	}
   920  }
   921  
   922  type RT0 struct {
   923  	A int
   924  	B string
   925  	C float64
   926  }
   927  type RT1 struct {
   928  	C      float64
   929  	B      string
   930  	A      int
   931  	NotSet string
   932  }
   933  
   934  func TestReorderedFields(t *testing.T) {
   935  	var rt0 RT0
   936  	rt0.A = 17
   937  	rt0.B = "hello"
   938  	rt0.C = 3.14159
   939  	b := new(bytes.Buffer)
   940  	NewEncoder(b).Encode(rt0)
   941  	dec := NewDecoder(b)
   942  	var rt1 RT1
   943  	// Wire type is RT0, local type is RT1.
   944  	err := dec.Decode(&rt1)
   945  	if err != nil {
   946  		t.Fatal("decode error:", err)
   947  	}
   948  	if rt0.A != rt1.A || rt0.B != rt1.B || rt0.C != rt1.C {
   949  		t.Errorf("rt1->rt0: expected %v; got %v", rt0, rt1)
   950  	}
   951  }
   952  
   953  // Like an RT0 but with fields we'll ignore on the decode side.
   954  type IT0 struct {
   955  	A        int64
   956  	B        string
   957  	Ignore_d []int
   958  	Ignore_e [3]float64
   959  	Ignore_f bool
   960  	Ignore_g string
   961  	Ignore_h []byte
   962  	Ignore_i *RT1
   963  	Ignore_m map[string]int
   964  	C        float64
   965  }
   966  
   967  func TestIgnoredFields(t *testing.T) {
   968  	var it0 IT0
   969  	it0.A = 17
   970  	it0.B = "hello"
   971  	it0.C = 3.14159
   972  	it0.Ignore_d = []int{1, 2, 3}
   973  	it0.Ignore_e[0] = 1.0
   974  	it0.Ignore_e[1] = 2.0
   975  	it0.Ignore_e[2] = 3.0
   976  	it0.Ignore_f = true
   977  	it0.Ignore_g = "pay no attention"
   978  	it0.Ignore_h = []byte("to the curtain")
   979  	it0.Ignore_i = &RT1{3.1, "hi", 7, "hello"}
   980  	it0.Ignore_m = map[string]int{"one": 1, "two": 2}
   981  
   982  	b := new(bytes.Buffer)
   983  	NewEncoder(b).Encode(it0)
   984  	dec := NewDecoder(b)
   985  	var rt1 RT1
   986  	// Wire type is IT0, local type is RT1.
   987  	err := dec.Decode(&rt1)
   988  	if err != nil {
   989  		t.Error("error: ", err)
   990  	}
   991  	if int(it0.A) != rt1.A || it0.B != rt1.B || it0.C != rt1.C {
   992  		t.Errorf("rt0->rt1: expected %v; got %v", it0, rt1)
   993  	}
   994  }
   995  
   996  func TestBadRecursiveType(t *testing.T) {
   997  	type Rec ***Rec
   998  	var rec Rec
   999  	b := new(bytes.Buffer)
  1000  	err := NewEncoder(b).Encode(&rec)
  1001  	if err == nil {
  1002  		t.Error("expected error; got none")
  1003  	} else if !strings.Contains(err.Error(), "recursive") {
  1004  		t.Error("expected recursive type error; got", err)
  1005  	}
  1006  	// Can't test decode easily because we can't encode one, so we can't pass one to a Decoder.
  1007  }
  1008  
  1009  type Indirect struct {
  1010  	A ***[3]int
  1011  	S ***[]int
  1012  	M ****map[string]int
  1013  }
  1014  
  1015  type Direct struct {
  1016  	A [3]int
  1017  	S []int
  1018  	M map[string]int
  1019  }
  1020  
  1021  func TestIndirectSliceMapArray(t *testing.T) {
  1022  	// Marshal indirect, unmarshal to direct.
  1023  	i := new(Indirect)
  1024  	i.A = new(**[3]int)
  1025  	*i.A = new(*[3]int)
  1026  	**i.A = new([3]int)
  1027  	***i.A = [3]int{1, 2, 3}
  1028  	i.S = new(**[]int)
  1029  	*i.S = new(*[]int)
  1030  	**i.S = new([]int)
  1031  	***i.S = []int{4, 5, 6}
  1032  	i.M = new(***map[string]int)
  1033  	*i.M = new(**map[string]int)
  1034  	**i.M = new(*map[string]int)
  1035  	***i.M = new(map[string]int)
  1036  	****i.M = map[string]int{"one": 1, "two": 2, "three": 3}
  1037  	b := new(bytes.Buffer)
  1038  	NewEncoder(b).Encode(i)
  1039  	dec := NewDecoder(b)
  1040  	var d Direct
  1041  	err := dec.Decode(&d)
  1042  	if err != nil {
  1043  		t.Error("error: ", err)
  1044  	}
  1045  	if len(d.A) != 3 || d.A[0] != 1 || d.A[1] != 2 || d.A[2] != 3 {
  1046  		t.Errorf("indirect to direct: d.A is %v not %v", d.A, ***i.A)
  1047  	}
  1048  	if len(d.S) != 3 || d.S[0] != 4 || d.S[1] != 5 || d.S[2] != 6 {
  1049  		t.Errorf("indirect to direct: d.S is %v not %v", d.S, ***i.S)
  1050  	}
  1051  	if len(d.M) != 3 || d.M["one"] != 1 || d.M["two"] != 2 || d.M["three"] != 3 {
  1052  		t.Errorf("indirect to direct: d.M is %v not %v", d.M, ***i.M)
  1053  	}
  1054  	// Marshal direct, unmarshal to indirect.
  1055  	d.A = [3]int{11, 22, 33}
  1056  	d.S = []int{44, 55, 66}
  1057  	d.M = map[string]int{"four": 4, "five": 5, "six": 6}
  1058  	i = new(Indirect)
  1059  	b.Reset()
  1060  	NewEncoder(b).Encode(d)
  1061  	dec = NewDecoder(b)
  1062  	err = dec.Decode(&i)
  1063  	if err != nil {
  1064  		t.Fatal("error: ", err)
  1065  	}
  1066  	if len(***i.A) != 3 || (***i.A)[0] != 11 || (***i.A)[1] != 22 || (***i.A)[2] != 33 {
  1067  		t.Errorf("direct to indirect: ***i.A is %v not %v", ***i.A, d.A)
  1068  	}
  1069  	if len(***i.S) != 3 || (***i.S)[0] != 44 || (***i.S)[1] != 55 || (***i.S)[2] != 66 {
  1070  		t.Errorf("direct to indirect: ***i.S is %v not %v", ***i.S, ***i.S)
  1071  	}
  1072  	if len(****i.M) != 3 || (****i.M)["four"] != 4 || (****i.M)["five"] != 5 || (****i.M)["six"] != 6 {
  1073  		t.Errorf("direct to indirect: ****i.M is %v not %v", ****i.M, d.M)
  1074  	}
  1075  }
  1076  
  1077  // An interface with several implementations
  1078  type Squarer interface {
  1079  	Square() int
  1080  }
  1081  
  1082  type Int int
  1083  
  1084  func (i Int) Square() int {
  1085  	return int(i * i)
  1086  }
  1087  
  1088  type Float float64
  1089  
  1090  func (f Float) Square() int {
  1091  	return int(f * f)
  1092  }
  1093  
  1094  type Vector []int
  1095  
  1096  func (v Vector) Square() int {
  1097  	sum := 0
  1098  	for _, x := range v {
  1099  		sum += x * x
  1100  	}
  1101  	return sum
  1102  }
  1103  
  1104  type Point struct {
  1105  	X, Y int
  1106  }
  1107  
  1108  func (p Point) Square() int {
  1109  	return p.X*p.X + p.Y*p.Y
  1110  }
  1111  
  1112  // A struct with interfaces in it.
  1113  type InterfaceItem struct {
  1114  	I             int
  1115  	Sq1, Sq2, Sq3 Squarer
  1116  	F             float64
  1117  	Sq            []Squarer
  1118  }
  1119  
  1120  // The same struct without interfaces
  1121  type NoInterfaceItem struct {
  1122  	I int
  1123  	F float64
  1124  }
  1125  
  1126  func TestInterface(t *testing.T) {
  1127  	iVal := Int(3)
  1128  	fVal := Float(5)
  1129  	// Sending a Vector will require that the receiver define a type in the middle of
  1130  	// receiving the value for item2.
  1131  	vVal := Vector{1, 2, 3}
  1132  	b := new(bytes.Buffer)
  1133  	item1 := &InterfaceItem{1, iVal, fVal, vVal, 11.5, []Squarer{iVal, fVal, nil, vVal}}
  1134  	// Register the types.
  1135  	Register(Int(0))
  1136  	Register(Float(0))
  1137  	Register(Vector{})
  1138  	err := NewEncoder(b).Encode(item1)
  1139  	if err != nil {
  1140  		t.Error("expected no encode error; got", err)
  1141  	}
  1142  
  1143  	item2 := InterfaceItem{}
  1144  	err = NewDecoder(b).Decode(&item2)
  1145  	if err != nil {
  1146  		t.Fatal("decode:", err)
  1147  	}
  1148  	if item2.I != item1.I {
  1149  		t.Error("normal int did not decode correctly")
  1150  	}
  1151  	if item2.Sq1 == nil || item2.Sq1.Square() != iVal.Square() {
  1152  		t.Error("Int did not decode correctly")
  1153  	}
  1154  	if item2.Sq2 == nil || item2.Sq2.Square() != fVal.Square() {
  1155  		t.Error("Float did not decode correctly")
  1156  	}
  1157  	if item2.Sq3 == nil || item2.Sq3.Square() != vVal.Square() {
  1158  		t.Error("Vector did not decode correctly")
  1159  	}
  1160  	if item2.F != item1.F {
  1161  		t.Error("normal float did not decode correctly")
  1162  	}
  1163  	// Now check that we received a slice of Squarers correctly, including a nil element
  1164  	if len(item1.Sq) != len(item2.Sq) {
  1165  		t.Fatalf("[]Squarer length wrong: got %d; expected %d", len(item2.Sq), len(item1.Sq))
  1166  	}
  1167  	for i, v1 := range item1.Sq {
  1168  		v2 := item2.Sq[i]
  1169  		if v1 == nil || v2 == nil {
  1170  			if v1 != nil || v2 != nil {
  1171  				t.Errorf("item %d inconsistent nils", i)
  1172  			}
  1173  		} else if v1.Square() != v2.Square() {
  1174  			t.Errorf("item %d inconsistent values: %v %v", i, v1, v2)
  1175  		}
  1176  	}
  1177  }
  1178  
  1179  // A struct with all basic types, stored in interfaces.
  1180  type BasicInterfaceItem struct {
  1181  	Int, Int8, Int16, Int32, Int64      any
  1182  	Uint, Uint8, Uint16, Uint32, Uint64 any
  1183  	Float32, Float64                    any
  1184  	Complex64, Complex128               any
  1185  	Bool                                any
  1186  	String                              any
  1187  	Bytes                               any
  1188  }
  1189  
  1190  func TestInterfaceBasic(t *testing.T) {
  1191  	b := new(bytes.Buffer)
  1192  	item1 := &BasicInterfaceItem{
  1193  		int(1), int8(1), int16(1), int32(1), int64(1),
  1194  		uint(1), uint8(1), uint16(1), uint32(1), uint64(1),
  1195  		float32(1), 1.0,
  1196  		complex64(1i), complex128(1i),
  1197  		true,
  1198  		"hello",
  1199  		[]byte("sailor"),
  1200  	}
  1201  	err := NewEncoder(b).Encode(item1)
  1202  	if err != nil {
  1203  		t.Error("expected no encode error; got", err)
  1204  	}
  1205  
  1206  	item2 := &BasicInterfaceItem{}
  1207  	err = NewDecoder(b).Decode(&item2)
  1208  	if err != nil {
  1209  		t.Fatal("decode:", err)
  1210  	}
  1211  	if !reflect.DeepEqual(item1, item2) {
  1212  		t.Errorf("encode expected %v got %v", item1, item2)
  1213  	}
  1214  	// Hand check a couple for correct types.
  1215  	if v, ok := item2.Bool.(bool); !ok || !v {
  1216  		t.Error("boolean should be true")
  1217  	}
  1218  	if v, ok := item2.String.(string); !ok || v != item1.String.(string) {
  1219  		t.Errorf("string should be %v is %v", item1.String, v)
  1220  	}
  1221  }
  1222  
  1223  type String string
  1224  
  1225  type PtrInterfaceItem struct {
  1226  	Str1 any // basic
  1227  	Str2 any // derived
  1228  }
  1229  
  1230  // We'll send pointers; should receive values.
  1231  // Also check that we can register T but send *T.
  1232  func TestInterfacePointer(t *testing.T) {
  1233  	b := new(bytes.Buffer)
  1234  	str1 := "howdy"
  1235  	str2 := String("kiddo")
  1236  	item1 := &PtrInterfaceItem{
  1237  		&str1,
  1238  		&str2,
  1239  	}
  1240  	// Register the type.
  1241  	Register(str2)
  1242  	err := NewEncoder(b).Encode(item1)
  1243  	if err != nil {
  1244  		t.Error("expected no encode error; got", err)
  1245  	}
  1246  
  1247  	item2 := &PtrInterfaceItem{}
  1248  	err = NewDecoder(b).Decode(&item2)
  1249  	if err != nil {
  1250  		t.Fatal("decode:", err)
  1251  	}
  1252  	// Hand test for correct types and values.
  1253  	if v, ok := item2.Str1.(string); !ok || v != str1 {
  1254  		t.Errorf("basic string failed: %q should be %q", v, str1)
  1255  	}
  1256  	if v, ok := item2.Str2.(String); !ok || v != str2 {
  1257  		t.Errorf("derived type String failed: %q should be %q", v, str2)
  1258  	}
  1259  }
  1260  
  1261  func TestIgnoreInterface(t *testing.T) {
  1262  	iVal := Int(3)
  1263  	fVal := Float(5)
  1264  	// Sending a Point will require that the receiver define a type in the middle of
  1265  	// receiving the value for item2.
  1266  	pVal := Point{2, 3}
  1267  	b := new(bytes.Buffer)
  1268  	item1 := &InterfaceItem{1, iVal, fVal, pVal, 11.5, nil}
  1269  	// Register the types.
  1270  	Register(Int(0))
  1271  	Register(Float(0))
  1272  	Register(Point{})
  1273  	err := NewEncoder(b).Encode(item1)
  1274  	if err != nil {
  1275  		t.Error("expected no encode error; got", err)
  1276  	}
  1277  
  1278  	item2 := NoInterfaceItem{}
  1279  	err = NewDecoder(b).Decode(&item2)
  1280  	if err != nil {
  1281  		t.Fatal("decode:", err)
  1282  	}
  1283  	if item2.I != item1.I {
  1284  		t.Error("normal int did not decode correctly")
  1285  	}
  1286  	if item2.F != item1.F {
  1287  		t.Error("normal float did not decode correctly")
  1288  	}
  1289  }
  1290  
  1291  type U struct {
  1292  	A int
  1293  	B string
  1294  	c float64
  1295  	D uint
  1296  }
  1297  
  1298  func TestUnexportedFields(t *testing.T) {
  1299  	var u0 U
  1300  	u0.A = 17
  1301  	u0.B = "hello"
  1302  	u0.c = 3.14159
  1303  	u0.D = 23
  1304  	b := new(bytes.Buffer)
  1305  	NewEncoder(b).Encode(u0)
  1306  	dec := NewDecoder(b)
  1307  	var u1 U
  1308  	u1.c = 1234.
  1309  	err := dec.Decode(&u1)
  1310  	if err != nil {
  1311  		t.Fatal("decode error:", err)
  1312  	}
  1313  	if u0.A != u1.A || u0.B != u1.B || u0.D != u1.D {
  1314  		t.Errorf("u1->u0: expected %v; got %v", u0, u1)
  1315  	}
  1316  	if u1.c != 1234. {
  1317  		t.Error("u1.c modified")
  1318  	}
  1319  }
  1320  
  1321  var singletons = []any{
  1322  	true,
  1323  	7,
  1324  	uint(10),
  1325  	3.2,
  1326  	"hello",
  1327  	[3]int{11, 22, 33},
  1328  	[]float32{0.5, 0.25, 0.125},
  1329  	map[string]int{"one": 1, "two": 2},
  1330  }
  1331  
  1332  func TestDebugSingleton(t *testing.T) {
  1333  	if debugFunc == nil {
  1334  		return
  1335  	}
  1336  	b := new(bytes.Buffer)
  1337  	// Accumulate a number of values and print them out all at once.
  1338  	for _, x := range singletons {
  1339  		err := NewEncoder(b).Encode(x)
  1340  		if err != nil {
  1341  			t.Fatal("encode:", err)
  1342  		}
  1343  	}
  1344  	debugFunc(b)
  1345  }
  1346  
  1347  // A type that won't be defined in the gob until we send it in an interface value.
  1348  type OnTheFly struct {
  1349  	A int
  1350  }
  1351  
  1352  type DT struct {
  1353  	//	X OnTheFly
  1354  	A     int
  1355  	B     string
  1356  	C     float64
  1357  	I     any
  1358  	J     any
  1359  	I_nil any
  1360  	M     map[string]int
  1361  	T     [3]int
  1362  	S     []string
  1363  }
  1364  
  1365  func newDT() DT {
  1366  	var dt DT
  1367  	dt.A = 17
  1368  	dt.B = "hello"
  1369  	dt.C = 3.14159
  1370  	dt.I = 271828
  1371  	dt.J = OnTheFly{3}
  1372  	dt.I_nil = nil
  1373  	dt.M = map[string]int{"one": 1, "two": 2}
  1374  	dt.T = [3]int{11, 22, 33}
  1375  	dt.S = []string{"hi", "joe"}
  1376  	return dt
  1377  }
  1378  
  1379  func TestDebugStruct(t *testing.T) {
  1380  	if debugFunc == nil {
  1381  		return
  1382  	}
  1383  	Register(OnTheFly{})
  1384  	dt := newDT()
  1385  	b := new(bytes.Buffer)
  1386  	err := NewEncoder(b).Encode(dt)
  1387  	if err != nil {
  1388  		t.Fatal("encode:", err)
  1389  	}
  1390  	debugBuffer := bytes.NewBuffer(b.Bytes())
  1391  	dt2 := &DT{}
  1392  	err = NewDecoder(b).Decode(&dt2)
  1393  	if err != nil {
  1394  		t.Error("decode:", err)
  1395  	}
  1396  	debugFunc(debugBuffer)
  1397  }
  1398  
  1399  func encFuzzDec(rng *rand.Rand, in any) error {
  1400  	buf := new(bytes.Buffer)
  1401  	enc := NewEncoder(buf)
  1402  	if err := enc.Encode(&in); err != nil {
  1403  		return err
  1404  	}
  1405  
  1406  	b := buf.Bytes()
  1407  	for i, bi := range b {
  1408  		if rng.Intn(10) < 3 {
  1409  			b[i] = bi + uint8(rng.Intn(256))
  1410  		}
  1411  	}
  1412  
  1413  	dec := NewDecoder(buf)
  1414  	var e any
  1415  	if err := dec.Decode(&e); err != nil {
  1416  		return err
  1417  	}
  1418  	return nil
  1419  }
  1420  
  1421  // This does some "fuzz testing" by attempting to decode a sequence of random bytes.
  1422  func TestFuzz(t *testing.T) {
  1423  	if !*doFuzzTests {
  1424  		t.Skipf("disabled; run with -gob.fuzz to enable")
  1425  	}
  1426  
  1427  	// all possible inputs
  1428  	input := []any{
  1429  		new(int),
  1430  		new(float32),
  1431  		new(float64),
  1432  		new(complex128),
  1433  		&ByteStruct{255},
  1434  		&ArrayStruct{},
  1435  		&StringStruct{"hello"},
  1436  		&GobTest1{0, &StringStruct{"hello"}},
  1437  	}
  1438  	testFuzz(t, time.Now().UnixNano(), 100, input...)
  1439  }
  1440  
  1441  func TestFuzzRegressions(t *testing.T) {
  1442  	if !*doFuzzTests {
  1443  		t.Skipf("disabled; run with -gob.fuzz to enable")
  1444  	}
  1445  
  1446  	// An instance triggering a type name of length ~102 GB.
  1447  	testFuzz(t, 1328492090837718000, 100, new(float32))
  1448  	// An instance triggering a type name of 1.6 GB.
  1449  	// Note: can take several minutes to run.
  1450  	testFuzz(t, 1330522872628565000, 100, new(int))
  1451  }
  1452  
  1453  func testFuzz(t *testing.T, seed int64, n int, input ...any) {
  1454  	for _, e := range input {
  1455  		t.Logf("seed=%d n=%d e=%T", seed, n, e)
  1456  		rng := rand.New(rand.NewSource(seed))
  1457  		for i := 0; i < n; i++ {
  1458  			encFuzzDec(rng, e)
  1459  		}
  1460  	}
  1461  }
  1462  
  1463  // TestFuzzOneByte tries to decode corrupted input sequences
  1464  // and checks that no panic occurs.
  1465  func TestFuzzOneByte(t *testing.T) {
  1466  	if !*doFuzzTests {
  1467  		t.Skipf("disabled; run with -gob.fuzz to enable")
  1468  	}
  1469  
  1470  	buf := new(bytes.Buffer)
  1471  	Register(OnTheFly{})
  1472  	dt := newDT()
  1473  	if err := NewEncoder(buf).Encode(dt); err != nil {
  1474  		t.Fatal(err)
  1475  	}
  1476  	s := buf.String()
  1477  
  1478  	indices := make([]int, 0, len(s))
  1479  	for i := 0; i < len(s); i++ {
  1480  		switch i {
  1481  		case 14, 167, 231, 265: // a slice length, corruptions are not handled yet.
  1482  			continue
  1483  		case 248:
  1484  			// Large map size, which currently causes an out of memory panic.
  1485  			// See golang.org/issue/24308 and golang.org/issue/20221.
  1486  			continue
  1487  		}
  1488  		indices = append(indices, i)
  1489  	}
  1490  	if testing.Short() {
  1491  		indices = []int{1, 111, 178} // known fixed panics
  1492  	}
  1493  	for _, i := range indices {
  1494  		for j := 0; j < 256; j += 3 {
  1495  			b := []byte(s)
  1496  			b[i] ^= byte(j)
  1497  			var e DT
  1498  			func() {
  1499  				defer func() {
  1500  					if p := recover(); p != nil {
  1501  						t.Errorf("crash for b[%d] ^= 0x%x", i, j)
  1502  						panic(p)
  1503  					}
  1504  				}()
  1505  				err := NewDecoder(bytes.NewReader(b)).Decode(&e)
  1506  				_ = err
  1507  			}()
  1508  		}
  1509  	}
  1510  }
  1511  
  1512  // Don't crash, just give error with invalid type id.
  1513  // Issue 9649.
  1514  func TestErrorInvalidTypeId(t *testing.T) {
  1515  	data := []byte{0x01, 0x00, 0x01, 0x00}
  1516  	d := NewDecoder(bytes.NewReader(data))
  1517  	// When running d.Decode(&foo) the first time the decoder stops
  1518  	// after []byte{0x01, 0x00} and reports an errBadType. Running
  1519  	// d.Decode(&foo) again on exactly the same input sequence should
  1520  	// give another errBadType, but instead caused a panic because
  1521  	// decoderMap wasn't cleaned up properly after the first error.
  1522  	for i := 0; i < 2; i++ {
  1523  		var foo struct{}
  1524  		err := d.Decode(&foo)
  1525  		if err != errBadType {
  1526  			t.Fatalf("decode: expected %s, got %s", errBadType, err)
  1527  		}
  1528  	}
  1529  }
  1530  

View as plain text