+++ /dev/null
-// This interpreter test is designed to run very quickly yet provide
-// some coverage of a broad selection of constructs.
-//
-// Validate this file with 'go run' after editing.
-// TODO(adonovan): break this into small files organized by theme.
-
-package main
-
-import (
- "fmt"
- "reflect"
- "strings"
-)
-
-func init() {
- // Call of variadic function with (implicit) empty slice.
- if x := fmt.Sprint(); x != "" {
- panic(x)
- }
-}
-
-type empty interface{}
-
-type I interface {
- f() int
-}
-
-type T struct{ z int }
-
-func (t T) f() int { return t.z }
-
-func use(interface{}) {}
-
-var counter = 2
-
-// Test initialization, including init blocks containing 'return'.
-// Assertion is in main.
-func init() {
- counter *= 3
- return
- counter *= 3
-}
-
-func init() {
- counter *= 5
- return
- counter *= 5
-}
-
-// Recursion.
-func fib(x int) int {
- if x < 2 {
- return x
- }
- return fib(x-1) + fib(x-2)
-}
-
-func fibgen(ch chan int) {
- for x := 0; x < 10; x++ {
- ch <- fib(x)
- }
- close(ch)
-}
-
-// Goroutines and channels.
-func init() {
- ch := make(chan int)
- go fibgen(ch)
- var fibs []int
- for v := range ch {
- fibs = append(fibs, v)
- if len(fibs) == 10 {
- break
- }
- }
- if x := fmt.Sprint(fibs); x != "[0 1 1 2 3 5 8 13 21 34]" {
- panic(x)
- }
-}
-
-// Test of aliasing.
-func init() {
- type S struct {
- a, b string
- }
-
- s1 := []string{"foo", "bar"}
- s2 := s1 // creates an alias
- s2[0] = "wiz"
- if x := fmt.Sprint(s1, s2); x != "[wiz bar] [wiz bar]" {
- panic(x)
- }
-
- pa1 := &[2]string{"foo", "bar"}
- pa2 := pa1 // creates an alias
- pa2[0] = "wiz"
- if x := fmt.Sprint(*pa1, *pa2); x != "[wiz bar] [wiz bar]" {
- panic(x)
- }
-
- a1 := [2]string{"foo", "bar"}
- a2 := a1 // creates a copy
- a2[0] = "wiz"
- if x := fmt.Sprint(a1, a2); x != "[foo bar] [wiz bar]" {
- panic(x)
- }
-
- t1 := S{"foo", "bar"}
- t2 := t1 // copy
- t2.a = "wiz"
- if x := fmt.Sprint(t1, t2); x != "{foo bar} {wiz bar}" {
- panic(x)
- }
-}
-
-func main() {
- print() // legal
-
- if counter != 2*3*5 {
- panic(counter)
- }
-
- // Test builtins (e.g. complex) preserve named argument types.
- type N complex128
- var n N
- n = complex(1.0, 2.0)
- if n != complex(1.0, 2.0) {
- panic(n)
- }
- if x := reflect.TypeOf(n).String(); x != "main.N" {
- panic(x)
- }
- if real(n) != 1.0 || imag(n) != 2.0 {
- panic(n)
- }
-
- // Channel + select.
- ch := make(chan int, 1)
- select {
- case ch <- 1:
- // ok
- default:
- panic("couldn't send")
- }
- if <-ch != 1 {
- panic("couldn't receive")
- }
- // A "receive" select-case that doesn't declare its vars. (regression test)
- anint := 0
- ok := false
- select {
- case anint, ok = <-ch:
- case anint = <-ch:
- default:
- }
- _ = anint
- _ = ok
-
- // Anon structs with methods.
- anon := struct{ T }{T: T{z: 1}}
- if x := anon.f(); x != 1 {
- panic(x)
- }
- var i I = anon
- if x := i.f(); x != 1 {
- panic(x)
- }
- // NB. precise output of reflect.Type.String is undefined.
- if x := reflect.TypeOf(i).String(); x != "struct { main.T }" && x != "struct{main.T}" {
- panic(x)
- }
-
- // fmt.
- const message = "Hello, World!"
- if fmt.Sprint("Hello", ", ", "World", "!") != message {
- panic("oops")
- }
-
- // Type assertion.
- type S struct {
- f int
- }
- var e empty = S{f: 42}
- switch v := e.(type) {
- case S:
- if v.f != 42 {
- panic(v.f)
- }
- default:
- panic(reflect.TypeOf(v))
- }
- if i, ok := e.(I); ok {
- panic(i)
- }
-
- // Switch.
- var x int
- switch x {
- case 1:
- panic(x)
- fallthrough
- case 2, 3:
- panic(x)
- default:
- // ok
- }
- // empty switch
- switch {
- }
- // empty switch
- switch {
- default:
- }
- // empty switch
- switch {
- default:
- fallthrough
- case false:
- }
-
- // string -> []rune conversion.
- use([]rune("foo"))
-
- // Calls of form x.f().
- type S2 struct {
- f func() int
- }
- S2{f: func() int { return 1 }}.f() // field is a func value
- T{}.f() // method call
- i.f() // interface method invocation
- (interface {
- f() int
- }(T{})).f() // anon interface method invocation
-
- // Map lookup.
- if v, ok := map[string]string{}["foo5"]; v != "" || ok {
- panic("oops")
- }
-
- // Regression test: implicit address-taken struct literal
- // inside literal map element.
- _ = map[int]*struct{}{0: {}}
-}
-
-type mybool bool
-
-func (mybool) f() {}
-
-func init() {
- type mybool bool
- var b mybool
- var i interface{} = b || b // result preserves types of operands
- _ = i.(mybool)
-
- i = false && b // result preserves type of "typed" operand
- _ = i.(mybool)
-
- i = b || true // result preserves type of "typed" operand
- _ = i.(mybool)
-}
-
-func init() {
- var x, y int
- var b mybool = x == y // x==y is an untyped bool
- b.f()
-}
-
-// Simple closures.
-func init() {
- b := 3
- f := func(a int) int {
- return a + b
- }
- b++
- if x := f(1); x != 5 { // 1+4 == 5
- panic(x)
- }
- b++
- if x := f(2); x != 7 { // 2+5 == 7
- panic(x)
- }
- if b := f(1) < 16 || f(2) < 17; !b {
- panic("oops")
- }
-}
-
-// Shifts.
-func init() {
- var i int64 = 1
- var u uint64 = 1 << 32
- if x := i << uint32(u); x != 1 {
- panic(x)
- }
- if x := i << uint64(u); x != 0 {
- panic(x)
- }
-}
-
-// Implicit conversion of delete() key operand.
-func init() {
- type I interface{}
- m := make(map[I]bool)
- m[1] = true
- m[I(2)] = true
- if len(m) != 2 {
- panic(m)
- }
- delete(m, I(1))
- delete(m, 2)
- if len(m) != 0 {
- panic(m)
- }
-}
-
-// An I->I conversion always succeeds.
-func init() {
- var x I
- if I(x) != I(nil) {
- panic("I->I conversion failed")
- }
-}
-
-// An I->I type-assert fails iff the value is nil.
-func init() {
- defer func() {
- r := fmt.Sprint(recover())
- // Exact error varies by toolchain.
- if r != "runtime error: interface conversion: interface is nil, not main.I" &&
- r != "interface conversion: interface is nil, not main.I" {
- panic("I->I type assertion succeeded for nil value")
- }
- }()
- var x I
- _ = x.(I)
-}
-
-//////////////////////////////////////////////////////////////////////
-// Variadic bridge methods and interface thunks.
-
-type VT int
-
-var vcount = 0
-
-func (VT) f(x int, y ...string) {
- vcount++
- if x != 1 {
- panic(x)
- }
- if len(y) != 2 || y[0] != "foo" || y[1] != "bar" {
- panic(y)
- }
-}
-
-type VS struct {
- VT
-}
-
-type VI interface {
- f(x int, y ...string)
-}
-
-func init() {
- foobar := []string{"foo", "bar"}
- var s VS
- s.f(1, "foo", "bar")
- s.f(1, foobar...)
- if vcount != 2 {
- panic("s.f not called twice")
- }
-
- fn := VI.f
- fn(s, 1, "foo", "bar")
- fn(s, 1, foobar...)
- if vcount != 4 {
- panic("I.f not called twice")
- }
-}
-
-// Multiple labels on same statement.
-func multipleLabels() {
- var trace []int
- i := 0
-one:
-two:
- for ; i < 3; i++ {
- trace = append(trace, i)
- switch i {
- case 0:
- continue two
- case 1:
- i++
- goto one
- case 2:
- break two
- }
- }
- if x := fmt.Sprint(trace); x != "[0 1 2]" {
- panic(x)
- }
-}
-
-func init() {
- multipleLabels()
-}
-
-func init() {
- // Struct equivalence ignores blank fields.
- type s struct{ x, _, z int }
- s1 := s{x: 1, z: 3}
- s2 := s{x: 1, z: 3}
- if s1 != s2 {
- panic("not equal")
- }
-}
-
-func init() {
- // A slice var can be compared to const []T nil.
- var i interface{} = []string{"foo"}
- var j interface{} = []string(nil)
- if i.([]string) == nil {
- panic("expected i non-nil")
- }
- if j.([]string) != nil {
- panic("expected j nil")
- }
- // But two slices cannot be compared, even if one is nil.
- defer func() {
- r := fmt.Sprint(recover())
- if !(strings.Contains(r, "compar") && strings.Contains(r, "[]string")) {
- panic("want panic from slice comparison, got " + r)
- }
- }()
- _ = i == j // interface comparison recurses on types
-}
-
-func init() {
- // Regression test for SSA renaming bug.
- var ints []int
- for range "foo" {
- var x int
- x++
- ints = append(ints, x)
- }
- if fmt.Sprint(ints) != "[1 1 1]" {
- panic(ints)
- }
-}
-
-// Regression test for issue 6949:
-// []byte("foo") is not a constant since it allocates memory.
-func init() {
- var r string
- for i, b := range "ABC" {
- x := []byte("abc")
- x[i] = byte(b)
- r += string(x)
- }
- if r != "AbcaBcabC" {
- panic(r)
- }
-}
-
-// Test of 3-operand x[lo:hi:max] slice.
-func init() {
- s := []int{0, 1, 2, 3}
- lenCapLoHi := func(x []int) [4]int { return [4]int{len(x), cap(x), x[0], x[len(x)-1]} }
- if got := lenCapLoHi(s[1:3]); got != [4]int{2, 3, 1, 2} {
- panic(got)
- }
- if got := lenCapLoHi(s[1:3:3]); got != [4]int{2, 2, 1, 2} {
- panic(got)
- }
- max := 3
- if "a"[0] == 'a' {
- max = 2 // max is non-constant, even in SSA form
- }
- if got := lenCapLoHi(s[1:2:max]); got != [4]int{1, 1, 1, 1} {
- panic(got)
- }
-}
-
-var one = 1 // not a constant
-
-// Test makeslice.
-func init() {
- check := func(s []string, wantLen, wantCap int) {
- if len(s) != wantLen {
- panic(len(s))
- }
- if cap(s) != wantCap {
- panic(cap(s))
- }
- }
- // SSA form:
- check(make([]string, 10), 10, 10) // new([10]string)[:10]
- check(make([]string, one), 1, 1) // make([]string, one, one)
- check(make([]string, 0, 10), 0, 10) // new([10]string)[:0]
- check(make([]string, 0, one), 0, 1) // make([]string, 0, one)
- check(make([]string, one, 10), 1, 10) // new([10]string)[:one]
- check(make([]string, one, one), 1, 1) // make([]string, one, one)
-}
-
-// Test that a nice error is issued by indirection wrappers.
-func init() {
- var ptr *T
- var i I = ptr
-
- defer func() {
- r := fmt.Sprint(recover())
- // Exact error varies by toolchain:
- if r != "runtime error: value method (main.T).f called using nil *main.T pointer" &&
- r != "value method (main.T).f called using nil *main.T pointer" {
- panic("want panic from call with nil receiver, got " + r)
- }
- }()
- i.f()
- panic("unreachable")
-}
-
-// Regression test for a subtle bug in which copying values would causes
-// subcomponents of aggregate variables to change address, breaking
-// aliases.
-func init() {
- type T struct{ f int }
- var x T
- p := &x.f
- x = T{}
- *p = 1
- if x.f != 1 {
- panic("lost store")
- }
- if p != &x.f {
- panic("unstable address")
- }
-}
projects / dotfiles / .git / blobdiff