You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
282 lines
4.6 KiB
282 lines
4.6 KiB
// run
|
|
|
|
// 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 float32
|
|
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(*&b)
|
|
isBool(*&b)
|
|
asBool(Bool(true))
|
|
isBool(Bool(true))
|
|
|
|
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([]byte(slice)))
|
|
isString(String([]byte(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)
|
|
}
|