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

refactor: move all tests out of src/ into tests/, remove unnecessary tests

Browse Source
This commit is contained in:
Xevion
2025-08-08 08:50:52 -05:00
parent 9d5ca54234
commit b308bc0ef7
26 changed files with 1018 additions and 2354 deletions
Download Patch File Download Diff File Expand all files Collapse all files

64
src/entity/direction.rs
View File

@@ -35,67 +35,3 @@ impl From<Direction> for IVec2 {
}
pub const DIRECTIONS: [Direction; 4] = [Direction::Up, Direction::Down, Direction::Left, Direction::Right];
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_direction_opposite() {
assert_eq!(Direction::Up.opposite(), Direction::Down);
assert_eq!(Direction::Down.opposite(), Direction::Up);
assert_eq!(Direction::Left.opposite(), Direction::Right);
assert_eq!(Direction::Right.opposite(), Direction::Left);
}
#[test]
fn test_direction_as_ivec2() {
assert_eq!(Direction::Up.as_ivec2(), -IVec2::Y);
assert_eq!(Direction::Down.as_ivec2(), IVec2::Y);
assert_eq!(Direction::Left.as_ivec2(), -IVec2::X);
assert_eq!(Direction::Right.as_ivec2(), IVec2::X);
}
#[test]
fn test_direction_from_ivec2() {
assert_eq!(IVec2::from(Direction::Up), -IVec2::Y);
assert_eq!(IVec2::from(Direction::Down), IVec2::Y);
assert_eq!(IVec2::from(Direction::Left), -IVec2::X);
assert_eq!(IVec2::from(Direction::Right), IVec2::X);
}
#[test]
fn test_directions_constant() {
assert_eq!(DIRECTIONS.len(), 4);
assert!(DIRECTIONS.contains(&Direction::Up));
assert!(DIRECTIONS.contains(&Direction::Down));
assert!(DIRECTIONS.contains(&Direction::Left));
assert!(DIRECTIONS.contains(&Direction::Right));
}
#[test]
fn test_direction_equality() {
assert_eq!(Direction::Up, Direction::Up);
assert_ne!(Direction::Up, Direction::Down);
assert_ne!(Direction::Left, Direction::Right);
}
#[test]
fn test_direction_clone() {
let dir = Direction::Up;
let cloned = dir;
assert_eq!(dir, cloned);
}
#[test]
fn test_direction_hash() {
use std::collections::HashMap;
let mut map = HashMap::new();
map.insert(Direction::Up, "up");
map.insert(Direction::Down, "down");
assert_eq!(map.get(&Direction::Up), Some(&"up"));
assert_eq!(map.get(&Direction::Down), Some(&"down"));
assert_eq!(map.get(&Direction::Left), None);
}
}

363
src/entity/graph.rs
View File

