hiasync 0.1.2

Supports only single-threaded asynchronous runtime
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

mod task;
pub(crate) use task::*;

mod join;
pub use join::*;

mod waker;
pub use waker::*;

mod future;
pub use future::*;

mod runtime;
pub use runtime::*;

#[cfg(test)]
mod tests {
    use super::*;

    async fn foo(val: i32) -> i32 {
        sched_yield().await;
        val + 1
    }

    #[test]
    fn test0() {
        let mut rt = Runtime::new();
        let _ = rt.spawn(foo(0));
        let cnt = rt.sched();
        assert_eq!(cnt, 1);
        assert_eq!(rt.pending_count(), 0);
    }

    #[test]
    fn test1() {
        let mut rt = Runtime::new();
        let h1 = rt.spawn(foo(0));
        let h2 = rt.spawn(foo(1));
        let cnt = rt.sched();
        assert_eq!(h1.join(), Some(1));
        assert_eq!(h2.join(), Some(2));
        assert_eq!(cnt, 2);
        assert_eq!(rt.pending_count(), 0);
    }

    async fn bar(val: i32) -> i32 {
        *wait_event::<i32>(val as u64).await.unwrap()
    }

    #[test]
    fn test2() {
        let mut rt = Runtime::new();
        let h = rt.spawn(bar(100));
        let cnt = rt.sched();
        assert_eq!(cnt, 0);
        assert_eq!(h.is_finished(), false);
        assert_eq!(rt.pending_count(), 1);
        let cnt = rt.sched_events(&[Event::new(100, &200)]);
        assert_eq!(cnt, 1);
        assert_eq!(h.join(), Some(200));
        assert_eq!(rt.pending_count(), 0);
    }

    #[test]
    fn test3() {
        let mut rt = Runtime::new();
        let h = rt.spawn(bar(100));
        let cnt = rt.sched();
        assert_eq!(cnt, 0);
        assert_eq!(h.is_finished(), false);
        assert_eq!(rt.pending_count(), 1);
        rt.notify_events(&[Event::new(100, &300)]);
        let cnt = rt.sched();
        assert_eq!(cnt, 1);
        assert_eq!(h.join(), Some(300));
        assert_eq!(rt.pending_count(), 0);
    }

    async fn boo(val: i32) -> i32 {
        spawn(foo(val)).await.await
    }

    #[test]
    fn test4() {
        let mut rt = Runtime::new();
        let h = rt.spawn(boo(99));
        let cnt = rt.sched();
        assert_eq!(rt.pending_count(), 0);
        assert_eq!(cnt, 2);
        assert!(h.is_finished());
        assert_eq!(h.join(), Some(100));
    }

    #[test]
    fn test5() {
        let mut rt = Runtime::new();
        let h = rt.spawn(foo(1).and(foo(2)));
        let cnt = rt.sched();
        assert_eq!(rt.pending_count(), 0);
        assert_eq!(cnt, 1);
        assert!(h.is_finished());
        assert_eq!(h.join(), Some((2, 3)));
    }
    #[test]
    fn test6() {
        let mut rt = Runtime::new();
        let h = rt.spawn(foo(1).or(foo(2)));
        let cnt = rt.sched();
        assert_eq!(rt.pending_count(), 0);
        assert_eq!(cnt, 1);
        assert!(h.is_finished());
        assert_eq!(h.join(), Some((Some(2), None)));
    }
}