leptos-motion-layout 1.1.0

//! Simple Layout Tests
//!
//! This module provides basic unit tests for the leptos-motion-layout crate
//! to improve test coverage with tests that actually work with the current API.

use super::*;

#[cfg(test)]
mod layout_info_tests {
    use super::*;

    #[test]
    fn test_layout_info_creation() {
        let info = LayoutInfo::new(10.0, 20.0, 100.0, 200.0);
        assert_eq!(info.x, 10.0);
        assert_eq!(info.y, 20.0);
        assert_eq!(info.width, 100.0);
        assert_eq!(info.height, 200.0);
    }

    #[test]
    fn test_layout_info_default() {
        let info = LayoutInfo::default();
        assert_eq!(info.x, 0.0);
        assert_eq!(info.y, 0.0);
        assert_eq!(info.width, 0.0);
        assert_eq!(info.height, 0.0);
    }

    #[test]
    fn test_layout_info_from_dimensions() {
        let info = LayoutInfo::from_dimensions(150.0, 300.0);
        assert_eq!(info.x, 0.0);
        assert_eq!(info.y, 0.0);
        assert_eq!(info.width, 150.0);
        assert_eq!(info.height, 300.0);
    }

    #[test]
    fn test_layout_info_from_position() {
        let info = LayoutInfo::from_position(25.0, 50.0);
        assert_eq!(info.x, 25.0);
        assert_eq!(info.y, 50.0);
        assert_eq!(info.width, 0.0);
        assert_eq!(info.height, 0.0);
    }

    #[test]
    fn test_layout_info_area() {
        let info = LayoutInfo::new(0.0, 0.0, 10.0, 20.0);
        assert_eq!(info.area(), 200.0);
        
        let info2 = LayoutInfo::new(5.0, 10.0, 3.0, 4.0);
        assert_eq!(info2.area(), 12.0);
    }

    #[test]
    fn test_layout_info_center() {
        let info = LayoutInfo::new(10.0, 20.0, 100.0, 200.0);
        let (cx, cy) = info.center();
        assert_eq!(cx, 60.0); // 10 + 100/2
        assert_eq!(cy, 120.0); // 20 + 200/2
        
        let info2 = LayoutInfo::new(0.0, 0.0, 8.0, 6.0);
        let (cx2, cy2) = info2.center();
        assert_eq!(cx2, 4.0); // 0 + 8/2
        assert_eq!(cy2, 3.0); // 0 + 6/2
    }

    #[test]
    fn test_layout_info_contains_point() {
        let info = LayoutInfo::new(10.0, 20.0, 100.0, 200.0);

        // Inside bounds
        assert!(info.contains_point(50.0, 100.0));
        assert!(info.contains_point(10.0, 20.0)); // Top-left corner
        assert!(info.contains_point(110.0, 220.0)); // Bottom-right corner
        assert!(info.contains_point(60.0, 120.0)); // Center

        // Outside bounds
        assert!(!info.contains_point(5.0, 100.0)); // Left of bounds
        assert!(!info.contains_point(115.0, 100.0)); // Right of bounds
        assert!(!info.contains_point(50.0, 15.0)); // Above bounds
        assert!(!info.contains_point(50.0, 225.0)); // Below bounds
    }

    #[test]
    fn test_layout_info_edge_cases() {
        // Zero dimensions
        let info = LayoutInfo::new(0.0, 0.0, 0.0, 0.0);
        assert_eq!(info.area(), 0.0);
        assert_eq!(info.center(), (0.0, 0.0));
        assert!(info.contains_point(0.0, 0.0));
        assert!(!info.contains_point(1.0, 1.0));

        // Negative coordinates
        let info2 = LayoutInfo::new(-10.0, -20.0, 100.0, 200.0);
        assert_eq!(info2.center(), (40.0, 80.0)); // -10 + 100/2, -20 + 200/2
        assert!(info2.contains_point(-10.0, -20.0));
        assert!(info2.contains_point(90.0, 180.0));
        assert!(!info2.contains_point(-11.0, -20.0));
    }
}

#[cfg(test)]
mod layout_animation_config_tests {
    use super::*;

    #[test]
    fn test_layout_animation_config_default() {
        let config = LayoutAnimationConfig::default();
        assert!(config.enabled);
        assert_eq!(config.duration, 0.3);
        assert!(config.hardware_accelerated);
    }

