foxhunt/ml/src/hyperopt/tests.rs

//! Unit Tests for Hyperparameter Optimization Framework
//!
//! This module provides comprehensive unit tests for the egobox integration,
//! parameter space conversions, and optimization logic.

#[cfg(test)]
#[allow(deprecated)] // Tests for deprecated denormalize_params function
mod tests {
    use super::super::egobox_tuner::*;
    use approx::assert_relative_eq;

    // ============================================================================
    // PARAMETER SPACE TESTS
    // ============================================================================

    #[test]
    fn test_hyperparameter_space_default_bounds() {
        let space = HyperparameterSpace::default();

        // Verify all bounds are valid (min < max)
        assert!(
            space.learning_rate_log_min < space.learning_rate_log_max,
            "Learning rate bounds invalid"
        );
        assert!(
            space.batch_size_min < space.batch_size_max,
            "Batch size bounds invalid"
        );
        assert!(
            space.dropout_min < space.dropout_max,
            "Dropout bounds invalid"
        );
        assert!(
            space.weight_decay_log_min < space.weight_decay_log_max,
            "Weight decay bounds invalid"
        );

        // Verify reasonable defaults
        assert_eq!(space.learning_rate_log_min, -5.0, "Expected 1e-5 min LR");
        assert_eq!(space.learning_rate_log_max, -2.0, "Expected 1e-2 max LR");
        assert_eq!(space.batch_size_min, 16, "Expected min batch size 16");
        assert_eq!(space.batch_size_max, 256, "Expected max batch size 256");
        assert_eq!(space.dropout_min, 0.0, "Expected min dropout 0.0");
        assert_eq!(space.dropout_max, 0.5, "Expected max dropout 0.5");
    }

    #[test]
    fn test_denormalize_params_min_bounds() {
        use ndarray::Array1;

        let space = HyperparameterSpace::default();

        // Test minimum values (all parameters at 0.0 in normalized space)
        let normalized = Array1::from_vec(vec![0.0, 0.0, 0.0, 0.0]);
        let (lr, batch, dropout, wd) =
            super::super::egobox_tuner::denormalize_params(&normalized, &space);

        // Learning rate: 10^-5.0 = 1e-5
        assert_relative_eq!(lr, 1e-5, epsilon = 1e-10);

        // Batch size: 16
        assert_eq!(batch, 16, "Expected batch size 16 at min");

        // Dropout: 0.0
        assert_relative_eq!(dropout, 0.0, epsilon = 1e-10);

        // Weight decay: 10^-6.0 = 1e-6
        assert_relative_eq!(wd, 1e-6, epsilon = 1e-10);
    }

    #[test]
    fn test_denormalize_params_max_bounds() {
        use ndarray::Array1;

        let space = HyperparameterSpace::default();

        // Test maximum values (all parameters at 1.0 in normalized space)
        let normalized = Array1::from_vec(vec![1.0, 1.0, 1.0, 1.0]);
        let (lr, batch, dropout, wd) =
            super::super::egobox_tuner::denormalize_params(&normalized, &space);

        // Learning rate: 10^-2.0 = 1e-2
        assert_relative_eq!(lr, 1e-2, epsilon = 1e-10);

        // Batch size: 256
        assert_eq!(batch, 256, "Expected batch size 256 at max");

        // Dropout: 0.5
        assert_relative_eq!(dropout, 0.5, epsilon = 1e-10);

        // Weight decay: 10^-2.0 = 1e-2
        assert_relative_eq!(wd, 1e-2, epsilon = 1e-10);
    }

