Pac-Man/pacman/tests/profiling.rs

// use pacman::systems::profiling::SystemId;
// use speculoos::prelude::*;
// use std::time::Duration;
// use strum::IntoEnumIterator;

// macro_rules! assert_close {
//     ($actual:expr, $expected:expr, $concern:expr) => {
//         let tolerance = Duration::from_micros(500);
//         let diff = $actual.abs_diff($expected);
//         assert_that(&(diff < tolerance)).is_true();
//     };
// }

// #[test]
// fn test_timing_statistics() {
//     let timings = SystemTimings::default();

//     // Add consecutive timing measurements (no skipped ticks to avoid zero padding)
//     timings.add_timing(SystemId::PlayerControls, Duration::from_millis(10), 1);
//     timings.add_timing(SystemId::PlayerControls, Duration::from_millis(12), 2);
//     timings.add_timing(SystemId::PlayerControls, Duration::from_millis(8), 3);

//     // Add consecutive timing measurements for another system
//     timings.add_timing(SystemId::Blinking, Duration::from_millis(3), 1);
//     timings.add_timing(SystemId::Blinking, Duration::from_millis(2), 2);
//     timings.add_timing(SystemId::Blinking, Duration::from_millis(1), 3);

//     {
//         let stats = timings.get_stats(3);
//         let (avg, std_dev) = stats.get(&SystemId::PlayerControls).unwrap();

//         assert_close!(*avg, Duration::from_millis(10), "PlayerControls average timing");
//         assert_close!(*std_dev, Duration::from_millis(2), "PlayerControls standard deviation timing");
//     }

//     // Note: get_total_stats() was removed as we now use the Total system directly
//     // This test now focuses on individual system statistics
// }

// #[test]
// fn test_default_zero_timing_for_unused_systems() {
//     let timings = SystemTimings::default();

//     // Add timing data for only one system
//     timings.add_timing(SystemId::PlayerControls, Duration::from_millis(5), 1);

//     let stats = timings.get_stats(1);

//     // Verify all SystemId variants are present in the stats
//     let expected_count = SystemId::iter().count();
//     assert_that(&stats.len()).is_equal_to(expected_count);

//     // Verify that the system with data has non-zero timing
//     let (avg, std_dev) = stats.get(&SystemId::PlayerControls).unwrap();
//     assert_close!(*avg, Duration::from_millis(5), "System with data should have correct timing");
//     assert_close!(*std_dev, Duration::ZERO, "Single measurement should have zero std dev");

//     // Verify that all other systems have zero timing (excluding Total which is special)
//     for id in SystemId::iter() {
//         if id != SystemId::PlayerControls && id != SystemId::Total {
//             let (avg, std_dev) = stats.get(&id).unwrap();
//             assert_close!(
//                 *avg,
//                 Duration::ZERO,
//                 format!("Unused system {:?} should have zero avg timing", id)
//             );
//             assert_close!(
//                 *std_dev,
//                 Duration::ZERO,
//                 format!("Unused system {:?} should have zero std dev", id)
//             );
//         }
//     }
// }

// #[test]
// fn test_total_system_timing() {
//     let timings = SystemTimings::default();

//     // Add some timing data to the Total system
//     timings.add_total_timing(Duration::from_millis(16), 1);
//     timings.add_total_timing(Duration::from_millis(18), 2);
//     timings.add_total_timing(Duration::from_millis(14), 3);

//     let stats = timings.get_stats(3);
//     let (avg, std_dev) = stats.get(&SystemId::Total).unwrap();

//     // Should have 16ms average (16+18+14)/3 = 16ms
//     assert_close!(*avg, Duration::from_millis(16), "Total system average timing");
//     // Should have some standard deviation
//     assert_that(&(*std_dev > Duration::ZERO)).is_true();
// }