blob: 043a92d3880e83fb8aef11cc358bf1e49d02a7ab [file] [log] [blame] [edit]
// 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)
}
}