type_test.go

Documentation: encoding/gob

		 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  	"reflect"
		10  	"sync"
		11  	"testing"
		12  )
		13  
		14  type typeT struct {
		15  	id	typeId
		16  	str string
		17  }
		18  
		19  var basicTypes = []typeT{
		20  	{tBool, "bool"},
		21  	{tInt, "int"},
		22  	{tUint, "uint"},
		23  	{tFloat, "float"},
		24  	{tBytes, "bytes"},
		25  	{tString, "string"},
		26  }
		27  
		28  func getTypeUnlocked(name string, rt reflect.Type) gobType {
		29  	typeLock.Lock()
		30  	defer typeLock.Unlock()
		31  	t, err := getBaseType(name, rt)
		32  	if err != nil {
		33  		panic("getTypeUnlocked: " + err.Error())
		34  	}
		35  	return t
		36  }
		37  
		38  // Sanity checks
		39  func TestBasic(t *testing.T) {
		40  	for _, tt := range basicTypes {
		41  		if tt.id.string() != tt.str {
		42  			t.Errorf("checkType: expected %q got %s", tt.str, tt.id.string())
		43  		}
		44  		if tt.id == 0 {
		45  			t.Errorf("id for %q is zero", tt.str)
		46  		}
		47  	}
		48  }
		49  
		50  // Reregister some basic types to check registration is idempotent.
		51  func TestReregistration(t *testing.T) {
		52  	newtyp := getTypeUnlocked("int", reflect.TypeOf(int(0)))
		53  	if newtyp != tInt.gobType() {
		54  		t.Errorf("reregistration of %s got new type", newtyp.string())
		55  	}
		56  	newtyp = getTypeUnlocked("uint", reflect.TypeOf(uint(0)))
		57  	if newtyp != tUint.gobType() {
		58  		t.Errorf("reregistration of %s got new type", newtyp.string())
		59  	}
		60  	newtyp = getTypeUnlocked("string", reflect.TypeOf("hello"))
		61  	if newtyp != tString.gobType() {
		62  		t.Errorf("reregistration of %s got new type", newtyp.string())
		63  	}
		64  }
		65  
		66  func TestArrayType(t *testing.T) {
		67  	var a3 [3]int
		68  	a3int := getTypeUnlocked("foo", reflect.TypeOf(a3))
		69  	newa3int := getTypeUnlocked("bar", reflect.TypeOf(a3))
		70  	if a3int != newa3int {
		71  		t.Errorf("second registration of [3]int creates new type")
		72  	}
		73  	var a4 [4]int
		74  	a4int := getTypeUnlocked("goo", reflect.TypeOf(a4))
		75  	if a3int == a4int {
		76  		t.Errorf("registration of [3]int creates same type as [4]int")
		77  	}
		78  	var b3 [3]bool
		79  	a3bool := getTypeUnlocked("", reflect.TypeOf(b3))
		80  	if a3int == a3bool {
		81  		t.Errorf("registration of [3]bool creates same type as [3]int")
		82  	}
		83  	str := a3bool.string()
		84  	expected := "[3]bool"
		85  	if str != expected {
		86  		t.Errorf("array printed as %q; expected %q", str, expected)
		87  	}
		88  }
		89  
		90  func TestSliceType(t *testing.T) {
		91  	var s []int
		92  	sint := getTypeUnlocked("slice", reflect.TypeOf(s))
		93  	var news []int
		94  	newsint := getTypeUnlocked("slice1", reflect.TypeOf(news))
		95  	if sint != newsint {
		96  		t.Errorf("second registration of []int creates new type")
		97  	}
		98  	var b []bool
		99  	sbool := getTypeUnlocked("", reflect.TypeOf(b))
	 100  	if sbool == sint {
	 101  		t.Errorf("registration of []bool creates same type as []int")
	 102  	}
	 103  	str := sbool.string()
	 104  	expected := "[]bool"
	 105  	if str != expected {
	 106  		t.Errorf("slice printed as %q; expected %q", str, expected)
	 107  	}
	 108  }
	 109  
	 110  func TestMapType(t *testing.T) {
	 111  	var m map[string]int
	 112  	mapStringInt := getTypeUnlocked("map", reflect.TypeOf(m))
	 113  	var newm map[string]int
	 114  	newMapStringInt := getTypeUnlocked("map1", reflect.TypeOf(newm))
	 115  	if mapStringInt != newMapStringInt {
	 116  		t.Errorf("second registration of map[string]int creates new type")
	 117  	}
	 118  	var b map[string]bool
	 119  	mapStringBool := getTypeUnlocked("", reflect.TypeOf(b))
	 120  	if mapStringBool == mapStringInt {
	 121  		t.Errorf("registration of map[string]bool creates same type as map[string]int")
	 122  	}
	 123  	str := mapStringBool.string()
	 124  	expected := "map[string]bool"
	 125  	if str != expected {
	 126  		t.Errorf("map printed as %q; expected %q", str, expected)
	 127  	}
	 128  }
	 129  
	 130  type Bar struct {
	 131  	X string
	 132  }
	 133  
	 134  // This structure has pointers and refers to itself, making it a good test case.
	 135  type Foo struct {
	 136  	A int
	 137  	B int32 // will become int
	 138  	C string
	 139  	D []byte
	 140  	E *float64		// will become float64
	 141  	F ****float64 // will become float64
	 142  	G *Bar
	 143  	H *Bar // should not interpolate the definition of Bar again
	 144  	I *Foo // will not explode
	 145  }
	 146  
	 147  func TestStructType(t *testing.T) {
	 148  	sstruct := getTypeUnlocked("Foo", reflect.TypeOf(Foo{}))
	 149  	str := sstruct.string()
	 150  	// If we can print it correctly, we built it correctly.
	 151  	expected := "Foo = struct { A int; B int; C string; D bytes; E float; F float; G Bar = struct { X string; }; H Bar; I Foo; }"
	 152  	if str != expected {
	 153  		t.Errorf("struct printed as %q; expected %q", str, expected)
	 154  	}
	 155  }
	 156  
	 157  // Should be OK to register the same type multiple times, as long as they're
	 158  // at the same level of indirection.
	 159  func TestRegistration(t *testing.T) {
	 160  	type T struct{ a int }
	 161  	Register(new(T))
	 162  	Register(new(T))
	 163  }
	 164  
	 165  type N1 struct{}
	 166  type N2 struct{}
	 167  
	 168  // See comment in type.go/Register.
	 169  func TestRegistrationNaming(t *testing.T) {
	 170  	testCases := []struct {
	 171  		t		interface{}
	 172  		name string
	 173  	}{
	 174  		{&N1{}, "*gob.N1"},
	 175  		{N2{}, "encoding/gob.N2"},
	 176  	}
	 177  
	 178  	for _, tc := range testCases {
	 179  		Register(tc.t)
	 180  
	 181  		tct := reflect.TypeOf(tc.t)
	 182  		ct, _ := nameToConcreteType.Load(tc.name)
	 183  		if ct != tct {
	 184  			t.Errorf("nameToConcreteType[%q] = %v, want %v", tc.name, ct, tct)
	 185  		}
	 186  		// concreteTypeToName is keyed off the base type.
	 187  		if tct.Kind() == reflect.Ptr {
	 188  			tct = tct.Elem()
	 189  		}
	 190  		if n, _ := concreteTypeToName.Load(tct); n != tc.name {
	 191  			t.Errorf("concreteTypeToName[%v] got %v, want %v", tct, n, tc.name)
	 192  		}
	 193  	}
	 194  }
	 195  
	 196  func TestStressParallel(t *testing.T) {
	 197  	type T2 struct{ A int }
	 198  	c := make(chan bool)
	 199  	const N = 10
	 200  	for i := 0; i < N; i++ {
	 201  		go func() {
	 202  			p := new(T2)
	 203  			Register(p)
	 204  			b := new(bytes.Buffer)
	 205  			enc := NewEncoder(b)
	 206  			err := enc.Encode(p)
	 207  			if err != nil {
	 208  				t.Error("encoder fail:", err)
	 209  			}
	 210  			dec := NewDecoder(b)
	 211  			err = dec.Decode(p)
	 212  			if err != nil {
	 213  				t.Error("decoder fail:", err)
	 214  			}
	 215  			c <- true
	 216  		}()
	 217  	}
	 218  	for i := 0; i < N; i++ {
	 219  		<-c
	 220  	}
	 221  }
	 222  
	 223  // Issue 23328. Note that this test name is known to cmd/dist/test.go.
	 224  func TestTypeRace(t *testing.T) {
	 225  	c := make(chan bool)
	 226  	var wg sync.WaitGroup
	 227  	for i := 0; i < 2; i++ {
	 228  		wg.Add(1)
	 229  		go func(i int) {
	 230  			defer wg.Done()
	 231  			var buf bytes.Buffer
	 232  			enc := NewEncoder(&buf)
	 233  			dec := NewDecoder(&buf)
	 234  			var x interface{}
	 235  			switch i {
	 236  			case 0:
	 237  				x = &N1{}
	 238  			case 1:
	 239  				x = &N2{}
	 240  			default:
	 241  				t.Errorf("bad i %d", i)
	 242  				return
	 243  			}
	 244  			m := make(map[string]string)
	 245  			<-c
	 246  			if err := enc.Encode(x); err != nil {
	 247  				t.Error(err)
	 248  				return
	 249  			}
	 250  			if err := enc.Encode(x); err != nil {
	 251  				t.Error(err)
	 252  				return
	 253  			}
	 254  			if err := dec.Decode(&m); err == nil {
	 255  				t.Error("decode unexpectedly succeeded")
	 256  				return
	 257  			}
	 258  		}(i)
	 259  	}
	 260  	close(c)
	 261  	wg.Wait()
	 262  }
	 263
View as plain text