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

Subversion Repositories openrisc

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

Details | Compare with Previous | View Log


// $G $D/$F.go && $L $F.$A && ./$A.out
 
// 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 close(c), receive of closed channel.
//
// TODO(rsc): Doesn't check behavior of close(c) when there
// are blocked senders/receivers.
 
package main
 
import "os"
 
var failed bool
 
type Chan interface {
        Send(int)
        Nbsend(int) bool
        Recv() (int)
        Nbrecv() (int, bool)
        Recv2() (int, bool)
        Nbrecv2() (int, bool, bool)
        Close()
        Impl() string
}
 
// direct channel operations when possible
type XChan chan int
 
func (c XChan) Send(x int) {
        c <- x
}
 
func (c XChan) Nbsend(x int) bool {
        select {
        case c <- x:
                return true
        default:
                return false
        }
        panic("nbsend")
}
 
func (c XChan) Recv() int {
        return <-c
}
 
func (c XChan) Nbrecv() (int, bool) {
        select {
        case x := <-c:
                return x, true
        default:
                return 0, false
        }
        panic("nbrecv")
}
 
func (c XChan) Recv2() (int, bool) {
        x, ok := <-c
        return x, ok
}
 
func (c XChan) Nbrecv2() (int, bool, bool) {
        select {
        case x, ok := <-c:
                return x, ok, true
        default:
                return 0, false, false
        }
        panic("nbrecv2")
}
 
func (c XChan) Close() {
        close(c)
}
 
func (c XChan) Impl() string {
        return "(<- operator)"
}
 
// indirect operations via select
type SChan chan int
 
func (c SChan) Send(x int) {
        select {
        case c <- x:
        }
}
 
func (c SChan) Nbsend(x int) bool {
        select {
        default:
                return false
        case c <- x:
                return true
        }
        panic("nbsend")
}
 
func (c SChan) Recv() int {
        select {
        case x := <-c:
                return x
        }
        panic("recv")
}
 
func (c SChan) Nbrecv() (int, bool) {
        select {
        default:
                return 0, false
        case x := <-c:
                return x, true
        }
        panic("nbrecv")
}
 
func (c SChan) Recv2() (int, bool) {
        select {
        case x, ok := <-c:
                return x, ok
        }
        panic("recv")
}
 
func (c SChan) Nbrecv2() (int, bool, bool) {
        select {
        default:
                return 0, false, false
        case x, ok := <-c:
                return x, ok, true
        }
        panic("nbrecv")
}
 
func (c SChan) Close() {
        close(c)
}
 
func (c SChan) Impl() string {
        return "(select)"
}
 
// indirect operations via larger selects
var dummy = make(chan bool)
 
type SSChan chan int
 
func (c SSChan) Send(x int) {
        select {
        case c <- x:
        case <-dummy:
        }
}
 
func (c SSChan) Nbsend(x int) bool {
        select {
        default:
                return false
        case <-dummy:
        case c <- x:
                return true
        }
        panic("nbsend")
}
 
func (c SSChan) Recv() int {
        select {
        case <-dummy:
        case x := <-c:
                return x
        }
        panic("recv")
}
 
func (c SSChan) Nbrecv() (int, bool) {
        select {
        case <-dummy:
        default:
                return 0, false
        case x := <-c:
                return x, true
        }
        panic("nbrecv")
}
 
func (c SSChan) Recv2() (int, bool) {
        select {
        case <-dummy:
        case x, ok := <-c:
                return x, ok
        }
        panic("recv")
}
 
func (c SSChan) Nbrecv2() (int, bool, bool) {
        select {
        case <-dummy:
        default:
                return 0, false, false
        case x, ok := <-c:
                return x, ok, true
        }
        panic("nbrecv")
}
 
func (c SSChan) Close() {
        close(c)
}
 
func (c SSChan) Impl() string {
        return "(select)"
}
 
 
func shouldPanic(f func()) {
        defer func() {
                if recover() == nil {
                        panic("did not panic")
                }
        }()
        f()
}
 
