shuttle 0.8.1

A library for testing concurrent Rust code
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

use futures::{future::join_all, stream::FuturesUnordered, StreamExt};
use shuttle::{
    check_dfs,
    future::{block_on, spawn, JoinHandle},
};

fn empty_tasks() -> FuturesUnordered<JoinHandle<()>> {
    (0..2).map(|_| spawn(async move {})).collect()
}

#[test]
fn collect_empty_tasks() {
    check_dfs(
        || {
            block_on(async {
                let tasks = empty_tasks();

                let _ = tasks.collect::<Vec<_>>().await;
            })
        },
        None,
    );
}

#[test]
fn next_empty_tasks() {
    check_dfs(
        || {
            block_on(async {
                let mut tasks = empty_tasks();

                while let Some(result) = tasks.next().await {
                    result.unwrap();
                }
            })
        },
        None,
    );
}

#[test]
fn join_all_empty_tasks() {
    check_dfs(
        || {
            block_on(async {
                let tasks = empty_tasks();

                join_all(tasks)
                    .await
                    .into_iter()
                    .collect::<Result<Vec<_>, _>>()
                    .unwrap();
            })
        },
        None,
    );
}