?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Reverting merge from trunk
[official-gcc.git] / libgo / go / reflect / all_test.go
blob6ab02f7d854296216b2ec81dd3e9b888247b91c1
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 reflect_test
6
7 import (
8 "bytes"
9 "encoding/base64"
10 "flag"
11 "fmt"
12 "io"
13 "math/rand"
14 "os"
15 . "reflect"
16 "runtime"
17 "sort"
18 "sync"
19 "testing"
20 "time"
21 "unsafe"
22 )
23
24 func TestBool(t *testing.T) {
25 v := ValueOf(true)
26 if v.Bool() != true {
27 t.Fatal("ValueOf(true).Bool() = false")
28 }
29 }
30
31 type integer int
32 type T struct {
33 a int
34 b float64
35 c string
36 d *int
37 }
38
39 type pair struct {
40 i interface{}
41 s string
42 }
43
44 func isDigit(c uint8) bool { return '0' <= c && c <= '9' }
45
46 func assert(t *testing.T, s, want string) {
47 if s != want {
48 t.Errorf("have %#q want %#q", s, want)
49 }
50 }
51
52 func typestring(i interface{}) string { return TypeOf(i).String() }
53
54 var typeTests = []pair{
55 {struct{ x int }{}, "int"},
56 {struct{ x int8 }{}, "int8"},
57 {struct{ x int16 }{}, "int16"},
58 {struct{ x int32 }{}, "int32"},
59 {struct{ x int64 }{}, "int64"},
60 {struct{ x uint }{}, "uint"},
61 {struct{ x uint8 }{}, "uint8"},
62 {struct{ x uint16 }{}, "uint16"},
63 {struct{ x uint32 }{}, "uint32"},
64 {struct{ x uint64 }{}, "uint64"},
65 {struct{ x float32 }{}, "float32"},
66 {struct{ x float64 }{}, "float64"},
67 {struct{ x int8 }{}, "int8"},
68 {struct{ x (**int8) }{}, "**int8"},
69 {struct{ x (**integer) }{}, "**reflect_test.integer"},
70 {struct{ x ([32]int32) }{}, "[32]int32"},
71 {struct{ x ([]int8) }{}, "[]int8"},
72 {struct{ x (map[string]int32) }{}, "map[string]int32"},
73 {struct{ x (chan<- string) }{}, "chan<- string"},
74 {struct {
75 x struct {
76 c chan *int32
77 d float32
78 }
79 }{},
80 "struct { c chan *int32; d float32 }",
81 },
82 {struct{ x (func(a int8, b int32)) }{}, "func(int8, int32)"},
83 {struct {
84 x struct {
85 c func(chan *integer, *int8)
86 }
87 }{},
88 "struct { c func(chan *reflect_test.integer, *int8) }",
89 },
90 {struct {
91 x struct {
92 a int8
93 b int32
94 }
95 }{},
96 "struct { a int8; b int32 }",
97 },
98 {struct {
99 x struct {
100 a int8
101 b int8
102 c int32
103 }
104 }{},
105 "struct { a int8; b int8; c int32 }",
106 },
107 {struct {
108 x struct {
109 a int8
110 b int8
111 c int8
112 d int32
113 }
114 }{},
115 "struct { a int8; b int8; c int8; d int32 }",
116 },
117 {struct {
118 x struct {
119 a int8
120 b int8
121 c int8
122 d int8
123 e int32
124 }
125 }{},
126 "struct { a int8; b int8; c int8; d int8; e int32 }",
127 },
128 {struct {
129 x struct {
130 a int8
131 b int8
132 c int8
133 d int8
134 e int8
135 f int32
136 }
137 }{},
138 "struct { a int8; b int8; c int8; d int8; e int8; f int32 }",
139 },
140 {struct {
141 x struct {
142 a int8 `reflect:"hi there"`
143 }
144 }{},
145 `struct { a int8 "reflect:\"hi there\"" }`,
146 },
147 {struct {
148 x struct {
149 a int8 `reflect:"hi \x00there\t\n\"\\"`
150 }
151 }{},
152 `struct { a int8 "reflect:\"hi \\x00there\\t\\n\\\"\\\\\"" }`,
153 },
154 {struct {
155 x struct {
156 f func(args ...int)
157 }
158 }{},
159 "struct { f func(...int) }",
160 },
161 {struct {
162 x (interface {
163 a(func(func(int) int) func(func(int)) int)
164 b()
165 })
166 }{},
167 "interface { reflect_test.a(func(func(int) int) func(func(int)) int); reflect_test.b() }",
168 },
169 }
170
171 var valueTests = []pair{
172 {new(int), "132"},
173 {new(int8), "8"},
174 {new(int16), "16"},
175 {new(int32), "32"},
176 {new(int64), "64"},
177 {new(uint), "132"},
178 {new(uint8), "8"},
179 {new(uint16), "16"},
180 {new(uint32), "32"},
181 {new(uint64), "64"},
182 {new(float32), "256.25"},
183 {new(float64), "512.125"},
184 {new(complex64), "532.125+10i"},
185 {new(complex128), "564.25+1i"},
186 {new(string), "stringy cheese"},
187 {new(bool), "true"},
188 {new(*int8), "*int8(0)"},
189 {new(**int8), "**int8(0)"},
190 {new([5]int32), "[5]int32{0, 0, 0, 0, 0}"},
191 {new(**integer), "**reflect_test.integer(0)"},
192 {new(map[string]int32), "map[string]int32{<can't iterate on maps>}"},
193 {new(chan<- string), "chan<- string"},
194 {new(func(a int8, b int32)), "func(int8, int32)(0)"},
195 {new(struct {
196 c chan *int32
197 d float32
198 }),
199 "struct { c chan *int32; d float32 }{chan *int32, 0}",
200 },
201 {new(struct{ c func(chan *integer, *int8) }),
202 "struct { c func(chan *reflect_test.integer, *int8) }{func(chan *reflect_test.integer, *int8)(0)}",
203 },
204 {new(struct {
205 a int8
206 b int32
207 }),
208 "struct { a int8; b int32 }{0, 0}",
209 },
210 {new(struct {
211 a int8
212 b int8
213 c int32
214 }),
215 "struct { a int8; b int8; c int32 }{0, 0, 0}",
216 },
217 }
218
219 func testType(t *testing.T, i int, typ Type, want string) {
220 s := typ.String()
221 if s != want {
222 t.Errorf("#%d: have %#q, want %#q", i, s, want)
223 }
224 }
225
226 func TestTypes(t *testing.T) {
227 for i, tt := range typeTests {
228 testType(t, i, ValueOf(tt.i).Field(0).Type(), tt.s)
229 }
230 }
231
232 func TestSet(t *testing.T) {
233 for i, tt := range valueTests {
234 v := ValueOf(tt.i)
235 v = v.Elem()
236 switch v.Kind() {
237 case Int:
238 v.SetInt(132)
239 case Int8:
240 v.SetInt(8)
241 case Int16:
242 v.SetInt(16)
243 case Int32:
244 v.SetInt(32)
245 case Int64:
246 v.SetInt(64)
247 case Uint:
248 v.SetUint(132)
249 case Uint8:
250 v.SetUint(8)
251 case Uint16:
252 v.SetUint(16)
253 case Uint32:
254 v.SetUint(32)
255 case Uint64:
256 v.SetUint(64)
257 case Float32:
258 v.SetFloat(256.25)
259 case Float64:
260 v.SetFloat(512.125)
261 case Complex64:
262 v.SetComplex(532.125 + 10i)
263 case Complex128:
264 v.SetComplex(564.25 + 1i)
265 case String:
266 v.SetString("stringy cheese")
267 case Bool:
268 v.SetBool(true)
269 }
270 s := valueToString(v)
271 if s != tt.s {
272 t.Errorf("#%d: have %#q, want %#q", i, s, tt.s)
273 }
274 }
275 }
276
277 func TestSetValue(t *testing.T) {
278 for i, tt := range valueTests {
279 v := ValueOf(tt.i).Elem()
280 switch v.Kind() {
281 case Int:
282 v.Set(ValueOf(int(132)))
283 case Int8:
284 v.Set(ValueOf(int8(8)))
285 case Int16:
286 v.Set(ValueOf(int16(16)))
287 case Int32:
288 v.Set(ValueOf(int32(32)))
289 case Int64:
290 v.Set(ValueOf(int64(64)))
291 case Uint:
292 v.Set(ValueOf(uint(132)))
293 case Uint8:
294 v.Set(ValueOf(uint8(8)))
295 case Uint16:
296 v.Set(ValueOf(uint16(16)))
297 case Uint32:
298 v.Set(ValueOf(uint32(32)))
299 case Uint64:
300 v.Set(ValueOf(uint64(64)))
301 case Float32:
302 v.Set(ValueOf(float32(256.25)))
303 case Float64:
304 v.Set(ValueOf(512.125))
305 case Complex64:
306 v.Set(ValueOf(complex64(532.125 + 10i)))
307 case Complex128:
308 v.Set(ValueOf(complex128(564.25 + 1i)))
309 case String:
310 v.Set(ValueOf("stringy cheese"))
311 case Bool:
312 v.Set(ValueOf(true))
313 }
314 s := valueToString(v)
315 if s != tt.s {
316 t.Errorf("#%d: have %#q, want %#q", i, s, tt.s)
317 }
318 }
319 }
320
321 var _i = 7
322
323 var valueToStringTests = []pair{
324 {123, "123"},
325 {123.5, "123.5"},
326 {byte(123), "123"},
327 {"abc", "abc"},
328 {T{123, 456.75, "hello", &_i}, "reflect_test.T{123, 456.75, hello, *int(&7)}"},
329 {new(chan *T), "*chan *reflect_test.T(&chan *reflect_test.T)"},
330 {[10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, "[10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}"},
331 {&[10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, "*[10]int(&[10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10})"},
332 {[]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, "[]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}"},
333 {&[]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, "*[]int(&[]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10})"},
334 }
335
336 func TestValueToString(t *testing.T) {
337 for i, test := range valueToStringTests {
338 s := valueToString(ValueOf(test.i))
339 if s != test.s {
340 t.Errorf("#%d: have %#q, want %#q", i, s, test.s)
341 }
342 }
343 }
344
345 func TestArrayElemSet(t *testing.T) {
346 v := ValueOf(&[10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}).Elem()
347 v.Index(4).SetInt(123)
348 s := valueToString(v)
349 const want = "[10]int{1, 2, 3, 4, 123, 6, 7, 8, 9, 10}"
350 if s != want {
351 t.Errorf("[10]int: have %#q want %#q", s, want)
352 }
353
354 v = ValueOf([]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10})
355 v.Index(4).SetInt(123)
356 s = valueToString(v)
357 const want1 = "[]int{1, 2, 3, 4, 123, 6, 7, 8, 9, 10}"
358 if s != want1 {
359 t.Errorf("[]int: have %#q want %#q", s, want1)
360 }
361 }
362
363 func TestPtrPointTo(t *testing.T) {
364 var ip *int32
365 var i int32 = 1234
366 vip := ValueOf(&ip)
367 vi := ValueOf(&i).Elem()
368 vip.Elem().Set(vi.Addr())
369 if *ip != 1234 {
370 t.Errorf("got %d, want 1234", *ip)
371 }
372
373 ip = nil
374 vp := ValueOf(&ip).Elem()
375 vp.Set(Zero(vp.Type()))
376 if ip != nil {
377 t.Errorf("got non-nil (%p), want nil", ip)
378 }
379 }
380
381 func TestPtrSetNil(t *testing.T) {
382 var i int32 = 1234
383 ip := &i
384 vip := ValueOf(&ip)
385 vip.Elem().Set(Zero(vip.Elem().Type()))
386 if ip != nil {
387 t.Errorf("got non-nil (%d), want nil", *ip)
388 }
389 }
390
391 func TestMapSetNil(t *testing.T) {
392 m := make(map[string]int)
393 vm := ValueOf(&m)
394 vm.Elem().Set(Zero(vm.Elem().Type()))
395 if m != nil {
396 t.Errorf("got non-nil (%p), want nil", m)
397 }
398 }
399
400 func TestAll(t *testing.T) {
401 testType(t, 1, TypeOf((int8)(0)), "int8")
402 testType(t, 2, TypeOf((*int8)(nil)).Elem(), "int8")
403
404 typ := TypeOf((*struct {
405 c chan *int32
406 d float32
407 })(nil))
408 testType(t, 3, typ, "*struct { c chan *int32; d float32 }")
409 etyp := typ.Elem()
410 testType(t, 4, etyp, "struct { c chan *int32; d float32 }")
411 styp := etyp
412 f := styp.Field(0)
413 testType(t, 5, f.Type, "chan *int32")
414
415 f, present := styp.FieldByName("d")
416 if !present {
417 t.Errorf("FieldByName says present field is absent")
418 }
419 testType(t, 6, f.Type, "float32")
420
421 f, present = styp.FieldByName("absent")
422 if present {
423 t.Errorf("FieldByName says absent field is present")
424 }
425
426 typ = TypeOf([32]int32{})
427 testType(t, 7, typ, "[32]int32")
428 testType(t, 8, typ.Elem(), "int32")
429
430 typ = TypeOf((map[string]*int32)(nil))
431 testType(t, 9, typ, "map[string]*int32")
432 mtyp := typ
433 testType(t, 10, mtyp.Key(), "string")
434 testType(t, 11, mtyp.Elem(), "*int32")
435
436 typ = TypeOf((chan<- string)(nil))
437 testType(t, 12, typ, "chan<- string")
438 testType(t, 13, typ.Elem(), "string")
439
440 // make sure tag strings are not part of element type
441 typ = TypeOf(struct {
442 d []uint32 `reflect:"TAG"`
443 }{}).Field(0).Type
444 testType(t, 14, typ, "[]uint32")
445 }
446
447 func TestInterfaceGet(t *testing.T) {
448 var inter struct {
449 E interface{}
450 }
451 inter.E = 123.456
452 v1 := ValueOf(&inter)
453 v2 := v1.Elem().Field(0)
454 assert(t, v2.Type().String(), "interface {}")
455 i2 := v2.Interface()
456 v3 := ValueOf(i2)
457 assert(t, v3.Type().String(), "float64")
458 }
459
460 func TestInterfaceValue(t *testing.T) {
461 var inter struct {
462 E interface{}
463 }
464 inter.E = 123.456
465 v1 := ValueOf(&inter)
466 v2 := v1.Elem().Field(0)
467 assert(t, v2.Type().String(), "interface {}")
468 v3 := v2.Elem()
469 assert(t, v3.Type().String(), "float64")
470
471 i3 := v2.Interface()
472 if _, ok := i3.(float64); !ok {
473 t.Error("v2.Interface() did not return float64, got ", TypeOf(i3))
474 }
475 }
476
477 func TestFunctionValue(t *testing.T) {
478 var x interface{} = func() {}
479 v := ValueOf(x)
480 if fmt.Sprint(v.Interface()) != fmt.Sprint(x) {
481 t.Fatalf("TestFunction returned wrong pointer")
482 }
483 assert(t, v.Type().String(), "func()")
484 }
485
486 var appendTests = []struct {
487 orig, extra []int
488 }{
489 {make([]int, 2, 4), []int{22}},
490 {make([]int, 2, 4), []int{22, 33, 44}},
491 }
492
493 func sameInts(x, y []int) bool {
494 if len(x) != len(y) {
495 return false
496 }
497 for i, xx := range x {
498 if xx != y[i] {
499 return false
500 }
501 }
502 return true
503 }
504
505 func TestAppend(t *testing.T) {
506 for i, test := range appendTests {
507 origLen, extraLen := len(test.orig), len(test.extra)
508 want := append(test.orig, test.extra...)
509 // Convert extra from []int to []Value.
510 e0 := make([]Value, len(test.extra))
511 for j, e := range test.extra {
512 e0[j] = ValueOf(e)
513 }
514 // Convert extra from []int to *SliceValue.
515 e1 := ValueOf(test.extra)
516 // Test Append.
517 a0 := ValueOf(test.orig)
518 have0 := Append(a0, e0...).Interface().([]int)
519 if !sameInts(have0, want) {
520 t.Errorf("Append #%d: have %v, want %v (%p %p)", i, have0, want, test.orig, have0)
521 }
522 // Check that the orig and extra slices were not modified.
523 if len(test.orig) != origLen {
524 t.Errorf("Append #%d origLen: have %v, want %v", i, len(test.orig), origLen)
525 }
526 if len(test.extra) != extraLen {
527 t.Errorf("Append #%d extraLen: have %v, want %v", i, len(test.extra), extraLen)
528 }
529 // Test AppendSlice.
530 a1 := ValueOf(test.orig)
531 have1 := AppendSlice(a1, e1).Interface().([]int)
532 if !sameInts(have1, want) {
533 t.Errorf("AppendSlice #%d: have %v, want %v", i, have1, want)
534 }
535 // Check that the orig and extra slices were not modified.
536 if len(test.orig) != origLen {
537 t.Errorf("AppendSlice #%d origLen: have %v, want %v", i, len(test.orig), origLen)
538 }
539 if len(test.extra) != extraLen {
540 t.Errorf("AppendSlice #%d extraLen: have %v, want %v", i, len(test.extra), extraLen)
541 }
542 }
543 }
544
545 func TestCopy(t *testing.T) {
546 a := []int{1, 2, 3, 4, 10, 9, 8, 7}
547 b := []int{11, 22, 33, 44, 1010, 99, 88, 77, 66, 55, 44}
548 c := []int{11, 22, 33, 44, 1010, 99, 88, 77, 66, 55, 44}
549 for i := 0; i < len(b); i++ {
550 if b[i] != c[i] {
551 t.Fatalf("b != c before test")
552 }
553 }
554 a1 := a
555 b1 := b
556 aa := ValueOf(&a1).Elem()
557 ab := ValueOf(&b1).Elem()
558 for tocopy := 1; tocopy <= 7; tocopy++ {
559 aa.SetLen(tocopy)
560 Copy(ab, aa)
561 aa.SetLen(8)
562 for i := 0; i < tocopy; i++ {
563 if a[i] != b[i] {
564 t.Errorf("(i) tocopy=%d a[%d]=%d, b[%d]=%d",
565 tocopy, i, a[i], i, b[i])
566 }
567 }
568 for i := tocopy; i < len(b); i++ {
569 if b[i] != c[i] {
570 if i < len(a) {
571 t.Errorf("(ii) tocopy=%d a[%d]=%d, b[%d]=%d, c[%d]=%d",
572 tocopy, i, a[i], i, b[i], i, c[i])
573 } else {
574 t.Errorf("(iii) tocopy=%d b[%d]=%d, c[%d]=%d",
575 tocopy, i, b[i], i, c[i])
576 }
577 } else {
578 t.Logf("tocopy=%d elem %d is okay\n", tocopy, i)
579 }
580 }
581 }
582 }
583
584 func TestCopyArray(t *testing.T) {
585 a := [8]int{1, 2, 3, 4, 10, 9, 8, 7}
586 b := [11]int{11, 22, 33, 44, 1010, 99, 88, 77, 66, 55, 44}
587 c := b
588 aa := ValueOf(&a).Elem()
589 ab := ValueOf(&b).Elem()
590 Copy(ab, aa)
591 for i := 0; i < len(a); i++ {
592 if a[i] != b[i] {
593 t.Errorf("(i) a[%d]=%d, b[%d]=%d", i, a[i], i, b[i])
594 }
595 }
596 for i := len(a); i < len(b); i++ {
597 if b[i] != c[i] {
598 t.Errorf("(ii) b[%d]=%d, c[%d]=%d", i, b[i], i, c[i])
599 } else {
600 t.Logf("elem %d is okay\n", i)
601 }
602 }
603 }
604
605 func TestBigUnnamedStruct(t *testing.T) {
606 b := struct{ a, b, c, d int64 }{1, 2, 3, 4}
607 v := ValueOf(b)
608 b1 := v.Interface().(struct {
609 a, b, c, d int64
610 })
611 if b1.a != b.a || b1.b != b.b || b1.c != b.c || b1.d != b.d {
612 t.Errorf("ValueOf(%v).Interface().(*Big) = %v", b, b1)
613 }
614 }
615
616 type big struct {
617 a, b, c, d, e int64
618 }
619
620 func TestBigStruct(t *testing.T) {
621 b := big{1, 2, 3, 4, 5}
622 v := ValueOf(b)
623 b1 := v.Interface().(big)
624 if b1.a != b.a || b1.b != b.b || b1.c != b.c || b1.d != b.d || b1.e != b.e {
625 t.Errorf("ValueOf(%v).Interface().(big) = %v", b, b1)
626 }
627 }
628
629 type Basic struct {
630 x int
631 y float32
632 }
633
634 type NotBasic Basic
635
636 type DeepEqualTest struct {
637 a, b interface{}
638 eq bool
639 }
640
641 // Simple functions for DeepEqual tests.
642 var (
643 fn1 func() // nil.
644 fn2 func() // nil.
645 fn3 = func() { fn1() } // Not nil.
646 )
647
648 var deepEqualTests = []DeepEqualTest{
649 // Equalities
650 {nil, nil, true},
651 {1, 1, true},
652 {int32(1), int32(1), true},
653 {0.5, 0.5, true},
654 {float32(0.5), float32(0.5), true},
655 {"hello", "hello", true},
656 {make([]int, 10), make([]int, 10), true},
657 {&[3]int{1, 2, 3}, &[3]int{1, 2, 3}, true},
658 {Basic{1, 0.5}, Basic{1, 0.5}, true},
659 {error(nil), error(nil), true},
660 {map[int]string{1: "one", 2: "two"}, map[int]string{2: "two", 1: "one"}, true},
661 {fn1, fn2, true},
662
663 // Inequalities
664 {1, 2, false},
665 {int32(1), int32(2), false},
666 {0.5, 0.6, false},
667 {float32(0.5), float32(0.6), false},
668 {"hello", "hey", false},
669 {make([]int, 10), make([]int, 11), false},
670 {&[3]int{1, 2, 3}, &[3]int{1, 2, 4}, false},
671 {Basic{1, 0.5}, Basic{1, 0.6}, false},
672 {Basic{1, 0}, Basic{2, 0}, false},
673 {map[int]string{1: "one", 3: "two"}, map[int]string{2: "two", 1: "one"}, false},
674 {map[int]string{1: "one", 2: "txo"}, map[int]string{2: "two", 1: "one"}, false},
675 {map[int]string{1: "one"}, map[int]string{2: "two", 1: "one"}, false},
676 {map[int]string{2: "two", 1: "one"}, map[int]string{1: "one"}, false},
677 {nil, 1, false},
678 {1, nil, false},
679 {fn1, fn3, false},
680 {fn3, fn3, false},
681
682 // Nil vs empty: not the same.
683 {[]int{}, []int(nil), false},
684 {[]int{}, []int{}, true},
685 {[]int(nil), []int(nil), true},
686 {map[int]int{}, map[int]int(nil), false},
687 {map[int]int{}, map[int]int{}, true},
688 {map[int]int(nil), map[int]int(nil), true},
689
690 // Mismatched types
691 {1, 1.0, false},
692 {int32(1), int64(1), false},
693 {0.5, "hello", false},
694 {[]int{1, 2, 3}, [3]int{1, 2, 3}, false},
695 {&[3]interface{}{1, 2, 4}, &[3]interface{}{1, 2, "s"}, false},
696 {Basic{1, 0.5}, NotBasic{1, 0.5}, false},
697 {map[uint]string{1: "one", 2: "two"}, map[int]string{2: "two", 1: "one"}, false},
698 }
699
700 func TestDeepEqual(t *testing.T) {
701 for _, test := range deepEqualTests {
702 if r := DeepEqual(test.a, test.b); r != test.eq {
703 t.Errorf("DeepEqual(%v, %v) = %v, want %v", test.a, test.b, r, test.eq)
704 }
705 }
706 }
707
708 func TestTypeOf(t *testing.T) {
709 // Special case for nil
710 if typ := TypeOf(nil); typ != nil {
711 t.Errorf("expected nil type for nil value; got %v", typ)
712 }
713 for _, test := range deepEqualTests {
714 v := ValueOf(test.a)
715 if !v.IsValid() {
716 continue
717 }
718 typ := TypeOf(test.a)
719 if typ != v.Type() {
720 t.Errorf("TypeOf(%v) = %v, but ValueOf(%v).Type() = %v", test.a, typ, test.a, v.Type())
721 }
722 }
723 }
724
725 type Recursive struct {
726 x int
727 r *Recursive
728 }
729
730 func TestDeepEqualRecursiveStruct(t *testing.T) {
731 a, b := new(Recursive), new(Recursive)
732 *a = Recursive{12, a}
733 *b = Recursive{12, b}
734 if !DeepEqual(a, b) {
735 t.Error("DeepEqual(recursive same) = false, want true")
736 }
737 }
738
739 type _Complex struct {
740 a int
741 b [3]*_Complex
742 c *string
743 d map[float64]float64
744 }
745
746 func TestDeepEqualComplexStruct(t *testing.T) {
747 m := make(map[float64]float64)
748 stra, strb := "hello", "hello"
749 a, b := new(_Complex), new(_Complex)
750 *a = _Complex{5, [3]*_Complex{a, b, a}, &stra, m}
751 *b = _Complex{5, [3]*_Complex{b, a, a}, &strb, m}
752 if !DeepEqual(a, b) {
753 t.Error("DeepEqual(complex same) = false, want true")
754 }
755 }
756
757 func TestDeepEqualComplexStructInequality(t *testing.T) {
758 m := make(map[float64]float64)
759 stra, strb := "hello", "helloo" // Difference is here
760 a, b := new(_Complex), new(_Complex)
761 *a = _Complex{5, [3]*_Complex{a, b, a}, &stra, m}
762 *b = _Complex{5, [3]*_Complex{b, a, a}, &strb, m}
763 if DeepEqual(a, b) {
764 t.Error("DeepEqual(complex different) = true, want false")
765 }
766 }
767
768 type UnexpT struct {
769 m map[int]int
770 }
771
772 func TestDeepEqualUnexportedMap(t *testing.T) {
773 // Check that DeepEqual can look at unexported fields.
774 x1 := UnexpT{map[int]int{1: 2}}
775 x2 := UnexpT{map[int]int{1: 2}}
776 if !DeepEqual(&x1, &x2) {
777 t.Error("DeepEqual(x1, x2) = false, want true")
778 }
779
780 y1 := UnexpT{map[int]int{2: 3}}
781 if DeepEqual(&x1, &y1) {
782 t.Error("DeepEqual(x1, y1) = true, want false")
783 }
784 }
785
786 func check2ndField(x interface{}, offs uintptr, t *testing.T) {
787 s := ValueOf(x)
788 f := s.Type().Field(1)
789 if f.Offset != offs {
790 t.Error("mismatched offsets in structure alignment:", f.Offset, offs)
791 }
792 }
793
794 // Check that structure alignment & offsets viewed through reflect agree with those
795 // from the compiler itself.
796 func TestAlignment(t *testing.T) {
797 type T1inner struct {
798 a int
799 }
800 type T1 struct {
801 T1inner
802 f int
803 }
804 type T2inner struct {
805 a, b int
806 }
807 type T2 struct {
808 T2inner
809 f int
810 }
811
812 x := T1{T1inner{2}, 17}
813 check2ndField(x, uintptr(unsafe.Pointer(&x.f))-uintptr(unsafe.Pointer(&x)), t)
814
815 x1 := T2{T2inner{2, 3}, 17}
816 check2ndField(x1, uintptr(unsafe.Pointer(&x1.f))-uintptr(unsafe.Pointer(&x1)), t)
817 }
818
819 func Nil(a interface{}, t *testing.T) {
820 n := ValueOf(a).Field(0)
821 if !n.IsNil() {
822 t.Errorf("%v should be nil", a)
823 }
824 }
825
826 func NotNil(a interface{}, t *testing.T) {
827 n := ValueOf(a).Field(0)
828 if n.IsNil() {
829 t.Errorf("value of type %v should not be nil", ValueOf(a).Type().String())
830 }
831 }
832
833 func TestIsNil(t *testing.T) {
834 // These implement IsNil.
835 // Wrap in extra struct to hide interface type.
836 doNil := []interface{}{
837 struct{ x *int }{},
838 struct{ x interface{} }{},
839 struct{ x map[string]int }{},
840 struct{ x func() bool }{},
841 struct{ x chan int }{},
842 struct{ x []string }{},
843 }
844 for _, ts := range doNil {
845 ty := TypeOf(ts).Field(0).Type
846 v := Zero(ty)
847 v.IsNil() // panics if not okay to call
848 }
849
850 // Check the implementations
851 var pi struct {
852 x *int
853 }
854 Nil(pi, t)
855 pi.x = new(int)
856 NotNil(pi, t)
857
858 var si struct {
859 x []int
860 }
861 Nil(si, t)
862 si.x = make([]int, 10)
863 NotNil(si, t)
864
865 var ci struct {
866 x chan int
867 }
868 Nil(ci, t)
869 ci.x = make(chan int)
870 NotNil(ci, t)
871
872 var mi struct {
873 x map[int]int
874 }
875 Nil(mi, t)
876 mi.x = make(map[int]int)
877 NotNil(mi, t)
878
879 var ii struct {
880 x interface{}
881 }
882 Nil(ii, t)
883 ii.x = 2
884 NotNil(ii, t)
885
886 var fi struct {
887 x func(t *testing.T)
888 }
889 Nil(fi, t)
890 fi.x = TestIsNil
891 NotNil(fi, t)
892 }
893
894 func TestInterfaceExtraction(t *testing.T) {
895 var s struct {
896 W io.Writer
897 }
898
899 s.W = os.Stdout
900 v := Indirect(ValueOf(&s)).Field(0).Interface()
901 if v != s.W.(interface{}) {
902 t.Error("Interface() on interface: ", v, s.W)
903 }
904 }
905
906 func TestNilPtrValueSub(t *testing.T) {
907 var pi *int
908 if pv := ValueOf(pi); pv.Elem().IsValid() {
909 t.Error("ValueOf((*int)(nil)).Elem().IsValid()")
910 }
911 }
912
913 func TestMap(t *testing.T) {
914 m := map[string]int{"a": 1, "b": 2}
915 mv := ValueOf(m)
916 if n := mv.Len(); n != len(m) {
917 t.Errorf("Len = %d, want %d", n, len(m))
918 }
919 keys := mv.MapKeys()
920 newmap := MakeMap(mv.Type())
921 for k, v := range m {
922 // Check that returned Keys match keys in range.
923 // These aren't required to be in the same order.
924 seen := false
925 for _, kv := range keys {
926 if kv.String() == k {
927 seen = true
928 break
929 }
930 }
931 if !seen {
932 t.Errorf("Missing key %q", k)
933 }
934
935 // Check that value lookup is correct.
936 vv := mv.MapIndex(ValueOf(k))
937 if vi := vv.Int(); vi != int64(v) {
938 t.Errorf("Key %q: have value %d, want %d", k, vi, v)
939 }
940
941 // Copy into new map.
942 newmap.SetMapIndex(ValueOf(k), ValueOf(v))
943 }
944 vv := mv.MapIndex(ValueOf("not-present"))
945 if vv.IsValid() {
946 t.Errorf("Invalid key: got non-nil value %s", valueToString(vv))
947 }
948
949 newm := newmap.Interface().(map[string]int)
950 if len(newm) != len(m) {
951 t.Errorf("length after copy: newm=%d, m=%d", len(newm), len(m))
952 }
953
954 for k, v := range newm {
955 mv, ok := m[k]
956 if mv != v {
957 t.Errorf("newm[%q] = %d, but m[%q] = %d, %v", k, v, k, mv, ok)
958 }
959 }
960
961 newmap.SetMapIndex(ValueOf("a"), Value{})
962 v, ok := newm["a"]
963 if ok {
964 t.Errorf("newm[\"a\"] = %d after delete", v)
965 }
966
967 mv = ValueOf(&m).Elem()
968 mv.Set(Zero(mv.Type()))
969 if m != nil {
970 t.Errorf("mv.Set(nil) failed")
971 }
972 }
973
974 func TestChan(t *testing.T) {
975 for loop := 0; loop < 2; loop++ {
976 var c chan int
977 var cv Value
978
979 // check both ways to allocate channels
980 switch loop {
981 case 1:
982 c = make(chan int, 1)
983 cv = ValueOf(c)
984 case 0:
985 cv = MakeChan(TypeOf(c), 1)
986 c = cv.Interface().(chan int)
987 }
988
989 // Send
990 cv.Send(ValueOf(2))
991 if i := <-c; i != 2 {
992 t.Errorf("reflect Send 2, native recv %d", i)
993 }
994
995 // Recv
996 c <- 3
997 if i, ok := cv.Recv(); i.Int() != 3 || !ok {
998 t.Errorf("native send 3, reflect Recv %d, %t", i.Int(), ok)
999 }
1000
1001 // TryRecv fail
1002 val, ok := cv.TryRecv()
1003 if val.IsValid() || ok {
1004 t.Errorf("TryRecv on empty chan: %s, %t", valueToString(val), ok)
1005 }
1006
1007 // TryRecv success
1008 c <- 4
1009 val, ok = cv.TryRecv()
1010 if !val.IsValid() {
1011 t.Errorf("TryRecv on ready chan got nil")
1012 } else if i := val.Int(); i != 4 || !ok {
1013 t.Errorf("native send 4, TryRecv %d, %t", i, ok)
1014 }
1015
1016 // TrySend fail
1017 c <- 100
1018 ok = cv.TrySend(ValueOf(5))
1019 i := <-c
1020 if ok {
1021 t.Errorf("TrySend on full chan succeeded: value %d", i)
1022 }
1023
1024 // TrySend success
1025 ok = cv.TrySend(ValueOf(6))
1026 if !ok {
1027 t.Errorf("TrySend on empty chan failed")
1028 } else {
1029 if i = <-c; i != 6 {
1030 t.Errorf("TrySend 6, recv %d", i)
1031 }
1032 }
1033
1034 // Close
1035 c <- 123
1036 cv.Close()
1037 if i, ok := cv.Recv(); i.Int() != 123 || !ok {
1038 t.Errorf("send 123 then close; Recv %d, %t", i.Int(), ok)
1039 }
1040 if i, ok := cv.Recv(); i.Int() != 0 || ok {
1041 t.Errorf("after close Recv %d, %t", i.Int(), ok)
1042 }
1043 }
1044
1045 // check creation of unbuffered channel
1046 var c chan int
1047 cv := MakeChan(TypeOf(c), 0)
1048 c = cv.Interface().(chan int)
1049 if cv.TrySend(ValueOf(7)) {
1050 t.Errorf("TrySend on sync chan succeeded")
1051 }
1052 if v, ok := cv.TryRecv(); v.IsValid() || ok {
1053 t.Errorf("TryRecv on sync chan succeeded: isvalid=%v ok=%v", v.IsValid(), ok)
1054 }
1055
1056 // len/cap
1057 cv = MakeChan(TypeOf(c), 10)
1058 c = cv.Interface().(chan int)
1059 for i := 0; i < 3; i++ {
1060 c <- i
1061 }
1062 if l, m := cv.Len(), cv.Cap(); l != len(c) || m != cap(c) {
1063 t.Errorf("Len/Cap = %d/%d want %d/%d", l, m, len(c), cap(c))
1064 }
1065 }
1066
1067 // caseInfo describes a single case in a select test.
1068 type caseInfo struct {
1069 desc string
1070 canSelect bool
1071 recv Value
1072 closed bool
1073 helper func()
1074 panic bool
1075 }
1076
1077 var allselect = flag.Bool("allselect", false, "exhaustive select test")
1078
1079 func TestSelect(t *testing.T) {
1080 selectWatch.once.Do(func() { go selectWatcher() })
1081
1082 var x exhaustive
1083 nch := 0
1084 newop := func(n int, cap int) (ch, val Value) {
1085 nch++
1086 if nch%101%2 == 1 {
1087 c := make(chan int, cap)
1088 ch = ValueOf(c)
1089 val = ValueOf(n)
1090 } else {
1091 c := make(chan string, cap)
1092 ch = ValueOf(c)
1093 val = ValueOf(fmt.Sprint(n))
1094 }
1095 return
1096 }
1097
1098 for n := 0; x.Next(); n++ {
1099 if testing.Short() && n >= 1000 {
1100 break
1101 }
1102 if n >= 100000 && !*allselect {
1103 break
1104 }
1105 if n%100000 == 0 && testing.Verbose() {
1106 println("TestSelect", n)
1107 }
1108 var cases []SelectCase
1109 var info []caseInfo
1110
1111 // Ready send.
1112 if x.Maybe() {
1113 ch, val := newop(len(cases), 1)
1114 cases = append(cases, SelectCase{
1115 Dir: SelectSend,
1116 Chan: ch,
1117 Send: val,
1118 })
1119 info = append(info, caseInfo{desc: "ready send", canSelect: true})
1120 }
1121
1122 // Ready recv.
1123 if x.Maybe() {
1124 ch, val := newop(len(cases), 1)
1125 ch.Send(val)
1126 cases = append(cases, SelectCase{
1127 Dir: SelectRecv,
1128 Chan: ch,
1129 })
1130 info = append(info, caseInfo{desc: "ready recv", canSelect: true, recv: val})
1131 }
1132
1133 // Blocking send.
1134 if x.Maybe() {
1135 ch, val := newop(len(cases), 0)
1136 cases = append(cases, SelectCase{
1137 Dir: SelectSend,
1138 Chan: ch,
1139 Send: val,
1140 })
1141 // Let it execute?
1142 if x.Maybe() {
1143 f := func() { ch.Recv() }
1144 info = append(info, caseInfo{desc: "blocking send", helper: f})
1145 } else {
1146 info = append(info, caseInfo{desc: "blocking send"})
1147 }
1148 }
1149
1150 // Blocking recv.
1151 if x.Maybe() {
1152 ch, val := newop(len(cases), 0)
1153 cases = append(cases, SelectCase{
1154 Dir: SelectRecv,
1155 Chan: ch,
1156 })
1157 // Let it execute?
1158 if x.Maybe() {
1159 f := func() { ch.Send(val) }
1160 info = append(info, caseInfo{desc: "blocking recv", recv: val, helper: f})
1161 } else {
1162 info = append(info, caseInfo{desc: "blocking recv"})
1163 }
1164 }
1165
1166 // Zero Chan send.
1167 if x.Maybe() {
1168 // Maybe include value to send.
1169 var val Value
1170 if x.Maybe() {
1171 val = ValueOf(100)
1172 }
1173 cases = append(cases, SelectCase{
1174 Dir: SelectSend,
1175 Send: val,
1176 })
1177 info = append(info, caseInfo{desc: "zero Chan send"})
1178 }
1179
1180 // Zero Chan receive.
1181 if x.Maybe() {
1182 cases = append(cases, SelectCase{
1183 Dir: SelectRecv,
1184 })
1185 info = append(info, caseInfo{desc: "zero Chan recv"})
1186 }
1187
1188 // nil Chan send.
1189 if x.Maybe() {
1190 cases = append(cases, SelectCase{
1191 Dir: SelectSend,
1192 Chan: ValueOf((chan int)(nil)),
1193 Send: ValueOf(101),
1194 })
1195 info = append(info, caseInfo{desc: "nil Chan send"})
1196 }
1197
1198 // nil Chan recv.
1199 if x.Maybe() {
1200 cases = append(cases, SelectCase{
1201 Dir: SelectRecv,
1202 Chan: ValueOf((chan int)(nil)),
1203 })
1204 info = append(info, caseInfo{desc: "nil Chan recv"})
1205 }
1206
1207 // closed Chan send.
1208 if x.Maybe() {
1209 ch := make(chan int)
1210 close(ch)
1211 cases = append(cases, SelectCase{
1212 Dir: SelectSend,
1213 Chan: ValueOf(ch),
1214 Send: ValueOf(101),
1215 })
1216 info = append(info, caseInfo{desc: "closed Chan send", canSelect: true, panic: true})
1217 }
1218
1219 // closed Chan recv.
1220 if x.Maybe() {
1221 ch, val := newop(len(cases), 0)
1222 ch.Close()
1223 val = Zero(val.Type())
1224 cases = append(cases, SelectCase{
1225 Dir: SelectRecv,
1226 Chan: ch,
1227 })
1228 info = append(info, caseInfo{desc: "closed Chan recv", canSelect: true, closed: true, recv: val})
1229 }
1230
1231 var helper func() // goroutine to help the select complete
1232
1233 // Add default? Must be last case here, but will permute.
1234 // Add the default if the select would otherwise
1235 // block forever, and maybe add it anyway.
1236 numCanSelect := 0
1237 canProceed := false
1238 canBlock := true
1239 canPanic := false
1240 helpers := []int{}
1241 for i, c := range info {
1242 if c.canSelect {
1243 canProceed = true
1244 canBlock = false
1245 numCanSelect++
1246 if c.panic {
1247 canPanic = true
1248 }
1249 } else if c.helper != nil {
1250 canProceed = true
1251 helpers = append(helpers, i)
1252 }
1253 }
1254 if !canProceed || x.Maybe() {
1255 cases = append(cases, SelectCase{
1256 Dir: SelectDefault,
1257 })
1258 info = append(info, caseInfo{desc: "default", canSelect: canBlock})
1259 numCanSelect++
1260 } else if canBlock {
1261 // Select needs to communicate with another goroutine.
1262 cas := &info[helpers[x.Choose(len(helpers))]]
1263 helper = cas.helper
1264 cas.canSelect = true
1265 numCanSelect++
1266 }
1267
1268 // Permute cases and case info.
1269 // Doing too much here makes the exhaustive loop
1270 // too exhausting, so just do two swaps.
1271 for loop := 0; loop < 2; loop++ {
1272 i := x.Choose(len(cases))
1273 j := x.Choose(len(cases))
1274 cases[i], cases[j] = cases[j], cases[i]
1275 info[i], info[j] = info[j], info[i]
1276 }
1277
1278 if helper != nil {
1279 // We wait before kicking off a goroutine to satisfy a blocked select.
1280 // The pause needs to be big enough to let the select block before
1281 // we run the helper, but if we lose that race once in a while it's okay: the
1282 // select will just proceed immediately. Not a big deal.
1283 // For short tests we can grow [sic] the timeout a bit without fear of taking too long
1284 pause := 10 * time.Microsecond
1285 if testing.Short() {
1286 pause = 100 * time.Microsecond
1287 }
1288 time.AfterFunc(pause, helper)
1289 }
1290
1291 // Run select.
1292 i, recv, recvOK, panicErr := runSelect(cases, info)
1293 if panicErr != nil && !canPanic {
1294 t.Fatalf("%s\npanicked unexpectedly: %v", fmtSelect(info), panicErr)
1295 }
1296 if panicErr == nil && canPanic && numCanSelect == 1 {
1297 t.Fatalf("%s\nselected #%d incorrectly (should panic)", fmtSelect(info), i)
1298 }
1299 if panicErr != nil {
1300 continue
1301 }
1302
1303 cas := info[i]
1304 if !cas.canSelect {
1305 recvStr := ""
1306 if recv.IsValid() {
1307 recvStr = fmt.Sprintf(", received %v, %v", recv.Interface(), recvOK)
1308 }
1309 t.Fatalf("%s\nselected #%d incorrectly%s", fmtSelect(info), i, recvStr)
1310 continue
1311 }
1312 if cas.panic {
1313 t.Fatalf("%s\nselected #%d incorrectly (case should panic)", fmtSelect(info), i)
1314 continue
1315 }
1316
1317 if cases[i].Dir == SelectRecv {
1318 if !recv.IsValid() {
1319 t.Fatalf("%s\nselected #%d but got %v, %v, want %v, %v", fmtSelect(info), i, recv, recvOK, cas.recv.Interface(), !cas.closed)
1320 }
1321 if !cas.recv.IsValid() {
1322 t.Fatalf("%s\nselected #%d but internal error: missing recv value", fmtSelect(info), i)
1323 }
1324 if recv.Interface() != cas.recv.Interface() || recvOK != !cas.closed {
1325 if recv.Interface() == cas.recv.Interface() && recvOK == !cas.closed {
1326 t.Fatalf("%s\nselected #%d, got %#v, %v, and DeepEqual is broken on %T", fmtSelect(info), i, recv.Interface(), recvOK, recv.Interface())
1327 }
1328 t.Fatalf("%s\nselected #%d but got %#v, %v, want %#v, %v", fmtSelect(info), i, recv.Interface(), recvOK, cas.recv.Interface(), !cas.closed)
1329 }
1330 } else {
1331 if recv.IsValid() || recvOK {
1332 t.Fatalf("%s\nselected #%d but got %v, %v, want %v, %v", fmtSelect(info), i, recv, recvOK, Value{}, false)
1333 }
1334 }
1335 }
1336 }
1337
1338 // selectWatch and the selectWatcher are a watchdog mechanism for running Select.
1339 // If the selectWatcher notices that the select has been blocked for >1 second, it prints
1340 // an error describing the select and panics the entire test binary.
1341 var selectWatch struct {
1342 sync.Mutex
1343 once sync.Once
1344 now time.Time
1345 info []caseInfo
1346 }
1347
1348 func selectWatcher() {
1349 for {
1350 time.Sleep(1 * time.Second)
1351 selectWatch.Lock()
1352 if selectWatch.info != nil && time.Since(selectWatch.now) > 1*time.Second {
1353 fmt.Fprintf(os.Stderr, "TestSelect:\n%s blocked indefinitely\n", fmtSelect(selectWatch.info))
1354 panic("select stuck")
1355 }
1356 selectWatch.Unlock()
1357 }
1358 }
1359
1360 // runSelect runs a single select test.
1361 // It returns the values returned by Select but also returns
1362 // a panic value if the Select panics.
1363 func runSelect(cases []SelectCase, info []caseInfo) (chosen int, recv Value, recvOK bool, panicErr interface{}) {
1364 defer func() {
1365 panicErr = recover()
1366
1367 selectWatch.Lock()
1368 selectWatch.info = nil
1369 selectWatch.Unlock()
1370 }()
1371
1372 selectWatch.Lock()
1373 selectWatch.now = time.Now()
1374 selectWatch.info = info
1375 selectWatch.Unlock()
1376
1377 chosen, recv, recvOK = Select(cases)
1378 return
1379 }
1380
1381 // fmtSelect formats the information about a single select test.
1382 func fmtSelect(info []caseInfo) string {
1383 var buf bytes.Buffer
1384 fmt.Fprintf(&buf, "\nselect {\n")
1385 for i, cas := range info {
1386 fmt.Fprintf(&buf, "%d: %s", i, cas.desc)
1387 if cas.recv.IsValid() {
1388 fmt.Fprintf(&buf, " val=%#v", cas.recv.Interface())
1389 }
1390 if cas.canSelect {
1391 fmt.Fprintf(&buf, " canselect")
1392 }
1393 if cas.panic {
1394 fmt.Fprintf(&buf, " panic")
1395 }
1396 fmt.Fprintf(&buf, "\n")
1397 }
1398 fmt.Fprintf(&buf, "}")
1399 return buf.String()
1400 }
1401
1402 type two [2]uintptr
1403
1404 // Difficult test for function call because of
1405 // implicit padding between arguments.
1406 func dummy(b byte, c int, d byte, e two, f byte, g float32, h byte) (i byte, j int, k byte, l two, m byte, n float32, o byte) {
1407 return b, c, d, e, f, g, h
1408 }
1409
1410 func TestFunc(t *testing.T) {
1411 ret := ValueOf(dummy).Call([]Value{
1412 ValueOf(byte(10)),
1413 ValueOf(20),
1414 ValueOf(byte(30)),
1415 ValueOf(two{40, 50}),
1416 ValueOf(byte(60)),
1417 ValueOf(float32(70)),
1418 ValueOf(byte(80)),
1419 })
1420 if len(ret) != 7 {
1421 t.Fatalf("Call returned %d values, want 7", len(ret))
1422 }
1423
1424 i := byte(ret[0].Uint())
1425 j := int(ret[1].Int())
1426 k := byte(ret[2].Uint())
1427 l := ret[3].Interface().(two)
1428 m := byte(ret[4].Uint())
1429 n := float32(ret[5].Float())
1430 o := byte(ret[6].Uint())
1431
1432 if i != 10 || j != 20 || k != 30 || l != (two{40, 50}) || m != 60 || n != 70 || o != 80 {
1433 t.Errorf("Call returned %d, %d, %d, %v, %d, %g, %d; want 10, 20, 30, [40, 50], 60, 70, 80", i, j, k, l, m, n, o)
1434 }
1435 }
1436
1437 func TestMakeFunc(t *testing.T) {
1438 switch runtime.GOARCH {
1439 case "amd64", "386":
1440 default:
1441 t.Skip("MakeFunc not implemented for " + runtime.GOARCH)
1442 }
1443
1444 f := dummy
1445 fv := MakeFunc(TypeOf(f), func(in []Value) []Value { return in })
1446 ValueOf(&f).Elem().Set(fv)
1447
1448 // Call g with small arguments so that there is
1449 // something predictable (and different from the
1450 // correct results) in those positions on the stack.
1451 g := dummy
1452 g(1, 2, 3, two{4, 5}, 6, 7, 8)
1453
1454 // Call constructed function f.
1455 i, j, k, l, m, n, o := f(10, 20, 30, two{40, 50}, 60, 70, 80)
1456 if i != 10 || j != 20 || k != 30 || l != (two{40, 50}) || m != 60 || n != 70 || o != 80 {
1457 t.Errorf("Call returned %d, %d, %d, %v, %d, %g, %d; want 10, 20, 30, [40, 50], 60, 70, 80", i, j, k, l, m, n, o)
1458 }
1459 }
1460
1461 func TestMakeFuncInterface(t *testing.T) {
1462 switch runtime.GOARCH {
1463 case "amd64", "386":
1464 default:
1465 t.Skip("MakeFunc not implemented for " + runtime.GOARCH)
1466 }
1467
1468 fn := func(i int) int { return i }
1469 incr := func(in []Value) []Value {
1470 return []Value{ValueOf(int(in[0].Int() + 1))}
1471 }
1472 fv := MakeFunc(TypeOf(fn), incr)
1473 ValueOf(&fn).Elem().Set(fv)
1474 if r := fn(2); r != 3 {
1475 t.Errorf("Call returned %d, want 3", r)
1476 }
1477 if r := fv.Call([]Value{ValueOf(14)})[0].Int(); r != 15 {
1478 t.Errorf("Call returned %d, want 15", r)
1479 }
1480 if r := fv.Interface().(func(int) int)(26); r != 27 {
1481 t.Errorf("Call returned %d, want 27", r)
1482 }
1483 }
1484
1485 type Point struct {
1486 x, y int
1487 }
1488
1489 // This will be index 0.
1490 func (p Point) AnotherMethod(scale int) int {
1491 return -1
1492 }
1493
1494 // This will be index 1.
1495 func (p Point) Dist(scale int) int {
1496 //println("Point.Dist", p.x, p.y, scale)
1497 return p.x*p.x*scale + p.y*p.y*scale
1498 }
1499
1500 func TestMethod(t *testing.T) {
1501 // Non-curried method of type.
1502 p := Point{3, 4}
1503 i := TypeOf(p).Method(1).Func.Call([]Value{ValueOf(p), ValueOf(10)})[0].Int()
1504 if i != 250 {
1505 t.Errorf("Type Method returned %d; want 250", i)
1506 }
1507
1508 m, ok := TypeOf(p).MethodByName("Dist")
1509 if !ok {
1510 t.Fatalf("method by name failed")
1511 }
1512 i = m.Func.Call([]Value{ValueOf(p), ValueOf(11)})[0].Int()
1513 if i != 275 {
1514 t.Errorf("Type MethodByName returned %d; want 275", i)
1515 }
1516
1517 i = TypeOf(&p).Method(1).Func.Call([]Value{ValueOf(&p), ValueOf(12)})[0].Int()
1518 if i != 300 {
1519 t.Errorf("Pointer Type Method returned %d; want 300", i)
1520 }
1521
1522 m, ok = TypeOf(&p).MethodByName("Dist")
1523 if !ok {
1524 t.Fatalf("ptr method by name failed")
1525 }
1526 i = m.Func.Call([]Value{ValueOf(&p), ValueOf(13)})[0].Int()
1527 if i != 325 {
1528 t.Errorf("Pointer Type MethodByName returned %d; want 325", i)
1529 }
1530
1531 // Curried method of value.
1532 tfunc := TypeOf((func(int) int)(nil))
1533 v := ValueOf(p).Method(1)
1534 if tt := v.Type(); tt != tfunc {
1535 t.Errorf("Value Method Type is %s; want %s", tt, tfunc)
1536 }
1537 i = v.Call([]Value{ValueOf(14)})[0].Int()
1538 if i != 350 {
1539 t.Errorf("Value Method returned %d; want 350", i)
1540 }
1541 v = ValueOf(p).MethodByName("Dist")
1542 if tt := v.Type(); tt != tfunc {
1543 t.Errorf("Value MethodByName Type is %s; want %s", tt, tfunc)
1544 }
1545 i = v.Call([]Value{ValueOf(15)})[0].Int()
1546 if i != 375 {
1547 t.Errorf("Value MethodByName returned %d; want 375", i)
1548 }
1549
1550 // Curried method of pointer.
1551 v = ValueOf(&p).Method(1)
1552 if tt := v.Type(); tt != tfunc {
1553 t.Errorf("Pointer Value Method Type is %s; want %s", tt, tfunc)
1554 }
1555 i = v.Call([]Value{ValueOf(16)})[0].Int()
1556 if i != 400 {
1557 t.Errorf("Pointer Value Method returned %d; want 400", i)
1558 }
1559 v = ValueOf(&p).MethodByName("Dist")
1560 if tt := v.Type(); tt != tfunc {
1561 t.Errorf("Pointer Value MethodByName Type is %s; want %s", tt, tfunc)
1562 }
1563 i = v.Call([]Value{ValueOf(17)})[0].Int()
1564 if i != 425 {
1565 t.Errorf("Pointer Value MethodByName returned %d; want 425", i)
1566 }
1567
1568 // Curried method of interface value.
1569 // Have to wrap interface value in a struct to get at it.
1570 // Passing it to ValueOf directly would
1571 // access the underlying Point, not the interface.
1572 var x interface {
1573 Dist(int) int
1574 } = p
1575 pv := ValueOf(&x).Elem()
1576 v = pv.Method(0)
1577 if tt := v.Type(); tt != tfunc {
1578 t.Errorf("Interface Method Type is %s; want %s", tt, tfunc)
1579 }
1580 i = v.Call([]Value{ValueOf(18)})[0].Int()
1581 if i != 450 {
1582 t.Errorf("Interface Method returned %d; want 450", i)
1583 }
1584 v = pv.MethodByName("Dist")
1585 if tt := v.Type(); tt != tfunc {
1586 t.Errorf("Interface MethodByName Type is %s; want %s", tt, tfunc)
1587 }
1588 i = v.Call([]Value{ValueOf(19)})[0].Int()
1589 if i != 475 {
1590 t.Errorf("Interface MethodByName returned %d; want 475", i)
1591 }
1592 }
1593
1594 /* Not yet implemented for gccgo
1595
1596 func TestMethodValue(t *testing.T) {
1597 p := Point{3, 4}
1598 var i int64
1599
1600 // Curried method of value.
1601 tfunc := TypeOf((func(int) int)(nil))
1602 v := ValueOf(p).Method(1)
1603 if tt := v.Type(); tt != tfunc {
1604 t.Errorf("Value Method Type is %s; want %s", tt, tfunc)
1605 }
1606 i = ValueOf(v.Interface()).Call([]Value{ValueOf(10)})[0].Int()
1607 if i != 250 {
1608 t.Errorf("Value Method returned %d; want 250", i)
1609 }
1610 v = ValueOf(p).MethodByName("Dist")
1611 if tt := v.Type(); tt != tfunc {
1612 t.Errorf("Value MethodByName Type is %s; want %s", tt, tfunc)
1613 }
1614 i = ValueOf(v.Interface()).Call([]Value{ValueOf(11)})[0].Int()
1615 if i != 275 {
1616 t.Errorf("Value MethodByName returned %d; want 275", i)
1617 }
1618
1619 // Curried method of pointer.
1620 v = ValueOf(&p).Method(1)
1621 if tt := v.Type(); tt != tfunc {
1622 t.Errorf("Pointer Value Method Type is %s; want %s", tt, tfunc)
1623 }
1624 i = ValueOf(v.Interface()).Call([]Value{ValueOf(12)})[0].Int()
1625 if i != 300 {
1626 t.Errorf("Pointer Value Method returned %d; want 300", i)
1627 }
1628 v = ValueOf(&p).MethodByName("Dist")
1629 if tt := v.Type(); tt != tfunc {
1630 t.Errorf("Pointer Value MethodByName Type is %s; want %s", tt, tfunc)
1631 }
1632 i = ValueOf(v.Interface()).Call([]Value{ValueOf(13)})[0].Int()
1633 if i != 325 {
1634 t.Errorf("Pointer Value MethodByName returned %d; want 325", i)
1635 }
1636
1637 // Curried method of pointer to pointer.
1638 pp := &p
1639 v = ValueOf(&pp).Elem().Method(1)
1640 if tt := v.Type(); tt != tfunc {
1641 t.Errorf("Pointer Pointer Value Method Type is %s; want %s", tt, tfunc)
1642 }
1643 i = ValueOf(v.Interface()).Call([]Value{ValueOf(14)})[0].Int()
1644 if i != 350 {
1645 t.Errorf("Pointer Pointer Value Method returned %d; want 350", i)
1646 }
1647 v = ValueOf(&pp).Elem().MethodByName("Dist")
1648 if tt := v.Type(); tt != tfunc {
1649 t.Errorf("Pointer Pointer Value MethodByName Type is %s; want %s", tt, tfunc)
1650 }
1651 i = ValueOf(v.Interface()).Call([]Value{ValueOf(15)})[0].Int()
1652 if i != 375 {
1653 t.Errorf("Pointer Pointer Value MethodByName returned %d; want 375", i)
1654 }
1655
1656 // Curried method of interface value.
1657 // Have to wrap interface value in a struct to get at it.
1658 // Passing it to ValueOf directly would
1659 // access the underlying Point, not the interface.
1660 var s = struct {
1661 X interface {
1662 Dist(int) int
1663 }
1664 }{p}
1665 pv := ValueOf(s).Field(0)
1666 v = pv.Method(0)
1667 if tt := v.Type(); tt != tfunc {
1668 t.Errorf("Interface Method Type is %s; want %s", tt, tfunc)
1669 }
1670 i = ValueOf(v.Interface()).Call([]Value{ValueOf(16)})[0].Int()
1671 if i != 400 {
1672 t.Errorf("Interface Method returned %d; want 400", i)
1673 }
1674 v = pv.MethodByName("Dist")
1675 if tt := v.Type(); tt != tfunc {
1676 t.Errorf("Interface MethodByName Type is %s; want %s", tt, tfunc)
1677 }
1678 i = ValueOf(v.Interface()).Call([]Value{ValueOf(17)})[0].Int()
1679 if i != 425 {
1680 t.Errorf("Interface MethodByName returned %d; want 425", i)
1681 }
1682 }
1683
1684 */
1685
1686 // Reflect version of $GOROOT/test/method5.go
1687
1688 // Concrete types implementing M method.
1689 // Smaller than a word, word-sized, larger than a word.
1690 // Value and pointer receivers.
1691
1692 type Tinter interface {
1693 M(int, byte) (byte, int)
1694 }
1695
1696 type Tsmallv byte
1697
1698 func (v Tsmallv) M(x int, b byte) (byte, int) { return b, x + int(v) }
1699
1700 type Tsmallp byte
1701
1702 func (p *Tsmallp) M(x int, b byte) (byte, int) { return b, x + int(*p) }
1703
1704 type Twordv uintptr
1705
1706 func (v Twordv) M(x int, b byte) (byte, int) { return b, x + int(v) }
1707
1708 type Twordp uintptr
1709
1710 func (p *Twordp) M(x int, b byte) (byte, int) { return b, x + int(*p) }
1711
1712 type Tbigv [2]uintptr
1713
1714 func (v Tbigv) M(x int, b byte) (byte, int) { return b, x + int(v[0]) + int(v[1]) }
1715
1716 type Tbigp [2]uintptr
1717
1718 func (p *Tbigp) M(x int, b byte) (byte, int) { return b, x + int(p[0]) + int(p[1]) }
1719
1720 // Again, with an unexported method.
1721
1722 type tsmallv byte
1723
1724 func (v tsmallv) m(x int, b byte) (byte, int) { return b, x + int(v) }
1725
1726 type tsmallp byte
1727
1728 func (p *tsmallp) m(x int, b byte) (byte, int) { return b, x + int(*p) }
1729
1730 type twordv uintptr
1731
1732 func (v twordv) m(x int, b byte) (byte, int) { return b, x + int(v) }
1733
1734 type twordp uintptr
1735
1736 func (p *twordp) m(x int, b byte) (byte, int) { return b, x + int(*p) }
1737
1738 type tbigv [2]uintptr
1739
1740 func (v tbigv) m(x int, b byte) (byte, int) { return b, x + int(v[0]) + int(v[1]) }
1741
1742 type tbigp [2]uintptr
1743
1744 func (p *tbigp) m(x int, b byte) (byte, int) { return b, x + int(p[0]) + int(p[1]) }
1745
1746 type tinter interface {
1747 m(int, byte) (byte, int)
1748 }
1749
1750 // Embedding via pointer.
1751
1752 type Tm1 struct {
1753 Tm2
1754 }
1755
1756 type Tm2 struct {
1757 *Tm3
1758 }
1759
1760 type Tm3 struct {
1761 *Tm4
1762 }
1763
1764 type Tm4 struct {
1765 }
1766
1767 func (t4 Tm4) M(x int, b byte) (byte, int) { return b, x + 40 }
1768
1769 func TestMethod5(t *testing.T) {
1770 /* Not yet used for gccgo
1771 CheckF := func(name string, f func(int, byte) (byte, int), inc int) {
1772 b, x := f(1000, 99)
1773 if b != 99 || x != 1000+inc {
1774 t.Errorf("%s(1000, 99) = %v, %v, want 99, %v", name, b, x, 1000+inc)
1775 }
1776 }
1777 */
1778
1779 CheckV := func(name string, i Value, inc int) {
1780 bx := i.Method(0).Call([]Value{ValueOf(1000), ValueOf(byte(99))})
1781 b := bx[0].Interface()
1782 x := bx[1].Interface()
1783 if b != byte(99) || x != 1000+inc {
1784 t.Errorf("direct %s.M(1000, 99) = %v, %v, want 99, %v", name, b, x, 1000+inc)
1785 }
1786
1787 /* Not yet implemented for gccgo
1788 CheckF(name+".M", i.Method(0).Interface().(func(int, byte) (byte, int)), inc)
1789 */
1790 }
1791
1792 var TinterType = TypeOf(new(Tinter)).Elem()
1793 var tinterType = TypeOf(new(tinter)).Elem()
1794
1795 CheckI := func(name string, i interface{}, inc int) {
1796 v := ValueOf(i)
1797 CheckV(name, v, inc)
1798 CheckV("(i="+name+")", v.Convert(TinterType), inc)
1799 }
1800
1801 sv := Tsmallv(1)
1802 CheckI("sv", sv, 1)
1803 CheckI("&sv", &sv, 1)
1804
1805 sp := Tsmallp(2)
1806 CheckI("&sp", &sp, 2)
1807
1808 wv := Twordv(3)
1809 CheckI("wv", wv, 3)
1810 CheckI("&wv", &wv, 3)
1811
1812 wp := Twordp(4)
1813 CheckI("&wp", &wp, 4)
1814
1815 bv := Tbigv([2]uintptr{5, 6})
1816 CheckI("bv", bv, 11)
1817 CheckI("&bv", &bv, 11)
1818
1819 bp := Tbigp([2]uintptr{7, 8})
1820 CheckI("&bp", &bp, 15)
1821
1822 t4 := Tm4{}
1823 t3 := Tm3{&t4}
1824 t2 := Tm2{&t3}
1825 t1 := Tm1{t2}
1826 CheckI("t4", t4, 40)
1827 CheckI("&t4", &t4, 40)
1828 CheckI("t3", t3, 40)
1829 CheckI("&t3", &t3, 40)
1830 CheckI("t2", t2, 40)
1831 CheckI("&t2", &t2, 40)
1832 CheckI("t1", t1, 40)
1833 CheckI("&t1", &t1, 40)
1834
1835 methodShouldPanic := func(name string, i interface{}) {
1836 v := ValueOf(i)
1837 m := v.Method(0)
1838 shouldPanic(func() { m.Call([]Value{ValueOf(1000), ValueOf(byte(99))}) })
1839 shouldPanic(func() { m.Interface() })
1840
1841 v = v.Convert(tinterType)
1842 m = v.Method(0)
1843 shouldPanic(func() { m.Call([]Value{ValueOf(1000), ValueOf(byte(99))}) })
1844 shouldPanic(func() { m.Interface() })
1845 }
1846
1847 _sv := tsmallv(1)
1848 methodShouldPanic("_sv", _sv)
1849 methodShouldPanic("&_sv", &_sv)
1850
1851 _sp := tsmallp(2)
1852 methodShouldPanic("&_sp", &_sp)
1853
1854 _wv := twordv(3)
1855 methodShouldPanic("_wv", _wv)
1856 methodShouldPanic("&_wv", &_wv)
1857
1858 _wp := twordp(4)
1859 methodShouldPanic("&_wp", &_wp)
1860
1861 _bv := tbigv([2]uintptr{5, 6})
1862 methodShouldPanic("_bv", _bv)
1863 methodShouldPanic("&_bv", &_bv)
1864
1865 _bp := tbigp([2]uintptr{7, 8})
1866 methodShouldPanic("&_bp", &_bp)
1867
1868 var tnil Tinter
1869 vnil := ValueOf(&tnil).Elem()
1870 shouldPanic(func() { vnil.Method(0) })
1871 }
1872
1873 func TestInterfaceSet(t *testing.T) {
1874 p := &Point{3, 4}
1875
1876 var s struct {
1877 I interface{}
1878 P interface {
1879 Dist(int) int
1880 }
1881 }
1882 sv := ValueOf(&s).Elem()
1883 sv.Field(0).Set(ValueOf(p))
1884 if q := s.I.(*Point); q != p {
1885 t.Errorf("i: have %p want %p", q, p)
1886 }
1887
1888 pv := sv.Field(1)
1889 pv.Set(ValueOf(p))
1890 if q := s.P.(*Point); q != p {
1891 t.Errorf("i: have %p want %p", q, p)
1892 }
1893
1894 i := pv.Method(0).Call([]Value{ValueOf(10)})[0].Int()
1895 if i != 250 {
1896 t.Errorf("Interface Method returned %d; want 250", i)
1897 }
1898 }
1899
1900 type T1 struct {
1901 a string
1902 int
1903 }
1904
1905 func TestAnonymousFields(t *testing.T) {
1906 var field StructField
1907 var ok bool
1908 var t1 T1
1909 type1 := TypeOf(t1)
1910 if field, ok = type1.FieldByName("int"); !ok {
1911 t.Fatal("no field 'int'")
1912 }
1913 if field.Index[0] != 1 {
1914 t.Error("field index should be 1; is", field.Index)
1915 }
1916 }
1917
1918 type FTest struct {
1919 s interface{}
1920 name string
1921 index []int
1922 value int
1923 }
1924
1925 type D1 struct {
1926 d int
1927 }
1928 type D2 struct {
1929 d int
1930 }
1931
1932 type S0 struct {
1933 A, B, C int
1934 D1
1935 D2
1936 }
1937
1938 type S1 struct {
1939 B int
1940 S0
1941 }
1942
1943 type S2 struct {
1944 A int
1945 *S1
1946 }
1947
1948 type S1x struct {
1949 S1
1950 }
1951
1952 type S1y struct {
1953 S1
1954 }
1955
1956 type S3 struct {
1957 S1x
1958 S2
1959 D, E int
1960 *S1y
1961 }
1962
1963 type S4 struct {
1964 *S4
1965 A int
1966 }
1967
1968 // The X in S6 and S7 annihilate, but they also block the X in S8.S9.
1969 type S5 struct {
1970 S6
1971 S7
1972 S8
1973 }
1974
1975 type S6 struct {
1976 X int
1977 }
1978
1979 type S7 S6
1980
1981 type S8 struct {
1982 S9
1983 }
1984
1985 type S9 struct {
1986 X int
1987 Y int
1988 }
1989
1990 // The X in S11.S6 and S12.S6 annihilate, but they also block the X in S13.S8.S9.
1991 type S10 struct {
1992 S11
1993 S12
1994 S13
1995 }
1996
1997 type S11 struct {
1998 S6
1999 }
2000
2001 type S12 struct {
2002 S6
2003 }
2004
2005 type S13 struct {
2006 S8
2007 }
2008
2009 // The X in S15.S11.S1 and S16.S11.S1 annihilate.
2010 type S14 struct {
2011 S15
2012 S16
2013 }
2014
2015 type S15 struct {
2016 S11
2017 }
2018
2019 type S16 struct {
2020 S11
2021 }
2022
2023 var fieldTests = []FTest{
2024 {struct{}{}, "", nil, 0},
2025 {struct{}{}, "Foo", nil, 0},
2026 {S0{A: 'a'}, "A", []int{0}, 'a'},
2027 {S0{}, "D", nil, 0},
2028 {S1{S0: S0{A: 'a'}}, "A", []int{1, 0}, 'a'},
2029 {S1{B: 'b'}, "B", []int{0}, 'b'},
2030 {S1{}, "S0", []int{1}, 0},
2031 {S1{S0: S0{C: 'c'}}, "C", []int{1, 2}, 'c'},
2032 {S2{A: 'a'}, "A", []int{0}, 'a'},
2033 {S2{}, "S1", []int{1}, 0},
2034 {S2{S1: &S1{B: 'b'}}, "B", []int{1, 0}, 'b'},
2035 {S2{S1: &S1{S0: S0{C: 'c'}}}, "C", []int{1, 1, 2}, 'c'},
2036 {S2{}, "D", nil, 0},
2037 {S3{}, "S1", nil, 0},
2038 {S3{S2: S2{A: 'a'}}, "A", []int{1, 0}, 'a'},
2039 {S3{}, "B", nil, 0},
2040 {S3{D: 'd'}, "D", []int{2}, 0},
2041 {S3{E: 'e'}, "E", []int{3}, 'e'},
2042 {S4{A: 'a'}, "A", []int{1}, 'a'},
2043 {S4{}, "B", nil, 0},
2044 {S5{}, "X", nil, 0},
2045 {S5{}, "Y", []int{2, 0, 1}, 0},
2046 {S10{}, "X", nil, 0},
2047 {S10{}, "Y", []int{2, 0, 0, 1}, 0},
2048 {S14{}, "X", nil, 0},
2049 }
2050
2051 func TestFieldByIndex(t *testing.T) {
2052 for _, test := range fieldTests {
2053 s := TypeOf(test.s)
2054 f := s.FieldByIndex(test.index)
2055 if f.Name != "" {
2056 if test.index != nil {
2057 if f.Name != test.name {
2058 t.Errorf("%s.%s found; want %s", s.Name(), f.Name, test.name)
2059 }
2060 } else {
2061 t.Errorf("%s.%s found", s.Name(), f.Name)
2062 }
2063 } else if len(test.index) > 0 {
2064 t.Errorf("%s.%s not found", s.Name(), test.name)
2065 }
2066
2067 if test.value != 0 {
2068 v := ValueOf(test.s).FieldByIndex(test.index)
2069 if v.IsValid() {
2070 if x, ok := v.Interface().(int); ok {
2071 if x != test.value {
2072 t.Errorf("%s%v is %d; want %d", s.Name(), test.index, x, test.value)
2073 }
2074 } else {
2075 t.Errorf("%s%v value not an int", s.Name(), test.index)
2076 }
2077 } else {
2078 t.Errorf("%s%v value not found", s.Name(), test.index)
2079 }
2080 }
2081 }
2082 }
2083
2084 func TestFieldByName(t *testing.T) {
2085 for _, test := range fieldTests {
2086 s := TypeOf(test.s)
2087 f, found := s.FieldByName(test.name)
2088 if found {
2089 if test.index != nil {
2090 // Verify field depth and index.
2091 if len(f.Index) != len(test.index) {
2092 t.Errorf("%s.%s depth %d; want %d: %v vs %v", s.Name(), test.name, len(f.Index), len(test.index), f.Index, test.index)
2093 } else {
2094 for i, x := range f.Index {
2095 if x != test.index[i] {
2096 t.Errorf("%s.%s.Index[%d] is %d; want %d", s.Name(), test.name, i, x, test.index[i])
2097 }
2098 }
2099 }
2100 } else {
2101 t.Errorf("%s.%s found", s.Name(), f.Name)
2102 }
2103 } else if len(test.index) > 0 {
2104 t.Errorf("%s.%s not found", s.Name(), test.name)
2105 }
2106
2107 if test.value != 0 {
2108 v := ValueOf(test.s).FieldByName(test.name)
2109 if v.IsValid() {
2110 if x, ok := v.Interface().(int); ok {
2111 if x != test.value {
2112 t.Errorf("%s.%s is %d; want %d", s.Name(), test.name, x, test.value)
2113 }
2114 } else {
2115 t.Errorf("%s.%s value not an int", s.Name(), test.name)
2116 }
2117 } else {
2118 t.Errorf("%s.%s value not found", s.Name(), test.name)
2119 }
2120 }
2121 }
2122 }
2123
2124 func TestImportPath(t *testing.T) {
2125 tests := []struct {
2126 t Type
2127 path string
2128 }{
2129 {TypeOf(&base64.Encoding{}).Elem(), "encoding/base64"},
2130 {TypeOf(int(0)), ""},
2131 {TypeOf(int8(0)), ""},
2132 {TypeOf(int16(0)), ""},
2133 {TypeOf(int32(0)), ""},
2134 {TypeOf(int64(0)), ""},
2135 {TypeOf(uint(0)), ""},
2136 {TypeOf(uint8(0)), ""},
2137 {TypeOf(uint16(0)), ""},
2138 {TypeOf(uint32(0)), ""},
2139 {TypeOf(uint64(0)), ""},
2140 {TypeOf(uintptr(0)), ""},
2141 {TypeOf(float32(0)), ""},
2142 {TypeOf(float64(0)), ""},
2143 {TypeOf(complex64(0)), ""},
2144 {TypeOf(complex128(0)), ""},
2145 {TypeOf(byte(0)), ""},
2146 {TypeOf(rune(0)), ""},
2147 {TypeOf([]byte(nil)), ""},
2148 {TypeOf([]rune(nil)), ""},
2149 {TypeOf(string("")), ""},
2150 {TypeOf((*interface{})(nil)).Elem(), ""},
2151 {TypeOf((*byte)(nil)), ""},
2152 {TypeOf((*rune)(nil)), ""},
2153 {TypeOf((*int64)(nil)), ""},
2154 {TypeOf(map[string]int{}), ""},
2155 {TypeOf((*error)(nil)).Elem(), ""},
2156 }
2157 for _, test := range tests {
2158 if path := test.t.PkgPath(); path != test.path {
2159 t.Errorf("%v.PkgPath() = %q, want %q", test.t, path, test.path)
2160 }
2161 }
2162 }
2163
2164 func TestVariadicType(t *testing.T) {
2165 // Test example from Type documentation.
2166 var f func(x int, y ...float64)
2167 typ := TypeOf(f)
2168 if typ.NumIn() == 2 && typ.In(0) == TypeOf(int(0)) {
2169 sl := typ.In(1)
2170 if sl.Kind() == Slice {
2171 if sl.Elem() == TypeOf(0.0) {
2172 // ok
2173 return
2174 }
2175 }
2176 }
2177
2178 // Failed
2179 t.Errorf("want NumIn() = 2, In(0) = int, In(1) = []float64")
2180 s := fmt.Sprintf("have NumIn() = %d", typ.NumIn())
2181 for i := 0; i < typ.NumIn(); i++ {
2182 s += fmt.Sprintf(", In(%d) = %s", i, typ.In(i))
2183 }
2184 t.Error(s)
2185 }
2186
2187 type inner struct {
2188 x int
2189 }
2190
2191 type outer struct {
2192 y int
2193 inner
2194 }
2195
2196 func (*inner) m() {}
2197 func (*outer) m() {}
2198
2199 func TestNestedMethods(t *testing.T) {
2200 t.Skip("fails on gccgo due to function wrappers")
2201 typ := TypeOf((*outer)(nil))
2202 if typ.NumMethod() != 1 || typ.Method(0).Func.Pointer() != ValueOf((*outer).m).Pointer() {
2203 t.Errorf("Wrong method table for outer: (m=%p)", (*outer).m)
2204 for i := 0; i < typ.NumMethod(); i++ {
2205 m := typ.Method(i)
2206 t.Errorf("\t%d: %s %#x\n", i, m.Name, m.Func.Pointer())
2207 }
2208 }
2209 }
2210
2211 type InnerInt struct {
2212 X int
2213 }
2214
2215 type OuterInt struct {
2216 Y int
2217 InnerInt
2218 }
2219
2220 func (i *InnerInt) M() int {
2221 return i.X
2222 }
2223
2224 func TestEmbeddedMethods(t *testing.T) {
2225 /* This part of the test fails on gccgo due to function wrappers.
2226 typ := TypeOf((*OuterInt)(nil))
2227 if typ.NumMethod() != 1 || typ.Method(0).Func.Pointer() != ValueOf((*OuterInt).M).Pointer() {
2228 t.Errorf("Wrong method table for OuterInt: (m=%p)", (*OuterInt).M)
2229 for i := 0; i < typ.NumMethod(); i++ {
2230 m := typ.Method(i)
2231 t.Errorf("\t%d: %s %#x\n", i, m.Name, m.Func.Pointer())
2232 }
2233 }
2234 */
2235
2236 i := &InnerInt{3}
2237 if v := ValueOf(i).Method(0).Call(nil)[0].Int(); v != 3 {
2238 t.Errorf("i.M() = %d, want 3", v)
2239 }
2240
2241 o := &OuterInt{1, InnerInt{2}}
2242 if v := ValueOf(o).Method(0).Call(nil)[0].Int(); v != 2 {
2243 t.Errorf("i.M() = %d, want 2", v)
2244 }
2245
2246 f := (*OuterInt).M
2247 if v := f(o); v != 2 {
2248 t.Errorf("f(o) = %d, want 2", v)
2249 }
2250 }
2251
2252 func TestPtrTo(t *testing.T) {
2253 var i int
2254
2255 typ := TypeOf(i)
2256 for i = 0; i < 100; i++ {
2257 typ = PtrTo(typ)
2258 }
2259 for i = 0; i < 100; i++ {
2260 typ = typ.Elem()
2261 }
2262 if typ != TypeOf(i) {
2263 t.Errorf("after 100 PtrTo and Elem, have %s, want %s", typ, TypeOf(i))
2264 }
2265 }
2266
2267 func TestPtrToGC(t *testing.T) {
2268 type T *uintptr
2269 tt := TypeOf(T(nil))
2270 pt := PtrTo(tt)
2271 const n = 100
2272 var x []interface{}
2273 for i := 0; i < n; i++ {
2274 v := New(pt)
2275 p := new(*uintptr)
2276 *p = new(uintptr)
2277 **p = uintptr(i)
2278 v.Elem().Set(ValueOf(p).Convert(pt))
2279 x = append(x, v.Interface())
2280 }
2281 runtime.GC()
2282
2283 for i, xi := range x {
2284 k := ValueOf(xi).Elem().Elem().Elem().Interface().(uintptr)
2285 if k != uintptr(i) {
2286 t.Errorf("lost x[%d] = %d, want %d", i, k, i)
2287 }
2288 }
2289 }
2290
2291 func TestAddr(t *testing.T) {
2292 var p struct {
2293 X, Y int
2294 }
2295
2296 v := ValueOf(&p)
2297 v = v.Elem()
2298 v = v.Addr()
2299 v = v.Elem()
2300 v = v.Field(0)
2301 v.SetInt(2)
2302 if p.X != 2 {
2303 t.Errorf("Addr.Elem.Set failed to set value")
2304 }
2305
2306 // Again but take address of the ValueOf value.
2307 // Exercises generation of PtrTypes not present in the binary.
2308 q := &p
2309 v = ValueOf(&q).Elem()
2310 v = v.Addr()
2311 v = v.Elem()
2312 v = v.Elem()
2313 v = v.Addr()
2314 v = v.Elem()
2315 v = v.Field(0)
2316 v.SetInt(3)
2317 if p.X != 3 {
2318 t.Errorf("Addr.Elem.Set failed to set value")
2319 }
2320
2321 // Starting without pointer we should get changed value
2322 // in interface.
2323 qq := p
2324 v = ValueOf(&qq).Elem()
2325 v0 := v
2326 v = v.Addr()
2327 v = v.Elem()
2328 v = v.Field(0)
2329 v.SetInt(4)
2330 if p.X != 3 { // should be unchanged from last time
2331 t.Errorf("somehow value Set changed original p")
2332 }
2333 p = v0.Interface().(struct {
2334 X, Y int
2335 })
2336 if p.X != 4 {
2337 t.Errorf("Addr.Elem.Set valued to set value in top value")
2338 }
2339
2340 // Verify that taking the address of a type gives us a pointer
2341 // which we can convert back using the usual interface
2342 // notation.
2343 var s struct {
2344 B *bool
2345 }
2346 ps := ValueOf(&s).Elem().Field(0).Addr().Interface()
2347 *(ps.(**bool)) = new(bool)
2348 if s.B == nil {
2349 t.Errorf("Addr.Interface direct assignment failed")
2350 }
2351 }
2352
2353 /* gccgo does do allocations here.
2354
2355 func noAlloc(t *testing.T, n int, f func(int)) {
2356 if testing.Short() {
2357 t.Skip("skipping malloc count in short mode")
2358 }
2359 if runtime.GOMAXPROCS(0) > 1 {
2360 t.Skip("skipping; GOMAXPROCS>1")
2361 }
2362 i := -1
2363 allocs := testing.AllocsPerRun(n, func() {
2364 f(i)
2365 i++
2366 })
2367 if allocs > 0 {
2368 t.Errorf("%d iterations: got %v mallocs, want 0", n, allocs)
2369 }
2370 }
2371
2372 func TestAllocations(t *testing.T) {
2373 noAlloc(t, 100, func(j int) {
2374 var i interface{}
2375 var v Value
2376 i = 42 + j
2377 v = ValueOf(i)
2378 if int(v.Int()) != 42+j {
2379 panic("wrong int")
2380 }
2381 })
2382 }
2383
2384 */
2385
2386 func TestSmallNegativeInt(t *testing.T) {
2387 i := int16(-1)
2388 v := ValueOf(i)
2389 if v.Int() != -1 {
2390 t.Errorf("int16(-1).Int() returned %v", v.Int())
2391 }
2392 }
2393
2394 func TestIndex(t *testing.T) {
2395 xs := []byte{1, 2, 3, 4, 5, 6, 7, 8}
2396 v := ValueOf(xs).Index(3).Interface().(byte)
2397 if v != xs[3] {
2398 t.Errorf("xs.Index(3) = %v; expected %v", v, xs[3])
2399 }
2400 xa := [8]byte{10, 20, 30, 40, 50, 60, 70, 80}
2401 v = ValueOf(xa).Index(2).Interface().(byte)
2402 if v != xa[2] {
2403 t.Errorf("xa.Index(2) = %v; expected %v", v, xa[2])
2404 }
2405 s := "0123456789"
2406 v = ValueOf(s).Index(3).Interface().(byte)
2407 if v != s[3] {
2408 t.Errorf("s.Index(3) = %v; expected %v", v, s[3])
2409 }
2410 }
2411
2412 func TestSlice(t *testing.T) {
2413 xs := []int{1, 2, 3, 4, 5, 6, 7, 8}
2414 v := ValueOf(xs).Slice(3, 5).Interface().([]int)
2415 if len(v) != 2 {
2416 t.Errorf("len(xs.Slice(3, 5)) = %d", len(v))
2417 }
2418 if cap(v) != 5 {
2419 t.Errorf("cap(xs.Slice(3, 5)) = %d", cap(v))
2420 }
2421 if !DeepEqual(v[0:5], xs[3:]) {
2422 t.Errorf("xs.Slice(3, 5)[0:5] = %v", v[0:5])
2423 }
2424 xa := [8]int{10, 20, 30, 40, 50, 60, 70, 80}
2425 v = ValueOf(&xa).Elem().Slice(2, 5).Interface().([]int)
2426 if len(v) != 3 {
2427 t.Errorf("len(xa.Slice(2, 5)) = %d", len(v))
2428 }
2429 if cap(v) != 6 {
2430 t.Errorf("cap(xa.Slice(2, 5)) = %d", cap(v))
2431 }
2432 if !DeepEqual(v[0:6], xa[2:]) {
2433 t.Errorf("xs.Slice(2, 5)[0:6] = %v", v[0:6])
2434 }
2435 s := "0123456789"
2436 vs := ValueOf(s).Slice(3, 5).Interface().(string)
2437 if vs != s[3:5] {
2438 t.Errorf("s.Slice(3, 5) = %q; expected %q", vs, s[3:5])
2439 }
2440 }
2441
2442 func TestSlice3(t *testing.T) {
2443 xs := []int{1, 2, 3, 4, 5, 6, 7, 8}
2444 v := ValueOf(xs).Slice3(3, 5, 7).Interface().([]int)
2445 if len(v) != 2 {
2446 t.Errorf("len(xs.Slice3(3, 5, 7)) = %d", len(v))
2447 }
2448 if cap(v) != 4 {
2449 t.Errorf("cap(xs.Slice3(3, 5, 7)) = %d", cap(v))
2450 }
2451 if !DeepEqual(v[0:4], xs[3:7:7]) {
2452 t.Errorf("xs.Slice3(3, 5, 7)[0:4] = %v", v[0:4])
2453 }
2454 rv := ValueOf(&xs).Elem()
2455 shouldPanic(func() { rv.Slice3(1, 2, 1) })
2456 shouldPanic(func() { rv.Slice3(1, 1, 11) })
2457 shouldPanic(func() { rv.Slice3(2, 2, 1) })
2458
2459 xa := [8]int{10, 20, 30, 40, 50, 60, 70, 80}
2460 v = ValueOf(&xa).Elem().Slice3(2, 5, 6).Interface().([]int)
2461 if len(v) != 3 {
2462 t.Errorf("len(xa.Slice(2, 5, 6)) = %d", len(v))
2463 }
2464 if cap(v) != 4 {
2465 t.Errorf("cap(xa.Slice(2, 5, 6)) = %d", cap(v))
2466 }
2467 if !DeepEqual(v[0:4], xa[2:6:6]) {
2468 t.Errorf("xs.Slice(2, 5, 6)[0:4] = %v", v[0:4])
2469 }
2470 rv = ValueOf(&xa).Elem()
2471 shouldPanic(func() { rv.Slice3(1, 2, 1) })
2472 shouldPanic(func() { rv.Slice3(1, 1, 11) })
2473 shouldPanic(func() { rv.Slice3(2, 2, 1) })
2474
2475 s := "hello world"
2476 rv = ValueOf(&s).Elem()
2477 shouldPanic(func() { rv.Slice3(1, 2, 3) })
2478 }
2479
2480 func TestSetLenCap(t *testing.T) {
2481 xs := []int{1, 2, 3, 4, 5, 6, 7, 8}
2482 xa := [8]int{10, 20, 30, 40, 50, 60, 70, 80}
2483
2484 vs := ValueOf(&xs).Elem()
2485 shouldPanic(func() { vs.SetLen(10) })
2486 shouldPanic(func() { vs.SetCap(10) })
2487 shouldPanic(func() { vs.SetLen(-1) })
2488 shouldPanic(func() { vs.SetCap(-1) })
2489 shouldPanic(func() { vs.SetCap(6) }) // smaller than len
2490 vs.SetLen(5)
2491 if len(xs) != 5 || cap(xs) != 8 {
2492 t.Errorf("after SetLen(5), len, cap = %d, %d, want 5, 8", len(xs), cap(xs))
2493 }
2494 vs.SetCap(6)
2495 if len(xs) != 5 || cap(xs) != 6 {
2496 t.Errorf("after SetCap(6), len, cap = %d, %d, want 5, 6", len(xs), cap(xs))
2497 }
2498 vs.SetCap(5)
2499 if len(xs) != 5 || cap(xs) != 5 {
2500 t.Errorf("after SetCap(5), len, cap = %d, %d, want 5, 5", len(xs), cap(xs))
2501 }
2502 shouldPanic(func() { vs.SetCap(4) }) // smaller than len
2503 shouldPanic(func() { vs.SetLen(6) }) // bigger than cap
2504
2505 va := ValueOf(&xa).Elem()
2506 shouldPanic(func() { va.SetLen(8) })
2507 shouldPanic(func() { va.SetCap(8) })
2508 }
2509
2510 func TestVariadic(t *testing.T) {
2511 var b bytes.Buffer
2512 V := ValueOf
2513
2514 b.Reset()
2515 V(fmt.Fprintf).Call([]Value{V(&b), V("%s, %d world"), V("hello"), V(42)})
2516 if b.String() != "hello, 42 world" {
2517 t.Errorf("after Fprintf Call: %q != %q", b.String(), "hello 42 world")
2518 }
2519
2520 b.Reset()
2521 V(fmt.Fprintf).CallSlice([]Value{V(&b), V("%s, %d world"), V([]interface{}{"hello", 42})})
2522 if b.String() != "hello, 42 world" {
2523 t.Errorf("after Fprintf CallSlice: %q != %q", b.String(), "hello 42 world")
2524 }
2525 }
2526
2527 func TestFuncArg(t *testing.T) {
2528 f1 := func(i int, f func(int) int) int { return f(i) }
2529 f2 := func(i int) int { return i + 1 }
2530 r := ValueOf(f1).Call([]Value{ValueOf(100), ValueOf(f2)})
2531 if r[0].Int() != 101 {
2532 t.Errorf("function returned %d, want 101", r[0].Int())
2533 }
2534 }
2535
2536 var tagGetTests = []struct {
2537 Tag StructTag
2538 Key string
2539 Value string
2540 }{
2541 {`protobuf:"PB(1,2)"`, `protobuf`, `PB(1,2)`},
2542 {`protobuf:"PB(1,2)"`, `foo`, ``},
2543 {`protobuf:"PB(1,2)"`, `rotobuf`, ``},
2544 {`protobuf:"PB(1,2)" json:"name"`, `json`, `name`},
2545 {`protobuf:"PB(1,2)" json:"name"`, `protobuf`, `PB(1,2)`},
2546 }
2547
2548 func TestTagGet(t *testing.T) {
2549 for _, tt := range tagGetTests {
2550 if v := tt.Tag.Get(tt.Key); v != tt.Value {
2551 t.Errorf("StructTag(%#q).Get(%#q) = %#q, want %#q", tt.Tag, tt.Key, v, tt.Value)
2552 }
2553 }
2554 }
2555
2556 func TestBytes(t *testing.T) {
2557 type B []byte
2558 x := B{1, 2, 3, 4}
2559 y := ValueOf(x).Bytes()
2560 if !bytes.Equal(x, y) {
2561 t.Fatalf("ValueOf(%v).Bytes() = %v", x, y)
2562 }
2563 if &x[0] != &y[0] {
2564 t.Errorf("ValueOf(%p).Bytes() = %p", &x[0], &y[0])
2565 }
2566 }
2567
2568 func TestSetBytes(t *testing.T) {
2569 type B []byte
2570 var x B
2571 y := []byte{1, 2, 3, 4}
2572 ValueOf(&x).Elem().SetBytes(y)
2573 if !bytes.Equal(x, y) {
2574 t.Fatalf("ValueOf(%v).Bytes() = %v", x, y)
2575 }
2576 if &x[0] != &y[0] {
2577 t.Errorf("ValueOf(%p).Bytes() = %p", &x[0], &y[0])
2578 }
2579 }
2580
2581 type Private struct {
2582 x int
2583 y **int
2584 }
2585
2586 func (p *Private) m() {
2587 }
2588
2589 type Public struct {
2590 X int
2591 Y **int
2592 }
2593
2594 func (p *Public) M() {
2595 }
2596
2597 func TestUnexported(t *testing.T) {
2598 var pub Public
2599 v := ValueOf(&pub)
2600 isValid(v.Elem().Field(0))
2601 isValid(v.Elem().Field(1))
2602 isValid(v.Elem().FieldByName("X"))
2603 isValid(v.Elem().FieldByName("Y"))
2604 isValid(v.Type().Method(0).Func)
2605 isNonNil(v.Elem().Field(0).Interface())
2606 isNonNil(v.Elem().Field(1).Interface())
2607 isNonNil(v.Elem().FieldByName("X").Interface())
2608 isNonNil(v.Elem().FieldByName("Y").Interface())
2609 isNonNil(v.Type().Method(0).Func.Interface())
2610
2611 var priv Private
2612 v = ValueOf(&priv)
2613 isValid(v.Elem().Field(0))
2614 isValid(v.Elem().Field(1))
2615 isValid(v.Elem().FieldByName("x"))
2616 isValid(v.Elem().FieldByName("y"))
2617 isValid(v.Type().Method(0).Func)
2618 shouldPanic(func() { v.Elem().Field(0).Interface() })
2619 shouldPanic(func() { v.Elem().Field(1).Interface() })
2620 shouldPanic(func() { v.Elem().FieldByName("x").Interface() })
2621 shouldPanic(func() { v.Elem().FieldByName("y").Interface() })
2622 shouldPanic(func() { v.Type().Method(0).Func.Interface() })
2623 }
2624
2625 func shouldPanic(f func()) {
2626 defer func() {
2627 if recover() == nil {
2628 panic("did not panic")
2629 }
2630 }()
2631 f()
2632 }
2633
2634 func isNonNil(x interface{}) {
2635 if x == nil {
2636 panic("nil interface")
2637 }
2638 }
2639
2640 func isValid(v Value) {
2641 if !v.IsValid() {
2642 panic("zero Value")
2643 }
2644 }
2645
2646 func TestAlias(t *testing.T) {
2647 x := string("hello")
2648 v := ValueOf(&x).Elem()
2649 oldvalue := v.Interface()
2650 v.SetString("world")
2651 newvalue := v.Interface()
2652
2653 if oldvalue != "hello" || newvalue != "world" {
2654 t.Errorf("aliasing: old=%q new=%q, want hello, world", oldvalue, newvalue)
2655 }
2656 }
2657
2658 var V = ValueOf
2659
2660 func EmptyInterfaceV(x interface{}) Value {
2661 return ValueOf(&x).Elem()
2662 }
2663
2664 func ReaderV(x io.Reader) Value {
2665 return ValueOf(&x).Elem()
2666 }
2667
2668 func ReadWriterV(x io.ReadWriter) Value {
2669 return ValueOf(&x).Elem()
2670 }
2671
2672 type Empty struct{}
2673 type MyString string
2674 type MyBytes []byte
2675 type MyRunes []int32
2676 type MyFunc func()
2677 type MyByte byte
2678
2679 var convertTests = []struct {
2680 in Value
2681 out Value
2682 }{
2683 // numbers
2684 /*
2685 Edit .+1,/\*\//-1>cat >/tmp/x.go && go run /tmp/x.go
2686
2687 package main
2688
2689 import "fmt"
2690
2691 var numbers = []string{
2692 "int8", "uint8", "int16", "uint16",
2693 "int32", "uint32", "int64", "uint64",
2694 "int", "uint", "uintptr",
2695 "float32", "float64",
2696 }
2697
2698 func main() {
2699 // all pairs but in an unusual order,
2700 // to emit all the int8, uint8 cases
2701 // before n grows too big.
2702 n := 1
2703 for i, f := range numbers {
2704 for _, g := range numbers[i:] {
2705 fmt.Printf("\t{V(%s(%d)), V(%s(%d))},\n", f, n, g, n)
2706 n++
2707 if f != g {
2708 fmt.Printf("\t{V(%s(%d)), V(%s(%d))},\n", g, n, f, n)
2709 n++
2710 }
2711 }
2712 }
2713 }
2714 */
2715 {V(int8(1)), V(int8(1))},
2716 {V(int8(2)), V(uint8(2))},
2717 {V(uint8(3)), V(int8(3))},
2718 {V(int8(4)), V(int16(4))},
2719 {V(int16(5)), V(int8(5))},
2720 {V(int8(6)), V(uint16(6))},
2721 {V(uint16(7)), V(int8(7))},
2722 {V(int8(8)), V(int32(8))},
2723 {V(int32(9)), V(int8(9))},
2724 {V(int8(10)), V(uint32(10))},
2725 {V(uint32(11)), V(int8(11))},
2726 {V(int8(12)), V(int64(12))},
2727 {V(int64(13)), V(int8(13))},
2728 {V(int8(14)), V(uint64(14))},
2729 {V(uint64(15)), V(int8(15))},
2730 {V(int8(16)), V(int(16))},
2731 {V(int(17)), V(int8(17))},
2732 {V(int8(18)), V(uint(18))},
2733 {V(uint(19)), V(int8(19))},
2734 {V(int8(20)), V(uintptr(20))},
2735 {V(uintptr(21)), V(int8(21))},
2736 {V(int8(22)), V(float32(22))},
2737 {V(float32(23)), V(int8(23))},
2738 {V(int8(24)), V(float64(24))},
2739 {V(float64(25)), V(int8(25))},
2740 {V(uint8(26)), V(uint8(26))},
2741 {V(uint8(27)), V(int16(27))},
2742 {V(int16(28)), V(uint8(28))},
2743 {V(uint8(29)), V(uint16(29))},
2744 {V(uint16(30)), V(uint8(30))},
2745 {V(uint8(31)), V(int32(31))},
2746 {V(int32(32)), V(uint8(32))},
2747 {V(uint8(33)), V(uint32(33))},
2748 {V(uint32(34)), V(uint8(34))},
2749 {V(uint8(35)), V(int64(35))},
2750 {V(int64(36)), V(uint8(36))},
2751 {V(uint8(37)), V(uint64(37))},
2752 {V(uint64(38)), V(uint8(38))},
2753 {V(uint8(39)), V(int(39))},
2754 {V(int(40)), V(uint8(40))},
2755 {V(uint8(41)), V(uint(41))},
2756 {V(uint(42)), V(uint8(42))},
2757 {V(uint8(43)), V(uintptr(43))},
2758 {V(uintptr(44)), V(uint8(44))},
2759 {V(uint8(45)), V(float32(45))},
2760 {V(float32(46)), V(uint8(46))},
2761 {V(uint8(47)), V(float64(47))},
2762 {V(float64(48)), V(uint8(48))},
2763 {V(int16(49)), V(int16(49))},
2764 {V(int16(50)), V(uint16(50))},
2765 {V(uint16(51)), V(int16(51))},
2766 {V(int16(52)), V(int32(52))},
2767 {V(int32(53)), V(int16(53))},
2768 {V(int16(54)), V(uint32(54))},
2769 {V(uint32(55)), V(int16(55))},
2770 {V(int16(56)), V(int64(56))},
2771 {V(int64(57)), V(int16(57))},
2772 {V(int16(58)), V(uint64(58))},
2773 {V(uint64(59)), V(int16(59))},
2774 {V(int16(60)), V(int(60))},
2775 {V(int(61)), V(int16(61))},
2776 {V(int16(62)), V(uint(62))},
2777 {V(uint(63)), V(int16(63))},
2778 {V(int16(64)), V(uintptr(64))},
2779 {V(uintptr(65)), V(int16(65))},
2780 {V(int16(66)), V(float32(66))},
2781 {V(float32(67)), V(int16(67))},
2782 {V(int16(68)), V(float64(68))},
2783 {V(float64(69)), V(int16(69))},
2784 {V(uint16(70)), V(uint16(70))},
2785 {V(uint16(71)), V(int32(71))},
2786 {V(int32(72)), V(uint16(72))},
2787 {V(uint16(73)), V(uint32(73))},
2788 {V(uint32(74)), V(uint16(74))},
2789 {V(uint16(75)), V(int64(75))},
2790 {V(int64(76)), V(uint16(76))},
2791 {V(uint16(77)), V(uint64(77))},
2792 {V(uint64(78)), V(uint16(78))},
2793 {V(uint16(79)), V(int(79))},
2794 {V(int(80)), V(uint16(80))},
2795 {V(uint16(81)), V(uint(81))},
2796 {V(uint(82)), V(uint16(82))},
2797 {V(uint16(83)), V(uintptr(83))},
2798 {V(uintptr(84)), V(uint16(84))},
2799 {V(uint16(85)), V(float32(85))},
2800 {V(float32(86)), V(uint16(86))},
2801 {V(uint16(87)), V(float64(87))},
2802 {V(float64(88)), V(uint16(88))},
2803 {V(int32(89)), V(int32(89))},
2804 {V(int32(90)), V(uint32(90))},
2805 {V(uint32(91)), V(int32(91))},
2806 {V(int32(92)), V(int64(92))},
2807 {V(int64(93)), V(int32(93))},
2808 {V(int32(94)), V(uint64(94))},
2809 {V(uint64(95)), V(int32(95))},
2810 {V(int32(96)), V(int(96))},
2811 {V(int(97)), V(int32(97))},
2812 {V(int32(98)), V(uint(98))},
2813 {V(uint(99)), V(int32(99))},
2814 {V(int32(100)), V(uintptr(100))},
2815 {V(uintptr(101)), V(int32(101))},
2816 {V(int32(102)), V(float32(102))},
2817 {V(float32(103)), V(int32(103))},
2818 {V(int32(104)), V(float64(104))},
2819 {V(float64(105)), V(int32(105))},
2820 {V(uint32(106)), V(uint32(106))},
2821 {V(uint32(107)), V(int64(107))},
2822 {V(int64(108)), V(uint32(108))},
2823 {V(uint32(109)), V(uint64(109))},
2824 {V(uint64(110)), V(uint32(110))},
2825 {V(uint32(111)), V(int(111))},
2826 {V(int(112)), V(uint32(112))},
2827 {V(uint32(113)), V(uint(113))},
2828 {V(uint(114)), V(uint32(114))},
2829 {V(uint32(115)), V(uintptr(115))},
2830 {V(uintptr(116)), V(uint32(116))},
2831 {V(uint32(117)), V(float32(117))},
2832 {V(float32(118)), V(uint32(118))},
2833 {V(uint32(119)), V(float64(119))},
2834 {V(float64(120)), V(uint32(120))},
2835 {V(int64(121)), V(int64(121))},
2836 {V(int64(122)), V(uint64(122))},
2837 {V(uint64(123)), V(int64(123))},
2838 {V(int64(124)), V(int(124))},
2839 {V(int(125)), V(int64(125))},
2840 {V(int64(126)), V(uint(126))},
2841 {V(uint(127)), V(int64(127))},
2842 {V(int64(128)), V(uintptr(128))},
2843 {V(uintptr(129)), V(int64(129))},
2844 {V(int64(130)), V(float32(130))},
2845 {V(float32(131)), V(int64(131))},
2846 {V(int64(132)), V(float64(132))},
2847 {V(float64(133)), V(int64(133))},
2848 {V(uint64(134)), V(uint64(134))},
2849 {V(uint64(135)), V(int(135))},
2850 {V(int(136)), V(uint64(136))},
2851 {V(uint64(137)), V(uint(137))},
2852 {V(uint(138)), V(uint64(138))},
2853 {V(uint64(139)), V(uintptr(139))},
2854 {V(uintptr(140)), V(uint64(140))},
2855 {V(uint64(141)), V(float32(141))},
2856 {V(float32(142)), V(uint64(142))},
2857 {V(uint64(143)), V(float64(143))},
2858 {V(float64(144)), V(uint64(144))},
2859 {V(int(145)), V(int(145))},
2860 {V(int(146)), V(uint(146))},
2861 {V(uint(147)), V(int(147))},
2862 {V(int(148)), V(uintptr(148))},
2863 {V(uintptr(149)), V(int(149))},
2864 {V(int(150)), V(float32(150))},
2865 {V(float32(151)), V(int(151))},
2866 {V(int(152)), V(float64(152))},
2867 {V(float64(153)), V(int(153))},
2868 {V(uint(154)), V(uint(154))},
2869 {V(uint(155)), V(uintptr(155))},
2870 {V(uintptr(156)), V(uint(156))},
2871 {V(uint(157)), V(float32(157))},
2872 {V(float32(158)), V(uint(158))},
2873 {V(uint(159)), V(float64(159))},
2874 {V(float64(160)), V(uint(160))},
2875 {V(uintptr(161)), V(uintptr(161))},
2876 {V(uintptr(162)), V(float32(162))},
2877 {V(float32(163)), V(uintptr(163))},
2878 {V(uintptr(164)), V(float64(164))},
2879 {V(float64(165)), V(uintptr(165))},
2880 {V(float32(166)), V(float32(166))},
2881 {V(float32(167)), V(float64(167))},
2882 {V(float64(168)), V(float32(168))},
2883 {V(float64(169)), V(float64(169))},
2884
2885 // truncation
2886 {V(float64(1.5)), V(int(1))},
2887
2888 // complex
2889 {V(complex64(1i)), V(complex64(1i))},
2890 {V(complex64(2i)), V(complex128(2i))},
2891 {V(complex128(3i)), V(complex64(3i))},
2892 {V(complex128(4i)), V(complex128(4i))},
2893
2894 // string
2895 {V(string("hello")), V(string("hello"))},
2896 {V(string("bytes1")), V([]byte("bytes1"))},
2897 {V([]byte("bytes2")), V(string("bytes2"))},
2898 {V([]byte("bytes3")), V([]byte("bytes3"))},
2899 {V(string("runes♝")), V([]rune("runes♝"))},
2900 {V([]rune("runes♕")), V(string("runes♕"))},
2901 {V([]rune("runes🙈🙉🙊")), V([]rune("runes🙈🙉🙊"))},
2902 {V(int('a')), V(string("a"))},
2903 {V(int8('a')), V(string("a"))},
2904 {V(int16('a')), V(string("a"))},
2905 {V(int32('a')), V(string("a"))},
2906 {V(int64('a')), V(string("a"))},
2907 {V(uint('a')), V(string("a"))},
2908 {V(uint8('a')), V(string("a"))},
2909 {V(uint16('a')), V(string("a"))},
2910 {V(uint32('a')), V(string("a"))},
2911 {V(uint64('a')), V(string("a"))},
2912 {V(uintptr('a')), V(string("a"))},
2913 {V(int(-1)), V(string("\uFFFD"))},
2914 {V(int8(-2)), V(string("\uFFFD"))},
2915 {V(int16(-3)), V(string("\uFFFD"))},
2916 {V(int32(-4)), V(string("\uFFFD"))},
2917 {V(int64(-5)), V(string("\uFFFD"))},
2918 {V(uint(0x110001)), V(string("\uFFFD"))},
2919 {V(uint32(0x110002)), V(string("\uFFFD"))},
2920 {V(uint64(0x110003)), V(string("\uFFFD"))},
2921 {V(uintptr(0x110004)), V(string("\uFFFD"))},
2922
2923 // named string
2924 {V(MyString("hello")), V(string("hello"))},
2925 {V(string("hello")), V(MyString("hello"))},
2926 {V(string("hello")), V(string("hello"))},
2927 {V(MyString("hello")), V(MyString("hello"))},
2928 {V(MyString("bytes1")), V([]byte("bytes1"))},
2929 {V([]byte("bytes2")), V(MyString("bytes2"))},
2930 {V([]byte("bytes3")), V([]byte("bytes3"))},
2931 {V(MyString("runes♝")), V([]rune("runes♝"))},
2932 {V([]rune("runes♕")), V(MyString("runes♕"))},
2933 {V([]rune("runes🙈🙉🙊")), V([]rune("runes🙈🙉🙊"))},
2934 {V([]rune("runes🙈🙉🙊")), V(MyRunes("runes🙈🙉🙊"))},
2935 {V(MyRunes("runes🙈🙉🙊")), V([]rune("runes🙈🙉🙊"))},
2936 {V(int('a')), V(MyString("a"))},
2937 {V(int8('a')), V(MyString("a"))},
2938 {V(int16('a')), V(MyString("a"))},
2939 {V(int32('a')), V(MyString("a"))},
2940 {V(int64('a')), V(MyString("a"))},
2941 {V(uint('a')), V(MyString("a"))},
2942 {V(uint8('a')), V(MyString("a"))},
2943 {V(uint16('a')), V(MyString("a"))},
2944 {V(uint32('a')), V(MyString("a"))},
2945 {V(uint64('a')), V(MyString("a"))},
2946 {V(uintptr('a')), V(MyString("a"))},
2947 {V(int(-1)), V(MyString("\uFFFD"))},
2948 {V(int8(-2)), V(MyString("\uFFFD"))},
2949 {V(int16(-3)), V(MyString("\uFFFD"))},
2950 {V(int32(-4)), V(MyString("\uFFFD"))},
2951 {V(int64(-5)), V(MyString("\uFFFD"))},
2952 {V(uint(0x110001)), V(MyString("\uFFFD"))},
2953 {V(uint32(0x110002)), V(MyString("\uFFFD"))},
2954 {V(uint64(0x110003)), V(MyString("\uFFFD"))},
2955 {V(uintptr(0x110004)), V(MyString("\uFFFD"))},
2956
2957 // named []byte
2958 {V(string("bytes1")), V(MyBytes("bytes1"))},
2959 {V(MyBytes("bytes2")), V(string("bytes2"))},
2960 {V(MyBytes("bytes3")), V(MyBytes("bytes3"))},
2961 {V(MyString("bytes1")), V(MyBytes("bytes1"))},
2962 {V(MyBytes("bytes2")), V(MyString("bytes2"))},
2963
2964 // named []rune
2965 {V(string("runes♝")), V(MyRunes("runes♝"))},
2966 {V(MyRunes("runes♕")), V(string("runes♕"))},
2967 {V(MyRunes("runes🙈🙉🙊")), V(MyRunes("runes🙈🙉🙊"))},
2968 {V(MyString("runes♝")), V(MyRunes("runes♝"))},
2969 {V(MyRunes("runes♕")), V(MyString("runes♕"))},
2970
2971 // named types and equal underlying types
2972 {V(new(int)), V(new(integer))},
2973 {V(new(integer)), V(new(int))},
2974 {V(Empty{}), V(struct{}{})},
2975 {V(new(Empty)), V(new(struct{}))},
2976 {V(struct{}{}), V(Empty{})},
2977 {V(new(struct{})), V(new(Empty))},
2978 {V(Empty{}), V(Empty{})},
2979 {V(MyBytes{}), V([]byte{})},
2980 {V([]byte{}), V(MyBytes{})},
2981 {V((func())(nil)), V(MyFunc(nil))},
2982 {V((MyFunc)(nil)), V((func())(nil))},
2983
2984 // can convert *byte and *MyByte
2985 {V((*byte)(nil)), V((*MyByte)(nil))},
2986 {V((*MyByte)(nil)), V((*byte)(nil))},
2987
2988 // cannot convert mismatched array sizes
2989 {V([2]byte{}), V([2]byte{})},
2990 {V([3]byte{}), V([3]byte{})},
2991
2992 // cannot convert other instances
2993 {V((**byte)(nil)), V((**byte)(nil))},
2994 {V((**MyByte)(nil)), V((**MyByte)(nil))},
2995 {V((chan byte)(nil)), V((chan byte)(nil))},
2996 {V((chan MyByte)(nil)), V((chan MyByte)(nil))},
2997 {V(([]byte)(nil)), V(([]byte)(nil))},
2998 {V(([]MyByte)(nil)), V(([]MyByte)(nil))},
2999 {V((map[int]byte)(nil)), V((map[int]byte)(nil))},
3000 {V((map[int]MyByte)(nil)), V((map[int]MyByte)(nil))},
3001 {V((map[byte]int)(nil)), V((map[byte]int)(nil))},
3002 {V((map[MyByte]int)(nil)), V((map[MyByte]int)(nil))},
3003 {V([2]byte{}), V([2]byte{})},
3004 {V([2]MyByte{}), V([2]MyByte{})},
3005
3006 // other
3007 {V((***int)(nil)), V((***int)(nil))},
3008 {V((***byte)(nil)), V((***byte)(nil))},
3009 {V((***int32)(nil)), V((***int32)(nil))},
3010 {V((***int64)(nil)), V((***int64)(nil))},
3011 {V((chan int)(nil)), V((<-chan int)(nil))},
3012 {V((chan int)(nil)), V((chan<- int)(nil))},
3013 {V((chan string)(nil)), V((<-chan string)(nil))},
3014 {V((chan string)(nil)), V((chan<- string)(nil))},
3015 {V((chan byte)(nil)), V((chan byte)(nil))},
3016 {V((chan MyByte)(nil)), V((chan MyByte)(nil))},
3017 {V((map[int]bool)(nil)), V((map[int]bool)(nil))},
3018 {V((map[int]byte)(nil)), V((map[int]byte)(nil))},
3019 {V((map[uint]bool)(nil)), V((map[uint]bool)(nil))},
3020 {V([]uint(nil)), V([]uint(nil))},
3021 {V([]int(nil)), V([]int(nil))},
3022 {V(new(interface{})), V(new(interface{}))},
3023 {V(new(io.Reader)), V(new(io.Reader))},
3024 {V(new(io.Writer)), V(new(io.Writer))},
3025
3026 // interfaces
3027 {V(int(1)), EmptyInterfaceV(int(1))},
3028 {V(string("hello")), EmptyInterfaceV(string("hello"))},
3029 {V(new(bytes.Buffer)), ReaderV(new(bytes.Buffer))},
3030 {ReadWriterV(new(bytes.Buffer)), ReaderV(new(bytes.Buffer))},
3031 {V(new(bytes.Buffer)), ReadWriterV(new(bytes.Buffer))},
3032 }
3033
3034 func TestConvert(t *testing.T) {
3035 canConvert := map[[2]Type]bool{}
3036 all := map[Type]bool{}
3037
3038 for _, tt := range convertTests {
3039 t1 := tt.in.Type()
3040 if !t1.ConvertibleTo(t1) {
3041 t.Errorf("(%s).ConvertibleTo(%s) = false, want true", t1, t1)
3042 continue
3043 }
3044
3045 t2 := tt.out.Type()
3046 if !t1.ConvertibleTo(t2) {
3047 t.Errorf("(%s).ConvertibleTo(%s) = false, want true", t1, t2)
3048 continue
3049 }
3050
3051 all[t1] = true
3052 all[t2] = true
3053 canConvert[[2]Type{t1, t2}] = true
3054
3055 // vout1 represents the in value converted to the in type.
3056 v1 := tt.in
3057 vout1 := v1.Convert(t1)
3058 out1 := vout1.Interface()
3059 if vout1.Type() != tt.in.Type() || !DeepEqual(out1, tt.in.Interface()) {
3060 t.Errorf("ValueOf(%T(%[1]v)).Convert(%s) = %T(%[3]v), want %T(%[4]v)", tt.in.Interface(), t1, out1, tt.in.Interface())
3061 }
3062
3063 // vout2 represents the in value converted to the out type.
3064 vout2 := v1.Convert(t2)
3065 out2 := vout2.Interface()
3066 if vout2.Type() != tt.out.Type() || !DeepEqual(out2, tt.out.Interface()) {
3067 t.Errorf("ValueOf(%T(%[1]v)).Convert(%s) = %T(%[3]v), want %T(%[4]v)", tt.in.Interface(), t2, out2, tt.out.Interface())
3068 }
3069
3070 // vout3 represents a new value of the out type, set to vout2. This makes
3071 // sure the converted value vout2 is really usable as a regular value.
3072 vout3 := New(t2).Elem()
3073 vout3.Set(vout2)
3074 out3 := vout3.Interface()
3075 if vout3.Type() != tt.out.Type() || !DeepEqual(out3, tt.out.Interface()) {
3076 t.Errorf("Set(ValueOf(%T(%[1]v)).Convert(%s)) = %T(%[3]v), want %T(%[4]v)", tt.in.Interface(), t2, out3, tt.out.Interface())
3077 }
3078
3079 if IsRO(v1) {
3080 t.Errorf("table entry %v is RO, should not be", v1)
3081 }
3082 if IsRO(vout1) {
3083 t.Errorf("self-conversion output %v is RO, should not be", vout1)
3084 }
3085 if IsRO(vout2) {
3086 t.Errorf("conversion output %v is RO, should not be", vout2)
3087 }
3088 if IsRO(vout3) {
3089 t.Errorf("set(conversion output) %v is RO, should not be", vout3)
3090 }
3091 if !IsRO(MakeRO(v1).Convert(t1)) {
3092 t.Errorf("RO self-conversion output %v is not RO, should be", v1)
3093 }
3094 if !IsRO(MakeRO(v1).Convert(t2)) {
3095 t.Errorf("RO conversion output %v is not RO, should be", v1)
3096 }
3097 }
3098
3099 // Assume that of all the types we saw during the tests,
3100 // if there wasn't an explicit entry for a conversion between
3101 // a pair of types, then it's not to be allowed. This checks for
3102 // things like 'int64' converting to '*int'.
3103 for t1 := range all {
3104 for t2 := range all {
3105 expectOK := t1 == t2 || canConvert[[2]Type{t1, t2}] || t2.Kind() == Interface && t2.NumMethod() == 0
3106 if ok := t1.ConvertibleTo(t2); ok != expectOK {
3107 t.Errorf("(%s).ConvertibleTo(%s) = %v, want %v", t1, t2, ok, expectOK)
3108 }
3109 }
3110 }
3111 }
3112
3113 func TestOverflow(t *testing.T) {
3114 if ovf := V(float64(0)).OverflowFloat(1e300); ovf {
3115 t.Errorf("%v wrongly overflows float64", 1e300)
3116 }
3117
3118 maxFloat32 := float64((1<<24 - 1) << (127 - 23))
3119 if ovf := V(float32(0)).OverflowFloat(maxFloat32); ovf {
3120 t.Errorf("%v wrongly overflows float32", maxFloat32)
3121 }
3122 ovfFloat32 := float64((1<<24-1)<<(127-23) + 1<<(127-52))
3123 if ovf := V(float32(0)).OverflowFloat(ovfFloat32); !ovf {
3124 t.Errorf("%v should overflow float32", ovfFloat32)
3125 }
3126 if ovf := V(float32(0)).OverflowFloat(-ovfFloat32); !ovf {
3127 t.Errorf("%v should overflow float32", -ovfFloat32)
3128 }
3129
3130 maxInt32 := int64(0x7fffffff)
3131 if ovf := V(int32(0)).OverflowInt(maxInt32); ovf {
3132 t.Errorf("%v wrongly overflows int32", maxInt32)
3133 }
3134 if ovf := V(int32(0)).OverflowInt(-1 << 31); ovf {
3135 t.Errorf("%v wrongly overflows int32", -int64(1)<<31)
3136 }
3137 ovfInt32 := int64(1 << 31)
3138 if ovf := V(int32(0)).OverflowInt(ovfInt32); !ovf {
3139 t.Errorf("%v should overflow int32", ovfInt32)
3140 }
3141
3142 maxUint32 := uint64(0xffffffff)
3143 if ovf := V(uint32(0)).OverflowUint(maxUint32); ovf {
3144 t.Errorf("%v wrongly overflows uint32", maxUint32)
3145 }
3146 ovfUint32 := uint64(1 << 32)
3147 if ovf := V(uint32(0)).OverflowUint(ovfUint32); !ovf {
3148 t.Errorf("%v should overflow uint32", ovfUint32)
3149 }
3150 }
3151
3152 func checkSameType(t *testing.T, x, y interface{}) {
3153 if TypeOf(x) != TypeOf(y) {
3154 t.Errorf("did not find preexisting type for %s (vs %s)", TypeOf(x), TypeOf(y))
3155 }
3156 }
3157
3158 func TestArrayOf(t *testing.T) {
3159 // check construction and use of type not in binary
3160 type T int
3161 at := ArrayOf(10, TypeOf(T(1)))
3162 v := New(at).Elem()
3163 for i := 0; i < v.Len(); i++ {
3164 v.Index(i).Set(ValueOf(T(i)))
3165 }
3166 s := fmt.Sprint(v.Interface())
3167 want := "[0 1 2 3 4 5 6 7 8 9]"
3168 if s != want {
3169 t.Errorf("constructed array = %s, want %s", s, want)
3170 }
3171
3172 // check that type already in binary is found
3173 checkSameType(t, Zero(ArrayOf(5, TypeOf(T(1)))).Interface(), [5]T{})
3174 }
3175
3176 func TestSliceOf(t *testing.T) {
3177 // check construction and use of type not in binary
3178 type T int
3179 st := SliceOf(TypeOf(T(1)))
3180 v := MakeSlice(st, 10, 10)
3181 runtime.GC()
3182 for i := 0; i < v.Len(); i++ {
3183 v.Index(i).Set(ValueOf(T(i)))
3184 runtime.GC()
3185 }
3186 s := fmt.Sprint(v.Interface())
3187 want := "[0 1 2 3 4 5 6 7 8 9]"
3188 if s != want {
3189 t.Errorf("constructed slice = %s, want %s", s, want)
3190 }
3191
3192 // check that type already in binary is found
3193 type T1 int
3194 checkSameType(t, Zero(SliceOf(TypeOf(T1(1)))).Interface(), []T1{})
3195 }
3196
3197 func TestSliceOverflow(t *testing.T) {
3198 // check that MakeSlice panics when size of slice overflows uint
3199 const S = 1e6
3200 s := uint(S)
3201 l := (1<<(unsafe.Sizeof((*byte)(nil))*8)-1)/s + 1
3202 if l*s >= s {
3203 t.Fatal("slice size does not overflow")
3204 }
3205 var x [S]byte
3206 st := SliceOf(TypeOf(x))
3207 defer func() {
3208 err := recover()
3209 if err == nil {
3210 t.Fatal("slice overflow does not panic")
3211 }
3212 }()
3213 MakeSlice(st, int(l), int(l))
3214 }
3215
3216 func TestSliceOfGC(t *testing.T) {
3217 type T *uintptr
3218 tt := TypeOf(T(nil))
3219 st := SliceOf(tt)
3220 const n = 100
3221 var x []interface{}
3222 for i := 0; i < n; i++ {
3223 v := MakeSlice(st, n, n)
3224 for j := 0; j < v.Len(); j++ {
3225 p := new(uintptr)
3226 *p = uintptr(i*n + j)
3227 v.Index(j).Set(ValueOf(p).Convert(tt))
3228 }
3229 x = append(x, v.Interface())
3230 }
3231 runtime.GC()
3232
3233 for i, xi := range x {
3234 v := ValueOf(xi)
3235 for j := 0; j < v.Len(); j++ {
3236 k := v.Index(j).Elem().Interface()
3237 if k != uintptr(i*n+j) {
3238 t.Errorf("lost x[%d][%d] = %d, want %d", i, j, k, i*n+j)
3239 }
3240 }
3241 }
3242 }
3243
3244 func TestChanOf(t *testing.T) {
3245 // check construction and use of type not in binary
3246 type T string
3247 ct := ChanOf(BothDir, TypeOf(T("")))
3248 v := MakeChan(ct, 2)
3249 runtime.GC()
3250 v.Send(ValueOf(T("hello")))
3251 runtime.GC()
3252 v.Send(ValueOf(T("world")))
3253 runtime.GC()
3254
3255 sv1, _ := v.Recv()
3256 sv2, _ := v.Recv()
3257 s1 := sv1.String()
3258 s2 := sv2.String()
3259 if s1 != "hello" || s2 != "world" {
3260 t.Errorf("constructed chan: have %q, %q, want %q, %q", s1, s2, "hello", "world")
3261 }
3262
3263 // check that type already in binary is found
3264 type T1 int
3265 checkSameType(t, Zero(ChanOf(BothDir, TypeOf(T1(1)))).Interface(), (chan T1)(nil))
3266 }
3267
3268 func TestChanOfGC(t *testing.T) {
3269 done := make(chan bool, 1)
3270 go func() {
3271 select {
3272 case <-done:
3273 case <-time.After(5 * time.Second):
3274 panic("deadlock in TestChanOfGC")
3275 }
3276 }()
3277
3278 defer func() {
3279 done <- true
3280 }()
3281
3282 type T *uintptr
3283 tt := TypeOf(T(nil))
3284 ct := ChanOf(BothDir, tt)
3285
3286 // NOTE: The garbage collector handles allocated channels specially,
3287 // so we have to save pointers to channels in x; the pointer code will
3288 // use the gc info in the newly constructed chan type.
3289 const n = 100
3290 var x []interface{}
3291 for i := 0; i < n; i++ {
3292 v := MakeChan(ct, n)
3293 for j := 0; j < n; j++ {
3294 p := new(uintptr)
3295 *p = uintptr(i*n + j)
3296 v.Send(ValueOf(p).Convert(tt))
3297 }
3298 pv := New(ct)
3299 pv.Elem().Set(v)
3300 x = append(x, pv.Interface())
3301 }
3302 runtime.GC()
3303
3304 for i, xi := range x {
3305 v := ValueOf(xi).Elem()
3306 for j := 0; j < n; j++ {
3307 pv, _ := v.Recv()
3308 k := pv.Elem().Interface()
3309 if k != uintptr(i*n+j) {
3310 t.Errorf("lost x[%d][%d] = %d, want %d", i, j, k, i*n+j)
3311 }
3312 }
3313 }
3314 }
3315
3316 func TestMapOf(t *testing.T) {
3317 // check construction and use of type not in binary
3318 type K string
3319 type V float64
3320
3321 v := MakeMap(MapOf(TypeOf(K("")), TypeOf(V(0))))
3322 runtime.GC()
3323 v.SetMapIndex(ValueOf(K("a")), ValueOf(V(1)))
3324 runtime.GC()
3325
3326 s := fmt.Sprint(v.Interface())
3327 want := "map[a:1]"
3328 if s != want {
3329 t.Errorf("constructed map = %s, want %s", s, want)
3330 }
3331
3332 // check that type already in binary is found
3333 checkSameType(t, Zero(MapOf(TypeOf(V(0)), TypeOf(K("")))).Interface(), map[V]K(nil))
3334
3335 // check that invalid key type panics
3336 shouldPanic(func() { MapOf(TypeOf((func())(nil)), TypeOf(false)) })
3337 }
3338
3339 func TestMapOfGCKeys(t *testing.T) {
3340 type T *uintptr
3341 tt := TypeOf(T(nil))
3342 mt := MapOf(tt, TypeOf(false))
3343
3344 // NOTE: The garbage collector handles allocated maps specially,
3345 // so we have to save pointers to maps in x; the pointer code will
3346 // use the gc info in the newly constructed map type.
3347 const n = 100
3348 var x []interface{}
3349 for i := 0; i < n; i++ {
3350 v := MakeMap(mt)
3351 for j := 0; j < n; j++ {
3352 p := new(uintptr)
3353 *p = uintptr(i*n + j)
3354 v.SetMapIndex(ValueOf(p).Convert(tt), ValueOf(true))
3355 }
3356 pv := New(mt)
3357 pv.Elem().Set(v)
3358 x = append(x, pv.Interface())
3359 }
3360 runtime.GC()
3361
3362 for i, xi := range x {
3363 v := ValueOf(xi).Elem()
3364 var out []int
3365 for _, kv := range v.MapKeys() {
3366 out = append(out, int(kv.Elem().Interface().(uintptr)))
3367 }
3368 sort.Ints(out)
3369 for j, k := range out {
3370 if k != i*n+j {
3371 t.Errorf("lost x[%d][%d] = %d, want %d", i, j, k, i*n+j)
3372 }
3373 }
3374 }
3375 }
3376
3377 func TestMapOfGCValues(t *testing.T) {
3378 type T *uintptr
3379 tt := TypeOf(T(nil))
3380 mt := MapOf(TypeOf(1), tt)
3381
3382 // NOTE: The garbage collector handles allocated maps specially,
3383 // so we have to save pointers to maps in x; the pointer code will
3384 // use the gc info in the newly constructed map type.
3385 const n = 100
3386 var x []interface{}
3387 for i := 0; i < n; i++ {
3388 v := MakeMap(mt)
3389 for j := 0; j < n; j++ {
3390 p := new(uintptr)
3391 *p = uintptr(i*n + j)
3392 v.SetMapIndex(ValueOf(j), ValueOf(p).Convert(tt))
3393 }
3394 pv := New(mt)
3395 pv.Elem().Set(v)
3396 x = append(x, pv.Interface())
3397 }
3398 runtime.GC()
3399
3400 for i, xi := range x {
3401 v := ValueOf(xi).Elem()
3402 for j := 0; j < n; j++ {
3403 k := v.MapIndex(ValueOf(j)).Elem().Interface().(uintptr)
3404 if k != uintptr(i*n+j) {
3405 t.Errorf("lost x[%d][%d] = %d, want %d", i, j, k, i*n+j)
3406 }
3407 }
3408 }
3409 }
3410
3411 type B1 struct {
3412 X int
3413 Y int
3414 Z int
3415 }
3416
3417 func BenchmarkFieldByName1(b *testing.B) {
3418 t := TypeOf(B1{})
3419 for i := 0; i < b.N; i++ {
3420 t.FieldByName("Z")
3421 }
3422 }
3423
3424 func BenchmarkFieldByName2(b *testing.B) {
3425 t := TypeOf(S3{})
3426 for i := 0; i < b.N; i++ {
3427 t.FieldByName("B")
3428 }
3429 }
3430
3431 type R0 struct {
3432 *R1
3433 *R2
3434 *R3
3435 *R4
3436 }
3437
3438 type R1 struct {
3439 *R5
3440 *R6
3441 *R7
3442 *R8
3443 }
3444
3445 type R2 R1
3446 type R3 R1
3447 type R4 R1
3448
3449 type R5 struct {
3450 *R9
3451 *R10
3452 *R11
3453 *R12
3454 }
3455
3456 type R6 R5
3457 type R7 R5
3458 type R8 R5
3459
3460 type R9 struct {
3461 *R13
3462 *R14
3463 *R15
3464 *R16
3465 }
3466
3467 type R10 R9
3468 type R11 R9
3469 type R12 R9
3470
3471 type R13 struct {
3472 *R17
3473 *R18
3474 *R19
3475 *R20
3476 }
3477
3478 type R14 R13
3479 type R15 R13
3480 type R16 R13
3481
3482 type R17 struct {
3483 *R21
3484 *R22
3485 *R23
3486 *R24
3487 }
3488
3489 type R18 R17
3490 type R19 R17
3491 type R20 R17
3492
3493 type R21 struct {
3494 X int
3495 }
3496
3497 type R22 R21
3498 type R23 R21
3499 type R24 R21
3500
3501 func TestEmbed(t *testing.T) {
3502 typ := TypeOf(R0{})
3503 f, ok := typ.FieldByName("X")
3504 if ok {
3505 t.Fatalf(`FieldByName("X") should fail, returned %v`, f.Index)
3506 }
3507 }
3508
3509 func BenchmarkFieldByName3(b *testing.B) {
3510 t := TypeOf(R0{})
3511 for i := 0; i < b.N; i++ {
3512 t.FieldByName("X")
3513 }
3514 }
3515
3516 type S struct {
3517 i1 int64
3518 i2 int64
3519 }
3520
3521 func BenchmarkInterfaceBig(b *testing.B) {
3522 v := ValueOf(S{})
3523 for i := 0; i < b.N; i++ {
3524 v.Interface()
3525 }
3526 b.StopTimer()
3527 }
3528
3529 func TestAllocsInterfaceBig(t *testing.T) {
3530 if testing.Short() {
3531 t.Skip("skipping malloc count in short mode")
3532 }
3533 v := ValueOf(S{})
3534 if allocs := testing.AllocsPerRun(100, func() { v.Interface() }); allocs > 0 {
3535 t.Error("allocs:", allocs)
3536 }
3537 }
3538
3539 func BenchmarkInterfaceSmall(b *testing.B) {
3540 v := ValueOf(int64(0))
3541 for i := 0; i < b.N; i++ {
3542 v.Interface()
3543 }
3544 }
3545
3546 func TestAllocsInterfaceSmall(t *testing.T) {
3547 if testing.Short() {
3548 t.Skip("skipping malloc count in short mode")
3549 }
3550 v := ValueOf(int64(0))
3551 if allocs := testing.AllocsPerRun(100, func() { v.Interface() }); allocs > 0 {
3552 t.Error("allocs:", allocs)
3553 }
3554 }
3555
3556 // An exhaustive is a mechanism for writing exhaustive or stochastic tests.
3557 // The basic usage is:
3558 //
3559 // for x.Next() {
3560 // ... code using x.Maybe() or x.Choice(n) to create test cases ...
3561 // }
3562 //
3563 // Each iteration of the loop returns a different set of results, until all
3564 // possible result sets have been explored. It is okay for different code paths
3565 // to make different method call sequences on x, but there must be no
3566 // other source of non-determinism in the call sequences.
3567 //
3568 // When faced with a new decision, x chooses randomly. Future explorations
3569 // of that path will choose successive values for the result. Thus, stopping
3570 // the loop after a fixed number of iterations gives somewhat stochastic
3571 // testing.
3572 //
3573 // Example:
3574 //
3575 // for x.Next() {
3576 // v := make([]bool, x.Choose(4))
3577 // for i := range v {
3578 // v[i] = x.Maybe()
3579 // }
3580 // fmt.Println(v)
3581 // }
3582 //
3583 // prints (in some order):
3584 //
3585 // []
3586 // [false]
3587 // [true]
3588 // [false false]
3589 // [false true]
3590 // ...
3591 // [true true]
3592 // [false false false]
3593 // ...
3594 // [true true true]
3595 // [false false false false]
3596 // ...
3597 // [true true true true]
3598 //
3599 type exhaustive struct {
3600 r *rand.Rand
3601 pos int
3602 last []choice
3603 }
3604
3605 type choice struct {
3606 off int
3607 n int
3608 max int
3609 }
3610
3611 func (x *exhaustive) Next() bool {
3612 if x.r == nil {
3613 x.r = rand.New(rand.NewSource(time.Now().UnixNano()))
3614 }
3615 x.pos = 0
3616 if x.last == nil {
3617 x.last = []choice{}
3618 return true
3619 }
3620 for i := len(x.last) - 1; i >= 0; i-- {
3621 c := &x.last[i]
3622 if c.n+1 < c.max {
3623 c.n++
3624 x.last = x.last[:i+1]
3625 return true
3626 }
3627 }
3628 return false
3629 }
3630
3631 func (x *exhaustive) Choose(max int) int {
3632 if x.pos >= len(x.last) {
3633 x.last = append(x.last, choice{x.r.Intn(max), 0, max})
3634 }
3635 c := &x.last[x.pos]
3636 x.pos++
3637 if c.max != max {
3638 panic("inconsistent use of exhaustive tester")
3639 }
3640 return (c.n + c.off) % max
3641 }
3642
3643 func (x *exhaustive) Maybe() bool {
3644 return x.Choose(2) == 1
3645 }
Mirror of the offical gcc git repository hosted at gcc.gnu.org