mirror of
https://github.com/golang/go
synced 2024-11-11 19:21:37 -07:00
test of named operations
R=r DELTA=305 (305 added, 0 deleted, 0 changed) OCL=34848 CL=34875
This commit is contained in:
parent
2975308125
commit
ce46cbe89e
305
test/named.go
Normal file
305
test/named.go
Normal file
@ -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);
|
||||
}
|
Loading…
Reference in New Issue
Block a user