xevion/Pac-Man
1
0
Fork 0
mirror of https://github.com/Xevion/Pac-Man.git synced 2025-12-12 18:12:22 -06:00
Code Issues Packages Projects Releases Wiki Activity

test: better formatting tests, alignment-based

Browse Source
This commit is contained in:
Xevion
2025-08-15 19:39:59 -05:00
parent f1935ad016
commit 30d76608dd
1 changed files with 84 additions and 122 deletions
Download Patch File Download Diff File Expand all files Collapse all files

206
tests/formatting.rs
View File

@@ -1,135 +1,97 @@
use itertools::izip;
use pacman::systems::formatting::format_timing_display; use pacman::systems::formatting::format_timing_display;
use smallvec::SmallVec;
use std::time::Duration; use std::time::Duration;
#[test] use pretty_assertions::assert_eq;
fn test_basic_formatting() {
let timing_data = vec![ fn get_timing_data() -> Vec<(String, Duration, Duration)> {
("60 FPS".to_string(), Duration::from_micros(1234), Duration::from_micros(567)), vec![
("input".to_string(), Duration::from_micros(123), Duration::from_micros(45)), ("total".to_string(), Duration::from_micros(1234), Duration::from_micros(570)),
("input".to_string(), Duration::from_micros(120), Duration::from_micros(45)),
("player".to_string(), Duration::from_micros(456), Duration::from_micros(123)), ("player".to_string(), Duration::from_micros(456), Duration::from_micros(123)),
("movement".to_string(), Duration::from_micros(789), Duration::from_micros(234)), ("movement".to_string(), Duration::from_micros(789), Duration::from_micros(234)),
("render".to_string(), Duration::from_micros(12), Duration::from_micros(3)), ("render".to_string(), Duration::from_micros(12), Duration::from_micros(3)),
("debug".to_string(), Duration::from_nanos(1000000), Duration::from_nanos(1000)), ("debug".to_string(), Duration::from_nanos(460), Duration::from_nanos(557)),
]; ]
}
let result = format_timing_display(timing_data); fn get_formatted_output() -> impl IntoIterator<Item = String> {
println!("Basic formatting test:"); format_timing_display(get_timing_data())
println!("{}", result);
println!();
} }
#[test] #[test]
fn test_desired_format() { fn test_formatting_alignment() {
// This test represents the exact format you want to achieve let mut colon_positions = vec![];
let timing_data = vec![ let mut first_decimal_positions = vec![];
("total".to_string(), Duration::from_micros(1230), Duration::from_micros(570)), let mut second_decimal_positions = vec![];
("input".to_string(), Duration::from_micros(120), Duration::from_micros(50)), let mut first_unit_positions = vec![];
("player".to_string(), Duration::from_micros(460), Duration::from_micros(120)), let mut second_unit_positions = vec![];
("movement".to_string(), Duration::from_micros(790), Duration::from_micros(230)),
("render".to_string(), Duration::from_micros(10), Duration::from_micros(3)),
("debug".to_string(), Duration::from_nanos(1000000), Duration::from_nanos(1000)),
];
let result = format_timing_display(timing_data); get_formatted_output().into_iter().for_each(|line| {
println!("Desired format test:"); let (mut got_decimal, mut got_unit) = (false, false);
println!("{}", result); for (i, char) in line.chars().enumerate() {
println!(); match char {
':' => colon_positions.push(i),
'.' => {
if got_decimal {
second_decimal_positions.push(i);
} else {
first_decimal_positions.push(i);
}
got_decimal = true;
}
's' => {
if got_unit {
first_unit_positions.push(i);
} else {
second_unit_positions.push(i);
got_unit = true;
}
}
_ => {}
}
}
});
// Expected output should look like: // Assert that all positions were found
// total : 1.23 ms ± 0.57 ms assert_eq!(
// input : 0.12 ms ± 0.05 ms vec![
// player : 0.46 ms ± 0.12 ms &colon_positions,
// movement : 0.79 ms ± 0.23 ms &first_decimal_positions,
// render : 0.01 ms ± 0.003ms &second_decimal_positions,
// debug : 0.001ms ± 0.000ms &first_unit_positions,
} &second_unit_positions
]
#[test] .iter()
fn test_mixed_units() { .all(|p| p.len() == 6),
let timing_data = vec![ true
("60 FPS".to_string(), Duration::from_millis(16), Duration::from_micros(500)), );
(
"fast_system".to_string(), // Assert that all positions are the same
Duration::from_nanos(500000), assert!(
Duration::from_nanos(100000), colon_positions.iter().all(|&p| p == colon_positions[0]),
), "colon positions are not the same {:?}",
( colon_positions
"medium_system".to_string(), );
Duration::from_micros(2500), assert!(
Duration::from_micros(500), first_decimal_positions.iter().all(|&p| p == first_decimal_positions[0]),
), "first decimal positions are not the same {:?}",
("slow_system".to_string(), Duration::from_millis(5), Duration::from_millis(1)), first_decimal_positions
]; );
assert!(
let result = format_timing_display(timing_data); second_decimal_positions.iter().all(|&p| p == second_decimal_positions[0]),
println!("Mixed units test:"); "second decimal positions are not the same {:?}",
println!("{}", result); second_decimal_positions
println!(); );
} assert!(
first_unit_positions.iter().all(|&p| p == first_unit_positions[0]),
#[test] "first unit positions are not the same {:?}",
fn test_trailing_zeros() { first_unit_positions
let timing_data = vec![ );
("60 FPS".to_string(), Duration::from_micros(1000), Duration::from_micros(500)), assert!(
("exact_ms".to_string(), Duration::from_millis(1), Duration::from_micros(100)), second_unit_positions.iter().all(|&p| p == second_unit_positions[0]),
("exact_us".to_string(), Duration::from_micros(1), Duration::from_nanos(100000)), "second unit positions are not the same {:?}",
("exact_ns".to_string(), Duration::from_nanos(1000), Duration::from_nanos(100)), second_unit_positions
]; );
let result = format_timing_display(timing_data);
println!("Trailing zeros test:");
println!("{}", result);
println!();
}
#[test]
fn test_edge_cases() {
let timing_data = vec![
("60 FPS".to_string(), Duration::from_nanos(1), Duration::from_nanos(1)),
("very_small".to_string(), Duration::from_nanos(100), Duration::from_nanos(50)),
("very_large".to_string(), Duration::from_secs(1), Duration::from_millis(100)),
("zero_time".to_string(), Duration::ZERO, Duration::ZERO),
];
let result = format_timing_display(timing_data);
println!("Edge cases test:");
println!("{}", result);
println!();
}
#[test]
fn test_variable_name_lengths() {
let timing_data = vec![
("60 FPS".to_string(), Duration::from_micros(1234), Duration::from_micros(567)),
("a".to_string(), Duration::from_micros(123), Duration::from_micros(45)),
(
"very_long_system_name".to_string(),
Duration::from_micros(456),
Duration::from_micros(123),
),
("medium".to_string(), Duration::from_micros(789), Duration::from_micros(234)),
];
let result = format_timing_display(timing_data);
println!("Variable name lengths test:");
println!("{}", result);
println!();
}
#[test]
fn test_empty_input() {
let timing_data = vec![];
let result = format_timing_display(timing_data);
assert_eq!(result, "");
println!("Empty input test: PASS");
}
#[test]
fn test_single_entry() {
let timing_data = vec![("60 FPS".to_string(), Duration::from_micros(1234), Duration::from_micros(567))];
let result = format_timing_display(timing_data);
println!("Single entry test:");
println!("{}", result);
println!();
} }