fugle 0.3.8

A Simple, Lightweight, Fast and Safe Fugle Library
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

#![macro_use]
use std::time::Duration;

use fugle::{errors::FugleError, schema::Result};

macro_rules! assert_err {
    ($expression:expr, $($pattern:tt)+) => {
        match $expression {
            $($pattern)+ => (),
            ref e => panic!("expected: {} but got: {:?}", stringify!($($pattern)+), e),
        }
    }
}

pub(crate) fn timeout_after<T, F>(d: Duration, f: F) -> T
where
    T: Send + 'static,
    F: FnOnce() -> T,
    F: Send + 'static,
{
    use std::{sync::mpsc, thread};

    let (done_tx, done_rx) = mpsc::channel();
    let handle = thread::spawn(move || {
        let val = f();
        done_tx.send(()).expect("unable to send completion signal");
        val
    });

    match done_rx.recv_timeout(d) {
        Ok(_) => handle.join().expect("thread panicked"),
        Err(_) => panic!("thread took too long"),
    }
}
pub(crate) async fn async_timeout_after<F, Fut>(d: Duration, f: F)
where
    F: FnOnce() -> Fut,
    F: Send + 'static,
    Fut: std::future::Future,
    Fut: Send + 'static,
{
    use tokio::{
        sync::oneshot::channel,
        time::{interval_at, Instant},
    };

    let mut timeout = interval_at(Instant::now() + d, d);
    let (done_tx, done_rx) = channel();
    tokio::spawn(async {
        f().await;
        done_tx.send(()).expect("unable to send completion signal");
    });

    'looper: loop {
        tokio::select! {
            _ = done_rx => { break 'looper }
            _ = timeout.tick() => { panic!("routine took too long") }
        }
    }
}

#[test]
fn test_assert_err() {
    let some_fn = || -> Result<()> { Err(FugleError::ResourceNotFound) };
    assert_err!(some_fn(), Err(FugleError::ResourceNotFound));
}

#[test]
#[should_panic]
fn test_timeout_after() {
    timeout_after(Duration::from_millis(100), || {
        std::thread::sleep(Duration::from_millis(200));
    })
}

#[tokio::test]
#[should_panic]
async fn test_async_timeout_after() {
    async_timeout_after(Duration::from_millis(100), move || async move {
        tokio::time::sleep(Duration::from_millis(200)).await;
    })
    .await
}