mirror of
https://github.com/golang/go
synced 2024-09-05 16:04:50 +00:00
![Russ Cox](/assets/img/avatar_default.png)
X ,s;^// \$G (\$D/)?\$F\.go *$;// compile;g X ,s;^// \$G (\$D/)?\$F\.go && \$L \$F\.\$A *$;// build;g X ,s;^// \$G (\$D/)?\$F\.go && \$L \$F\.\$A && \./\$A\.out *$;// run;g X ,s;^// errchk \$G( -e)? (\$D/)?\$F\.go *$;// errorcheck;g R=golang-dev, bradfitz CC=golang-dev https://golang.org/cl/5656082
360 lines
5.8 KiB
Go
360 lines
5.8 KiB
Go
// 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 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)
|
|
}
|
|
}
|