test/ken/convert.go

   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
  10 package main
  11
  12 var i8 int8;
  13 var u8 uint8;
  14 var i16 int16;
  15 var u16 uint16;
  16 var i32 int32;
  17 var u32 uint32;
  18 var i64 int64;
  19 var u64 uint64;
  20 var f32 float32;
  21 var f64 float64;
  22
  23 type    big     float64
  24
  25 type    t       struct {
  26         from, to        int
  27         val             big
  28 }
  29
  30 const (
  31         ti8     = iota+1
  32         tu8
  33         ti16
  34         tu16
  35         ti32
  36         tu32
  37         ti64
  38         tu64
  39         tf32
  40         tf64
  41 )
  42
  43 var     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
 204 func 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 }