    #[test]
    fn test_denormalize_params_mid_point() {
        use ndarray::Array1;

        let space = HyperparameterSpace::default();

        // Test mid-point values (all parameters at 0.5 in normalized space)
        let normalized = Array1::from_vec(vec![0.5, 0.5, 0.5, 0.5]);
        let (lr, batch, dropout, wd) =
            super::super::egobox_tuner::denormalize_params(&normalized, &space);

        // Learning rate: 10^-3.5 ≈ 3.16e-4 (geometric mean)
        let expected_lr = 10_f64.powf(-3.5);
        assert_relative_eq!(lr, expected_lr, epsilon = 1e-10);

        // Batch size: (16 + 256) / 2 = 136
        assert_eq!(batch, 136, "Expected batch size 136 at mid");

        // Dropout: 0.25 (arithmetic mean)
        assert_relative_eq!(dropout, 0.25, epsilon = 1e-10);

        // Weight decay: 10^-4.0 = 1e-4 (geometric mean)
        let expected_wd = 10_f64.powf(-4.0);
        assert_relative_eq!(wd, expected_wd, epsilon = 1e-10);
    }

    #[test]
    fn test_denormalize_params_log_scale_properties() {
        use ndarray::Array1;

        let space = HyperparameterSpace::default();

        // Test that log-scale parameters maintain proper spacing
        let norm_25 = Array1::from_vec(vec![0.25, 0.5, 0.5, 0.25]);
        let norm_75 = Array1::from_vec(vec![0.75, 0.5, 0.5, 0.75]);

        let (lr_25, _, _, wd_25) = super::super::egobox_tuner::denormalize_params(&norm_25, &space);
        let (lr_75, _, _, wd_75) = super::super::egobox_tuner::denormalize_params(&norm_75, &space);

        // Verify log-scale: ratio should be consistent
        // LR space: [-5, -2] = 3 decades, increment 0.5 -> 10^1.5 = 31.62x
        // WD space: [-6, -2] = 4 decades, increment 0.5 -> 10^2.0 = 100x
        // So ratios will be different - just verify they are reasonable
        let lr_ratio = lr_75 / lr_25;
        let wd_ratio = wd_75 / wd_25;

        assert!(lr_ratio > 10.0, "LR ratio {} should be > 10x", lr_ratio);
        assert!(wd_ratio > 10.0, "WD ratio {} should be > 10x", wd_ratio);
        assert!(lr_ratio < 1000.0, "LR ratio {} should be < 1000x", lr_ratio);
        assert!(wd_ratio < 1000.0, "WD ratio {} should be < 1000x", wd_ratio);
    }

    #[test]
    fn test_denormalize_batch_size_discrete() {
        use ndarray::Array1;

        let space = HyperparameterSpace::default();

        // Test that batch size is always an integer
        for i in 0..=10 {
            let norm = i as f64 / 10.0; // 0.0, 0.1, 0.2, ..., 1.0
            let normalized = Array1::from_vec(vec![0.5, norm, 0.5, 0.5]);
            let (_, batch, _, _) =
                super::super::egobox_tuner::denormalize_params(&normalized, &space);

            // Batch size must be an integer
            assert_eq!(batch as f64, batch as f64, "Batch size is an integer");

            // Batch size must be in valid range
            assert!(
                batch >= space.batch_size_min && batch <= space.batch_size_max,
                "Batch size {} out of bounds [{}, {}]",
                batch,
                space.batch_size_min,
                space.batch_size_max
            );
        }
    }

    // ============================================================================
    // BEST HYPERPARAMETERS SERIALIZATION TESTS
    // ============================================================================

    #[test]
    fn test_best_hyperparameters_serialization() {
        let params = BestHyperparameters {
            learning_rate: 0.001,
            batch_size: 64,
            dropout: 0.2,
            weight_decay: 0.0001,
            best_validation_loss: 15.5,
            trials_used: 30,
        };

        // Serialize to JSON
        let json = serde_json::to_string(&params).expect("Failed to serialize to JSON");
        assert!(json.contains("learning_rate"));
        assert!(json.contains("0.001"));

        // Deserialize back
        let deserialized: BestHyperparameters =
            serde_json::from_str(&json).expect("Failed to deserialize from JSON");

        assert_relative_eq!(
            deserialized.learning_rate,
            params.learning_rate,
            epsilon = 1e-10
        );
        assert_eq!(deserialized.batch_size, params.batch_size);
        assert_relative_eq!(deserialized.dropout, params.dropout, epsilon = 1e-10);
        assert_relative_eq!(
            deserialized.weight_decay,
            params.weight_decay,
            epsilon = 1e-10
        );
        assert_relative_eq!(
            deserialized.best_validation_loss,
            params.best_validation_loss,
            epsilon = 1e-10
        );
        assert_eq!(deserialized.trials_used, params.trials_used);
    }

