test/typeswitch.go

   1 // $G $F.go && $L $F.$A && ./$A.out
   2
   3 // Copyright 2009 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 package main
   8
   9 import "os"
  10
  11 const (
  12         Bool = iota;
  13         Int;
  14         Float;
  15         String;
  16         Struct;
  17         Chan;
  18         Array;
  19         Map;
  20         Func;
  21         Last;
  22 )
  23
  24 type S struct { a int }
  25 var s S = S{1234}
  26
  27 var c = make(chan int);
  28
  29 var a   = []int{0,1,2,3}
  30
  31 var m = make(map[string]int)
  32
  33 func assert(b bool, s string) {
  34         if !b {
  35                 println(s);
  36                 os.Exit(1);
  37         }
  38 }
  39
  40 func f(i int) interface{} {
  41         switch i {
  42         case Bool:
  43                 return true;
  44         case Int:
  45                 return 7;
  46         case Float:
  47                 return 7.4;
  48         case String:
  49                 return "hello";
  50         case Struct:
  51                 return s;
  52         case Chan:
  53                 return c;
  54         case Array:
  55                 return a;
  56         case Map:
  57                 return m;
  58         case Func:
  59                 return f;
  60         }
  61         panic("bad type number");
  62 }
  63
  64 func main() {
  65         for i := Bool; i < Last; i++ {
  66                 switch x := f(i).(type) {
  67                 case bool:
  68                         assert(x == true && i == Bool, "bool");
  69                 case int:
  70                         assert(x == 7 && i == Int, "int");
  71                 case float:
  72                         assert(x == 7.4 && i == Float, "float");
  73                 case string:
  74                         assert(x == "hello"&& i == String, "string");
  75                 case S:
  76                         assert(x.a == 1234 && i == Struct, "struct");
  77                 case chan int:
  78                         assert(x == c && i == Chan, "chan");
  79                 case []int:
  80                         assert(x[3] == 3 && i == Array, "array");
  81                 case map[string]int:
  82                         assert(x == m && i == Map, "map");
  83                 case func(i int) interface{}:
  84                         assert(x == f && i == Func, "fun");
  85                 default:
  86                         assert(false, "unknown");
  87                 }
  88         }
  89
  90         // boolean switch (has had bugs in past; worth writing down)
  91         switch {
  92         case true:
  93                 assert(true, "switch 2 bool");
  94         default:
  95                 assert(false, "switch 2 unknown");
  96         }
  97
  98         switch true {
  99         case true:
 100                 assert(true, "switch 3 bool");
 101         default:
 102                 assert(false, "switch 3 unknown");
 103         }
 104
 105         switch false {
 106         case false:
 107                 assert(true, "switch 4 bool");
 108         default:
 109                 assert(false, "switch 4 unknown");
 110         }
 111
 112 }