← Back to branch summary

~john-koepi/ubuntu/trusty/golang/default

« back to all changes in this revision

Viewing changes to test/ken/convert.go

  • Committer: Bazaar Package Importer
  • Author(s): Ondřej Surý
  • Date: 2011-04-20 17:36:48 UTC
  • Revision ID: james.westby@ubuntu.com-20110420173648-ifergoxyrm832trd
Tags: upstream-2011.03.07.1
Import upstream version 2011.03.07.1

Show diffs side-by-side

added added

removed removed

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