1 //! Tests for iteration over receivers.
2 
3 use crossbeam_channel::unbounded;
4 use crossbeam_utils::thread::scope;
5 
6 #[test]
nested_recv_iter()7 fn nested_recv_iter() {
8     let (s, r) = unbounded::<i32>();
9     let (total_s, total_r) = unbounded::<i32>();
10 
11     scope(|scope| {
12         scope.spawn(move |_| {
13             let mut acc = 0;
14             for x in r.iter() {
15                 acc += x;
16             }
17             total_s.send(acc).unwrap();
18         });
19 
20         s.send(3).unwrap();
21         s.send(1).unwrap();
22         s.send(2).unwrap();
23         drop(s);
24         assert_eq!(total_r.recv().unwrap(), 6);
25     })
26     .unwrap();
27 }
28 
29 #[test]
recv_iter_break()30 fn recv_iter_break() {
31     let (s, r) = unbounded::<i32>();
32     let (count_s, count_r) = unbounded();
33 
34     scope(|scope| {
35         scope.spawn(move |_| {
36             let mut count = 0;
37             for x in r.iter() {
38                 if count >= 3 {
39                     break;
40                 } else {
41                     count += x;
42                 }
43             }
44             count_s.send(count).unwrap();
45         });
46 
47         s.send(2).unwrap();
48         s.send(2).unwrap();
49         s.send(2).unwrap();
50         let _ = s.send(2);
51         drop(s);
52         assert_eq!(count_r.recv().unwrap(), 4);
53     })
54     .unwrap();
55 }
56 
57 #[test]
recv_try_iter()58 fn recv_try_iter() {
59     let (request_s, request_r) = unbounded();
60     let (response_s, response_r) = unbounded();
61 
62     scope(|scope| {
63         scope.spawn(move |_| {
64             let mut count = 0;
65             loop {
66                 for x in response_r.try_iter() {
67                     count += x;
68                     if count == 6 {
69                         return;
70                     }
71                 }
72                 request_s.send(()).unwrap();
73             }
74         });
75 
76         for _ in request_r.iter() {
77             if response_s.send(2).is_err() {
78                 break;
79             }
80         }
81     })
82     .unwrap();
83 }
84 
85 #[test]
recv_into_iter_owned()86 fn recv_into_iter_owned() {
87     let mut iter = {
88         let (s, r) = unbounded::<i32>();
89         s.send(1).unwrap();
90         s.send(2).unwrap();
91         r.into_iter()
92     };
93 
94     assert_eq!(iter.next().unwrap(), 1);
95     assert_eq!(iter.next().unwrap(), 2);
96     assert_eq!(iter.next().is_none(), true);
97 }
98 
99 #[test]
recv_into_iter_borrowed()100 fn recv_into_iter_borrowed() {
101     let (s, r) = unbounded::<i32>();
102     s.send(1).unwrap();
103     s.send(2).unwrap();
104     drop(s);
105 
106     let mut iter = (&r).into_iter();
107     assert_eq!(iter.next().unwrap(), 1);
108     assert_eq!(iter.next().unwrap(), 2);
109     assert_eq!(iter.next().is_none(), true);
110 }
111