ftt/

lib.rs

// Copyright 2025 Clivern. All rights reserved.
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

#[macro_export]
macro_rules! timed {
    ($name:expr, $code:block) => {{
        let start = std::time::Instant::now();
        let result = $code;
        let elapsed = start.elapsed();
        log::info!("{} took {:?}", $name, elapsed);
        result
    }};
}

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

    #[test]
    fn test_timed_macro_returns_correct_value() {
        let result = timed!("test addition", {
            let x = 5 + 3;
            x
        });
        assert_eq!(result, 8);
    }

    #[test]
    fn test_timed_macro_with_complex_computation() {
        let result = timed!("fibonacci calculation", {
            fn fibonacci(n: u32) -> u32 {
                match n {
                    0 => 0,
                    1 => 1,
                    _ => fibonacci(n - 1) + fibonacci(n - 2),
                }
            }
            fibonacci(10)
        });
        assert_eq!(result, 55);
    }

    #[test]
    fn test_timed_macro_with_side_effects() {
        let mut counter = 0;
        let result = timed!("increment counter", {
            counter += 1;
            counter
        });
        assert_eq!(result, 1);
        assert_eq!(counter, 1);
    }

    #[test]
    fn test_timed_macro_with_string_operations() {
        let result = timed!("string concatenation", {
            let mut s = String::new();
            for i in 0..100 {
                s.push_str(&i.to_string());
            }
            s.len()
        });
        assert_eq!(result, 190); // Sum of digits from 0-99
    }

    #[test]
    fn test_timed_macro_with_vector_operations() {
        let result = timed!("vector operations", {
            let mut vec = Vec::new();
            for i in 0..1000 {
                vec.push(i * i);
            }
            vec.iter().sum::<i32>()
        });
        assert_eq!(result, 332833500); // Sum of squares from 0 to 999
    }

    #[test]
    fn test_timed_macro_measurement_accuracy() {
        let duration = timed!("sleep test", {
            thread::sleep(Duration::from_millis(10));
        });

        // The macro should capture the elapsed time
        // We can't directly test the logged output, but we can verify
        // that the macro executes without panicking and returns the expected value
        assert!(duration == ()); // The block returns unit type
    }

    #[test]
    fn test_timed_macro_with_error_handling() {
        let result = timed!("error handling test", {
            match "42".parse::<i32>() {
                Ok(n) => n * 2,
                Err(_) => -1,
            }
        });
        assert_eq!(result, 84);
    }

    #[test]
    fn test_timed_macro_with_nested_calls() {
        let result = timed!("nested timing", {
            let inner = timed!("inner operation", { 5 * 5 });
            inner + 10
        });
        assert_eq!(result, 35);
    }

    #[test]
    fn test_timed_macro_with_different_data_types() {
        // Test with boolean
        let bool_result = timed!("boolean operation", { true && false });
        assert_eq!(bool_result, false);

        // Test with Option
        let option_result = timed!("option operation", { Some(42).map(|x| x * 2) });
        assert_eq!(option_result, Some(84));

        // Test with Result
        let result_result =
            timed!("result operation", { Ok::<i32, &str>(10).map(|x| x * 3) });
        assert_eq!(result_result, Ok(30));
    }

    #[test]
    fn test_timed_macro_with_closure() {
        let result = timed!("closure test", {
            let closure = |x| x * x;
            (0..10).map(closure).sum::<i32>()
        });
        assert_eq!(result, 285); // Sum of squares from 0 to 9
    }

    #[test]
    fn test_timed_macro_performance_characteristics() {
        // Test that timing overhead is minimal
        let start = std::time::Instant::now();
        let result = timed!("minimal operation", { 1 + 1 });
        let total_time = start.elapsed();

        assert_eq!(result, 2);
        // The total time should be reasonable (less than 1ms for simple operations)
        assert!(total_time < Duration::from_millis(1));
    }

    #[test]
    fn test_timed_macro_with_large_data_processing() {
        let result = timed!("large data processing", {
            let data: Vec<i32> = (0..10000).collect();
            data.iter().filter(|&&x| x % 2 == 0).count()
        });
        assert_eq!(result, 5000);
    }

    #[test]
    fn test_logging_levels_work_correctly() {
        // Test that the macro works with different logging levels
        // The actual log level filtering is handled by the logger implementation
        let result = timed!("debug level test", {
            log::debug!("This is a debug message");
            log::info!("This is an info message");
            log::warn!("This is a warning message");
            42
        });

        assert_eq!(result, 42);
    }

    #[test]
    fn test_multiple_timed_operations() {
        let results = timed!("multiple operations", {
            let op1 = timed!("operation 1", { 1 + 1 });
            let op2 = timed!("operation 2", { 2 * 2 });
            let op3 = timed!("operation 3", { 3 * 3 });
            (op1, op2, op3)
        });

        assert_eq!(results, (2, 4, 9));
    }

    #[test]
    fn test_timed_macro_with_async_simulation() {
        let result = timed!("async simulation", {
            // Simulate some async-like behavior with threads
            let handle = thread::spawn(|| {
                thread::sleep(Duration::from_millis(5));
                42
            });
            handle.join().unwrap()
        });

        assert_eq!(result, 42);
    }
}