1// run
2
3// Copyright 2010 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, near-exhaustive, of converting numbers between types.
8// No complex numbers though.
9
10package main
11
12var i8 int8;
13var u8 uint8;
14var i16 int16;
15var u16 uint16;
16var i32 int32;
17var u32 uint32;
18var i64 int64;
19var u64 uint64;
20var f32 float32;
21var f64 float64;
22
23type	big	float64
24
25type	t	struct {
26	from, to	int
27	val		big
28}
29
30const (
31	ti8	= iota+1
32	tu8
33	ti16
34	tu16
35	ti32
36	tu32
37	ti64
38	tu64
39	tf32
40	tf64
41)
42
43var	x = []t{
44
45	/* value good in all types (10) */
46	{ ti8,  ti8,  10 }, { ti8,  tu8,  10 }, { ti8,  ti16, 10 }, { ti8,  tu16, 10 },
47	{ ti8,  ti32, 10 }, { ti8,  tu32, 10 }, { ti8,  ti64, 10 }, { ti8,  tu64, 10 },
48	{ ti8,  tf32, 10 }, { ti8,  tf64, 10 },
49
50	{ tu8,  ti8,  10 }, { tu8,  tu8,  10 }, { tu8,  ti16, 10 }, { tu8,  tu16, 10 },
51	{ tu8,  ti32, 10 }, { tu8,  tu32, 10 }, { tu8,  ti64, 10 }, { tu8,  tu64, 10 },
52	{ tu8,  tf32, 10 }, { tu8,  tf64, 10 },
53
54	{ ti16, ti8,  10 }, { ti16, tu8,  10 }, { ti16, ti16, 10 }, { ti16, tu16, 10 },
55	{ ti16, ti32, 10 }, { ti16, tu32, 10 }, { ti16, ti64, 10 }, { ti16, tu64, 10 },
56	{ ti16, tf32, 10 }, { ti16, tf64, 10 },
57
58	{ tu16, ti8,  10 }, { tu16, tu8,  10 }, { tu16, ti16, 10 }, { tu16, tu16, 10 },
59	{ tu16, ti32, 10 }, { tu16, tu32, 10 }, { tu16, ti64, 10 }, { tu16, tu64, 10 },
60	{ tu16, tf32, 10 }, { tu16, tf64, 10 },
61
62	{ ti32, ti8,  10 }, { ti32, tu8,  10 }, { ti32, ti16, 10 }, { ti32, tu16, 10 },
63	{ ti32, ti32, 10 }, { ti32, tu32, 10 }, { ti32, ti64, 10 }, { ti32, tu64, 10 },
64	{ ti32, tf32, 10 }, { ti32, tf64, 10 },
65
66	{ tu32, ti8,  10 }, { tu32, tu8,  10 }, { tu32, ti16, 10 }, { tu32, tu16, 10 },
67	{ tu32, ti32, 10 }, { tu32, tu32, 10 }, { tu32, ti64, 10 }, { tu32, tu64, 10 },
68	{ tu32, tf32, 10 }, { tu32, tf64, 10 },
69
70	{ ti64, ti8,  10 }, { ti64, tu8,  10 }, { ti64, ti16, 10 }, { ti64, tu16, 10 },
71	{ ti64, ti32, 10 }, { ti64, tu32, 10 }, { ti64, ti64, 10 }, { ti64, tu64, 10 },
72	{ ti64, tf32, 10 }, { ti64, tf64, 10 },
73
74	{ tu64, ti8,  10 }, { tu64, tu8,  10 }, { tu64, ti16, 10 }, { tu64, tu16, 10 },
75	{ tu64, ti32, 10 }, { tu64, tu32, 10 }, { tu64, ti64, 10 }, { tu64, tu64, 10 },
76	{ tu64, tf32, 10 }, { tu64, tf64, 10 },
77
78	{ tf32, ti8,  10 }, { tf32, tu8,  10 }, { tf32, ti16, 10 }, { tf32, tu16, 10 },
79	{ tf32, ti32, 10 }, { tf32, tu32, 10 }, { tf32, ti64, 10 }, { tf32, tu64, 10 },
80	{ tf32, tf32, 10 }, { tf32, tf64, 10 },
81
82	{ tf64, ti8,  10 }, { tf64, tu8,  10 }, { tf64, ti16, 10 }, { tf64, tu16, 10 },
83	{ tf64, ti32, 10 }, { tf64, tu32, 10 }, { tf64, ti64, 10 }, { tf64, tu64, 10 },
84	{ tf64, tf32, 10 }, { tf64, tf64, 10 },
85
86	/* value good in all signed types (-4) */
87	{ ti8,  ti8,  -4 }, { ti8,  ti16, -4 },
88	{ ti8,  ti32, -4 }, { ti8,  ti64, -4 },
89	{ ti8,  tf32, -4 }, { ti8,  tf64, -4 },
90
91	{ ti16, ti8,  -4 }, { ti16, ti16, -4 },
92	{ ti16, ti32, -4 }, { ti16, ti64, -4 },
93	{ ti16, tf32, -4 },
94
95	{ ti32, ti8,  -4 }, { ti32, ti16, -4 },
96	{ ti32, ti32, -4 }, { ti32, ti64, -4 },
97	{ ti32, tf32, -4 }, { ti32, tf64, -4 },
98
99	{ ti64, ti8,  -4 }, { ti64, ti16, -4 },
100	{ ti64, ti32, -4 }, { ti64, ti64, -4 },
101	{ ti64, tf32, -4 },
102
103	{ tf32, ti8,  -4 }, { tf32, ti16, -4 },
104	{ tf32, ti32, -4 }, { tf32, ti64, -4 },
105	{ tf32, tf32, -4 },
106
107	{ tf64, ti8,  -4 }, { tf64, ti16, -4 },
108	{ tf64, ti32, -4 }, { tf64, ti64, -4 },
109	{ tf64, tf32, -4 }, { tf64, tf64, -4 },
110
111	/* value good in u8 and up (175) */
112	{ tu8,  tu8,  175 }, { tu8,  ti16, 175 }, { tu8,  tu16, 175 },
113	{ tu8,  ti32, 175 }, { tu8,  tu32, 175 }, { tu8,  ti64, 175 }, { tu8,  tu64, 175 },
114	{ tu8,  tf32, 175 }, { tu8,  tf64, 175 },
115
116	{ ti16, tu8,  175 }, { ti16, ti16, 175 }, { ti16, tu16, 175 },
117	{ ti16, ti32, 175 }, { ti16, tu32, 175 }, { ti16, ti64, 175 }, { ti16, tu64, 175 },
118	{ ti16, tf32, 175 }, { ti16, tf64, 175 },
119
120	{ tu16, tu8,  175 }, { tu16, ti16, 175 }, { tu16, tu16, 175 },
121	{ tu16, ti32, 175 }, { tu16, tu32, 175 }, { tu16, ti64, 175 }, { tu16, tu64, 175 },
122	{ tu16, tf32, 175 }, { tu16, tf64, 175 },
123
124	{ ti32, tu8,  175 }, { ti32, ti16, 175 }, { ti32, tu16, 175 },
125	{ ti32, ti32, 175 }, { ti32, tu32, 175 }, { ti32, ti64, 175 }, { ti32, tu64, 175 },
126	{ ti32, tf32, 175 }, { ti32, tf64, 175 },
127
128	{ tu32, tu8,  175 }, { tu32, ti16, 175 }, { tu32, tu16, 175 },
129	{ tu32, ti32, 175 }, { tu32, tu32, 175 }, { tu32, ti64, 175 }, { tu32, tu64, 175 },
130	{ tu32, tf32, 175 }, { tu32, tf64, 175 },
131
132	{ ti64, tu8,  175 }, { ti64, ti16, 175 }, { ti64, tu16, 175 },
133	{ ti64, ti32, 175 }, { ti64, tu32, 175 }, { ti64, ti64, 175 }, { ti64, tu64, 175 },
134	{ ti64, tf32, 175 }, { ti64, tf64, 175 },
135
136	{ tu64, tu8,  175 }, { tu64, ti16, 175 }, { tu64, tu16, 175 },
137	{ tu64, ti32, 175 }, { tu64, tu32, 175 }, { tu64, ti64, 175 }, { tu64, tu64, 175 },
138	{ tu64, tf32, 175 }, { tu64, tf64, 175 },
139
140	{ tf32, tu8,  175 }, { tf32, ti16, 175 }, { tf32, tu16, 175 },
141	{ tf32, ti32, 175 }, { tf32, tu32, 175 }, { tf32, ti64, 175 }, { tf32, tu64, 175 },
142	{ tf32, tf32, 175 }, { tf32, tf64, 175 },
143
144	{ tf64, tu8,  175 }, { tf64, ti16, 175 }, { tf64, tu16, 175 },
145	{ tf64, ti32, 175 }, { tf64, tu32, 175 }, { tf64, ti64, 175 }, { tf64, tu64, 175 },
146	{ tf64, tf32, 175 }, { tf64, tf64, 175 },
147
148	/* value good in u16 and up (41259) */
149	{ tu16, tu16, 41259 },
150	{ tu16, ti32, 41259 }, { tu16, ti64, 41259 }, { tu16, tu64, 41259 },
151	{ tu16, tf32, 41259 }, { tu16, tf64, 41259 },
152
153	{ ti32, tu16, 41259 },
154	{ ti32, ti32, 41259 }, { ti32, tu32, 41259 }, { ti32, ti64, 41259 }, { ti32, tu64, 41259 },
155	{ ti32, tf32, 41259 }, { ti32, tf64, 41259 },
156
157	{ tu32, tu16, 41259 },
158	{ tu32, ti32, 41259 }, { tu32, tu32, 41259 }, { tu32, ti64, 41259 }, { tu32, tu64, 41259 },
159	{ tu32, tf32, 41259 }, { tu32, tf64, 41259 },
160
161	{ ti64, tu16, 41259 },
162	{ ti64, ti32, 41259 }, { ti64, tu32, 41259 }, { ti64, ti64, 41259 }, { ti64, tu64, 41259 },
163	{ ti64, tf32, 41259 }, { ti64, tf64, 41259 },
164
165	{ tu64, tu16, 41259 },
166	{ tu64, ti32, 41259 }, { tu64, tu32, 41259 }, { tu64, ti64, 41259 }, { tu64, tu64, 41259 },
167	{ tu64, tf32, 41259 }, { tu64, tf64, 41259 },
168
169	{ tf32, tu16, 41259 },
170	{ tf32, ti32, 41259 }, { tf32, tu32, 41259 }, { tf32, ti64, 41259 }, { tf32, tu64, 41259 },
171	{ tf32, tf32, 41259 }, { tf32, tf64, 41259 },
172
173	{ tf64, tu16, 41259 },
174	{ tf64, ti32, 41259 }, { tf64, tu32, 41259 }, { tf64, ti64, 41259 }, { tf64, tu64, 41259 },
175	{ tf64, tf32, 41259 }, { tf64, tf64, 41259 },
176
177	/* value good in u32 and up (3758096384) */
178	{ tu32, tu32, 3758096384 }, { tu32, ti64, 3758096384 }, { tu32, tu64, 3758096384 },
179	{ tu32, tf32, 3758096384 }, { tu32, tf64, 3758096384 },
180
181	{ ti64, tu32, 3758096384 }, { ti64, ti64, 3758096384 }, { ti64, tu64, 3758096384 },
182	{ ti64, tf32, 3758096384 }, { ti64, tf64, 3758096384 },
183
184	{ tu64, tu32, 3758096384 }, { tu64, ti64, 3758096384 }, { tu64, tu64, 3758096384 },
185	{ tu64, tf32, 3758096384 }, { tu64, tf64, 3758096384 },
186
187	{ tf32, tu32, 3758096384 }, { tf32, ti64, 3758096384 }, { tf32, tu64, 3758096384 },
188	{ tf32, tf32, 3758096384 }, { tf32, tf64, 3758096384 },
189
190	{ tf64, tu32, 3758096384 }, { tf64, ti64, 3758096384 }, { tf64, tu64, 3758096384 },
191	{ tf64, tf32, 3758096384 }, { tf64, tf64, 3758096384 },
192
193	/* value good in u64 and up (16717361816799281152) */
194	{ tu64, tu64, 16717361816799281152 },
195	{ tu64, tf32, 16717361816799281152 }, { tu64, tf64, 16717361816799281152 },
196
197	{ tf32, tu64, 16717361816799281152 },
198	{ tf32, tf32, 16717361816799281152 }, { tf32, tf64, 16717361816799281152 },
199
200	{ tf64, tu64, 16717361816799281152 },
201	{ tf64, tf32, 16717361816799281152 }, { tf64, tf64, 16717361816799281152 },
202}
203
204func main() {
205	for i:=0; i<len(x); i++ {
206		v := x[i].val		// input value
207		w := big(0)		// output value
208		f := x[i].from		// input type
209		t := x[i].to		// output type
210
211		i8  = 0; u8  = 0; i16 = 0; u16 = 0
212		i32 = 0; u32 = 0; i64 = 0; u64 = 0
213		f32 = 0; f64 = 0
214
215		switch f*100 + t {
216		default:
217			println("missing case", i, v, f, t)
218			w = v
219
220		case ti8*100 + ti8:
221			i8 = int8(v); i8 = int8(i8); w = big(i8)
222		case ti8*100 + tu8:
223			i8 = int8(v); u8 = uint8(i8); w = big(u8)
224		case ti8*100 + ti16:
225			i8 = int8(v); i16 = int16(i8); w = big(i16)
226		case ti8*100 + tu16:
227			i8 = int8(v); u16 = uint16(i8); w = big(u16)
228		case ti8*100 + ti32:
229			i8 = int8(v); i32 = int32(i8); w = big(i32)
230		case ti8*100 + tu32:
231			i8 = int8(v); u32 = uint32(i8); w = big(u32)
232		case ti8*100 + ti64:
233			i8 = int8(v); i64 = int64(i8); w = big(i64)
234		case ti8*100 + tu64:
235			i8 = int8(v); u64 = uint64(i8); w = big(u64)
236		case ti8*100 + tf32:
237			i8 = int8(v); f32 = float32(i8); w = big(f32)
238		case ti8*100 + tf64:
239			i8 = int8(v); f64 = float64(i8); w = big(f64)
240
241		case tu8*100 + ti8:
242			u8 = uint8(v); i8 = int8(u8); w = big(i8)
243		case tu8*100 + tu8:
244			u8 = uint8(v); u8 = uint8(u8); w = big(u8)
245		case tu8*100 + ti16:
246			u8 = uint8(v); i16 = int16(u8); w = big(i16)
247		case tu8*100 + tu16:
248			u8 = uint8(v); u16 = uint16(u8); w = big(u16)
249		case tu8*100 + ti32:
250			u8 = uint8(v); i32 = int32(u8); w = big(i32)
251		case tu8*100 + tu32:
252			u8 = uint8(v); u32 = uint32(u8); w = big(u32)
253		case tu8*100 + ti64:
254			u8 = uint8(v); i64 = int64(u8); w = big(i64)
255		case tu8*100 + tu64:
256			u8 = uint8(v); u64 = uint64(u8); w = big(u64)
257		case tu8*100 + tf32:
258			u8 = uint8(v); f32 = float32(u8); w = big(f32)
259		case tu8*100 + tf64:
260			u8 = uint8(v); f64 = float64(u8); w = big(f64)
261
262		case ti16*100 + ti8:
263			i16 = int16(v); i8 = int8(i16); w = big(i8)
264		case ti16*100 + tu8:
265			i16 = int16(v); u8 = uint8(i16); w = big(u8)
266		case ti16*100 + ti16:
267			i16 = int16(v); i16 = int16(i16); w = big(i16)
268		case ti16*100 + tu16:
269			i16 = int16(v); u16 = uint16(i16); w = big(u16)
270		case ti16*100 + ti32:
271			i16 = int16(v); i32 = int32(i16); w = big(i32)
272		case ti16*100 + tu32:
273			i16 = int16(v); u32 = uint32(i16); w = big(u32)
274		case ti16*100 + ti64:
275			i16 = int16(v); i64 = int64(i16); w = big(i64)
276		case ti16*100 + tu64:
277			i16 = int16(v); u64 = uint64(i16); w = big(u64)
278		case ti16*100 + tf32:
279			i16 = int16(v); f32 = float32(i16); w = big(f32)
280		case ti16*100 + tf64:
281			i16 = int16(v); f64 = float64(i16); w = big(f64)
282
283		case tu16*100 + ti8:
284			u16 = uint16(v); i8 = int8(u16); w = big(i8)
285		case tu16*100 + tu8:
286			u16 = uint16(v); u8 = uint8(u16); w = big(u8)
287		case tu16*100 + ti16:
288			u16 = uint16(v); i16 = int16(u16); w = big(i16)
289		case tu16*100 + tu16:
290			u16 = uint16(v); u16 = uint16(u16); w = big(u16)
291		case tu16*100 + ti32:
292			u16 = uint16(v); i32 = int32(u16); w = big(i32)
293		case tu16*100 + tu32:
294			u16 = uint16(v); u32 = uint32(u16); w = big(u32)
295		case tu16*100 + ti64:
296			u16 = uint16(v); i64 = int64(u16); w = big(i64)
297		case tu16*100 + tu64:
298			u16 = uint16(v); u64 = uint64(u16); w = big(u64)
299		case tu16*100 + tf32:
300			u16 = uint16(v); f32 = float32(u16); w = big(f32)
301		case tu16*100 + tf64:
302			u16 = uint16(v); f64 = float64(u16); w = big(f64)
303
304		case ti32*100 + ti8:
305			i32 = int32(v); i8 = int8(i32); w = big(i8)
306		case ti32*100 + tu8:
307			i32 = int32(v); u8 = uint8(i32); w = big(u8)
308		case ti32*100 + ti16:
309			i32 = int32(v); i16 = int16(i32); w = big(i16)
310		case ti32*100 + tu16:
311			i32 = int32(v); u16 = uint16(i32); w = big(u16)
312		case ti32*100 + ti32:
313			i32 = int32(v); i32 = int32(i32); w = big(i32)
314		case ti32*100 + tu32:
315			i32 = int32(v); u32 = uint32(i32); w = big(u32)
316		case ti32*100 + ti64:
317			i32 = int32(v); i64 = int64(i32); w = big(i64)
318		case ti32*100 + tu64:
319			i32 = int32(v); u64 = uint64(i32); w = big(u64)
320		case ti32*100 + tf32:
321			i32 = int32(v); f32 = float32(i32); w = big(f32)
322		case ti32*100 + tf64:
323			i32 = int32(v); f64 = float64(i32); w = big(f64)
324
325		case tu32*100 + ti8:
326			u32 = uint32(v); i8 = int8(u32); w = big(i8)
327		case tu32*100 + tu8:
328			u32 = uint32(v); u8 = uint8(u32); w = big(u8)
329		case tu32*100 + ti16:
330			u32 = uint32(v); i16 = int16(u32); w = big(i16)
331		case tu32*100 + tu16:
332			u32 = uint32(v); u16 = uint16(u32); w = big(u16)
333		case tu32*100 + ti32:
334			u32 = uint32(v); i32 = int32(u32); w = big(i32)
335		case tu32*100 + tu32:
336			u32 = uint32(v); u32 = uint32(u32); w = big(u32)
337		case tu32*100 + ti64:
338			u32 = uint32(v); i64 = int64(u32); w = big(i64)
339		case tu32*100 + tu64:
340			u32 = uint32(v); u64 = uint64(u32); w = big(u64)
341		case tu32*100 + tf32:
342			u32 = uint32(v); f32 = float32(u32); w = big(f32)
343		case tu32*100 + tf64:
344			u32 = uint32(v); f64 = float64(u32); w = big(f64)
345
346		case ti64*100 + ti8:
347			i64 = int64(v); i8 = int8(i64); w = big(i8)
348		case ti64*100 + tu8:
349			i64 = int64(v); u8 = uint8(i64); w = big(u8)
350		case ti64*100 + ti16:
351			i64 = int64(v); i16 = int16(i64); w = big(i16)
352		case ti64*100 + tu16:
353			i64 = int64(v); u16 = uint16(i64); w = big(u16)
354		case ti64*100 + ti32:
355			i64 = int64(v); i32 = int32(i64); w = big(i32)
356		case ti64*100 + tu32:
357			i64 = int64(v); u32 = uint32(i64); w = big(u32)
358		case ti64*100 + ti64:
359			i64 = int64(v); i64 = int64(i64); w = big(i64)
360		case ti64*100 + tu64:
361			i64 = int64(v); u64 = uint64(i64); w = big(u64)
362		case ti64*100 + tf32:
363			i64 = int64(v); f32 = float32(i64); w = big(f32)
364		case ti64*100 + tf64:
365			i64 = int64(v); f64 = float64(i64); w = big(f64)
366
367		case tu64*100 + ti8:
368			u64 = uint64(v); i8 = int8(u64); w = big(i8)
369		case tu64*100 + tu8:
370			u64 = uint64(v); u8 = uint8(u64); w = big(u8)
371		case tu64*100 + ti16:
372			u64 = uint64(v); i16 = int16(u64); w = big(i16)
373		case tu64*100 + tu16:
374			u64 = uint64(v); u16 = uint16(u64); w = big(u16)
375		case tu64*100 + ti32:
376			u64 = uint64(v); i32 = int32(u64); w = big(i32)
377		case tu64*100 + tu32:
378			u64 = uint64(v); u32 = uint32(u64); w = big(u32)
379		case tu64*100 + ti64:
380			u64 = uint64(v); i64 = int64(u64); w = big(i64)
381		case tu64*100 + tu64:
382			u64 = uint64(v); u64 = uint64(u64); w = big(u64)
383		case tu64*100 + tf32:
384			u64 = uint64(v); f32 = float32(u64); w = big(f32)
385		case tu64*100 + tf64:
386			u64 = uint64(v); f64 = float64(u64); w = big(f64)
387
388		case tf32*100 + ti8:
389			f32 = float32(v); i8 = int8(f32); w = big(i8)
390		case tf32*100 + tu8:
391			f32 = float32(v); u8 = uint8(f32); w = big(u8)
392		case tf32*100 + ti16:
393			f32 = float32(v); i16 = int16(f32); w = big(i16)
394		case tf32*100 + tu16:
395			f32 = float32(v); u16 = uint16(f32); w = big(u16)
396		case tf32*100 + ti32:
397			f32 = float32(v); i32 = int32(f32); w = big(i32)
398		case tf32*100 + tu32:
399			f32 = float32(v); u32 = uint32(f32); w = big(u32)
400		case tf32*100 + ti64:
401			f32 = float32(v); i64 = int64(f32); w = big(i64)
402		case tf32*100 + tu64:
403			f32 = float32(v); u64 = uint64(f32); w = big(u64)
404		case tf32*100 + tf32:
405			f32 = float32(v); f32 = float32(f32); w = big(f32)
406		case tf32*100 + tf64:
407			f32 = float32(v); f64 = float64(f32); w = big(f64)
408
409		case tf64*100 + ti8:
410			f64 = float64(v); i8 = int8(f64); w = big(i8)
411		case tf64*100 + tu8:
412			f64 = float64(v); u8 = uint8(f64); w = big(u8)
413		case tf64*100 + ti16:
414			f64 = float64(v); i16 = int16(f64); w = big(i16)
415		case tf64*100 + tu16:
416			f64 = float64(v); u16 = uint16(f64); w = big(u16)
417		case tf64*100 + ti32:
418			f64 = float64(v); i32 = int32(f64); w = big(i32)
419		case tf64*100 + tu32:
420			f64 = float64(v); u32 = uint32(f64); w = big(u32)
421		case tf64*100 + ti64:
422			f64 = float64(v); i64 = int64(f64); w = big(i64)
423		case tf64*100 + tu64:
424			f64 = float64(v); u64 = uint64(f64); w = big(u64)
425		case tf64*100 + tf32:
426			f64 = float64(v); f32 = float32(f64); w = big(f32)
427		case tf64*100 + tf64:
428			f64 = float64(v); f64 = float64(f64); w = big(f64)
429		}
430		if v != w { println(i, v, w, f, t) }
431	}
432}
433