// //! Tests copied from Go and manually rewritten in Rust.
// //!
// //! Source:
// //! - https://github.com/golang/go
// //!
// //! Copyright & License:
// //! - Copyright (c) 2009 The Go Authors
// //! - https://golang.org/AUTHORS
// //! - https://golang.org/LICENSE
// //! - https://golang.org/PATENTS
// use std::any::Any;
// use std::cell::Cell;
// use std::collections::HashMap;
// use std::sync::{Arc, Condvar, Mutex};
// use std::thread;
// use std::time::Duration;
// use flume::{bounded, tick, Receiver, Select, Sender};
// fn ms(ms: u64) -> Duration {
// Duration::from_millis(ms)
// }
// struct Chan<T> {
// inner: Arc<Mutex<ChanInner<T>>>,
// }
// struct ChanInner<T> {
// s: Option<Sender<T>>,
// r: Receiver<T>,
// }
// impl<T> Clone for Chan<T> {
// fn clone(&self) -> Chan<T> {
// Chan {
// inner: self.inner.clone(),
// }
// }
// }
// impl<T> Chan<T> {
// fn send(&self, msg: T) {
// let s = self
// .inner
// .lock()
// .unwrap()
// .s
// .as_ref()
// .expect("sending into closed channel")
// .clone();
// let _ = s.send(msg);
// }
// fn try_recv(&self) -> Option<T> {
// let r = self.inner.lock().unwrap().r.clone();
// r.try_recv().ok()
// }
// fn recv(&self) -> Option<T> {
// let r = self.inner.lock().unwrap().r.clone();
// r.recv().ok()
// }
// fn close(&self) {
// self.inner
// .lock()
// .unwrap()
// .s
// .take()
// .expect("channel already closed");
// }
// fn rx(&self) -> Receiver<T> {
// self.inner.lock().unwrap().r.clone()
// }
// fn tx(&self) -> Sender<T> {
// match self.inner.lock().unwrap().s.as_ref() {
// None => {
// let (s, r) = bounded(0);
// std::mem::forget(r);
// s
// }
// Some(s) => s.clone(),
// }
// }
// }
// impl<T> Iterator for Chan<T> {
// type Item = T;
// fn next(&mut self) -> Option<Self::Item> {
// self.recv()
// }
// }
// impl<'a, T> IntoIterator for &'a Chan<T> {
// type Item = T;
// type IntoIter = Chan<T>;
// fn into_iter(self) -> Self::IntoIter {
// self.clone()
// }
// }
// fn make<T>(cap: usize) -> Chan<T> {
// let (s, r) = bounded(cap);
// Chan {
// inner: Arc::new(Mutex::new(ChanInner { s: Some(s), r })),
// }
// }
// #[derive(Clone)]
// struct WaitGroup(Arc<WaitGroupInner>);
// struct WaitGroupInner {
// cond: Condvar,
// count: Mutex<i32>,
// }
// impl WaitGroup {
// fn new() -> WaitGroup {
// WaitGroup(Arc::new(WaitGroupInner {
// cond: Condvar::new(),
// count: Mutex::new(0),
// }))
// }
// fn add(&self, delta: i32) {
// let mut count = self.0.count.lock().unwrap();
// *count += delta;
// assert!(*count >= 0);
// self.0.cond.notify_all();
// }
// fn done(&self) {
// self.add(-1);
// }
// fn wait(&self) {
// let mut count = self.0.count.lock().unwrap();
// while *count > 0 {
// count = self.0.cond.wait(count).unwrap();
// }
// }
// }
// struct Defer<F: FnOnce()> {
// f: Option<Box<F>>,
// }
// impl<F: FnOnce()> Drop for Defer<F> {
// fn drop(&mut self) {
// let f = self.f.take().unwrap();
// let mut f = Some(f);
// let mut f = move || f.take().unwrap()();
// f();
// }
// }
// macro_rules! defer {
// ($body:expr) => {
// let _defer = Defer {
// f: Some(Box::new(|| $body)),
// };
// };
// }
// macro_rules! go {
// (@parse ref $v:ident, $($tail:tt)*) => {{
// let ref $v = $v;
// go!(@parse $($tail)*)
// }};
// (@parse move $v:ident, $($tail:tt)*) => {{
// let $v = $v;
// go!(@parse $($tail)*)
// }};
// (@parse $v:ident, $($tail:tt)*) => {{
// let $v = $v.clone();
// go!(@parse $($tail)*)
// }};
// (@parse $body:expr) => {
// ::std::thread::spawn(move || {
// let res = ::std::panic::catch_unwind(::std::panic::AssertUnwindSafe(|| {
// $body
// }));
// if res.is_err() {
// eprintln!("goroutine panicked: {:?}", res);
// ::std::process::abort();
// }
// })
// };
// (@parse $($tail:tt)*) => {
// compile_error!("invalid `go!` syntax")
// };
// ($($tail:tt)*) => {{
// go!(@parse $($tail)*)
// }};
// }
// // https://github.com/golang/go/blob/master/test/chan/doubleselect.go
// mod doubleselect {
// use super::*;
// const ITERATIONS: i32 = 10_000;
// fn sender(n: i32, c1: Chan<i32>, c2: Chan<i32>, c3: Chan<i32>, c4: Chan<i32>) {
// defer! { c1.close() }
// defer! { c2.close() }
// defer! { c3.close() }
// defer! { c4.close() }
// for i in 0..n {
// select! {
// send(c1.tx(), i) -> _ => {}
// send(c2.tx(), i) -> _ => {}
// send(c3.tx(), i) -> _ => {}
// send(c4.tx(), i) -> _ => {}
// }
// }
// }
// fn mux(out: Chan<i32>, inp: Chan<i32>, done: Chan<bool>) {
// for v in inp {
// out.send(v);
// }
// done.send(true);
// }
// fn recver(inp: Chan<i32>) {
// let mut seen = HashMap::new();
// for v in &inp {
// if seen.contains_key(&v) {
// panic!("got duplicate value for {}", v);
// }
// seen.insert(v, true);
// }
// }
// #[test]
// fn main() {
// let c1 = make::<i32>(0);
// let c2 = make::<i32>(0);
// let c3 = make::<i32>(0);
// let c4 = make::<i32>(0);
// let done = make::<bool>(0);
// let cmux = make::<i32>(0);
// go!(c1, c2, c3, c4, sender(ITERATIONS, c1, c2, c3, c4));
// go!(cmux, c1, done, mux(cmux, c1, done));
// go!(cmux, c2, done, mux(cmux, c2, done));
// go!(cmux, c3, done, mux(cmux, c3, done));
// go!(cmux, c4, done, mux(cmux, c4, done));
// go!(done, cmux, {
// done.recv();
// done.recv();
// done.recv();
// done.recv();
// cmux.close();
// });
// recver(cmux);
// }
// }
// // https://github.com/golang/go/blob/master/test/chan/fifo.go
// mod fifo {
// use super::*;
// const N: i32 = 10;
// #[test]
// fn asynch_fifo() {
// let ch = make::<i32>(N as usize);
// for i in 0..N {
// ch.send(i);
// }
// for i in 0..N {
// if ch.recv() != Some(i) {
// panic!("bad receive");
// }
// }
// }
// fn chain(ch: Chan<i32>, val: i32, inp: Chan<i32>, out: Chan<i32>) {
// inp.recv();
// if ch.recv() != Some(val) {
// panic!(val);
// }
// out.send(1);
// }
// #[test]
// fn synch_fifo() {
// let ch = make::<i32>(0);
// let mut inp = make::<i32>(0);
// let start = inp.clone();
// for i in 0..N {
// let out = make::<i32>(0);
// go!(ch, i, inp, out, chain(ch, i, inp, out));
// inp = out;
// }
// start.send(0);
// for i in 0..N {
// ch.send(i);
// }
// inp.recv();
// }
// }
// // https://github.com/golang/go/blob/master/test/chan/goroutines.go
// mod goroutines {
// use super::*;
// fn f(left: Chan<i32>, right: Chan<i32>) {
// left.send(right.recv().unwrap());
// }
// #[test]
// fn main() {
// let n = 100i32;
// let leftmost = make::<i32>(0);
// let mut right = leftmost.clone();
// let mut left = leftmost.clone();
// for _ in 0..n {
// right = make::<i32>(0);
// go!(left, right, f(left, right));
// left = right.clone();
// }
// go!(right, right.send(1));
// leftmost.recv().unwrap();
// }
// }
// // https://github.com/golang/go/blob/master/test/chan/nonblock.go
// mod nonblock {
// use super::*;
// fn i32receiver(c: Chan<i32>, strobe: Chan<bool>) {
// if c.recv().unwrap() != 123 {
// panic!("i32 value");
// }
// strobe.send(true);
// }
// fn i32sender(c: Chan<i32>, strobe: Chan<bool>) {
// c.send(234);
// strobe.send(true);
// }
// fn i64receiver(c: Chan<i64>, strobe: Chan<bool>) {
// if c.recv().unwrap() != 123456 {
// panic!("i64 value");
// }
// strobe.send(true);
// }
// fn i64sender(c: Chan<i64>, strobe: Chan<bool>) {
// c.send(234567);
// strobe.send(true);
// }
// fn breceiver(c: Chan<bool>, strobe: Chan<bool>) {
// if !c.recv().unwrap() {
// panic!("b value");
// }
// strobe.send(true);
// }
// fn bsender(c: Chan<bool>, strobe: Chan<bool>) {
// c.send(true);
// strobe.send(true);
// }
// fn sreceiver(c: Chan<String>, strobe: Chan<bool>) {
// if c.recv().unwrap() != "hello" {
// panic!("x value");
// }
// strobe.send(true);
// }
// fn ssender(c: Chan<String>, strobe: Chan<bool>) {
// c.send("hello again".to_string());
// strobe.send(true);
// }
// const MAX_TRIES: usize = 10000; // Up to 100ms per test.
// #[test]
// fn main() {
// let ticker = tick(Duration::new(0, 10_000)); // 10 us
// let sleep = || {
// ticker.recv().unwrap();
// ticker.recv().unwrap();
// thread::yield_now();
// thread::yield_now();
// thread::yield_now();
// };
// let sync = make::<bool>(0);
// for buffer in 0..2 {
// let c32 = make::<i32>(buffer);
// let c64 = make::<i64>(buffer);
// let cb = make::<bool>(buffer);
// let cs = make::<String>(buffer);
// select! {
// recv(c32.rx()) -> _ => panic!("blocked i32sender"),
// default => {}
// }
// select! {
// recv(c64.rx()) -> _ => panic!("blocked i64sender"),
// default => {}
// }
// select! {
// recv(cb.rx()) -> _ => panic!("blocked bsender"),
// default => {}
// }
// select! {
// recv(cs.rx()) -> _ => panic!("blocked ssender"),
// default => {}
// }
// go!(c32, sync, i32receiver(c32, sync));
// let mut try = 0;
// loop {
// select! {
// send(c32.tx(), 123) -> _ => break,
// default => {
// try += 1;
// if try > MAX_TRIES {
// println!("i32receiver buffer={}", buffer);
// panic!("fail")
// }
// sleep();
// }
// }
// }
// sync.recv();
// go!(c32, sync, i32sender(c32, sync));
// if buffer > 0 {
// sync.recv();
// }
// let mut try = 0;
// loop {
// select! {
// recv(c32.rx()) -> v => {
// if v != Ok(234) {
// panic!("i32sender value");
// }
// break;
// }
// default => {
// try += 1;
// if try > MAX_TRIES {
// println!("i32sender buffer={}", buffer);
// panic!("fail");
// }
// sleep();
// }
// }
// }
// if buffer == 0 {
// sync.recv();
// }
// go!(c64, sync, i64receiver(c64, sync));
// let mut try = 0;
// loop {
// select! {
// send(c64.tx(), 123456) -> _ => break,
// default => {
// try += 1;
// if try > MAX_TRIES {
// println!("i64receiver buffer={}", buffer);
// panic!("fail")
// }
// sleep();
// }
// }
// }
// sync.recv();
// go!(c64, sync, i64sender(c64, sync));
// if buffer > 0 {
// sync.recv();
// }
// let mut try = 0;
// loop {
// select! {
// recv(c64.rx()) -> v => {
// if v != Ok(234567) {
// panic!("i64sender value");
// }
// break;
// }
// default => {
// try += 1;
// if try > MAX_TRIES {
// println!("i64sender buffer={}", buffer);
// panic!("fail");
// }
// sleep();
// }
// }
// }
// if buffer == 0 {
// sync.recv();
// }
// go!(cb, sync, breceiver(cb, sync));
// let mut try = 0;
// loop {
// select! {
// send(cb.tx(), true) -> _ => break,
// default => {
// try += 1;
// if try > MAX_TRIES {
// println!("breceiver buffer={}", buffer);
// panic!("fail")
// }
// sleep();
// }
// }
// }
// sync.recv();
// go!(cb, sync, bsender(cb, sync));
// if buffer > 0 {
// sync.recv();
// }
// let mut try = 0;
// loop {
// select! {
// recv(cb.rx()) -> v => {
// if v != Ok(true) {
// panic!("bsender value");
// }
// break;
// }
// default => {
// try += 1;
// if try > MAX_TRIES {
// println!("bsender buffer={}", buffer);
// panic!("fail");
// }
// sleep();
// }
// }
// }
// if buffer == 0 {
// sync.recv();
// }
// go!(cs, sync, sreceiver(cs, sync));
// let mut try = 0;
// loop {
// select! {
// send(cs.tx(), "hello".to_string()) -> _ => break,
// default => {
// try += 1;
// if try > MAX_TRIES {
// println!("sreceiver buffer={}", buffer);
// panic!("fail")
// }
// sleep();
// }
// }
// }
// sync.recv();
// go!(cs, sync, ssender(cs, sync));
// if buffer > 0 {
// sync.recv();
// }
// let mut try = 0;
// loop {
// select! {
// recv(cs.rx()) -> v => {
// if v != Ok("hello again".to_string()) {
// panic!("ssender value");
// }
// break;
// }
// default => {
// try += 1;
// if try > MAX_TRIES {
// println!("ssender buffer={}", buffer);
// panic!("fail");
// }
// sleep();
// }
// }
// }
// if buffer == 0 {
// sync.recv();
// }
// }
// }
// }
// // https://github.com/golang/go/blob/master/test/chan/select.go
// mod select {
// use super::*;
// #[test]
// fn main() {
// let shift = Cell::new(0);
// let counter = Cell::new(0);
// let get_value = || {
// counter.set(counter.get() + 1);
// 1 << shift.get()
// };
// let send = |mut a: Option<&Chan<u32>>, mut b: Option<&Chan<u32>>| {
// let mut i = 0;
// let never = make::<u32>(0);
// loop {
// let nil1 = never.tx();
// let nil2 = never.tx();
// let v1 = get_value();
// let v2 = get_value();
// select! {
// send(a.map(|c| c.tx()).unwrap_or(nil1), v1) -> _ => {
// i += 1;
// a = None;
// }
// send(b.map(|c| c.tx()).unwrap_or(nil2), v2) -> _ => {
// i += 1;
// b = None;
// }
// default => break,
// }
// shift.set(shift.get() + 1);
// }
// i
// };
// let a = make::<u32>(1);
// let b = make::<u32>(1);
// assert_eq!(send(Some(&a), Some(&b)), 2);
// let av = a.recv().unwrap();
// let bv = b.recv().unwrap();
// assert_eq!(av | bv, 3);
// assert_eq!(send(Some(&a), None), 1);
// assert_eq!(counter.get(), 10);
// }
// }
// // https://github.com/golang/go/blob/master/test/chan/select2.go
// mod select2 {
// // TODO
// }
// // https://github.com/golang/go/blob/master/test/chan/select3.go
// mod select3 {
// // TODO
// }
// // https://github.com/golang/go/blob/master/test/chan/select4.go
// mod select4 {
// use super::*;
// #[test]
// fn main() {
// let c = make::<i32>(1);
// let c1 = make::<i32>(0);
// c.send(42);
// select! {
// recv(c1.rx()) -> _ => panic!("BUG"),
// recv(c.rx()) -> v => assert_eq!(v, Ok(42)),
// }
// }
// }
// // https://github.com/golang/go/blob/master/test/chan/select6.go
// mod select6 {
// use super::*;
// #[test]
// fn main() {
// let c1 = make::<bool>(0);
// let c2 = make::<bool>(0);
// let c3 = make::<bool>(0);
// go!(c1, c1.recv());
// go!(c1, c2, c3, {
// select! {
// recv(c1.rx()) -> _ => panic!("dummy"),
// recv(c2.rx()) -> _ => c3.send(true),
// }
// c1.recv();
// });
// go!(c2, c2.send(true));
// c3.recv();
// c1.send(true);
// c1.send(true);
// }
// }
// // https://github.com/golang/go/blob/master/test/chan/select7.go
// mod select7 {
// use super::*;
// fn recv1(c: Chan<i32>) {
// c.recv().unwrap();
// }
// fn recv2(c: Chan<i32>) {
// select! {
// recv(c.rx()) -> _ => ()
// }
// }
// fn recv3(c: Chan<i32>) {
// let c2 = make::<i32>(1);
// select! {
// recv(c.rx()) -> _ => (),
// recv(c2.rx()) -> _ => ()
// }
// }
// fn send1(recv: fn(Chan<i32>)) {
// let c = make::<i32>(1);
// go!(c, recv(c));
// thread::yield_now();
// c.send(1);
// }
// fn send2(recv: fn(Chan<i32>)) {
// let c = make::<i32>(1);
// go!(c, recv(c));
// thread::yield_now();
// select! {
// send(c.tx(), 1) -> _ => ()
// }
// }
// fn send3(recv: fn(Chan<i32>)) {
// let c = make::<i32>(1);
// go!(c, recv(c));
// thread::yield_now();
// let c2 = make::<i32>(1);
// select! {
// send(c.tx(), 1) -> _ => (),
// send(c2.tx(), 1) -> _ => ()
// }
// }
// #[test]
// fn main() {
// send1(recv1);
// send2(recv1);
// send3(recv1);
// send1(recv2);
// send2(recv2);
// send3(recv2);
// send1(recv3);
// send2(recv3);
// send3(recv3);
// }
// }
// // https://github.com/golang/go/blob/master/test/chan/sieve1.go
// mod sieve1 {
// use super::*;
// fn generate(ch: Chan<i32>) {
// let mut i = 2;
// loop {
// ch.send(i);
// i += 1;
// }
// }
// fn filter(in_ch: Chan<i32>, out_ch: Chan<i32>, prime: i32) {
// for i in in_ch {
// if i % prime != 0 {
// out_ch.send(i);
// }
// }
// }
// fn sieve(primes: Chan<i32>) {
// let mut ch = make::<i32>(1);
// go!(ch, generate(ch));
// loop {
// let prime = ch.recv().unwrap();
// primes.send(prime);
// let ch1 = make::<i32>(1);
// go!(ch, ch1, prime, filter(ch, ch1, prime));
// ch = ch1;
// }
// }
// #[test]
// fn main() {
// let primes = make::<i32>(1);
// go!(primes, sieve(primes));
// let a = [
// 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83,
// 89, 97,
// ];
// for item in a.iter() {
// let x = primes.recv().unwrap();
// if x != *item {
// println!("{} != {}", x, item);
// panic!("fail");
// }
// }
// }
// }
// // https://github.com/golang/go/blob/master/test/chan/zerosize.go
// mod zerosize {
// use super::*;
// #[test]
// fn zero_size_struct() {
// struct ZeroSize;
// let _ = make::<ZeroSize>(0);
// }
// #[test]
// fn zero_size_array() {
// let _ = make::<[u8; 0]>(0);
// }
// }
// // https://github.com/golang/go/blob/master/src/runtime/chan_test.go
// mod chan_test {
// use super::*;
// #[test]
// fn test_chan() {
// const N: i32 = 200;
// for cap in 0..N {
// {
// // Ensure that receive from empty chan blocks.
// let c = make::<i32>(cap as usize);
// let recv1 = Arc::new(Mutex::new(false));
// go!(c, recv1, {
// c.recv();
// *recv1.lock().unwrap() = true;
// });
// let recv2 = Arc::new(Mutex::new(false));
// go!(c, recv2, {
// c.recv();
// *recv2.lock().unwrap() = true;
// });
// thread::sleep(ms(1));
// if *recv1.lock().unwrap() || *recv2.lock().unwrap() {
// panic!();
// }
// // Ensure that non-blocking receive does not block.
// select! {
// recv(c.rx()) -> _ => panic!(),
// default => {}
// }
// select! {
// recv(c.rx()) -> _ => panic!(),
// default => {}
// }
// c.send(0);
// c.send(0);
// }
// {
// // Ensure that send to full chan blocks.
// let c = make::<i32>(cap as usize);
// for i in 0..cap {
// c.send(i);
// }
// let sent = Arc::new(Mutex::new(0));
// go!(sent, c, {
// c.send(0);
// *sent.lock().unwrap() = 1;
// });
// thread::sleep(ms(1));
// if *sent.lock().unwrap() != 0 {
// panic!();
// }
// // Ensure that non-blocking send does not block.
// select! {
// send(c.tx(), 0) -> _ => panic!(),
// default => {}
// }
// c.recv();
// }
// {
// // Ensure that we receive 0 from closed chan.
// let c = make::<i32>(cap as usize);
// for i in 0..cap {
// c.send(i);
// }
// c.close();
// for i in 0..cap {
// let v = c.recv();
// if v != Some(i) {
// panic!();
// }
// }
// if c.recv() != None {
// panic!();
// }
// if c.try_recv() != None {
// panic!();
// }
// }
// {
// // Ensure that close unblocks receive.
// let c = make::<i32>(cap as usize);
// let done = make::<bool>(0);
// go!(c, done, {
// let v = c.try_recv();
// done.send(v.is_some());
// });
// thread::sleep(ms(1));
// c.close();
// if !done.recv().unwrap() {
// // panic!();
// }
// }
// {
// // Send 100 integers,
// // ensure that we receive them non-corrupted in FIFO order.
// let c = make::<i32>(cap as usize);
// go!(c, {
// for i in 0..100 {
// c.send(i);
// }
// });
// for i in 0..100 {
// if c.recv() != Some(i) {
// panic!();
// }
// }
// // Same, but using recv2.
// go!(c, {
// for i in 0..100 {
// c.send(i);
// }
// });
// for i in 0..100 {
// if c.recv() != Some(i) {
// panic!();
// }
// }
// }
// }
// }
// #[test]
// fn test_nonblock_recv_race() {
// const N: usize = 1000;
// for _ in 0..N {
// let c = make::<i32>(1);
// c.send(1);
// let t = go!(c, {
// select! {
// recv(c.rx()) -> _ => {}
// default => panic!("chan is not ready"),
// }
// });
// c.close();
// c.recv();
// t.join().unwrap();
// }
// }
// #[test]
// fn test_nonblock_select_race() {
// const N: usize = 1000;
// let done = make::<bool>(1);
// for _ in 0..N {
// let c1 = make::<i32>(1);
// let c2 = make::<i32>(1);
// c1.send(1);
// go!(c1, c2, done, {
// select! {
// recv(c1.rx()) -> _ => {}
// recv(c2.rx()) -> _ => {}
// default => {
// done.send(false);
// return;
// }
// }
// done.send(true);
// });
// c2.send(1);
// select! {
// recv(c1.rx()) -> _ => {}
// default => {}
// }
// if !done.recv().unwrap() {
// panic!("no chan is ready");
// }
// }
// }
// #[test]
// fn test_nonblock_select_race2() {
// const N: usize = 1000;
// let done = make::<bool>(1);
// for _ in 0..N {
// let c1 = make::<i32>(1);
// let c2 = make::<i32>(0);
// c1.send(1);
// go!(c1, c2, done, {
// select! {
// recv(c1.rx()) -> _ => {}
// recv(c2.rx()) -> _ => {}
// default => {
// done.send(false);
// return;
// }
// }
// done.send(true);
// });
// c2.close();
// select! {
// recv(c1.rx()) -> _ => {}
// default => {}
// }
// if !done.recv().unwrap() {
// panic!("no chan is ready");
// }
// }
// }
// #[test]
// fn test_self_select() {
// // Ensure that send/recv on the same chan in select
// // does not crash nor deadlock.
// for &cap in &[0, 10] {
// let wg = WaitGroup::new();
// wg.add(2);
// let c = make::<i32>(cap);
// for p in 0..2 {
// let p = p;
// go!(wg, p, c, {
// defer! { wg.done() }
// for i in 0..1000 {
// if p == 0 || i % 2 == 0 {
// select! {
// send(c.tx(), p) -> _ => {}
// recv(c.rx()) -> v => {
// if cap == 0 && v.ok() == Some(p) {
// panic!("self receive");
// }
// }
// }
// } else {
// select! {
// recv(c.rx()) -> v => {
// if cap == 0 && v.ok() == Some(p) {
// panic!("self receive");
// }
// }
// send(c.tx(), p) -> _ => {}
// }
// }
// }
// });
// }
// wg.wait();
// }
// }
// #[test]
// fn test_select_stress() {
// let c = vec![
// make::<i32>(0),
// make::<i32>(0),
// make::<i32>(2),
// make::<i32>(3),
// ];
// const N: usize = 10000;
// // There are 4 goroutines that send N values on each of the chans,
// // + 4 goroutines that receive N values on each of the chans,
// // + 1 goroutine that sends N values on each of the chans in a single select,
// // + 1 goroutine that receives N values on each of the chans in a single select.
// // All these sends, receives and selects interact chaotically at runtime,
// // but we are careful that this whole construct does not deadlock.
// let wg = WaitGroup::new();
// wg.add(10);
// for k in 0..4 {
// go!(k, c, wg, {
// for _ in 0..N {
// c[k].send(0);
// }
// wg.done();
// });
// go!(k, c, wg, {
// for _ in 0..N {
// c[k].recv();
// }
// wg.done();
// });
// }
// go!(c, wg, {
// let mut n = [0; 4];
// let mut c1 = c.iter().map(|c| Some(c.rx().clone())).collect::<Vec<_>>();
// for _ in 0..4 * N {
// let index = {
// let mut sel = Select::new();
// let mut opers = [!0; 4];
// for &i in &[3, 2, 0, 1] {
// if let Some(c) = &c1[i] {
// opers[i] = sel.recv(c);
// }
// }
// let oper = sel.select();
// let mut index = !0;
// for i in 0..4 {
// if opers[i] == oper.index() {
// index = i;
// let _ = oper.recv(c1[i].as_ref().unwrap());
// break;
// }
// }
// index
// };
// n[index] += 1;
// if n[index] == N {
// c1[index] = None;
// }
// }
// wg.done();
// });
// go!(c, wg, {
// let mut n = [0; 4];
// let mut c1 = c.iter().map(|c| Some(c.tx().clone())).collect::<Vec<_>>();
// for _ in 0..4 * N {
// let index = {
// let mut sel = Select::new();
// let mut opers = [!0; 4];
// for &i in &[0, 1, 2, 3] {
// if let Some(c) = &c1[i] {
// opers[i] = sel.send(c);
// }
// }
// let oper = sel.select();
// let mut index = !0;
// for i in 0..4 {
// if opers[i] == oper.index() {
// index = i;
// let _ = oper.send(c1[i].as_ref().unwrap(), 0);
// break;
// }
// }
// index
// };
// n[index] += 1;
// if n[index] == N {
// c1[index] = None;
// }
// }
// wg.done();
// });
// wg.wait();
// }
// #[test]
// fn test_select_fairness() {
// const TRIALS: usize = 10000;
// let c1 = make::<u8>(TRIALS + 1);
// let c2 = make::<u8>(TRIALS + 1);
// for _ in 0..TRIALS + 1 {
// c1.send(1);
// c2.send(2);
// }
// let c3 = make::<u8>(0);
// let c4 = make::<u8>(0);
// let out = make::<u8>(0);
// let done = make::<u8>(0);
// let wg = WaitGroup::new();
// wg.add(1);
// go!(wg, c1, c2, c3, c4, out, done, {
// defer! { wg.done() };
// loop {
// let b;
// select! {
// recv(c3.rx()) -> m => b = m.unwrap(),
// recv(c4.rx()) -> m => b = m.unwrap(),
// recv(c1.rx()) -> m => b = m.unwrap(),
// recv(c2.rx()) -> m => b = m.unwrap(),
// }
// select! {
// send(out.tx(), b) -> _ => {}
// recv(done.rx()) -> _ => return,
// }
// }
// });
// let (mut cnt1, mut cnt2) = (0, 0);
// for _ in 0..TRIALS {
// match out.recv() {
// Some(1) => cnt1 += 1,
// Some(2) => cnt2 += 1,
// b => panic!("unexpected value {:?} on channel", b),
// }
// }
// // If the select in the goroutine is fair,
// // cnt1 and cnt2 should be about the same value.
// // With 10,000 trials, the expected margin of error at
// // a confidence level of five nines is 4.4172 / (2 * Sqrt(10000)).
// let r = cnt1 as f64 / TRIALS as f64;
// let e = (r - 0.5).abs();
// if e > 4.4172 / (2.0 * (TRIALS as f64).sqrt()) {
// panic!(
// "unfair select: in {} trials, results were {}, {}",
// TRIALS, cnt1, cnt2,
// );
// }
// done.close();
// wg.wait();
// }
// #[test]
// fn test_chan_send_interface() {
// struct Mt;
// let c = make::<Box<dyn Any>>(1);
// c.send(Box::new(Mt));
// select! {
// send(c.tx(), Box::new(Mt)) -> _ => {}
// default => {}
// }
// select! {
// send(c.tx(), Box::new(Mt)) -> _ => {}
// send(c.tx(), Box::new(Mt)) -> _ => {}
// default => {}
// }
// }
// #[test]
// fn test_pseudo_random_send() {
// const N: usize = 100;
// for cap in 0..N {
// let c = make::<i32>(cap);
// let l = Arc::new(Mutex::new(vec![0i32; N]));
// let done = make::<bool>(0);
// go!(c, done, l, {
// let mut l = l.lock().unwrap();
// for i in 0..N {
// thread::yield_now();
// l[i] = c.recv().unwrap();
// }
// done.send(true);
// });
// for _ in 0..N {
// select! {
// send(c.tx(), 1) -> _ => {}
// send(c.tx(), 0) -> _ => {}
// }
// }
// done.recv();
// let mut n0 = 0;
// let mut n1 = 0;
// for &i in l.lock().unwrap().iter() {
// n0 += (i + 1) % 2;
// n1 += i;
// }
// if n0 <= N as i32 / 10 || n1 <= N as i32 / 10 {
// panic!(
// "Want pseudorandom, got {} zeros and {} ones (chan cap {})",
// n0, n1, cap,
// );
// }
// }
// }
// #[test]
// fn test_multi_consumer() {
// const NWORK: usize = 23;
// const NITER: usize = 271828;
// let pn = [2, 3, 7, 11, 13, 17, 19, 23, 27, 31];
// let q = make::<i32>(NWORK * 3);
// let r = make::<i32>(NWORK * 3);
// let wg = WaitGroup::new();
// for i in 0..NWORK {
// wg.add(1);
// let w = i;
// go!(q, r, wg, pn, {
// for v in &q {
// if pn[w % pn.len()] == v {
// thread::yield_now();
// }
// r.send(v);
// }
// wg.done();
// });
// }
// let expect = Arc::new(Mutex::new(0));
// go!(q, r, expect, wg, pn, {
// for i in 0..NITER {
// let v = pn[i % pn.len()];
// *expect.lock().unwrap() += v;
// q.send(v);
// }
// q.close();
// wg.wait();
// r.close();
// });
// let mut n = 0;
// let mut s = 0;
// for v in &r {
// n += 1;
// s += v;
// }
// if n != NITER || s != *expect.lock().unwrap() {
// panic!();
// }
// }
// #[test]
// fn test_select_duplicate_channel() {
// // This test makes sure we can queue a G on
// // the same channel multiple times.
// let c = make::<i32>(0);
// let d = make::<i32>(0);
// let e = make::<i32>(0);
// go!(c, d, e, {
// select! {
// recv(c.rx()) -> _ => {}
// recv(d.rx()) -> _ => {}
// recv(e.rx()) -> _ => {}
// }
// e.send(9);
// });
// thread::sleep(ms(1));
// go!(c, c.recv());
// thread::sleep(ms(1));
// d.send(7);
// e.recv();
// c.send(8);
// }
// }
// // https://github.com/golang/go/blob/master/test/closedchan.go
// mod closedchan {
// // TODO
// }
// // https://github.com/golang/go/blob/master/src/runtime/chanbarrier_test.go
// mod chanbarrier_test {
// // TODO
// }
// // https://github.com/golang/go/blob/master/src/runtime/race/testdata/chan_test.go
// mod race_chan_test {
// // TODO
// }
// // https://github.com/golang/go/blob/master/test/ken/chan.go
// mod chan {
// // TODO
// }
// // https://github.com/golang/go/blob/master/test/ken/chan1.go
// mod chan1 {
// // TODO
// }