    #[test]
    fn test_best_hyperparameters_yaml_serialization() {
        let params = BestHyperparameters {
            learning_rate: 0.001,
            batch_size: 64,
            dropout: 0.2,
            weight_decay: 0.0001,
            best_validation_loss: 15.5,
            trials_used: 30,
        };

        // Serialize to YAML
        let yaml = serde_yaml::to_string(&params).expect("Failed to serialize to YAML");
        assert!(yaml.contains("learning_rate"));
        assert!(yaml.contains("0.001"));

        // Deserialize back
        let deserialized: BestHyperparameters =
            serde_yaml::from_str(&yaml).expect("Failed to deserialize from YAML");

        assert_relative_eq!(
            deserialized.learning_rate,
            params.learning_rate,
            epsilon = 1e-10
        );
        assert_eq!(deserialized.batch_size, params.batch_size);
    }

    // ============================================================================
    // TRIAL RESULT TESTS
    // ============================================================================

    #[test]
    fn test_trial_result_creation() {
        let trial = TrialResult {
            trial_number: 1,
            learning_rate: 0.001,
            batch_size: 64,
            dropout: 0.2,
            weight_decay: 0.0001,
            validation_loss: 15.5,
            training_time_seconds: 18.3,
        };

        assert_eq!(trial.trial_number, 1);
        assert_relative_eq!(trial.learning_rate, 0.001, epsilon = 1e-10);
        assert_eq!(trial.batch_size, 64);
        assert_relative_eq!(trial.dropout, 0.2, epsilon = 1e-10);
        assert_relative_eq!(trial.validation_loss, 15.5, epsilon = 1e-10);
        assert_relative_eq!(trial.training_time_seconds, 18.3, epsilon = 1e-10);
    }

    #[test]
    fn test_trial_result_serialization() {
        let trial = TrialResult {
            trial_number: 5,
            learning_rate: 0.001,
            batch_size: 128,
            dropout: 0.3,
            weight_decay: 0.0001,
            validation_loss: 12.3,
            training_time_seconds: 20.5,
        };

        // Serialize to JSON
        let json = serde_json::to_string(&trial).expect("Failed to serialize trial to JSON");
        assert!(json.contains("trial_number"));
        // JSON may serialize as "trial_number":5 (no quotes around number)
        assert!(json.contains("5") || json.contains("\"5\""));

        // Deserialize back
        let deserialized: TrialResult =
            serde_json::from_str(&json).expect("Failed to deserialize trial from JSON");

        assert_eq!(deserialized.trial_number, trial.trial_number);
        assert_relative_eq!(
            deserialized.learning_rate,
            trial.learning_rate,
            epsilon = 1e-10
        );
        assert_eq!(deserialized.batch_size, trial.batch_size);
    }

    // ============================================================================
    // OPTIMIZATION RESULT TESTS
    // ============================================================================

    #[test]
    fn test_optimization_result_structure() {
        let best_params = BestHyperparameters {
            learning_rate: 0.001,
            batch_size: 64,
            dropout: 0.2,
            weight_decay: 0.0001,
            best_validation_loss: 12.5,
            trials_used: 30,
        };

        let trial_history = vec![
            TrialResult {
                trial_number: 1,
                learning_rate: 0.001,
                batch_size: 64,
                dropout: 0.2,
                weight_decay: 0.0001,
                validation_loss: 15.5,
                training_time_seconds: 18.0,
            },
            TrialResult {
                trial_number: 30,
                learning_rate: 0.001,
                batch_size: 64,
                dropout: 0.2,
                weight_decay: 0.0001,
                validation_loss: 12.5,
                training_time_seconds: 19.0,
            },
        ];

        let result = OptimizationResult {
            best_params: best_params.clone(),
            trial_history: trial_history.clone(),
        };

        assert_relative_eq!(
            result.best_params.best_validation_loss,
            12.5,
            epsilon = 1e-10
        );
        assert_eq!(result.trial_history.len(), 2);
        assert_eq!(result.trial_history[0].trial_number, 1);
        assert_eq!(result.trial_history[1].trial_number, 30);
    }

