1 extern crate futures;
2 extern crate tokio_executor;
3 extern crate tokio_timer;
4
5 #[macro_use]
6 mod support;
7 use support::*;
8
9 use tokio_timer::timer::Handle;
10 use tokio_timer::*;
11
12 use futures::Future;
13
14 use std::time::{Duration, Instant};
15
16 #[test]
immediate_delay()17 fn immediate_delay() {
18 mocked(|timer, time| {
19 // Create `Delay` that elapsed immediately.
20 let mut delay = Delay::new(time.now());
21
22 // Ready!
23 assert_ready!(delay);
24
25 // Turn the timer, it runs for the elapsed time
26 turn(timer, ms(1000));
27
28 // The time has not advanced. The `turn` completed immediately.
29 assert_eq!(time.advanced(), ms(1000));
30 });
31 }
32
33 #[test]
delayed_delay_level_0()34 fn delayed_delay_level_0() {
35 for &i in &[1, 10, 60] {
36 mocked(|timer, time| {
37 // Create a `Delay` that elapses in the future
38 let mut delay = Delay::new(time.now() + ms(i));
39
40 // The delay has not elapsed.
41 assert_not_ready!(delay);
42
43 turn(timer, ms(1000));
44 assert_eq!(time.advanced(), ms(i));
45
46 assert_ready!(delay);
47 });
48 }
49 }
50
51 #[test]
sub_ms_delayed_delay()52 fn sub_ms_delayed_delay() {
53 mocked(|timer, time| {
54 for _ in 0..5 {
55 let deadline = time.now() + Duration::from_millis(1) + Duration::new(0, 1);
56
57 let mut delay = Delay::new(deadline);
58
59 assert_not_ready!(delay);
60
61 turn(timer, None);
62 assert_ready!(delay);
63
64 assert!(time.now() >= deadline);
65
66 time.advance(Duration::new(0, 1));
67 }
68 });
69 }
70
71 #[test]
delayed_delay_wrapping_level_0()72 fn delayed_delay_wrapping_level_0() {
73 mocked(|timer, time| {
74 turn(timer, ms(5));
75 assert_eq!(time.advanced(), ms(5));
76
77 let mut delay = Delay::new(time.now() + ms(60));
78
79 assert_not_ready!(delay);
80
81 turn(timer, None);
82 assert_eq!(time.advanced(), ms(64));
83 assert_not_ready!(delay);
84
85 turn(timer, None);
86 assert_eq!(time.advanced(), ms(65));
87
88 assert_ready!(delay);
89 });
90 }
91
92 #[test]
timer_wrapping_with_higher_levels()93 fn timer_wrapping_with_higher_levels() {
94 mocked(|timer, time| {
95 // Set delay to hit level 1
96 let mut s1 = Delay::new(time.now() + ms(64));
97 assert_not_ready!(s1);
98
99 // Turn a bit
100 turn(timer, ms(5));
101
102 // Set timeout such that it will hit level 0, but wrap
103 let mut s2 = Delay::new(time.now() + ms(60));
104 assert_not_ready!(s2);
105
106 // This should result in s1 firing
107 turn(timer, None);
108 assert_eq!(time.advanced(), ms(64));
109
110 assert_ready!(s1);
111 assert_not_ready!(s2);
112
113 turn(timer, None);
114 assert_eq!(time.advanced(), ms(65));
115
116 assert_ready!(s2);
117 });
118 }
119
120 #[test]
delay_with_deadline_in_past()121 fn delay_with_deadline_in_past() {
122 mocked(|timer, time| {
123 // Create `Delay` that elapsed immediately.
124 let mut delay = Delay::new(time.now() - ms(100));
125
126 // Even though the delay expires in the past, it is not ready yet
127 // because the timer must observe it.
128 assert_ready!(delay);
129
130 // Turn the timer, it runs for the elapsed time
131 turn(timer, ms(1000));
132
133 // The time has not advanced. The `turn` completed immediately.
134 assert_eq!(time.advanced(), ms(1000));
135 });
136 }
137
138 #[test]
delayed_delay_level_1()139 fn delayed_delay_level_1() {
140 mocked(|timer, time| {
141 // Create a `Delay` that elapses in the future
142 let mut delay = Delay::new(time.now() + ms(234));
143
144 // The delay has not elapsed.
145 assert_not_ready!(delay);
146
147 // Turn the timer, this will wake up to cascade the timer down.
148 turn(timer, ms(1000));
149 assert_eq!(time.advanced(), ms(192));
150
151 // The delay has not elapsed.
152 assert_not_ready!(delay);
153
154 // Turn the timer again
155 turn(timer, ms(1000));
156 assert_eq!(time.advanced(), ms(234));
157
158 // The delay has elapsed.
159 assert_ready!(delay);
160 });
161
162 mocked(|timer, time| {
163 // Create a `Delay` that elapses in the future
164 let mut delay = Delay::new(time.now() + ms(234));
165
166 // The delay has not elapsed.
167 assert_not_ready!(delay);
168
169 // Turn the timer with a smaller timeout than the cascade.
170 turn(timer, ms(100));
171 assert_eq!(time.advanced(), ms(100));
172
173 assert_not_ready!(delay);
174
175 // Turn the timer, this will wake up to cascade the timer down.
176 turn(timer, ms(1000));
177 assert_eq!(time.advanced(), ms(192));
178
179 // The delay has not elapsed.
180 assert_not_ready!(delay);
181
182 // Turn the timer again
183 turn(timer, ms(1000));
184 assert_eq!(time.advanced(), ms(234));
185
186 // The delay has elapsed.
187 assert_ready!(delay);
188 });
189 }
190
191 #[test]
creating_delay_outside_of_context()192 fn creating_delay_outside_of_context() {
193 let now = Instant::now();
194
195 // This creates a delay outside of the context of a mock timer. This tests
196 // that it will still expire.
197 let mut delay = Delay::new(now + ms(500));
198
199 mocked_with_now(now, |timer, time| {
200 // This registers the delay with the timer
201 assert_not_ready!(delay);
202
203 // Wait some time... the timer is cascading
204 turn(timer, ms(1000));
205 assert_eq!(time.advanced(), ms(448));
206
207 assert_not_ready!(delay);
208
209 turn(timer, ms(1000));
210 assert_eq!(time.advanced(), ms(500));
211
212 // The delay has elapsed
213 assert_ready!(delay);
214 });
215 }
216
217 #[test]
concurrently_set_two_timers_second_one_shorter()218 fn concurrently_set_two_timers_second_one_shorter() {
219 mocked(|timer, time| {
220 let mut delay1 = Delay::new(time.now() + ms(500));
221 let mut delay2 = Delay::new(time.now() + ms(200));
222
223 // The delay has not elapsed
224 assert_not_ready!(delay1);
225 assert_not_ready!(delay2);
226
227 // Delay until a cascade
228 turn(timer, None);
229 assert_eq!(time.advanced(), ms(192));
230
231 // Delay until the second timer.
232 turn(timer, None);
233 assert_eq!(time.advanced(), ms(200));
234
235 // The shorter delay fires
236 assert_ready!(delay2);
237 assert_not_ready!(delay1);
238
239 turn(timer, None);
240 assert_eq!(time.advanced(), ms(448));
241
242 assert_not_ready!(delay1);
243
244 // Turn again, this time the time will advance to the second delay
245 turn(timer, None);
246 assert_eq!(time.advanced(), ms(500));
247
248 assert_ready!(delay1);
249 })
250 }
251
252 #[test]
short_delay()253 fn short_delay() {
254 mocked(|timer, time| {
255 // Create a `Delay` that elapses in the future
256 let mut delay = Delay::new(time.now() + ms(1));
257
258 // The delay has not elapsed.
259 assert_not_ready!(delay);
260
261 // Turn the timer, but not enough time will go by.
262 turn(timer, None);
263
264 // The delay has elapsed.
265 assert_ready!(delay);
266
267 // The time has advanced to the point of the delay elapsing.
268 assert_eq!(time.advanced(), ms(1));
269 })
270 }
271
272 #[test]
sorta_long_delay()273 fn sorta_long_delay() {
274 const MIN_5: u64 = 5 * 60 * 1000;
275
276 mocked(|timer, time| {
277 // Create a `Delay` that elapses in the future
278 let mut delay = Delay::new(time.now() + ms(MIN_5));
279
280 // The delay has not elapsed.
281 assert_not_ready!(delay);
282
283 let cascades = &[262_144, 262_144 + 9 * 4096, 262_144 + 9 * 4096 + 15 * 64];
284
285 for &elapsed in cascades {
286 turn(timer, None);
287 assert_eq!(time.advanced(), ms(elapsed));
288
289 assert_not_ready!(delay);
290 }
291
292 turn(timer, None);
293 assert_eq!(time.advanced(), ms(MIN_5));
294
295 // The delay has elapsed.
296 assert_ready!(delay);
297 })
298 }
299
300 #[test]
very_long_delay()301 fn very_long_delay() {
302 const MO_5: u64 = 5 * 30 * 24 * 60 * 60 * 1000;
303
304 mocked(|timer, time| {
305 // Create a `Delay` that elapses in the future
306 let mut delay = Delay::new(time.now() + ms(MO_5));
307
308 // The delay has not elapsed.
309 assert_not_ready!(delay);
310
311 let cascades = &[
312 12_884_901_888,
313 12_952_010_752,
314 12_959_875_072,
315 12_959_997_952,
316 ];
317
318 for &elapsed in cascades {
319 turn(timer, None);
320 assert_eq!(time.advanced(), ms(elapsed));
321
322 assert_not_ready!(delay);
323 }
324
325 // Turn the timer, but not enough time will go by.
326 turn(timer, None);
327
328 // The time has advanced to the point of the delay elapsing.
329 assert_eq!(time.advanced(), ms(MO_5));
330
331 // The delay has elapsed.
332 assert_ready!(delay);
333 })
334 }
335
336 #[test]
greater_than_max()337 fn greater_than_max() {
338 const YR_5: u64 = 5 * 365 * 24 * 60 * 60 * 1000;
339
340 mocked(|timer, time| {
341 // Create a `Delay` that elapses in the future
342 let mut delay = Delay::new(time.now() + ms(YR_5));
343
344 assert_not_ready!(delay);
345
346 turn(timer, ms(0));
347
348 assert!(delay.poll().is_err());
349 })
350 }
351
352 #[test]
unpark_is_delayed()353 fn unpark_is_delayed() {
354 mocked(|timer, time| {
355 let mut delay1 = Delay::new(time.now() + ms(100));
356 let mut delay2 = Delay::new(time.now() + ms(101));
357 let mut delay3 = Delay::new(time.now() + ms(200));
358
359 assert_not_ready!(delay1);
360 assert_not_ready!(delay2);
361 assert_not_ready!(delay3);
362
363 time.park_for(ms(500));
364
365 turn(timer, None);
366
367 assert_eq!(time.advanced(), ms(500));
368
369 assert_ready!(delay1);
370 assert_ready!(delay2);
371 assert_ready!(delay3);
372 })
373 }
374
375 #[test]
set_timeout_at_deadline_greater_than_max_timer()376 fn set_timeout_at_deadline_greater_than_max_timer() {
377 const YR_1: u64 = 365 * 24 * 60 * 60 * 1000;
378 const YR_5: u64 = 5 * YR_1;
379
380 mocked(|timer, time| {
381 for _ in 0..5 {
382 turn(timer, ms(YR_1));
383 }
384
385 let mut delay = Delay::new(time.now() + ms(1));
386 assert_not_ready!(delay);
387
388 turn(timer, ms(1000));
389 assert_eq!(time.advanced(), Duration::from_millis(YR_5) + ms(1));
390
391 assert_ready!(delay);
392 });
393 }
394
395 #[test]
reset_future_delay_before_fire()396 fn reset_future_delay_before_fire() {
397 mocked(|timer, time| {
398 let mut delay = Delay::new(time.now() + ms(100));
399
400 assert_not_ready!(delay);
401
402 delay.reset(time.now() + ms(200));
403
404 turn(timer, None);
405 assert_eq!(time.advanced(), ms(192));
406
407 assert_not_ready!(delay);
408
409 turn(timer, None);
410 assert_eq!(time.advanced(), ms(200));
411
412 assert_ready!(delay);
413 });
414 }
415
416 #[test]
reset_past_delay_before_turn()417 fn reset_past_delay_before_turn() {
418 mocked(|timer, time| {
419 let mut delay = Delay::new(time.now() + ms(100));
420
421 assert_not_ready!(delay);
422
423 delay.reset(time.now() + ms(80));
424
425 turn(timer, None);
426 assert_eq!(time.advanced(), ms(64));
427
428 assert_not_ready!(delay);
429
430 turn(timer, None);
431 assert_eq!(time.advanced(), ms(80));
432
433 assert_ready!(delay);
434 });
435 }
436
437 #[test]
reset_past_delay_before_fire()438 fn reset_past_delay_before_fire() {
439 mocked(|timer, time| {
440 let mut delay = Delay::new(time.now() + ms(100));
441
442 assert_not_ready!(delay);
443 turn(timer, ms(10));
444
445 assert_not_ready!(delay);
446 delay.reset(time.now() + ms(80));
447
448 turn(timer, None);
449 assert_eq!(time.advanced(), ms(64));
450
451 assert_not_ready!(delay);
452
453 turn(timer, None);
454 assert_eq!(time.advanced(), ms(90));
455
456 assert_ready!(delay);
457 });
458 }
459
460 #[test]
reset_future_delay_after_fire()461 fn reset_future_delay_after_fire() {
462 mocked(|timer, time| {
463 let mut delay = Delay::new(time.now() + ms(100));
464
465 assert_not_ready!(delay);
466
467 turn(timer, ms(1000));
468 assert_eq!(time.advanced(), ms(64));
469
470 turn(timer, None);
471 assert_eq!(time.advanced(), ms(100));
472
473 assert_ready!(delay);
474
475 delay.reset(time.now() + ms(10));
476 assert_not_ready!(delay);
477
478 turn(timer, ms(1000));
479 assert_eq!(time.advanced(), ms(110));
480
481 assert_ready!(delay);
482 });
483 }
484
485 #[test]
delay_with_default_handle()486 fn delay_with_default_handle() {
487 let handle = Handle::default();
488 let now = Instant::now();
489
490 let mut delay = handle.delay(now + ms(1));
491
492 mocked_with_now(now, |timer, _time| {
493 assert_not_ready!(delay);
494
495 turn(timer, ms(1));
496
497 assert_ready!(delay);
498 });
499 }
500