    #[test]
    fn test_layout_animation_config_new() {
        let config = LayoutAnimationConfig::new();
        assert!(config.enabled);
        assert_eq!(config.duration, 0.3);
        assert!(config.hardware_accelerated);
    }

    #[test]
    fn test_layout_animation_config_builder() {
        let config = LayoutAnimationConfig::new()
            .with_duration(0.5)
            .hardware_accelerated(false)
            .enabled(false);

        assert!(!config.enabled);
        assert_eq!(config.duration, 0.5);
        assert!(!config.hardware_accelerated);
    }

    #[test]
    fn test_layout_animation_config_with_easing() {
        let config = LayoutAnimationConfig::new().with_easing(EasingFunction::Linear);

        match config.easing {
            EasingFunction::Linear => assert!(true),
            _ => panic!("Expected Linear easing function"),
        }
    }

    #[test]
    fn test_layout_animation_config_fluent_api() {
        let config = LayoutAnimationConfig::new()
            .with_duration(1.0)
            .with_easing(EasingFunction::EaseIn)
            .hardware_accelerated(true)
            .enabled(true);

        assert!(config.enabled);
        assert_eq!(config.duration, 1.0);
        assert!(config.hardware_accelerated);
        match config.easing {
            EasingFunction::EaseIn => assert!(true),
            _ => panic!("Expected EaseIn easing function"),
        }
    }
}

#[cfg(test)]
mod flip_animation_tests {
    use super::*;

    #[test]
    fn test_easing_function_variants() {
        // Test all easing function variants
        let linear = EasingFunction::Linear;
        let ease_in = EasingFunction::EaseIn;
        let ease_out = EasingFunction::EaseOut;
        let ease_in_out = EasingFunction::EaseInOut;
        let spring = EasingFunction::Spring { tension: 100.0, friction: 10.0 };
        let cubic_bezier = EasingFunction::CubicBezier(0.25, 0.1, 0.25, 1.0);

        // Test that they can be created and matched
        match linear {
            EasingFunction::Linear => assert!(true),
            _ => panic!("Expected Linear"),
        }

        match ease_in {
            EasingFunction::EaseIn => assert!(true),
            _ => panic!("Expected EaseIn"),
        }

        match ease_out {
            EasingFunction::EaseOut => assert!(true),
            _ => panic!("Expected EaseOut"),
        }

        match ease_in_out {
            EasingFunction::EaseInOut => assert!(true),
            _ => panic!("Expected EaseInOut"),
        }

        match spring {
            EasingFunction::Spring { tension, friction } => {
                assert_eq!(tension, 100.0);
                assert_eq!(friction, 10.0);
            },
            _ => panic!("Expected Spring"),
        }

        match cubic_bezier {
            EasingFunction::CubicBezier(x1, y1, x2, y2) => {
                assert_eq!(x1, 0.25);
                assert_eq!(y1, 0.1);
                assert_eq!(x2, 0.25);
                assert_eq!(y2, 1.0);
            },
            _ => panic!("Expected CubicBezier"),
        }
    }

    #[test]
    fn test_easing_function_default() {
        let easing = EasingFunction::default();
        match easing {
            EasingFunction::EaseOut => assert!(true),
            _ => panic!("Expected default to be EaseOut"),
        }
    }

    #[test]
    fn test_flip_animator_creation() {
        let animator = FLIPAnimator::new();
        // FLIPAnimator::new() returns a struct, not an Option
        assert!(true); // Just test that it can be created
    }

    #[test]
    fn test_flip_animator_default() {
        let animator = FLIPAnimator::default();
        // FLIPAnimator::default() returns a struct, not an Option
        assert!(true); // Just test that it can be created
    }

    #[test]
    fn test_transform_values_default() {
        let transform = TransformValues::default();
        assert_eq!(transform.translate_x, 0.0);
        assert_eq!(transform.translate_y, 0.0);
        assert_eq!(transform.scale_x, 1.0);
        assert_eq!(transform.scale_y, 1.0);
        assert_eq!(transform.rotation, 0.0);
    }

    #[test]
    fn test_transform_values_new() {
        let transform = TransformValues::new(10.0, 20.0, 2.0, 3.0, 45.0);
        assert_eq!(transform.translate_x, 10.0);
        assert_eq!(transform.translate_y, 20.0);
        assert_eq!(transform.scale_x, 2.0);
        assert_eq!(transform.scale_y, 3.0);
        assert_eq!(transform.rotation, 45.0);
    }

