| blob | f9aaa3160903bb623168e76bb99c61707e9a4311 |
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.
5 package reflect_test
8 "bytes"
9 "encoding/base64"
10 "flag"
11 "fmt"
12 "go/token"
13 "internal/goarch"
14 "io"
15 "math"
16 "math/rand"
17 "os"
19 "reflect/internal/example1"
20 "reflect/internal/example2"
21 "runtime"
22 "sort"
23 "strconv"
24 "strings"
25 "sync"
26 "sync/atomic"
27 "testing"
28 "time"
29 "unsafe"
30 )
32 var sink any
38 }
39 }
43 a int
44 b float64
45 c string
47 }
50 i any
51 s string
52 }
57 }
58 }
87 d float32
88 }
89 }{},
91 },
96 }
97 }{},
99 },
102 a int8
103 b int32
104 }
105 }{},
107 },
110 a int8
111 b int8
112 c int32
113 }
114 }{},
116 },
119 a int8
120 b int8
121 c int8
122 d int32
123 }
124 }{},
126 },
129 a int8
130 b int8
131 c int8
132 d int8
133 e int32
134 }
135 }{},
137 },
140 a int8
141 b int8
142 c int8
143 d int8
144 e int8
145 f int32
146 }
147 }{},
149 },
153 }
154 }{},
156 },
160 }
161 }{},
163 },
167 }
168 }{},
170 },
175 })
176 }{},
178 },
181 int32
182 int64
183 }
184 }{},
186 },
187 }
215 d float32
216 }),
218 },
220 "struct { c func(chan *reflect_test.integer, *int8) }{func(chan *reflect_test.integer, *int8)(0)}",
221 },
223 a int8
224 b int32
225 }),
227 },
229 a int8
230 b int8
231 c int32
232 }),
234 },
235 }
241 }
242 }
247 }
248 }
287 }
291 }
292 }
293 }
331 }
335 }
336 }
337 }
343 }
357 }
360 }
363 }
364 }
371 }
372 }))
373 // Making a *MapIter allocates. This should be the only allocation.
376 }
377 }
383 type complex complex128
388 i any
390 }{
391 // signed integer
397 // unsigned integer
404 // floating-point
407 // complex
410 // underlying
415 // not-acceptable
427 }
437 i,
442 )
443 }
444 }
445 }
446 }
452 embed
454 }
456 *embed
458 }
460 Embed
462 }
464 *Embed
466 }
469 // -1 means Addr().Elem() of current value
471 canSet bool
472 }
474 val Value
475 cases []testCase
476 }{{
493 },
494 }, {
509 },
510 }, {
525 },
526 }, {
541 },
542 }}
551 }
556 }
557 }
560 }
561 }
562 })
563 }
564 }
579 }
586 }
587 }
588 }
597 }
605 }
606 }
616 }
623 }
624 }
628 ip := &i
633 }
634 }
642 }
643 }
651 d float32
656 styp := etyp
663 }
669 }
677 mtyp := typ
685 // make sure tag strings are not part of element type
690 }
694 E any
695 }
703 }
707 E any
708 }
719 }
720 }
727 }
729 }
733 }{
736 }
741 }
745 }
746 }
748 }
754 // Convert extra from []int to []Value.
758 }
759 // Convert extra from []int to *SliceValue.
761 // Test Append.
766 }
767 // Check that the orig and extra slices were not modified.
770 }
773 }
774 // Test AppendSlice.
779 }
780 // Check that the orig and extra slices were not modified.
783 }
786 }
787 }
788 }
797 }
798 }
799 a1 := a
800 b1 := b
811 }
812 }
821 }
824 }
825 }
826 }
827 }
837 }
842 }
847 }
848 })
856 }
861 }
866 }
867 })
868 }
873 c := b
880 }
881 }
887 }
888 }
889 }
896 })
899 }
900 }
904 }
912 }
913 }
916 x int
917 y float32
918 }
920 type NotBasic Basic
923 a, b any
924 eq bool
925 }
927 // Simple functions for DeepEqual tests.
932 )
937 type Loopy any
944 p *structWithSelfPtr
945 s string
946 }
949 loop1 = &loop2
950 loop2 = &loop1
952 loopy1 = &loopy2
953 loopy2 = &loopy1
961 }
964 // Equalities
981 // Inequalities
1000 {&structWithSelfPtr{p: &structWithSelfPtr{s: "a"}}, &structWithSelfPtr{p: &structWithSelfPtr{s: "b"}}, false},
1002 // Fun with floating point.
1011 // Nil vs empty: not the same.
1019 // Mismatched types
1031 // Possible loops.
1038 }
1044 }
1047 }
1048 }
1049 }
1052 // Special case for nil
1055 }
1059 continue
1060 }
1064 }
1065 }
1066 }
1069 x int
1070 r *Recursive
1071 }
1079 }
1080 }
1083 a int
1087 }
1097 }
1098 }
1108 }
1109 }
1113 }
1116 // Check that DeepEqual can look at unexported fields.
1121 }
1126 }
1127 }
1130 x, y any
1131 }{
1176 {x: [][6]byte{[6]byte{'a', 'b', 'c', 'a', 'b', 'c'}}, y: [][6]byte{[6]byte{'a', 'b', 'c', 'a', 'b', 'c'}}},
1177 }
1182 }
1188 }
1189 })
1192 }
1193 })
1194 }
1195 }
1203 }
1204 })
1205 }
1206 }
1213 }
1214 }
1216 // Check that structure alignment & offsets viewed through reflect agree with those
1217 // from the compiler itself.
1220 a int
1221 }
1223 T1inner
1224 f int
1225 }
1228 }
1230 T2inner
1231 f int
1232 }
1239 }
1245 }
1246 }
1252 }
1253 }
1256 // These implement IsNil.
1257 // Wrap in extra struct to hide interface type.
1266 }
1271 }
1273 // Check the implementations
1276 }
1283 }
1290 }
1297 }
1303 x any
1304 }
1311 }
1315 }
1319 x any
1320 want bool
1321 }{
1322 // Booleans
1325 // Numeric types
1360 // Array
1365 // Chan
1369 // Func
1372 // Interface
1375 // Map
1379 // Pointer
1383 // Slice
1387 // Strings
1390 // Structs
1393 // UnsafePointer
1396 } {
1397 var x Value
1399 x = v
1402 }
1407 }
1411 }
1412 }
1418 }
1419 }()
1421 }()
1422 }
1426 W io.Writer
1427 }
1433 }
1434 }
1440 }
1441 }
1448 }
1452 // Check that returned Keys match keys in range.
1453 // These aren't required to be in the same order.
1458 break
1459 }
1460 }
1463 }
1465 // Check that value lookup is correct.
1469 }
1471 // Copy into new map.
1473 }
1477 }
1482 }
1488 }
1489 }
1495 }
1501 }
1502 }
1510 }
1512 // Check that value for missing key is zero.
1516 }
1518 // Check big value too.
1523 }
1525 // Test that deletes from a nil map succeed.
1527 }
1532 var cv Value
1534 // check both ways to allocate channels
1542 }
1544 // Send
1548 }
1550 // Recv
1554 }
1556 // TryRecv fail
1560 }
1562 // TryRecv success
1569 }
1571 // TrySend fail
1574 i := <-c
1577 }
1579 // TrySend success
1587 }
1591 }
1592 }
1594 // Close
1599 }
1602 }
1603 }
1605 // check creation of unbuffered channel
1611 }
1614 }
1616 // len/cap
1620 c <- i
1621 }
1624 }
1625 }
1627 // caseInfo describes a single case in a select test.
1629 desc string
1630 canSelect bool
1631 recv Value
1632 closed bool
1634 panic bool
1635 }
1642 var x exhaustive
1645 nch++
1654 }
1655 return
1656 }
1660 break
1661 }
1663 break
1664 }
1667 }
1671 // Ready send.
1678 })
1680 }
1682 // Ready recv.
1689 })
1691 }
1693 // Blocking send.
1700 })
1701 // Let it execute?
1707 }
1708 }
1710 // Blocking recv.
1716 })
1717 // Let it execute?
1723 }
1724 }
1726 // Zero Chan send.
1728 // Maybe include value to send.
1729 var val Value
1732 }
1736 })
1738 }
1740 // Zero Chan receive.
1744 })
1746 }
1748 // nil Chan send.
1754 })
1756 }
1758 // nil Chan recv.
1763 })
1765 }
1767 // closed Chan send.
1775 })
1777 }
1779 // closed Chan recv.
1787 })
1788 info = append(info, caseInfo{desc: "closed Chan recv", canSelect: true, closed: true, recv: val})
1789 }
1793 // Add default? Must be last case here, but will permute.
1794 // Add the default if the select would otherwise
1795 // block forever, and maybe add it anyway.
1805 numCanSelect++
1808 }
1812 }
1813 }
1817 })
1819 numCanSelect++
1821 // Select needs to communicate with another goroutine.
1825 numCanSelect++
1826 }
1828 // Permute cases and case info.
1829 // Doing too much here makes the exhaustive loop
1830 // too exhausting, so just do two swaps.
1836 }
1839 // We wait before kicking off a goroutine to satisfy a blocked select.
1840 // The pause needs to be big enough to let the select block before
1841 // we run the helper, but if we lose that race once in a while it's okay: the
1842 // select will just proceed immediately. Not a big deal.
1843 // For short tests we can grow [sic] the timeout a bit without fear of taking too long
1847 }
1849 }
1851 // Run select.
1855 }
1858 }
1860 continue
1861 }
1868 }
1870 continue
1871 }
1874 continue
1875 }
1879 t.Fatalf("%s\nselected #%d but got %v, %v, want %v, %v", fmtSelect(info), i, recv, recvOK, cas.recv.Interface(), !cas.closed)
1880 }
1883 }
1886 t.Fatalf("%s\nselected #%d, got %#v, %v, and DeepEqual is broken on %T", fmtSelect(info), i, recv.Interface(), recvOK, recv.Interface())
1887 }
1888 t.Fatalf("%s\nselected #%d but got %#v, %v, want %#v, %v", fmtSelect(info), i, recv.Interface(), recvOK, cas.recv.Interface(), !cas.closed)
1889 }
1892 t.Fatalf("%s\nselected #%d but got %v, %v, want %v, %v", fmtSelect(info), i, recv, recvOK, Value{}, false)
1893 }
1894 }
1895 }
1896 }
1906 })
1907 }
1908 // Should not panic
1913 })
1918 }
1921 }
1922 }()
1923 // Should panic
1925 }
1928 // "select { default: }" should always return the default case.
1932 }
1933 }
1943 })
1944 }
1950 }
1951 })
1952 }
1953 }
1955 // selectWatch and the selectWatcher are a watchdog mechanism for running Select.
1956 // If the selectWatcher notices that the select has been blocked for >1 second, it prints
1957 // an error describing the select and panics the entire test binary.
1959 sync.Mutex
1960 once sync.Once
1961 now time.Time
1962 info []caseInfo
1963 }
1972 }
1974 }
1975 }
1977 // runSelect runs a single select test.
1978 // It returns the values returned by Select but also returns
1979 // a panic value if the Select panics.
1980 func runSelect(cases []SelectCase, info []caseInfo) (chosen int, recv Value, recvOK bool, panicErr any) {
1987 }()
1995 return
1996 }
1998 // fmtSelect formats the information about a single select test.
2006 }
2009 }
2012 }
2014 }
2017 }
2021 // Difficult test for function call because of
2022 // implicit padding between arguments.
2023 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) {
2025 }
2036 })
2039 }
2050 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)
2051 }
2056 }
2057 }
2058 }
2066 }
2067 }
2072 member int
2073 }
2077 }
2080 }
2084 }
2088 }
2094 }
2098 }
2102 }
2106 }
2107 }
2112 }
2113 // Issue 21717: past-the-end pointer write in Call with
2114 // nonzero-sized frame and zero-sized return value.
2121 }
2122 v := ValueOf(f).Call(nil)[0] // out[0] should not alias out[1]'s memory, so the finalizer should run.
2129 }
2132 }
2134 }
2143 }
2144 })
2145 }
2151 }
2160 }
2161 }
2166 }
2168 fv Value
2169 arg Value
2170 }{
2176 }
2185 }
2186 })
2187 }
2190 }
2191 }
2194 f := dummy
2198 // Call g with small arguments so that there is
2199 // something predictable (and different from the
2200 // correct results) in those positions on the stack.
2201 g := dummy
2204 // Call constructed function f.
2207 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)
2208 }
2209 }
2215 }
2220 }
2223 }
2226 }
2227 }
2230 // Test that variadic arguments are packed into a slice and passed as last arg
2238 }
2243 }
2248 }
2253 }
2260 }
2264 }
2265 }
2267 // Dummy type that implements io.WriteCloser
2269 }
2273 }
2276 }
2279 // reflect.Values returned from the wrapped function should be assignment-converted
2280 // to the types returned by the result of MakeFunc.
2282 // Concrete types should be promotable to interfaces they implement.
2289 // Super-interfaces should be promotable to simpler interfaces.
2297 // Channels should be promotable to directional channels.
2304 // Unnamed types should be promotable to named types.
2311 }
2314 // Type doesn't implement the required interface.
2321 })
2322 // Assigning to an interface with additional methods.
2330 })
2331 // Directional channels can't be assigned to bidirectional ones.
2339 })
2340 // Two named types which are otherwise identical.
2349 })
2350 }
2354 }
2356 // This will be index 0.
2359 }
2361 // This will be index 1.
2363 //println("Point.Dist", p.x, p.y, scale)
2365 }
2367 // This will be index 2.
2371 }
2373 // This will be index 3.
2375 // Exercise no-argument/no-result paths.
2376 }
2378 // This will be index 4.
2386 }
2387 return tot
2388 }
2390 // This will be index 5.
2392 return x
2393 }
2395 // This will be index 6.
2397 return x
2398 }
2401 // Non-curried method of type.
2406 }
2411 }
2415 }
2420 }
2424 }
2429 }
2434 }
2438 }
2443 }
2447 }
2449 // Curried method of value.
2454 }
2458 }
2462 }
2466 }
2470 // Curried method of pointer.
2474 }
2478 }
2482 }
2486 }
2490 // Curried method of interface value.
2491 // Have to wrap interface value in a struct to get at it.
2492 // Passing it to ValueOf directly would
2493 // access the underlying Point, not the interface.
2496 } = p
2501 }
2505 }
2509 }
2513 }
2514 }
2520 // Check that method value have the same underlying code pointers.
2521 if p1, p2 := ValueOf(Point{1, 1}).Method(1), ValueOf(Point{2, 2}).Method(1); p1.Pointer() != p2.Pointer() {
2523 }
2525 // Curried method of value.
2530 }
2534 }
2538 }
2542 }
2547 // Curried method of pointer.
2551 }
2555 }
2559 }
2563 }
2568 // Curried method of pointer to pointer.
2569 pp := &p
2573 }
2577 }
2581 }
2585 }
2587 // Curried method of interface value.
2588 // Have to wrap interface value in a struct to get at it.
2589 // Passing it to ValueOf directly would
2590 // access the underlying Point, not the interface.
2594 }
2600 }
2604 }
2608 }
2612 }
2614 // For issue #33628: method args are not stored at the right offset
2615 // on amd64p32.
2619 }
2623 }
2624 }
2631 // Variadic method of type.
2635 }
2637 // Curried method of value.
2642 }
2643 i := ValueOf(v.Interface()).Call([]Value{ValueOf(points[0]), ValueOf(points[1]), ValueOf(points[2])})[0].Int()
2646 }
2650 }
2656 }
2660 }
2661 }
2665 }
2676 }
2681 }
2683 pv := &v
2688 }
2693 }
2694 }
2696 // Reflect version of $GOROOT/test/method5.go
2698 // Concrete types implementing M method.
2699 // Smaller than a word, word-sized, larger than a word.
2700 // Value and pointer receivers.
2704 }
2732 }
2734 // Embedding via pointer.
2737 Tm2
2738 }
2741 *Tm3
2742 }
2745 *Tm4
2746 }
2749 }
2758 }
2759 }
2767 }
2770 }
2778 }
2814 var tnil Tinter
2817 }
2823 I any
2826 }
2827 }
2832 }
2838 }
2843 }
2844 }
2847 a string
2848 int
2849 }
2852 var field StructField
2854 var t1 T1
2858 }
2861 }
2862 }
2865 s any
2866 name string
2868 value int
2869 }
2872 d int
2873 }
2875 d int
2876 }
2880 D1
2881 D2
2882 }
2885 B int
2886 S0
2887 }
2890 A int
2891 *S1
2892 }
2895 S1
2896 }
2899 S1
2900 }
2903 S1x
2904 S2
2906 *S1y
2907 }
2910 *S4
2911 A int
2912 }
2914 // The X in S6 and S7 annihilate, but they also block the X in S8.S9.
2916 S6
2917 S7
2918 S8
2919 }
2922 X int
2923 }
2925 type S7 S6
2928 S9
2929 }
2932 X int
2933 Y int
2934 }
2936 // The X in S11.S6 and S12.S6 annihilate, but they also block the X in S13.S8.S9.
2938 S11
2939 S12
2940 S13
2941 }
2944 S6
2945 }
2948 S6
2949 }
2952 S8
2953 }
2955 // The X in S15.S11.S1 and S16.S11.S1 annihilate.
2957 S15
2958 S16
2959 }
2962 S11
2963 }
2966 S11
2967 }
2995 }
3005 }
3008 }
3011 }
3019 }
3022 }
3025 }
3026 }
3027 }
3028 }
3036 // Verify field depth and index.
3038 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)
3043 }
3044 }
3045 }
3048 }
3051 }
3059 }
3062 }
3065 }
3066 }
3067 }
3068 }
3072 t Type
3073 path string
3074 }{
3104 }
3108 }
3109 }
3110 }
3115 Exported string
3116 unexported string
3117 OtherPkgFields
3120 }{})
3124 pkgPath string
3125 embedded bool
3126 exported bool
3127 }
3134 }
3137 }
3140 }
3141 }
3142 }
3152 })
3154 type localOtherPkgFields OtherPkgFields
3159 })
3160 }
3166 }
3168 I
3174 name string
3175 pkgPath string
3176 exported bool
3177 }{
3182 }
3188 }
3191 }
3192 }
3193 }
3196 // Test example from Type documentation.
3203 // ok
3204 return
3205 }
3206 }
3207 }
3209 // Failed
3214 }
3216 }
3219 x int
3220 }
3223 y int
3224 inner
3225 }
3233 if typ.NumMethod() != 1 || typ.Method(0).Func.UnsafePointer() != ValueOf((*outer).M).UnsafePointer() {
3238 }
3239 }
3240 }
3249 }
3258 }
3259 }
3262 X int
3263 }
3266 Y int
3267 InnerInt
3268 }
3272 }
3275 /* This part of the test fails on gccgo due to function wrappers.
3276 typ := TypeOf((*OuterInt)(nil))
3277 if typ.NumMethod() != 1 || typ.Method(0).Func.UnsafePointer() != ValueOf((*OuterInt).M).UnsafePointer() {
3278 t.Errorf("Wrong method table for OuterInt: (m=%p)", (*OuterInt).M)
3279 for i := 0; i < typ.NumMethod(); i++ {
3280 m := typ.Method(i)
3281 t.Errorf("\t%d: %s %p\n", i, m.Name, m.Func.UnsafePointer())
3282 }
3283 }
3284 */
3289 }
3294 }
3299 }
3300 }
3310 }
3311 }
3314 // This block of code means that the ptrToThis field of the
3315 // reflect data for *unsafe.Pointer is non zero, see
3316 // https://golang.org/issue/19003
3326 }
3329 }
3332 }
3333 }
3348 }
3355 }
3356 }
3357 }
3360 // Construct a type with a zero ptrToThis.
3366 }
3369 }
3372 // Now benchmark calling PointerTo on it: we'll have to hit the ptrMap cache on
3373 // every call.
3377 }
3378 })
3379 }
3384 }
3394 }
3396 // Again but take address of the ValueOf value.
3397 // Exercises generation of PtrTypes not present in the binary.
3398 q := &p
3409 }
3411 // Starting without pointer we should get changed value
3412 // in interface.
3413 qq := p
3415 v0 := v
3422 }
3425 })
3428 }
3430 // Verify that taking the address of a type gives us a pointer
3431 // which we can convert back using the usual interface
3432 // notation.
3435 }
3440 }
3441 }
3443 /* gccgo does do allocations here.
3445 func noAlloc(t *testing.T, n int, f func(int)) {
3446 if testing.Short() {
3447 t.Skip("skipping malloc count in short mode")
3448 }
3449 if runtime.GOMAXPROCS(0) > 1 {
3450 t.Skip("skipping; GOMAXPROCS>1")
3451 }
3452 i := -1
3453 allocs := testing.AllocsPerRun(n, func() {
3454 f(i)
3455 i++
3456 })
3457 if allocs > 0 {
3458 t.Errorf("%d iterations: got %v mallocs, want 0", n, allocs)
3459 }
3460 }
3462 func TestAllocations(t *testing.T) {
3463 noAlloc(t, 100, func(j int) {
3464 var i any
3465 var v Value
3467 // We can uncomment this when compiler escape analysis
3468 // is good enough to see that the integer assigned to i
3469 // does not escape and therefore need not be allocated.
3470 //
3471 // i = 42 + j
3472 // v = ValueOf(i)
3473 // if int(v.Int()) != 42+j {
3474 // panic("wrong int")
3475 // }
3477 i = func(j int) int { return j }
3478 v = ValueOf(i)
3479 if v.Interface().(func(int) int)(j) != j {
3480 panic("wrong result")
3481 }
3482 })
3483 }
3485 */
3492 }
3493 }
3500 }
3505 }
3510 }
3511 }
3518 }
3521 }
3524 }
3529 }
3532 }
3535 }
3540 }
3549 }
3550 }
3557 }
3560 }
3563 }
3573 }
3576 }
3579 }
3596 }
3597 }
3612 }
3616 }
3620 }
3627 }
3631 V := ValueOf
3637 }
3643 }
3644 }
3652 }
3653 }
3657 B string
3658 C int32
3659 }
3661 gotA padded
3662 gotB uint32
3665 )
3668 }
3672 }
3673 }
3676 Tag StructTag
3677 Key string
3678 Value string
3679 }{
3687 }
3693 }
3694 }
3695 }
3703 }
3706 }
3707 }
3711 var x B
3716 }
3719 }
3720 }
3723 x int
3725 Z int
3726 }
3729 }
3732 Z int
3733 z int
3734 S string
3736 T []Private
3737 }
3740 }
3743 X int
3745 private
3746 }
3749 }
3752 var pub Public
3778 var priv Private
3789 }
3797 W int
3798 }
3801 Y int
3802 t0
3803 }
3806 Z int
3807 namedT0 t0
3808 }
3811 X int
3812 t1
3813 T2
3814 NamedT1 t1
3815 NamedT2 T2
3816 namedT1 t1
3817 namedT2 T2
3818 }
3820 // not addressable
3848 // addressable
3875 }
3888 }
3892 }
3894 T1
3895 t0
3896 }
3898 t0 // 0
3899 T1 // 1
3901 NamedT0 t0 // 2
3902 NamedT1 T1 // 3
3903 NamedT2 T2 // 4
3905 namedT0 t0 // 5
3906 namedT1 T1 // 6
3907 namedT2 T2 // 7
3908 }
3954 }
3961 }
3966 s = r
3971 }
3974 }
3977 }
3978 }
3979 }()
3981 }
3986 }
3987 }
3992 }
3993 }
4004 }
4005 }
4011 }
4015 }
4019 }
4024 }
4028 }
4029 }
4033 }
4034 }
4053 in Value
4054 out Value
4055 }{
4056 // numbers
4057 /*
4058 Edit .+1,/\*\//-1>cat >/tmp/x.go && go run /tmp/x.go
4060 package main
4062 import "fmt"
4064 var numbers = []string{
4065 "int8", "uint8", "int16", "uint16",
4066 "int32", "uint32", "int64", "uint64",
4067 "int", "uint", "uintptr",
4068 "float32", "float64",
4069 }
4071 func main() {
4072 // all pairs but in an unusual order,
4073 // to emit all the int8, uint8 cases
4074 // before n grows too big.
4075 n := 1
4076 for i, f := range numbers {
4077 for _, g := range numbers[i:] {
4078 fmt.Printf("\t{V(%s(%d)), V(%s(%d))},\n", f, n, g, n)
4079 n++
4080 if f != g {
4081 fmt.Printf("\t{V(%s(%d)), V(%s(%d))},\n", g, n, f, n)
4082 n++
4083 }
4084 }
4085 }
4086 }
4087 */
4258 // truncation
4261 // complex
4267 // string
4299 // named string
4333 // named []byte
4340 // named []rune
4347 // slice to array pointer
4371 // named types and equal underlying types
4384 // structs with different tags
4389 }{})},
4395 }{})},
4399 }{})},
4407 }{})},
4416 // can convert *byte and *MyByte
4420 // cannot convert mismatched array sizes
4424 // cannot convert other instances
4438 // other
4454 // channels
4480 // cannot convert other instances (channels)
4488 // interfaces
4494 }
4504 continue
4505 }
4510 continue
4511 }
4517 // vout1 represents the in value converted to the in type.
4521 }
4525 t.Errorf("ValueOf(%T(%[1]v)).Convert(%s) = %T(%[3]v), want %T(%[4]v)", tt.in.Interface(), t1, out1, tt.in.Interface())
4526 }
4528 // vout2 represents the in value converted to the out type.
4531 }
4535 t.Errorf("ValueOf(%T(%[1]v)).Convert(%s) = %T(%[3]v), want %T(%[4]v)", tt.in.Interface(), t2, out2, tt.out.Interface())
4536 }
4538 t.Errorf("ValueOf(%T(%[1]v)).Convert(%s) has internal kind %v want %v", tt.in.Interface(), t1, got, want)
4539 }
4541 // vout3 represents a new value of the out type, set to vout2. This makes
4542 // sure the converted value vout2 is really usable as a regular value.
4547 t.Errorf("Set(ValueOf(%T(%[1]v)).Convert(%s)) = %T(%[3]v), want %T(%[4]v)", tt.in.Interface(), t2, out3, tt.out.Interface())
4548 }
4552 }
4555 }
4558 }
4561 }
4564 }
4567 }
4568 }
4570 // Assume that of all the types we saw during the tests,
4571 // if there wasn't an explicit entry for a conversion between
4572 // a pair of types, then it's not to be allowed. This checks for
4573 // things like 'int64' converting to '*int'.
4576 expectOK := t1 == t2 || canConvert[[2]Type{t1, t2}] || t2.Kind() == Interface && t2.NumMethod() == 0
4579 }
4580 }
4581 }
4582 }
4591 }
4594 }
4595 shouldPanic("reflect: cannot convert slice with length 4 to pointer to array with length 8", func() {
4597 })
4598 }
4605 // Test to see if a store followed by a load of a signaling NaN
4606 // maintains the signaling bit. (This used to fail on the 387 port.)
4611 }
4612 // Test reflect's conversion between float32s. See issue 36400.
4620 }
4622 }
4623 }
4626 X int
4627 }
4630 X int
4632 }
4635 typ Type
4636 ok bool
4637 }{
4653 }
4659 }
4660 }
4661 }
4666 }
4671 }
4675 }
4678 }
4683 }
4686 }
4690 }
4695 }
4699 }
4700 }
4705 }
4706 }
4709 // check construction and use of type not in binary
4711 n int
4713 comparable bool
4714 want string
4715 }{
4716 {
4721 },
4722 {
4727 },
4728 {
4733 },
4734 {
4739 },
4740 {
4745 },
4746 {
4751 },
4752 {
4757 },
4758 {
4763 },
4764 {
4769 },
4770 {
4775 },
4776 {
4780 U int
4781 V float64
4782 }
4784 },
4787 },
4788 }
4798 j := i
4801 }
4803 }
4807 }
4810 t.Errorf("constructed array (%#v) is comparable=%v, want=%v", v.Interface(), at.Comparable(), table.comparable)
4811 }
4818 )
4819 }
4820 }
4825 )
4826 }
4827 }
4828 }
4830 // check that type already in binary is found
4833 }
4846 }
4848 }
4857 }
4858 }
4859 }
4860 }
4868 }
4872 }
4877 }
4886 }
4892 }
4898 }
4900 // Test hash
4905 }
4906 }
4909 {
4921 }
4925 }
4926 }
4927 {
4939 }
4943 }
4944 }
4945 }
4947 // Ensure passing in negative lengths panics.
4948 // See https://golang.org/issue/43603
4952 })
4953 }
4956 // check construction and use of type not in binary
4961 }
4967 }
4972 }
4974 // check that type already in binary is found
4977 }
4980 // check that MakeSlice panics when size of slice overflows uint
4986 }
4993 }
4994 }()
4996 }
5010 }
5012 }
5021 }
5022 }
5023 }
5024 }
5027 // invalid field name "1nvalid"
5032 })
5033 })
5035 // invalid field name "+"
5040 })
5041 })
5043 // no field name
5047 })
5048 })
5050 // verify creation of a struct with valid struct fields
5052 {
5055 },
5056 {
5059 },
5060 {
5063 },
5064 }
5071 }
5072 }
5075 // check construction and use of type not in binary
5077 {
5081 },
5082 {
5086 },
5087 {
5090 },
5091 {
5094 },
5095 }
5108 }
5112 }
5114 // check the size, alignment and field offsets
5116 String string
5117 X byte
5118 Y uint64
5120 }{})
5123 }
5126 }
5129 }
5135 }
5136 }
5138 // Check size and alignment with a trailing zero-sized field.
5140 {
5143 },
5144 {
5147 },
5148 })
5150 G1 byte
5152 }{})
5153 // Broken with gccgo for now--gccgo does not pad structs yet.
5154 // if st.Size() != stt.Size() {
5155 // t.Errorf("constructed zero-padded struct size = %v, want %v", st.Size(), stt.Size())
5156 // }
5159 }
5161 t.Errorf("constructed zero-padded struct field align = %v, want %v", st.FieldAlign(), stt.FieldAlign())
5162 }
5168 }
5169 }
5171 // check duplicate names
5176 })
5177 })
5182 })
5183 })
5188 })
5189 })
5190 // check that type already in binary is found
5193 // gccgo used to fail this test.
5194 type structFieldType any
5197 {
5200 },
5201 }),
5203 }
5216 }
5219 }
5220 }()
5222 }
5225 field StructField
5226 mustPanic bool
5227 exported bool
5228 }{
5229 {
5232 },
5233 {
5236 },
5237 {
5240 },
5241 {
5244 },
5245 {
5248 },
5249 {
5252 },
5253 {
5256 },
5257 {
5258 field: StructField{Name: "S1", Anonymous: true, Type: TypeOf((*S1)(nil)), PkgPath: "other/pkg"},
5260 },
5261 {
5264 },
5265 {
5266 field: StructField{Name: "s2", Anonymous: true, Type: TypeOf((*s2)(nil)), PkgPath: "other/pkg"},
5268 },
5269 {
5271 },
5272 {
5274 },
5275 {
5278 },
5279 {
5282 },
5283 {
5286 },
5287 {
5290 },
5291 {
5294 },
5295 {
5298 },
5299 {
5302 },
5303 {
5306 },
5307 {
5309 },
5310 {
5312 },
5313 {
5315 },
5316 {
5318 },
5319 {
5322 },
5323 {
5326 },
5327 {
5330 },
5331 {
5334 },
5335 }
5342 return
5343 }
5348 }
5352 }
5355 }
5356 })
5357 }
5358 }
5366 }
5377 }
5379 }
5388 }
5389 }
5390 }
5391 }
5399 }
5403 }
5408 }
5414 })
5418 })
5421 rt Type
5423 }{
5424 {
5427 },
5428 {
5431 },
5432 {
5437 },
5438 ),
5440 },
5441 {
5447 },
5448 ),
5450 },
5451 {
5456 },
5457 ),
5459 },
5460 {
5466 },
5467 ),
5469 },
5470 {
5476 },
5477 ),
5479 },
5480 {
5486 },
5487 ),
5489 },
5490 {
5497 },
5498 ),
5500 },
5501 }
5509 }
5515 }
5523 }
5525 // Test hash
5530 }
5535 }
5539 }
5540 }
5541 }
5544 {
5551 {
5554 },
5561 }
5565 }
5566 }
5567 {
5574 {
5577 },
5584 }
5588 }
5589 }
5590 }
5602 SettableField int
5603 }
5609 }
5613 /*
5614 gccgo does not yet support StructOf with methods.
5616 func TestStructOfWithInterface(t *testing.T) {
5617 const want = 42
5618 type Iface interface {
5619 Get() int
5620 }
5621 type IfaceSet interface {
5622 Set(int)
5623 }
5624 tests := []struct {
5625 name string
5626 typ Type
5627 val Value
5628 impl bool
5629 }{
5630 {
5631 name: "StructI",
5632 typ: TypeOf(StructI(want)),
5633 val: ValueOf(StructI(want)),
5634 impl: true,
5635 },
5636 {
5637 name: "StructI",
5638 typ: PointerTo(TypeOf(StructI(want))),
5639 val: ValueOf(func() any {
5640 v := StructI(want)
5641 return &v
5642 }()),
5643 impl: true,
5644 },
5645 {
5646 name: "StructIPtr",
5647 typ: PointerTo(TypeOf(StructIPtr(want))),
5648 val: ValueOf(func() any {
5649 v := StructIPtr(want)
5650 return &v
5651 }()),
5652 impl: true,
5653 },
5654 {
5655 name: "StructIPtr",
5656 typ: TypeOf(StructIPtr(want)),
5657 val: ValueOf(StructIPtr(want)),
5658 impl: false,
5659 },
5660 // {
5661 // typ: TypeOf((*Iface)(nil)).Elem(), // FIXME(sbinet): fix method.ifn/tfn
5662 // val: ValueOf(StructI(want)),
5663 // impl: true,
5664 // },
5665 }
5667 for i, table := range tests {
5668 for j := 0; j < 2; j++ {
5669 var fields []StructField
5670 if j == 1 {
5671 fields = append(fields, StructField{
5672 Name: "Dummy",
5673 PkgPath: "",
5674 Type: TypeOf(int(0)),
5675 })
5676 }
5677 fields = append(fields, StructField{
5678 Name: table.name,
5679 Anonymous: true,
5680 PkgPath: "",
5681 Type: table.typ,
5682 })
5684 // We currently do not correctly implement methods
5685 // for embedded fields other than the first.
5686 // Therefore, for now, we expect those methods
5687 // to not exist. See issues 15924 and 20824.
5688 // When those issues are fixed, this test of panic
5689 // should be removed.
5690 if j == 1 && table.impl {
5691 func() {
5692 defer func() {
5693 if err := recover(); err == nil {
5694 t.Errorf("test-%d-%d did not panic", i, j)
5695 }
5696 }()
5697 _ = StructOf(fields)
5698 }()
5699 continue
5700 }
5702 rt := StructOf(fields)
5703 rv := New(rt).Elem()
5704 rv.Field(j).Set(table.val)
5706 if _, ok := rv.Interface().(Iface); ok != table.impl {
5707 if table.impl {
5708 t.Errorf("test-%d-%d: type=%v fails to implement Iface.\n", i, j, table.typ)
5709 } else {
5710 t.Errorf("test-%d-%d: type=%v should NOT implement Iface\n", i, j, table.typ)
5711 }
5712 continue
5713 }
5715 if !table.impl {
5716 continue
5717 }
5719 v := rv.Interface().(Iface).Get()
5720 if v != want {
5721 t.Errorf("test-%d-%d: x.Get()=%v. want=%v\n", i, j, v, want)
5722 }
5724 fct := rv.MethodByName("Get")
5725 out := fct.Call(nil)
5726 if !DeepEqual(out[0].Interface(), want) {
5727 t.Errorf("test-%d-%d: x.Get()=%v. want=%v\n", i, j, out[0].Interface(), want)
5728 }
5729 }
5730 }
5732 // Test an embedded nil pointer with pointer methods.
5733 fields := []StructField{{
5734 Name: "StructIPtr",
5735 Anonymous: true,
5736 Type: PointerTo(TypeOf(StructIPtr(want))),
5737 }}
5738 rt := StructOf(fields)
5739 rv := New(rt).Elem()
5740 // This should panic since the pointer is nil.
5741 shouldPanic("", func() {
5742 rv.Interface().(IfaceSet).Set(want)
5743 })
5745 // Test an embedded nil pointer to a struct with pointer methods.
5747 fields = []StructField{{
5748 Name: "SettableStruct",
5749 Anonymous: true,
5750 Type: PointerTo(TypeOf(SettableStruct{})),
5751 }}
5752 rt = StructOf(fields)
5753 rv = New(rt).Elem()
5754 // This should panic since the pointer is nil.
5755 shouldPanic("", func() {
5756 rv.Interface().(IfaceSet).Set(want)
5757 })
5759 // The behavior is different if there is a second field,
5760 // since now an interface value holds a pointer to the struct
5761 // rather than just holding a copy of the struct.
5762 fields = []StructField{
5763 {
5764 Name: "SettableStruct",
5765 Anonymous: true,
5766 Type: PointerTo(TypeOf(SettableStruct{})),
5767 },
5768 {
5769 Name: "EmptyStruct",
5770 Anonymous: true,
5771 Type: StructOf(nil),
5772 },
5773 }
5774 // With the current implementation this is expected to panic.
5775 // Ideally it should work and we should be able to see a panic
5776 // if we call the Set method.
5777 shouldPanic("", func() {
5778 StructOf(fields)
5779 })
5781 // Embed a field that can be stored directly in an interface,
5782 // with a second field.
5783 fields = []StructField{
5784 {
5785 Name: "SettablePointer",
5786 Anonymous: true,
5787 Type: TypeOf(SettablePointer{}),
5788 },
5789 {
5790 Name: "EmptyStruct",
5791 Anonymous: true,
5792 Type: StructOf(nil),
5793 },
5794 }
5795 // With the current implementation this is expected to panic.
5796 // Ideally it should work and we should be able to call the
5797 // Set and Get methods.
5798 shouldPanic("", func() {
5799 StructOf(fields)
5800 })
5801 }
5802 */
5807 }
5809 // Bug Fix: #25402 - this should not panic
5812 })
5816 }
5817 }
5821 {
5825 },
5826 {
5830 },
5831 }
5834 })
5835 }
5838 // check construction and use of type not in binary
5854 }
5856 // check that type already in binary is found
5860 // Check arrow token association in undefined chan types.
5867 }
5870 }
5871 }
5874 // check construction and use of type not in binary
5879 // check that type already in binary is found
5884 // check String form of ChanDir
5887 }
5890 }
5891 }
5900 }
5901 }()
5905 }()
5911 // NOTE: The garbage collector handles allocated channels specially,
5912 // so we have to save pointers to channels in x; the pointer code will
5913 // use the gc info in the newly constructed chan type.
5922 }
5926 }
5936 }
5937 }
5938 }
5939 }
5942 // check construction and use of type not in binary
5955 }
5957 // check that type already in binary is found
5960 // check that invalid key type panics
5962 }
5969 // NOTE: The garbage collector handles allocated maps specially,
5970 // so we have to save pointers to maps in x; the pointer code will
5971 // use the gc info in the newly constructed map type.
5980 }
5984 }
5992 }
5997 }
5998 }
5999 }
6000 }
6007 // NOTE: The garbage collector handles allocated maps specially,
6008 // so we have to save pointers to maps in x; the pointer code will
6009 // use the gc info in the newly constructed map type.
6018 }
6022 }
6031 }
6032 }
6033 }
6034 }
6041 }
6042 last = n
6043 }
6044 }
6047 // check construction and use of type not in binary
6058 }
6060 }
6068 }
6072 }
6074 // check that types already in binary are found
6078 variadic bool
6079 want any
6080 }{
6085 {in: []Type{TypeOf(int(0))}, out: []Type{TypeOf(false), TypeOf("")}, want: (func(int) (bool, string))(nil)},
6086 }
6089 }
6091 // check that variadic requires last element be a slice.
6093 shouldPanic("must be slice", func() { FuncOf([]Type{TypeOf(0), TypeOf(""), TypeOf(false)}, nil, true) })
6095 }
6098 X int
6099 Y int
6100 Z int
6101 }
6108 }
6109 })
6110 }
6117 }
6118 })
6119 }
6122 *R1
6123 *R2
6124 *R3
6125 *R4
6126 }
6129 *R5
6130 *R6
6131 *R7
6132 *R8
6133 }
6135 type R2 R1
6136 type R3 R1
6137 type R4 R1
6140 *R9
6141 *R10
6142 *R11
6143 *R12
6144 }
6146 type R6 R5
6147 type R7 R5
6148 type R8 R5
6151 *R13
6152 *R14
6153 *R15
6154 *R16
6155 }
6157 type R10 R9
6158 type R11 R9
6159 type R12 R9
6162 *R17
6163 *R18
6164 *R19
6165 *R20
6166 }
6168 type R14 R13
6169 type R15 R13
6170 type R16 R13
6173 *R21
6174 *R22
6175 *R23
6176 *R24
6177 }
6179 type R18 R17
6180 type R19 R17
6181 type R20 R17
6184 X int
6185 }
6187 type R22 R21
6188 type R23 R21
6189 type R24 R21
6196 }
6197 }
6204 }
6205 })
6206 }
6209 i1 int64
6210 i2 int64
6211 }
6218 }
6219 })
6221 }
6226 }
6230 }
6231 }
6238 }
6239 })
6240 }
6245 }
6249 }
6250 }
6252 // An exhaustive is a mechanism for writing exhaustive or stochastic tests.
6253 // The basic usage is:
6254 //
6255 // for x.Next() {
6256 // ... code using x.Maybe() or x.Choice(n) to create test cases ...
6257 // }
6258 //
6259 // Each iteration of the loop returns a different set of results, until all
6260 // possible result sets have been explored. It is okay for different code paths
6261 // to make different method call sequences on x, but there must be no
6262 // other source of non-determinism in the call sequences.
6263 //
6264 // When faced with a new decision, x chooses randomly. Future explorations
6265 // of that path will choose successive values for the result. Thus, stopping
6266 // the loop after a fixed number of iterations gives somewhat stochastic
6267 // testing.
6268 //
6269 // Example:
6270 //
6271 // for x.Next() {
6272 // v := make([]bool, x.Choose(4))
6273 // for i := range v {
6274 // v[i] = x.Maybe()
6275 // }
6276 // fmt.Println(v)
6277 // }
6278 //
6279 // prints (in some order):
6280 //
6281 // []
6282 // [false]
6283 // [true]
6284 // [false false]
6285 // [false true]
6286 // ...
6287 // [true true]
6288 // [false false false]
6289 // ...
6290 // [true true true]
6291 // [false false false false]
6292 // ...
6293 // [true true true true]
6294 //
6297 pos int
6298 last []choice
6299 }
6302 off int
6303 n int
6304 max int
6305 }
6310 }
6315 }
6322 }
6323 }
6325 }
6330 }
6335 }
6337 }
6341 }
6346 }
6351 }
6359 }
6360 }
6367 }
6368 }
6377 }
6378 }
6379 }
6384 a uint64
6385 T T
6386 b uint64
6387 }
6392 }
6397 }) {
6399 }
6400 }
6404 F int
6405 }
6407 *P
6408 }
6418 }
6419 }()
6423 }
6425 // Given
6426 // type Outer struct {
6427 // *Inner
6428 // ...
6429 // }
6430 // the compiler generates the implementation of (*Outer).M dispatching to the embedded Inner.
6431 // The implementation is logically:
6432 // func (p *Outer) M() {
6433 // (p.Inner).M()
6434 // }
6435 // but since the only change here is the replacement of one pointer receiver with another,
6436 // the actual generated code overwrites the original receiver with the p.Inner pointer and
6437 // then jumps to the M method expecting the *Inner receiver.
6438 //
6439 // During reflect.Value.Call, we create an argument frame and the associated data structures
6440 // to describe it to the garbage collector, populate the frame, call reflect.call to
6441 // run a function call using that frame, and then copy the results back out of the frame.
6442 // The reflect.call function does a memmove of the frame structure onto the
6443 // stack (to set up the inputs), runs the call, and the memmoves the stack back to
6444 // the frame structure (to preserve the outputs).
6445 //
6446 // Originally reflect.call did not distinguish inputs from outputs: both memmoves
6447 // were for the full stack frame. However, in the case where the called function was
6448 // one of these wrappers, the rewritten receiver is almost certainly a different type
6449 // than the original receiver. This is not a problem on the stack, where we use the
6450 // program counter to determine the type information and understand that
6451 // during (*Outer).M the receiver is an *Outer while during (*Inner).M the receiver in the same
6452 // memory word is now an *Inner. But in the statically typed argument frame created
6453 // by reflect, the receiver is always an *Outer. Copying the modified receiver pointer
6454 // off the stack into the frame will store an *Inner there, and then if a garbage collection
6455 // happens to scan that argument frame before it is discarded, it will scan the *Inner
6456 // memory as if it were an *Outer. If the two have different memory layouts, the
6457 // collection will interpret the memory incorrectly.
6458 //
6459 // One such possible incorrect interpretation is to treat two arbitrary memory words
6460 // (Inner.P1 and Inner.P2 below) as an interface (Outer.R below). Because interpreting
6461 // an interface requires dereferencing the itab word, the misinterpretation will try to
6462 // deference Inner.P1, causing a crash during garbage collection.
6463 //
6464 // This came up in a real program in issue 7725.
6467 *Inner
6468 R io.Reader
6469 }
6472 X *Outer
6473 P1 uintptr
6474 P2 uintptr
6475 }
6478 // Clear references to pi so that the only way the
6479 // garbage collection will find the pointer is in the
6480 // argument frame, typed as a *Outer.
6483 // Set up an interface value that will cause a crash.
6484 // P1 = 1 is a non-zero, so the interface looks non-nil.
6485 // P2 = pi ensures that the data word points into the
6486 // allocated heap; if not the collection skips the interface
6487 // value as irrelevant, without dereferencing P1.
6490 }
6493 // In reflect.Value.Call, trigger a garbage collection after reflect.call
6494 // returns but before the args frame has been discarded.
6495 // This is a little clumsy but makes the failure repeatable.
6502 // Stop garbage collecting during reflect.call.
6504 }
6511 // In reflect.Value.Call, trigger a garbage collection in reflect.call
6512 // between marshaling argument and the actual call.
6519 }
6520 })
6525 // Stop garbage collecting during reflect.call.
6527 }
6534 }
6542 }
6543 }
6545 // use about n KB of stack
6548 return
6549 }
6552 }
6562 }
6566 t.Errorf("ValueOf(Impl{}).Method(0).String() = %q, want %q", method.String(), "<func() Value>")
6567 }
6568 }
6571 // Used to have inconsistency between IsValid() and Kind() != Invalid.
6577 }
6581 }
6582 }
6584 // Issue 8917.
6588 }
6593 }()
6596 return
6597 }
6599 // Issue 15046.
6603 i int
6604 mustPanic bool
6605 }{
6610 }
6616 }
6620 }
6621 }
6622 }
6623 }
6625 // Issue 9179.
6628 }
6632 }
6636 }
6638 // Issue 18635 (function version).
6640 // Test that we keep makeFuncImpl live as long as it is
6641 // referenced on the stack.
6648 // We can't use Value.Call here because
6649 // runtime.call* will keep the makeFuncImpl
6650 // alive. However, by converting it to an
6651 // interface value and calling that,
6652 // reflect.callReflect is the only thing that
6653 // can keep the makeFuncImpl live.
6654 //
6655 // Alternate between f and g so that if we do
6656 // reuse the memory prematurely it's more
6657 // likely to get obviously corrupted.
6659 }
6661 }
6667 }
6669 }
6676 // Issue 21177
6681 }
6682 }()
6687 }
6688 }
6690 // Issue 18635 (method version).
6697 }
6698 }
6703 }
6706 // Test that we keep methodValue live as long as it is
6707 // referenced on the stack.
6709 }
6711 // clobber tries to clobber unreachable memory.
6717 sink = obj
6718 }
6719 }
6721 }
6723 /*
6725 func TestFuncLayout(t *testing.T) {
6726 align := func(x uintptr) uintptr {
6727 return (x + goarch.PtrSize - 1) &^ (goarch.PtrSize - 1)
6728 }
6729 var r []byte
6730 if goarch.PtrSize == 4 {
6731 r = []byte{0, 0, 0, 1}
6732 } else {
6733 r = []byte{0, 0, 1}
6734 }
6736 type S struct {
6737 a, b uintptr
6738 c, d *byte
6739 }
6741 type test struct {
6742 rcvr, typ Type
6743 size, argsize, retOffset uintptr
6744 stack, gc, inRegs, outRegs []byte // pointer bitmap: 1 is pointer, 0 is scalar
6745 intRegs, floatRegs int
6746 floatRegSize uintptr
6747 }
6748 tests := []test{
6749 {
6750 typ: ValueOf(func(a, b string) string { return "" }).Type(),
6751 size: 6 * goarch.PtrSize,
6752 argsize: 4 * goarch.PtrSize,
6753 retOffset: 4 * goarch.PtrSize,
6754 stack: []byte{1, 0, 1, 0, 1},
6755 gc: []byte{1, 0, 1, 0, 1},
6756 },
6757 {
6758 typ: ValueOf(func(a, b, c uint32, p *byte, d uint16) {}).Type(),
6759 size: align(align(3*4) + goarch.PtrSize + 2),
6760 argsize: align(3*4) + goarch.PtrSize + 2,
6761 retOffset: align(align(3*4) + goarch.PtrSize + 2),
6762 stack: r,
6763 gc: r,
6764 },
6765 {
6766 typ: ValueOf(func(a map[int]int, b uintptr, c any) {}).Type(),
6767 size: 4 * goarch.PtrSize,
6768 argsize: 4 * goarch.PtrSize,
6769 retOffset: 4 * goarch.PtrSize,
6770 stack: []byte{1, 0, 1, 1},
6771 gc: []byte{1, 0, 1, 1},
6772 },
6773 {
6774 typ: ValueOf(func(a S) {}).Type(),
6775 size: 4 * goarch.PtrSize,
6776 argsize: 4 * goarch.PtrSize,
6777 retOffset: 4 * goarch.PtrSize,
6778 stack: []byte{0, 0, 1, 1},
6779 gc: []byte{0, 0, 1, 1},
6780 },
6781 {
6782 rcvr: ValueOf((*byte)(nil)).Type(),
6783 typ: ValueOf(func(a uintptr, b *int) {}).Type(),
6784 size: 3 * goarch.PtrSize,
6785 argsize: 3 * goarch.PtrSize,
6786 retOffset: 3 * goarch.PtrSize,
6787 stack: []byte{1, 0, 1},
6788 gc: []byte{1, 0, 1},
6789 },
6790 {
6791 typ: ValueOf(func(a uintptr) {}).Type(),
6792 size: goarch.PtrSize,
6793 argsize: goarch.PtrSize,
6794 retOffset: goarch.PtrSize,
6795 stack: []byte{},
6796 gc: []byte{},
6797 },
6798 {
6799 typ: ValueOf(func() uintptr { return 0 }).Type(),
6800 size: goarch.PtrSize,
6801 argsize: 0,
6802 retOffset: 0,
6803 stack: []byte{},
6804 gc: []byte{},
6805 },
6806 {
6807 rcvr: ValueOf(uintptr(0)).Type(),
6808 typ: ValueOf(func(a uintptr) {}).Type(),
6809 size: 2 * goarch.PtrSize,
6810 argsize: 2 * goarch.PtrSize,
6811 retOffset: 2 * goarch.PtrSize,
6812 stack: []byte{1},
6813 gc: []byte{1},
6814 // Note: this one is tricky, as the receiver is not a pointer. But we
6815 // pass the receiver by reference to the autogenerated pointer-receiver
6816 // version of the function.
6817 },
6818 // TODO(mknyszek): Add tests for non-zero register count.
6819 }
6820 for _, lt := range tests {
6821 name := lt.typ.String()
6822 if lt.rcvr != nil {
6823 name = lt.rcvr.String() + "." + name
6824 }
6825 t.Run(name, func(t *testing.T) {
6826 defer SetArgRegs(SetArgRegs(lt.intRegs, lt.floatRegs, lt.floatRegSize))
6828 typ, argsize, retOffset, stack, gc, inRegs, outRegs, ptrs := FuncLayout(lt.typ, lt.rcvr)
6829 if typ.Size() != lt.size {
6830 t.Errorf("funcLayout(%v, %v).size=%d, want %d", lt.typ, lt.rcvr, typ.Size(), lt.size)
6831 }
6832 if argsize != lt.argsize {
6833 t.Errorf("funcLayout(%v, %v).argsize=%d, want %d", lt.typ, lt.rcvr, argsize, lt.argsize)
6834 }
6835 if retOffset != lt.retOffset {
6836 t.Errorf("funcLayout(%v, %v).retOffset=%d, want %d", lt.typ, lt.rcvr, retOffset, lt.retOffset)
6837 }
6838 if !bytes.Equal(stack, lt.stack) {
6839 t.Errorf("funcLayout(%v, %v).stack=%v, want %v", lt.typ, lt.rcvr, stack, lt.stack)
6840 }
6841 if !bytes.Equal(gc, lt.gc) {
6842 t.Errorf("funcLayout(%v, %v).gc=%v, want %v", lt.typ, lt.rcvr, gc, lt.gc)
6843 }
6844 if !bytes.Equal(inRegs, lt.inRegs) {
6845 t.Errorf("funcLayout(%v, %v).inRegs=%v, want %v", lt.typ, lt.rcvr, inRegs, lt.inRegs)
6846 }
6847 if !bytes.Equal(outRegs, lt.outRegs) {
6848 t.Errorf("funcLayout(%v, %v).outRegs=%v, want %v", lt.typ, lt.rcvr, outRegs, lt.outRegs)
6849 }
6850 if ptrs && len(stack) == 0 || !ptrs && len(stack) > 0 {
6851 t.Errorf("funcLayout(%v, %v) pointers flag=%v, want %v", lt.typ, lt.rcvr, ptrs, !ptrs)
6852 }
6853 })
6854 }
6855 }
6857 */
6864 }
6865 }
6868 // Creating a slice causes the runtime to repeat a bitmap,
6869 // which exercises a different path from making the compiler
6870 // repeat a bitmap for a small array or executing a repeat in
6871 // a GC program.
6875 // Repeat the bitmap for the slice size, trimming scalars in
6876 // the last element.
6880 }
6883 }
6884 }
6891 // Building blocks for types seen by the compiler (like [2]Xscalar).
6892 // The compiler will create the type structures for the derived types,
6893 // including their GC metadata.
6898 uintptr
6899 }
6901 uintptr
6903 }
6907 }
6910 {
6911 // Building blocks for types constructed by reflect.
6912 // This code is in a separate block so that code below
6913 // cannot accidentally refer to these.
6914 // The compiler must NOT see types derived from these
6915 // (for example, [2]Scalar must NOT appear in the program),
6916 // or else reflect will use it instead of having to construct one.
6917 // The goal is to test the construction.
6922 uintptr
6923 }
6925 uintptr
6927 }
6931 }
6939 }
6976 verifyGCBits(t, TypeOf([4]Xbigptrscalar{}), join(rep(3, join(rep(100, lit(1)), rep(100, lit(0)))), rep(100, lit(1))))
6977 verifyGCBits(t, ArrayOf(4, Tbigptrscalar), join(rep(3, join(rep(100, lit(1)), rep(100, lit(0)))), rep(100, lit(1))))
7026 }
7041 empty)
7062 }
7069 // Check that all the type constructors return concrete *rtype implementations.
7070 // It's difficult to test directly because the reflect package is only at arm's length.
7071 // The easiest thing to do is just call a function that crashes if it doesn't get an *rtype.
7075 }
7076 }
7087 }
7099 }
7100 }
7108 })
7111 }
7118 // Only adding half of the capacity to not trigger re-allocations due too many overloaded buckets.
7122 }
7123 })
7126 }
7127 // Empirical testing shows that with capacity hint single run will trigger 3 allocations and without 91. I set
7128 // the threshold to 10, to not make it overly brittle if something changes in the initial allocation of the
7129 // map, but to still catch a regression where we keep re-allocating in the hashmap as new entries are added.
7130 }
7133 // Note: for a chan int, the return Value must be allocated, so we
7134 // use a chan *int instead.
7140 })
7143 }
7144 // Note: there is one allocation in reflect.recv which seems to be
7145 // a limitation of escape analysis. If that is ever fixed the
7146 // allocs < 0.5 condition will trigger and this test should be fixed.
7147 }
7149 type TheNameOfThisTypeIsExactly255BytesLongSoWhenTheCompilerPrependsTheReflectTestPackageNameAndExtraStarTheLinkerRuntimeAndReflectPackagesWillHaveToCorrectlyDecodeTheSecondLengthByte0123456789_0123456789_0123456789_0123456789_0123456789_012345678 int
7152 v any
7153 want string
7154 }
7168 {(*TheNameOfThisTypeIsExactly255BytesLongSoWhenTheCompilerPrependsTheReflectTestPackageNameAndExtraStarTheLinkerRuntimeAndReflectPackagesWillHaveToCorrectlyDecodeTheSecondLengthByte0123456789_0123456789_0123456789_0123456789_0123456789_012345678)(nil), "TheNameOfThisTypeIsExactly255BytesLongSoWhenTheCompilerPrependsTheReflectTestPackageNameAndExtraStarTheLinkerRuntimeAndReflectPackagesWillHaveToCorrectlyDecodeTheSecondLengthByte0123456789_0123456789_0123456789_0123456789_0123456789_012345678"},
7169 }
7176 }
7177 }
7178 }
7180 /*
7181 gccgo doesn't really record whether a type is exported.
7182 It's not in the reflect API anyhow.
7184 func TestExported(t *testing.T) {
7185 type ΦExported struct{}
7186 type φUnexported struct{}
7187 type BigP *big
7188 type P int
7189 type p *P
7190 type P2 p
7191 type p3 p
7193 type exportTest struct {
7194 v any
7195 want bool
7196 }
7197 exportTests := []exportTest{
7198 {D1{}, true},
7199 {(*D1)(nil), true},
7200 {big{}, false},
7201 {(*big)(nil), false},
7202 {(BigP)(nil), true},
7203 {(*BigP)(nil), true},
7204 {ΦExported{}, true},
7205 {φUnexported{}, false},
7206 {P(0), true},
7207 {(p)(nil), false},
7208 {(P2)(nil), true},
7209 {(p3)(nil), false},
7210 }
7212 for i, test := range exportTests {
7213 typ := TypeOf(test.v)
7214 if got := IsExported(typ); got != test.want {
7215 t.Errorf("%d: %s exported=%v, want %v", i, typ.Name(), got, test.want)
7216 }
7217 }
7218 }
7219 */
7223 typ Type
7224 want string
7225 }
7237 }
7242 }
7243 }
7244 }
7246 /*
7247 gccgo does not have resolveReflectName.
7249 func TestOffsetLock(t *testing.T) {
7250 var wg sync.WaitGroup
7251 for i := 0; i < 4; i++ {
7252 i := i
7253 wg.Add(1)
7254 go func() {
7255 for j := 0; j < 50; j++ {
7256 ResolveReflectName(fmt.Sprintf("OffsetLockName:%d:%d", i, j))
7257 }
7258 wg.Done()
7259 }()
7260 }
7261 wg.Wait()
7262 }
7263 */
7270 }
7271 })
7272 }
7289 }
7292 label string
7294 }{
7297 }
7306 }
7307 }
7308 })
7314 }
7315 }
7316 })
7317 })
7318 }
7319 }
7326 }
7329 p *I
7330 }
7334 in any
7336 want any
7337 }{
7338 {
7343 },
7344 {
7349 },
7350 {
7355 },
7356 {
7361 },
7362 {
7367 },
7368 {
7373 },
7374 {
7379 },
7380 {
7385 },
7386 {
7391 },
7392 }
7399 }
7400 }
7401 }
7403 // TestUnaddressableField tests that the reflect package will not allow
7404 // a type from another package to be used as a named type with an
7405 // unexported field.
7406 //
7407 // This ensures that unexported fields cannot be modified by other packages.
7412 }
7417 })
7418 }
7425 byte
7426 uint8
7427 int
7428 int32
7429 rune
7430 }
7433 Tint
7434 Tint2
7435 }
7443 }
7450 }
7451 }
7462 }
7467 }
7468 }
7469 }
7481 }
7483 // Shouldn't panic.
7485 }
7492 }
7493 }
7500 }
7501 }
7506 // Use of zero iterator should panic.
7511 }()
7513 // Reset to new Map should work.
7518 }
7520 // Reset to Zero value should work, but iterating over it should panic.
7526 }()
7528 // Reset to a different Map with different types should work.
7533 }
7535 // Check that Reset, Next, and SetKey/SetValue play nicely together.
7540 }
7550 }
7553 }
7556 }
7557 }
7559 // Reset should not allocate.
7563 }))
7566 }
7567 }
7570 // Using a zero MapIter causes a panic, but not a crash.
7575 }()
7580 }()
7585 }()
7587 // Calling Key/Value on a MapIter before Next
7588 // causes a panic, but not a crash.
7596 }()
7601 }()
7603 // Calling Next, Key, or Value on an exhausted iterator
7604 // causes a panic, but not a crash.
7610 }()
7615 }()
7620 }()
7621 }
7624 // The first call to Next should reflect any
7625 // insertions to the map since the iterator was created.
7631 }
7632 }
7639 }
7641 }
7642 }
7645 // Delete all elements before first iteration.
7653 }
7654 }
7657 // Delete all elements after first iteration.
7666 }
7669 }
7670 }
7672 // iterateToString returns the set of elements
7673 // returned by an iterator in readable form.
7679 }
7682 }
7688 // Shouldn't raise stack overflow
7691 }
7698 }
7699 }
7706 }
7714 })
7717 })
7723 }
7726 }
7729 })
7732 })
7738 })
7741 })
7744 })
7747 })
7749 // Make sure assignment conversion works.
7750 var x any
7755 }
7759 }
7761 // Try some key/value types which are direct interfaces.
7766 }
7772 }
7776 }
7777 }
7779 //go:notinheap
7785 // See issue 48399.
7788 shouldPanic("reflect: call of reflect.Value.Field on zero Value", func() { v.Elem().Field(0) })
7793 }
7796 shouldPanic("reflect: reflect.Value.Elem on an invalid notinheap pointer", func() { v.Elem() })
7797 shouldPanic("reflect: reflect.Value.Pointer on an invalid notinheap pointer", func() { v.Pointer() })
7798 shouldPanic("reflect: reflect.Value.UnsafePointer on an invalid notinheap pointer", func() { v.UnsafePointer() })
7799 }
7806 }
7809 }
7810 }
7812 /* FIXME: comment out for generics
7814 type A struct{}
7815 type B[T any] struct{}
7817 func TestIssue50208(t *testing.T) {
7818 want1 := "B[reflect_test.A]"
7819 if got := TypeOf(new(B[A])).Elem().Name(); got != want1 {
7820 t.Errorf("name of type parameter mismatched, want:%s, got:%s", want1, got)
7821 }
7822 want2 := "B[reflect_test.B[reflect_test.A]]"
7823 if got := TypeOf(new(B[B[A]])).Elem().Name(); got != want2 {
7824 t.Errorf("name of type parameter mismatched, want:%s, got:%s", want2, got)
7825 }
7826 }
7828 */