compact-waitgroup 0.3.6

A compact asynchronous WaitGroup synchronization primitive.
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

#![cfg(loom)]

pub(super) trait FutureTestExt {
    fn wait_in_place(self);
    fn run_in_background(self);
}

impl<T: Future + 'static> FutureTestExt for T {
    fn wait_in_place(self) {
        loom::future::block_on(self);
    }

    fn run_in_background(self) {
        loom::thread::spawn(move || {
            self.wait_in_place();
        });
    }
}

// #[should_panic]

macro_rules! loom_test_case {
    (async $fn_name:ident, $builder_modifier:expr) => {
        #[test]
        fn $fn_name() {
            let mut builder = loom::model::Builder::new();
            ($builder_modifier)(&mut builder);
            builder.check(|| {
                $crate::tests::default::$fn_name().wait_in_place();
            });
        }
    };
    (panic $fn_name:ident, $builder_modifier:expr) => {
        #[test]
        #[should_panic]
        fn $fn_name() {
            let mut builder = loom::model::Builder::new();
            ($builder_modifier)(&mut builder);
            builder.check(|| {
                $crate::tests::default::$fn_name();
            });
        }
    };
    ($fn_name:ident, $builder_modifier:expr) => {
        #[test]
        fn $fn_name() {
            let mut builder = loom::model::Builder::new();
            ($builder_modifier)(&mut builder);
            builder.check(|| {
                $crate::tests::default::$fn_name();
            });
        }
    };
    ($token:tt $fn_name:ident) => {
        loom_test_case!($token $fn_name, |_| {});
    };
    ($fn_name:ident) => {
        loom_test_case!($fn_name, |_| {});
    };
}

// base
loom_test_case!(test_mono_wg_done);
loom_test_case!(test_mono_wg_drop_before_send);
loom_test_case!(test_mono_wg_send_before_poll);
loom_test_case!(test_wg_done);
loom_test_case!(test_wg_done_twice);
loom_test_case!(test_wg_done_twice_rev);
loom_test_case!(test_wg_drop_before_send);
loom_test_case!(test_wg_drop_early);
loom_test_case!(test_wg_poll_by_others);
loom_test_case!(test_wg_send_before_poll);

// futures
loom_test_case!(async test_mono_wg_await_background);
loom_test_case!(async test_mono_wg_pinned_drop_in_another_thread);
loom_test_case!(async test_wg_await);
loom_test_case!(async test_wg_await_background);
loom_test_case!(async test_wg_await_background_twice);
loom_test_case!(async test_wg_await_background_twice_rev);
loom_test_case!(async test_wg_await_multiple_repeat_n);
loom_test_case!(async test_wg_await_multiple_repeat_with);
loom_test_case!(async test_wg_await_pin_multiple_repeat_n);
loom_test_case!(async test_wg_await_pin_multiple_repeat_with);
loom_test_case! {
    async test_mono_wg_await_pin_multiple_threads,
    |builder: &mut loom::model::Builder| {
        builder.preemption_bound = Some(2);
    }
}
loom_test_case! {
    async test_wg_await_pin_multiple_threads,
    |builder: &mut loom::model::Builder| {
        builder.preemption_bound = Some(2);
    }
}

// panic
loom_test_case!(panic test_mono_wg_panic_both);
loom_test_case!(panic test_mono_wg_panic_handle);
loom_test_case!(panic test_mono_wg_panic_wg);
loom_test_case!(panic test_wg_panic_both);
loom_test_case!(panic test_wg_panic_handle);
loom_test_case!(panic test_wg_panic_wg);

// twin_ref
loom_test_case!(test_twin_ref_clonable);
loom_test_case!(test_twin_ref_mono);