test of named operations

R=r
DELTA=305  (305 added, 0 deleted, 0 changed)
OCL=34848
CL=34875

test/named.go

@@ -0,0 +1,305 @@
+// $G $D/$F.go && $L $F.$A && ./$A.out
+
+// Copyright 2009 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test that basic operations on named types are valid
+// and preserve the type.
+
+package main
+
+type Array [10]byte
+type Bool bool
+type Chan chan int
+type Float float
+type Int int
+type Map map[int]byte
+type Slice []byte
+type String string
+
+// Calling these functions checks at compile time that the argument
+// can be converted implicitly to (used as) the given type.
+func asArray(Array) {}
+func asBool(Bool) {}
+func asChan(Chan) {}
+func asFloat(Float) {}
+func asInt(Int) {}
+func asMap(Map) {}
+func asSlice(Slice) {}
+func asString(String) {}
+
+func (Map) M() {}
+
+
+// These functions check at run time that the default type
+// (in the absence of any implicit conversion hints)
+// is the given type.
+func isArray(x interface{}) { _ = x.(Array) }
+func isBool(x interface{}) { _ = x.(Bool) }
+func isChan(x interface{}) { _ = x.(Chan) }
+func isFloat(x interface{}) { _ = x.(Float) }
+func isInt(x interface{}) { _ = x.(Int) }
+func isMap(x interface{}) { _ = x.(Map) }
+func isSlice(x interface{}) { _ = x.(Slice) }
+func isString(x interface{}) { _ = x.(String) }
+
+func main() {
+	var (
+		a Array;
+		b Bool = true;
+		c Chan = make(Chan);
+		f Float = 1;
+		i Int = 1;
+		m Map = make(Map);
+		slice Slice = make(Slice, 10);
+		str String = "hello";
+	)
+
+	asArray(a);
+	isArray(a);
+	asArray(*&a);
+	isArray(*&a);
+	asArray(Array{});
+	isArray(Array{});
+
+	asBool(b);
+	isBool(b);
+	asBool(!b);
+	isBool(!b);
+	asBool(true);
+	asBool(1!=2);
+	asBool(*&b);
+	isBool(*&b);
+	asBool(Bool(true));
+	isBool(Bool(true));
+	asBool(i < Int(f));
+
+	_, b = m[2];
+	m[2] = 1, b;
+
+	b = c<-1;
+	_ = b;
+	asBool(c<-1);
+
+	_, b = <-c;
+	_ = b;
+
+	var inter interface{};
+	_, b = inter.(Map);
+	_ = b;
+
+	var minter interface{M()};
+	_, b = minter.(Map);
+	_ = b;
+
+	asBool(closed(c));
+	b = closed(c);
+	_ = b;
+
+	asChan(c);
+	isChan(c);
+	asChan(make(Chan));
+	isChan(make(Chan));
+	asChan(*&c);
+	isChan(*&c);
+	asChan(Chan(nil));
+	isChan(Chan(nil));
+
+	asFloat(f);
+	isFloat(f);
+	asFloat(-f);
+	isFloat(-f);
+	asFloat(+f);
+	isFloat(+f);
+	asFloat(f+1);
+	isFloat(f+1);
+	asFloat(1+f);
+	isFloat(1+f);
+	asFloat(f+f);
+	isFloat(f+f);
+	f++;
+	f+=2;
+	asFloat(f-1);
+	isFloat(f-1);
+	asFloat(1-f);
+	isFloat(1-f);
+	asFloat(f-f);
+	isFloat(f-f);
+	f--;
+	f-=2;
+	asFloat(f*2.5);
+	isFloat(f*2.5);
+	asFloat(2.5*f);
+	isFloat(2.5*f);
+	asFloat(f*f);
+	isFloat(f*f);
+	f*=4;
+	asFloat(f/2.5);
+	isFloat(f/2.5);
+	asFloat(2.5/f);
+	isFloat(2.5/f);
+	asFloat(f/f);
+	isFloat(f/f);
+	f/=4;
+	asFloat(f);
+	isFloat(f);
+	f = 5;
+	asFloat(*&f);
+	isFloat(*&f);
+	asFloat(234);
+	asFloat(Float(234));
+	isFloat(Float(234));
+	asFloat(1.2);
+	asFloat(Float(i));
+	isFloat(Float(i));
+
+	asInt(i);
+	isInt(i);
+	asInt(-i);
+	isInt(-i);
+	asInt(^i);
+	isInt(^i);
+	asInt(+i);
+	isInt(+i);
+	asInt(i+1);
+	isInt(i+1);
+	asInt(1+i);
+	isInt(1+i);
+	asInt(i+i);
+	isInt(i+i);
+	i++;
+	i+=1;
+	asInt(i-1);
+	isInt(i-1);
+	asInt(1-i);
+	isInt(1-i);
+	asInt(i-i);
+	isInt(i-i);
+	i--;
+	i-=1;
+	asInt(i*2);
+	isInt(i*2);
+	asInt(2*i);
+	isInt(2*i);
+	asInt(i*i);
+	isInt(i*i);
+	i*=2;
+	asInt(i/5);
+	isInt(i/5);
+	asInt(5/i);
+	isInt(5/i);
+	asInt(i/i);
+	isInt(i/i);
+	i/=2;
+	asInt(i%5);
+	isInt(i%5);
+	asInt(5%i);
+	isInt(5%i);
+	asInt(i%i);
+	isInt(i%i);
+	i%=2;
+	asInt(i&5);
+	isInt(i&5);
+	asInt(5&i);
+	isInt(5&i);
+	asInt(i&i);
+	isInt(i&i);
+	i&=2;
+	asInt(i&^5);
+	isInt(i&^5);
+	asInt(5&^i);
+	isInt(5&^i);
+	asInt(i&^i);
+	isInt(i&^i);
+	i&^=2;
+	asInt(i|5);
+	isInt(i|5);
+	asInt(5|i);
+	isInt(5|i);
+	asInt(i|i);
+	isInt(i|i);
+	i|=2;
+	asInt(i^5);
+	isInt(i^5);
+	asInt(5^i);
+	isInt(5^i);
+	asInt(i^i);
+	isInt(i^i);
+	i^=2;
+	asInt(i<<4);
+	isInt(i<<4);
+	i<<=2;
+	asInt(i>>4);
+	isInt(i>>4);
+	i>>=2;
+	asInt(i);
+	isInt(i);
+	asInt(0);
+	asInt(Int(0));
+	isInt(Int(0));
+	i = 10;
+	asInt(*&i);
+	isInt(*&i);
+	asInt(23);
+	asInt(Int(f));
+	isInt(Int(f));
+
+	asMap(m);
+	isMap(m);
+	asMap(nil);
+	m = nil;
+	asMap(make(Map));
+	isMap(make(Map));
+	asMap(*&m);
+	isMap(*&m);
+	asMap(Map(nil));
+	isMap(Map(nil));
+	asMap(Map{});
+	isMap(Map{});
+
+	asSlice(slice);
+	isSlice(slice);
+	asSlice(make(Slice, 5));
+	isSlice(make(Slice, 5));
+	asSlice([]byte{1,2,3});
+	asSlice([]byte{1,2,3}[0:2]);
+	asSlice(slice[0:4]);
+	isSlice(slice[0:4]);
+	asSlice(slice[3:8]);
+	isSlice(slice[3:8]);
+	asSlice(nil);
+	asSlice(Slice(nil));
+	isSlice(Slice(nil));
+	slice = nil;
+	asSlice(Slice{1,2,3});
+	isSlice(Slice{1,2,3});
+	asSlice(Slice{});
+	isSlice(Slice{});
+	asSlice(*&slice);
+	isSlice(*&slice);
+
+	asString(str);
+	isString(str);
+	asString(str+"a");
+	isString(str+"a");
+	asString("a"+str);
+	isString("a"+str);
+	asString(str+str);
+	isString(str+str);
+	str += "a";
+	str += str;
+	asString(String('a'));
+	isString(String('a'));
+	asString(String(slice));
+	isString(String(slice));
+	asString(String([]byte(nil)));
+	isString(String([]byte(nil)));
+	asString("hello");
+	asString(String("hello"));
+	isString(String("hello"));
+	str = "hello";
+	isString(str);
+	asString(*&str);
+	isString(*&str);
+}