// //! Tests for the tick channel flavor.

// #[macro_use]
// extern crate crossbeam_channel;
// extern crate crossbeam_utils;
// extern crate rand;

// use std::sync::atomic::AtomicUsize;
// use std::sync::atomic::Ordering;
// use std::thread;
// use std::time::{Duration, Instant};

// use crossbeam_channel::{after, tick, Select, TryRecvError};
// use crossbeam_utils::thread::scope;

// fn ms(ms: u64) -> Duration {
//     Duration::from_millis(ms)
// }

// #[test]
// fn fire() {
//     let start = Instant::now();
//     let r = tick(ms(50));

//     assert_eq!(r.try_recv(), Err(TryRecvError::Empty));
//     thread::sleep(ms(100));

//     let fired = r.try_recv().unwrap();
//     assert!(start < fired);
//     assert!(fired - start >= ms(50));

//     let now = Instant::now();
//     assert!(fired < now);
//     assert!(now - fired >= ms(50));

//     assert_eq!(r.try_recv(), Err(TryRecvError::Empty));

//     select! {
//         recv(r) -> _ => panic!(),
//         default => {}
//     }

//     select! {
//         recv(r) -> _ => {}
//         recv(tick(ms(200))) -> _ => panic!(),
//     }
// }

// #[test]
// fn intervals() {
//     let start = Instant::now();
//     let r = tick(ms(50));

//     let t1 = r.recv().unwrap();
//     assert!(start + ms(50) <= t1);
//     assert!(start + ms(100) > t1);

//     thread::sleep(ms(300));
//     let t2 = r.try_recv().unwrap();
//     assert!(start + ms(100) <= t2);
//     assert!(start + ms(150) > t2);

//     assert_eq!(r.try_recv(), Err(TryRecvError::Empty));
//     let t3 = r.recv().unwrap();
//     assert!(start + ms(400) <= t3);
//     assert!(start + ms(450) > t3);

//     assert_eq!(r.try_recv(), Err(TryRecvError::Empty));
// }

// #[test]
// fn capacity() {
//     const COUNT: usize = 10;

//     for i in 0..COUNT {
//         let r = tick(ms(i as u64));
//         assert_eq!(r.capacity(), Some(1));
//     }
// }

// #[test]
// fn len_empty_full() {
//     let r = tick(ms(50));

//     assert_eq!(r.len(), 0);
//     assert_eq!(r.is_empty(), true);
//     assert_eq!(r.is_full(), false);

//     thread::sleep(ms(100));

//     assert_eq!(r.len(), 1);
//     assert_eq!(r.is_empty(), false);
//     assert_eq!(r.is_full(), true);

//     r.try_recv().unwrap();

//     assert_eq!(r.len(), 0);
//     assert_eq!(r.is_empty(), true);
//     assert_eq!(r.is_full(), false);
// }

// #[test]
// fn try_recv() {
//     let r = tick(ms(200));
//     assert!(r.try_recv().is_err());

//     thread::sleep(ms(100));
//     assert!(r.try_recv().is_err());

//     thread::sleep(ms(200));
//     assert!(r.try_recv().is_ok());
//     assert!(r.try_recv().is_err());

//     thread::sleep(ms(200));
//     assert!(r.try_recv().is_ok());
//     assert!(r.try_recv().is_err());
// }

// #[test]
// fn recv() {
//     let start = Instant::now();
//     let r = tick(ms(50));

//     let fired = r.recv().unwrap();
//     assert!(start < fired);
//     assert!(fired - start >= ms(50));

//     let now = Instant::now();
//     assert!(fired < now);
//     assert!(now - fired < fired - start);

//     assert_eq!(r.try_recv(), Err(TryRecvError::Empty));
// }

// #[test]
// fn recv_timeout() {
//     let start = Instant::now();
//     let r = tick(ms(200));

//     assert!(r.recv_timeout(ms(100)).is_err());
//     let now = Instant::now();
//     assert!(now - start >= ms(100));
//     assert!(now - start <= ms(150));

//     let fired = r.recv_timeout(ms(200)).unwrap();
//     assert!(fired - start >= ms(200));
//     assert!(fired - start <= ms(250));

//     assert!(r.recv_timeout(ms(100)).is_err());
//     let now = Instant::now();
//     assert!(now - start >= ms(300));
//     assert!(now - start <= ms(350));

//     let fired = r.recv_timeout(ms(200)).unwrap();
//     assert!(fired - start >= ms(400));
//     assert!(fired - start <= ms(450));
// }

// #[test]
// fn recv_two() {
//     let r1 = tick(ms(50));
//     let r2 = tick(ms(50));

