Initial vendor packages

Signed-off-by: Valentin Popov <valentin@popov.link>

1 files changed, 1304 insertions, 0 deletions

diff --git a/vendor/flume/tests/select.rs b/vendor/flume/tests/select.rs
new file mode 100644
index 0000000..4fac9e9
--- /dev/null
+++ b/vendor/flume/tests/select.rs
@@ -0,0 +1,1304 @@
+// //! Tests for channel selection using the `Select` struct.
+
+// extern crate crossbeam_channel;
+// extern crate crossbeam_utils;
+
+// use std::any::Any;
+// use std::cell::Cell;
+// use std::thread;
+// use std::time::{Duration, Instant};
+
+// use crossbeam_channel::{after, bounded, tick, unbounded, Receiver, Select, 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();
+
+//     let mut sel = Select::new();
+//     let oper1 = sel.recv(&r1);
+//     let oper2 = sel.recv(&r2);
+//     let oper = sel.select();
+//     match oper.index() {
+//         i if i == oper1 => assert_eq!(oper.recv(&r1), Ok(1)),
+//         i if i == oper2 => panic!(),
+//         _ => unreachable!(),
+//     }
+
+//     s2.send(2).unwrap();
+
+//     let mut sel = Select::new();
+//     let oper1 = sel.recv(&r1);
+//     let oper2 = sel.recv(&r2);
+//     let oper = sel.select();
+//     match oper.index() {
+//         i if i == oper1 => panic!(),
+//         i if i == oper2 => assert_eq!(oper.recv(&r2), Ok(2)),
+//         _ => unreachable!(),
+//     }
+// }
+
+// #[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();
+
+//     let mut sel = Select::new();
+//     let oper1 = sel.recv(&r1);
+//     let oper2 = sel.recv(&r2);
+//     let oper3 = sel.recv(&r3);
+//     let oper4 = sel.recv(&r4);
+//     let oper5 = sel.recv(&r5);
+//     let oper = sel.select();
+//     match oper.index() {
+//         i if i == oper1 => panic!(),
+//         i if i == oper2 => panic!(),
+//         i if i == oper3 => panic!(),
+//         i if i == oper4 => panic!(),
+//         i if i == oper5 => assert_eq!(oper.recv(&r5), Ok(5)),
+//         _ => unreachable!(),
+//     }
+// }
+
+// #[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();
+//         });
+
+//         let mut sel = Select::new();
+//         let oper1 = sel.recv(&r1);
+//         let oper2 = sel.recv(&r2);
+//         let oper = sel.select_timeout(ms(1000));
+//         match oper {
+//             Err(_) => panic!(),
+//             Ok(oper) => match oper.index() {
+//                 i if i == oper1 => assert!(oper.recv(&r1).is_err()),
+//                 i if i == oper2 => panic!(),
+//                 _ => unreachable!(),
+//             },
+//         }
+
+//         r2.recv().unwrap();
+//     })
+//     .unwrap();
+
+//     let mut sel = Select::new();
+//     let oper1 = sel.recv(&r1);
+//     let oper2 = sel.recv(&r2);
+//     let oper = sel.select_timeout(ms(1000));
+//     match oper {
+//         Err(_) => panic!(),
+//         Ok(oper) => match oper.index() {
+//             i if i == oper1 => assert!(oper.recv(&r1).is_err()),
+//             i if i == oper2 => panic!(),
+//             _ => unreachable!(),
+//         },
+//     }
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             thread::sleep(ms(500));
+//             drop(s2);
+//         });
+
+//         let mut sel = Select::new();
+//         let oper1 = sel.recv(&r2);
+//         let oper = sel.select_timeout(ms(1000));
+//         match oper {
+//             Err(_) => panic!(),
+//             Ok(oper) => match oper.index() {
+//                 i if i == oper1 => assert!(oper.recv(&r2).is_err()),
+//                 _ => unreachable!(),
+//             },
+//         }
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn default() {
+//     let (s1, r1) = unbounded::<i32>();
+//     let (s2, r2) = unbounded::<i32>();
+
+//     let mut sel = Select::new();
+//     let _oper1 = sel.recv(&r1);
+//     let _oper2 = sel.recv(&r2);
+//     let oper = sel.try_select();
+//     match oper {
+//         Err(_) => {}
+//         Ok(_) => panic!(),
+//     }
+
+//     drop(s1);
+
+//     let mut sel = Select::new();
+//     let oper1 = sel.recv(&r1);
+//     let oper2 = sel.recv(&r2);
+//     let oper = sel.try_select();
+//     match oper {
+//         Err(_) => panic!(),
+//         Ok(oper) => match oper.index() {
+//             i if i == oper1 => assert!(oper.recv(&r1).is_err()),
+//             i if i == oper2 => panic!(),
+//             _ => unreachable!(),
+//         },
+//     }
+
+//     s2.send(2).unwrap();
+
+//     let mut sel = Select::new();
+//     let oper1 = sel.recv(&r2);
+//     let oper = sel.try_select();
+//     match oper {
+//         Err(_) => panic!(),
+//         Ok(oper) => match oper.index() {
+//             i if i == oper1 => assert_eq!(oper.recv(&r2), Ok(2)),
+//             _ => unreachable!(),
+//         },
+//     }
+
+//     let mut sel = Select::new();
+//     let _oper1 = sel.recv(&r2);
+//     let oper = sel.try_select();
+//     match oper {
+//         Err(_) => {}
+//         Ok(_) => panic!(),
+//     }
+
+//     let mut sel = Select::new();
+//     let oper = sel.try_select();
+//     match oper {
+//         Err(_) => {}
+//         Ok(_) => panic!(),
+//     }
+// }
+
+// #[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();
+//         });
+
+//         let mut sel = Select::new();
+//         let oper1 = sel.recv(&r1);
+//         let oper2 = sel.recv(&r2);
+//         let oper = sel.select_timeout(ms(1000));
+//         match oper {
+//             Err(_) => {}
+//             Ok(oper) => match oper.index() {
+//                 i if i == oper1 => panic!(),
+//                 i if i == oper2 => panic!(),
+//                 _ => unreachable!(),
+//             },
+//         }
+
+//         let mut sel = Select::new();
+//         let oper1 = sel.recv(&r1);
+//         let oper2 = sel.recv(&r2);
+//         let oper = sel.select_timeout(ms(1000));
+//         match oper {
+//             Err(_) => panic!(),
+//             Ok(oper) => match oper.index() {
+//                 i if i == oper1 => panic!(),
+//                 i if i == oper2 => assert_eq!(oper.recv(&r2), Ok(2)),
+//                 _ => unreachable!(),
+//             },
+//         }
+//     })
+//     .unwrap();
+
+//     scope(|scope| {
+//         let (s, r) = unbounded::<i32>();
+
+//         scope.spawn(move |_| {
+//             thread::sleep(ms(500));
+//             drop(s);
+//         });
+
+//         let mut sel = Select::new();
+//         let oper = sel.select_timeout(ms(1000));
+//         match oper {
+//             Err(_) => {
+//                 let mut sel = Select::new();
+//                 let oper1 = sel.recv(&r);
+//                 let oper = sel.try_select();
+//                 match oper {
+//                     Err(_) => panic!(),
+//                     Ok(oper) => match oper.index() {
+//                         i if i == oper1 => assert!(oper.recv(&r).is_err()),
+//                         _ => unreachable!(),
+//                     },
+//                 }
+//             }
+//             Ok(_) => unreachable!(),
+//         }
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn default_when_disconnected() {
+//     let (_, r) = unbounded::<i32>();
+
+//     let mut sel = Select::new();
+//     let oper1 = sel.recv(&r);
+//     let oper = sel.try_select();
+//     match oper {
+//         Err(_) => panic!(),
+//         Ok(oper) => match oper.index() {
+//             i if i == oper1 => assert!(oper.recv(&r).is_err()),
+//             _ => unreachable!(),
+//         },
+//     }
+
+//     let (_, r) = unbounded::<i32>();
+
+//     let mut sel = Select::new();
+//     let oper1 = sel.recv(&r);
+//     let oper = sel.select_timeout(ms(1000));
+//     match oper {
+//         Err(_) => panic!(),
+//         Ok(oper) => match oper.index() {
+//             i if i == oper1 => assert!(oper.recv(&r).is_err()),
+//             _ => unreachable!(),
+//         },
+//     }
+
+//     let (s, _) = bounded::<i32>(0);
+
+//     let mut sel = Select::new();
+//     let oper1 = sel.send(&s);
+//     let oper = sel.try_select();
+//     match oper {
+//         Err(_) => panic!(),
+//         Ok(oper) => match oper.index() {
+//             i if i == oper1 => assert!(oper.send(&s, 0).is_err()),
+//             _ => unreachable!(),
+//         },
+//     }
+
+//     let (s, _) = bounded::<i32>(0);
+
+//     let mut sel = Select::new();
+//     let oper1 = sel.send(&s);
+//     let oper = sel.select_timeout(ms(1000));
+//     match oper {
+//         Err(_) => panic!(),
+//         Ok(oper) => match oper.index() {
+//             i if i == oper1 => assert!(oper.send(&s, 0).is_err()),
+//             _ => unreachable!(),
+//         },
+//     }
+// }
+
+// #[test]
+// fn default_only() {
+//     let start = Instant::now();
+
+//     let mut sel = Select::new();
+//     let oper = sel.try_select();
+//     assert!(oper.is_err());
+//     let now = Instant::now();
+//     assert!(now - start <= ms(50));
+
+//     let start = Instant::now();
+//     let mut sel = Select::new();
+//     let oper = sel.select_timeout(ms(500));
+//     assert!(oper.is_err());
+//     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();
+//         });
+
+//         let mut sel = Select::new();
+//         let oper1 = sel.recv(&r1);
+//         let oper2 = sel.recv(&r2);
+//         let oper = sel.select_timeout(ms(1000));
+//         match oper {
+//             Err(_) => panic!(),
+//             Ok(oper) => match oper.index() {
+//                 i if i == oper1 => panic!(),
+//                 i if i == oper2 => assert_eq!(oper.recv(&r2), Ok(2)),
+//                 _ => unreachable!(),
+//             },
+//         }
+//     })
+//     .unwrap();
+
+//     scope(|scope| {
+//         scope.spawn(|_| {
+//             thread::sleep(ms(500));
+//             assert_eq!(r1.recv().unwrap(), 1);
+//         });
+
+//         let mut sel = Select::new();
+//         let oper1 = sel.send(&s1);
+//         let oper2 = sel.send(&s2);
+//         let oper = sel.select_timeout(ms(1000));
+//         match oper {
+//             Err(_) => panic!(),
+//             Ok(oper) => match oper.index() {
+//                 i if i == oper1 => oper.send(&s1, 1).unwrap(),
+//                 i if i == oper2 => panic!(),
+//                 _ => unreachable!(),
+//             },
+//         }
+//     })
+//     .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 {
+//             let mut sel = Select::new();
+//             let oper1 = sel.recv(&r1);
+//             let oper2 = sel.send(&s2);
+//             let oper = sel.select();
+//             match oper.index() {
+//                 i if i == oper1 => assert_eq!(oper.recv(&r1), Ok(1)),
+//                 i if i == oper2 => oper.send(&s2, 2).unwrap(),
+//                 _ => unreachable!(),
+//             }
+//         }
+//     })
+//     .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 {
+//                 let mut done = false;
+
+//                 let mut sel = Select::new();
+//                 let oper1 = sel.send(&s1);
+//                 let oper = sel.try_select();
+//                 match oper {
+//                     Err(_) => {}
+//                     Ok(oper) => match oper.index() {
+//                         i if i == oper1 => {
+//                             let _ = oper.send(&s1, 1);
+//                             done = true;
+//                         }
+//                         _ => unreachable!(),
+//                     },
+//                 }
+//                 if done {
+//                     break;
+//                 }
+
+//                 let mut sel = Select::new();
+//                 let oper1 = sel.recv(&r_end);
+//                 let oper = sel.try_select();
+//                 match oper {
+//                     Err(_) => {}
+//                     Ok(oper) => match oper.index() {
+//                         i if i == oper1 => {
+//                             let _ = oper.recv(&r_end);
+//                             done = true;
+//                         }
+//                         _ => unreachable!(),
+//                     },
+//                 }
+//                 if done {
+//                     break;
+//                 }
+//             });
+
+//             scope.spawn(|_| loop {
+//                 if let Ok(x) = r2.try_recv() {
+//                     assert_eq!(x, 2);
+//                     break;
+//                 }
+
+//                 let mut done = false;
+//                 let mut sel = Select::new();
+//                 let oper1 = sel.recv(&r_end);
+//                 let oper = sel.try_select();
+//                 match oper {
+//                     Err(_) => {}
+//                     Ok(oper) => match oper.index() {
+//                         i if i == oper1 => {
+//                             let _ = oper.recv(&r_end);
+//                             done = true;
+//                         }
+//                         _ => unreachable!(),
+//                     },
+//                 }
+//                 if done {
+//                     break;
+//                 }
+//             });
+
+//             scope.spawn(|_| {
+//                 thread::sleep(ms(500));
+
+//                 let mut sel = Select::new();
+//                 let oper1 = sel.recv(&r1);
+//                 let oper2 = sel.send(&s2);
+//                 let oper = sel.select_timeout(ms(1000));
+//                 match oper {
+//                     Err(_) => {}
+//                     Ok(oper) => match oper.index() {
+//                         i if i == oper1 => assert_eq!(oper.recv(&r1), Ok(1)),
+//                         i if i == oper2 => assert!(oper.send(&s2, 2).is_ok()),
+//                         _ => unreachable!(),
+//                     },
+//                 }
+
+//                 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!(r3.try_recv().is_err());
+//             s1.send(1).unwrap();
+//             r3.recv().unwrap();
+//         });
+
+//         s3.send(()).unwrap();
+
+//         let mut sel = Select::new();
+//         let oper1 = sel.recv(&r1);
+//         let oper2 = sel.recv(&r2);
+//         let oper = sel.select();
+//         match oper.index() {
+//             i if i == oper1 => drop(oper.recv(&r1)),
+//             i if i == oper2 => drop(oper.recv(&r2)),
+//             _ => unreachable!(),
+//         }
+
+//         s3.send(()).unwrap();
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn cloning2() {
+//     let (s1, r1) = unbounded::<()>();
+//     let (s2, r2) = unbounded::<()>();
+//     let (_s3, _r3) = unbounded::<()>();
+
+//     scope(|scope| {
+//         scope.spawn(move |_| {
+//             let mut sel = Select::new();
+//             let oper1 = sel.recv(&r1);
+//             let oper2 = sel.recv(&r2);
+//             let oper = sel.select();
+//             match oper.index() {
+//                 i if i == oper1 => panic!(),
+//                 i if i == oper2 => drop(oper.recv(&r2)),
+//                 _ => unreachable!(),
+//             }
+//         });
+
+//         thread::sleep(ms(500));
+//         drop(s1.clone());
+//         s2.send(()).unwrap();
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn preflight1() {
+//     let (s, r) = unbounded();
+//     s.send(()).unwrap();
+
+//     let mut sel = Select::new();
+//     let oper1 = sel.recv(&r);
+//     let oper = sel.select();
+//     match oper.index() {
+//         i if i == oper1 => drop(oper.recv(&r)),
+//         _ => unreachable!(),
+//     }
+// }
+
+// #[test]
+// fn preflight2() {
+//     let (s, r) = unbounded();
+//     drop(s.clone());
+//     s.send(()).unwrap();
+//     drop(s);
+
+//     let mut sel = Select::new();
+//     let oper1 = sel.recv(&r);
+//     let oper = sel.select();
+//     match oper.index() {
+//         i if i == oper1 => assert_eq!(oper.recv(&r), Ok(())),
+//         _ => unreachable!(),
+//     }
+
+//     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();
+
+//     let mut sel = Select::new();
+//     let oper1 = sel.recv(&r);
+//     let oper = sel.select();
+//     match oper.index() {
+//         i if i == oper1 => assert!(oper.recv(&r).is_err()),
+//         _ => unreachable!(),
+//     }
+// }
+
+// #[test]
+// fn duplicate_operations() {
+//     let (s, r) = unbounded::<i32>();
+//     let hit = vec![Cell::new(false); 4];
+
+//     while hit.iter().map(|h| h.get()).any(|hit| !hit) {
+//         let mut sel = Select::new();
+//         let oper0 = sel.recv(&r);
+//         let oper1 = sel.recv(&r);
+//         let oper2 = sel.send(&s);
+//         let oper3 = sel.send(&s);
+//         let oper = sel.select();
+//         match oper.index() {
+//             i if i == oper0 => {
+//                 assert!(oper.recv(&r).is_ok());
+//                 hit[0].set(true);
+//             }
+//             i if i == oper1 => {
+//                 assert!(oper.recv(&r).is_ok());
+//                 hit[1].set(true);
+//             }
+//             i if i == oper2 => {
+//                 assert!(oper.send(&s, 0).is_ok());
+//                 hit[2].set(true);
+//             }
+//             i if i == oper3 => {
+//                 assert!(oper.send(&s, 0).is_ok());
+//                 hit[3].set(true);
+//             }
+//             _ => unreachable!(),
+//         }
+//     }
+// }
+
+// #[test]
+// fn nesting() {
+//     let (s, r) = unbounded::<i32>();
+
+//     let mut sel = Select::new();
+//     let oper1 = sel.send(&s);
+//     let oper = sel.select();
+//     match oper.index() {
+//         i if i == oper1 => {
+//             assert!(oper.send(&s, 0).is_ok());
+
+//             let mut sel = Select::new();
+//             let oper1 = sel.recv(&r);
+//             let oper = sel.select();
+//             match oper.index() {
+//                 i if i == oper1 => {
+//                     assert_eq!(oper.recv(&r), Ok(0));
+
+//                     let mut sel = Select::new();
+//                     let oper1 = sel.send(&s);
+//                     let oper = sel.select();
+//                     match oper.index() {
+//                         i if i == oper1 => {
+//                             assert!(oper.send(&s, 1).is_ok());
+
+//                             let mut sel = Select::new();
+//                             let oper1 = sel.recv(&r);
+//                             let oper = sel.select();
+//                             match oper.index() {
+//                                 i if i == oper1 => {
+//                                     assert_eq!(oper.recv(&r), Ok(1));
+//                                 }
+//                                 _ => unreachable!(),
+//                             }
+//                         }
+//                         _ => unreachable!(),
+//                     }
+//                 }
+//                 _ => unreachable!(),
+//             }
+//         }
+//         _ => unreachable!(),
+//     }
+// }
+
+// #[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 {
+//                 let mut sel = Select::new();
+//                 let oper1 = sel.recv(&r1);
+//                 let oper2 = sel.recv(&r2);
+//                 let oper = sel.select();
+//                 match oper.index() {
+//                     ix if ix == oper1 => assert_eq!(oper.recv(&r1), Ok(i)),
+//                     ix if ix == oper2 => assert_eq!(oper.recv(&r2), Ok(i)),
+//                     _ => unreachable!(),
+//                 }
+
+//                 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 {
+//                 let mut sel = Select::new();
+//                 let oper1 = sel.send(&s1);
+//                 let oper2 = sel.send(&s2);
+//                 let oper = sel.select();
+//                 match oper.index() {
+//                     ix if ix == oper1 => assert!(oper.send(&s1, i).is_ok()),
+//                     ix if ix == oper2 => assert!(oper.send(&s2, i).is_ok()),
+//                     _ => unreachable!(),
+//                 }
+//             }
+//             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 {
+//                 let mut sel = Select::new();
+//                 let oper1 = sel.recv(&r1);
+//                 let oper2 = sel.send(&s2);
+//                 let oper = sel.select();
+//                 match oper.index() {
+//                     ix if ix == oper1 => assert_eq!(oper.recv(&r1), Ok(i)),
+//                     ix if ix == oper2 => assert!(oper.send(&s2, i).is_ok()),
+//                     _ => unreachable!(),
+//                 }
+//             }
+//             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));
+//                 }
+
+//                 let done = false;
+//                 while !done {
+//                     let mut sel = Select::new();
+//                     let oper1 = sel.send(&s);
+//                     let oper = sel.select_timeout(ms(100));
+//                     match oper {
+//                         Err(_) => {}
+//                         Ok(oper) => match oper.index() {
+//                             ix if ix == oper1 => {
+//                                 assert!(oper.send(&s, i).is_ok());
+//                                 break;
+//                             }
+//                             _ => unreachable!(),
+//                         },
+//                     }
+//                 }
+//             }
+//         });
+
+//         scope.spawn(|_| {
+//             for i in 0..COUNT {
+//                 if i % 2 == 0 {
+//                     thread::sleep(ms(500));
+//                 }
+
+//                 let mut done = false;
+//                 while !done {
+//                     let mut sel = Select::new();
+//                     let oper1 = sel.recv(&r);
+//                     let oper = sel.select_timeout(ms(100));
+//                     match oper {
+//                         Err(_) => {}
+//                         Ok(oper) => match oper.index() {
+//                             ix if ix == oper1 => {
+//                                 assert_eq!(oper.recv(&r), Ok(i));
+//                                 done = true;
+//                             }
+//                             _ => unreachable!(),
+//                         },
+//                     }
+//                 }
+//             }
+//         });
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn send_recv_same_channel() {
+//     let (s, r) = bounded::<i32>(0);
+//     let mut sel = Select::new();
+//     let oper1 = sel.send(&s);
+//     let oper2 = sel.recv(&r);
+//     let oper = sel.select_timeout(ms(100));
+//     match oper {
+//         Err(_) => {}
+//         Ok(oper) => match oper.index() {
+//             ix if ix == oper1 => panic!(),
+//             ix if ix == oper2 => panic!(),
+//             _ => unreachable!(),
+//         },
+//     }
+
+//     let (s, r) = unbounded::<i32>();
+//     let mut sel = Select::new();
+//     let oper1 = sel.send(&s);
+//     let oper2 = sel.recv(&r);
+//     let oper = sel.select_timeout(ms(100));
+//     match oper {
+//         Err(_) => panic!(),
+//         Ok(oper) => match oper.index() {
+//             ix if ix == oper1 => assert!(oper.send(&s, 0).is_ok()),
+//             ix if ix == oper2 => panic!(),
+//             _ => unreachable!(),
+//         },
+//     }
+// }
+
+// #[test]
+// fn matching() {
+//     const THREADS: usize = 44;
+
+//     let (s, r) = &bounded::<usize>(0);
+
+//     scope(|scope| {
+//         for i in 0..THREADS {
+//             scope.spawn(move |_| {
+//                 let mut sel = Select::new();
+//                 let oper1 = sel.recv(&r);
+//                 let oper2 = sel.send(&s);
+//                 let oper = sel.select();
+//                 match oper.index() {
+//                     ix if ix == oper1 => assert_ne!(oper.recv(&r), Ok(i)),
+//                     ix if ix == oper2 => assert!(oper.send(&s, i).is_ok()),
+//                     _ => unreachable!(),
+//                 }
+//             });
+//         }
+//     })
+//     .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 |_| {
+//                 let mut sel = Select::new();
+//                 let oper1 = sel.recv(&r);
+//                 let oper2 = sel.send(&s);
+//                 let oper = sel.select();
+//                 match oper.index() {
+//                     ix if ix == oper1 => assert_ne!(oper.recv(&r), Ok(i)),
+//                     ix if ix == oper2 => assert!(oper.send(&s, i).is_ok()),
+//                     _ => unreachable!(),
+//                 }
+//             });
+//         }
+//         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));
+
+//                     {
+//                         let mut sel = Select::new();
+//                         let oper1 = sel.send(&s);
+//                         let oper = sel.select();
+//                         match oper.index() {
+//                             ix if ix == oper1 => assert!(oper.send(&s, new_r).is_ok()),
+//                             _ => unreachable!(),
+//                         }
+//                     }
+
+//                     s = new_s;
+//                 }
+//             });
+
+//             scope.spawn(move |_| {
+//                 let mut r = r;
+
+//                 for _ in 0..COUNT {
+//                     let new = {
+//                         let mut sel = Select::new();
+//                         let oper1 = sel.recv(&r);
+//                         let oper = sel.select();
+//                         match oper.index() {
+//                             ix if ix == oper1 => oper
+//                                 .recv(&r)
+//                                 .unwrap()
+//                                 .downcast_mut::<Option<Receiver<T>>>()
+//                                 .unwrap()
+//                                 .take()
+//                                 .unwrap(),
+//                             _ => unreachable!(),
+//                         }
+//                     };
+//                     r = new;
+//                 }
+//             });
+//         })
+//         .unwrap();
+//     }
+// }
+
+// #[test]
+// fn linearizable_try() {
+//     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();
+
+//                     let mut sel = Select::new();
+//                     let oper1 = sel.recv(&r1);
+//                     let oper2 = sel.recv(&r2);
+//                     let oper = sel.try_select();
+//                     match oper {
+//                         Err(_) => unreachable!(),
+//                         Ok(oper) => match oper.index() {
+//                             ix if ix == oper1 => assert!(oper.recv(&r1).is_ok()),
+//                             ix if ix == oper2 => assert!(oper.recv(&r2).is_ok()),
+//                             _ => 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();
+
+//                     let mut sel = Select::new();
+//                     let oper1 = sel.recv(&r1);
+//                     let oper2 = sel.recv(&r2);
+//                     let oper = sel.select_timeout(ms(0));
+//                     match oper {
+//                         Err(_) => unreachable!(),
+//                         Ok(oper) => match oper.index() {
+//                             ix if ix == oper1 => assert!(oper.recv(&r1).is_ok()),
+//                             ix if ix == oper2 => assert!(oper.recv(&r2).is_ok()),
+//                             _ => 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 hits = vec![Cell::new(0usize); 4];
+//     for _ in 0..COUNT {
+//         let after = after(ms(0));
+//         let tick = tick(ms(0));
+
+//         let mut sel = Select::new();
+//         let oper1 = sel.recv(&r1);
+//         let oper2 = sel.recv(&r2);
+//         let oper3 = sel.recv(&after);
+//         let oper4 = sel.recv(&tick);
+//         let oper = sel.select();
+//         match oper.index() {
+//             i if i == oper1 => {
+//                 oper.recv(&r1).unwrap();
+//                 hits[0].set(hits[0].get() + 1);
+//             }
+//             i if i == oper2 => {
+//                 oper.recv(&r2).unwrap();
+//                 hits[1].set(hits[1].get() + 1);
+//             }
+//             i if i == oper3 => {
+//                 oper.recv(&after).unwrap();
+//                 hits[2].set(hits[2].get() + 1);
+//             }
+//             i if i == oper4 => {
+//                 oper.recv(&tick).unwrap();
+//                 hits[3].set(hits[3].get() + 1);
+//             }
+//             _ => unreachable!(),
+//         }
+//     }
+//     assert!(hits.iter().all(|x| x.get() >= 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(|_| {
+//             for _ in 0..COUNT {
+//                 let mut sel = Select::new();
+//                 let mut oper1 = None;
+//                 let mut oper2 = None;
+//                 if s1.is_empty() {
+//                     oper1 = Some(sel.send(&s1));
+//                 }
+//                 if s2.is_empty() {
+//                     oper2 = Some(sel.send(&s2));
+//                 }
+//                 let oper3 = sel.send(&s3);
+//                 let oper = sel.select();
+//                 match oper.index() {
+//                     i if Some(i) == oper1 => assert!(oper.send(&s1, ()).is_ok()),
+//                     i if Some(i) == oper2 => assert!(oper.send(&s2, ()).is_ok()),
+//                     i if i == oper3 => assert!(oper.send(&s3, ()).is_ok()),
+//                     _ => unreachable!(),
+//                 }
+//             }
+//         });
+
+//         let hits = vec![Cell::new(0usize); 3];
+//         for _ in 0..COUNT {
+//             let mut sel = Select::new();
+//             let oper1 = sel.recv(&r1);
+//             let oper2 = sel.recv(&r2);
+//             let oper3 = sel.recv(&r3);
+//             let oper = sel.select();
+//             match oper.index() {
+//                 i if i == oper1 => {
+//                     oper.recv(&r1).unwrap();
+//                     hits[0].set(hits[0].get() + 1);
+//                 }
+//                 i if i == oper2 => {
+//                     oper.recv(&r2).unwrap();
+//                     hits[1].set(hits[1].get() + 1);
+//                 }
+//                 i if i == oper3 => {
+//                     oper.recv(&r3).unwrap();
+//                     hits[2].set(hits[2].get() + 1);
+//                 }
+//                 _ => unreachable!(),
+//             }
+//         }
+//         assert!(hits.iter().all(|x| x.get() >= COUNT / hits.len() / 50));
+//     })
+//     .unwrap();
+// }
+
+// #[test]
+// fn sync_and_clone() {
+//     const THREADS: usize = 20;
+
+//     let (s, r) = &bounded::<usize>(0);
+
+//     let mut sel = Select::new();
+//     let oper1 = sel.recv(&r);
+//     let oper2 = sel.send(&s);
+//     let sel = &sel;
+
+//     scope(|scope| {
+//         for i in 0..THREADS {
+//             scope.spawn(move |_| {
+//                 let mut sel = sel.clone();
+//                 let oper = sel.select();
+//                 match oper.index() {
+//                     ix if ix == oper1 => assert_ne!(oper.recv(&r), Ok(i)),
+//                     ix if ix == oper2 => assert!(oper.send(&s, i).is_ok()),
+//                     _ => unreachable!(),
+//                 }
+//             });
+//         }
+//     })
+//     .unwrap();
+
+//     assert_eq!(r.try_recv(), Err(TryRecvError::Empty));
+// }
+
+// #[test]
+// fn send_and_clone() {
+//     const THREADS: usize = 20;
+
+//     let (s, r) = &bounded::<usize>(0);
+
+//     let mut sel = Select::new();
+//     let oper1 = sel.recv(&r);
+//     let oper2 = sel.send(&s);
+
+//     scope(|scope| {
+//         for i in 0..THREADS {
+//             let mut sel = sel.clone();
+//             scope.spawn(move |_| {
+//                 let oper = sel.select();
+//                 match oper.index() {
+//                     ix if ix == oper1 => assert_ne!(oper.recv(&r), Ok(i)),
+//                     ix if ix == oper2 => assert!(oper.send(&s, i).is_ok()),
+//                     _ => unreachable!(),
+//                 }
+//             });
+//         }
+//     })
+//     .unwrap();
+
+//     assert_eq!(r.try_recv(), Err(TryRecvError::Empty));
+// }
+
+// #[test]
+// fn reuse() {
+//     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();
+//             }
+//         });
+
+//         let mut sel = Select::new();
+//         let oper1 = sel.recv(&r1);
+//         let oper2 = sel.send(&s2);
+
+//         for i in 0..COUNT {
+//             for _ in 0..2 {
+//                 let oper = sel.select();
+//                 match oper.index() {
+//                     ix if ix == oper1 => assert_eq!(oper.recv(&r1), Ok(i)),
+//                     ix if ix == oper2 => assert!(oper.send(&s2, i).is_ok()),
+//                     _ => unreachable!(),
+//                 }
+//             }
+//             s3.send(()).unwrap();
+//         }
+//     })
+//     .unwrap();
+// }