    #[test]
    fn test_optimization_result_serialization() {
        let best_params = BestHyperparameters {
            learning_rate: 0.001,
            batch_size: 64,
            dropout: 0.2,
            weight_decay: 0.0001,
            best_validation_loss: 12.5,
            trials_used: 30,
        };

        let trial_history = vec![TrialResult {
            trial_number: 1,
            learning_rate: 0.001,
            batch_size: 64,
            dropout: 0.2,
            weight_decay: 0.0001,
            validation_loss: 15.5,
            training_time_seconds: 18.0,
        }];

        let result = OptimizationResult {
            best_params,
            trial_history,
        };

        // Serialize to YAML (production format)
        let yaml = serde_yaml::to_string(&result).expect("Failed to serialize result to YAML");
        assert!(yaml.contains("best_params"));
        assert!(yaml.contains("trial_history"));

        // Deserialize back
        let deserialized: OptimizationResult =
            serde_yaml::from_str(&yaml).expect("Failed to deserialize result from YAML");

        assert_relative_eq!(
            deserialized.best_params.learning_rate,
            0.001,
            epsilon = 1e-10
        );
        assert_eq!(deserialized.trial_history.len(), 1);
    }

    // ============================================================================
    // CUSTOM SEARCH SPACE TESTS
    // ============================================================================

    #[test]
    fn test_custom_search_space() {
        let custom_space = HyperparameterSpace {
            learning_rate_log_min: -4.0, // 1e-4
            learning_rate_log_max: -1.0, // 1e-1
            batch_size_min: 32,
            batch_size_max: 128,
            dropout_min: 0.1,
            dropout_max: 0.3,
            weight_decay_log_min: -5.0, // 1e-5
            weight_decay_log_max: -3.0, // 1e-3
        };

        use ndarray::Array1;

        // Test min bounds
        let min_normalized = Array1::from_vec(vec![0.0, 0.0, 0.0, 0.0]);
        let (lr_min, batch_min, dropout_min, wd_min) =
            super::super::egobox_tuner::denormalize_params(&min_normalized, &custom_space);

        assert_relative_eq!(lr_min, 1e-4, epsilon = 1e-10);
        assert_eq!(batch_min, 32);
        assert_relative_eq!(dropout_min, 0.1, epsilon = 1e-10);
        assert_relative_eq!(wd_min, 1e-5, epsilon = 1e-10);

        // Test max bounds
        let max_normalized = Array1::from_vec(vec![1.0, 1.0, 1.0, 1.0]);
        let (lr_max, batch_max, dropout_max, wd_max) =
            super::super::egobox_tuner::denormalize_params(&max_normalized, &custom_space);

        assert_relative_eq!(lr_max, 1e-1, epsilon = 1e-10);
        assert_eq!(batch_max, 128);
        assert_relative_eq!(dropout_max, 0.3, epsilon = 1e-10);
        assert_relative_eq!(wd_max, 1e-3, epsilon = 1e-10);
    }

    // ============================================================================
    // EDGE CASE TESTS
    // ============================================================================

    #[test]
    fn test_denormalize_extreme_values() {
        use ndarray::Array1;

        let space = HyperparameterSpace::default();

        // Test values slightly outside [0, 1] (numerical edge cases)
        let slightly_negative = Array1::from_vec(vec![-0.0001, 0.5, 0.5, 0.5]);
        let (lr, _, _, _) =
            super::super::egobox_tuner::denormalize_params(&slightly_negative, &space);

        // Should clamp or handle gracefully (depends on implementation)
        assert!(lr > 0.0, "Learning rate must be positive");
        assert!(lr.is_finite(), "Learning rate must be finite");
    }

