slow_function_warning 0.6.0

A simple macro that prints a warning if a function takes longer than expected
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use std::{thread, time::Duration};

use slow_function_warning::*;

#[test]
fn warn() {
    #[slow_function_warning(1ms, {*warned = true;})]
    pub fn sleep(millis: u64, warned: &mut bool) {
        thread::sleep(Duration::from_millis(millis));
    }

    let mut warned = false;
    sleep(2, &mut warned);

    assert!(warned);
}

#[test]
fn no_warn() {
    #[slow_function_warning(10ms, {*warned = true;})]
    pub fn sleep(millis: u64, warned: &mut bool) {
        thread::sleep(Duration::from_millis(millis));
    }

    let mut warned = false;
    sleep(1, &mut warned);

    assert!(!warned);
}

#[test]
fn warn_using_params() {
    #[slow_function_warning(1ms, {
        println!("{module}::{function} {param}");
        *warned = true;
    })]
    pub fn sleep(millis: u64, param: &str, warned: &mut bool) {
        thread::sleep(Duration::from_millis(millis));
    }

    let mut warned = false;
    sleep(2, "trace id", &mut warned);

    assert!(warned);
}

#[test]
fn no_warn_using_params() {
    #[slow_function_warning(10ms, {
        println!("{module}::{function} {param}");
        *warned = true;
    })]
    pub fn sleep(millis: u64, param: &str, warned: &mut bool) {
        thread::sleep(Duration::from_millis(millis));
    }

    let mut warned = false;
    sleep(1, "trace id", &mut warned);

    assert!(!warned);
}

#[test]
fn warn_impl() {
    struct MyStruct {
        pub warned: bool,
    }

    impl MyStruct {
        #[slow_function_warning(1ms, {
            println!("{module}::{function} {param}");
            self.warned = true;
        })]
        pub fn sleep(&mut self, millis: u64, param: &str) {
            thread::sleep(Duration::from_millis(millis));
        }
    }

    let mut my_struct = MyStruct { warned: false };
    my_struct.sleep(2, "trace id");

    assert!(my_struct.warned);
}

#[test]
fn no_warn_impl() {
    struct MyStruct {
        pub warned: bool,
    }

    impl MyStruct {
        #[slow_function_warning(10ms, {
            println!("{module}::{function} {param}");
            self.warned = true;
        })]
        pub fn sleep(&mut self, millis: u64, param: &str) {
            thread::sleep(Duration::from_millis(millis));
        }
    }

    let mut my_struct = MyStruct { warned: false };
    my_struct.sleep(1, "trace id");

    assert!(!my_struct.warned);
}

#[tokio::test]
async fn warn_async() {
    #[slow_function_warning(1ms, {
        println!("{module}::{function} {param}");
        *warned = true;
    })]
    pub async fn sleep(millis: u64, param: &str, warned: &mut bool) {
        tokio::time::sleep(Duration::from_millis(millis)).await;
    }

    let mut warned = false;
    sleep(2, "trace id", &mut warned).await;

    assert!(warned);
}

#[tokio::test]
async fn no_warn_async() {
    #[slow_function_warning(50ms, {
        println!("{module}::{function} {param}");
        *warned = true;
    })]
    pub async fn sleep(millis: u64, param: &str, warned: &mut bool) {
        tokio::time::sleep(Duration::from_millis(millis)).await;
    }

    let mut warned = false;
    sleep(1, "trace id", &mut warned).await;

    assert!(!warned);
}