test/named.go

   1 // $G $D/$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 // Test that basic operations on named types are valid
   8 // and preserve the type.
   9
  10 package main
  11
  12 type Array [10]byte
  13 type Bool bool
  14 type Chan chan int
  15 type Float float
  16 type Int int
  17 type Map map[int]byte
  18 type Slice []byte
  19 type String string
  20
  21 // Calling these functions checks at compile time that the argument
  22 // can be converted implicitly to (used as) the given type.
  23 func asArray(Array) {}
  24 func asBool(Bool) {}
  25 func asChan(Chan) {}
  26 func asFloat(Float) {}
  27 func asInt(Int) {}
  28 func asMap(Map) {}
  29 func asSlice(Slice) {}
  30 func asString(String) {}
  31
  32 func (Map) M() {}
  33
  34
  35 // These functions check at run time that the default type
  36 // (in the absence of any implicit conversion hints)
  37 // is the given type.
  38 func isArray(x interface{}) { _ = x.(Array) }
  39 func isBool(x interface{}) { _ = x.(Bool) }
  40 func isChan(x interface{}) { _ = x.(Chan) }
  41 func isFloat(x interface{}) { _ = x.(Float) }
  42 func isInt(x interface{}) { _ = x.(Int) }
  43 func isMap(x interface{}) { _ = x.(Map) }
  44 func isSlice(x interface{}) { _ = x.(Slice) }
  45 func isString(x interface{}) { _ = x.(String) }
  46
  47 func main() {
  48         var (
  49                 a Array;
  50                 b Bool = true;
  51                 c Chan = make(Chan);
  52                 f Float = 1;
  53                 i Int = 1;
  54                 m Map = make(Map);
  55                 slice Slice = make(Slice, 10);
  56                 str String = "hello";
  57         )
  58
  59         asArray(a);
  60         isArray(a);
  61         asArray(*&a);
  62         isArray(*&a);
  63         asArray(Array{});
  64         isArray(Array{});
  65
  66         asBool(b);
  67         isBool(b);
  68         asBool(!b);
  69         isBool(!b);
  70         asBool(true);
  71         asBool(1!=2);
  72         asBool(*&b);
  73         isBool(*&b);
  74         asBool(Bool(true));
  75         isBool(Bool(true));
  76         asBool(i < Int(f));
  77
  78         _, b = m[2];
  79         m[2] = 1, b;
  80
  81         b = c<-1;
  82         _ = b;
  83         asBool(c<-1);
  84
  85         _, b = <-c;
  86         _ = b;
  87
  88         var inter interface{};
  89         _, b = inter.(Map);
  90         _ = b;
  91
  92         var minter interface{M()};
  93         _, b = minter.(Map);
  94         _ = b;
  95
  96         asBool(closed(c));
  97         b = closed(c);
  98         _ = b;
  99
 100         asChan(c);
 101         isChan(c);
 102         asChan(make(Chan));
 103         isChan(make(Chan));
 104         asChan(*&c);
 105         isChan(*&c);
 106         asChan(Chan(nil));
 107         isChan(Chan(nil));
 108
 109         asFloat(f);
 110         isFloat(f);
 111         asFloat(-f);
 112         isFloat(-f);
 113         asFloat(+f);
 114         isFloat(+f);
 115         asFloat(f+1);
 116         isFloat(f+1);
 117         asFloat(1+f);
 118         isFloat(1+f);
 119         asFloat(f+f);
 120         isFloat(f+f);
 121         f++;
 122         f+=2;
 123         asFloat(f-1);
 124         isFloat(f-1);
 125         asFloat(1-f);
 126         isFloat(1-f);
 127         asFloat(f-f);
 128         isFloat(f-f);
 129         f--;
 130         f-=2;
 131         asFloat(f*2.5);
 132         isFloat(f*2.5);
 133         asFloat(2.5*f);
 134         isFloat(2.5*f);
 135         asFloat(f*f);
 136         isFloat(f*f);
 137         f*=4;
 138         asFloat(f/2.5);
 139         isFloat(f/2.5);
 140         asFloat(2.5/f);
 141         isFloat(2.5/f);
 142         asFloat(f/f);
 143         isFloat(f/f);
 144         f/=4;
 145         asFloat(f);
 146         isFloat(f);
 147         f = 5;
 148         asFloat(*&f);
 149         isFloat(*&f);
 150         asFloat(234);
 151         asFloat(Float(234));
 152         isFloat(Float(234));
 153         asFloat(1.2);
 154         asFloat(Float(i));
 155         isFloat(Float(i));
 156
 157         asInt(i);
 158         isInt(i);
 159         asInt(-i);
 160         isInt(-i);
 161         asInt(^i);
 162         isInt(^i);
 163         asInt(+i);
 164         isInt(+i);
 165         asInt(i+1);
 166         isInt(i+1);
 167         asInt(1+i);
 168         isInt(1+i);
 169         asInt(i+i);
 170         isInt(i+i);
 171         i++;
 172         i+=1;
 173         asInt(i-1);
 174         isInt(i-1);
 175         asInt(1-i);
 176         isInt(1-i);
 177         asInt(i-i);
 178         isInt(i-i);
 179         i--;
 180         i-=1;
 181         asInt(i*2);
 182         isInt(i*2);
 183         asInt(2*i);
 184         isInt(2*i);
 185         asInt(i*i);
 186         isInt(i*i);
 187         i*=2;
 188         asInt(i/5);
 189         isInt(i/5);
 190         asInt(5/i);
 191         isInt(5/i);
 192         asInt(i/i);
 193         isInt(i/i);
 194         i/=2;
 195         asInt(i%5);
 196         isInt(i%5);
 197         asInt(5%i);
 198         isInt(5%i);
 199         asInt(i%i);
 200         isInt(i%i);
 201         i%=2;
 202         asInt(i&5);
 203         isInt(i&5);
 204         asInt(5&i);
 205         isInt(5&i);
 206         asInt(i&i);
 207         isInt(i&i);
 208         i&=2;
 209         asInt(i&^5);
 210         isInt(i&^5);
 211         asInt(5&^i);
 212         isInt(5&^i);
 213         asInt(i&^i);
 214         isInt(i&^i);
 215         i&^=2;
 216         asInt(i|5);
 217         isInt(i|5);
 218         asInt(5|i);
 219         isInt(5|i);
 220         asInt(i|i);
 221         isInt(i|i);
 222         i|=2;
 223         asInt(i^5);
 224         isInt(i^5);
 225         asInt(5^i);
 226         isInt(5^i);
 227         asInt(i^i);
 228         isInt(i^i);
 229         i^=2;
 230         asInt(i<<4);
 231         isInt(i<<4);
 232         i<<=2;
 233         asInt(i>>4);
 234         isInt(i>>4);
 235         i>>=2;
 236         asInt(i);
 237         isInt(i);
 238         asInt(0);
 239         asInt(Int(0));
 240         isInt(Int(0));
 241         i = 10;
 242         asInt(*&i);
 243         isInt(*&i);
 244         asInt(23);
 245         asInt(Int(f));
 246         isInt(Int(f));
 247
 248         asMap(m);
 249         isMap(m);
 250         asMap(nil);
 251         m = nil;
 252         asMap(make(Map));
 253         isMap(make(Map));
 254         asMap(*&m);
 255         isMap(*&m);
 256         asMap(Map(nil));
 257         isMap(Map(nil));
 258         asMap(Map{});
 259         isMap(Map{});
 260
 261         asSlice(slice);
 262         isSlice(slice);
 263         asSlice(make(Slice, 5));
 264         isSlice(make(Slice, 5));
 265         asSlice([]byte{1,2,3});
 266         asSlice([]byte{1,2,3}[0:2]);
 267         asSlice(slice[0:4]);
 268         isSlice(slice[0:4]);
 269         asSlice(slice[3:8]);
 270         isSlice(slice[3:8]);
 271         asSlice(nil);
 272         asSlice(Slice(nil));
 273         isSlice(Slice(nil));
 274         slice = nil;
 275         asSlice(Slice{1,2,3});
 276         isSlice(Slice{1,2,3});
 277         asSlice(Slice{});
 278         isSlice(Slice{});
 279         asSlice(*&slice);
 280         isSlice(*&slice);
 281
 282         asString(str);
 283         isString(str);
 284         asString(str+"a");
 285         isString(str+"a");
 286         asString("a"+str);
 287         isString("a"+str);
 288         asString(str+str);
 289         isString(str+str);
 290         str += "a";
 291         str += str;
 292         asString(String('a'));
 293         isString(String('a'));
 294         asString(String(slice));
 295         isString(String(slice));
 296         asString(String([]byte(nil)));
 297         isString(String([]byte(nil)));
 298         asString("hello");
 299         asString(String("hello"));
 300         isString(String("hello"));
 301         str = "hello";
 302         isString(str);
 303         asString(*&str);
 304         isString(*&str);
 305 }