#[test]
fn room_config_version_policy_accepts_supported_generations_and_rejects_unknown_versions() {
for version in ["1.0.0", "1.2.7", "2.0.0", "2.1.0"] {
assert!(
validate_config_version(version).is_ok(),
"known compatible version {version} should be accepted"
);
}
for version in ["", "2", "2.1", "0.9.0", "1.3.0", "2.2.0", "3.0.0"] {
assert!(
validate_config_version(version).is_err(),
"unknown version {version:?} should be rejected"
);
}
}
#[test]
fn room_config_default_uses_current_config_version() {
assert_eq!(RoomConfig::default().version, default_config_version());
}
#[test]
fn structural_validation_report_cannot_claim_production_readiness() {
let mut config = RoomConfig::default();
config.speakers.insert(
"L".to_string(),
SpeakerConfig::Single(MeasurementSource::Single(MeasurementSingle {
measurement: MeasurementRef::Path("left.csv".into()),
speaker_name: None,
})),
);
let report = config.validation_report();
assert!(report.stage_ran(ValidationStage::SchemaVersion));
assert!(report.stage_ran(ValidationStage::Structural));
assert!(!report.stage_ran(ValidationStage::ResolvedResource));
assert!(!report.production_ready());
assert!(config.validate_structure().is_ok());
}
#[test]
fn structural_validation_rejects_missing_system_speaker_reference() {
let mut config = RoomConfig::default();
config.speakers.insert(
"left_measurement".to_string(),
SpeakerConfig::Single(MeasurementSource::Single(MeasurementSingle {
measurement: MeasurementRef::Path("left.csv".into()),
speaker_name: None,
})),
);
config.system = Some(SystemConfig {
model: SystemModel::Stereo,
speakers: HashMap::from([("L".to_string(), "typo".to_string())]),
..Default::default()
});
let report = config.validation_report();
assert!(
report
.stage(ValidationStage::Structural)
.errors
.iter()
.any(|error| error.contains("role 'L'") && error.contains("'typo'")),
"canonical structural validation must reject dangling system speaker mappings: {report:?}"
);
assert!(config.validate_structure().is_err());
}
#[test]
fn structural_validation_rejects_unsupported_crossover_type() {
let mut config = RoomConfig::default();
config.speakers.insert(
"L".to_string(),
SpeakerConfig::Single(MeasurementSource::Single(MeasurementSingle {
measurement: MeasurementRef::Path("left.csv".into()),
speaker_name: None,
})),
);
config.crossovers = Some(HashMap::from([(
"main".to_string(),
CrossoverConfig {
crossover_type: "not-a-crossover".to_string(),
frequency: Some(80.0),
frequencies: None,
frequency_range: None,
},
)]));
let report = config.validation_report();
assert!(
report
.stage(ValidationStage::Structural)
.errors
.iter()
.any(|error| error.contains("Crossover 'main'") && error.contains("unsupported type")),
"canonical structural validation must reject unsupported crossover types: {report:?}"
);
assert!(config.validate_structure().is_err());
}
#[test]
fn structural_validation_rejects_invalid_gain_envelopes() {
let mut config = RoomConfig::default();
config.speakers.insert(
"L".to_string(),
SpeakerConfig::Single(MeasurementSource::Single(MeasurementSingle {
measurement: MeasurementRef::Path("left.csv".into()),
speaker_name: None,
})),
);
config.optimizer.max_boost_envelope =
Some(vec![(20.0, 6.0), (200.0, 3.0), (200.0, 2.0)]);
config.optimizer.min_cut_envelope =
Some(vec![(20.0, -6.0), (200.0, f64::NEG_INFINITY)]);
let report = config.validation_report();
let errors = &report.stage(ValidationStage::Structural).errors;
assert!(
errors
.iter()
.any(|error| error.contains("max_boost_envelope")
&& error.contains("strictly increasing")),
"duplicate frequencies were accepted: {errors:?}"
);
assert!(
errors
.iter()
.any(|error| error.contains("min_cut_envelope") && error.contains("finite")),
"non-finite envelope gain was accepted: {errors:?}"
);
}
#[test]
fn spl_calibration_roundtrip_and_helpers() {
let cal = SplCalibration {
reported_db_spl: 85.0,
reference_freq_hz: 1000.0,
peak_sample_level: 0.5,
spl_offset_db: 85.0 - 20.0 * 0.5_f32.log10(),
};
let json = serde_json::to_string(&cal).unwrap();
let back: SplCalibration = serde_json::from_str(&json).unwrap();
assert_eq!(back, cal);
let recovered = cal.dbspl_for_peak_level(cal.peak_sample_level);
assert!((recovered - cal.reported_db_spl).abs() < 1e-3);
let peak = cal.peak_level_for_dbspl(cal.reported_db_spl);
assert!((peak - cal.peak_sample_level).abs() < 1e-5);
assert_eq!(cal.peak_level_for_dbspl(-1000.0), 0.0);
}
#[test]
fn recording_configuration_accepts_gd_v2_fields() {
let cfg_json = serde_json::json!({
"bass_octave_duration_s": 3.0,
"pre_silence_s": 2.0,
"post_silence_s": 4.0,
"sweep_level_db_spl": 85.0,
"num_sweeps": 4,
"coherence_threshold": 0.9,
"bass_probe_freq_hz": 30.0,
"bass_probe_duration_s": 2.0,
"mic_phase_calibration_path": "/tmp/mic_phase.csv",
"spl_calibration": {
"reported_db_spl": 85.0,
"reference_freq_hz": 1000.0,
"peak_sample_level": 0.5,
"spl_offset_db": 91.02
},
"recording_seed": 42
});
let cfg: RecordingConfiguration = serde_json::from_value(cfg_json).unwrap();
assert_eq!(cfg.bass_octave_duration_s, Some(3.0));
assert_eq!(cfg.num_sweeps, Some(4));
assert_eq!(cfg.coherence_threshold, Some(0.9));
assert_eq!(cfg.bass_probe_freq_hz, Some(30.0));
assert_eq!(cfg.bass_probe_duration_s, Some(2.0));
assert_eq!(
cfg.mic_phase_calibration_path.as_deref(),
Some("/tmp/mic_phase.csv")
);
let cal = cfg.spl_calibration.expect("spl_calibration populated");
assert!((cal.reported_db_spl - 85.0).abs() < 1e-6);
assert_eq!(cfg.recording_seed, Some(42));
}
#[test]
fn recording_configuration_legacy_json_still_loads() {
let legacy_json = serde_json::json!({
"signal_type": "Sweep",
"signal_duration_secs": 10.0,
"sweep_start_freq": 20.0,
"sweep_end_freq": 20000.0
});
let cfg: RecordingConfiguration = serde_json::from_value(legacy_json).unwrap();
assert!(cfg.bass_octave_duration_s.is_none());
assert!(cfg.num_sweeps.is_none());
assert!(cfg.coherence_threshold.is_none());
assert!(cfg.bass_probe_freq_hz.is_none());
assert!(cfg.bass_probe_duration_s.is_none());
assert!(cfg.mic_phase_calibration_path.is_none());
assert!(cfg.mic_phase_calibration_paths.is_none());
assert!(cfg.spl_calibration.is_none());
assert!(cfg.recording_seed.is_none());
}
#[test]
fn bass_anchor_results_legacy_migrates_v1_bass_cycles_to_duration() {
let legacy = serde_json::json!({
"channels": [],
"sample_rate": 48_000_u32,
"bass_freq_hz": 30.0_f32,
"bass_cycles": 6_u16,
});
let r: BassAnchorResultsLegacy = serde_json::from_value(legacy).unwrap();
assert!(
(r.bass_duration_s - 0.2).abs() < 1e-6,
"expected 0.2 s migrated from 6 cycles @ 30 Hz, got {}",
r.bass_duration_s
);
assert_eq!(r.sample_rate, 48_000);
assert_eq!(r.bass_freq_hz, 30.0);
}
#[test]
fn bass_anchor_results_prefers_explicit_duration_when_both_present() {
let mixed = serde_json::json!({
"channels": [],
"sample_rate": 48_000_u32,
"bass_freq_hz": 30.0_f32,
"bass_cycles": 6_u16,
"bass_duration_s": 2.5_f32,
});
let r: BassAnchorResultsLegacy = serde_json::from_value(mixed).unwrap();
assert!((r.bass_duration_s - 2.5).abs() < 1e-6);
}
#[test]
fn bass_anchor_results_v2_round_trips() {
let v2 = serde_json::json!({
"channels": [],
"sample_rate": 48_000_u32,
"bass_freq_hz": 30.0_f32,
"bass_duration_s": 2.0_f32,
});
let r: BassAnchorResultsLegacy = serde_json::from_value(v2).unwrap();
assert_eq!(r.bass_duration_s, 2.0);
}
#[test]
fn target_shape_canonical_wire_format() {
let cases = [
(TargetShape::Flat, "\"flat\""),
(TargetShape::Harman, "\"harman\""),
(TargetShape::Custom, "\"custom\""),
(TargetShape::File, "\"file\""),
(TargetShape::FromMeasurement, "\"from_measurement\""),
];
for (variant, expected) in cases {
let serialized = serde_json::to_string(&variant).unwrap();
assert_eq!(serialized, expected, "serialize {variant:?}");
let round_tripped: TargetShape = serde_json::from_str(&serialized).unwrap();
assert_eq!(round_tripped, variant, "round-trip {variant:?}");
}
assert!(serde_json::from_str::<TargetShape>("\"frommeasurement\"").is_err());
}
#[test]
fn test_optimizer_config_default_matches_omitted_decomposed_correction() {
let config = OptimizerConfig::default();
let deserialized: OptimizerConfig = serde_json::from_value(serde_json::json!({})).unwrap();
assert!(config.decomposed_correction.is_none());
assert!(deserialized.decomposed_correction.is_none());
}
#[test]
fn test_optimizer_config_default_algorithm_is_cmaes() {
let config = OptimizerConfig::default();
assert_eq!(config.algorithm, "autoeq:cmaes");
}
#[test]
fn test_optimizer_config_resolves_new_acoustic_defaults() {
let config = OptimizerConfig::default();
assert_eq!(
config.psychoacoustic_smoothing_config(),
PsychoacousticSmoothingConfig::default()
);
assert_eq!(
config.asymmetric_loss_config(),
AsymmetricLossConfig::default()
);
let custom_smoothing = PsychoacousticSmoothingConfig {
low_freq_n: 24,
high_freq_n: 3,
low_freq: 80.0,
high_freq: 800.0,
};
let custom_asym = AsymmetricLossConfig {
peak_weight: 3.0,
dip_weight: 0.5,
bass_peak_weight: 6.0,
bass_dip_weight: 0.25,
transition_freq: 180.0,
};
let config = OptimizerConfig {
psychoacoustic_smoothing: Some(custom_smoothing),
asymmetric_loss_config: Some(custom_asym),
..Default::default()
};
assert_eq!(config.psychoacoustic_smoothing_config(), custom_smoothing);
assert_eq!(config.asymmetric_loss_config(), custom_asym);
}
#[test]
fn perceptual_policy_preserves_legacy_defaults_when_absent() {
let mut config = OptimizerConfig::default();
config.apply_perceptual_policy_defaults();
assert!(config.perceptual_policy.is_none());
assert!(config.audibility_deadband.is_none());
assert!(config.high_frequency_correction.is_none());
assert!(config.early_late_correction.is_none());
assert!(config.validation_bundle.is_none());
assert_eq!(config.loss_type, "flat");
assert_eq!(config.max_freq, default_max_freq());
}
#[test]
fn music_policy_fills_perceptual_defaults() {
let mut config = OptimizerConfig {
perceptual_policy: Some(PerceptualPolicyConfig {
preset: PerceptualPolicyPreset::Music,
..Default::default()
}),
..Default::default()
};
config.apply_perceptual_policy_defaults();
assert_eq!(config.loss_type, "epa");
assert_eq!(
config.target_response.as_ref().unwrap().shape,
TargetShape::Harman
);
assert!(config.audibility_deadband_config().is_some());
assert!(config.high_frequency_correction.is_some());
assert!(config.early_late_correction_config().is_some());
assert!(config.validation_bundle_config().is_some());
assert_eq!(
config.multi_measurement.as_ref().unwrap().strategy,
MultiMeasurementStrategy::SpatialRobustness
);
}
#[test]
fn high_frequency_guard_caps_default_q_but_preserves_explicit_q() {
let mut default_q = OptimizerConfig {
max_freq: 8_000.0,
high_frequency_correction: Some(HighFrequencyCorrectionConfig::default()),
..Default::default()
};
default_q.apply_high_frequency_correction_defaults(false);
assert_eq!(default_q.max_q, default_high_freq_guard_max_q());
assert_eq!(
default_q.psychoacoustic_smoothing.unwrap().high_freq_n,
default_high_freq_smoothing_n()
);
let mut explicit_q = OptimizerConfig {
max_freq: 8_000.0,
max_q: 4.5,
high_frequency_correction: Some(HighFrequencyCorrectionConfig::default()),
..Default::default()
};
explicit_q.apply_high_frequency_correction_defaults(false);
assert_eq!(explicit_q.max_q, 4.5);
explicit_q.apply_high_frequency_correction_defaults(true);
assert_eq!(explicit_q.max_q, default_high_freq_guard_max_q());
}
#[test]
fn perceptual_policy_tightens_generated_high_frequency_smoothing() {
let mut config = OptimizerConfig {
max_freq: 8_000.0,
perceptual_policy: Some(PerceptualPolicyConfig {
preset: PerceptualPolicyPreset::Music,
..Default::default()
}),
..Default::default()
};
config.apply_perceptual_policy_defaults();
let smoothing = config.psychoacoustic_smoothing.unwrap();
assert_eq!(
smoothing.high_freq_n,
policy_high_frequency_guard(PerceptualPolicyPreset::Music).smoothing_n
);
assert!(smoothing.high_freq <= default_high_freq_guard_start_hz());
}
#[test]
fn high_frequency_smoothing_guard_preserves_valid_transition_order() {
let mut config = OptimizerConfig {
max_freq: 8_000.0,
psychoacoustic_smoothing: Some(PsychoacousticSmoothingConfig {
low_freq_n: 48,
high_freq_n: 6,
low_freq: 1_000.0,
high_freq: 2_000.0,
}),
high_frequency_correction: Some(HighFrequencyCorrectionConfig {
start_hz: 500.0,
..Default::default()
}),
..Default::default()
};
config.apply_high_frequency_correction_defaults(true);
let smoothing = config.psychoacoustic_smoothing.unwrap();
assert!(smoothing.low_freq > 0.0);
assert!(smoothing.low_freq < smoothing.high_freq);
assert_eq!(smoothing.high_freq, 500.0);
}
#[test]
fn test_decomposed_correction_serde_config_default() {
let dc = DecomposedCorrectionSerdeConfig::default();
assert!(dc.enabled);
assert_eq!(dc.schroeder_freq, 300.0);
assert_eq!(dc.steady_state_weight, 0.4);
assert_eq!(dc.min_mode_q, 3.0);
assert_eq!(dc.min_mode_prominence_db, 3.0);
assert_eq!(dc.mode_correction_weight, 1.0);
assert_eq!(dc.early_reflection_weight, 0.3);
assert!(dc.fdw_enabled);
assert_eq!(dc.fdw_cycles, 8.0);
assert_eq!(dc.fdw_min_window_ms, 3.0);
assert_eq!(dc.fdw_max_window_ms, 500.0);
assert_eq!(dc.fdw_smoothing_octaves, 1.0 / 24.0);
}
#[test]
fn test_channel_matching_config_defaults() {
let cfg = ChannelMatchingConfig::default();
assert!(cfg.enabled);
assert_eq!(cfg.threshold_db, 0.75);
assert_eq!(cfg.max_filters, 5);
}
#[test]
fn test_max_boost_envelope_interpolation() {
let mut config = OptimizerConfig::default();
assert_eq!(config.max_boost_at_freq(100.0), config.max_db);
config.max_boost_envelope = Some(vec![
(20.0, 6.0),
(200.0, 4.0),
(1000.0, 2.0),
(8000.0, 0.0),
]);
assert!((config.max_boost_at_freq(20.0) - 6.0).abs() < 1e-10);
assert!((config.max_boost_at_freq(200.0) - 4.0).abs() < 1e-10);
assert!((config.max_boost_at_freq(1000.0) - 2.0).abs() < 1e-10);
assert!((config.max_boost_at_freq(8000.0) - 0.0).abs() < 1e-10);
assert!((config.max_boost_at_freq(10.0) - 6.0).abs() < 1e-10);
assert!((config.max_boost_at_freq(16000.0) - 0.0).abs() < 1e-10);
let mid_freq = (200.0_f64 * 1000.0).sqrt();
let mid_boost = config.max_boost_at_freq(mid_freq);
assert!(
(mid_boost - 3.0).abs() < 1e-6,
"geometric midpoint should give 3.0 dB, got {:.6}",
mid_boost
);
}
#[test]
fn config_types_default_roundtrip() {
use super::*;
let _ = AreaPriorKind::default();
let _ = AreaQuadratureKind::default();
let _ = AreaScalarisationKind::default();
let _ = BootstrapScalarisation::default();
let _ = CtcConfig::default();
let _ = CtcRegularizationConfig::default();
let _ = CtcWindowConfig::default();
let _ = MixedModeConfig::default();
let _ = SubOptimizerConfig::default();
let _ = serde_json::to_string(&CtcConfig::default()).unwrap();
let _ = serde_json::to_string(&MixedModeConfig::default()).unwrap();
let _ = serde_json::to_string(&SubOptimizerConfig::default()).unwrap();
let quad = AreaQuadratureKind::Sobol {
num_points: 16,
seed: 42,
};
let json = serde_json::to_string(&quad).unwrap();
let back: AreaQuadratureKind = serde_json::from_str(&json).unwrap();
assert_eq!(back, quad);
}
#[test]
fn enabled_phase_alignment_allows_delay_in_low_latency_mode_unless_overridden() {
use super::*;
let mut config = OptimizerConfig::default();
assert!(!config.allow_delay());
config.phase_alignment = Some(PhaseAlignmentConfig::default());
assert!(config.allow_delay());
config.allow_delay = Some(false);
assert!(!config.allow_delay());
}