epox 0.2.4

An epoll driven async executor.
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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

const SHUTDOWN_AFTER_MILLIS: u64 = 100;

const SHUTDOWN_AFTER: std::time::Duration = std::time::Duration::from_millis(100);
const WILL_COMPLETE: std::time::Duration =
    std::time::Duration::from_millis(SHUTDOWN_AFTER_MILLIS / 2);
const WILL_NOT_COMPLETE: std::time::Duration =
    std::time::Duration::from_millis(SHUTDOWN_AFTER_MILLIS * 2);

#[test]
fn shutdown() {
    let calls_shutdown = epox::spawn(async move {
        let mut timer = epox::Timer::new().unwrap();
        timer
            .set(epox::timer::Expiration::OneShot(SHUTDOWN_AFTER.into()))
            .unwrap();
        timer.tick().await.unwrap();
        println!("timer finished; shutdown now");

        epox::shutdown().await;
    });
    let will_complete = epox::spawn(async move {
        let mut timer = epox::Timer::new().unwrap();
        timer
            .set(epox::timer::Expiration::OneShot(WILL_COMPLETE.into()))
            .unwrap();
        timer.tick().await.unwrap();
        println!("timer finished; will_complete complete");

        "return value"
    });
    let will_not_complete = epox::spawn(async move {
        let mut timer = epox::Timer::new().unwrap();
        timer
            .set(epox::timer::Expiration::OneShot(WILL_NOT_COMPLETE.into()))
            .unwrap();
        timer.tick().await.unwrap();
        println!("timer finished; will_not_complete complete");

        "return value"
    });

    epox::run().unwrap();

    assert!(will_complete.result().is_some());
    assert!(will_not_complete.result().is_none());
    assert!(calls_shutdown.result().is_none());
}

#[test]
fn shutdown_executor_unchecked() {
    let calls_shutdown = epox::spawn(async move {
        let mut timer = epox::Timer::new().unwrap();
        timer
            .set(epox::timer::Expiration::OneShot(SHUTDOWN_AFTER.into()))
            .unwrap();
        timer.tick().await.unwrap();
        println!("timer finished; shutdown now");

        unsafe { epox::executor::shutdown_executor_unchecked() };
        "return value"
    });
    let will_complete = epox::spawn(async move {
        let mut timer = epox::Timer::new().unwrap();
        timer
            .set(epox::timer::Expiration::OneShot(WILL_COMPLETE.into()))
            .unwrap();
        timer.tick().await.unwrap();
        println!("timer finished; will_complete complete");

        "return value"
    });
    let will_not_complete = epox::spawn(async move {
        let mut timer = epox::Timer::new().unwrap();
        timer
            .set(epox::timer::Expiration::OneShot(WILL_NOT_COMPLETE.into()))
            .unwrap();
        timer.tick().await.unwrap();
        println!("timer finished; will_not_complete complete");

        "return value"
    });

    epox::run().unwrap();

    assert!(will_complete.result().is_some());
    assert!(will_not_complete.result().is_none());
    // shutdown_executor_unchecked lets calls_shutdown return a value
    assert!(calls_shutdown.result().is_some());
}

#[test]
fn spawn_checked() {
    let will_complete = epox::spawn(async move {
        let mut timer = epox::Timer::new().unwrap();
        timer
            .set(epox::timer::Expiration::OneShot(WILL_COMPLETE.into()))
            .unwrap();
        timer.tick().await.unwrap();
        println!("timer finished; will_complete complete");

        "return value"
    });
    // will loop 3x before returning an error, and should never return Ok
    let will_error = epox::spawn_checked::<(), Box<dyn std::error::Error>, _>(async move {
        let mut num = 0;
        loop {
            let mut timer = epox::Timer::new().unwrap();
            timer
                .set(epox::timer::Expiration::OneShot(
                    (SHUTDOWN_AFTER / 3).into(),
                ))
                .unwrap();
            timer.tick().await.unwrap();

            (num < 3).then_some(()).ok_or("error")?;

            num += 1;
        }
    });

    let will_not_complete = epox::spawn(async move {
        let mut timer = epox::Timer::new().unwrap();
        timer
            .set(epox::timer::Expiration::OneShot(WILL_NOT_COMPLETE.into()))
            .unwrap();
        timer.tick().await.unwrap();
        println!("timer finished; will_not_complete complete");

        "return value"
    });

    epox::run().unwrap();

    assert!(will_error.result().is_some_and(|r| r.is_err()));

    assert!(will_complete.result().is_some());
    assert!(will_not_complete.result().is_none());
}