@@ -441,366 +441,3 @@ impl Traverser {
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::entity::direction::Direction;
fn create_test_graph() -> Graph {
let mut graph = Graph::new();
let node1 = graph.add_node(Node {
position: glam::Vec2::new(0.0, 0.0),
});
let node2 = graph.add_node(Node {
position: glam::Vec2::new(16.0, 0.0),
});
let node3 = graph.add_node(Node {
position: glam::Vec2::new(0.0, 16.0),
});
graph.connect(node1, node2, false, None, Direction::Right).unwrap();
graph.connect(node1, node3, false, None, Direction::Down).unwrap();
graph
}
#[test]
fn test_graph_new() {
let graph = Graph::new();
assert_eq!(graph.node_count(), 0);
assert!(graph.adjacency_list.is_empty());
}
#[test]
fn test_graph_add_node() {
let mut graph = Graph::new();
let node = Node {
position: glam::Vec2::new(10.0, 20.0),
};
let id = graph.add_node(node);
assert_eq!(id, 0);
assert_eq!(graph.node_count(), 1);
assert_eq!(graph.adjacency_list.len(), 1);
let retrieved_node = graph.get_node(id).unwrap();
assert_eq!(retrieved_node.position, glam::Vec2::new(10.0, 20.0));
}
#[test]
fn test_graph_node_count() {
let mut graph = Graph::new();
assert_eq!(graph.node_count(), 0);
graph.add_node(Node {
position: glam::Vec2::new(0.0, 0.0),
});
assert_eq!(graph.node_count(), 1);
graph.add_node(Node {
position: glam::Vec2::new(1.0, 1.0),
});
assert_eq!(graph.node_count(), 2);
}
#[test]
fn test_graph_get_node() {
let mut graph = Graph::new();
let node = Node {
position: glam::Vec2::new(5.0, 10.0),
};
let id = graph.add_node(node);
let retrieved = graph.get_node(id).unwrap();
assert_eq!(retrieved.position, glam::Vec2::new(5.0, 10.0));
assert!(graph.get_node(999).is_none());
}
#[test]
fn test_graph_connect() {
let mut graph = Graph::new();
let node1 = graph.add_node(Node {
position: glam::Vec2::new(0.0, 0.0),
});
let node2 = graph.add_node(Node {
position: glam::Vec2::new(16.0, 0.0),
});
let result = graph.connect(node1, node2, false, None, Direction::Right);
assert!(result.is_ok());
// Check that edges were added in both directions
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);
}
#[test]
fn test_graph_connect_invalid_nodes() {
let mut graph = Graph::new();
let node1 = graph.add_node(Node {
position: glam::Vec2::new(0.0, 0.0),
});
// Try to connect to non-existent node
let result = graph.connect(node1, 999, false, None, Direction::Right);
assert!(result.is_err());
// Try to connect from non-existent node
let result = graph.connect(999, node1, false, None, Direction::Right);
assert!(result.is_err());
}
#[test]
fn test_graph_find_edge() {
let mut graph = Graph::new();
let node1 = graph.add_node(Node {
position: glam::Vec2::new(0.0, 0.0),
});
let node2 = graph.add_node(Node {
position: glam::Vec2::new(16.0, 0.0),
});
graph.connect(node1, node2, false, None, Direction::Right).unwrap();
let edge = graph.find_edge(node1, node2);
assert!(edge.is_some());
assert_eq!(edge.unwrap().target, node2);
// Test non-existent edge
assert!(graph.find_edge(node1, 999).is_none());
}
#[test]
fn test_graph_find_edge_in_direction() {
let mut graph = Graph::new();
let node1 = graph.add_node(Node {
position: glam::Vec2::new(0.0, 0.0),
});
let node2 = graph.add_node(Node {
position: glam::Vec2::new(16.0, 0.0),
});
graph.connect(node1, node2, false, None, Direction::Right).unwrap();
let edge = graph.find_edge_in_direction(node1, Direction::Right);
assert!(edge.is_some());
assert_eq!(edge.unwrap().target, node2);
// Test non-existent direction
assert!(graph.find_edge_in_direction(node1, Direction::Up).is_none());
}
#[test]
fn test_intersection_edges() {
let mut intersection = Intersection::default();
intersection.set(
Direction::Up,
Edge {
target: 1,
distance: 10.0,
direction: Direction::Up,
permissions: EdgePermissions::All,
},
);
intersection.set(
Direction::Right,
Edge {
target: 2,
distance: 15.0,
direction: Direction::Right,
permissions: EdgePermissions::All,
},
);
let edges: Vec<_> = intersection.edges().collect();
assert_eq!(edges.len(), 2);
let up_edge = edges.iter().find(|e| e.direction == Direction::Up).unwrap();
let right_edge = edges.iter().find(|e| e.direction == Direction::Right).unwrap();
assert_eq!(up_edge.target, 1);
assert_eq!(up_edge.distance, 10.0);
assert_eq!(right_edge.target, 2);
assert_eq!(right_edge.distance, 15.0);
}
#[test]
fn test_intersection_get() {
let mut intersection = Intersection::default();
let edge = Edge {
target: 1,
distance: 10.0,
direction: Direction::Up,
permissions: EdgePermissions::All,
};
intersection.set(Direction::Up, edge);
let retrieved = intersection.get(Direction::Up);
assert!(retrieved.is_some());
assert_eq!(retrieved.unwrap().target, 1);
assert!(intersection.get(Direction::Down).is_none());
}
#[test]
fn test_intersection_set() {
let mut intersection = Intersection::default();
let edge = Edge {
target: 1,
distance: 10.0,
direction: Direction::Left,
permissions: EdgePermissions::All,
};
intersection.set(Direction::Left, edge);
let retrieved = intersection.get(Direction::Left);
assert!(retrieved.is_some());
assert_eq!(retrieved.unwrap().target, 1);
}
#[test]
fn test_position_is_at_node() {
let pos = Position::AtNode(5);
assert!(pos.is_at_node());
let pos = Position::BetweenNodes {
from: 1,
to: 2,
traversed: 5.0,
};
assert!(!pos.is_at_node());
}
#[test]
fn test_position_from_node_id() {
let pos = Position::AtNode(5);
assert_eq!(pos.from_node_id(), 5);
let pos = Position::BetweenNodes {
from: 1,
to: 2,
traversed: 5.0,
};
assert_eq!(pos.from_node_id(), 1);
}
#[test]
fn test_position_to_node_id() {
let pos = Position::AtNode(5);
assert_eq!(pos.to_node_id(), None);
let pos = Position::BetweenNodes {
from: 1,
to: 2,
traversed: 5.0,
};
assert_eq!(pos.to_node_id(), Some(2));
}
#[test]
fn test_position_is_stopped() {
let pos = Position::AtNode(5);
assert!(pos.is_stopped());
let pos = Position::BetweenNodes {
from: 1,
to: 2,
traversed: 5.0,
};
assert!(!pos.is_stopped());
}
#[test]
fn test_traverser_new() {
let graph = create_test_graph();
let traverser = Traverser::new(&graph, 0, Direction::Left, &|_| true);
assert_eq!(traverser.direction, Direction::Left);
// The next_direction might be consumed immediately when the traverser starts moving
// So we just check that the direction is set correctly
assert_eq!(traverser.direction, Direction::Left);
}
#[test]
fn test_traverser_set_next_direction() {
let graph = create_test_graph();
let mut traverser = Traverser::new(&graph, 0, Direction::Left, &|_| true);
traverser.set_next_direction(Direction::Up);
assert!(traverser.next_direction.is_some());
assert_eq!(traverser.next_direction.unwrap().0, Direction::Up);
// Setting same direction should not change anything
traverser.set_next_direction(Direction::Up);
assert_eq!(traverser.next_direction.unwrap().0, Direction::Up);
}
#[test]
fn test_traverser_advance_at_node() {
let graph = create_test_graph();
let mut traverser = Traverser::new(&graph, 0, Direction::Right, &|_| true);
// Should start moving in the initial direction
traverser.advance(&graph, 5.0, &|_| true);
match traverser.position {
Position::BetweenNodes { from, to, traversed } => {
assert_eq!(from, 0);
assert_eq!(to, 1);
assert_eq!(traversed, 5.0);
}
_ => panic!("Expected to be between nodes"),
}
}
#[test]
fn test_traverser_advance_between_nodes() {
let graph = create_test_graph();
let mut traverser = Traverser::new(&graph, 0, Direction::Right, &|_| true);
// Move to between nodes
traverser.advance(&graph, 5.0, &|_| true);
// Advance further
traverser.advance(&graph, 3.0, &|_| true);
match traverser.position {
Position::BetweenNodes { from, to, traversed } => {
assert_eq!(from, 0);
assert_eq!(to, 1);
assert_eq!(traversed, 8.0);
}
_ => panic!("Expected to be between nodes"),
}
}
#[test]
fn test_edge_structure() {
let edge = Edge {
target: 5,
distance: 10.5,
direction: Direction::Up,
permissions: EdgePermissions::All,
};
assert_eq!(edge.target, 5);
assert_eq!(edge.distance, 10.5);
assert_eq!(edge.direction, Direction::Up);
}
#[test]
fn test_node_structure() {
let node = Node {
position: glam::Vec2::new(10.0, 20.0),
};
assert_eq!(node.position, glam::Vec2::new(10.0, 20.0));
}
}