//     scope(|scope| {
//         scope.spawn(|_| {
//             for _ in 0..10 {
//                 select! {
//                     recv(r1) -> _ => {}
//                     recv(r2) -> _ => {}
//                 }
//             }
//         });
//         scope.spawn(|_| {
//             for _ in 0..10 {
//                 select! {
//                     recv(r1) -> _ => {}
//                     recv(r2) -> _ => {}
//                 }
//             }
//         });
//     })
//     .unwrap();
// }

// #[test]
// fn recv_race() {
//     select! {
//         recv(tick(ms(50))) -> _ => {}
//         recv(tick(ms(100))) -> _ => panic!(),
//     }

//     select! {
//         recv(tick(ms(100))) -> _ => panic!(),
//         recv(tick(ms(50))) -> _ => {}
//     }
// }

// #[test]
// fn stress_default() {
//     const COUNT: usize = 10;

//     for _ in 0..COUNT {
//         select! {
//             recv(tick(ms(0))) -> _ => {}
//             default => panic!(),
//         }
//     }

//     for _ in 0..COUNT {
//         select! {
//             recv(tick(ms(100))) -> _ => panic!(),
//             default => {}
//         }
//     }
// }

// #[test]
// fn select() {
//     const THREADS: usize = 4;

//     let hits = AtomicUsize::new(0);
//     let r1 = tick(ms(200));
//     let r2 = tick(ms(300));

//     scope(|scope| {
//         for _ in 0..THREADS {
//             scope.spawn(|_| {
//                 let timeout = after(ms(1100));
//                 loop {
//                     let mut sel = Select::new();
//                     let oper1 = sel.recv(&r1);
//                     let oper2 = sel.recv(&r2);
//                     let oper3 = sel.recv(&timeout);
//                     let oper = sel.select();
//                     match oper.index() {
//                         i if i == oper1 => {
//                             oper.recv(&r1).unwrap();
//                             hits.fetch_add(1, Ordering::SeqCst);
//                         }
//                         i if i == oper2 => {
//                             oper.recv(&r2).unwrap();
//                             hits.fetch_add(1, Ordering::SeqCst);
//                         }
//                         i if i == oper3 => {
//                             oper.recv(&timeout).unwrap();
//                             break;
//                         }
//                         _ => unreachable!(),
//                     }
//                 }
//             });
//         }
//     })
//     .unwrap();

//     assert_eq!(hits.load(Ordering::SeqCst), 8);
// }

// #[test]
// fn ready() {
//     const THREADS: usize = 4;

//     let hits = AtomicUsize::new(0);
//     let r1 = tick(ms(200));
//     let r2 = tick(ms(300));

//     scope(|scope| {
//         for _ in 0..THREADS {
//             scope.spawn(|_| {
//                 let timeout = after(ms(1100));
//                 'outer: loop {
//                     let mut sel = Select::new();
//                     sel.recv(&r1);
//                     sel.recv(&r2);
//                     sel.recv(&timeout);
//                     loop {
//                         match sel.ready() {
//                             0 => {
//                                 if r1.try_recv().is_ok() {
//                                     hits.fetch_add(1, Ordering::SeqCst);
//                                     break;
//                                 }
//                             }
//                             1 => {
//                                 if r2.try_recv().is_ok() {
//                                     hits.fetch_add(1, Ordering::SeqCst);
//                                     break;
//                                 }
//                             }
//                             2 => {
//                                 if timeout.try_recv().is_ok() {
//                                     break 'outer;
//                                 }
//                             }
//                             _ => unreachable!(),
//                         }
//                     }
//                 }
//             });
//         }
//     })
//     .unwrap();

//     assert_eq!(hits.load(Ordering::SeqCst), 8);
// }

// #[test]
// fn fairness() {
//     const COUNT: usize = 30;

//     for &dur in &[0, 1] {
//         let mut hits = [0usize; 2];

//         for _ in 0..COUNT {
//             let r1 = tick(ms(dur));
//             let r2 = tick(ms(dur));

//             for _ in 0..COUNT {
//                 select! {
//                     recv(r1) -> _ => hits[0] += 1,
//                     recv(r2) -> _ => hits[1] += 1,
//                 }
//             }
//         }

//         assert!(hits.iter().all(|x| *x >= COUNT / hits.len() / 2));
//     }
// }

// #[test]
// fn fairness_duplicates() {
//     const COUNT: usize = 30;

//     for &dur in &[0, 1] {
//         let mut hits = [0usize; 5];

//         for _ in 0..COUNT {
//             let r = tick(ms(dur));

//             for _ in 0..COUNT {
//                 select! {
//                     recv(r) -> _ => hits[0] += 1,
//                     recv(r) -> _ => hits[1] += 1,
//                     recv(r) -> _ => hits[2] += 1,
//                     recv(r) -> _ => hits[3] += 1,
//                     recv(r) -> _ => hits[4] += 1,
//                 }
//             }
//         }

//         assert!(hits.iter().all(|x| *x >= COUNT / hits.len() / 2));
//     }
// }