test/convT2X.go

   1 // run
   2
   3 // Copyright 2012 The Go Authors. All rights reserved.
   4 // Use of this source code is governed by a BSD-style
   5 // license that can be found in the LICENSE file.
   6
   7 // Test conversion from non-interface types to the empty interface.
   8
   9 package main
  10
  11 type J interface {
  12         Method()
  13 }
  14
  15 type (
  16         U16  uint16
  17         U32  uint32
  18         U64  uint64
  19         U128 [2]uint64
  20         F32  float32
  21         F64  float64
  22         C128 complex128
  23         S    string
  24         B    []byte
  25         M    map[int]int
  26         C    chan int
  27         Z    struct{}
  28 )
  29
  30 func (U16) Method()  {}
  31 func (U32) Method()  {}
  32 func (U64) Method()  {}
  33 func (U128) Method() {}
  34 func (F32) Method()  {}
  35 func (F64) Method()  {}
  36 func (C128) Method() {}
  37 func (S) Method()    {}
  38 func (B) Method()    {}
  39 func (M) Method()    {}
  40 func (C) Method()    {}
  41 func (Z) Method()    {}
  42
  43 var (
  44         u16  = U16(1)
  45         u32  = U32(2)
  46         u64  = U64(3)
  47         u128 = U128{4, 5}
  48         f32  = F32(6)
  49         f64  = F64(7)
  50         c128 = C128(8 + 9i)
  51         s    = S("10")
  52         b    = B("11")
  53         m    = M{12: 13}
  54         c    = make(C, 14)
  55         z    = Z{}
  56         p    = &z
  57         pp   = &p
  58 )
  59
  60 var (
  61         iu16  interface{} = u16
  62         iu32  interface{} = u32
  63         iu64  interface{} = u64
  64         iu128 interface{} = u128
  65         if32  interface{} = f32
  66         if64  interface{} = f64
  67         ic128 interface{} = c128
  68         is    interface{} = s
  69         ib    interface{} = b
  70         im    interface{} = m
  71         ic    interface{} = c
  72         iz    interface{} = z
  73         ip    interface{} = p
  74         ipp   interface{} = pp
  75
  76         ju16  J = u16
  77         ju32  J = u32
  78         ju64  J = u64
  79         ju128 J = u128
  80         jf32  J = f32
  81         jf64  J = f64
  82         jc128 J = c128
  83         js    J = s
  84         jb    J = b
  85         jm    J = m
  86         jc    J = c
  87         jz J = z
  88         jp J = p // The method set for *T contains the methods for T.
  89         // pp does not implement error.
  90 )
  91
  92 func second(a ...interface{}) interface{} {
  93         return a[1]
  94 }
  95
  96 func main() {
  97         // Test equality.
  98         if u16 != iu16 {
  99                 panic("u16 != iu16")
 100         }
 101         if u16 != ju16 {
 102                 panic("u16 != ju16")
 103         }
 104         if u32 != iu32 {
 105                 panic("u32 != iu32")
 106         }
 107         if u32 != ju32 {
 108                 panic("u32 != ju32")
 109         }
 110         if u64 != iu64 {
 111                 panic("u64 != iu64")
 112         }
 113         if u64 != ju64 {
 114                 panic("u64 != ju64")
 115         }
 116         if u128 != iu128 {
 117                 panic("u128 != iu128")
 118         }
 119         if u128 != ju128 {
 120                 panic("u128 != ju128")
 121         }
 122         if f32 != if32 {
 123                 panic("f32 != if32")
 124         }
 125         if f32 != jf32 {
 126                 panic("f32 != jf32")
 127         }
 128         if f64 != if64 {
 129                 panic("f64 != if64")
 130         }
 131         if f64 != jf64 {
 132                 panic("f64 != jf64")
 133         }
 134         if c128 != ic128 {
 135                 panic("c128 != ic128")
 136         }
 137         if c128 != jc128 {
 138                 panic("c128 != jc128")
 139         }
 140         if s != is {
 141                 panic("s != is")
 142         }
 143         if s != js {
 144                 panic("s != js")
 145         }
 146         if c != ic {
 147                 panic("c != ic")
 148         }
 149         if c != jc {
 150                 panic("c != jc")
 151         }
 152         // There are no tests for b and m, as slices and maps are not comparable by ==.
 153         if z != iz {
 154                 panic("z != iz")
 155         }
 156         if z != jz {
 157                 panic("z != jz")
 158         }
 159         if p != ip {
 160                 panic("p != ip")
 161         }
 162         if p != jp {
 163                 panic("p != jp")
 164         }
 165         if pp != ipp {
 166                 panic("pp != ipp")
 167         }
 168         // pp does not implement J.
 169
 170         // Test that non-interface types can be used as ...interface{} arguments.
 171         if got := second(z, p, pp, u16, u32, u64, u128, f32, f64, c128, s, b, m, c); got != ip {
 172                 println("second: got", got, "want", ip)
 173                 panic("fail")
 174         }
 175
 176         // Test that non-interface types can be sent on a chan interface{}.
 177         const n = 100
 178         uc := make(chan interface{})
 179         go func() {
 180                 for i := 0; i < n; i++ {
 181                         select {
 182                         case uc <- nil:
 183                         case uc <- u32:
 184                         case uc <- u64:
 185                         case uc <- u128:
 186                         }
 187                 }
 188         }()
 189         for i := 0; i < n; i++ {
 190                 if got := <-uc; got != nil && got != u32 && got != u64 && got != u128 {
 191                         println("recv: i", i, "got", got)
 192                         panic("fail")
 193                 }
 194         }
 195 }