summaryrefslogtreecommitdiffstats
path: root/test/blank.go
diff options
context:
space:
mode:
Diffstat (limited to 'test/blank.go')
-rw-r--r--test/blank.go189
1 files changed, 189 insertions, 0 deletions
diff --git a/test/blank.go b/test/blank.go
new file mode 100644
index 0000000..0539deb
--- /dev/null
+++ b/test/blank.go
@@ -0,0 +1,189 @@
+// 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 behavior of the blank identifier (_).
+
+package main
+
+import (
+ "os"
+ "unsafe"
+)
+
+import _ "fmt"
+
+var call string
+
+type T struct {
+ _, _, _ int
+}
+
+func (T) _() {
+}
+
+func (T) _() {
+}
+
+type U struct {
+ _ struct{ a, b, c int }
+}
+
+const (
+ c0 = iota
+ _
+ _
+ _
+ c4
+)
+
+var ints = []string{
+ "1",
+ "2",
+ "3",
+}
+
+func f() (int, int) {
+ call += "f"
+ return 1, 2
+}
+
+func g() (float64, float64) {
+ call += "g"
+ return 3, 4
+}
+
+func h(_ int, _ float64) {
+}
+
+func i() int {
+ call += "i"
+ return 23
+}
+
+var _ = i()
+
+func main() {
+ if call != "i" {
+ panic("init did not run")
+ }
+ call = ""
+ _, _ = f()
+ a, _ := f()
+ if a != 1 {
+ panic(a)
+ }
+ b, _ := g()
+ if b != 3 {
+ panic(b)
+ }
+ _, a = f()
+ if a != 2 {
+ panic(a)
+ }
+ _, b = g()
+ if b != 4 {
+ panic(b)
+ }
+ _ = i()
+ if call != "ffgfgi" {
+ panic(call)
+ }
+ if c4 != 4 {
+ panic(c4)
+ }
+
+ out := ""
+ for _, s := range ints {
+ out += s
+ }
+ if out != "123" {
+ panic(out)
+ }
+
+ sum := 0
+ for s := range ints {
+ sum += s
+ }
+ if sum != 3 {
+ panic(sum)
+ }
+
+ // go.tools/ssa/interp cannot support unsafe.Pointer.
+ if os.Getenv("GOSSAINTERP") == "" {
+ type T1 struct{ x, y, z int }
+ t1 := *(*T)(unsafe.Pointer(&T1{1, 2, 3}))
+ t2 := *(*T)(unsafe.Pointer(&T1{4, 5, 6}))
+ if t1 != t2 {
+ panic("T{} != T{}")
+ }
+
+ var u1, u2 interface{}
+ u1 = *(*U)(unsafe.Pointer(&T1{1, 2, 3}))
+ u2 = *(*U)(unsafe.Pointer(&T1{4, 5, 6}))
+ if u1 != u2 {
+ panic("U{} != U{}")
+ }
+ }
+
+ h(a, b)
+
+ m()
+}
+
+type I interface {
+ M(_ int, y int)
+}
+
+type TI struct{}
+
+func (_ TI) M(x int, y int) {
+ if x != y {
+ println("invalid M call:", x, y)
+ panic("bad M")
+ }
+}
+
+var fp = func(_ int, y int) {}
+
+func init() {
+ fp = fp1
+}
+
+func fp1(x, y int) {
+ if x != y {
+ println("invalid fp1 call:", x, y)
+ panic("bad fp1")
+ }
+}
+
+func m() {
+ var i I
+
+ i = TI{}
+ i.M(1, 1)
+ i.M(2, 2)
+
+ fp(1, 1)
+ fp(2, 2)
+}
+
+// useless but legal
+var _ int = 1
+var _ = 2
+var _, _ = 3, 4
+
+const _ = 3
+const _, _ = 4, 5
+
+type _ int
+
+func _() {
+ panic("oops")
+}
+
+func ff() {
+ var _ int = 1
+}