gcc/testsuite/go.test/test/chan/nonblock.go

   1 // $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 // Verify channel operations that test for blocking
   8 // Use several sizes and types of operands
   9
  10 package main
  11
  12 import "runtime"
  13 import "time"
  14
  15 func i32receiver(c chan int32, strobe chan bool) {
  16         if <-c != 123 {
  17                 panic("i32 value")
  18         }
  19         strobe <- true
  20 }
  21
  22 func i32sender(c chan int32, strobe chan bool) {
  23         c <- 234
  24         strobe <- true
  25 }
  26
  27 func i64receiver(c chan int64, strobe chan bool) {
  28         if <-c != 123456 {
  29                 panic("i64 value")
  30         }
  31         strobe <- true
  32 }
  33
  34 func i64sender(c chan int64, strobe chan bool) {
  35         c <- 234567
  36         strobe <- true
  37 }
  38
  39 func breceiver(c chan bool, strobe chan bool) {
  40         if !<-c {
  41                 panic("b value")
  42         }
  43         strobe <- true
  44 }
  45
  46 func bsender(c chan bool, strobe chan bool) {
  47         c <- true
  48         strobe <- true
  49 }
  50
  51 func sreceiver(c chan string, strobe chan bool) {
  52         if <-c != "hello" {
  53                 panic("s value")
  54         }
  55         strobe <- true
  56 }
  57
  58 func ssender(c chan string, strobe chan bool) {
  59         c <- "hello again"
  60         strobe <- true
  61 }
  62
  63 var ticker = time.Tick(10 * 1000) // 10 us
  64 func sleep() {
  65         <-ticker
  66         <-ticker
  67         runtime.Gosched()
  68         runtime.Gosched()
  69         runtime.Gosched()
  70 }
  71
  72 const maxTries = 10000 // Up to 100ms per test.
  73
  74 func main() {
  75         var i32 int32
  76         var i64 int64
  77         var b bool
  78         var s string
  79         var ok bool
  80
  81         var sync = make(chan bool)
  82
  83         for buffer := 0; buffer < 2; buffer++ {
  84                 c32 := make(chan int32, buffer)
  85                 c64 := make(chan int64, buffer)
  86                 cb := make(chan bool, buffer)
  87                 cs := make(chan string, buffer)
  88
  89                 i32, ok = <-c32
  90                 if ok {
  91                         panic("blocked i32sender")
  92                 }
  93
  94                 i64, ok = <-c64
  95                 if ok {
  96                         panic("blocked i64sender")
  97                 }
  98
  99                 b, ok = <-cb
 100                 if ok {
 101                         panic("blocked bsender")
 102                 }
 103
 104                 s, ok = <-cs
 105                 if ok {
 106                         panic("blocked ssender")
 107                 }
 108
 109                 go i32receiver(c32, sync)
 110                 try := 0
 111                 for !(c32 <- 123) {
 112                         try++
 113                         if try > maxTries {
 114                                 println("i32receiver buffer=", buffer)
 115                                 panic("fail")
 116                         }
 117                         sleep()
 118                 }
 119                 <-sync
 120
 121                 go i32sender(c32, sync)
 122                 if buffer > 0 {
 123                         <-sync
 124                 }
 125                 try = 0
 126                 for i32, ok = <-c32; !ok; i32, ok = <-c32 {
 127                         try++
 128                         if try > maxTries {
 129                                 println("i32sender buffer=", buffer)
 130                                 panic("fail")
 131                         }
 132                         sleep()
 133                 }
 134                 if i32 != 234 {
 135                         panic("i32sender value")
 136                 }
 137                 if buffer == 0 {
 138                         <-sync
 139                 }
 140
 141                 go i64receiver(c64, sync)
 142                 try = 0
 143                 for !(c64 <- 123456) {
 144                         try++
 145                         if try > maxTries {
 146                                 panic("i64receiver")
 147                         }
 148                         sleep()
 149                 }
 150                 <-sync
 151
 152                 go i64sender(c64, sync)
 153                 if buffer > 0 {
 154                         <-sync
 155                 }
 156                 try = 0
 157                 for i64, ok = <-c64; !ok; i64, ok = <-c64 {
 158                         try++
 159                         if try > maxTries {
 160                                 panic("i64sender")
 161                         }
 162                         sleep()
 163                 }
 164                 if i64 != 234567 {
 165                         panic("i64sender value")
 166                 }
 167                 if buffer == 0 {
 168                         <-sync
 169                 }
 170
 171                 go breceiver(cb, sync)
 172                 try = 0
 173                 for !(cb <- true) {
 174                         try++
 175                         if try > maxTries {
 176                                 panic("breceiver")
 177                         }
 178                         sleep()
 179                 }
 180                 <-sync
 181
 182                 go bsender(cb, sync)
 183                 if buffer > 0 {
 184                         <-sync
 185                 }
 186                 try = 0
 187                 for b, ok = <-cb; !ok; b, ok = <-cb {
 188                         try++
 189                         if try > maxTries {
 190                                 panic("bsender")
 191                         }
 192                         sleep()
 193                 }
 194                 if !b {
 195                         panic("bsender value")
 196                 }
 197                 if buffer == 0 {
 198                         <-sync
 199                 }
 200
 201                 go sreceiver(cs, sync)
 202                 try = 0
 203                 for !(cs <- "hello") {
 204                         try++
 205                         if try > maxTries {
 206                                 panic("sreceiver")
 207                         }
 208                         sleep()
 209                 }
 210                 <-sync
 211
 212                 go ssender(cs, sync)
 213                 if buffer > 0 {
 214                         <-sync
 215                 }
 216                 try = 0
 217                 for s, ok = <-cs; !ok; s, ok = <-cs {
 218                         try++
 219                         if try > maxTries {
 220                                 panic("ssender")
 221                         }
 222                         sleep()
 223                 }
 224                 if s != "hello again" {
 225                         panic("ssender value")
 226                 }
 227                 if buffer == 0 {
 228                         <-sync
 229                 }
 230         }
 231         print("PASS\n")
 232 }