1 //use crate::time::driver::{Driver, Entry, Handle};
2 
3 /*
4 macro_rules! poll {
5     ($e:expr) => {
6         $e.enter(|cx, e| e.poll_elapsed(cx))
7     };
8 }
9 
10 #[test]
11 fn frozen_utility_returns_correct_advanced_duration() {
12     let clock = Clock::new();
13     clock.pause();
14     let start = clock.now();
15 
16     clock.advance(ms(10));
17     assert_eq!(clock.now() - start, ms(10));
18 }
19 
20 #[test]
21 fn immediate_sleep() {
22     let (mut driver, clock, handle) = setup();
23     let start = clock.now();
24 
25     let when = clock.now();
26     let mut e = task::spawn(sleep_until(&handle, when));
27 
28     assert_ready_ok!(poll!(e));
29 
30     assert_ok!(driver.park_timeout(Duration::from_millis(1000)));
31 
32     // The time has not advanced. The `turn` completed immediately.
33     assert_eq!(clock.now() - start, ms(1000));
34 }
35 
36 #[test]
37 fn delayed_sleep_level_0() {
38     let (mut driver, clock, handle) = setup();
39     let start = clock.now();
40 
41     for &i in &[1, 10, 60] {
42         // Create a `Sleep` that elapses in the future
43         let mut e = task::spawn(sleep_until(&handle, start + ms(i)));
44 
45         // The sleep instance has not elapsed.
46         assert_pending!(poll!(e));
47 
48         assert_ok!(driver.park());
49         assert_eq!(clock.now() - start, ms(i));
50 
51         assert_ready_ok!(poll!(e));
52     }
53 }
54 
55 #[test]
56 fn sub_ms_delayed_sleep() {
57     let (mut driver, clock, handle) = setup();
58 
59     for _ in 0..5 {
60         let deadline = clock.now() + ms(1) + Duration::new(0, 1);
61 
62         let mut e = task::spawn(sleep_until(&handle, deadline));
63 
64         assert_pending!(poll!(e));
65 
66         assert_ok!(driver.park());
67         assert_ready_ok!(poll!(e));
68 
69         assert!(clock.now() >= deadline);
70 
71         clock.advance(Duration::new(0, 1));
72     }
73 }
74 
75 #[test]
76 fn delayed_sleep_wrapping_level_0() {
77     let (mut driver, clock, handle) = setup();
78     let start = clock.now();
79 
80     assert_ok!(driver.park_timeout(ms(5)));
81     assert_eq!(clock.now() - start, ms(5));
82 
83     let mut e = task::spawn(sleep_until(&handle, clock.now() + ms(60)));
84 
85     assert_pending!(poll!(e));
86 
87     assert_ok!(driver.park());
88     assert_eq!(clock.now() - start, ms(64));
89     assert_pending!(poll!(e));
90 
91     assert_ok!(driver.park());
92     assert_eq!(clock.now() - start, ms(65));
93 
94     assert_ready_ok!(poll!(e));
95 }
96 
97 #[test]
98 fn timer_wrapping_with_higher_levels() {
99     let (mut driver, clock, handle) = setup();
100     let start = clock.now();
101 
102     // Set sleep to hit level 1
103     let mut e1 = task::spawn(sleep_until(&handle, clock.now() + ms(64)));
104     assert_pending!(poll!(e1));
105 
106     // Turn a bit
107     assert_ok!(driver.park_timeout(ms(5)));
108 
109     // Set timeout such that it will hit level 0, but wrap
110     let mut e2 = task::spawn(sleep_until(&handle, clock.now() + ms(60)));
111     assert_pending!(poll!(e2));
112 
113     // This should result in s1 firing
114     assert_ok!(driver.park());
115     assert_eq!(clock.now() - start, ms(64));
116 
117     assert_ready_ok!(poll!(e1));
118     assert_pending!(poll!(e2));
119 
120     assert_ok!(driver.park());
121     assert_eq!(clock.now() - start, ms(65));
122 
123     assert_ready_ok!(poll!(e1));
124 }
125 
126 #[test]
127 fn sleep_with_deadline_in_past() {
128     let (mut driver, clock, handle) = setup();
129     let start = clock.now();
130 
131     // Create `Sleep` that elapsed immediately.
132     let mut e = task::spawn(sleep_until(&handle, clock.now() - ms(100)));
133 
134     // Even though the `Sleep` expires in the past, it is not ready yet
135     // because the timer must observe it.
136     assert_ready_ok!(poll!(e));
137 
138     // Turn the timer, it runs for the elapsed time
139     assert_ok!(driver.park_timeout(ms(1000)));
140 
141     // The time has not advanced. The `turn` completed immediately.
142     assert_eq!(clock.now() - start, ms(1000));
143 }
144 
145 #[test]
146 fn delayed_sleep_level_1() {
147     let (mut driver, clock, handle) = setup();
148     let start = clock.now();
149 
150     // Create a `Sleep` that elapses in the future
151     let mut e = task::spawn(sleep_until(&handle, clock.now() + ms(234)));
152 
153     // The sleep has not elapsed.
154     assert_pending!(poll!(e));
155 
156     // Turn the timer, this will wake up to cascade the timer down.
157     assert_ok!(driver.park_timeout(ms(1000)));
158     assert_eq!(clock.now() - start, ms(192));
159 
160     // The sleep has not elapsed.
161     assert_pending!(poll!(e));
162 
163     // Turn the timer again
164     assert_ok!(driver.park_timeout(ms(1000)));
165     assert_eq!(clock.now() - start, ms(234));
166 
167     // The sleep has elapsed.
168     assert_ready_ok!(poll!(e));
169 
170     let (mut driver, clock, handle) = setup();
171     let start = clock.now();
172 
173     // Create a `Sleep` that elapses in the future
174     let mut e = task::spawn(sleep_until(&handle, clock.now() + ms(234)));
175 
176     // The sleep has not elapsed.
177     assert_pending!(poll!(e));
178 
179     // Turn the timer with a smaller timeout than the cascade.
180     assert_ok!(driver.park_timeout(ms(100)));
181     assert_eq!(clock.now() - start, ms(100));
182 
183     assert_pending!(poll!(e));
184 
185     // Turn the timer, this will wake up to cascade the timer down.
186     assert_ok!(driver.park_timeout(ms(1000)));
187     assert_eq!(clock.now() - start, ms(192));
188 
189     // The sleep has not elapsed.
190     assert_pending!(poll!(e));
191 
192     // Turn the timer again
193     assert_ok!(driver.park_timeout(ms(1000)));
194     assert_eq!(clock.now() - start, ms(234));
195 
196     // The sleep has elapsed.
197     assert_ready_ok!(poll!(e));
198 }
199 
200 #[test]
201 fn concurrently_set_two_timers_second_one_shorter() {
202     let (mut driver, clock, handle) = setup();
203     let start = clock.now();
204 
205     let mut e1 = task::spawn(sleep_until(&handle, clock.now() + ms(500)));
206     let mut e2 = task::spawn(sleep_until(&handle, clock.now() + ms(200)));
207 
208     // The sleep has not elapsed
209     assert_pending!(poll!(e1));
210     assert_pending!(poll!(e2));
211 
212     // Sleep until a cascade
213     assert_ok!(driver.park());
214     assert_eq!(clock.now() - start, ms(192));
215 
216     // Sleep until the second timer.
217     assert_ok!(driver.park());
218     assert_eq!(clock.now() - start, ms(200));
219 
220     // The shorter sleep fires
221     assert_ready_ok!(poll!(e2));
222     assert_pending!(poll!(e1));
223 
224     assert_ok!(driver.park());
225     assert_eq!(clock.now() - start, ms(448));
226 
227     assert_pending!(poll!(e1));
228 
229     // Turn again, this time the time will advance to the second sleep
230     assert_ok!(driver.park());
231     assert_eq!(clock.now() - start, ms(500));
232 
233     assert_ready_ok!(poll!(e1));
234 }
235 
236 #[test]
237 fn short_sleep() {
238     let (mut driver, clock, handle) = setup();
239     let start = clock.now();
240 
241     // Create a `Sleep` that elapses in the future
242     let mut e = task::spawn(sleep_until(&handle, clock.now() + ms(1)));
243 
244     // The sleep has not elapsed.
245     assert_pending!(poll!(e));
246 
247     // Turn the timer, but not enough time will go by.
248     assert_ok!(driver.park());
249 
250     // The sleep has elapsed.
251     assert_ready_ok!(poll!(e));
252 
253     // The time has advanced to the point of the sleep elapsing.
254     assert_eq!(clock.now() - start, ms(1));
255 }
256 
257 #[test]
258 fn sorta_long_sleep_until() {
259     const MIN_5: u64 = 5 * 60 * 1000;
260 
261     let (mut driver, clock, handle) = setup();
262     let start = clock.now();
263 
264     // Create a `Sleep` that elapses in the future
265     let mut e = task::spawn(sleep_until(&handle, clock.now() + ms(MIN_5)));
266 
267     // The sleep has not elapsed.
268     assert_pending!(poll!(e));
269 
270     let cascades = &[262_144, 262_144 + 9 * 4096, 262_144 + 9 * 4096 + 15 * 64];
271 
272     for &elapsed in cascades {
273         assert_ok!(driver.park());
274         assert_eq!(clock.now() - start, ms(elapsed));
275 
276         assert_pending!(poll!(e));
277     }
278 
279     assert_ok!(driver.park());
280     assert_eq!(clock.now() - start, ms(MIN_5));
281 
282     // The sleep has elapsed.
283     assert_ready_ok!(poll!(e));
284 }
285 
286 #[test]
287 fn very_long_sleep() {
288     const MO_5: u64 = 5 * 30 * 24 * 60 * 60 * 1000;
289 
290     let (mut driver, clock, handle) = setup();
291     let start = clock.now();
292 
293     // Create a `Sleep` that elapses in the future
294     let mut e = task::spawn(sleep_until(&handle, clock.now() + ms(MO_5)));
295 
296     // The sleep has not elapsed.
297     assert_pending!(poll!(e));
298 
299     let cascades = &[
300         12_884_901_888,
301         12_952_010_752,
302         12_959_875_072,
303         12_959_997_952,
304     ];
305 
306     for &elapsed in cascades {
307         assert_ok!(driver.park());
308         assert_eq!(clock.now() - start, ms(elapsed));
309 
310         assert_pending!(poll!(e));
311     }
312 
313     // Turn the timer, but not enough time will go by.
314     assert_ok!(driver.park());
315 
316     // The time has advanced to the point of the sleep elapsing.
317     assert_eq!(clock.now() - start, ms(MO_5));
318 
319     // The sleep has elapsed.
320     assert_ready_ok!(poll!(e));
321 }
322 
323 #[test]
324 fn unpark_is_delayed() {
325     // A special park that will take much longer than the requested duration
326     struct MockPark(Clock);
327 
328     struct MockUnpark;
329 
330     impl Park for MockPark {
331         type Unpark = MockUnpark;
332         type Error = ();
333 
334         fn unpark(&self) -> Self::Unpark {
335             MockUnpark
336         }
337 
338         fn park(&mut self) -> Result<(), Self::Error> {
339             panic!("parking forever");
340         }
341 
342         fn park_timeout(&mut self, duration: Duration) -> Result<(), Self::Error> {
343             assert_eq!(duration, ms(0));
344             self.0.advance(ms(436));
345             Ok(())
346         }
347 
348         fn shutdown(&mut self) {}
349     }
350 
351     impl Unpark for MockUnpark {
352         fn unpark(&self) {}
353     }
354 
355     let clock = Clock::new();
356     clock.pause();
357     let start = clock.now();
358     let mut driver = Driver::new(MockPark(clock.clone()), clock.clone());
359     let handle = driver.handle();
360 
361     let mut e1 = task::spawn(sleep_until(&handle, clock.now() + ms(100)));
362     let mut e2 = task::spawn(sleep_until(&handle, clock.now() + ms(101)));
363     let mut e3 = task::spawn(sleep_until(&handle, clock.now() + ms(200)));
364 
365     assert_pending!(poll!(e1));
366     assert_pending!(poll!(e2));
367     assert_pending!(poll!(e3));
368 
369     assert_ok!(driver.park());
370 
371     assert_eq!(clock.now() - start, ms(500));
372 
373     assert_ready_ok!(poll!(e1));
374     assert_ready_ok!(poll!(e2));
375     assert_ready_ok!(poll!(e3));
376 }
377 
378 #[test]
379 fn set_timeout_at_deadline_greater_than_max_timer() {
380     const YR_1: u64 = 365 * 24 * 60 * 60 * 1000;
381     const YR_5: u64 = 5 * YR_1;
382 
383     let (mut driver, clock, handle) = setup();
384     let start = clock.now();
385 
386     for _ in 0..5 {
387         assert_ok!(driver.park_timeout(ms(YR_1)));
388     }
389 
390     let mut e = task::spawn(sleep_until(&handle, clock.now() + ms(1)));
391     assert_pending!(poll!(e));
392 
393     assert_ok!(driver.park_timeout(ms(1000)));
394     assert_eq!(clock.now() - start, ms(YR_5) + ms(1));
395 
396     assert_ready_ok!(poll!(e));
397 }
398 
399 fn setup() -> (Driver<MockPark>, Clock, Handle) {
400     let clock = Clock::new();
401     clock.pause();
402     let driver = Driver::new(MockPark(clock.clone()), clock.clone());
403     let handle = driver.handle();
404 
405     (driver, clock, handle)
406 }
407 
408 fn sleep_until(handle: &Handle, when: Instant) -> Arc<Entry> {
409     Entry::new(&handle, when, ms(0))
410 }
411 
412 struct MockPark(Clock);
413 
414 struct MockUnpark;
415 
416 impl Park for MockPark {
417     type Unpark = MockUnpark;
418     type Error = ();
419 
420     fn unpark(&self) -> Self::Unpark {
421         MockUnpark
422     }
423 
424     fn park(&mut self) -> Result<(), Self::Error> {
425         panic!("parking forever");
426     }
427 
428     fn park_timeout(&mut self, duration: Duration) -> Result<(), Self::Error> {
429         self.0.advance(duration);
430         Ok(())
431     }
432 
433     fn shutdown(&mut self) {}
434 }
435 
436 impl Unpark for MockUnpark {
437     fn unpark(&self) {}
438 }
439 
440 fn ms(n: u64) -> Duration {
441     Duration::from_millis(n)
442 }
443 */
444