URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [testsuite/] [go.test/] [test/] [chan/] [select3.go] - Blame information for rev 700

Details | Compare with Previous | View Log


// $G $D/$F.go && $L $F.$A && ./$A.out
 
// Copyright 2010 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.
 
// Tests verifying the semantics of the select statement
// for basic empty/non-empty cases.
 
package main
 
import "time"
 
const always = "function did not"
const never = "function did"
 
 
func unreachable() {
        panic("control flow shouldn't reach here")
}
 
 
// Calls f and verifies that f always/never panics depending on signal.
func testPanic(signal string, f func()) {
        defer func() {
                s := never
                if recover() != nil {
                        s = always // f panicked
                }
                if s != signal {
                        panic(signal + " panic")
                }
        }()
        f()
}
 
 
// Calls f and empirically verifies that f always/never blocks depending on signal.
func testBlock(signal string, f func()) {
        c := make(chan string)
        go func() {
                f()
                c <- never // f didn't block
        }()
        go func() {
                time.Sleep(1e8) // 0.1s seems plenty long
                c <- always     // f blocked always
        }()
        if <-c != signal {
                panic(signal + " block")
        }
}
 
 
func main() {
        const async = 1 // asynchronous channels
        var nilch chan int
        closedch := make(chan int)
        close(closedch)
 
        // sending/receiving from a nil channel blocks
        testBlock(always, func() {
                nilch <- 7
        })
        testBlock(always, func() {
                <-nilch
        })
 
        // sending/receiving from a nil channel inside a select is never selected
        testPanic(never, func() {
                select {
                case nilch <- 7:
                        unreachable()
                default:
                }
        })
        testPanic(never, func() {
                select {
                case <-nilch:
                        unreachable()
                default:
                }
        })
 
        // sending to an async channel with free buffer space never blocks
        testBlock(never, func() {
                ch := make(chan int, async)
                ch <- 7
        })
 
        // receiving from a closed channel never blocks
        testBlock(never, func() {
                for i := 0; i < 10; i++ {
                        if <-closedch != 0 {
                                panic("expected zero value when reading from closed channel")
                        }
                        if x, ok := <-closedch; x != 0 || ok {
                                println("closedch:", x, ok)
                                panic("expected 0, false from closed channel")
                        }
                }
        })
 
        // sending to a closed channel panics.
        testPanic(always, func() {
                closedch <- 7
        })
 
        // receiving from a non-ready channel always blocks
        testBlock(always, func() {
                ch := make(chan int)
                <-ch
        })
 
        // empty selects always block
        testBlock(always, func() {
                select {
                }
        })
 
        // selects with only nil channels always block
        testBlock(always, func() {
                select {
                case <-nilch:
                        unreachable()
                }
        })
        testBlock(always, func() {
                select {
                case nilch <- 7:
                        unreachable()
                }
        })
        testBlock(always, func() {
                select {
                case <-nilch:
                        unreachable()
                case nilch <- 7:
                        unreachable()
                }
        })
 
        // selects with non-ready non-nil channels always block
        testBlock(always, func() {
                ch := make(chan int)
                select {
                case <-ch:
                        unreachable()
                }
        })
 
        // selects with default cases don't block
        testBlock(never, func() {
                select {
                default:
                }
        })
        testBlock(never, func() {
                select {
                case <-nilch:
                        unreachable()
                default:
                }
        })
        testBlock(never, func() {
                select {
                case nilch <- 7:
                        unreachable()
                default:
                }
        })
 
        // selects with ready channels don't block
        testBlock(never, func() {
                ch := make(chan int, async)
                select {
                case ch <- 7:
                default:
                        unreachable()
                }
        })
        testBlock(never, func() {
                ch := make(chan int, async)
                ch <- 7
                select {
                case <-ch:
                default:
                        unreachable()
                }
        })
 
        // selects with closed channels behave like ordinary operations
        testBlock(never, func() {
                select {
                case <-closedch:
                }
        })
        testBlock(never, func() {
                select {
                case x := <-closedch:
                        _ = x
                }
        })
        testBlock(never, func() {
                select {
                case x, ok := <-closedch:
                        _, _ = x, ok
                }
        })
        testPanic(always, func() {
                select {
                case closedch <- 7:
                }
        })
 
        // select should not get confused if it sees itself
        testBlock(always, func() {
                c := make(chan int)
                select {
                case c <- 1:
                case <-c:
                }
        })
}

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [testsuite/] [go.test/] [test/] [chan/] [select3.go] - Blame information for rev 700