    #[test]
    fn test_transform_values_translation() {
        let transform = TransformValues::translation(15.0, 25.0);
        assert_eq!(transform.translate_x, 15.0);
        assert_eq!(transform.translate_y, 25.0);
        assert_eq!(transform.scale_x, 1.0);
        assert_eq!(transform.scale_y, 1.0);
        assert_eq!(transform.rotation, 0.0);
    }

    #[test]
    fn test_transform_values_scale() {
        let transform = TransformValues::scale(2.5, 1.5);
        assert_eq!(transform.translate_x, 0.0);
        assert_eq!(transform.translate_y, 0.0);
        assert_eq!(transform.scale_x, 2.5);
        assert_eq!(transform.scale_y, 1.5);
        assert_eq!(transform.rotation, 0.0);
    }

    #[test]
    fn test_transform_values_rotation() {
        let transform = TransformValues::rotation(90.0);
        assert_eq!(transform.translate_x, 0.0);
        assert_eq!(transform.translate_y, 0.0);
        assert_eq!(transform.scale_x, 1.0);
        assert_eq!(transform.scale_y, 1.0);
        assert_eq!(transform.rotation, 90.0);
    }
}

#[cfg(test)]
mod shared_elements_tests {
    use super::*;
    use crate::shared_elements::{TransitionPriority, TransitionRecord, SharedElementMetrics};

    #[test]
    fn test_shared_element_config_default() {
        let config = SharedElementConfig::default();
        assert_eq!(config.duration, 0.3);
        assert!(config.hardware_accelerated);
    }

    #[test]
    fn test_transition_priority_variants() {
        let critical = TransitionPriority::Critical;
        let high = TransitionPriority::High;
        let normal = TransitionPriority::Normal;
        let low = TransitionPriority::Low;

        // Test that they can be created and matched
        match critical {
            TransitionPriority::Critical => assert!(true),
            _ => panic!("Expected Critical"),
        }

        match high {
            TransitionPriority::High => assert!(true),
            _ => panic!("Expected High"),
        }

        match normal {
            TransitionPriority::Normal => assert!(true),
            _ => panic!("Expected Normal"),
        }

        match low {
            TransitionPriority::Low => assert!(true),
            _ => panic!("Expected Low"),
        }
    }

    #[test]
    fn test_transition_priority_default() {
        let priority = TransitionPriority::default();
        match priority {
            TransitionPriority::Normal => assert!(true),
            _ => panic!("Expected default to be Normal"),
        }
    }

    #[test]
    fn test_transition_record_creation() {
        let record = TransitionRecord {
            id: "test-id".to_string(),
            start_time: 0.0,
            end_time: None,
            duration: 0.0,
            success: false,
            performance: SharedElementMetrics::default(),
        };
        assert_eq!(record.id, "test-id");
        assert_eq!(record.start_time, 0.0);
        assert_eq!(record.duration, 0.0);
        assert!(!record.success);
    }

    #[test]
    fn test_z_index_strategy_variants() {
        let fixed = ZIndexStrategy::Fixed { base: 100, increment: 1 };
        let dynamic = ZIndexStrategy::Dynamic { base: 1000, max: 10000 };
        let elevate = ZIndexStrategy::Elevate;
        let maintain = ZIndexStrategy::Maintain;
        let custom = ZIndexStrategy::Custom(42);
        let custom_property = ZIndexStrategy::CustomProperty { property: "z-index".to_string() };

        // Test that they can be created and matched
        match fixed {
            ZIndexStrategy::Fixed { base, increment } => {
                assert_eq!(base, 100);
                assert_eq!(increment, 1);
            },
            _ => panic!("Expected Fixed"),
        }

        match dynamic {
            ZIndexStrategy::Dynamic { base, max } => {
                assert_eq!(base, 1000);
                assert_eq!(max, 10000);
            },
            _ => panic!("Expected Dynamic"),
        }

        match elevate {
            ZIndexStrategy::Elevate => assert!(true),
            _ => panic!("Expected Elevate"),
        }

        match maintain {
            ZIndexStrategy::Maintain => assert!(true),
            _ => panic!("Expected Maintain"),
        }

        match custom {
            ZIndexStrategy::Custom(value) => assert_eq!(value, 42),
            _ => panic!("Expected Custom"),
        }

        match custom_property {
            ZIndexStrategy::CustomProperty { property } => assert_eq!(property, "z-index"),
            _ => panic!("Expected CustomProperty"),
        }
    }

