test/blank.go

   1 // run
   2
   3 // Copyright 2009 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 behavior of the blank identifier (_).
   8
   9 package main
  10
  11 import "unsafe"
  12
  13 import _ "fmt"
  14
  15 var call string
  16
  17 type T struct {
  18         _, _, _ int
  19 }
  20
  21 func (T) _() {
  22 }
  23
  24 func (T) _() {
  25 }
  26
  27 const (
  28         c0 = iota
  29         _
  30         _
  31         _
  32         c4
  33 )
  34
  35 var ints = []string{
  36         "1",
  37         "2",
  38         "3",
  39 }
  40
  41 func f() (int, int) {
  42         call += "f"
  43         return 1, 2
  44 }
  45
  46 func g() (float64, float64) {
  47         call += "g"
  48         return 3, 4
  49 }
  50
  51 func h(_ int, _ float64) {
  52 }
  53
  54 func i() int {
  55         call += "i"
  56         return 23
  57 }
  58
  59 var _ = i()
  60
  61 func main() {
  62         if call != "i" {
  63                 panic("init did not run")
  64         }
  65         call = ""
  66         _, _ = f()
  67         a, _ := f()
  68         if a != 1 {
  69                 panic(a)
  70         }
  71         b, _ := g()
  72         if b != 3 {
  73                 panic(b)
  74         }
  75         _, a = f()
  76         if a != 2 {
  77                 panic(a)
  78         }
  79         _, b = g()
  80         if b != 4 {
  81                 panic(b)
  82         }
  83         _ = i()
  84         if call != "ffgfgi" {
  85                 panic(call)
  86         }
  87         if c4 != 4 {
  88                 panic(c4)
  89         }
  90
  91         out := ""
  92         for _, s := range ints {
  93                 out += s
  94         }
  95         if out != "123" {
  96                 panic(out)
  97         }
  98
  99         sum := 0
 100         for s := range ints {
 101                 sum += s
 102         }
 103         if sum != 3 {
 104                 panic(sum)
 105         }
 106
 107         type T1 struct{ x, y, z int }
 108         t1 := *(*T)(unsafe.Pointer(&T1{1, 2, 3}))
 109         t2 := *(*T)(unsafe.Pointer(&T1{4, 5, 6}))
 110         if t1 != t2 {
 111                 panic("T{} != T{}")
 112         }
 113
 114         h(a, b)
 115
 116         m()
 117 }
 118
 119 type I interface {
 120         M(_ int, y int)
 121 }
 122
 123 type TI struct{}
 124
 125 func (_ TI) M(x int, y int) {
 126         if x != y {
 127                 println("invalid M call:", x, y)
 128                 panic("bad M")
 129         }
 130 }
 131
 132 var fp = func(_ int, y int) {}
 133
 134 func init() {
 135         fp = fp1
 136 }
 137
 138 func fp1(x, y int) {
 139         if x != y {
 140                 println("invalid fp1 call:", x, y)
 141                 panic("bad fp1")
 142         }
 143 }
 144
 145 func m() {
 146         var i I
 147
 148         i = TI{}
 149         i.M(1, 1)
 150         i.M(2, 2)
 151
 152         fp(1, 1)
 153         fp(2, 2)
 154 }
 155
 156 // useless but legal
 157 var _ int = 1
 158 var _ = 2
 159 var _, _ = 3, 4
 160
 161 const _ = 3
 162 const _, _ = 4, 5
 163
 164 type _ int
 165
 166 func _() {
 167         panic("oops")
 168 }
 169
 170 func ff() {
 171         var _ int = 1
 172 }