go/test/chan/nonblock.go

// $G $D/$F.go && $L $F.$A && ./$A.out

// 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.

// Verify 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 ok bool

	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)

		i32, ok = <-c32
		if ok {
			panic("blocked i32sender")
		}

		i64, ok = <-c64
		if ok {
			panic("blocked i64sender")
		}

		b, ok = <-cb
		if ok {
			panic("blocked bsender")
		}

		s, ok = <-cs
		if ok {
			panic("blocked ssender")
		}

		go i32receiver(c32, sync)
		try := 0
		for !(c32 <- 123) {
			try++
			if try > maxTries {
				println("i32receiver buffer=", buffer)
				panic("fail")
			}
			sleep()
		}
		<-sync

		go i32sender(c32, sync)
		if buffer > 0 {
			<-sync
		}
		try = 0
		for i32, ok = <-c32; !ok; i32, ok = <-c32 {
			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
		for !(c64 <- 123456) {
			try++
			if try > maxTries {
				panic("i64receiver")
			}
			sleep()
		}
		<-sync

		go i64sender(c64, sync)
		if buffer > 0 {
			<-sync
		}
		try = 0
		for i64, ok = <-c64; !ok; i64, ok = <-c64 {
			try++
			if try > maxTries {
				panic("i64sender")
			}
			sleep()
		}
		if i64 != 234567 {
			panic("i64sender value")
		}
		if buffer == 0 {
			<-sync
		}

		go breceiver(cb, sync)
		try = 0
		for !(cb <- true) {
			try++
			if try > maxTries {
				panic("breceiver")
			}
			sleep()
		}
		<-sync

		go bsender(cb, sync)
		if buffer > 0 {
			<-sync
		}
		try = 0
		for b, ok = <-cb; !ok; b, ok = <-cb {
			try++
			if try > maxTries {
				panic("bsender")
			}
			sleep()
		}
		if !b {
			panic("bsender value")
		}
		if buffer == 0 {
			<-sync
		}

		go sreceiver(cs, sync)
		try = 0
		for !(cs <- "hello") {
			try++
			if try > maxTries {
				panic("sreceiver")
			}
			sleep()
		}
		<-sync

		go ssender(cs, sync)
		if buffer > 0 {
			<-sync
		}
		try = 0
		for s, ok = <-cs; !ok; s, ok = <-cs {
			try++
			if try > maxTries {
				panic("ssender")
			}
			sleep()
		}
		if s != "hello again" {
			panic("ssender value")
		}
		if buffer == 0 {
			<-sync
		}
	}
	print("PASS\n")
}