    #[test]
    fn test_z_index_strategy_default() {
        let strategy = ZIndexStrategy::default();
        match strategy {
            ZIndexStrategy::Fixed { base, increment } => {
                assert_eq!(base, 1000);
                assert_eq!(increment, 1);
            },
            _ => panic!("Expected default to be Fixed"),
        }
    }
}

#[cfg(test)]
mod simplified_layout_api_tests {
    use super::*;

    #[test]
    fn test_simplified_easing_variants() {
        let linear = SimplifiedEasing::Linear;
        let ease_in = SimplifiedEasing::EaseIn;
        let ease_out = SimplifiedEasing::EaseOut;
        let ease_in_out = SimplifiedEasing::EaseInOut;

        // Test that they can be created and matched
        match linear {
            SimplifiedEasing::Linear => assert!(true),
            _ => panic!("Expected Linear"),
        }

        match ease_in {
            SimplifiedEasing::EaseIn => assert!(true),
            _ => panic!("Expected EaseIn"),
        }

        match ease_out {
            SimplifiedEasing::EaseOut => assert!(true),
            _ => panic!("Expected EaseOut"),
        }

        match ease_in_out {
            SimplifiedEasing::EaseInOut => assert!(true),
            _ => panic!("Expected EaseInOut"),
        }
    }

    #[test]
    fn test_simplified_layout_config_default() {
        let config = SimplifiedLayoutConfig::default();
        assert_eq!(config.duration, 0.3);
        assert!(config.hardware_accelerated);
    }

    #[test]
    fn test_simplified_layout_config_creation() {
        let config = SimplifiedLayoutConfig::new();
        assert_eq!(config.duration, 0.3);
        assert!(config.hardware_accelerated);
    }

    #[test]
    fn test_simplified_layout_config_fluent_api() {
        let config = SimplifiedLayoutConfig::new()
            .duration(0.5)
            .easing(SimplifiedEasing::Linear)
            .hardware_accelerated(false);

        assert_eq!(config.duration, 0.5);
        assert_eq!(config.easing, SimplifiedEasing::Linear);
        assert!(!config.hardware_accelerated);
    }

    #[test]
    fn test_simplified_layout_config_clone() {
        let config1 = SimplifiedLayoutConfig::new()
            .duration(0.8)
            .easing(SimplifiedEasing::EaseIn);
        
        let config2 = config1.clone();
        
        assert_eq!(config1.duration, config2.duration);
        assert_eq!(config1.easing, config2.easing);
        assert_eq!(config1.hardware_accelerated, config2.hardware_accelerated);
    }

    #[test]
    fn test_simplified_layout_config_debug() {
        let config = SimplifiedLayoutConfig::new();
        let debug_str = format!("{:?}", config);
        assert!(debug_str.contains("SimplifiedLayoutConfig"));
        assert!(debug_str.contains("duration"));
        assert!(debug_str.contains("easing"));
    }

    #[test]
    fn test_simplified_layout_manager_creation() {
        let manager = SimplifiedLayoutManager::new();
        // SimplifiedLayoutManager::new() returns a struct, not an Option
        assert!(true); // Just test that it can be created
    }

    #[test]
    fn test_simplified_layout_manager_with_config() {
        let config = SimplifiedLayoutConfig::new().duration(0.5);
        let manager = SimplifiedLayoutManager::with_config(config);
        // SimplifiedLayoutManager::with_config() returns a struct, not an Option
        assert!(true); // Just test that it can be created
    }

    #[test]
    fn test_simplified_layout_manager_clone() {
        let manager1 = SimplifiedLayoutManager::new();
        let manager2 = manager1.clone();
        // Test that clone works (we can't easily test internal state without more complex setup)
        assert!(true);
    }

    #[test]
    fn test_simplified_layout_manager_debug() {
        let manager = SimplifiedLayoutManager::new();
        let debug_str = format!("{:?}", manager);
        assert!(debug_str.contains("SimplifiedLayoutManager"));
    }

    #[test]
    fn test_simplified_layout_manager_default() {
        let manager = SimplifiedLayoutManager::default();
        // SimplifiedLayoutManager::default() returns a struct, not an Option
        assert!(true); // Just test that it can be created
    }
}

#[cfg(test)]
mod edge_case_tests {
    use super::*;

    #[test]
    fn test_layout_info_with_negative_values() {
        let info = LayoutInfo::new(-10.0, -20.0, 100.0, 200.0);
        assert_eq!(info.x, -10.0);
        assert_eq!(info.y, -20.0);
        assert_eq!(info.width, 100.0);
        assert_eq!(info.height, 200.0);
        assert_eq!(info.area(), 20000.0);
        assert_eq!(info.center(), (40.0, 80.0));
    }

