Subversion Repositories openrisc

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