Preview: nonblock.go
Size: 3.93 KB
/proc/thread-self/root/opt/golang/1.22.0/test/chan/nonblock.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 channel operations that test for blocking.
// Use several sizes and types of operands.
package main
import "runtime"
import "time"
func i32receiver(c chan int32, strobe chan bool) {
if <-c != 123 {
panic("i32 value")
}
strobe <- true
}
func i32sender(c chan int32, strobe chan bool) {
c <- 234
strobe <- true
}
func i64receiver(c chan int64, strobe chan bool) {
if <-c != 123456 {
panic("i64 value")
}
strobe <- true
}
func i64sender(c chan int64, strobe chan bool) {
c <- 234567
strobe <- true
}
func breceiver(c chan bool, strobe chan bool) {
if !<-c {
panic("b value")
}
strobe <- true
}
func bsender(c chan bool, strobe chan bool) {
c <- true
strobe <- true
}
func sreceiver(c chan string, strobe chan bool) {
if <-c != "hello" {
panic("s value")
}
strobe <- true
}
func ssender(c chan string, strobe chan bool) {
c <- "hello again"
strobe <- true
}
var ticker = time.Tick(10 * 1000) // 10 us
func sleep() {
<-ticker
<-ticker
runtime.Gosched()
runtime.Gosched()
runtime.Gosched()
}
const maxTries = 10000 // Up to 100ms per test.
func main() {
var i32 int32
var i64 int64
var b bool
var s string
var sync = make(chan bool)
for buffer := 0; buffer < 2; buffer++ {
c32 := make(chan int32, buffer)
c64 := make(chan int64, buffer)
cb := make(chan bool, buffer)
cs := make(chan string, buffer)
select {
case i32 = <-c32:
panic("blocked i32sender")
default:
}
select {
case i64 = <-c64:
panic("blocked i64sender")
default:
}
select {
case b = <-cb:
panic("blocked bsender")
default:
}
select {
case s = <-cs:
panic("blocked ssender")
default:
}
go i32receiver(c32, sync)
try := 0
Send32:
for {
select {
case c32 <- 123:
break Send32
default:
try++
if try > maxTries {
println("i32receiver buffer=", buffer)
panic("fail")
}
sleep()
}
}
<-sync
go i32sender(c32, sync)
if buffer > 0 {
<-sync
}
try = 0
Recv32:
for {
select {
case i32 = <-c32:
break Recv32
default:
try++
if try > maxTries {
println("i32sender buffer=", buffer)
panic("fail")
}
sleep()
}
}
if i32 != 234 {
panic("i32sender value")
}
if buffer == 0 {
<-sync
}
go i64receiver(c64, sync)
try = 0
Send64:
for {
select {
case c64 <- 123456:
break Send64
default:
try++
if try > maxTries {
panic("i64receiver")
}
sleep()
}
}
<-sync
go i64sender(c64, sync)
if buffer > 0 {
<-sync
}
try = 0
Recv64:
for {
select {
case i64 = <-c64:
break Recv64
default:
try++
if try > maxTries {
panic("i64sender")
}
sleep()
}
}
if i64 != 234567 {
panic("i64sender value")
}
if buffer == 0 {
<-sync
}
go breceiver(cb, sync)
try = 0
SendBool:
for {
select {
case cb <- true:
break SendBool
default:
try++
if try > maxTries {
panic("breceiver")
}
sleep()
}
}
<-sync
go bsender(cb, sync)
if buffer > 0 {
<-sync
}
try = 0
RecvBool:
for {
select {
case b = <-cb:
break RecvBool
default:
try++
if try > maxTries {
panic("bsender")
}
sleep()
}
}
if !b {
panic("bsender value")
}
if buffer == 0 {
<-sync
}
go sreceiver(cs, sync)
try = 0
SendString:
for {
select {
case cs <- "hello":
break SendString
default:
try++
if try > maxTries {
panic("sreceiver")
}
sleep()
}
}
<-sync
go ssender(cs, sync)
if buffer > 0 {
<-sync
}
try = 0
RecvString:
for {
select {
case s = <-cs:
break RecvString
default:
try++
if try > maxTries {
panic("ssender")
}
sleep()
}
}
if s != "hello again" {
panic("ssender value")
}
if buffer == 0 {
<-sync
}
}
}
Directory Contents
Dirs: 0 × Files: 19