| // $G $D/$F.go && $L $F.$A && ./$A.out >tmp.go && | |
| // $G tmp.go && $L tmp.$A && ./$A.out || echo BUG: select5 | |
| // rm -f tmp.go | |
| // Copyright 2011 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. | |
| // Generate test of channel operations and simple selects. | |
| // Only doing one real send or receive at a time, but phrased | |
| // in various ways that the compiler may or may not rewrite | |
| // into simpler expressions. | |
| package main | |
| import ( | |
| "bufio" | |
| "fmt" | |
| "io" | |
| "os" | |
| "template" | |
| ) | |
| func main() { | |
| out := bufio.NewWriter(os.Stdout) | |
| fmt.Fprintln(out, header) | |
| a := new(arg) | |
| // Generate each kind of test as a separate function to avoid | |
| // hitting the 6g optimizer with one enormous function. | |
| // If we name all the functions init we don't have to | |
| // maintain a list of which ones to run. | |
| do := func(t *template.Template) { | |
| fmt.Fprintln(out, `func init() {`) | |
| for ; next(); a.reset() { | |
| run(t, a, out) | |
| } | |
| fmt.Fprintln(out, `}`) | |
| } | |
| do(recv) | |
| do(send) | |
| do(recvOrder) | |
| do(sendOrder) | |
| do(nonblock) | |
| fmt.Fprintln(out, "//", a.nreset, "cases") | |
| out.Flush() | |
| } | |
| func run(t *template.Template, a interface{}, out io.Writer) { | |
| if err := t.Execute(out, a); err != nil { | |
| panic(err) | |
| } | |
| } | |
| type arg struct{ | |
| def bool | |
| nreset int | |
| } | |
| func (a *arg) Maybe() bool { | |
| return maybe() | |
| } | |
| func (a *arg) MaybeDefault() bool { | |
| if a.def { | |
| return false | |
| } | |
| a.def = maybe() | |
| return a.def | |
| } | |
| func (a *arg) MustDefault() bool { | |
| return !a.def | |
| } | |
| func (a *arg) reset() { | |
| a.def = false | |
| a.nreset++ | |
| } | |
| const header = `// GENERATED BY select5.go; DO NOT EDIT | |
| package main | |
| // channel is buffered so test is single-goroutine. | |
| // we are not interested in the concurrency aspects | |
| // of select, just testing that the right calls happen. | |
| var c = make(chan int, 1) | |
| var nilch chan int | |
| var n = 1 | |
| var x int | |
| var i interface{} | |
| var dummy = make(chan int) | |
| var m = make(map[int]int) | |
| var order = 0 | |
| func f(p *int) *int { | |
| return p | |
| } | |
| // check order of operations by ensuring that | |
| // successive calls to checkorder have increasing o values. | |
| func checkorder(o int) { | |
| if o <= order { | |
| println("invalid order", o, "after", order) | |
| panic("order") | |
| } | |
| order = o | |
| } | |
| func fc(c chan int, o int) chan int { | |
| checkorder(o) | |
| return c | |
| } | |
| func fp(p *int, o int) *int { | |
| checkorder(o) | |
| return p | |
| } | |
| func fn(n, o int) int { | |
| checkorder(o) | |
| return n | |
| } | |
| func die(x int) { | |
| println("have", x, "want", n) | |
| panic("chan") | |
| } | |
| func main() { | |
| // everything happens in init funcs | |
| } | |
| ` | |
| func parse(s string) *template.Template { | |
| t := template.New(nil) | |
| t.SetDelims("〈", "〉") | |
| if err := t.Parse(s); err != nil { | |
| panic(s) | |
| } | |
| return t | |
| } | |
| var recv = parse(` | |
| 〈# Send n, receive it one way or another into x, check that they match.〉 | |
| c <- n | |
| 〈.section Maybe〉 | |
| x = <-c | |
| 〈.or〉 | |
| select { | |
| 〈# Blocking or non-blocking, before the receive.〉 | |
| 〈# The compiler implements two-case select where one is default with custom code,〉 | |
| 〈# so test the default branch both before and after the send.〉 | |
| 〈.section MaybeDefault〉 | |
| default: | |
| panic("nonblock") | |
| 〈.end〉 | |
| 〈# Receive from c. Different cases are direct, indirect, :=, interface, and map assignment.〉 | |
| 〈.section Maybe〉 | |
| case x = <-c: | |
| 〈.or〉〈.section Maybe〉 | |
| case *f(&x) = <-c: | |
| 〈.or〉〈.section Maybe〉 | |
| case y := <-c: | |
| x = y | |
| 〈.or〉〈.section Maybe〉 | |
| case i = <-c: | |
| x = i.(int) | |
| 〈.or〉 | |
| case m[13] = <-c: | |
| x = m[13] | |
| 〈.end〉〈.end〉〈.end〉〈.end〉 | |
| 〈# Blocking or non-blocking again, after the receive.〉 | |
| 〈.section MaybeDefault〉 | |
| default: | |
| panic("nonblock") | |
| 〈.end〉 | |
| 〈# Dummy send, receive to keep compiler from optimizing select.〉 | |
| 〈.section Maybe〉 | |
| case dummy <- 1: | |
| panic("dummy send") | |
| 〈.end〉 | |
| 〈.section Maybe〉 | |
| case <-dummy: | |
| panic("dummy receive") | |
| 〈.end〉 | |
| 〈# Nil channel send, receive to keep compiler from optimizing select.〉 | |
| 〈.section Maybe〉 | |
| case nilch <- 1: | |
| panic("nilch send") | |
| 〈.end〉 | |
| 〈.section Maybe〉 | |
| case <-nilch: | |
| panic("nilch recv") | |
| 〈.end〉 | |
| } | |
| 〈.end〉 | |
| if x != n { | |
| die(x) | |
| } | |
| n++ | |
| `) | |
| var recvOrder = parse(` | |
| 〈# Send n, receive it one way or another into x, check that they match.〉 | |
| 〈# Check order of operations along the way by calling functions that check〉 | |
| 〈# that the argument sequence is strictly increasing.〉 | |
| order = 0 | |
| c <- n | |
| 〈.section Maybe〉 | |
| 〈# Outside of select, left-to-right rule applies.〉 | |
| 〈# (Inside select, assignment waits until case is chosen,〉 | |
| 〈# so right hand side happens before anything on left hand side.〉 | |
| *fp(&x, 1) = <-fc(c, 2) | |
| 〈.or〉〈.section Maybe〉 | |
| m[fn(13, 1)] = <-fc(c, 2) | |
| x = m[13] | |
| 〈.or〉 | |
| select { | |
| 〈# Blocking or non-blocking, before the receive.〉 | |
| 〈# The compiler implements two-case select where one is default with custom code,〉 | |
| 〈# so test the default branch both before and after the send.〉 | |
| 〈.section MaybeDefault〉 | |
| default: | |
| panic("nonblock") | |
| 〈.end〉 | |
| 〈# Receive from c. Different cases are direct, indirect, :=, interface, and map assignment.〉 | |
| 〈.section Maybe〉 | |
| case *fp(&x, 100) = <-fc(c, 1): | |
| 〈.or〉〈.section Maybe〉 | |
| case y := <-fc(c, 1): | |
| x = y | |
| 〈.or〉〈.section Maybe〉 | |
| case i = <-fc(c, 1): | |
| x = i.(int) | |
| 〈.or〉 | |
| case m[fn(13, 100)] = <-fc(c, 1): | |
| x = m[13] | |
| 〈.end〉〈.end〉〈.end〉 | |
| 〈# Blocking or non-blocking again, after the receive.〉 | |
| 〈.section MaybeDefault〉 | |
| default: | |
| panic("nonblock") | |
| 〈.end〉 | |
| 〈# Dummy send, receive to keep compiler from optimizing select.〉 | |
| 〈.section Maybe〉 | |
| case fc(dummy, 2) <- fn(1, 3): | |
| panic("dummy send") | |
| 〈.end〉 | |
| 〈.section Maybe〉 | |
| case <-fc(dummy, 4): | |
| panic("dummy receive") | |
| 〈.end〉 | |
| 〈# Nil channel send, receive to keep compiler from optimizing select.〉 | |
| 〈.section Maybe〉 | |
| case fc(nilch, 5) <- fn(1, 6): | |
| panic("nilch send") | |
| 〈.end〉 | |
| 〈.section Maybe〉 | |
| case <-fc(nilch, 7): | |
| panic("nilch recv") | |
| 〈.end〉 | |
| } | |
| 〈.end〉〈.end〉 | |
| if x != n { | |
| die(x) | |
| } | |
| n++ | |
| `) | |
| var send = parse(` | |
| 〈# Send n one way or another, receive it into x, check that they match.〉 | |
| 〈.section Maybe〉 | |
| c <- n | |
| 〈.or〉 | |
| select { | |
| 〈# Blocking or non-blocking, before the receive (same reason as in recv).〉 | |
| 〈.section MaybeDefault〉 | |
| default: | |
| panic("nonblock") | |
| 〈.end〉 | |
| 〈# Send c <- n. No real special cases here, because no values come back〉 | |
| 〈# from the send operation.〉 | |
| case c <- n: | |
| 〈# Blocking or non-blocking.〉 | |
| 〈.section MaybeDefault〉 | |
| default: | |
| panic("nonblock") | |
| 〈.end〉 | |
| 〈# Dummy send, receive to keep compiler from optimizing select.〉 | |
| 〈.section Maybe〉 | |
| case dummy <- 1: | |
| panic("dummy send") | |
| 〈.end〉 | |
| 〈.section Maybe〉 | |
| case <-dummy: | |
| panic("dummy receive") | |
| 〈.end〉 | |
| 〈# Nil channel send, receive to keep compiler from optimizing select.〉 | |
| 〈.section Maybe〉 | |
| case nilch <- 1: | |
| panic("nilch send") | |
| 〈.end〉 | |
| 〈.section Maybe〉 | |
| case <-nilch: | |
| panic("nilch recv") | |
| 〈.end〉 | |
| } | |
| 〈.end〉 | |
| x = <-c | |
| if x != n { | |
| die(x) | |
| } | |
| n++ | |
| `) | |
| var sendOrder = parse(` | |
| 〈# Send n one way or another, receive it into x, check that they match.〉 | |
| 〈# Check order of operations along the way by calling functions that check〉 | |
| 〈# that the argument sequence is strictly increasing.〉 | |
| order = 0 | |
| 〈.section Maybe〉 | |
| fc(c, 1) <- fn(n, 2) | |
| 〈.or〉 | |
| select { | |
| 〈# Blocking or non-blocking, before the receive (same reason as in recv).〉 | |
| 〈.section MaybeDefault〉 | |
| default: | |
| panic("nonblock") | |
| 〈.end〉 | |
| 〈# Send c <- n. No real special cases here, because no values come back〉 | |
| 〈# from the send operation.〉 | |
| case fc(c, 1) <- fn(n, 2): | |
| 〈# Blocking or non-blocking.〉 | |
| 〈.section MaybeDefault〉 | |
| default: | |
| panic("nonblock") | |
| 〈.end〉 | |
| 〈# Dummy send, receive to keep compiler from optimizing select.〉 | |
| 〈.section Maybe〉 | |
| case fc(dummy, 3) <- fn(1, 4): | |
| panic("dummy send") | |
| 〈.end〉 | |
| 〈.section Maybe〉 | |
| case <-fc(dummy, 5): | |
| panic("dummy receive") | |
| 〈.end〉 | |
| 〈# Nil channel send, receive to keep compiler from optimizing select.〉 | |
| 〈.section Maybe〉 | |
| case fc(nilch, 6) <- fn(1, 7): | |
| panic("nilch send") | |
| 〈.end〉 | |
| 〈.section Maybe〉 | |
| case <-fc(nilch, 8): | |
| panic("nilch recv") | |
| 〈.end〉 | |
| } | |
| 〈.end〉 | |
| x = <-c | |
| if x != n { | |
| die(x) | |
| } | |
| n++ | |
| `) | |
| var nonblock = parse(` | |
| x = n | |
| 〈# Test various combinations of non-blocking operations.〉 | |
| 〈# Receive assignments must not edit or even attempt to compute the address of the lhs.〉 | |
| select { | |
| 〈.section MaybeDefault〉 | |
| default: | |
| 〈.end〉 | |
| 〈.section Maybe〉 | |
| case dummy <- 1: | |
| panic("dummy <- 1") | |
| 〈.end〉 | |
| 〈.section Maybe〉 | |
| case nilch <- 1: | |
| panic("nilch <- 1") | |
| 〈.end〉 | |
| 〈.section Maybe〉 | |
| case <-dummy: | |
| panic("<-dummy") | |
| 〈.end〉 | |
| 〈.section Maybe〉 | |
| case x = <-dummy: | |
| panic("<-dummy x") | |
| 〈.end〉 | |
| 〈.section Maybe〉 | |
| case **(**int)(nil) = <-dummy: | |
| panic("<-dummy (and didn't crash saving result!)") | |
| 〈.end〉 | |
| 〈.section Maybe〉 | |
| case <-nilch: | |
| panic("<-nilch") | |
| 〈.end〉 | |
| 〈.section Maybe〉 | |
| case x = <-nilch: | |
| panic("<-nilch x") | |
| 〈.end〉 | |
| 〈.section Maybe〉 | |
| case **(**int)(nil) = <-nilch: | |
| panic("<-nilch (and didn't crash saving result!)") | |
| 〈.end〉 | |
| 〈.section MustDefault〉 | |
| default: | |
| 〈.end〉 | |
| } | |
| if x != n { | |
| die(x) | |
| } | |
| n++ | |
| `) | |
| // Code for enumerating all possible paths through | |
| // some logic. The logic should call choose(n) when | |
| // it wants to choose between n possibilities. | |
| // On successive runs through the logic, choose(n) | |
| // will return 0, 1, ..., n-1. The helper maybe() is | |
| // similar but returns true and then false. | |
| // | |
| // Given a function gen that generates an output | |
| // using choose and maybe, code can generate all | |
| // possible outputs using | |
| // | |
| // for next() { | |
| // gen() | |
| // } | |
| type choice struct { | |
| i, n int | |
| } | |
| var choices []choice | |
| var cp int = -1 | |
| func maybe() bool { | |
| return choose(2) == 0 | |
| } | |
| func choose(n int) int { | |
| if cp >= len(choices) { | |
| // never asked this before: start with 0. | |
| choices = append(choices, choice{0, n}) | |
| cp = len(choices) | |
| return 0 | |
| } | |
| // otherwise give recorded answer | |
| if n != choices[cp].n { | |
| panic("inconsistent choices") | |
| } | |
| i := choices[cp].i | |
| cp++ | |
| return i | |
| } | |
| func next() bool { | |
| if cp < 0 { | |
| // start a new round | |
| cp = 0 | |
| return true | |
| } | |
| // increment last choice sequence | |
| cp = len(choices)-1 | |
| for cp >= 0 && choices[cp].i == choices[cp].n-1 { | |
| cp-- | |
| } | |
| if cp < 0 { | |
| choices = choices[:0] | |
| return false | |
| } | |
| choices[cp].i++ | |
| choices = choices[:cp+1] | |
| cp = 0 | |
| return true | |
| } | |