func test1(c Chan) {
        for i := 0; i < 3; i++ {
                // recv a close signal (a zero value)
                if x := c.Recv(); x != 0 {
                        println("test1: recv on closed:", x, c.Impl())
                        failed = true
                }
                if x, ok := c.Recv2(); x != 0 || ok {
                        println("test1: recv2 on closed:", x, ok, c.Impl())
                        failed = true
                }
 
                // should work with select: received a value without blocking, so selected == true.
                x, selected := c.Nbrecv()
                if x != 0 || !selected {
                        println("test1: recv on closed nb:", x, selected, c.Impl())
                        failed = true
                }
                x, ok, selected := c.Nbrecv2()
                if x != 0 || ok || !selected {
                        println("test1: recv2 on closed nb:", x, ok, selected, c.Impl())
                        failed = true
                }
        }
 
        // send should work with ,ok too: sent a value without blocking, so ok == true.
        shouldPanic(func() { c.Nbsend(1) })
 
        // the value should have been discarded.
        if x := c.Recv(); x != 0 {
                println("test1: recv on closed got non-zero after send on closed:", x, c.Impl())
                failed = true
        }
 
        // similarly Send.
        shouldPanic(func() { c.Send(2) })
        if x := c.Recv(); x != 0 {
                println("test1: recv on closed got non-zero after send on closed:", x, c.Impl())
                failed = true
        }
}
 
func testasync1(c Chan) {
        // should be able to get the last value via Recv
        if x := c.Recv(); x != 1 {
                println("testasync1: Recv did not get 1:", x, c.Impl())
                failed = true
        }
 
        test1(c)
}
 
func testasync2(c Chan) {
        // should be able to get the last value via Recv2
        if x, ok := c.Recv2(); x != 1 || !ok {
                println("testasync1: Recv did not get 1, true:", x, ok, c.Impl())
                failed = true
        }
 
        test1(c)
}
 
func testasync3(c Chan) {
        // should be able to get the last value via Nbrecv
        if x, selected := c.Nbrecv(); x != 1 || !selected {
                println("testasync2: Nbrecv did not get 1, true:", x, selected, c.Impl())
                failed = true
        }
 
        test1(c)
}
 
func testasync4(c Chan) {
        // should be able to get the last value via Nbrecv2
        if x, ok, selected := c.Nbrecv2(); x != 1 || !ok || !selected {
                println("testasync2: Nbrecv did not get 1, true, true:", x, ok, selected, c.Impl())
                failed = true
        }
        test1(c)
}
 
func closedsync() chan int {
        c := make(chan int)
        close(c)
        return c
}
 
func closedasync() chan int {
        c := make(chan int, 2)
        c <- 1
        close(c)
        return c
}
 
var mks = []func(chan int) Chan {
        func(c chan int) Chan { return XChan(c) },
        func(c chan int) Chan { return SChan(c) },
        func(c chan int) Chan { return SSChan(c) },
}
 
var testcloseds = []func(Chan) {
        testasync1,
        testasync2,
        testasync3,
        testasync4,
}
 
