...
Run Format

Source file test/closedchan.go

Documentation: test

     1  // run
     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  }
   360  

View as plain text