1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package gob
import (
"reflect"
"testing"
)
type typeT struct {
id typeId
str string
}
var basicTypes = []typeT{
{tBool, "bool"},
{tInt, "int"},
{tUint, "uint"},
{tFloat, "float"},
{tBytes, "bytes"},
{tString, "string"},
}
func getTypeUnlocked(name string, rt reflect.Type) gobType {
typeLock.Lock()
defer typeLock.Unlock()
t, err := getBaseType(name, rt)
if err != nil {
panic("getTypeUnlocked: " + err.String())
}
return t
}
// Sanity checks
func TestBasic(t *testing.T) {
for _, tt := range basicTypes {
if tt.id.string() != tt.str {
t.Errorf("checkType: expected %q got %s", tt.str, tt.id.string())
}
if tt.id == 0 {
t.Errorf("id for %q is zero", tt.str)
}
}
}
// Reregister some basic types to check registration is idempotent.
func TestReregistration(t *testing.T) {
newtyp := getTypeUnlocked("int", reflect.Typeof(int(0)))
if newtyp != tInt.gobType() {
t.Errorf("reregistration of %s got new type", newtyp.string())
}
newtyp = getTypeUnlocked("uint", reflect.Typeof(uint(0)))
if newtyp != tUint.gobType() {
t.Errorf("reregistration of %s got new type", newtyp.string())
}
newtyp = getTypeUnlocked("string", reflect.Typeof("hello"))
if newtyp != tString.gobType() {
t.Errorf("reregistration of %s got new type", newtyp.string())
}
}
func TestArrayType(t *testing.T) {
var a3 [3]int
a3int := getTypeUnlocked("foo", reflect.Typeof(a3))
newa3int := getTypeUnlocked("bar", reflect.Typeof(a3))
if a3int != newa3int {
t.Errorf("second registration of [3]int creates new type")
}
var a4 [4]int
a4int := getTypeUnlocked("goo", reflect.Typeof(a4))
if a3int == a4int {
t.Errorf("registration of [3]int creates same type as [4]int")
}
var b3 [3]bool
a3bool := getTypeUnlocked("", reflect.Typeof(b3))
if a3int == a3bool {
t.Errorf("registration of [3]bool creates same type as [3]int")
}
str := a3bool.string()
expected := "[3]bool"
if str != expected {
t.Errorf("array printed as %q; expected %q", str, expected)
}
}
func TestSliceType(t *testing.T) {
var s []int
sint := getTypeUnlocked("slice", reflect.Typeof(s))
var news []int
newsint := getTypeUnlocked("slice1", reflect.Typeof(news))
if sint != newsint {
t.Errorf("second registration of []int creates new type")
}
var b []bool
sbool := getTypeUnlocked("", reflect.Typeof(b))
if sbool == sint {
t.Errorf("registration of []bool creates same type as []int")
}
str := sbool.string()
expected := "[]bool"
if str != expected {
t.Errorf("slice printed as %q; expected %q", str, expected)
}
}
func TestMapType(t *testing.T) {
var m map[string]int
mapStringInt := getTypeUnlocked("map", reflect.Typeof(m))
var newm map[string]int
newMapStringInt := getTypeUnlocked("map1", reflect.Typeof(newm))
if mapStringInt != newMapStringInt {
t.Errorf("second registration of map[string]int creates new type")
}
var b map[string]bool
mapStringBool := getTypeUnlocked("", reflect.Typeof(b))
if mapStringBool == mapStringInt {
t.Errorf("registration of map[string]bool creates same type as map[string]int")
}
str := mapStringBool.string()
expected := "map[string]bool"
if str != expected {
t.Errorf("map printed as %q; expected %q", str, expected)
}
}
type Bar struct {
X string
}
// This structure has pointers and refers to itself, making it a good test case.
type Foo struct {
A int
B int32 // will become int
C string
D []byte
E *float64 // will become float64
F ****float64 // will become float64
G *Bar
H *Bar // should not interpolate the definition of Bar again
I *Foo // will not explode
}
func TestStructType(t *testing.T) {
sstruct := getTypeUnlocked("Foo", reflect.Typeof(Foo{}))
str := sstruct.string()
// If we can print it correctly, we built it correctly.
expected := "Foo = struct { A int; B int; C string; D bytes; E float; F float; G Bar = struct { X string; }; H Bar; I Foo; }"
if str != expected {
t.Errorf("struct printed as %q; expected %q", str, expected)
}
}
|
