...
Run Format

Source file test/convT2X.go

Documentation: test

  // run
  
  // Copyright 2012 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 conversion from non-interface types to the empty interface.
  
  package main
  
  type J interface {
  	Method()
  }
  
  type (
  	U16  uint16
  	U32  uint32
  	U64  uint64
  	U128 [2]uint64
  	F32  float32
  	F64  float64
  	C128 complex128
  	S    string
  	B    []byte
  	M    map[int]int
  	C    chan int
  	Z    struct{}
  )
  
  func (U16) Method()  {}
  func (U32) Method()  {}
  func (U64) Method()  {}
  func (U128) Method() {}
  func (F32) Method()  {}
  func (F64) Method()  {}
  func (C128) Method() {}
  func (S) Method()    {}
  func (B) Method()    {}
  func (M) Method()    {}
  func (C) Method()    {}
  func (Z) Method()    {}
  
  var (
  	u16  = U16(1)
  	u32  = U32(2)
  	u64  = U64(3)
  	u128 = U128{4, 5}
  	f32  = F32(6)
  	f64  = F64(7)
  	c128 = C128(8 + 9i)
  	s    = S("10")
  	b    = B("11")
  	m    = M{12: 13}
  	c    = make(C, 14)
  	z    = Z{}
  	p    = &z
  	pp   = &p
  )
  
  var (
  	iu16  interface{} = u16
  	iu32  interface{} = u32
  	iu64  interface{} = u64
  	iu128 interface{} = u128
  	if32  interface{} = f32
  	if64  interface{} = f64
  	ic128 interface{} = c128
  	is    interface{} = s
  	ib    interface{} = b
  	im    interface{} = m
  	ic    interface{} = c
  	iz    interface{} = z
  	ip    interface{} = p
  	ipp   interface{} = pp
  
  	ju16  J = u16
  	ju32  J = u32
  	ju64  J = u64
  	ju128 J = u128
  	jf32  J = f32
  	jf64  J = f64
  	jc128 J = c128
  	js    J = s
  	jb    J = b
  	jm    J = m
  	jc    J = c
  	jz J = z
  	jp J = p // The method set for *T contains the methods for T.
  	// pp does not implement error.
  )
  
  func second(a ...interface{}) interface{} {
  	return a[1]
  }
  
  func main() {
  	// Test equality.
  	if u16 != iu16 {
  		panic("u16 != iu16")
  	}
  	if u16 != ju16 {
  		panic("u16 != ju16")
  	}
  	if u32 != iu32 {
  		panic("u32 != iu32")
  	}
  	if u32 != ju32 {
  		panic("u32 != ju32")
  	}
  	if u64 != iu64 {
  		panic("u64 != iu64")
  	}
  	if u64 != ju64 {
  		panic("u64 != ju64")
  	}
  	if u128 != iu128 {
  		panic("u128 != iu128")
  	}
  	if u128 != ju128 {
  		panic("u128 != ju128")
  	}
  	if f32 != if32 {
  		panic("f32 != if32")
  	}
  	if f32 != jf32 {
  		panic("f32 != jf32")
  	}
  	if f64 != if64 {
  		panic("f64 != if64")
  	}
  	if f64 != jf64 {
  		panic("f64 != jf64")
  	}
  	if c128 != ic128 {
  		panic("c128 != ic128")
  	}
  	if c128 != jc128 {
  		panic("c128 != jc128")
  	}
  	if s != is {
  		panic("s != is")
  	}
  	if s != js {
  		panic("s != js")
  	}
  	if c != ic {
  		panic("c != ic")
  	}
  	if c != jc {
  		panic("c != jc")
  	}
  	// There are no tests for b and m, as slices and maps are not comparable by ==.
  	if z != iz {
  		panic("z != iz")
  	}
  	if z != jz {
  		panic("z != jz")
  	}
  	if p != ip {
  		panic("p != ip")
  	}
  	if p != jp {
  		panic("p != jp")
  	}
  	if pp != ipp {
  		panic("pp != ipp")
  	}
  	// pp does not implement J.
  
  	// Test that non-interface types can be used as ...interface{} arguments.
  	if got := second(z, p, pp, u16, u32, u64, u128, f32, f64, c128, s, b, m, c); got != ip {
  		println("second: got", got, "want", ip)
  		panic("fail")
  	}
  
  	// Test that non-interface types can be sent on a chan interface{}.
  	const n = 100
  	uc := make(chan interface{})
  	go func() {
  		for i := 0; i < n; i++ {
  			select {
  			case uc <- nil:
  			case uc <- u32:
  			case uc <- u64:
  			case uc <- u128:
  			}
  		}
  	}()
  	for i := 0; i < n; i++ {
  		if got := <-uc; got != nil && got != u32 && got != u64 && got != u128 {
  			println("recv: i", i, "got", got)
  			panic("fail")
  		}
  	}
  }
  

View as plain text