mirror of
https://github.com/golang/go
synced 2024-11-23 00:30:07 -07:00
145 lines
2.9 KiB
Go
145 lines
2.9 KiB
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();
|
|
}
|
|
|
|
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);
|
|
sleep();
|
|
ok = c32 <- 123;
|
|
if !ok { panic("i32receiver buffer=", buffer) }
|
|
<-sync;
|
|
|
|
go i32sender(c32, sync);
|
|
if buffer > 0 { <-sync } else { sleep() }
|
|
i32, ok = <-c32;
|
|
if !ok { panic("i32sender buffer=", buffer) }
|
|
if i32 != 234 { panic("i32sender value") }
|
|
if buffer == 0 { <-sync }
|
|
|
|
go i64receiver(c64, sync);
|
|
sleep();
|
|
ok = c64 <- 123456;
|
|
if !ok { panic("i64receiver") }
|
|
<-sync;
|
|
|
|
go i64sender(c64, sync);
|
|
if buffer > 0 { <-sync } else { sleep() }
|
|
i64, ok = <-c64;
|
|
if !ok { panic("i64sender") }
|
|
if i64 != 234567 { panic("i64sender value") }
|
|
if buffer == 0 { <-sync }
|
|
|
|
go breceiver(cb, sync);
|
|
sleep();
|
|
ok = cb <- true;
|
|
if !ok { panic("breceiver") }
|
|
<-sync;
|
|
|
|
go bsender(cb, sync);
|
|
if buffer > 0 { <-sync } else { sleep() }
|
|
b, ok = <-cb;
|
|
if !ok { panic("bsender") }
|
|
if !b{ panic("bsender value") }
|
|
if buffer == 0 { <-sync }
|
|
|
|
go sreceiver(cs, sync);
|
|
sleep();
|
|
ok = cs <- "hello";
|
|
if !ok { panic("sreceiver") }
|
|
<-sync;
|
|
|
|
go ssender(cs, sync);
|
|
if buffer > 0 { <-sync } else { sleep() }
|
|
s, ok = <-cs;
|
|
if !ok { panic("ssender") }
|
|
if s != "hello again" { panic("ssender value") }
|
|
if buffer == 0 { <-sync }
|
|
}
|
|
print("PASS\n")
|
|
}
|