ticked_async_executor 0.4.0

Local executor that runs woken async tasks when it is ticked
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

use ticked_async_executor::TickedAsyncExecutor;

const DELTA: f64 = 1000.0 / 60.0;

#[test]
fn test_tokio_join() {
    let mut executor = TickedAsyncExecutor::default();

    let (tx1, mut rx1) = tokio::sync::mpsc::channel::<usize>(1);
    let (tx2, mut rx2) = tokio::sync::mpsc::channel::<usize>(1);
    executor
        .spawn_local("LocalFuture1", async move {
            let (a, b) = tokio::join!(rx1.recv(), rx2.recv());
            assert_eq!(a.unwrap(), 10);
            assert_eq!(b.unwrap(), 20);
        })
        .detach();

    let (tx3, mut rx3) = tokio::sync::mpsc::channel::<usize>(1);
    let (tx4, mut rx4) = tokio::sync::mpsc::channel::<usize>(1);
    executor
        .spawn_local("LocalFuture2", async move {
            let (a, b) = tokio::join!(rx3.recv(), rx4.recv());
            assert_eq!(a.unwrap(), 10);
            assert_eq!(b.unwrap(), 20);
        })
        .detach();

    tx1.try_send(10).unwrap();
    tx3.try_send(10).unwrap();
    for _ in 0..10 {
        executor.tick(DELTA, None);
    }
    tx2.try_send(20).unwrap();
    tx4.try_send(20).unwrap();

    while executor.num_tasks() != 0 {
        executor.tick(DELTA, None);
    }
}

#[test]
fn test_tokio_select() {
    let mut executor = TickedAsyncExecutor::default();

    let (tx1, mut rx1) = tokio::sync::mpsc::channel::<usize>(1);
    let (_tx2, mut rx2) = tokio::sync::mpsc::channel::<usize>(1);
    executor
        .spawn_local("LocalFuture1", async move {
            tokio::select! {
                data = rx1.recv() => {
                    assert_eq!(data.unwrap(), 10);
                }
                _ = rx2.recv() => {}
            }
        })
        .detach();

    let (tx3, mut rx3) = tokio::sync::mpsc::channel::<usize>(1);
    let (_tx4, mut rx4) = tokio::sync::mpsc::channel::<usize>(1);
    executor
        .spawn_local("LocalFuture2", async move {
            tokio::select! {
                data = rx3.recv() => {
                    assert_eq!(data.unwrap(), 10);
                }
                _ = rx4.recv() => {}
            }
        })
        .detach();

    for _ in 0..10 {
        executor.tick(DELTA, None);
    }

    tx1.try_send(10).unwrap();
    tx3.try_send(10).unwrap();
    while executor.num_tasks() != 0 {
        executor.tick(DELTA, None);
    }
}