diff --git a/tests/collision.rs b/tests/collision.rs index 25979a2..77360e2 100644 --- a/tests/collision.rs +++ b/tests/collision.rs @@ -1,5 +1,6 @@ use bevy_ecs::system::RunSystemOnce; use pacman::systems::{check_collision, collision_system, Collider, EntityType, GhostState, Position}; +use speculoos::prelude::*; mod common; @@ -9,8 +10,8 @@ fn test_collider_collision_detection() { let collider2 = Collider { size: 8.0 }; // Test collision detection - assert!(collider1.collides_with(collider2.size, 5.0)); // Should collide (distance < 9.0) - assert!(!collider1.collides_with(collider2.size, 15.0)); // Should not collide (distance > 9.0) + assert_that(&collider1.collides_with(collider2.size, 5.0)).is_true(); // Should collide (distance < 9.0) + assert_that(&collider1.collides_with(collider2.size, 15.0)).is_false(); // Should not collide (distance > 9.0) } #[test] @@ -23,13 +24,13 @@ fn test_check_collision_helper() { // Test collision at same position let result = check_collision(&pos1, &collider1, &pos2, &collider2, &map); - assert!(result.is_ok()); - assert!(result.unwrap()); // Should collide at same position + assert_that(&result.is_ok()).is_true(); + assert_that(&result.unwrap()).is_true(); // Should collide at same position // Test collision at different positions let pos3 = Position::Stopped { node: 1 }; // Different position let result = check_collision(&pos1, &collider1, &pos3, &collider2, &map); - assert!(result.is_ok()); + assert_that(&result.is_ok()).is_true(); // May or may not collide depending on actual node positions } diff --git a/tests/constants.rs b/tests/constants.rs index dc2ba94..50b7a70 100644 --- a/tests/constants.rs +++ b/tests/constants.rs @@ -1,35 +1,24 @@ use pacman::constants::*; +use speculoos::prelude::*; #[test] fn test_raw_board_structure() { // Test board dimensions match expected size - assert_eq!(RAW_BOARD.len(), BOARD_CELL_SIZE.y as usize); + assert_that(&RAW_BOARD.len()).is_equal_to(BOARD_CELL_SIZE.y as usize); for row in RAW_BOARD.iter() { - assert_eq!(row.len(), BOARD_CELL_SIZE.x as usize); + assert_that(&row.len()).is_equal_to(BOARD_CELL_SIZE.x as usize); } // Test boundaries are properly walled - assert!(RAW_BOARD[0].chars().all(|c| c == '#')); - assert!(RAW_BOARD[RAW_BOARD.len() - 1].chars().all(|c| c == '#')); + assert_that(&RAW_BOARD[0].chars().all(|c| c == '#')).is_true(); + assert_that(&RAW_BOARD[RAW_BOARD.len() - 1].chars().all(|c| c == '#')).is_true(); } #[test] fn test_raw_board_contains_required_elements() { // Test that essential game elements are present - assert!( - RAW_BOARD.iter().any(|row| row.contains('X')), - "Board should contain Pac-Man start position" - ); - assert!( - RAW_BOARD.iter().any(|row| row.contains("==")), - "Board should contain ghost house door" - ); - assert!( - RAW_BOARD.iter().any(|row| row.chars().any(|c| c == 'T')), - "Board should contain tunnel entrances" - ); - assert!( - RAW_BOARD.iter().any(|row| row.chars().any(|c| c == 'o')), - "Board should contain power pellets" - ); + assert_that(&RAW_BOARD.iter().any(|row| row.contains('X'))).is_true(); + assert_that(&RAW_BOARD.iter().any(|row| row.contains("=="))).is_true(); + assert_that(&RAW_BOARD.iter().any(|row| row.chars().any(|c| c == 'T'))).is_true(); + assert_that(&RAW_BOARD.iter().any(|row| row.chars().any(|c| c == 'o'))).is_true(); } diff --git a/tests/error.rs b/tests/error.rs index 3551f3c..ce806a2 100644 --- a/tests/error.rs +++ b/tests/error.rs @@ -1,73 +1,74 @@ use pacman::error::{ AssetError, EntityError, GameError, GameResult, IntoGameError, MapError, OptionExt, ParseError, ResultExt, TextureError, }; +use speculoos::prelude::*; use std::io; #[test] fn test_game_error_from_asset_error() { let asset_error = AssetError::NotFound("test.png".to_string()); let game_error: GameError = asset_error.into(); - assert!(matches!(game_error, GameError::Asset(_))); + assert_that(&matches!(game_error, GameError::Asset(_))).is_true(); } #[test] fn test_game_error_from_parse_error() { let parse_error = ParseError::UnknownCharacter('Z'); let game_error: GameError = parse_error.into(); - assert!(matches!(game_error, GameError::MapParse(_))); + assert_that(&matches!(game_error, GameError::MapParse(_))).is_true(); } #[test] fn test_game_error_from_map_error() { let map_error = MapError::NodeNotFound(42); let game_error: GameError = map_error.into(); - assert!(matches!(game_error, GameError::Map(_))); + assert_that(&matches!(game_error, GameError::Map(_))).is_true(); } #[test] fn test_game_error_from_texture_error() { let texture_error = TextureError::LoadFailed("Failed to load".to_string()); let game_error: GameError = texture_error.into(); - assert!(matches!(game_error, GameError::Texture(_))); + assert_that(&matches!(game_error, GameError::Texture(_))).is_true(); } #[test] fn test_game_error_from_entity_error() { let entity_error = EntityError::NodeNotFound(10); let game_error: GameError = entity_error.into(); - assert!(matches!(game_error, GameError::Entity(_))); + assert_that(&matches!(game_error, GameError::Entity(_))).is_true(); } #[test] fn test_game_error_from_io_error() { let io_error = io::Error::new(io::ErrorKind::NotFound, "File not found"); let game_error: GameError = io_error.into(); - assert!(matches!(game_error, GameError::Io(_))); + assert_that(&matches!(game_error, GameError::Io(_))).is_true(); } #[test] fn test_asset_error_from_io_error() { let io_error = io::Error::new(io::ErrorKind::PermissionDenied, "Permission denied"); let asset_error: AssetError = io_error.into(); - assert!(matches!(asset_error, AssetError::Io(_))); + assert_that(&matches!(asset_error, AssetError::Io(_))).is_true(); } #[test] fn test_parse_error_display() { let error = ParseError::UnknownCharacter('!'); - assert_eq!(error.to_string(), "Unknown character in board: !"); + assert_that(&error.to_string()).is_equal_to("Unknown character in board: !".to_string()); let error = ParseError::InvalidHouseDoorCount(3); - assert_eq!(error.to_string(), "House door must have exactly 2 positions, found 3"); + assert_that(&error.to_string()).is_equal_to("House door must have exactly 2 positions, found 3".to_string()); } #[test] fn test_entity_error_display() { let error = EntityError::NodeNotFound(42); - assert_eq!(error.to_string(), "Node not found in graph: 42"); + assert_that(&error.to_string()).is_equal_to("Node not found in graph: 42".to_string()); let error = EntityError::EdgeNotFound { from: 1, to: 2 }; - assert_eq!(error.to_string(), "Edge not found: from 1 to 2"); + assert_that(&error.to_string()).is_equal_to("Edge not found: from 1 to 2".to_string()); } #[test] @@ -75,9 +76,9 @@ fn test_into_game_error_trait() { let result: Result = Err(io::Error::new(io::ErrorKind::Other, "test error")); let game_result: GameResult = result.into_game_error(); - assert!(game_result.is_err()); + assert_that(&game_result.is_err()).is_true(); if let Err(GameError::InvalidState(msg)) = game_result { - assert!(msg.contains("test error")); + assert_that(&msg.contains("test error")).is_true(); } else { panic!("Expected InvalidState error"); } @@ -88,7 +89,7 @@ fn test_into_game_error_trait_success() { let result: Result = Ok(42); let game_result: GameResult = result.into_game_error(); - assert_eq!(game_result.unwrap(), 42); + assert_that(&game_result.unwrap()).is_equal_to(42); } #[test] @@ -96,7 +97,7 @@ fn test_option_ext_some() { let option: Option = Some(42); let result: GameResult = option.ok_or_game_error(|| GameError::InvalidState("Not found".to_string())); - assert_eq!(result.unwrap(), 42); + assert_that(&result.unwrap()).is_equal_to(42); } #[test] @@ -104,9 +105,9 @@ fn test_option_ext_none() { let option: Option = None; let result: GameResult = option.ok_or_game_error(|| GameError::InvalidState("Not found".to_string())); - assert!(result.is_err()); + assert_that(&result.is_err()).is_true(); if let Err(GameError::InvalidState(msg)) = result { - assert_eq!(msg, "Not found"); + assert_that(&msg).is_equal_to("Not found".to_string()); } else { panic!("Expected InvalidState error"); } @@ -117,7 +118,7 @@ fn test_result_ext_success() { let result: Result = Ok(42); let game_result: GameResult = result.with_context(|_| GameError::InvalidState("Context".to_string())); - assert_eq!(game_result.unwrap(), 42); + assert_that(&game_result.unwrap()).is_equal_to(42); } #[test] @@ -125,9 +126,9 @@ fn test_result_ext_error() { let result: Result = Err(io::Error::new(io::ErrorKind::Other, "original error")); let game_result: GameResult = result.with_context(|_| GameError::InvalidState("Context error".to_string())); - assert!(game_result.is_err()); + assert_that(&game_result.is_err()).is_true(); if let Err(GameError::InvalidState(msg)) = game_result { - assert_eq!(msg, "Context error"); + assert_that(&msg).is_equal_to("Context error".to_string()); } else { panic!("Expected InvalidState error"); } diff --git a/tests/formatting.rs b/tests/formatting.rs index 35561de..5279016 100644 --- a/tests/formatting.rs +++ b/tests/formatting.rs @@ -1,8 +1,7 @@ use pacman::systems::profiling::format_timing_display; +use speculoos::prelude::*; use std::time::Duration; -use pretty_assertions::assert_eq; - fn get_timing_data() -> Vec<(String, Duration, Duration)> { vec![ ("total".to_string(), Duration::from_micros(1234), Duration::from_micros(570)), @@ -53,45 +52,25 @@ fn test_complex_formatting_alignment() { }); // Assert that all positions were found - assert_eq!( - [ + assert_that( + &[ &colon_positions, &first_decimal_positions, &second_decimal_positions, &first_unit_positions, - &second_unit_positions + &second_unit_positions, ] .iter() .all(|p| p.len() == 6), - true - ); + ) + .is_true(); // Assert that all positions are the same - assert!( - colon_positions.iter().all(|&p| p == colon_positions[0]), - "colon positions are not the same {:?}", - colon_positions - ); - assert!( - first_decimal_positions.iter().all(|&p| p == first_decimal_positions[0]), - "first decimal positions are not the same {:?}", - first_decimal_positions - ); - assert!( - second_decimal_positions.iter().all(|&p| p == second_decimal_positions[0]), - "second decimal positions are not the same {:?}", - second_decimal_positions - ); - assert!( - first_unit_positions.iter().all(|&p| p == first_unit_positions[0]), - "first unit positions are not the same {:?}", - first_unit_positions - ); - assert!( - second_unit_positions.iter().all(|&p| p == second_unit_positions[0]), - "second unit positions are not the same {:?}", - second_unit_positions - ); + assert_that(&colon_positions.iter().all(|&p| p == colon_positions[0])).is_true(); + assert_that(&first_decimal_positions.iter().all(|&p| p == first_decimal_positions[0])).is_true(); + assert_that(&second_decimal_positions.iter().all(|&p| p == second_decimal_positions[0])).is_true(); + assert_that(&first_unit_positions.iter().all(|&p| p == first_unit_positions[0])).is_true(); + assert_that(&second_unit_positions.iter().all(|&p| p == second_unit_positions[0])).is_true(); } #[test] @@ -105,17 +84,17 @@ fn test_format_timing_display_basic() { let formatted = format_timing_display(timing_data); // Should have 3 lines (one for each system) - assert_eq!(formatted.len(), 3); + assert_that(&formatted.len()).is_equal_to(3); // Each line should contain the system name - assert!(formatted.iter().any(|line| line.contains("render"))); - assert!(formatted.iter().any(|line| line.contains("input"))); - assert!(formatted.iter().any(|line| line.contains("physics"))); + assert_that(&formatted.iter().any(|line| line.contains("render"))).is_true(); + assert_that(&formatted.iter().any(|line| line.contains("input"))).is_true(); + assert_that(&formatted.iter().any(|line| line.contains("physics"))).is_true(); // Each line should contain timing information with proper units for line in formatted.iter() { - assert!(line.contains(":"), "Line should contain colon separator: {}", line); - assert!(line.contains("±"), "Line should contain ± symbol: {}", line); + assert_that(&line.contains(":")).is_true(); + assert_that(&line.contains("±")).is_true(); } } @@ -132,10 +111,10 @@ fn test_format_timing_display_units() { // Check that appropriate units are used let all_lines = formatted.join(" "); - assert!(all_lines.contains("s"), "Should contain seconds unit"); - assert!(all_lines.contains("ms"), "Should contain milliseconds unit"); - assert!(all_lines.contains("µs"), "Should contain microseconds unit"); - assert!(all_lines.contains("ns"), "Should contain nanoseconds unit"); + assert_that(&all_lines.contains("s")).is_true(); + assert_that(&all_lines.contains("ms")).is_true(); + assert_that(&all_lines.contains("µs")).is_true(); + assert_that(&all_lines.contains("ns")).is_true(); } #[test] @@ -157,9 +136,6 @@ fn test_format_timing_display_alignment() { // All colons should be at the same position (aligned) if colon_positions.len() > 1 { let first_pos = colon_positions[0]; - assert!( - colon_positions.iter().all(|&pos| pos == first_pos), - "Colons should be aligned at the same position" - ); + assert_that(&colon_positions.iter().all(|&pos| pos == first_pos)).is_true(); } } diff --git a/tests/graph.rs b/tests/graph.rs index 0212430..e070718 100644 --- a/tests/graph.rs +++ b/tests/graph.rs @@ -1,5 +1,6 @@ use pacman::map::direction::Direction; use pacman::map::graph::{Graph, Node, TraversalFlags}; +use speculoos::prelude::*; mod common; @@ -13,10 +14,10 @@ fn test_graph_basic_operations() { position: glam::Vec2::new(16.0, 0.0), }); - assert_eq!(graph.nodes().count(), 2); - assert!(graph.get_node(node1).is_some()); - assert!(graph.get_node(node2).is_some()); - assert!(graph.get_node(999).is_none()); + assert_that(&graph.nodes().count()).is_equal_to(2); + assert_that(&graph.get_node(node1).is_some()).is_true(); + assert_that(&graph.get_node(node2).is_some()).is_true(); + assert_that(&graph.get_node(999).is_none()).is_true(); } #[test] @@ -29,15 +30,15 @@ fn test_graph_connect() { position: glam::Vec2::new(16.0, 0.0), }); - assert!(graph.connect(node1, node2, false, None, Direction::Right).is_ok()); + assert_that(&graph.connect(node1, node2, false, None, Direction::Right).is_ok()).is_true(); let edge1 = graph.find_edge_in_direction(node1, Direction::Right); let edge2 = graph.find_edge_in_direction(node2, Direction::Left); - assert!(edge1.is_some()); - assert!(edge2.is_some()); - assert_eq!(edge1.unwrap().target, node2); - assert_eq!(edge2.unwrap().target, node1); + assert_that(&edge1.is_some()).is_true(); + assert_that(&edge2.is_some()).is_true(); + assert_that(&edge1.unwrap().target).is_equal_to(node2); + assert_that(&edge2.unwrap().target).is_equal_to(node1); } #[test] @@ -47,8 +48,8 @@ fn test_graph_connect_errors() { position: glam::Vec2::new(0.0, 0.0), }); - assert!(graph.connect(node1, 999, false, None, Direction::Right).is_err()); - assert!(graph.connect(999, node1, false, None, Direction::Right).is_err()); + assert_that(&graph.connect(node1, 999, false, None, Direction::Right).is_err()).is_true(); + assert_that(&graph.connect(999, node1, false, None, Direction::Right).is_err()).is_true(); } #[test] @@ -66,7 +67,7 @@ fn test_graph_edge_permissions() { .unwrap(); let edge = graph.find_edge_in_direction(node1, Direction::Right).unwrap(); - assert_eq!(edge.traversal_flags, TraversalFlags::GHOST); + assert_that(&edge.traversal_flags).is_equal_to(TraversalFlags::GHOST); } #[test] @@ -86,10 +87,10 @@ fn should_add_connected_node() { ) .unwrap(); - assert_eq!(graph.nodes().count(), 2); + assert_that(&graph.nodes().count()).is_equal_to(2); let edge = graph.find_edge(node1, node2); - assert!(edge.is_some()); - assert_eq!(edge.unwrap().direction, Direction::Right); + assert_that(&edge.is_some()).is_true(); + assert_that(&edge.unwrap().direction).is_equal_to(Direction::Right); } #[test] @@ -103,33 +104,33 @@ fn should_error_on_negative_edge_distance() { }); let result = graph.add_edge(node1, node2, false, Some(-1.0), Direction::Right, TraversalFlags::ALL); - assert!(result.is_err()); + assert_that(&result.is_err()).is_true(); } #[test] fn should_error_on_duplicate_edge_without_replace() { let mut graph = common::create_test_graph(); let result = graph.add_edge(0, 1, false, None, Direction::Right, TraversalFlags::ALL); - assert!(result.is_err()); + assert_that(&result.is_err()).is_true(); } #[test] fn should_allow_replacing_an_edge() { let mut graph = common::create_test_graph(); let result = graph.add_edge(0, 1, true, Some(42.0), Direction::Right, TraversalFlags::ALL); - assert!(result.is_ok()); + assert_that(&result.is_ok()).is_true(); let edge = graph.find_edge(0, 1).unwrap(); - assert_eq!(edge.distance, 42.0); + assert_that(&edge.distance).is_equal_to(42.0); } #[test] fn should_find_edge_between_nodes() { let graph = common::create_test_graph(); let edge = graph.find_edge(0, 1); - assert!(edge.is_some()); - assert_eq!(edge.unwrap().target, 1); + assert_that(&edge.is_some()).is_true(); + assert_that(&edge.unwrap().target).is_equal_to(1); let non_existent_edge = graph.find_edge(0, 99); - assert!(non_existent_edge.is_none()); + assert_that(&non_existent_edge.is_none()).is_true(); } diff --git a/tests/input.rs b/tests/input.rs index 8a55ec7..536cc9b 100644 --- a/tests/input.rs +++ b/tests/input.rs @@ -2,6 +2,7 @@ use pacman::events::{GameCommand, GameEvent}; use pacman::map::direction::Direction; use pacman::systems::input::{process_simple_key_events, Bindings, SimpleKeyEvent}; use sdl2::keyboard::Keycode; +use speculoos::prelude::*; #[test] fn resumes_previous_direction_when_secondary_key_released() { @@ -9,15 +10,15 @@ fn resumes_previous_direction_when_secondary_key_released() { // Frame 1: Press W (Up) => emits Move Up let events = process_simple_key_events(&mut bindings, &[SimpleKeyEvent::KeyDown(Keycode::W)]); - assert!(events.contains(&GameEvent::Command(GameCommand::MovePlayer(Direction::Up)))); + assert_that(&events.contains(&GameEvent::Command(GameCommand::MovePlayer(Direction::Up)))).is_true(); // Frame 2: Press D (Right) => emits Move Right let events = process_simple_key_events(&mut bindings, &[SimpleKeyEvent::KeyDown(Keycode::D)]); - assert!(events.contains(&GameEvent::Command(GameCommand::MovePlayer(Direction::Right)))); + assert_that(&events.contains(&GameEvent::Command(GameCommand::MovePlayer(Direction::Right)))).is_true(); // Frame 3: Release D, no new key this frame => should continue previous key W (Up) let events = process_simple_key_events(&mut bindings, &[SimpleKeyEvent::KeyUp(Keycode::D)]); - assert!(events.contains(&GameEvent::Command(GameCommand::MovePlayer(Direction::Up)))); + assert_that(&events.contains(&GameEvent::Command(GameCommand::MovePlayer(Direction::Up)))).is_true(); } #[test] @@ -26,13 +27,13 @@ fn holds_last_pressed_key_across_frames_when_no_new_input() { // Frame 1: Press Left let events = process_simple_key_events(&mut bindings, &[SimpleKeyEvent::KeyDown(Keycode::Left)]); - assert!(events.contains(&GameEvent::Command(GameCommand::MovePlayer(Direction::Left)))); + assert_that(&events.contains(&GameEvent::Command(GameCommand::MovePlayer(Direction::Left)))).is_true(); // Frame 2: No input => continues Left let events = process_simple_key_events(&mut bindings, &[]); - assert!(events.contains(&GameEvent::Command(GameCommand::MovePlayer(Direction::Left)))); + assert_that(&events.contains(&GameEvent::Command(GameCommand::MovePlayer(Direction::Left)))).is_true(); // Frame 3: Release Left, no input remains => nothing emitted let events = process_simple_key_events(&mut bindings, &[SimpleKeyEvent::KeyUp(Keycode::Left)]); - assert!(events.is_empty()); + assert_that(&events.is_empty()).is_true(); } diff --git a/tests/item.rs b/tests/item.rs index e0dc19f..bc850c0 100644 --- a/tests/item.rs +++ b/tests/item.rs @@ -1,41 +1,42 @@ use bevy_ecs::{entity::Entity, system::RunSystemOnce}; use pacman::systems::{is_valid_item_collision, item_system, EntityType, GhostState, Position, ScoreResource}; +use speculoos::prelude::*; mod common; #[test] 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::Player.score_value().is_none()); - assert!(EntityType::Ghost.score_value().is_none()); + assert_that(&(EntityType::Pellet.score_value() < EntityType::PowerPellet.score_value())).is_true(); + assert_that(&EntityType::Pellet.score_value().is_some()).is_true(); + assert_that(&EntityType::PowerPellet.score_value().is_some()).is_true(); + assert_that(&EntityType::Player.score_value().is_none()).is_true(); + assert_that(&EntityType::Ghost.score_value().is_none()).is_true(); } #[test] fn test_is_collectible_item() { // Collectible - assert!(EntityType::Pellet.is_collectible()); - assert!(EntityType::PowerPellet.is_collectible()); + assert_that(&EntityType::Pellet.is_collectible()).is_true(); + assert_that(&EntityType::PowerPellet.is_collectible()).is_true(); // Non-collectible - assert!(!EntityType::Player.is_collectible()); - assert!(!EntityType::Ghost.is_collectible()); + assert_that(&EntityType::Player.is_collectible()).is_false(); + assert_that(&EntityType::Ghost.is_collectible()).is_false(); } #[test] fn test_is_valid_item_collision() { // Player-item collisions should be valid - assert!(is_valid_item_collision(EntityType::Player, EntityType::Pellet)); - assert!(is_valid_item_collision(EntityType::Player, EntityType::PowerPellet)); - assert!(is_valid_item_collision(EntityType::Pellet, EntityType::Player)); - assert!(is_valid_item_collision(EntityType::PowerPellet, EntityType::Player)); + assert_that(&is_valid_item_collision(EntityType::Player, EntityType::Pellet)).is_true(); + assert_that(&is_valid_item_collision(EntityType::Player, EntityType::PowerPellet)).is_true(); + assert_that(&is_valid_item_collision(EntityType::Pellet, EntityType::Player)).is_true(); + assert_that(&is_valid_item_collision(EntityType::PowerPellet, EntityType::Player)).is_true(); // Non-player-item collisions should be invalid - assert!(!is_valid_item_collision(EntityType::Player, EntityType::Ghost)); - assert!(!is_valid_item_collision(EntityType::Ghost, EntityType::Pellet)); - assert!(!is_valid_item_collision(EntityType::Pellet, EntityType::PowerPellet)); - assert!(!is_valid_item_collision(EntityType::Player, EntityType::Player)); + assert_that(&is_valid_item_collision(EntityType::Player, EntityType::Ghost)).is_false(); + assert_that(&is_valid_item_collision(EntityType::Ghost, EntityType::Pellet)).is_false(); + assert_that(&is_valid_item_collision(EntityType::Pellet, EntityType::PowerPellet)).is_false(); + assert_that(&is_valid_item_collision(EntityType::Player, EntityType::Player)).is_false(); } #[test] @@ -52,7 +53,7 @@ fn test_item_system_pellet_collection() { // Check that score was updated let score = world.resource::(); - assert_eq!(score.0, 10); + assert_that(&score.0).is_equal_to(10); // Check that the pellet was despawned (query should return empty) let item_count = world @@ -60,7 +61,7 @@ fn test_item_system_pellet_collection() { .iter(&world) .filter(|&entity_type| matches!(entity_type, EntityType::Pellet)) .count(); - assert_eq!(item_count, 0); + assert_that(&item_count).is_equal_to(0); } #[test] @@ -75,7 +76,7 @@ fn test_item_system_power_pellet_collection() { // Check that score was updated with power pellet value let score = world.resource::(); - assert_eq!(score.0, 50); + assert_that(&score.0).is_equal_to(50); // Check that the power pellet was despawned (query should return empty) let item_count = world @@ -83,7 +84,7 @@ fn test_item_system_power_pellet_collection() { .iter(&world) .filter(|&entity_type| matches!(entity_type, EntityType::PowerPellet)) .count(); - assert_eq!(item_count, 0); + assert_that(&item_count).is_equal_to(0); } #[test] @@ -103,7 +104,7 @@ fn test_item_system_multiple_collections() { // Check final score: 2 pellets (20) + 1 power pellet (50) = 70 let score = world.resource::(); - assert_eq!(score.0, 70); + assert_that(&score.0).is_equal_to(70); // Check that all items were despawned let pellet_count = world @@ -116,8 +117,8 @@ fn test_item_system_multiple_collections() { .iter(&world) .filter(|&entity_type| matches!(entity_type, EntityType::PowerPellet)) .count(); - assert_eq!(pellet_count, 0); - assert_eq!(power_pellet_count, 0); + assert_that(&pellet_count).is_equal_to(0); + assert_that(&power_pellet_count).is_equal_to(0); } #[test] @@ -138,7 +139,7 @@ fn test_item_system_ignores_non_item_collisions() { // Score should remain unchanged let score = world.resource::(); - assert_eq!(score.0, initial_score); + assert_that(&score.0).is_equal_to(initial_score); // Ghost should still exist (not despawned) let ghost_count = world @@ -146,7 +147,7 @@ fn test_item_system_ignores_non_item_collisions() { .iter(&world) .filter(|&entity_type| matches!(entity_type, EntityType::Ghost)) .count(); - assert_eq!(ghost_count, 1); + assert_that(&ghost_count).is_equal_to(1); } #[test] @@ -162,13 +163,13 @@ fn test_item_system_no_collision_events() { // Nothing should change let score = world.resource::(); - assert_eq!(score.0, initial_score); + assert_that(&score.0).is_equal_to(initial_score); let pellet_count = world .query::<&EntityType>() .iter(&world) .filter(|&entity_type| matches!(entity_type, EntityType::Pellet)) .count(); - assert_eq!(pellet_count, 1); + assert_that(&pellet_count).is_equal_to(1); } #[test] @@ -188,7 +189,7 @@ fn test_item_system_collision_with_missing_entity() { // Score should remain unchanged let score = world.resource::(); - assert_eq!(score.0, 0); + assert_that(&score.0).is_equal_to(0); } #[test] @@ -207,7 +208,7 @@ fn test_item_system_preserves_existing_score() { // Score should be initial + pellet value let score = world.resource::(); - assert_eq!(score.0, 110); + assert_that(&score.0).is_equal_to(110); } #[test] @@ -228,7 +229,7 @@ fn test_power_pellet_does_not_affect_ghosts_in_eyes_state() { // Check that the power pellet was collected and score updated let score = world.resource::(); - assert_eq!(score.0, 50); + assert_that(&score.0).is_equal_to(50); // Check that the power pellet was despawned let power_pellet_count = world @@ -236,13 +237,13 @@ fn test_power_pellet_does_not_affect_ghosts_in_eyes_state() { .iter(&world) .filter(|&entity_type| matches!(entity_type, EntityType::PowerPellet)) .count(); - assert_eq!(power_pellet_count, 0); + assert_that(&power_pellet_count).is_equal_to(0); // Check that the Eyes ghost state was not changed let eyes_ghost_state = world.entity(eyes_ghost).get::().unwrap(); - assert!(matches!(*eyes_ghost_state, GhostState::Eyes)); + assert_that(&matches!(*eyes_ghost_state, GhostState::Eyes)).is_true(); // Check that the Normal ghost state was changed to Frightened let normal_ghost_state = world.entity(normal_ghost).get::().unwrap(); - assert!(matches!(*normal_ghost_state, GhostState::Frightened { .. })); + assert_that(&matches!(*normal_ghost_state, GhostState::Frightened { .. })).is_true(); } diff --git a/tests/map_builder.rs b/tests/map_builder.rs index 4b68c52..90da547 100644 --- a/tests/map_builder.rs +++ b/tests/map_builder.rs @@ -1,13 +1,14 @@ use glam::Vec2; use pacman::constants::{CELL_SIZE, RAW_BOARD}; use pacman::map::builder::Map; +use speculoos::prelude::*; #[test] fn test_map_creation() { let map = Map::new(RAW_BOARD).unwrap(); - assert!(map.graph.nodes().count() > 0); - assert!(!map.grid_to_node.is_empty()); + assert_that(&map.graph.nodes().count()).is_greater_than(0); + assert_that(&map.grid_to_node.is_empty()).is_false(); // Check that some connections were made let mut has_connections = false; @@ -17,7 +18,7 @@ fn test_map_creation() { break; } } - assert!(has_connections); + assert_that(&has_connections).is_true(); } #[test] @@ -31,6 +32,6 @@ fn test_map_node_positions() { (grid_pos.y as i32 * CELL_SIZE as i32) as f32, ) + Vec2::splat(CELL_SIZE as f32 / 2.0); - assert_eq!(node.position, expected_pos); + assert_that(&node.position).is_equal_to(expected_pos); } } diff --git a/tests/movement.rs b/tests/movement.rs index 1b9b098..7a0070e 100644 --- a/tests/movement.rs +++ b/tests/movement.rs @@ -1,6 +1,7 @@ use glam::Vec2; use pacman::map::direction::Direction; use pacman::systems::movement::{BufferedDirection, Position, Velocity}; +use speculoos::prelude::*; mod common; @@ -13,8 +14,8 @@ fn test_position_is_at_node() { remaining_distance: 8.0, }; - assert!(stopped_pos.is_at_node()); - assert!(!moving_pos.is_at_node()); + assert_that(&stopped_pos.is_at_node()).is_true(); + assert_that(&moving_pos.is_at_node()).is_false(); } #[test] @@ -26,8 +27,8 @@ fn test_position_current_node() { remaining_distance: 12.0, }; - assert_eq!(stopped_pos.current_node(), 5); - assert_eq!(moving_pos.current_node(), 3); + assert_that(&stopped_pos.current_node()).is_equal_to(5); + assert_that(&moving_pos.current_node()).is_equal_to(3); } #[test] @@ -35,8 +36,8 @@ fn test_position_tick_no_movement_when_stopped() { let mut pos = Position::Stopped { node: 0 }; let result = pos.tick(5.0); - assert!(result.is_none()); - assert_eq!(pos, Position::Stopped { node: 0 }); + assert_that(&result.is_none()).is_true(); + assert_that(&pos).is_equal_to(Position::Stopped { node: 0 }); } #[test] @@ -48,15 +49,12 @@ fn test_position_tick_no_movement_when_zero_distance() { }; let result = pos.tick(0.0); - assert!(result.is_none()); - assert_eq!( - pos, - Position::Moving { - from: 0, - to: 1, - remaining_distance: 10.0, - } - ); + assert_that(&result.is_none()).is_true(); + assert_that(&pos).is_equal_to(Position::Moving { + from: 0, + to: 1, + remaining_distance: 10.0, + }); } #[test] @@ -68,15 +66,12 @@ fn test_position_tick_partial_movement() { }; let result = pos.tick(3.0); - assert!(result.is_none()); - assert_eq!( - pos, - Position::Moving { - from: 0, - to: 1, - remaining_distance: 7.0, - } - ); + assert_that(&result.is_none()).is_true(); + assert_that(&pos).is_equal_to(Position::Moving { + from: 0, + to: 1, + remaining_distance: 7.0, + }); } #[test] @@ -88,8 +83,8 @@ fn test_position_tick_exact_arrival() { }; let result = pos.tick(5.0); - assert!(result.is_none()); - assert_eq!(pos, Position::Stopped { node: 1 }); + assert_that(&result.is_none()).is_true(); + assert_that(&pos).is_equal_to(Position::Stopped { node: 1 }); } #[test] @@ -101,8 +96,8 @@ fn test_position_tick_overshoot_with_overflow() { }; let result = pos.tick(8.0); - assert_eq!(result, Some(5.0)); - assert_eq!(pos, Position::Stopped { node: 1 }); + assert_that(&result).is_equal_to(Some(5.0)); + assert_that(&pos).is_equal_to(Position::Stopped { node: 1 }); } #[test] @@ -116,7 +111,7 @@ fn test_position_get_pixel_position_stopped() { 0.0 + pacman::constants::BOARD_PIXEL_OFFSET.y as f32, ); - assert_eq!(pixel_pos, expected); + assert_that(&pixel_pos).is_equal_to(expected); } #[test] @@ -135,7 +130,7 @@ fn test_position_get_pixel_position_moving() { 0.0 + pacman::constants::BOARD_PIXEL_OFFSET.y as f32, ); - assert_eq!(pixel_pos, expected); + assert_that(&pixel_pos).is_equal_to(expected); } #[test] @@ -145,14 +140,14 @@ fn test_velocity_basic_properties() { direction: Direction::Up, }; - assert_eq!(velocity.speed, 2.5); - assert_eq!(velocity.direction, Direction::Up); + assert_that(&velocity.speed).is_equal_to(2.5); + assert_that(&velocity.direction).is_equal_to(Direction::Up); } #[test] fn test_buffered_direction_none() { let buffered = BufferedDirection::None; - assert_eq!(buffered, BufferedDirection::None); + assert_that(&buffered).is_equal_to(BufferedDirection::None); } #[test] @@ -167,8 +162,8 @@ fn test_buffered_direction_some() { remaining_time, } = buffered { - assert_eq!(direction, Direction::Left); - assert_eq!(remaining_time, 0.5); + assert_that(&direction).is_equal_to(Direction::Left); + assert_that(&remaining_time).is_equal_to(0.5); } else { panic!("Expected BufferedDirection::Some"); } diff --git a/tests/parser.rs b/tests/parser.rs index 53a1ee7..b8c7b92 100644 --- a/tests/parser.rs +++ b/tests/parser.rs @@ -1,6 +1,7 @@ use pacman::constants::{BOARD_CELL_SIZE, RAW_BOARD}; use pacman::error::ParseError; use pacman::map::parser::MapTileParser; +use speculoos::prelude::*; #[test] fn test_parse_character() { @@ -15,25 +16,25 @@ fn test_parse_character() { ]; for (char, _expected) in test_cases { - assert!(matches!(MapTileParser::parse_character(char).unwrap(), _expected)); + assert_that(&matches!(MapTileParser::parse_character(char).unwrap(), _expected)).is_true(); } - assert!(MapTileParser::parse_character('Z').is_err()); + assert_that(&MapTileParser::parse_character('Z').is_err()).is_true(); } #[test] fn test_parse_board() { let result = MapTileParser::parse_board(RAW_BOARD); - assert!(result.is_ok()); + assert_that(&result.is_ok()).is_true(); let parsed = result.unwrap(); - assert_eq!(parsed.tiles.len(), BOARD_CELL_SIZE.x as usize); - assert_eq!(parsed.tiles[0].len(), BOARD_CELL_SIZE.y as usize); - assert!(parsed.house_door[0].is_some()); - assert!(parsed.house_door[1].is_some()); - assert!(parsed.tunnel_ends[0].is_some()); - assert!(parsed.tunnel_ends[1].is_some()); - assert!(parsed.pacman_start.is_some()); + assert_that(&parsed.tiles.len()).is_equal_to(BOARD_CELL_SIZE.x as usize); + assert_that(&parsed.tiles[0].len()).is_equal_to(BOARD_CELL_SIZE.y as usize); + assert_that(&parsed.house_door[0].is_some()).is_true(); + assert_that(&parsed.house_door[1].is_some()).is_true(); + assert_that(&parsed.tunnel_ends[0].is_some()).is_true(); + assert_that(&parsed.tunnel_ends[1].is_some()).is_true(); + assert_that(&parsed.pacman_start.is_some()).is_true(); } #[test] @@ -42,6 +43,6 @@ fn test_parse_board_invalid_character() { invalid_board[0] = "###########################Z".to_string(); let result = MapTileParser::parse_board(invalid_board.each_ref().map(|s| s.as_str())); - assert!(result.is_err()); - assert!(matches!(result.unwrap_err(), ParseError::UnknownCharacter('Z'))); + assert_that(&result.is_err()).is_true(); + assert_that(&matches!(result.unwrap_err(), ParseError::UnknownCharacter('Z'))).is_true(); } diff --git a/tests/player.rs b/tests/player.rs index f9789a2..5ac7dc0 100644 --- a/tests/player.rs +++ b/tests/player.rs @@ -10,6 +10,7 @@ use pacman::{ EntityType, GlobalState, Position, Velocity, }, }; +use speculoos::prelude::*; mod common; @@ -22,7 +23,7 @@ fn test_can_traverse_player_on_all_edges() { traversal_flags: TraversalFlags::ALL, }; - assert!(can_traverse(EntityType::Player, edge)); + assert_that(&can_traverse(EntityType::Player, edge)).is_true(); } #[test] @@ -34,7 +35,7 @@ fn test_can_traverse_player_on_pacman_only_edges() { traversal_flags: TraversalFlags::PACMAN, }; - assert!(can_traverse(EntityType::Player, edge)); + assert_that(&can_traverse(EntityType::Player, edge)).is_true(); } #[test] @@ -46,7 +47,7 @@ fn test_can_traverse_player_blocked_on_ghost_only_edges() { traversal_flags: TraversalFlags::GHOST, }; - assert!(!can_traverse(EntityType::Player, edge)); + assert_that(&can_traverse(EntityType::Player, edge)).is_false(); } #[test] @@ -58,7 +59,7 @@ fn test_can_traverse_ghost_on_all_edges() { traversal_flags: TraversalFlags::ALL, }; - assert!(can_traverse(EntityType::Ghost, edge)); + assert_that(&can_traverse(EntityType::Ghost, edge)).is_true(); } #[test] @@ -70,7 +71,7 @@ fn test_can_traverse_ghost_on_ghost_only_edges() { traversal_flags: TraversalFlags::GHOST, }; - assert!(can_traverse(EntityType::Ghost, edge)); + assert_that(&can_traverse(EntityType::Ghost, edge)).is_true(); } #[test] @@ -82,7 +83,7 @@ fn test_can_traverse_ghost_blocked_on_pacman_only_edges() { traversal_flags: TraversalFlags::PACMAN, }; - assert!(!can_traverse(EntityType::Ghost, edge)); + assert_that(&can_traverse(EntityType::Ghost, edge)).is_false(); } #[test] @@ -97,16 +98,16 @@ fn test_can_traverse_static_entities_flags() { // Static entities have empty traversal flags but can still "traverse" // in the sense that empty flags are contained in any flag set // This is the expected behavior since empty ⊆ any set - assert!(can_traverse(EntityType::Pellet, edge)); - assert!(can_traverse(EntityType::PowerPellet, edge)); + assert_that(&can_traverse(EntityType::Pellet, edge)).is_true(); + assert_that(&can_traverse(EntityType::PowerPellet, edge)).is_true(); } #[test] fn test_entity_type_traversal_flags() { - assert_eq!(EntityType::Player.traversal_flags(), TraversalFlags::PACMAN); - assert_eq!(EntityType::Ghost.traversal_flags(), TraversalFlags::GHOST); - assert_eq!(EntityType::Pellet.traversal_flags(), TraversalFlags::empty()); - assert_eq!(EntityType::PowerPellet.traversal_flags(), TraversalFlags::empty()); + assert_that(&EntityType::Player.traversal_flags()).is_equal_to(TraversalFlags::PACMAN); + assert_that(&EntityType::Ghost.traversal_flags()).is_equal_to(TraversalFlags::GHOST); + assert_that(&EntityType::Pellet.traversal_flags()).is_equal_to(TraversalFlags::empty()); + assert_that(&EntityType::PowerPellet.traversal_flags()).is_equal_to(TraversalFlags::empty()); } #[test] @@ -131,8 +132,8 @@ fn test_player_control_system_move_command() { direction, remaining_time, } => { - assert_eq!(direction, Direction::Up); - assert_eq!(remaining_time, 0.25); + assert_that(&direction).is_equal_to(Direction::Up); + assert_that(&remaining_time).is_equal_to(0.25); } BufferedDirection::None => panic!("Expected buffered direction to be set"), } @@ -153,7 +154,7 @@ fn test_player_control_system_exit_command() { // Check that exit flag was set let state = world.resource::(); - assert!(state.exit); + assert_that(&state.exit).is_true(); } #[test] @@ -171,7 +172,7 @@ fn test_player_control_system_toggle_debug() { // Check that debug state changed let debug_state = world.resource::(); - assert!(debug_state.enabled); + assert_that(&debug_state.enabled).is_true(); } #[test] @@ -189,7 +190,7 @@ fn test_player_control_system_mute_audio() { // Check that audio was muted let audio_state = world.resource::(); - assert!(audio_state.muted); + assert_that(&audio_state.muted).is_true(); // Send mute audio command again to unmute - need fresh events world.resource_mut::>().clear(); // Clear previous events @@ -200,7 +201,7 @@ fn test_player_control_system_mute_audio() { // Check that audio was unmuted let audio_state = world.resource::(); - assert!(!audio_state.muted, "Audio should be unmuted after second toggle"); + assert_that(&audio_state.muted).is_false(); } #[test] @@ -245,10 +246,7 @@ fn test_player_movement_system_buffered_direction_expires() { match *buffered_direction { BufferedDirection::None => {} // Expected - fully expired BufferedDirection::Some { remaining_time, .. } => { - assert!( - remaining_time <= 0.0, - "Buffered direction should be expired or have non-positive time" - ); + assert_that(&(remaining_time <= 0.0)).is_true(); } } } @@ -271,7 +269,7 @@ fn test_player_movement_system_start_moving_from_stopped() { match *position { Position::Moving { from, .. } => { - assert_eq!(from, 0, "Player should start from node 0"); + assert_that(&from).is_equal_to(0); // Don't assert exact target node since the real map has different connectivity } Position::Stopped { .. } => {} // May stay stopped if no valid edge in current direction @@ -299,8 +297,8 @@ fn test_player_movement_system_buffered_direction_change() { match *position { Position::Moving { from, to, .. } => { - assert_eq!(from, 0); - assert_eq!(to, 2); // Should be moving to node 2 (down) + assert_that(&from).is_equal_to(0); + assert_that(&to).is_equal_to(2); // Should be moving to node 2 (down) } Position::Stopped { .. } => panic!("Player should have started moving"), } @@ -329,7 +327,7 @@ fn test_player_movement_system_no_valid_edge() { let position = query.single(&world).expect("Player should exist"); match *position { - Position::Stopped { node } => assert_eq!(node, 0), + Position::Stopped { node } => assert_that(&node).is_equal_to(0), Position::Moving { .. } => panic!("Player shouldn't be able to move without valid edge"), } } @@ -356,7 +354,7 @@ fn test_player_movement_system_continue_moving() { match *position { Position::Moving { remaining_distance, .. } => { - assert!(remaining_distance < 50.0); // Should have moved + assert_that(&(remaining_distance < 50.0)).is_true(); // Should have moved } Position::Stopped { .. } => { // If player reached destination, that's also valid @@ -388,8 +386,8 @@ fn test_full_player_input_to_movement_flow() { match *position { Position::Moving { from, to, .. } => { - assert_eq!(from, 0); - assert_eq!(to, 2); // Moving to node 2 (down) + assert_that(&from).is_equal_to(0); + assert_that(&to).is_equal_to(2); // Moving to node 2 (down) } Position::Stopped { .. } => panic!("Player should be moving"), } @@ -421,8 +419,8 @@ fn test_buffered_direction_timing() { match *buffered_direction { BufferedDirection::Some { remaining_time, .. } => { - assert!(remaining_time > 0.0); - assert!(remaining_time < 0.25); + assert_that(&(remaining_time > 0.0)).is_true(); + assert_that(&(remaining_time < 0.25)).is_true(); } BufferedDirection::None => panic!("Buffered direction should still be active"), } @@ -434,7 +432,7 @@ fn test_buffered_direction_timing() { .expect("System should run successfully"); let buffered_direction = query.single(&world).expect("Player should exist"); - assert_eq!(*buffered_direction, BufferedDirection::None); + assert_that(buffered_direction).is_equal_to(BufferedDirection::None); } #[test] @@ -464,7 +462,7 @@ fn test_multiple_rapid_direction_changes() { match *buffered_direction { BufferedDirection::Some { direction, .. } => { - assert_eq!(direction, Direction::Left); + assert_that(&direction).is_equal_to(Direction::Left); } BufferedDirection::None => panic!("Expected buffered direction"), } @@ -510,8 +508,8 @@ fn test_player_state_persistence_across_systems() { let position = *query.single(&world).expect("Player should exist"); // Check that the state changes persisted individually - assert!(debug_state_after_toggle.enabled, "Debug state should have toggled"); - assert!(audio_muted_after_toggle, "Audio should be muted"); + assert_that(&debug_state_after_toggle.enabled).is_true(); + assert_that(&audio_muted_after_toggle).is_true(); // Player position depends on actual map connectivity match position { diff --git a/tests/profiling.rs b/tests/profiling.rs index 10bb0da..29d3f5c 100644 --- a/tests/profiling.rs +++ b/tests/profiling.rs @@ -1,4 +1,5 @@ use pacman::systems::profiling::{SystemId, SystemTimings}; +use speculoos::prelude::*; use std::time::Duration; use strum::IntoEnumIterator; @@ -6,15 +7,7 @@ macro_rules! assert_close { ($actual:expr, $expected:expr, $concern:expr) => { let tolerance = Duration::from_micros(500); let diff = $actual.abs_diff($expected); - assert!( - diff < tolerance, - "Expected {expected:?} ± {tolerance:.0?}, got {actual:?}, off by {diff:?} ({concern})", - concern = $concern, - expected = $expected, - actual = $actual, - tolerance = tolerance, - diff = diff - ); + assert_that(&(diff < tolerance)).is_true(); }; } @@ -55,7 +48,7 @@ fn test_default_zero_timing_for_unused_systems() { // Verify all SystemId variants are present in the stats let expected_count = SystemId::iter().count(); - assert_eq!(stats.len(), expected_count, "All SystemId variants should be in stats"); + 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(); @@ -95,11 +88,7 @@ fn test_pre_populated_timing_entries() { let stats = timings.get_stats(1); for id in SystemId::iter() { let (avg, _) = stats.get(&id).unwrap(); - assert!( - *avg > Duration::ZERO, - "System {:?} should have non-zero timing after add_timing", - id - ); + assert_that(&(*avg > Duration::ZERO)).is_true(); } } @@ -118,8 +107,5 @@ fn test_total_system_timing() { // 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!( - *std_dev > Duration::ZERO, - "Total system should have non-zero std dev with multiple measurements" - ); + assert_that(&(*std_dev > Duration::ZERO)).is_true(); } diff --git a/tests/sprite.rs b/tests/sprite.rs index e7e2bee..4c50c29 100644 --- a/tests/sprite.rs +++ b/tests/sprite.rs @@ -1,6 +1,7 @@ use glam::U16Vec2; use pacman::texture::sprite::{AtlasMapper, AtlasTile, MapperFrame}; use sdl2::pixels::Color; +use speculoos::prelude::*; use std::collections::HashMap; mod common; @@ -20,10 +21,10 @@ fn test_atlas_mapper_frame_lookup() { // Test direct frame lookup let frame = mapper.frames.get("test"); - assert!(frame.is_some()); + assert_that(&frame.is_some()).is_true(); let frame = frame.unwrap(); - assert_eq!(frame.pos, U16Vec2::new(10, 20)); - assert_eq!(frame.size, U16Vec2::new(32, 64)); + assert_that(&frame.pos).is_equal_to(U16Vec2::new(10, 20)); + assert_that(&frame.size).is_equal_to(U16Vec2::new(32, 64)); } #[test] @@ -46,11 +47,11 @@ fn test_atlas_mapper_multiple_frames() { let mapper = AtlasMapper { frames }; - assert_eq!(mapper.frames.len(), 2); - assert!(mapper.frames.contains_key("tile1")); - assert!(mapper.frames.contains_key("tile2")); - assert!(!mapper.frames.contains_key("tile3")); - assert!(!mapper.frames.contains_key("nonexistent")); + assert_that(&mapper.frames.len()).is_equal_to(2); + assert_that(&mapper.frames.contains_key("tile1")).is_true(); + assert_that(&mapper.frames.contains_key("tile2")).is_true(); + assert_that(&mapper.frames.contains_key("tile3")).is_false(); + assert_that(&mapper.frames.contains_key("nonexistent")).is_false(); } #[test] @@ -60,10 +61,10 @@ fn test_atlas_tile_new_and_with_color() { let color = Color::RGB(100, 150, 200); let tile = AtlasTile::new(pos, size, None); - assert_eq!(tile.pos, pos); - assert_eq!(tile.size, size); - assert_eq!(tile.color, None); + assert_that(&tile.pos).is_equal_to(pos); + assert_that(&tile.size).is_equal_to(size); + assert_that(&tile.color).is_equal_to(None); let tile_with_color = tile.with_color(color); - assert_eq!(tile_with_color.color, Some(color)); + assert_that(&tile_with_color.color).is_equal_to(Some(color)); } diff --git a/tests/text.rs b/tests/text.rs index 66aa38d..b0a9ed2 100644 --- a/tests/text.rs +++ b/tests/text.rs @@ -1,4 +1,5 @@ use pacman::texture::{sprite::SpriteAtlas, text::TextTexture}; +use speculoos::prelude::*; mod common; @@ -16,22 +17,16 @@ fn get_all_chars() -> String { /// Helper function to check if a character is in the atlas and char_map fn check_char(text_texture: &mut TextTexture, atlas: &mut SpriteAtlas, c: char) { // Check that the character is not in the char_map yet - assert!( - !text_texture.get_char_map().contains_key(&c), - "Character {c} should not yet be in char_map" - ); + assert_that(&text_texture.get_char_map().contains_key(&c)).is_false(); // Get the tile from the atlas, which caches the tile in the char_map let tile = text_texture.get_tile(c, atlas); - assert!(tile.is_ok(), "Failed to get tile for character {c}"); - assert!(tile.unwrap().is_some(), "Tile for character {c} not found in atlas"); + assert_that(&tile.is_ok()).is_true(); + assert_that(&tile.unwrap().is_some()).is_true(); // Check that the tile is now cached in the char_map - assert!( - text_texture.get_char_map().contains_key(&c), - "Tile for character {c} was not cached in char_map" - ); + assert_that(&text_texture.get_char_map().contains_key(&c)).is_true(); } #[test] @@ -74,8 +69,8 @@ fn test_text_width() -> Result<(), String> { let width = text_texture.text_width(&string); let height = text_texture.text_height(); - assert!(width > 0, "Width for string {string} should be greater than 0"); - assert!(height > 0, "Height for string {string} should be greater than 0"); + assert_that(&(width > 0)).is_true(); + assert_that(&(height > 0)).is_true(); } Ok(()) @@ -88,22 +83,22 @@ fn test_text_scale() -> Result<(), String> { let mut text_texture = TextTexture::new(0.5); - assert_eq!(text_texture.scale(), 0.5); - assert_eq!(text_texture.text_height(), 4); - assert_eq!(text_texture.text_width(""), 0); - assert_eq!(text_texture.text_width(string), base_width / 2); + assert_that(&text_texture.scale()).is_equal_to(0.5); + assert_that(&text_texture.text_height()).is_equal_to(4); + assert_that(&text_texture.text_width("")).is_equal_to(0); + assert_that(&text_texture.text_width(string)).is_equal_to(base_width / 2); text_texture.set_scale(2.0); - assert_eq!(text_texture.scale(), 2.0); - assert_eq!(text_texture.text_height(), 16); - assert_eq!(text_texture.text_width(string), base_width * 2); - assert_eq!(text_texture.text_width(""), 0); + assert_that(&text_texture.scale()).is_equal_to(2.0); + assert_that(&text_texture.text_height()).is_equal_to(16); + assert_that(&text_texture.text_width(string)).is_equal_to(base_width * 2); + assert_that(&text_texture.text_width("")).is_equal_to(0); text_texture.set_scale(1.0); - assert_eq!(text_texture.scale(), 1.0); - assert_eq!(text_texture.text_height(), 8); - assert_eq!(text_texture.text_width(string), base_width); - assert_eq!(text_texture.text_width(""), 0); + assert_that(&text_texture.scale()).is_equal_to(1.0); + assert_that(&text_texture.text_height()).is_equal_to(8); + assert_that(&text_texture.text_width(string)).is_equal_to(base_width); + assert_that(&text_texture.text_width("")).is_equal_to(0); Ok(()) } @@ -113,17 +108,17 @@ fn test_text_color() -> Result<(), String> { let mut text_texture = TextTexture::new(1.0); // Test default color (should be None initially) - assert_eq!(text_texture.color(), None); + assert_that(&text_texture.color()).is_equal_to(None); // Test setting color let test_color = sdl2::pixels::Color::YELLOW; text_texture.set_color(test_color); - assert_eq!(text_texture.color(), Some(test_color)); + assert_that(&text_texture.color()).is_equal_to(Some(test_color)); // Test changing color let new_color = sdl2::pixels::Color::RED; text_texture.set_color(new_color); - assert_eq!(text_texture.color(), Some(new_color)); + assert_that(&text_texture.color()).is_equal_to(Some(new_color)); Ok(()) }