From 1b6a04ca5504955c571d1c97504fb45ea0befee4 Mon Sep 17 00:00:00 2001
From: Valentin Popov <valentin@popov.link>
Date: Mon, 8 Jan 2024 01:21:28 +0400
Subject: Initial vendor packages

Signed-off-by: Valentin Popov <valentin@popov.link>
---
 vendor/flume/tests/select_macro.rs | 1440 ++++++++++++++++++++++++++++++++++++
 1 file changed, 1440 insertions(+)
 create mode 100644 vendor/flume/tests/select_macro.rs

(limited to 'vendor/flume/tests/select_macro.rs')

diff --git a/vendor/flume/tests/select_macro.rs b/vendor/flume/tests/select_macro.rs
new file mode 100644
index 0000000..367d8dd
--- /dev/null
+++ b/vendor/flume/tests/select_macro.rs
@@ -0,0 +1,1440 @@
+// //! Tests for the `select!` macro.
+
+// #![deny(unsafe_code)]
+
+// #[macro_use]
+// extern crate crossbeam_channel;
+// extern crate crossbeam_utils;
+
+// use std::any::Any;
+// use std::cell::Cell;
+// use std::ops::Deref;
+// use std::thread;
+// use std::time::{Duration, Instant};
+
+// use crossbeam_channel::{after, bounded, never, tick, unbounded};
+// use crossbeam_channel::{Receiver, RecvError, SendError, Sender, TryRecvError};
+// use crossbeam_utils::thread::scope;
+
+// fn ms(ms: u64) -> Duration {
+//     Duration::from_millis(ms)
+// }
+
+// #[test]
+// fn smoke1() {
+//     let (s1, r1) = unbounded::<usize>();
+//     let (s2, r2) = unbounded::<usize>();
+
+//     s1.send(1).unwrap();
+
+//     select! {
+//         recv(r1) -> v => assert_eq!(v, Ok(1)),
+//         recv(r2) -> _ => panic!(),
+//     }
+
+//     s2.send(2).unwrap();
+
+//     select! {
+//         recv(r1) -> _ => panic!(),
+//         recv(r2) -> v => assert_eq!(v, Ok(2)),
+//     }
+// }
+
+// #[test]
+// fn smoke2() {
+//     let (_s1, r1) = unbounded::<i32>();
+//     let (_s2, r2) = unbounded::<i32>();
+//     let (_s3, r3) = unbounded::<i32>();
+//     let (_s4, r4) = unbounded::<i32>();
+//     let (s5, r5) = unbounded::<i32>();
+
+//     s5.send(5).unwrap();
+
+//     select! {
+//         recv(r1) -> _ => panic!(),
+//         recv(r2) -> _ => panic!(),
+//         recv(r3) -> _ => panic!(),
+//         recv(r4) -> _ => panic!(),
+//         recv(r5) -> v => assert_eq!(v, Ok(5)),
+//     }
+// }
+
+// #[test]
+// fn disconnected() {
+//     let (s1, r1) = unbounded::<i32>();
+//     let (s2, r2) = unbounded::<i32>();
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             drop(s1);
+//             thread::sleep(ms(500));
+//             s2.send(5).unwrap();
+//         });
+
+//         select! {
+//             recv(r1) -> v => assert!(v.is_err()),
+//             recv(r2) -> _ => panic!(),
+//             default(ms(1000)) => panic!(),
+//         }
+
+//         r2.recv().unwrap();
+//     })
+//     .unwrap();
+
+//     select! {
+//         recv(r1) -> v => assert!(v.is_err()),
+//         recv(r2) -> _ => panic!(),
+//         default(ms(1000)) => panic!(),
+//     }
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             thread::sleep(ms(500));
+//             drop(s2);
+//         });
+
+//         select! {
+//             recv(r2) -> v => assert!(v.is_err()),
+//             default(ms(1000)) => panic!(),
+//         }
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn default() {
+//     let (s1, r1) = unbounded::<i32>();
+//     let (s2, r2) = unbounded::<i32>();
+
+//     select! {
+//         recv(r1) -> _ => panic!(),
+//         recv(r2) -> _ => panic!(),
+//         default => {}
+//     }
+
+//     drop(s1);
+
+//     select! {
+//         recv(r1) -> v => assert!(v.is_err()),
+//         recv(r2) -> _ => panic!(),
+//         default => panic!(),
+//     }
+
+//     s2.send(2).unwrap();
+
+//     select! {
+//         recv(r2) -> v => assert_eq!(v, Ok(2)),
+//         default => panic!(),
+//     }
+
+//     select! {
+//         recv(r2) -> _ => panic!(),
+//         default => {},
+//     }
+
+//     select! {
+//         default => {},
+//     }
+// }
+
+// #[test]
+// fn timeout() {
+//     let (_s1, r1) = unbounded::<i32>();
+//     let (s2, r2) = unbounded::<i32>();
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             thread::sleep(ms(1500));
+//             s2.send(2).unwrap();
+//         });
+
+//         select! {
+//             recv(r1) -> _ => panic!(),
+//             recv(r2) -> _ => panic!(),
+//             default(ms(1000)) => {},
+//         }
+
+//         select! {
+//             recv(r1) -> _ => panic!(),
+//             recv(r2) -> v => assert_eq!(v, Ok(2)),
+//             default(ms(1000)) => panic!(),
+//         }
+//     })
+//     .unwrap();
+
+//     scope(|scope| {
+//         let (s, r) = unbounded::<i32>();
+
+//         scope.spawn(move |_| {
+//             thread::sleep(ms(500));
+//             drop(s);
+//         });
+
+//         select! {
+//             default(ms(1000)) => {
+//                 select! {
+//                     recv(r) -> v => assert!(v.is_err()),
+//                     default => panic!(),
+//                 }
+//             }
+//         }
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn default_when_disconnected() {
+//     let (_, r) = unbounded::<i32>();
+
+//     select! {
+//         recv(r) -> res => assert!(res.is_err()),
+//         default => panic!(),
+//     }
+
+//     let (_, r) = unbounded::<i32>();
+
+//     select! {
+//         recv(r) -> res => assert!(res.is_err()),
+//         default(ms(1000)) => panic!(),
+//     }
+
+//     let (s, _) = bounded::<i32>(0);
+
+//     select! {
+//         send(s, 0) -> res => assert!(res.is_err()),
+//         default => panic!(),
+//     }
+
+//     let (s, _) = bounded::<i32>(0);
+
+//     select! {
+//         send(s, 0) -> res => assert!(res.is_err()),
+//         default(ms(1000)) => panic!(),
+//     }
+// }
+
+// #[test]
+// fn default_only() {
+//     let start = Instant::now();
+//     select! {
+//         default => {}
+//     }
+//     let now = Instant::now();
+//     assert!(now - start <= ms(50));
+
+//     let start = Instant::now();
+//     select! {
+//         default(ms(500)) => {}
+//     }
+//     let now = Instant::now();
+//     assert!(now - start >= ms(450));
+//     assert!(now - start <= ms(550));
+// }
+
+// #[test]
+// fn unblocks() {
+//     let (s1, r1) = bounded::<i32>(0);
+//     let (s2, r2) = bounded::<i32>(0);
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             thread::sleep(ms(500));
+//             s2.send(2).unwrap();
+//         });
+
+//         select! {
+//             recv(r1) -> _ => panic!(),
+//             recv(r2) -> v => assert_eq!(v, Ok(2)),
+//             default(ms(1000)) => panic!(),
+//         }
+//     })
+//     .unwrap();
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             thread::sleep(ms(500));
+//             assert_eq!(r1.recv().unwrap(), 1);
+//         });
+
+//         select! {
+//             send(s1, 1) -> _ => {},
+//             send(s2, 2) -> _ => panic!(),
+//             default(ms(1000)) => panic!(),
+//         }
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn both_ready() {
+//     let (s1, r1) = bounded(0);
+//     let (s2, r2) = bounded(0);
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             thread::sleep(ms(500));
+//             s1.send(1).unwrap();
+//             assert_eq!(r2.recv().unwrap(), 2);
+//         });
+
+//         for _ in 0..2 {
+//             select! {
+//                 recv(r1) -> v => assert_eq!(v, Ok(1)),
+//                 send(s2, 2) -> _ => {},
+//             }
+//         }
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn loop_try() {
+//     const RUNS: usize = 20;
+
+//     for _ in 0..RUNS {
+//         let (s1, r1) = bounded::<i32>(0);
+//         let (s2, r2) = bounded::<i32>(0);
+//         let (s_end, r_end) = bounded::<()>(0);
+
+//         scope(|scope| {
+//             scope.spawn(|_| loop {
+//                 select! {
+//                     send(s1, 1) -> _ => break,
+//                     default => {}
+//                 }
+
+//                 select! {
+//                     recv(r_end) -> _ => break,
+//                     default => {}
+//                 }
+//             });
+
+//             scope.spawn(|_| loop {
+//                 if let Ok(x) = r2.try_recv() {
+//                     assert_eq!(x, 2);
+//                     break;
+//                 }
+
+//                 select! {
+//                     recv(r_end) -> _ => break,
+//                     default => {}
+//                 }
+//             });
+
+//             scope.spawn(|_| {
+//                 thread::sleep(ms(500));
+
+//                 select! {
+//                     recv(r1) -> v => assert_eq!(v, Ok(1)),
+//                     send(s2, 2) -> _ => {},
+//                     default(ms(500)) => panic!(),
+//                 }
+
+//                 drop(s_end);
+//             });
+//         })
+//         .unwrap();
+//     }
+// }
+
+// #[test]
+// fn cloning1() {
+//     scope(|scope| {
+//         let (s1, r1) = unbounded::<i32>();
+//         let (_s2, r2) = unbounded::<i32>();
+//         let (s3, r3) = unbounded::<()>();
+
+//         scope.spawn(move |_| {
+//             r3.recv().unwrap();
+//             drop(s1.clone());
+//             assert_eq!(r3.try_recv(), Err(TryRecvError::Empty));
+//             s1.send(1).unwrap();
+//             r3.recv().unwrap();
+//         });
+
+//         s3.send(()).unwrap();
+
+//         select! {
+//             recv(r1) -> _ => {},
+//             recv(r2) -> _ => {},
+//         }
+
+//         s3.send(()).unwrap();
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn cloning2() {
+//     let (s1, r1) = unbounded::<()>();
+//     let (s2, r2) = unbounded::<()>();
+//     let (_s3, _r3) = unbounded::<()>();
+
+//     scope(|scope| {
+//         scope.spawn(move |_| {
+//             select! {
+//                 recv(r1) -> _ => panic!(),
+//                 recv(r2) -> _ => {},
+//             }
+//         });
+
+//         thread::sleep(ms(500));
+//         drop(s1.clone());
+//         s2.send(()).unwrap();
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn preflight1() {
+//     let (s, r) = unbounded();
+//     s.send(()).unwrap();
+
+//     select! {
+//         recv(r) -> _ => {}
+//     }
+// }
+
+// #[test]
+// fn preflight2() {
+//     let (s, r) = unbounded();
+//     drop(s.clone());
+//     s.send(()).unwrap();
+//     drop(s);
+
+//     select! {
+//         recv(r) -> v => assert!(v.is_ok()),
+//     }
+//     assert_eq!(r.try_recv(), Err(TryRecvError::Disconnected));
+// }
+
+// #[test]
+// fn preflight3() {
+//     let (s, r) = unbounded();
+//     drop(s.clone());
+//     s.send(()).unwrap();
+//     drop(s);
+//     r.recv().unwrap();
+
+//     select! {
+//         recv(r) -> v => assert!(v.is_err())
+//     }
+// }
+
+// #[test]
+// fn duplicate_operations() {
+//     let (s, r) = unbounded::<i32>();
+//     let mut hit = [false; 4];
+
+//     while hit.iter().any(|hit| !hit) {
+//         select! {
+//             recv(r) -> _ => hit[0] = true,
+//             recv(r) -> _ => hit[1] = true,
+//             send(s, 0) -> _ => hit[2] = true,
+//             send(s, 0) -> _ => hit[3] = true,
+//         }
+//     }
+// }
+
+// #[test]
+// fn nesting() {
+//     let (s, r) = unbounded::<i32>();
+
+//     select! {
+//         send(s, 0) -> _ => {
+//             select! {
+//                 recv(r) -> v => {
+//                     assert_eq!(v, Ok(0));
+//                     select! {
+//                         send(s, 1) -> _ => {
+//                             select! {
+//                                 recv(r) -> v => {
+//                                     assert_eq!(v, Ok(1));
+//                                 }
+//                             }
+//                         }
+//                     }
+//                 }
+//             }
+//         }
+//     }
+// }
+
+// #[test]
+// #[should_panic(expected = "send panicked")]
+// fn panic_sender() {
+//     fn get() -> Sender<i32> {
+//         panic!("send panicked")
+//     }
+
+//     #[allow(unreachable_code)]
+//     {
+//         select! {
+//             send(get(), panic!()) -> _ => {}
+//         }
+//     }
+// }
+
+// #[test]
+// #[should_panic(expected = "recv panicked")]
+// fn panic_receiver() {
+//     fn get() -> Receiver<i32> {
+//         panic!("recv panicked")
+//     }
+
+//     select! {
+//         recv(get()) -> _ => {}
+//     }
+// }
+
+// #[test]
+// fn stress_recv() {
+//     const COUNT: usize = 10_000;
+
+//     let (s1, r1) = unbounded();
+//     let (s2, r2) = bounded(5);
+//     let (s3, r3) = bounded(100);
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             for i in 0..COUNT {
+//                 s1.send(i).unwrap();
+//                 r3.recv().unwrap();
+
+//                 s2.send(i).unwrap();
+//                 r3.recv().unwrap();
+//             }
+//         });
+
+//         for i in 0..COUNT {
+//             for _ in 0..2 {
+//                 select! {
+//                     recv(r1) -> v => assert_eq!(v, Ok(i)),
+//                     recv(r2) -> v => assert_eq!(v, Ok(i)),
+//                 }
+
+//                 s3.send(()).unwrap();
+//             }
+//         }
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn stress_send() {
+//     const COUNT: usize = 10_000;
+
+//     let (s1, r1) = bounded(0);
+//     let (s2, r2) = bounded(0);
+//     let (s3, r3) = bounded(100);
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             for i in 0..COUNT {
+//                 assert_eq!(r1.recv().unwrap(), i);
+//                 assert_eq!(r2.recv().unwrap(), i);
+//                 r3.recv().unwrap();
+//             }
+//         });
+
+//         for i in 0..COUNT {
+//             for _ in 0..2 {
+//                 select! {
+//                     send(s1, i) -> _ => {},
+//                     send(s2, i) -> _ => {},
+//                 }
+//             }
+//             s3.send(()).unwrap();
+//         }
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn stress_mixed() {
+//     const COUNT: usize = 10_000;
+
+//     let (s1, r1) = bounded(0);
+//     let (s2, r2) = bounded(0);
+//     let (s3, r3) = bounded(100);
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             for i in 0..COUNT {
+//                 s1.send(i).unwrap();
+//                 assert_eq!(r2.recv().unwrap(), i);
+//                 r3.recv().unwrap();
+//             }
+//         });
+
+//         for i in 0..COUNT {
+//             for _ in 0..2 {
+//                 select! {
+//                     recv(r1) -> v => assert_eq!(v, Ok(i)),
+//                     send(s2, i) -> _ => {},
+//                 }
+//             }
+//             s3.send(()).unwrap();
+//         }
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn stress_timeout_two_threads() {
+//     const COUNT: usize = 20;
+
+//     let (s, r) = bounded(2);
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             for i in 0..COUNT {
+//                 if i % 2 == 0 {
+//                     thread::sleep(ms(500));
+//                 }
+
+//                 loop {
+//                     select! {
+//                         send(s, i) -> _ => break,
+//                         default(ms(100)) => {}
+//                     }
+//                 }
+//             }
+//         });
+
+//         scope.spawn(|_| {
+//             for i in 0..COUNT {
+//                 if i % 2 == 0 {
+//                     thread::sleep(ms(500));
+//                 }
+
+//                 loop {
+//                     select! {
+//                         recv(r) -> v => {
+//                             assert_eq!(v, Ok(i));
+//                             break;
+//                         }
+//                         default(ms(100)) => {}
+//                     }
+//                 }
+//             }
+//         });
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn send_recv_same_channel() {
+//     let (s, r) = bounded::<i32>(0);
+//     select! {
+//         send(s, 0) -> _ => panic!(),
+//         recv(r) -> _ => panic!(),
+//         default(ms(500)) => {}
+//     }
+
+//     let (s, r) = unbounded::<i32>();
+//     select! {
+//         send(s, 0) -> _ => {},
+//         recv(r) -> _ => panic!(),
+//         default(ms(500)) => panic!(),
+//     }
+// }
+
+// #[test]
+// fn matching() {
+//     const THREADS: usize = 44;
+
+//     let (s, r) = &bounded::<usize>(0);
+
+//     scope(|scope| {
+//         for i in 0..THREADS {
+//             scope.spawn(move |_| {
+//                 select! {
+//                     recv(r) -> v => assert_ne!(v.unwrap(), i),
+//                     send(s, i) -> _ => {},
+//                 }
+//             });
+//         }
+//     })
+//     .unwrap();
+
+//     assert_eq!(r.try_recv(), Err(TryRecvError::Empty));
+// }
+
+// #[test]
+// fn matching_with_leftover() {
+//     const THREADS: usize = 55;
+
+//     let (s, r) = &bounded::<usize>(0);
+
+//     scope(|scope| {
+//         for i in 0..THREADS {
+//             scope.spawn(move |_| {
+//                 select! {
+//                     recv(r) -> v => assert_ne!(v.unwrap(), i),
+//                     send(s, i) -> _ => {},
+//                 }
+//             });
+//         }
+//         s.send(!0).unwrap();
+//     })
+//     .unwrap();
+
+//     assert_eq!(r.try_recv(), Err(TryRecvError::Empty));
+// }
+
+// #[test]
+// fn channel_through_channel() {
+//     const COUNT: usize = 1000;
+
+//     type T = Box<dyn Any + Send>;
+
+//     for cap in 0..3 {
+//         let (s, r) = bounded::<T>(cap);
+
+//         scope(|scope| {
+//             scope.spawn(move |_| {
+//                 let mut s = s;
+
+//                 for _ in 0..COUNT {
+//                     let (new_s, new_r) = bounded(cap);
+//                     let new_r: T = Box::new(Some(new_r));
+
+//                     select! {
+//                         send(s, new_r) -> _ => {}
+//                     }
+
+//                     s = new_s;
+//                 }
+//             });
+
+//             scope.spawn(move |_| {
+//                 let mut r = r;
+
+//                 for _ in 0..COUNT {
+//                     r = select! {
+//                         recv(r) -> msg => {
+//                             msg.unwrap()
+//                                 .downcast_mut::<Option<Receiver<T>>>()
+//                                 .unwrap()
+//                                 .take()
+//                                 .unwrap()
+//                         }
+//                     }
+//                 }
+//             });
+//         })
+//         .unwrap();
+//     }
+// }
+
+// #[test]
+// fn linearizable_default() {
+//     const COUNT: usize = 100_000;
+
+//     for step in 0..2 {
+//         let (start_s, start_r) = bounded::<()>(0);
+//         let (end_s, end_r) = bounded::<()>(0);
+
+//         let ((s1, r1), (s2, r2)) = if step == 0 {
+//             (bounded::<i32>(1), bounded::<i32>(1))
+//         } else {
+//             (unbounded::<i32>(), unbounded::<i32>())
+//         };
+
+//         scope(|scope| {
+//             scope.spawn(|_| {
+//                 for _ in 0..COUNT {
+//                     start_s.send(()).unwrap();
+
+//                     s1.send(1).unwrap();
+//                     select! {
+//                         recv(r1) -> _ => {}
+//                         recv(r2) -> _ => {}
+//                         default => unreachable!()
+//                     }
+
+//                     end_s.send(()).unwrap();
+//                     let _ = r2.try_recv();
+//                 }
+//             });
+
+//             for _ in 0..COUNT {
+//                 start_r.recv().unwrap();
+
+//                 s2.send(1).unwrap();
+//                 let _ = r1.try_recv();
+
+//                 end_r.recv().unwrap();
+//             }
+//         })
+//         .unwrap();
+//     }
+// }
+
+// #[test]
+// fn linearizable_timeout() {
+//     const COUNT: usize = 100_000;
+
+//     for step in 0..2 {
+//         let (start_s, start_r) = bounded::<()>(0);
+//         let (end_s, end_r) = bounded::<()>(0);
+
+//         let ((s1, r1), (s2, r2)) = if step == 0 {
+//             (bounded::<i32>(1), bounded::<i32>(1))
+//         } else {
+//             (unbounded::<i32>(), unbounded::<i32>())
+//         };
+
+//         scope(|scope| {
+//             scope.spawn(|_| {
+//                 for _ in 0..COUNT {
+//                     start_s.send(()).unwrap();
+
+//                     s1.send(1).unwrap();
+//                     select! {
+//                         recv(r1) -> _ => {}
+//                         recv(r2) -> _ => {}
+//                         default(ms(0)) => unreachable!()
+//                     }
+
+//                     end_s.send(()).unwrap();
+//                     let _ = r2.try_recv();
+//                 }
+//             });
+
+//             for _ in 0..COUNT {
+//                 start_r.recv().unwrap();
+
+//                 s2.send(1).unwrap();
+//                 let _ = r1.try_recv();
+
+//                 end_r.recv().unwrap();
+//             }
+//         })
+//         .unwrap();
+//     }
+// }
+
+// #[test]
+// fn fairness1() {
+//     const COUNT: usize = 10_000;
+
+//     let (s1, r1) = bounded::<()>(COUNT);
+//     let (s2, r2) = unbounded::<()>();
+
+//     for _ in 0..COUNT {
+//         s1.send(()).unwrap();
+//         s2.send(()).unwrap();
+//     }
+
+//     let mut hits = [0usize; 4];
+//     for _ in 0..COUNT {
+//         select! {
+//             recv(r1) -> _ => hits[0] += 1,
+//             recv(r2) -> _ => hits[1] += 1,
+//             recv(after(ms(0))) -> _ => hits[2] += 1,
+//             recv(tick(ms(0))) -> _ => hits[3] += 1,
+//         }
+//     }
+//     assert!(hits.iter().all(|x| *x >= COUNT / hits.len() / 2));
+// }
+
+// #[test]
+// fn fairness2() {
+//     const COUNT: usize = 10_000;
+
+//     let (s1, r1) = unbounded::<()>();
+//     let (s2, r2) = bounded::<()>(1);
+//     let (s3, r3) = bounded::<()>(0);
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             let (hole, _r) = bounded(0);
+
+//             for _ in 0..COUNT {
+//                 let s1 = if s1.is_empty() { &s1 } else { &hole };
+//                 let s2 = if s2.is_empty() { &s2 } else { &hole };
+
+//                 select! {
+//                     send(s1, ()) -> res => assert!(res.is_ok()),
+//                     send(s2, ()) -> res => assert!(res.is_ok()),
+//                     send(s3, ()) -> res => assert!(res.is_ok()),
+//                 }
+//             }
+//         });
+
+//         let hits = vec![Cell::new(0usize); 3];
+//         for _ in 0..COUNT {
+//             select! {
+//                 recv(r1) -> _ => hits[0].set(hits[0].get() + 1),
+//                 recv(r2) -> _ => hits[1].set(hits[1].get() + 1),
+//                 recv(r3) -> _ => hits[2].set(hits[2].get() + 1),
+//             }
+//         }
+//         assert!(hits.iter().all(|x| x.get() >= COUNT / hits.len() / 50));
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn fairness_recv() {
+//     const COUNT: usize = 10_000;
+
+//     let (s1, r1) = bounded::<()>(COUNT);
+//     let (s2, r2) = unbounded::<()>();
+
+//     for _ in 0..COUNT {
+//         s1.send(()).unwrap();
+//         s2.send(()).unwrap();
+//     }
+
+//     let mut hits = [0usize; 2];
+//     while hits[0] + hits[1] < COUNT {
+//         select! {
+//             recv(r1) -> _ => hits[0] += 1,
+//             recv(r2) -> _ => hits[1] += 1,
+//         }
+//     }
+//     assert!(hits.iter().all(|x| *x >= COUNT / 4));
+// }
+
+// #[test]
+// fn fairness_send() {
+//     const COUNT: usize = 10_000;
+
+//     let (s1, _r1) = bounded::<()>(COUNT);
+//     let (s2, _r2) = unbounded::<()>();
+
+//     let mut hits = [0usize; 2];
+//     for _ in 0..COUNT {
+//         select! {
+//             send(s1, ()) -> _ => hits[0] += 1,
+//             send(s2, ()) -> _ => hits[1] += 1,
+//         }
+//     }
+//     assert!(hits.iter().all(|x| *x >= COUNT / 4));
+// }
+
+// #[test]
+// fn references() {
+//     let (s, r) = unbounded::<i32>();
+//     select! {
+//         send(s, 0) -> _ => {}
+//         recv(r) -> _ => {}
+//     }
+//     select! {
+//         send(&&&&s, 0) -> _ => {}
+//         recv(&&&&r) -> _ => {}
+//     }
+//     select! {
+//         recv(Some(&r).unwrap_or(&never())) -> _ => {},
+//         default => {}
+//     }
+//     select! {
+//         recv(Some(r).unwrap_or(never())) -> _ => {},
+//         default => {}
+//     }
+// }
+
+// #[test]
+// fn case_blocks() {
+//     let (s, r) = unbounded::<i32>();
+
+//     select! {
+//         recv(r) -> _ => 3.0,
+//         recv(r) -> _ => loop {
+//             unreachable!()
+//         },
+//         recv(r) -> _ => match 7 + 3 {
+//             _ => unreachable!()
+//         },
+//         default => 7.
+//     };
+
+//     select! {
+//         recv(r) -> msg => if msg.is_ok() {
+//             unreachable!()
+//         },
+//         default => ()
+//     }
+
+//     drop(s);
+// }
+
+// #[test]
+// fn move_handles() {
+//     let (s, r) = unbounded::<i32>();
+//     select! {
+//         recv((move || r)()) -> _ => {}
+//         send((move || s)(), 0) -> _ => {}
+//     }
+// }
+
+// #[test]
+// fn infer_types() {
+//     let (s, r) = unbounded();
+//     select! {
+//         recv(r) -> _ => {}
+//         default => {}
+//     }
+//     s.send(()).unwrap();
+
+//     let (s, r) = unbounded();
+//     select! {
+//         send(s, ()) -> _ => {}
+//     }
+//     r.recv().unwrap();
+// }
+
+// #[test]
+// fn default_syntax() {
+//     let (s, r) = bounded::<i32>(0);
+
+//     select! {
+//         recv(r) -> _ => panic!(),
+//         default => {}
+//     }
+//     select! {
+//         send(s, 0) -> _ => panic!(),
+//         default() => {}
+//     }
+//     select! {
+//         default => {}
+//     }
+//     select! {
+//         default() => {}
+//     }
+// }
+
+// #[test]
+// fn same_variable_name() {
+//     let (_, r) = unbounded::<i32>();
+//     select! {
+//         recv(r) -> r => assert!(r.is_err()),
+//     }
+// }
+
+// #[test]
+// fn handles_on_heap() {
+//     let (s, r) = unbounded::<i32>();
+//     let (s, r) = (Box::new(s), Box::new(r));
+
+//     select! {
+//         send(*s, 0) -> _ => {}
+//         recv(*r) -> _ => {}
+//         default => {}
+//     }
+
+//     drop(s);
+//     drop(r);
+// }
+
+// #[test]
+// fn once_blocks() {
+//     let (s, r) = unbounded::<i32>();
+
+//     let once = Box::new(());
+//     select! {
+//         send(s, 0) -> _ => drop(once),
+//     }
+
+//     let once = Box::new(());
+//     select! {
+//         recv(r) -> _ => drop(once),
+//     }
+
+//     let once1 = Box::new(());
+//     let once2 = Box::new(());
+//     select! {
+//         send(s, 0) -> _ => drop(once1),
+//         default => drop(once2),
+//     }
+
+//     let once1 = Box::new(());
+//     let once2 = Box::new(());
+//     select! {
+//         recv(r) -> _ => drop(once1),
+//         default => drop(once2),
+//     }
+
+//     let once1 = Box::new(());
+//     let once2 = Box::new(());
+//     select! {
+//         recv(r) -> _ => drop(once1),
+//         send(s, 0) -> _ => drop(once2),
+//     }
+// }
+
+// #[test]
+// fn once_receiver() {
+//     let (_, r) = unbounded::<i32>();
+
+//     let once = Box::new(());
+//     let get = move || {
+//         drop(once);
+//         r
+//     };
+
+//     select! {
+//         recv(get()) -> _ => {}
+//     }
+// }
+
+// #[test]
+// fn once_sender() {
+//     let (s, _) = unbounded::<i32>();
+
+//     let once = Box::new(());
+//     let get = move || {
+//         drop(once);
+//         s
+//     };
+
+//     select! {
+//         send(get(), 5) -> _ => {}
+//     }
+// }
+
+// #[test]
+// fn parse_nesting() {
+//     let (_, r) = unbounded::<i32>();
+
+//     select! {
+//         recv(r) -> _ => {}
+//         recv(r) -> _ => {
+//             select! {
+//                 recv(r) -> _ => {}
+//                 recv(r) -> _ => {
+//                     select! {
+//                         recv(r) -> _ => {}
+//                         recv(r) -> _ => {
+//                             select! {
+//                                 default => {}
+//                             }
+//                         }
+//                     }
+//                 }
+//             }
+//         }
+//     }
+// }
+
+// #[test]
+// fn evaluate() {
+//     let (s, r) = unbounded::<i32>();
+
+//     let v = select! {
+//         recv(r) -> _ => "foo".into(),
+//         send(s, 0) -> _ => "bar".to_owned(),
+//         default => "baz".to_string(),
+//     };
+//     assert_eq!(v, "bar");
+
+//     let v = select! {
+//         recv(r) -> _ => "foo".into(),
+//         default => "baz".to_string(),
+//     };
+//     assert_eq!(v, "foo");
+
+//     let v = select! {
+//         recv(r) -> _ => "foo".into(),
+//         default => "baz".to_string(),
+//     };
+//     assert_eq!(v, "baz");
+// }
+
+// #[test]
+// fn deref() {
+//     use crossbeam_channel as cc;
+
+//     struct Sender<T>(cc::Sender<T>);
+//     struct Receiver<T>(cc::Receiver<T>);
+
+//     impl<T> Deref for Receiver<T> {
+//         type Target = cc::Receiver<T>;
+
+//         fn deref(&self) -> &Self::Target {
+//             &self.0
+//         }
+//     }
+
+//     impl<T> Deref for Sender<T> {
+//         type Target = cc::Sender<T>;
+
+//         fn deref(&self) -> &Self::Target {
+//             &self.0
+//         }
+//     }
+
+//     let (s, r) = bounded::<i32>(0);
+//     let (s, r) = (Sender(s), Receiver(r));
+
+//     select! {
+//         send(s, 0) -> _ => panic!(),
+//         recv(r) -> _ => panic!(),
+//         default => {}
+//     }
+// }
+
+// #[test]
+// fn result_types() {
+//     let (s, _) = bounded::<i32>(0);
+//     let (_, r) = bounded::<i32>(0);
+
+//     select! {
+//         recv(r) -> res => drop::<Result<i32, RecvError>>(res),
+//     }
+//     select! {
+//         recv(r) -> res => drop::<Result<i32, RecvError>>(res),
+//         default => {}
+//     }
+//     select! {
+//         recv(r) -> res => drop::<Result<i32, RecvError>>(res),
+//         default(ms(0)) => {}
+//     }
+
+//     select! {
+//         send(s, 0) -> res => drop::<Result<(), SendError<i32>>>(res),
+//     }
+//     select! {
+//         send(s, 0) -> res => drop::<Result<(), SendError<i32>>>(res),
+//         default => {}
+//     }
+//     select! {
+//         send(s, 0) -> res => drop::<Result<(), SendError<i32>>>(res),
+//         default(ms(0)) => {}
+//     }
+
+//     select! {
+//         send(s, 0) -> res => drop::<Result<(), SendError<i32>>>(res),
+//         recv(r) -> res => drop::<Result<i32, RecvError>>(res),
+//     }
+// }
+
+// #[test]
+// fn try_recv() {
+//     let (s, r) = bounded(0);
+
+//     scope(|scope| {
+//         scope.spawn(move |_| {
+//             select! {
+//                 recv(r) -> _ => panic!(),
+//                 default => {}
+//             }
+//             thread::sleep(ms(1500));
+//             select! {
+//                 recv(r) -> v => assert_eq!(v, Ok(7)),
+//                 default => panic!(),
+//             }
+//             thread::sleep(ms(500));
+//             select! {
+//                 recv(r) -> v => assert_eq!(v, Err(RecvError)),
+//                 default => panic!(),
+//             }
+//         });
+//         scope.spawn(move |_| {
+//             thread::sleep(ms(1000));
+//             select! {
+//                 send(s, 7) -> res => res.unwrap(),
+//             }
+//         });
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn recv() {
+//     let (s, r) = bounded(0);
+
+//     scope(|scope| {
+//         scope.spawn(move |_| {
+//             select! {
+//                 recv(r) -> v => assert_eq!(v, Ok(7)),
+//             }
+//             thread::sleep(ms(1000));
+//             select! {
+//                 recv(r) -> v => assert_eq!(v, Ok(8)),
+//             }
+//             thread::sleep(ms(1000));
+//             select! {
+//                 recv(r) -> v => assert_eq!(v, Ok(9)),
+//             }
+//             select! {
+//                 recv(r) -> v => assert_eq!(v, Err(RecvError)),
+//             }
+//         });
+//         scope.spawn(move |_| {
+//             thread::sleep(ms(1500));
+//             select! {
+//                 send(s, 7) -> res => res.unwrap(),
+//             }
+//             select! {
+//                 send(s, 8) -> res => res.unwrap(),
+//             }
+//             select! {
+//                 send(s, 9) -> res => res.unwrap(),
+//             }
+//         });
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn recv_timeout() {
+//     let (s, r) = bounded::<i32>(0);
+
+//     scope(|scope| {
+//         scope.spawn(move |_| {
+//             select! {
+//                 recv(r) -> _ => panic!(),
+//                 default(ms(1000)) => {}
+//             }
+//             select! {
+//                 recv(r) -> v => assert_eq!(v, Ok(7)),
+//                 default(ms(1000)) => panic!(),
+//             }
+//             select! {
+//                 recv(r) -> v => assert_eq!(v, Err(RecvError)),
+//                 default(ms(1000)) => panic!(),
+//             }
+//         });
+//         scope.spawn(move |_| {
+//             thread::sleep(ms(1500));
+//             select! {
+//                 send(s, 7) -> res => res.unwrap(),
+//             }
+//         });
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn try_send() {
+//     let (s, r) = bounded(0);
+
+//     scope(|scope| {
+//         scope.spawn(move |_| {
+//             select! {
+//                 send(s, 7) -> _ => panic!(),
+//                 default => {}
+//             }
+//             thread::sleep(ms(1500));
+//             select! {
+//                 send(s, 8) -> res => res.unwrap(),
+//                 default => panic!(),
+//             }
+//             thread::sleep(ms(500));
+//             select! {
+//                 send(s, 8) -> res => assert_eq!(res, Err(SendError(8))),
+//                 default => panic!(),
+//             }
+//         });
+//         scope.spawn(move |_| {
+//             thread::sleep(ms(1000));
+//             select! {
+//                 recv(r) -> v => assert_eq!(v, Ok(8)),
+//             }
+//         });
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn send() {
+//     let (s, r) = bounded(0);
+
+//     scope(|scope| {
+//         scope.spawn(move |_| {
+//             select! {
+//                 send(s, 7) -> res => res.unwrap(),
+//             }
+//             thread::sleep(ms(1000));
+//             select! {
+//                 send(s, 8) -> res => res.unwrap(),
+//             }
+//             thread::sleep(ms(1000));
+//             select! {
+//                 send(s, 9) -> res => res.unwrap(),
+//             }
+//         });
+//         scope.spawn(move |_| {
+//             thread::sleep(ms(1500));
+//             select! {
+//                 recv(r) -> v => assert_eq!(v, Ok(7)),
+//             }
+//             select! {
+//                 recv(r) -> v => assert_eq!(v, Ok(8)),
+//             }
+//             select! {
+//                 recv(r) -> v => assert_eq!(v, Ok(9)),
+//             }
+//         });
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn send_timeout() {
+//     let (s, r) = bounded(0);
+
+//     scope(|scope| {
+//         scope.spawn(move |_| {
+//             select! {
+//                 send(s, 7) -> _ => panic!(),
+//                 default(ms(1000)) => {}
+//             }
+//             select! {
+//                 send(s, 8) -> res => res.unwrap(),
+//                 default(ms(1000)) => panic!(),
+//             }
+//             select! {
+//                 send(s, 9) -> res => assert_eq!(res, Err(SendError(9))),
+//                 default(ms(1000)) => panic!(),
+//             }
+//         });
+//         scope.spawn(move |_| {
+//             thread::sleep(ms(1500));
+//             select! {
+//                 recv(r) -> v => assert_eq!(v, Ok(8)),
+//             }
+//         });
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn disconnect_wakes_sender() {
+//     let (s, r) = bounded(0);
+
+//     scope(|scope| {
+//         scope.spawn(move |_| {
+//             select! {
+//                 send(s, ()) -> res => assert_eq!(res, Err(SendError(()))),
+//             }
+//         });
+//         scope.spawn(move |_| {
+//             thread::sleep(ms(1000));
+//             drop(r);
+//         });
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn disconnect_wakes_receiver() {
+//     let (s, r) = bounded::<()>(0);
+
+//     scope(|scope| {
+//         scope.spawn(move |_| {
+//             select! {
+//                 recv(r) -> res => assert_eq!(res, Err(RecvError)),
+//             }
+//         });
+//         scope.spawn(move |_| {
+//             thread::sleep(ms(1000));
+//             drop(s);
+//         });
+//     })
+//     .unwrap();
+// }
-- 
cgit v1.2.3