1// run
2
3// Copyright 2012 The Go Authors. All rights reserved.
4// Use of this source code is governed by a BSD-style
5// license that can be found in the LICENSE file.
6
7// Test conversion from non-interface types to the empty interface.
8
9package main
10
11type J interface {
12	Method()
13}
14
15type (
16	U16  uint16
17	U32  uint32
18	U64  uint64
19	U128 [2]uint64
20	F32  float32
21	F64  float64
22	C128 complex128
23	S    string
24	B    []byte
25	M    map[int]int
26	C    chan int
27	Z    struct{}
28)
29
30func (U16) Method()  {}
31func (U32) Method()  {}
32func (U64) Method()  {}
33func (U128) Method() {}
34func (F32) Method()  {}
35func (F64) Method()  {}
36func (C128) Method() {}
37func (S) Method()    {}
38func (B) Method()    {}
39func (M) Method()    {}
40func (C) Method()    {}
41func (Z) Method()    {}
42
43var (
44	u16  = U16(1)
45	u32  = U32(2)
46	u64  = U64(3)
47	u128 = U128{4, 5}
48	f32  = F32(6)
49	f64  = F64(7)
50	c128 = C128(8 + 9i)
51	s    = S("10")
52	b    = B("11")
53	m    = M{12: 13}
54	c    = make(C, 14)
55	z    = Z{}
56	p    = &z
57	pp   = &p
58)
59
60var (
61	iu16  interface{} = u16
62	iu32  interface{} = u32
63	iu64  interface{} = u64
64	iu128 interface{} = u128
65	if32  interface{} = f32
66	if64  interface{} = f64
67	ic128 interface{} = c128
68	is    interface{} = s
69	ib    interface{} = b
70	im    interface{} = m
71	ic    interface{} = c
72	iz    interface{} = z
73	ip    interface{} = p
74	ipp   interface{} = pp
75
76	ju16  J = u16
77	ju32  J = u32
78	ju64  J = u64
79	ju128 J = u128
80	jf32  J = f32
81	jf64  J = f64
82	jc128 J = c128
83	js    J = s
84	jb    J = b
85	jm    J = m
86	jc    J = c
87	jz J = z
88	jp J = p // The method set for *T contains the methods for T.
89	// pp does not implement error.
90)
91
92func second(a ...interface{}) interface{} {
93	return a[1]
94}
95
96func main() {
97	// Test equality.
98	if u16 != iu16 {
99		panic("u16 != iu16")
100	}
101	if u16 != ju16 {
102		panic("u16 != ju16")
103	}
104	if u32 != iu32 {
105		panic("u32 != iu32")
106	}
107	if u32 != ju32 {
108		panic("u32 != ju32")
109	}
110	if u64 != iu64 {
111		panic("u64 != iu64")
112	}
113	if u64 != ju64 {
114		panic("u64 != ju64")
115	}
116	if u128 != iu128 {
117		panic("u128 != iu128")
118	}
119	if u128 != ju128 {
120		panic("u128 != ju128")
121	}
122	if f32 != if32 {
123		panic("f32 != if32")
124	}
125	if f32 != jf32 {
126		panic("f32 != jf32")
127	}
128	if f64 != if64 {
129		panic("f64 != if64")
130	}
131	if f64 != jf64 {
132		panic("f64 != jf64")
133	}
134	if c128 != ic128 {
135		panic("c128 != ic128")
136	}
137	if c128 != jc128 {
138		panic("c128 != jc128")
139	}
140	if s != is {
141		panic("s != is")
142	}
143	if s != js {
144		panic("s != js")
145	}
146	if c != ic {
147		panic("c != ic")
148	}
149	if c != jc {
150		panic("c != jc")
151	}
152	// There are no tests for b and m, as slices and maps are not comparable by ==.
153	if z != iz {
154		panic("z != iz")
155	}
156	if z != jz {
157		panic("z != jz")
158	}
159	if p != ip {
160		panic("p != ip")
161	}
162	if p != jp {
163		panic("p != jp")
164	}
165	if pp != ipp {
166		panic("pp != ipp")
167	}
168	// pp does not implement J.
169
170	// Test that non-interface types can be used as ...interface{} arguments.
171	if got := second(z, p, pp, u16, u32, u64, u128, f32, f64, c128, s, b, m, c); got != ip {
172		println("second: got", got, "want", ip)
173		panic("fail")
174	}
175
176	// Test that non-interface types can be sent on a chan interface{}.
177	const n = 100
178	uc := make(chan interface{})
179	go func() {
180		for i := 0; i < n; i++ {
181			select {
182			case uc <- nil:
183			case uc <- u32:
184			case uc <- u64:
185			case uc <- u128:
186			}
187		}
188	}()
189	for i := 0; i < n; i++ {
190		if got := <-uc; got != nil && got != u32 && got != u64 && got != u128 {
191			println("recv: i", i, "got", got)
192			panic("fail")
193		}
194	}
195}
196