    #[test]
    fn test_layout_info_with_zero_dimensions() {
        let info = LayoutInfo::new(10.0, 20.0, 0.0, 0.0);
        assert_eq!(info.area(), 0.0);
        assert_eq!(info.center(), (10.0, 20.0));
        assert!(info.contains_point(10.0, 20.0));
        assert!(!info.contains_point(11.0, 21.0));
    }

    #[test]
    fn test_layout_info_with_very_large_values() {
        let info = LayoutInfo::new(1e6, 2e6, 1e9, 2e9);
        assert_eq!(info.area(), 2e18);
        // Center calculation: x + width/2, y + height/2
        // 1e6 + 1e9/2 = 1e6 + 5e8 = 5.01e8
        // 2e6 + 2e9/2 = 2e6 + 1e9 = 1.002e9
        assert_eq!(info.center(), (5.01e8, 1.002e9));
    }

    #[test]
    fn test_transform_values_with_extreme_values() {
        let transform = TransformValues::new(1e6, -1e6, 1e3, 1e-3, 360.0);
        assert_eq!(transform.translate_x, 1e6);
        assert_eq!(transform.translate_y, -1e6);
        assert_eq!(transform.scale_x, 1e3);
        assert_eq!(transform.scale_y, 1e-3);
        assert_eq!(transform.rotation, 360.0);
    }

    #[test]
    fn test_easing_function_with_extreme_spring_values() {
        let spring = EasingFunction::Spring { 
            tension: 1e6, 
            friction: 1e-6 
        };
        
        match spring {
            EasingFunction::Spring { tension, friction } => {
                assert_eq!(tension, 1e6);
                assert_eq!(friction, 1e-6);
            },
            _ => panic!("Expected Spring"),
        }
    }

    #[test]
    fn test_easing_function_with_extreme_cubic_bezier_values() {
        let cubic_bezier = EasingFunction::CubicBezier(1.0, 0.0, 0.0, 1.0);
        
        match cubic_bezier {
            EasingFunction::CubicBezier(x1, y1, x2, y2) => {
                assert_eq!(x1, 1.0);
                assert_eq!(y1, 0.0);
                assert_eq!(x2, 0.0);
                assert_eq!(y2, 1.0);
            },
            _ => panic!("Expected CubicBezier"),
        }
    }

    #[test]
    fn test_layout_animation_config_with_extreme_duration() {
        let config = LayoutAnimationConfig::new()
            .with_duration(1e6)
            .with_duration(1e-6);
        
        assert_eq!(config.duration, 1e-6);
    }
}

#[cfg(test)]
mod integration_tests {
    use super::*;

    #[test]
    fn test_layout_info_and_animation_config_integration() {
        let layout = LayoutInfo::new(0.0, 0.0, 100.0, 100.0);
        let config = LayoutAnimationConfig::new()
            .with_duration(0.5)
            .with_easing(EasingFunction::EaseInOut);

        // Test that they work together conceptually
        assert_eq!(layout.area(), 10000.0);
        assert_eq!(config.duration, 0.5);
        match config.easing {
            EasingFunction::EaseInOut => assert!(true),
            _ => panic!("Expected EaseInOut"),
        }
    }

    #[test]
    fn test_transform_values_and_easing_integration() {
        let transform = TransformValues::new(10.0, 20.0, 2.0, 1.5, 45.0);
        let easing = EasingFunction::Spring { tension: 200.0, friction: 20.0 };

        // Test that they can be used together
        assert_eq!(transform.translate_x, 10.0);
        assert_eq!(transform.scale_x, 2.0);
        match easing {
            EasingFunction::Spring { tension, friction } => {
                assert_eq!(tension, 200.0);
                assert_eq!(friction, 20.0);
            },
            _ => panic!("Expected Spring"),
        }
    }

    #[test]
    fn test_shared_elements_and_simplified_api_integration() {
        let shared_config = SharedElementConfig::default();
        let simplified_config = SimplifiedLayoutConfig::new();

        // Test that both configs can be created and used
        assert!(shared_config.duration >= 0.0);
        assert!(simplified_config.duration >= 0.0);
        assert!(shared_config.hardware_accelerated || !shared_config.hardware_accelerated);
        assert!(simplified_config.hardware_accelerated || !simplified_config.hardware_accelerated);
    }
}