func main() {
        for _, mk := range mks {
                test1(mk(closedsync()))
        }
 
        for _, testclosed := range testcloseds {
                for _, mk := range mks {
                        testclosed(mk(closedasync()))
                }
        }
 
        var ch chan int
        shouldPanic(func() {
                close(ch)
        })
 
        ch = make(chan int)
        close(ch)
        shouldPanic(func() {
                close(ch)
        })
 
        if failed {
                os.Exit(1)
        }
}

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [testsuite/] [go.test/] [test/] [closedchan.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 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 close(c), receive of closed channel.`
8			`//`
9			`// TODO(rsc): Doesn't check behavior of close(c) when there`
10			`// are blocked senders/receivers.`
11
12			`package main`
13
14			`import "os"`
15
16			`var failed bool`
17
18			`type Chan interface {`
19			`Send(int)`
20			`Nbsend(int) bool`
21			`Recv() (int)`
22			`Nbrecv() (int, bool)`
23			`Recv2() (int, bool)`
24			`Nbrecv2() (int, bool, bool)`
25			`Close()`
26			`Impl() string`
27			`}`
28
29			`// direct channel operations when possible`
30			`type XChan chan int`
31
32			`func (c XChan) Send(x int) {`
33			`c <- x`
34			`}`
35
36			`func (c XChan) Nbsend(x int) bool {`
37			`select {`
38			`case c <- x:`
39			`return true`
40			`default:`
41			`return false`
42			`}`
43			`panic("nbsend")`
44			`}`
45
46			`func (c XChan) Recv() int {`
47			`return <-c`
48			`}`
49
50			`func (c XChan) Nbrecv() (int, bool) {`
51			`select {`
52			`case x := <-c:`
53			`return x, true`
54			`default:`
55			`return 0, false`
56			`}`
57			`panic("nbrecv")`
58			`}`
59
60			`func (c XChan) Recv2() (int, bool) {`
61			`x, ok := <-c`
62			`return x, ok`
63			`}`
64
65			`func (c XChan) Nbrecv2() (int, bool, bool) {`
66			`select {`
67			`case x, ok := <-c:`
68			`return x, ok, true`
69			`default:`
70			`return 0, false, false`
71			`}`
72			`panic("nbrecv2")`
73			`}`
74
75			`func (c XChan) Close() {`
76			`close(c)`
77			`}`
78
79			`func (c XChan) Impl() string {`
80			`return "(<- operator)"`
81			`}`
82
83			`// indirect operations via select`
84			`type SChan chan int`
85
86			`func (c SChan) Send(x int) {`
87			`select {`
88			`case c <- x:`
89			`}`
90			`}`
91
92			`func (c SChan) Nbsend(x int) bool {`
93			`select {`
94			`default:`
95			`return false`
96			`case c <- x:`
97			`return true`
98			`}`
99			`panic("nbsend")`
100			`}`
101
102			`func (c SChan) Recv() int {`
103			`select {`
104			`case x := <-c:`
105			`return x`
106			`}`
107			`panic("recv")`
108			`}`
109
110			`func (c SChan) Nbrecv() (int, bool) {`
111			`select {`
112			`default:`
113			`return 0, false`
114			`case x := <-c:`
115			`return x, true`
116			`}`
117			`panic("nbrecv")`
118			`}`
119
120			`func (c SChan) Recv2() (int, bool) {`
121			`select {`
122			`case x, ok := <-c:`
123			`return x, ok`
124			`}`
125			`panic("recv")`
126			`}`
127
128			`func (c SChan) Nbrecv2() (int, bool, bool) {`
129			`select {`
130			`default:`
131			`return 0, false, false`
132			`case x, ok := <-c:`
133			`return x, ok, true`
134			`}`
135			`panic("nbrecv")`
136			`}`
137
138			`func (c SChan) Close() {`
139			`close(c)`
140			`}`
141
142			`func (c SChan) Impl() string {`
143			`return "(select)"`
144			`}`
145
146			`// indirect operations via larger selects`
147			`var dummy = make(chan bool)`
148
149			`type SSChan chan int`
150
151			`func (c SSChan) Send(x int) {`
152			`select {`
153			`case c <- x:`
154			`case <-dummy:`
155			`}`
156			`}`
157
158			`func (c SSChan) Nbsend(x int) bool {`
159			`select {`
160			`default:`
161			`return false`
162			`case <-dummy:`
163			`case c <- x:`
164			`return true`
165			`}`
166			`panic("nbsend")`
167			`}`
168
169			`func (c SSChan) Recv() int {`
170			`select {`
171			`case <-dummy:`
172			`case x := <-c:`
173			`return x`
174			`}`
175			`panic("recv")`
176			`}`
177
178			`func (c SSChan) Nbrecv() (int, bool) {`
179			`select {`
180			`case <-dummy:`
181			`default:`
182			`return 0, false`
183			`case x := <-c:`
184			`return x, true`
185			`}`
186			`panic("nbrecv")`
187			`}`
188
189			`func (c SSChan) Recv2() (int, bool) {`
190			`select {`
191			`case <-dummy:`
192			`case x, ok := <-c:`
193			`return x, ok`
194			`}`
195			`panic("recv")`
196			`}`
197
198			`func (c SSChan) Nbrecv2() (int, bool, bool) {`
199			`select {`
200			`case <-dummy:`
201			`default:`
202			`return 0, false, false`
203			`case x, ok := <-c:`
204			`return x, ok, true`
205			`}`
206			`panic("nbrecv")`
207			`}`
208
209			`func (c SSChan) Close() {`
210			`close(c)`
211			`}`
212
213			`func (c SSChan) Impl() string {`
214			`return "(select)"`
215			`}`
216
217
218			`func shouldPanic(f func()) {`
219			`defer func() {`
220			`if recover() == nil {`
221			`panic("did not panic")`
222			`}`
223			`}()`
224			`f()`
225			`}`
226
227			`func test1(c Chan) {`
228			`for i := 0; i < 3; i++ {`
229			`// recv a close signal (a zero value)`
230			`if x := c.Recv(); x != 0 {`
231			`println("test1: recv on closed:", x, c.Impl())`
232			`failed = true`
233			`}`
234			`if x, ok := c.Recv2(); x != 0 \|\| ok {`
235			`println("test1: recv2 on closed:", x, ok, c.Impl())`
236			`failed = true`
237			`}`
238
239			`// should work with select: received a value without blocking, so selected == true.`
240			`x, selected := c.Nbrecv()`
241			`if x != 0 \|\| !selected {`
242			`println("test1: recv on closed nb:", x, selected, c.Impl())`
243			`failed = true`
244			`}`
245			`x, ok, selected := c.Nbrecv2()`
246			`if x != 0 \|\| ok \|\| !selected {`
247			`println("test1: recv2 on closed nb:", x, ok, selected, c.Impl())`
248			`failed = true`
249			`}`
250			`}`
251
252			`// send should work with ,ok too: sent a value without blocking, so ok == true.`
253			`shouldPanic(func() { c.Nbsend(1) })`
254
255			`// the value should have been discarded.`
256			`if x := c.Recv(); x != 0 {`
257			`println("test1: recv on closed got non-zero after send on closed:", x, c.Impl())`
258			`failed = true`
259			`}`
260
261			`// similarly Send.`
262			`shouldPanic(func() { c.Send(2) })`
263			`if x := c.Recv(); x != 0 {`
264			`println("test1: recv on closed got non-zero after send on closed:", x, c.Impl())`
265			`failed = true`
266			`}`
267			`}`
268
269			`func testasync1(c Chan) {`
270			`// should be able to get the last value via Recv`
271			`if x := c.Recv(); x != 1 {`
272			`println("testasync1: Recv did not get 1:", x, c.Impl())`
273			`failed = true`
274			`}`
275
276			`test1(c)`
277			`}`
278
279			`func testasync2(c Chan) {`
280			`// should be able to get the last value via Recv2`
281			`if x, ok := c.Recv2(); x != 1 \|\| !ok {`
282			`println("testasync1: Recv did not get 1, true:", x, ok, c.Impl())`
283			`failed = true`
284			`}`
285
286			`test1(c)`
287			`}`
288
289			`func testasync3(c Chan) {`
290			`// should be able to get the last value via Nbrecv`
291			`if x, selected := c.Nbrecv(); x != 1 \|\| !selected {`
292			`println("testasync2: Nbrecv did not get 1, true:", x, selected, c.Impl())`
293			`failed = true`
294			`}`
295
296			`test1(c)`
297			`}`
298
299			`func testasync4(c Chan) {`
300			`// should be able to get the last value via Nbrecv2`
301			`if x, ok, selected := c.Nbrecv2(); x != 1 \|\| !ok \|\| !selected {`
302			`println("testasync2: Nbrecv did not get 1, true, true:", x, ok, selected, c.Impl())`
303			`failed = true`
304			`}`
305			`test1(c)`
306			`}`
307
308			`func closedsync() chan int {`
309			`c := make(chan int)`
310			`close(c)`
311			`return c`
312			`}`
313
314			`func closedasync() chan int {`
315			`c := make(chan int, 2)`
316			`c <- 1`
317			`close(c)`
318			`return c`
319			`}`
320
321			`var mks = []func(chan int) Chan {`
322			`func(c chan int) Chan { return XChan(c) },`
323			`func(c chan int) Chan { return SChan(c) },`
324			`func(c chan int) Chan { return SSChan(c) },`
325			`}`
326
327			`var testcloseds = []func(Chan) {`
328			`testasync1,`
329			`testasync2,`
330			`testasync3,`
331			`testasync4,`
332			`}`
333
334			`func main() {`
335			`for _, mk := range mks {`
336			`test1(mk(closedsync()))`
337			`}`
338
339			`for _, testclosed := range testcloseds {`
340			`for _, mk := range mks {`
341			`testclosed(mk(closedasync()))`
342			`}`
343			`}`
344
345			`var ch chan int`
346			`shouldPanic(func() {`
347			`close(ch)`
348			`})`
349
350			`ch = make(chan int)`
351			`close(ch)`
352			`shouldPanic(func() {`
353			`close(ch)`
354			`})`
355
356			`if failed {`
357			`os.Exit(1)`
358			`}`
359			`}`