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

Remove 9 redundant and non-valuable tests to improve test suite quality (#4)

Browse Source 
* Initial plan

* Remove 9 redundant and non-valuable tests across events, formatting, and item modules

Co-authored-by: Xevion <44609630+Xevion@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: Xevion <44609630+Xevion@users.noreply.github.com>
This commit is contained in:
Copilot
2025-08-19 13:07:14 -05:00
committed by GitHub
parent 8b5e66f514
commit 67a5c4a1ed
3 changed files with 2 additions and 101 deletions
Download Patch File Download Diff File Expand all files Collapse all files

75
tests/events.rs
View File

@@ -1,60 +1,13 @@
use pacman::events::{GameCommand, GameEvent};
use pacman::map::direction::Direction;
#[test]
fn test_game_command_variants() {
// Test that all GameCommand variants can be created
let commands = [
GameCommand::Exit,
GameCommand::MovePlayer(Direction::Up),
GameCommand::MovePlayer(Direction::Down),
GameCommand::MovePlayer(Direction::Left),
GameCommand::MovePlayer(Direction::Right),
GameCommand::ToggleDebug,
GameCommand::MuteAudio,
GameCommand::ResetLevel,
GameCommand::TogglePause,
];
// Just verify they can be created and compared
assert_eq!(commands.len(), 9);
assert_eq!(commands[0], GameCommand::Exit);
assert_eq!(commands[1], GameCommand::MovePlayer(Direction::Up));
}
#[test]
fn test_game_command_equality() {
assert_eq!(GameCommand::Exit, GameCommand::Exit);
assert_eq!(GameCommand::ToggleDebug, GameCommand::ToggleDebug);
assert_eq!(
GameCommand::MovePlayer(Direction::Left),
GameCommand::MovePlayer(Direction::Left)
);
assert_ne!(GameCommand::Exit, GameCommand::ToggleDebug);
assert_ne!(
GameCommand::MovePlayer(Direction::Left),
GameCommand::MovePlayer(Direction::Right)
);
}
#[test]
fn test_game_event_variants() {
let command_event = GameEvent::Command(GameCommand::Exit);
let collision_event = GameEvent::Collision(bevy_ecs::entity::Entity::from_raw(1), bevy_ecs::entity::Entity::from_raw(2));
// Test that events can be created and compared
assert_eq!(command_event, GameEvent::Command(GameCommand::Exit));
assert_ne!(command_event, collision_event);
}
#[test]
fn test_game_command_to_game_event_conversion() {
let command = GameCommand::ToggleDebug;
let event: GameEvent = command.into();
assert_eq!(event, GameEvent::Command(GameCommand::ToggleDebug));
}
#[test]
fn test_game_command_to_game_event_conversion_all_variants() {
@@ -73,34 +26,8 @@ fn test_game_command_to_game_event_conversion_all_variants() {
}
}
#[test]
fn test_move_player_all_directions() {
let directions = [Direction::Up, Direction::Down, Direction::Left, Direction::Right];
for direction in directions {
let command = GameCommand::MovePlayer(direction);
let event: GameEvent = command.into();
if let GameEvent::Command(GameCommand::MovePlayer(dir)) = event {
assert_eq!(dir, direction);
} else {
panic!("Expected MovePlayer command with direction {:?}", direction);
}
}
}
#[test]
fn test_game_event_debug_format() {
let event = GameEvent::Command(GameCommand::Exit);
let debug_str = format!("{:?}", event);
assert!(debug_str.contains("Command"));
assert!(debug_str.contains("Exit"));
}
#[test]
fn test_game_command_debug_format() {
let command = GameCommand::MovePlayer(Direction::Left);
let debug_str = format!("{:?}", command);
assert!(debug_str.contains("MovePlayer"));
assert!(debug_str.contains("Left"));
}

7
tests/formatting.rs
View File

@@ -119,12 +119,7 @@ fn test_format_timing_display_basic() {
}
}
#[test]
fn test_format_timing_display_empty() {
let timing_data = vec![];
let formatted = format_timing_display(timing_data);
assert!(formatted.is_empty());
}
#[test]
fn test_format_timing_display_units() {

21
tests/item.rs
View File

@@ -16,7 +16,6 @@ fn test_calculate_score_for_item() {
assert!(EntityType::Pellet.score_value() < EntityType::PowerPellet.score_value());
assert!(EntityType::Pellet.score_value().is_some());
assert!(EntityType::PowerPellet.score_value().is_some());
assert!(EntityType::Pellet.score_value().unwrap() < EntityType::PowerPellet.score_value().unwrap());
assert!(EntityType::Player.score_value().is_none());
assert!(EntityType::Ghost.score_value().is_none());
}
@@ -194,27 +193,7 @@ fn test_item_system_ignores_non_item_collisions() {
assert_eq!(ghost_count, 1);
}
#[test]
fn test_item_system_wrong_collision_order() {
let mut world = create_test_world();
let pacman = spawn_test_pacman(&mut world);
let pellet = spawn_test_item(&mut world, EntityType::Pellet);
// Send collision event with entities in reverse order
send_collision_event(&mut world, pellet, pacman);
world.run_system_once(item_system).expect("System should run successfully");
// Should still work correctly
let score = world.resource::<ScoreResource>();
assert_eq!(score.0, 10);
let pellet_count = world
.query::<&EntityType>()
.iter(&world)
.filter(|&entity_type| matches!(entity_type, EntityType::Pellet))
.count();
assert_eq!(pellet_count, 0);
}
#[test]
fn test_item_system_no_collision_events() {