nio 0.1.4

Async runtime for Rust
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

use nio::{Sleep, test};
use std::time::{Duration, Instant};

mod support {
    pub mod futures;
}
use support::futures::test::{assert_pending, task};

#[test]
async fn immediate_sleep() {
    let iter = if cfg!(miri) { 10 } else { 1000 };
    for _ in 0..iter {
        let now = Instant::now();
        let mut sleep = Sleep::at(now);
        (&mut sleep).await;
        assert!(sleep.is_elapsed())
    }
}

#[test]
async fn is_elapsed() {
    let now = Instant::now();
    let mut sleep = Sleep::at(now + Duration::from_millis(10));

    assert!(!sleep.is_elapsed());
    assert!(futures::poll!(&mut sleep).is_pending());
    assert!(!sleep.is_elapsed());

    (&mut sleep).await;
    assert!(sleep.is_elapsed());
}

#[test]
async fn reset_future_sleep_before_fire() {
    let now = Instant::now();

    let mut sleep = task::spawn(Sleep::at(now + ms(100)));
    assert_pending!(sleep.poll());

    let mut sleep = sleep.into_inner();

    sleep.reset_at(Instant::now() + ms(200));
    sleep.await;

    assert!(now.elapsed() >= ms(200));
}

#[test]
async fn reset_past_sleep_before_fire() {
    let now = Instant::now();

    let mut sleep = task::spawn(Sleep::at(now + ms(200)));
    assert_pending!(sleep.poll());

    let mut sleep = sleep.into_inner();

    nio::sleep(ms(20)).await;

    sleep.reset_at(now + ms(80));
    sleep.await;

    assert!(now.elapsed() >= ms(80));
}

fn ms(n: u64) -> Duration {
    Duration::from_millis(n)
}