tokio-os-timer 0.1.8

Timer facilities for Tokio based on OS-level primitives.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

// heavily copied from https://github.com/tokio-rs/tokio/blob/master/tokio-timer/tests/delay.rs

use futures::Stream;
use std::time::Duration;
use tokio_os_timer::Interval;

macro_rules! assert_ready {
    ($f:expr) => {{
        use ::futures::Async::*;

        match $f.poll().unwrap() {
            Ready(v) => v,
            NotReady => panic!("NotReady"),
        }
    }};
    ($f:expr, $($msg:expr),+) => {{
        use ::futures::Async::*;

        match $f.poll().unwrap() {
            Ready(v) => v,
            NotReady => {
                let msg = format!($($msg),+);
                panic!("NotReady; {}", msg)
            }
        }
    }}
}

macro_rules! assert_not_ready {
    ($f:expr) => {{
        let res = $f.poll().unwrap();
        assert!(!res.is_ready(), "actual={:?}", res)
    }};
    ($f:expr, $($msg:expr),+) => {{
        let res = $f.poll().unwrap();
        if res.is_ready() {
            let msg = format!($($msg),+);
            panic!("actual={:?}; {}", res, msg);
        }
    }};
}
#[test]
fn immediate() {
    let mut mock = tokio_mock_task::MockTask::new();
    let mut interval = Interval::new(Duration::new(0, 0)).unwrap();
    assert!(mock.enter(|| assert_ready!(interval)).is_some());
    assert!(mock.enter(|| assert_ready!(interval)).is_some());
}

#[test]
fn delayed() {
    let mut mock = tokio_mock_task::MockTask::new();
    let interval = Duration::from_millis(500);
    let mut t = Interval::new(interval).unwrap();
    mock.enter(|| assert_not_ready!(t));
    // sleep until a time when timer still hasn't expired
    std::thread::sleep(Duration::from_millis(250));
    mock.enter(|| assert_not_ready!(t));
    // sleep until interval has passed
    std::thread::sleep(Duration::from_millis(500));
    assert!(mock.enter(|| assert_ready!(t)).is_some());
    mock.enter(|| assert_not_ready!(t));
    // sleep until a time when timer still hasn't expired
    std::thread::sleep(Duration::from_millis(100));
    mock.enter(|| assert_not_ready!(t));
    // sleep until interval has passed again
    std::thread::sleep(Duration::from_millis(300));
    assert!(mock.enter(|| assert_ready!(t)).is_some());
    mock.enter(|| assert_not_ready!(t));
}