216
src/entity/pacman.rs
View File

@@ -100,219 +100,3 @@ impl Pacman {
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::entity::graph::{Graph, Node};
use crate::texture::sprite::{AtlasMapper, MapperFrame, SpriteAtlas};
use sdl2::keyboard::Keycode;
use std::collections::HashMap;
fn create_test_graph() -> Graph {
let mut graph = Graph::new();
let node1 = graph.add_node(Node {
position: glam::Vec2::new(0.0, 0.0),
});
let node2 = graph.add_node(Node {
position: glam::Vec2::new(16.0, 0.0),
});
let node3 = graph.add_node(Node {
position: glam::Vec2::new(0.0, 16.0),
});
graph.connect(node1, node2, false, None, Direction::Right).unwrap();
graph.connect(node1, node3, false, None, Direction::Down).unwrap();
graph
}
fn create_test_atlas() -> SpriteAtlas {
// Create a minimal test atlas with required tiles
let mut frames = HashMap::new();
frames.insert(
"pacman/up_a.png".to_string(),
MapperFrame {
x: 0,
y: 0,
width: 16,
height: 16,
},
);
frames.insert(
"pacman/up_b.png".to_string(),
MapperFrame {
x: 16,
y: 0,
width: 16,
height: 16,
},
);
frames.insert(
"pacman/down_a.png".to_string(),
MapperFrame {
x: 32,
y: 0,
width: 16,
height: 16,
},
);
frames.insert(
"pacman/down_b.png".to_string(),
MapperFrame {
x: 48,
y: 0,
width: 16,
height: 16,
},
);
frames.insert(
"pacman/left_a.png".to_string(),
MapperFrame {
x: 64,
y: 0,
width: 16,
height: 16,
},
);
frames.insert(
"pacman/left_b.png".to_string(),
MapperFrame {
x: 80,
y: 0,
width: 16,
height: 16,
},
);
frames.insert(
"pacman/right_a.png".to_string(),
MapperFrame {
x: 96,
y: 0,
width: 16,
height: 16,
},
);
frames.insert(
"pacman/right_b.png".to_string(),
MapperFrame {
x: 112,
y: 0,
width: 16,
height: 16,
},
);
frames.insert(
"pacman/full.png".to_string(),
MapperFrame {
x: 128,
y: 0,
width: 16,
height: 16,
},
);
let mapper = AtlasMapper { frames };
// Create a dummy texture (we won't actually render, just test the logic)
let dummy_texture = unsafe { std::mem::zeroed() };
SpriteAtlas::new(dummy_texture, mapper)
}
#[test]
fn test_pacman_new() {
let graph = create_test_graph();
let atlas = create_test_atlas();
let pacman = Pacman::new(&graph, 0, &atlas);
assert_eq!(pacman.traverser.direction, Direction::Left);
assert!(matches!(pacman.traverser.position, crate::entity::graph::Position::AtNode(0)));
}
#[test]
fn test_handle_key_valid_directions() {
let graph = create_test_graph();
let atlas = create_test_atlas();
let mut pacman = Pacman::new(&graph, 0, &atlas);
// Test that direction keys are handled correctly
// The traverser might consume next_direction immediately, so we check the actual direction
pacman.handle_key(Keycode::Up);
// Check that the direction was set (either in next_direction or current direction)
assert!(pacman.traverser.next_direction.is_some() || pacman.traverser.direction == Direction::Up);
pacman.handle_key(Keycode::Down);
assert!(pacman.traverser.next_direction.is_some() || pacman.traverser.direction == Direction::Down);
pacman.handle_key(Keycode::Left);
assert!(pacman.traverser.next_direction.is_some() || pacman.traverser.direction == Direction::Left);
pacman.handle_key(Keycode::Right);
assert!(pacman.traverser.next_direction.is_some() || pacman.traverser.direction == Direction::Right);
}
#[test]
fn test_handle_key_invalid_direction() {
let graph = create_test_graph();
let atlas = create_test_atlas();
let mut pacman = Pacman::new(&graph, 0, &atlas);
let original_direction = pacman.traverser.direction;
let original_next_direction = pacman.traverser.next_direction;
// Test invalid key
pacman.handle_key(Keycode::Space);
// Should not change direction
assert_eq!(pacman.traverser.direction, original_direction);
assert_eq!(pacman.traverser.next_direction, original_next_direction);
}
#[test]
fn test_get_pixel_pos_at_node() {
let graph = create_test_graph();
let atlas = create_test_atlas();
let pacman = Pacman::new(&graph, 0, &atlas);
let pos = pacman.get_pixel_pos(&graph);
assert_eq!(pos, glam::Vec2::new(0.0, 0.0));
}
#[test]
fn test_get_pixel_pos_between_nodes() {
let graph = create_test_graph();
let atlas = create_test_atlas();
let mut pacman = Pacman::new(&graph, 0, &atlas);
// Move pacman between nodes - need to advance with a larger distance to ensure movement
pacman.traverser.advance(&graph, 5.0, &can_pacman_traverse); // Larger advance to ensure movement
let pos = pacman.get_pixel_pos(&graph);
// Should be between (0,0) and (16,0), but not exactly at (8,0) due to advance distance
assert!(pos.x >= 0.0 && pos.x <= 16.0);
assert_eq!(pos.y, 0.0);
}
#[test]
fn test_tick_updates_texture() {
let graph = create_test_graph();
let atlas = create_test_atlas();
let mut pacman = Pacman::new(&graph, 0, &atlas);
// Test that tick doesn't panic
pacman.tick(0.016, &graph); // 60 FPS frame time
}
#[test]
fn test_pacman_initial_direction() {
let graph = create_test_graph();
let atlas = create_test_atlas();
let pacman = Pacman::new(&graph, 0, &atlas);
// Pacman should start with the initial direction (Left)
assert_eq!(pacman.traverser.direction, Direction::Left);
// The next_direction might be consumed immediately when the traverser starts moving
// So we just check that the direction is set correctly
assert_eq!(pacman.traverser.direction, Direction::Left);
}
}