compio-runtime 0.12.6

High-level runtime for compio
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

use std::{
    cell::Cell,
    panic::{AssertUnwindSafe, catch_unwind},
    rc::Rc,
    time::Duration,
};

use compio_runtime::time::sleep;

#[test]
#[should_panic]
fn panic_spawn() {
    compio_runtime::Runtime::new().unwrap().block_on(async {
        let _handle = compio_runtime::spawn(async {
            sleep(Duration::from_millis(100)).await;
            panic!("test panic in spawn");
        });
        sleep(Duration::from_millis(100)).await;
        panic!("another panic");
    })
}

#[test]
fn timer_construction_does_not_require_runtime() {
    let timer = sleep(Duration::ZERO);
    compio_runtime::Runtime::new().unwrap().block_on(timer);
}

struct DropGuard(Rc<Cell<bool>>);

impl Drop for DropGuard {
    fn drop(&mut self) {
        self.0.set(true);
    }
}

#[test]
fn panic_clears_spawned_tasks() {
    let dropped = Rc::new(Cell::new(false));
    let observed = dropped.clone();
    let runtime = compio_runtime::Runtime::new().unwrap();

    let result = catch_unwind(AssertUnwindSafe(|| {
        runtime.block_on(async move {
            compio_runtime::spawn(async move {
                let _guard = DropGuard(dropped);
                sleep(Duration::from_secs(1)).await;
            })
            .detach();

            sleep(Duration::from_millis(10)).await;
            panic!("panic while a spawned task is pending");
        });
    }));

    let dropped_before_runtime_drop = observed.get();
    drop(runtime);

    assert!(result.is_err());
    assert!(
        dropped_before_runtime_drop,
        "pending task was not dropped before the panic resumed"
    );
}