test: add tons of tests for all easy submodules

src/texture/directional.rs

@@ -54,4 +54,130 @@ impl DirectionalAnimatedTexture {
             Ok(())
         }
     }
+
+    // Helper methods for testing
+    pub fn has_direction(&self, direction: Direction) -> bool {
+        self.textures.contains_key(&direction)
+    }
+
+    pub fn has_stopped_direction(&self, direction: Direction) -> bool {
+        self.stopped_textures.contains_key(&direction)
+    }
+
+    pub fn texture_count(&self) -> usize {
+        self.textures.len()
+    }
+
+    pub fn stopped_texture_count(&self) -> usize {
+        self.stopped_textures.len()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::texture::sprite::AtlasTile;
+    use glam::U16Vec2;
+    use sdl2::pixels::Color;
+
+    fn mock_atlas_tile(id: u32) -> AtlasTile {
+        AtlasTile {
+            pos: U16Vec2::new(0, 0),
+            size: U16Vec2::new(16, 16),
+            color: Some(Color::RGB(id as u8, 0, 0)),
+        }
+    }
+
+    fn mock_animated_texture(id: u32) -> AnimatedTexture {
+        AnimatedTexture::new(vec![mock_atlas_tile(id)], 0.1).expect("Invalid frame duration")
+    }
+
+    #[test]
+    fn test_new_directional_animated_texture() {
+        let mut textures = HashMap::new();
+        let mut stopped_textures = HashMap::new();
+
+        textures.insert(Direction::Up, mock_animated_texture(1));
+        textures.insert(Direction::Down, mock_animated_texture(2));
+        stopped_textures.insert(Direction::Up, mock_animated_texture(3));
+        stopped_textures.insert(Direction::Down, mock_animated_texture(4));
+
+        let texture = DirectionalAnimatedTexture::new(textures, stopped_textures);
+
+        assert_eq!(texture.texture_count(), 2);
+        assert_eq!(texture.stopped_texture_count(), 2);
+        assert!(texture.has_direction(Direction::Up));
+        assert!(texture.has_direction(Direction::Down));
+        assert!(!texture.has_direction(Direction::Left));
+        assert!(texture.has_stopped_direction(Direction::Up));
+        assert!(texture.has_stopped_direction(Direction::Down));
+        assert!(!texture.has_stopped_direction(Direction::Left));
+    }
+
+    #[test]
+    fn test_tick() {
+        let mut textures = HashMap::new();
+        textures.insert(Direction::Up, mock_animated_texture(1));
+        textures.insert(Direction::Down, mock_animated_texture(2));
+
+        let mut texture = DirectionalAnimatedTexture::new(textures, HashMap::new());
+
+        // Should not panic
+        texture.tick(0.1);
+        assert_eq!(texture.texture_count(), 2);
+    }
+
+    #[test]
+    fn test_empty_texture() {
+        let texture = DirectionalAnimatedTexture::new(HashMap::new(), HashMap::new());
+
+        assert_eq!(texture.texture_count(), 0);
+        assert_eq!(texture.stopped_texture_count(), 0);
+        assert!(!texture.has_direction(Direction::Up));
+        assert!(!texture.has_stopped_direction(Direction::Up));
+    }
+
+    #[test]
+    fn test_partial_directions() {
+        let mut textures = HashMap::new();
+        textures.insert(Direction::Up, mock_animated_texture(1));
+
+        let texture = DirectionalAnimatedTexture::new(textures, HashMap::new());
+
+        assert_eq!(texture.texture_count(), 1);
+        assert!(texture.has_direction(Direction::Up));
+        assert!(!texture.has_direction(Direction::Down));
+        assert!(!texture.has_direction(Direction::Left));
+        assert!(!texture.has_direction(Direction::Right));
+    }
+
+    #[test]
+    fn test_clone() {
+        let mut textures = HashMap::new();
+        textures.insert(Direction::Up, mock_animated_texture(1));
+
+        let texture = DirectionalAnimatedTexture::new(textures, HashMap::new());
+        let cloned = texture.clone();
+
+        assert_eq!(texture.texture_count(), cloned.texture_count());
+        assert_eq!(texture.stopped_texture_count(), cloned.stopped_texture_count());
+        assert_eq!(texture.has_direction(Direction::Up), cloned.has_direction(Direction::Up));
+    }
+
+    #[test]
+    fn test_all_directions() {
+        let mut textures = HashMap::new();
+        textures.insert(Direction::Up, mock_animated_texture(1));
+        textures.insert(Direction::Down, mock_animated_texture(2));
+        textures.insert(Direction::Left, mock_animated_texture(3));
+        textures.insert(Direction::Right, mock_animated_texture(4));
+
+        let texture = DirectionalAnimatedTexture::new(textures, HashMap::new());
+
+        assert_eq!(texture.texture_count(), 4);
+        assert!(texture.has_direction(Direction::Up));
+        assert!(texture.has_direction(Direction::Down));
+        assert!(texture.has_direction(Direction::Left));
+        assert!(texture.has_direction(Direction::Right));
+    }
 }