dportable 0.1.5

Portable interface for various utilities.
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

#[cfg(not(target_arch = "wasm32"))]
mod native;

#[cfg(not(target_arch = "wasm32"))]
pub use native::*;

#[cfg(target_arch = "wasm32")]
mod wasm;

#[cfg(target_arch = "wasm32")]
pub use wasm::*;

#[cfg(test)]
mod tests {
    use std::time::Duration;

    use super::CancellationToken;
    use crate::test::{dtest, dtest_configure};
    use crate::time::*;

    dtest_configure!();

    #[dtest]
    async fn test_cancellation_token() {
        let token = CancellationToken::new();
        token.cancel();
        assert!(token.is_cancelled());
        token.cancelled().await;

        let token = CancellationToken::new();
        let result = token.run_until_cancelled(async {
            sleep(Duration::from_millis(10)).await;
            ()
        });
        token.cancel();
        assert!(result.await.is_none());
    }

    #[dtest]
    async fn test_child_token() {
        let token = CancellationToken::new();
        let child_token = token.child_token();
        token.cancel();
        assert!(child_token.is_cancelled());

        let token = CancellationToken::new();
        let child_token = token.child_token();
        child_token.cancel();
        assert!(!token.is_cancelled());
        assert!(child_token.is_cancelled());

        let token = CancellationToken::new();
        let child_token = token.child_token();
        let result = token.run_until_cancelled(async {
            sleep(Duration::from_millis(10)).await;
            ()
        });
        let child_result = child_token.run_until_cancelled(async {
            sleep(Duration::from_millis(10)).await;
            ()
        });
        token.cancel();
        assert!(result.await.is_none());
        assert!(child_result.await.is_none());

        let token = CancellationToken::new();
        let child_token = token.child_token();
        let result = token.run_until_cancelled(async {
            sleep(Duration::from_millis(10)).await;
            ()
        });
        let child_result = child_token.run_until_cancelled(async {
            sleep(Duration::from_millis(10)).await;
            ()
        });
        child_token.cancel();
        assert!(result.await.is_some());
        assert!(child_result.await.is_none());
    }
}