...
Run Format

Source file test/named.go

Documentation: test

  // 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)
  }
  

View as plain text