    #[test]
    fn test_batch_size_rounding() {
        use ndarray::Array1;

        let space = HyperparameterSpace {
            batch_size_min: 10,
            batch_size_max: 20,
            ..HyperparameterSpace::default()
        };

        // Test values that should round to specific integers
        let test_values = vec![0.0, 0.1, 0.5, 0.9, 1.0];

        for norm_val in test_values {
            let normalized = Array1::from_vec(vec![0.5, norm_val, 0.5, 0.5]);
            let (_, batch, _, _) =
                super::super::egobox_tuner::denormalize_params(&normalized, &space);

            // Verify integer and in range
            assert!(
                batch >= 10 && batch <= 20,
                "Batch {} out of range [10, 20]",
                batch
            );
        }
    }

    #[test]
    fn test_zero_dropout_valid() {
        use ndarray::Array1;

        let space = HyperparameterSpace::default();

        // Test zero dropout (valid edge case)
        let normalized = Array1::from_vec(vec![0.5, 0.5, 0.0, 0.5]);
        let (_, _, dropout, _) =
            super::super::egobox_tuner::denormalize_params(&normalized, &space);

        assert_relative_eq!(dropout, 0.0, epsilon = 1e-10);
        assert!(dropout >= 0.0, "Dropout must be non-negative");
    }

    #[test]
    fn test_max_dropout_valid() {
        use ndarray::Array1;

        let space = HyperparameterSpace::default();

        // Test max dropout
        let normalized = Array1::from_vec(vec![0.5, 0.5, 1.0, 0.5]);
        let (_, _, dropout, _) =
            super::super::egobox_tuner::denormalize_params(&normalized, &space);

        assert_relative_eq!(dropout, 0.5, epsilon = 1e-10);
        assert!(dropout <= 1.0, "Dropout must be <= 1.0");
    }

    // ============================================================================
    // HELPER FUNCTION TESTS
    // ============================================================================

    #[test]
    fn test_denormalize_is_deterministic() {
        use ndarray::Array1;

        let space = HyperparameterSpace::default();
        let normalized = Array1::from_vec(vec![0.3, 0.7, 0.2, 0.8]);

        // Call multiple times with same input
        let (lr1, batch1, dropout1, wd1) =
            super::super::egobox_tuner::denormalize_params(&normalized, &space);
        let (lr2, batch2, dropout2, wd2) =
            super::super::egobox_tuner::denormalize_params(&normalized, &space);

        // Results must be identical
        assert_relative_eq!(lr1, lr2, epsilon = 1e-15);
        assert_eq!(batch1, batch2);
        assert_relative_eq!(dropout1, dropout2, epsilon = 1e-15);
        assert_relative_eq!(wd1, wd2, epsilon = 1e-15);
    }

    #[test]
    fn test_denormalize_all_parameters_used() {
        use ndarray::Array1;

        let space = HyperparameterSpace::default();

        // Different values for each parameter
        let normalized = Array1::from_vec(vec![0.1, 0.2, 0.3, 0.4]);
        let (lr, batch, dropout, wd) =
            super::super::egobox_tuner::denormalize_params(&normalized, &space);

        // Verify each parameter is different (not a default value)
        assert!(
            lr > 1e-5 && lr < 1e-2,
            "LR should be within bounds and unique"
        );
        assert!(
            batch > 16 && batch < 256,
            "Batch should be within bounds and unique"
        );
        assert!(
            dropout > 0.0 && dropout < 0.5,
            "Dropout should be within bounds and unique"
        );
        assert!(
            wd > 1e-6 && wd < 1e-2,
            "WD should be within bounds and unique"
        );
    }

    // ============================================================================
    // PROPERTY-BASED TESTS (proptest)
    // ============================================================================

    use proptest::prelude::*;

