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