simple_func_timer 0.1.0

Simple macro to measure the function execution time in Rust
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

#[cfg(test)]
pub mod utils {
    use log::{Level, LevelFilter, Log, Metadata, Record};
    use std::cell::RefCell;
    use std::sync::Once;

    thread_local!(static LOG_RECORDS: RefCell<Vec<TestLog>> = RefCell::new(Vec::with_capacity(1)));

    pub struct TestLog {
        pub body: String,
        pub level: Level,
        pub target: String,
    }

    struct TestingLogger {}

    impl Log for TestingLogger {
        #[allow(unused_variables)]
        fn enabled(&self, metadata: &Metadata) -> bool {
            true // capture all log levels
        }

        fn log(&self, record: &Record) {
            LOG_RECORDS.with(|records| {
                println!("records: {:?}", record.args());
                let captured_record = TestLog {
                    body: format!("{}", record.args()),
                    level: record.level(),
                    target: record.target().to_string(),
                };
                records.borrow_mut().push(captured_record);
            });
        }

        fn flush(&self) {}
    }

    static TEST_LOGGER: TestingLogger = TestingLogger {};
    static FIRST_TEST: Once = Once::new();

    pub fn setup() {
        FIRST_TEST.call_once(|| {
            log::set_logger(&TEST_LOGGER)
                .map(|()| log::set_max_level(LevelFilter::Trace))
                .unwrap();
        });
        LOG_RECORDS.with(|records| {
            records.borrow_mut().truncate(0);
        });
    }

    pub fn validate<F>(asserter: F)
    where
        F: Fn(&Vec<TestLog>),
    {
        LOG_RECORDS.with(|records| {
            asserter(&records.borrow());
            records.borrow_mut().truncate(0);
        });
    }
}