1 #![cfg(feature = "os-poll")]
2
3 use mio::{Events, Poll, Token, Waker};
4 use std::sync::{Arc, Barrier};
5 use std::thread;
6 use std::time::Duration;
7
8 mod util;
9 use util::{assert_send, assert_sync, expect_no_events, init};
10
11 #[test]
is_send_and_sync()12 fn is_send_and_sync() {
13 assert_send::<Waker>();
14 assert_sync::<Waker>();
15 }
16
17 #[test]
waker()18 fn waker() {
19 init();
20
21 let mut poll = Poll::new().expect("unable to create new Poll instance");
22 let mut events = Events::with_capacity(10);
23
24 let token = Token(10);
25 let waker = Waker::new(poll.registry(), token).expect("unable to create waker");
26
27 waker.wake().expect("unable to wake");
28 expect_waker_event(&mut poll, &mut events, token);
29 }
30
31 #[test]
waker_multiple_wakeups_same_thread()32 fn waker_multiple_wakeups_same_thread() {
33 init();
34
35 let mut poll = Poll::new().expect("unable to create new Poll instance");
36 let mut events = Events::with_capacity(10);
37
38 let token = Token(10);
39 let waker = Waker::new(poll.registry(), token).expect("unable to create waker");
40
41 for _ in 0..3 {
42 waker.wake().expect("unable to wake");
43 }
44 expect_waker_event(&mut poll, &mut events, token);
45 }
46
47 #[test]
waker_wakeup_different_thread()48 fn waker_wakeup_different_thread() {
49 init();
50
51 let mut poll = Poll::new().expect("unable to create new Poll instance");
52 let mut events = Events::with_capacity(10);
53
54 let token = Token(10);
55 let waker = Waker::new(poll.registry(), token).expect("unable to create waker");
56
57 let waker = Arc::new(waker);
58 let waker1 = Arc::clone(&waker);
59 let handle = thread::spawn(move || {
60 waker1.wake().expect("unable to wake");
61 });
62
63 expect_waker_event(&mut poll, &mut events, token);
64
65 expect_no_events(&mut poll, &mut events);
66
67 handle.join().unwrap();
68 }
69
70 #[test]
waker_multiple_wakeups_different_thread()71 fn waker_multiple_wakeups_different_thread() {
72 init();
73
74 let mut poll = Poll::new().expect("unable to create new Poll instance");
75 let mut events = Events::with_capacity(10);
76
77 let token = Token(10);
78 let waker = Waker::new(poll.registry(), token).expect("unable to create waker");
79 let waker = Arc::new(waker);
80 let waker1 = Arc::clone(&waker);
81 let waker2 = Arc::clone(&waker1);
82
83 let handle1 = thread::spawn(move || {
84 waker1.wake().expect("unable to wake");
85 });
86
87 let barrier = Arc::new(Barrier::new(2));
88 let barrier2 = barrier.clone();
89 let handle2 = thread::spawn(move || {
90 barrier2.wait();
91 waker2.wake().expect("unable to wake");
92 });
93
94 // Receive the event from thread 1.
95 expect_waker_event(&mut poll, &mut events, token);
96
97 // Unblock thread 2.
98 barrier.wait();
99
100 // Now we need to receive another event from thread 2.
101 expect_waker_event(&mut poll, &mut events, token);
102
103 expect_no_events(&mut poll, &mut events);
104
105 handle1.join().unwrap();
106 handle2.join().unwrap();
107 }
108
expect_waker_event(poll: &mut Poll, events: &mut Events, token: Token)109 fn expect_waker_event(poll: &mut Poll, events: &mut Events, token: Token) {
110 poll.poll(events, Some(Duration::from_millis(100))).unwrap();
111 assert!(!events.is_empty());
112 for event in events.iter() {
113 assert_eq!(event.token(), token);
114 assert!(event.is_readable());
115 }
116 }
117