    proptest! {
        #[test]
        fn test_denormalize_always_in_bounds(
            lr_norm in 0.0f64..=1.0,
            batch_norm in 0.0f64..=1.0,
            dropout_norm in 0.0f64..=1.0,
            wd_norm in 0.0f64..=1.0
        ) {
            use ndarray::Array1;

            let space = HyperparameterSpace::default();
            let normalized = Array1::from_vec(vec![lr_norm, batch_norm, dropout_norm, wd_norm]);

            let (lr, batch, dropout, wd) =
                super::super::egobox_tuner::denormalize_params(&normalized, &space);

            // Learning rate bounds (log scale)
            let lr_min = 10_f64.powf(space.learning_rate_log_min);
            let lr_max = 10_f64.powf(space.learning_rate_log_max);
            prop_assert!(lr >= lr_min * 0.9999 && lr <= lr_max * 1.0001,
                "LR {} not in [{}, {}]", lr, lr_min, lr_max);

            // Batch size bounds
            prop_assert!(batch >= space.batch_size_min && batch <= space.batch_size_max,
                "Batch {} not in [{}, {}]", batch, space.batch_size_min, space.batch_size_max);

            // Dropout bounds
            prop_assert!(dropout >= space.dropout_min && dropout <= space.dropout_max,
                "Dropout {} not in [{}, {}]", dropout, space.dropout_min, space.dropout_max);

            // Weight decay bounds (log scale)
            let wd_min = 10_f64.powf(space.weight_decay_log_min);
            let wd_max = 10_f64.powf(space.weight_decay_log_max);
            prop_assert!(wd >= wd_min * 0.9999 && wd <= wd_max * 1.0001,
                "WD {} not in [{}, {}]", wd, wd_min, wd_max);

            // Verify all values are finite
            prop_assert!(lr.is_finite(), "LR must be finite");
            prop_assert!(dropout.is_finite(), "Dropout must be finite");
            prop_assert!(wd.is_finite(), "WD must be finite");

            // Verify batch size is an integer
            prop_assert_eq!(batch as f64, batch as f64, "Batch size must be integer");
        }

        #[test]
        fn test_denormalize_monotonicity_lr(
            norm1 in 0.0f64..0.5,
            norm2 in 0.5f64..=1.0
        ) {
            use ndarray::Array1;

            let space = HyperparameterSpace::default();

            let normalized1 = Array1::from_vec(vec![norm1, 0.5, 0.5, 0.5]);
            let normalized2 = Array1::from_vec(vec![norm2, 0.5, 0.5, 0.5]);

            let (lr1, _, _, _) =
                super::super::egobox_tuner::denormalize_params(&normalized1, &space);
            let (lr2, _, _, _) =
                super::super::egobox_tuner::denormalize_params(&normalized2, &space);

            // Higher normalized value should give higher learning rate
            prop_assert!(lr2 >= lr1, "LR monotonicity violated: {} >= {}", lr2, lr1);
        }

        #[test]
        fn test_denormalize_monotonicity_batch(
            norm1 in 0.0f64..0.5,
            norm2 in 0.5f64..=1.0
        ) {
            use ndarray::Array1;

            let space = HyperparameterSpace::default();

            let normalized1 = Array1::from_vec(vec![0.5, norm1, 0.5, 0.5]);
            let normalized2 = Array1::from_vec(vec![0.5, norm2, 0.5, 0.5]);

            let (_, batch1, _, _) =
                super::super::egobox_tuner::denormalize_params(&normalized1, &space);
            let (_, batch2, _, _) =
                super::super::egobox_tuner::denormalize_params(&normalized2, &space);

            // Higher normalized value should give higher batch size
            prop_assert!(batch2 >= batch1, "Batch monotonicity violated: {} >= {}", batch2, batch1);
        }

        #[test]
        fn test_denormalize_deterministic(
            lr_norm in 0.0f64..=1.0,
            batch_norm in 0.0f64..=1.0,
            dropout_norm in 0.0f64..=1.0,
            wd_norm in 0.0f64..=1.0
        ) {
            use ndarray::Array1;

            let space = HyperparameterSpace::default();
            let normalized = Array1::from_vec(vec![lr_norm, batch_norm, dropout_norm, wd_norm]);

            // Call twice with same input
            let (lr1, batch1, dropout1, wd1) =
                super::super::egobox_tuner::denormalize_params(&normalized, &space);
            let (lr2, batch2, dropout2, wd2) =
                super::super::egobox_tuner::denormalize_params(&normalized, &space);

            // Results must be identical
            prop_assert_eq!(lr1, lr2, "LR not deterministic");
            prop_assert_eq!(batch1, batch2, "Batch not deterministic");
            prop_assert_eq!(dropout1, dropout2, "Dropout not deterministic");
            prop_assert_eq!(wd1, wd2, "WD not deterministic");
        }

        #[test]
        fn test_custom_space_always_valid(
            lr_min in -6.0f64..=-2.0,
            lr_max in -2.0f64..=-1.0,
            batch_min in 8usize..64,
            batch_max in 64usize..512,
            dropout_min in 0.0f64..0.3,
            dropout_max in 0.3f64..0.8,
            wd_min in -7.0f64..=-3.0,
            wd_max in -3.0f64..=-1.0
        ) {
            // Ensure min < max
            prop_assume!(lr_min < lr_max);
            prop_assume!(batch_min < batch_max);
            prop_assume!(dropout_min < dropout_max);
            prop_assume!(wd_min < wd_max);

            let space = HyperparameterSpace {
                learning_rate_log_min: lr_min,
                learning_rate_log_max: lr_max,
                batch_size_min: batch_min,
                batch_size_max: batch_max,
                dropout_min,
                dropout_max,
                weight_decay_log_min: wd_min,
                weight_decay_log_max: wd_max,
            };

            use ndarray::Array1;

            // Test with mid-point
            let normalized = Array1::from_vec(vec![0.5, 0.5, 0.5, 0.5]);
            let (lr, batch, dropout, wd) =
                super::super::egobox_tuner::denormalize_params(&normalized, &space);

            // All values must be valid
            prop_assert!(lr.is_finite() && lr > 0.0, "LR must be finite and positive");
            prop_assert!(batch >= batch_min && batch <= batch_max, "Batch out of bounds");
            prop_assert!(dropout >= dropout_min && dropout <= dropout_max, "Dropout out of bounds");
            prop_assert!(wd.is_finite() && wd > 0.0, "WD must be finite and positive");
        }

        #[test]
        fn test_batch_size_always_integer(
            batch_norm in 0.0f64..=1.0
        ) {
            use ndarray::Array1;

            let space = HyperparameterSpace::default();
            let normalized = Array1::from_vec(vec![0.5, batch_norm, 0.5, 0.5]);

            let (_, batch, _, _) =
                super::super::egobox_tuner::denormalize_params(&normalized, &space);

            // Batch size must be an integer (no fractional part)
            let batch_float = batch as f64;
            prop_assert_eq!(batch_float.floor(), batch_float, "Batch size must be integer");
        }

        #[test]
        fn test_log_scale_geometric_mean(
            norm in 0.0f64..=1.0
        ) {
            use ndarray::Array1;

            let space = HyperparameterSpace::default();
            let normalized = Array1::from_vec(vec![norm, 0.5, 0.5, 0.5]);

            let (lr, _, _, _) =
                super::super::egobox_tuner::denormalize_params(&normalized, &space);

            // Verify log-scale: lr = 10^(log_min + norm * (log_max - log_min))
            let expected_log = space.learning_rate_log_min + norm * (space.learning_rate_log_max - space.learning_rate_log_min);
            let expected_lr = 10_f64.powf(expected_log);

            // Allow small floating point tolerance
            let rel_error = (lr - expected_lr).abs() / expected_lr;
            prop_assert!(rel_error < 1e-10, "LR log-scale error too large: {}", rel_error);
        }
    }
}