select_macro.rs

//! 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();
}