Line No.	Rev	Author	Line
1	700	jeremybenn	`// $G $D/$F.go && $L $F.$A && ./$A.out`
2
3			`// Copyright 2010 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			`// Tests verifying the semantics of the select statement`
8			`// for basic empty/non-empty cases.`
9
10			`package main`
11
12			`import "time"`
13
14			`const always = "function did not"`
15			`const never = "function did"`
16
17
18			`func unreachable() {`
19			`panic("control flow shouldn't reach here")`
20			`}`
21
22
23			`// Calls f and verifies that f always/never panics depending on signal.`
24			`func testPanic(signal string, f func()) {`
25			`defer func() {`
26			`s := never`
27			`if recover() != nil {`
28			`s = always // f panicked`
29			`}`
30			`if s != signal {`
31			`panic(signal + " panic")`
32			`}`
33			`}()`
34			`f()`
35			`}`
36
37
38			`// Calls f and empirically verifies that f always/never blocks depending on signal.`
39			`func testBlock(signal string, f func()) {`
40			`c := make(chan string)`
41			`go func() {`
42			`f()`
43			`c <- never // f didn't block`
44			`}()`
45			`go func() {`
46			`time.Sleep(1e8) // 0.1s seems plenty long`
47			`c <- always // f blocked always`
48			`}()`
49			`if <-c != signal {`
50			`panic(signal + " block")`
51			`}`
52			`}`
53
54
55			`func main() {`
56			`const async = 1 // asynchronous channels`
57			`var nilch chan int`
58			`closedch := make(chan int)`
59			`close(closedch)`
60
61			`// sending/receiving from a nil channel blocks`
62			`testBlock(always, func() {`
63			`nilch <- 7`
64			`})`
65			`testBlock(always, func() {`
66			`<-nilch`
67			`})`
68
69			`// sending/receiving from a nil channel inside a select is never selected`
70			`testPanic(never, func() {`
71			`select {`
72			`case nilch <- 7:`
73			`unreachable()`
74			`default:`
75			`}`
76			`})`
77			`testPanic(never, func() {`
78			`select {`
79			`case <-nilch:`
80			`unreachable()`
81			`default:`
82			`}`
83			`})`
84
85			`// sending to an async channel with free buffer space never blocks`
86			`testBlock(never, func() {`
87			`ch := make(chan int, async)`
88			`ch <- 7`
89			`})`
90
91			`// receiving from a closed channel never blocks`
92			`testBlock(never, func() {`
93			`for i := 0; i < 10; i++ {`
94			`if <-closedch != 0 {`
95			`panic("expected zero value when reading from closed channel")`
96			`}`
97			`if x, ok := <-closedch; x != 0 \|\| ok {`
98			`println("closedch:", x, ok)`
99			`panic("expected 0, false from closed channel")`
100			`}`
101			`}`
102			`})`
103
104			`// sending to a closed channel panics.`
105			`testPanic(always, func() {`
106			`closedch <- 7`
107			`})`
108
109			`// receiving from a non-ready channel always blocks`
110			`testBlock(always, func() {`
111			`ch := make(chan int)`
112			`<-ch`
113			`})`
114
115			`// empty selects always block`
116			`testBlock(always, func() {`
117			`select {`
118			`}`
119			`})`
120
121			`// selects with only nil channels always block`
122			`testBlock(always, func() {`
123			`select {`
124			`case <-nilch:`
125			`unreachable()`
126			`}`
127			`})`
128			`testBlock(always, func() {`
129			`select {`
130			`case nilch <- 7:`
131			`unreachable()`
132			`}`
133			`})`
134			`testBlock(always, func() {`
135			`select {`
136			`case <-nilch:`
137			`unreachable()`
138			`case nilch <- 7:`
139			`unreachable()`
140			`}`
141			`})`
142
143			`// selects with non-ready non-nil channels always block`
144			`testBlock(always, func() {`
145			`ch := make(chan int)`
146			`select {`
147			`case <-ch:`
148			`unreachable()`
149			`}`
150			`})`
151
152			`// selects with default cases don't block`
153			`testBlock(never, func() {`
154			`select {`
155			`default:`
156			`}`
157			`})`
158			`testBlock(never, func() {`
159			`select {`
160			`case <-nilch:`
161			`unreachable()`
162			`default:`
163			`}`
164			`})`
165			`testBlock(never, func() {`
166			`select {`
167			`case nilch <- 7:`
168			`unreachable()`
169			`default:`
170			`}`
171			`})`
172
173			`// selects with ready channels don't block`
174			`testBlock(never, func() {`
175			`ch := make(chan int, async)`
176			`select {`
177			`case ch <- 7:`
178			`default:`
179			`unreachable()`
180			`}`
181			`})`
182			`testBlock(never, func() {`
183			`ch := make(chan int, async)`
184			`ch <- 7`
185			`select {`
186			`case <-ch:`
187			`default:`
188			`unreachable()`
189			`}`
190			`})`
191
192			`// selects with closed channels behave like ordinary operations`
193			`testBlock(never, func() {`
194			`select {`
195			`case <-closedch:`
196			`}`
197			`})`
198			`testBlock(never, func() {`
199			`select {`
200			`case x := <-closedch:`
201			`_ = x`
202			`}`
203			`})`
204			`testBlock(never, func() {`
205			`select {`
206			`case x, ok := <-closedch:`
207			`_, _ = x, ok`
208			`}`
209			`})`
210			`testPanic(always, func() {`
211			`select {`
212			`case closedch <- 7:`
213			`}`
214			`})`
215
216			`// select should not get confused if it sees itself`
217			`testBlock(always, func() {`
218			`c := make(chan int)`
219			`select {`
220			`case c <- 1:`
221			`case <-c:`
222			`}`
223			`})`
224			`}`