use super::misc::collect_sources;
use super::misc::is_valid_speaker_name;
use super::misc::source_is_cea2034_shaped;
use super::optimizer_rules::run_optimizer_validation_rules;
use super::validation_result::{ValidationContext, ValidationResult};
use crate::MeasurementSource;
use crate::config::{
AreaPriorKind, AreaQuadratureKind, AreaScalarisationKind, BootstrapScalarisation,
MultiMeasurementStrategy, MultiSeatStrategy, OptimizerConfig, RoomConfig, SpeakerConfig,
TargetShape,
};
use std::collections::HashMap;
use std::path::{Path, PathBuf};
#[derive(Debug, Clone, Default)]
pub struct RoomValidationContext {
production: bool,
export_target: Option<PathBuf>,
}
impl RoomValidationContext {
pub fn structural() -> Self {
Self::default()
}
pub fn production() -> Self {
Self {
production: true,
export_target: None,
}
}
#[allow(dead_code)]
pub fn for_export(target: impl Into<PathBuf>) -> Self {
Self {
production: true,
export_target: Some(target.into()),
}
}
}
pub fn validate_room_config(config: &RoomConfig) -> ValidationResult {
let report = validate_room_config_staged(config, RoomValidationContext::structural());
let errors = report.errors().cloned().collect::<Vec<_>>();
let warnings = report.warnings().cloned().collect::<Vec<_>>();
ValidationResult {
is_valid: errors.is_empty(),
errors,
warnings,
staged_report: Some(report),
}
}
pub fn validate_room_config_staged(
config: &RoomConfig,
context: RoomValidationContext,
) -> crate::config::ConfigValidationReport {
use crate::config::ValidationStage;
let mut report = config.validation_report();
let structural = validate_room_config_rules(config);
let mut structural_errors = report.stage(ValidationStage::Structural).errors.clone();
structural_errors.extend(structural.errors);
structural_errors.sort();
structural_errors.dedup();
report.record(
ValidationStage::Structural,
structural_errors,
structural.warnings,
);
if !context.production {
return report;
}
report.record(
ValidationStage::ResolvedResource,
validate_resolved_resources(config),
Vec::new(),
);
let acoustic_errors = validate_acoustic_inputs(config);
if !acoustic_errors.is_empty() || !acoustic_inputs_require_loading(config) {
report.record(ValidationStage::Acoustic, acoustic_errors, Vec::new());
}
if let Some(target) = context.export_target.as_deref() {
report.record(
ValidationStage::ExportTarget,
validate_export_target(target),
Vec::new(),
);
} else {
report.mark_not_applicable(ValidationStage::ExportTarget);
}
report
}
fn validate_room_config_rules(config: &RoomConfig) -> ValidationResult {
let mut result = ValidationResult::valid();
validate_optimizer_config(&config.optimizer, &mut result);
if config.target_curve.is_some()
&& let Some(ref tr) = config.optimizer.target_response
{
let has_shape = tr.shape != TargetShape::Flat
|| tr.preference.bass_shelf_db.abs() > 1e-6
|| tr.preference.treble_shelf_db.abs() > 1e-6
|| tr.broadband_precorrection;
if has_shape {
result.add_warning(
"Both target_curve and target_response are configured. \
target_response takes precedence — it is baked into the \
measurement before EQ optimization, and target_curve is \
ignored to avoid double-application. Set only one."
.to_string(),
);
}
}
validate_speakers(&config.speakers, &mut result);
validate_crossovers(&config.speakers, config.crossovers.as_ref(), &mut result);
validate_cross_option_interactions(config, &mut result);
result
}
fn validate_resolved_resources(config: &RoomConfig) -> Vec<String> {
let mut errors = Vec::new();
for (speaker_name, speaker) in &config.speakers {
for source in collect_sources(speaker) {
for path in measurement_paths(source) {
if path.is_relative() {
errors.push(format!(
"speaker '{speaker_name}' measurement path was not resolved: {}",
path.display()
));
} else if !path.is_file() {
errors.push(format!(
"speaker '{speaker_name}' measurement resource does not exist: {}",
path.display()
));
}
}
}
}
if let Some(crate::config::TargetCurveConfig::Path(path)) = &config.target_curve {
if path.is_relative() {
errors.push(format!(
"target curve path was not resolved: {}",
path.display()
));
} else if !path.is_file() {
errors.push(format!(
"target curve resource does not exist: {}",
path.display()
));
}
}
errors
}
fn measurement_paths(source: &MeasurementSource) -> Vec<PathBuf> {
match source {
MeasurementSource::Single(single) => {
measurement_path(&single.measurement).into_iter().collect()
}
MeasurementSource::Multiple(multiple) => multiple
.measurements
.iter()
.filter_map(measurement_path)
.collect(),
MeasurementSource::InMemory(_) | MeasurementSource::InMemoryMultiple(_) => Vec::new(),
}
}
fn measurement_path(measurement: &crate::MeasurementRef) -> Option<PathBuf> {
match measurement {
crate::MeasurementRef::Path(path) | crate::MeasurementRef::Named { path, .. } => {
Some(path.clone())
}
crate::MeasurementRef::Inline(inline)
if inline.frequencies.is_empty() || inline.magnitude_db.is_empty() =>
{
inline
.csv_path
.as_deref()
.filter(|path| !path.trim().is_empty())
.map(PathBuf::from)
}
crate::MeasurementRef::Inline(_) => None,
}
}
fn acoustic_inputs_require_loading(config: &RoomConfig) -> bool {
config.speakers.values().any(|speaker| {
collect_sources(speaker)
.into_iter()
.any(source_requires_acoustic_loading)
})
}
fn source_requires_acoustic_loading(source: &MeasurementSource) -> bool {
match source {
MeasurementSource::Single(single) => measurement_path(&single.measurement).is_some(),
MeasurementSource::Multiple(multiple) => multiple
.measurements
.iter()
.any(|measurement| measurement_path(measurement).is_some()),
MeasurementSource::InMemory(_) | MeasurementSource::InMemoryMultiple(_) => false,
}
}
fn validate_acoustic_inputs(config: &RoomConfig) -> Vec<String> {
let mut errors = Vec::new();
for (speaker_name, speaker) in &config.speakers {
for (source_index, source) in collect_sources(speaker).into_iter().enumerate() {
let curves: Vec<&crate::Curve> = match source {
MeasurementSource::InMemory(curve) => vec![curve],
MeasurementSource::InMemoryMultiple(curves) => curves.iter().collect(),
MeasurementSource::Single(single) => match &single.measurement {
crate::MeasurementRef::Inline(inline) => {
validate_inline_measurement(
inline,
speaker_name,
source_index,
&mut errors,
);
Vec::new()
}
_ => Vec::new(),
},
MeasurementSource::Multiple(multiple) => {
for measurement in &multiple.measurements {
if let crate::MeasurementRef::Inline(inline) = measurement {
validate_inline_measurement(
inline,
speaker_name,
source_index,
&mut errors,
);
}
}
Vec::new()
}
};
if matches!(source, MeasurementSource::InMemoryMultiple(curves) if curves.is_empty()) {
errors.push(format!(
"speaker '{speaker_name}' source {source_index} produced no measurement curves"
));
}
for curve in curves {
if curve.freq.is_empty() || curve.freq.len() != curve.spl.len() {
errors.push(format!(
"speaker '{speaker_name}' source {source_index} has invalid in-memory frequency/SPL data"
));
}
}
}
}
errors
}
fn validate_inline_measurement(
inline: &crate::InlineMeasurement,
speaker_name: &str,
source_index: usize,
errors: &mut Vec<String>,
) {
let uses_csv_fallback = (inline.frequencies.is_empty() || inline.magnitude_db.is_empty())
&& inline
.csv_path
.as_deref()
.is_some_and(|path| !path.trim().is_empty());
if !uses_csv_fallback
&& (inline.frequencies.is_empty() || inline.frequencies.len() != inline.magnitude_db.len())
{
errors.push(format!(
"speaker '{speaker_name}' source {source_index} has invalid inline frequency/SPL data"
));
}
if !uses_csv_fallback
&& inline
.phase_deg
.as_ref()
.is_some_and(|phase| phase.len() != inline.frequencies.len())
{
errors.push(format!(
"speaker '{speaker_name}' source {source_index} has inline phase data with the wrong length"
));
}
}
fn validate_export_target(target: &Path) -> Vec<String> {
let mut errors = Vec::new();
if target.as_os_str().is_empty() {
errors.push("export target must not be empty".to_string());
return errors;
}
if target.is_dir() {
errors.push(format!(
"export target must be a file, not a directory: {}",
target.display()
));
}
let parent = target
.parent()
.filter(|path| !path.as_os_str().is_empty())
.unwrap_or_else(|| Path::new("."));
if !parent.is_dir() {
errors.push(format!(
"export target parent directory does not exist: {}",
parent.display()
));
}
errors
}
fn validate_optimizer_config(opt: &OptimizerConfig, result: &mut ValidationResult) {
let mut ctx = ValidationContext::new(opt, result);
run_optimizer_validation_rules(&mut ctx);
validate_channel_alignment_config(opt, result);
}
fn validate_channel_alignment_config(opt: &OptimizerConfig, result: &mut ValidationResult) {
if let Some(config) = &opt.inter_channel_timbre_matching {
let path = "optimizer.inter_channel_timbre_matching";
if config.enabled && config.reference_channel.trim().is_empty() {
result.add_error(format!(
"{path}.reference_channel must not be empty when enabled"
));
}
if !config.min_improvement_db.is_finite() || config.min_improvement_db < 0.0 {
result.add_error(format!(
"{path}.min_improvement_db must be finite and non-negative"
));
}
}
if let Some(config) = &opt.height_channel_alignment {
if !config.min_timbre_improvement_db.is_finite() || config.min_timbre_improvement_db < 0.0 {
result.add_error(
"optimizer.height_channel_alignment.min_timbre_improvement_db must be finite and non-negative"
.to_string(),
);
}
if !config.max_delay_ms.is_finite() || config.max_delay_ms <= 0.0 {
result.add_error(
"optimizer.height_channel_alignment.max_delay_ms must be finite and positive"
.to_string(),
);
}
if config.enabled
&& !(config.match_timbre || config.match_level || config.match_arrival_time)
{
result.add_error(
"optimizer.height_channel_alignment requires at least one actionable timbre, level, or arrival-time objective"
.to_string(),
);
}
for (role, reference) in &config.reference_channels {
if role.trim().is_empty() || reference.trim().is_empty() {
result.add_error(
"optimizer.height_channel_alignment.reference_channels keys and values must not be empty"
.to_string(),
);
break;
}
}
}
}
fn validate_speakers(speakers: &HashMap<String, SpeakerConfig>, result: &mut ValidationResult) {
if speakers.is_empty() {
result.add_error("No speakers configured".to_string());
return;
}
for (name, config) in speakers {
if let Some(speaker_name) = config.speaker_name()
&& !is_valid_speaker_name(speaker_name)
{
result.add_error(format!(
"Speaker '{}' has invalid speaker_name '{}'. Only alphanumeric, spaces, and hyphens allowed.",
name, speaker_name
));
}
match config {
SpeakerConfig::Topology(topology) => {
if let Err(message) = topology.validate() {
result.add_error(format!("Speaker topology '{}': {message}", name));
}
let band_count = topology
.acoustic_bands()
.map(|bands| bands.len())
.unwrap_or_default();
if topology.crossover.is_none() && band_count > 1 {
result.add_error(format!(
"Speaker topology '{}' has multiple acoustic bands but no crossover specified",
name
));
}
}
SpeakerConfig::Group(group) => {
result.add_warning(format!(
"Speaker group '{}' uses deprecated measurements input; migrate to explicit drivers topology",
name
));
if group.measurements.is_empty() {
result.add_error(format!("Speaker group '{}' has no measurements", name));
}
if group.measurements.len() == 1 {
result.add_warning(format!(
"Speaker group '{}' has only 1 measurement, consider using Single config",
name
));
}
if group.crossover.is_none() && group.measurements.len() > 1 {
result.add_error(format!(
"Speaker group '{}' has multiple drivers but no crossover specified",
name
));
}
}
SpeakerConfig::MultiSub(ms) => {
if ms.subwoofers.is_empty() {
result.add_error(format!("Multi-sub '{}' has no subwoofers", name));
}
if ms.subwoofers.len() == 1 {
result.add_warning(format!(
"Multi-sub '{}' has only 1 subwoofer, consider using Single config",
name
));
}
}
SpeakerConfig::Dba(dba) => {
if dba.front.is_empty() {
result.add_error(format!("DBA '{}' has no front speakers", name));
}
if dba.rear.is_empty() {
result.add_error(format!("DBA '{}' has no rear speakers", name));
}
}
SpeakerConfig::Cardioid(cardioid) => {
if cardioid.separation_meters <= 0.0 {
result.add_error(format!(
"Cardioid '{}' has invalid separation {:.2}m (must be > 0)",
name, cardioid.separation_meters
));
}
}
SpeakerConfig::SupportingSource(s) => {
if s.primary.speaker_name().is_some()
&& s.support.speaker_name().is_some()
&& s.primary.speaker_name() == s.support.speaker_name()
{
result.add_warning(format!(
"Supporting source '{}' uses the same speaker_name for primary and support",
name
));
}
let cfg = &s.supporting_source;
if !(1.0..=50.0).contains(&cfg.delay_ms) {
result.add_error(format!(
"Supporting source '{}' delay_ms must be in [1.0, 50.0], got {:.2}",
name, cfg.delay_ms
));
}
if cfg.fir_taps == 0 || cfg.fir_taps > 65536 || cfg.fir_taps % 2 != 0 {
result.add_error(format!(
"Supporting source '{}' fir_taps must be even and in [2, 65536], got {}",
name, cfg.fir_taps
));
}
if cfg.velvet_noise_taps >= cfg.fir_taps {
result.add_warning(format!(
"Supporting source '{}' velvet_noise_taps ({}) should be < fir_taps ({})",
name, cfg.velvet_noise_taps, cfg.fir_taps
));
}
if cfg.freq_range_hz.0 >= cfg.freq_range_hz.1 {
result.add_error(format!(
"Supporting source '{}' freq_range_hz must satisfy low < high, got {:?}",
name, cfg.freq_range_hz
));
}
for (i, band) in cfg.precedence_limits.iter().enumerate() {
if band.low_hz >= band.high_hz {
result.add_error(format!(
"Supporting source '{}' precedence_limits[{}]: low_hz must be < high_hz",
name, i
));
}
if band.limit_db <= 0.0 {
result.add_warning(format!(
"Supporting source '{}' precedence_limits[{}]: limit_db <= 0 dB will prevent compensation",
name, i
));
}
}
}
SpeakerConfig::Single(_) => {
}
}
}
}
fn validate_crossovers(
speakers: &HashMap<String, SpeakerConfig>,
crossovers: Option<&HashMap<String, crate::config::CrossoverConfig>>,
result: &mut ValidationResult,
) {
for (name, config) in speakers {
let (crossover_ref, num_drivers) = match config {
SpeakerConfig::Group(group) => {
let Some(crossover_ref) = group.crossover.as_ref() else {
continue;
};
(crossover_ref, group.measurements.len())
}
SpeakerConfig::Topology(topology) => {
let Some(crossover_ref) = topology.crossover.as_ref() else {
continue;
};
let band_count = topology
.acoustic_bands()
.map(|bands| bands.len())
.unwrap_or_default();
(crossover_ref, band_count)
}
_ => continue,
};
let Some(crossovers) = crossovers else {
result.add_error(format!(
"Speaker '{}' references crossover '{}' but no crossovers defined",
name, crossover_ref
));
continue;
};
if !crossovers.contains_key(crossover_ref) {
result.add_error(format!(
"Speaker '{}' references non-existent crossover '{}'",
name, crossover_ref
));
continue;
}
let crossover = &crossovers[crossover_ref];
let expected_freqs = num_drivers.saturating_sub(1);
let has_single = crossover.frequency.is_some();
let has_multiple = crossover.frequencies.is_some();
let has_range = crossover.frequency_range.is_some();
if has_single && num_drivers != 2 {
result.add_warning(format!(
"Crossover '{}' has single frequency but speaker '{}' has {} drivers",
crossover_ref, name, num_drivers
));
}
if has_multiple
&& let Some(ref freqs) = crossover.frequencies
&& freqs.len() != expected_freqs
{
result.add_error(format!(
"Crossover '{}' has {} frequencies but speaker '{}' needs {} for {} drivers",
crossover_ref,
freqs.len(),
name,
expected_freqs,
num_drivers
));
}
if !has_single && !has_multiple && !has_range {
result.add_warning(format!(
"Crossover '{}' has no frequency specified, will be auto-optimized",
crossover_ref
));
}
}
}
fn validate_cross_option_interactions(config: &RoomConfig, result: &mut ValidationResult) {
validate_multi_measurement_weights(config, result);
validate_bootstrap_uncertainty(config, result);
validate_continuous_listening_area(config, result);
validate_cea2034_source_plausibility(config, result);
validate_bass_management(config, result);
validate_role_targets(config, result);
}
fn validate_bootstrap_uncertainty(config: &RoomConfig, result: &mut ValidationResult) {
let Some(mm) = config.optimizer.multi_measurement.as_ref() else {
return;
};
if !matches!(
mm.strategy,
MultiMeasurementStrategy::MinimaxUncertainty | MultiMeasurementStrategy::SpatialRobustness
) {
return;
}
if let Some(b) = mm.bootstrap_uncertainty.as_ref() {
if let Some(value) = b.effective_spatial_sample_size
&& (!value.is_finite() || value <= 0.0)
{
result.add_error(format!(
"multi_measurement.bootstrap_uncertainty.effective_spatial_sample_size must be finite and positive, got {value}"
));
}
for (name, value) in [
("repeat_sweep_noise_std_db", b.repeat_sweep_noise_std_db),
(
"calibration_uncertainty_std_db",
b.calibration_uncertainty_std_db,
),
] {
if let Some(value) = value
&& (!value.is_finite() || value < 0.0)
{
result.add_error(format!(
"multi_measurement.bootstrap_uncertainty.{name} must be finite and nonnegative, got {value}"
));
}
}
if b.num_resamples == 0 {
result.add_error(
"multi_measurement.bootstrap_uncertainty.num_resamples must be > 0".to_string(),
);
}
if !(0.0..1.0).contains(&b.alpha) || b.alpha <= 0.0 {
result.add_error(format!(
"multi_measurement.bootstrap_uncertainty.alpha must be in (0, 1), got {}",
b.alpha
));
}
if matches!(b.scalarisation, BootstrapScalarisation::Cvar)
&& (!(0.0..=1.0).contains(&b.cvar_alpha) || b.cvar_alpha <= 0.0)
{
result.add_error(format!(
"multi_measurement.bootstrap_uncertainty.cvar_alpha must be in (0, 1] when \
scalarisation = cvar, got {}",
b.cvar_alpha
));
}
}
}
fn validate_continuous_listening_area(config: &RoomConfig, result: &mut ValidationResult) {
let Some(ms) = config.optimizer.multi_seat.as_ref() else {
return;
};
if ms.strategy != MultiSeatStrategy::ContinuousArea {
return;
}
let Some(area) = ms.continuous_area.as_ref() else {
result.add_error(
"multi_seat.strategy = continuous_area requires multi_seat.continuous_area to be set"
.to_string(),
);
return;
};
if !(1..=3).contains(&area.dimensions) {
result.add_error(format!(
"multi_seat.continuous_area.dimensions must be 1, 2, or 3 (got {})",
area.dimensions
));
}
if area.bounds.len() != area.dimensions {
result.add_error(format!(
"multi_seat.continuous_area.bounds length {} must equal dimensions {}",
area.bounds.len(),
area.dimensions
));
}
for (i, (lo, hi)) in area.bounds.iter().enumerate() {
if !(lo.is_finite() && hi.is_finite()) || hi <= lo {
result.add_error(format!(
"multi_seat.continuous_area.bounds[{}] = ({}, {}) is degenerate",
i, lo, hi
));
}
}
if area.seat_positions.is_empty() {
result.add_error(
"multi_seat.continuous_area.seat_positions must contain at least one position"
.to_string(),
);
} else {
for (i, row) in area.seat_positions.iter().enumerate() {
if row.len() != area.dimensions {
result.add_error(format!(
"multi_seat.continuous_area.seat_positions[{}] has length {} (expected {})",
i,
row.len(),
area.dimensions
));
}
}
}
if !area.idw_power.is_finite() || area.idw_power <= 0.0 {
result.add_error(format!(
"multi_seat.continuous_area.idw_power must be > 0, got {}",
area.idw_power
));
}
match &area.prior {
AreaPriorKind::Uniform => {}
AreaPriorKind::Gaussian {
mean,
cov_diag,
truncation_sigmas,
} => {
if mean.len() != area.dimensions {
result.add_error(format!(
"multi_seat.continuous_area.prior.gaussian.mean length {} must equal dimensions {}",
mean.len(),
area.dimensions
));
}
if cov_diag.len() != area.dimensions {
result.add_error(format!(
"multi_seat.continuous_area.prior.gaussian.cov_diag length {} must equal dimensions {}",
cov_diag.len(),
area.dimensions
));
}
for (i, &v) in cov_diag.iter().enumerate() {
if !v.is_finite() || v <= 0.0 {
result.add_error(format!(
"multi_seat.continuous_area.prior.gaussian.cov_diag[{}] must be > 0, got {}",
i, v
));
}
}
if !truncation_sigmas.is_finite() || *truncation_sigmas <= 0.0 {
result.add_error(format!(
"multi_seat.continuous_area.prior.gaussian.truncation_sigmas must be > 0, got {}",
truncation_sigmas
));
}
}
}
match &area.quadrature {
AreaQuadratureKind::Sobol { num_points, .. }
| AreaQuadratureKind::LatinHypercube { num_points, .. } => {
if *num_points == 0 {
result.add_error(
"multi_seat.continuous_area.quadrature.num_points must be > 0".to_string(),
);
}
}
AreaQuadratureKind::GaussLegendre { points_per_axis } => {
if *points_per_axis == 0 {
result.add_error(
"multi_seat.continuous_area.quadrature.points_per_axis must be > 0".to_string(),
);
}
}
}
match &area.scalarisation {
AreaScalarisationKind::ExpectedValue => {}
AreaScalarisationKind::WorstCase { inner_maxiter, .. } => {
if *inner_maxiter == 0 {
result.add_error(
"multi_seat.continuous_area.scalarisation.worst_case.inner_maxiter must be > 0"
.to_string(),
);
}
}
AreaScalarisationKind::Cvar { alpha } => {
if !(0.0..=1.0).contains(alpha) || *alpha <= 0.0 {
result.add_error(format!(
"multi_seat.continuous_area.scalarisation.cvar.alpha must be in (0, 1], got {}",
alpha
));
}
}
}
}
fn validate_multi_measurement_weights(config: &RoomConfig, result: &mut ValidationResult) {
let Some(mm) = config.optimizer.multi_measurement.as_ref() else {
return;
};
if !mm.variance_lambda.is_finite() || mm.variance_lambda < 0.0 {
result.add_error(format!(
"multi_measurement.variance_lambda must be finite and nonnegative, got {}",
mm.variance_lambda
));
}
let Some(weights) = mm.weights.as_ref() else {
return;
};
for (index, weight) in weights.iter().enumerate() {
if !weight.is_finite() || *weight < 0.0 {
result.add_error(format!(
"multi_measurement.weights[{index}] must be finite and nonnegative, got {weight}"
));
}
}
let weight_sum: f64 = weights.iter().sum();
if !weight_sum.is_finite() || weight_sum <= 0.0 {
result.add_error(format!(
"multi_measurement.weights must have a finite, strictly positive total, got {weight_sum}"
));
}
for (channel, speaker) in &config.speakers {
for source in collect_sources(speaker) {
let count = match source {
MeasurementSource::Multiple(m) => m.measurements.len(),
MeasurementSource::InMemoryMultiple(curves) => curves.len(),
_ => continue,
};
if count != weights.len() {
result.add_error(format!(
"Channel '{}': multi_measurement.weights has {} entries but the channel \
has {} measurements. The lengths must match; `optimize_channel_eq_multi` \
would otherwise index out of bounds.",
channel,
weights.len(),
count,
));
}
}
}
}
fn validate_cea2034_source_plausibility(config: &RoomConfig, result: &mut ValidationResult) {
let enabled = config
.optimizer
.cea2034_correction
.as_ref()
.is_some_and(|c| c.enabled);
if !enabled {
return;
}
let any_plausible = config
.speakers
.values()
.flat_map(collect_sources)
.any(source_is_cea2034_shaped);
if !any_plausible {
result.add_warning(
"cea2034_correction is enabled but no speaker looks like a CEA2034/spinorama \
source (no speaker_name set, no path/name hint of 'cea2034' or 'spinorama'). \
The 3-pass correction pipeline assumes spinorama-shaped data; applying it to \
plain in-room responses will produce incorrect results. \
Either disable cea2034_correction or provide a speaker_name so the pipeline \
can fetch the matching spinorama data."
.to_string(),
);
}
}
fn validate_bass_management(config: &RoomConfig, result: &mut ValidationResult) {
let Some(system) = config.system.as_ref() else {
return;
};
let Some(bm) = system.bass_management.as_ref() else {
return;
};
if !bm.enabled {
return;
}
if system.subwoofers.is_none() {
result.add_warning(
"bass_management is enabled but system.subwoofers is missing; bass management \
will be reported as unavailable."
.to_string(),
);
}
if bm.lfe_playback_gain_db.abs() > 24.0 {
result.add_error(format!(
"bass_management.lfe_playback_gain_db ({}) is outside the safe +/-24 dB range",
bm.lfe_playback_gain_db
));
}
if !bm.lfe_low_pass_hz.is_finite() || !(20.0..=250.0).contains(&bm.lfe_low_pass_hz) {
result.add_error(format!(
"bass_management.lfe_low_pass_hz ({}) must be finite and within 20..=250 Hz",
bm.lfe_low_pass_hz
));
}
if bm.max_sub_boost_db < 0.0 {
result.add_error(format!(
"bass_management.max_sub_boost_db ({}) must be non-negative",
bm.max_sub_boost_db
));
}
if bm.headroom_margin_db < 0.0 {
result.add_error(format!(
"bass_management.headroom_margin_db ({}) must be non-negative",
bm.headroom_margin_db
));
}
if bm.apply_lfe_gain_to_chain && bm.redirect_bass {
result.add_warning(
"bass_management.apply_lfe_gain_to_chain=true while redirect_bass=true. \
The exported RoomEQ chain is per physical sub output, so this also boosts \
redirected bass; leave it false unless downstream routing separates LFE."
.to_string(),
);
}
}
fn validate_role_targets(config: &RoomConfig, result: &mut ValidationResult) {
let Some(role_targets) = config
.optimizer
.target_response
.as_ref()
.and_then(|target| target.role_targets.as_ref())
else {
return;
};
if !role_targets.enabled {
return;
}
if role_targets.center_dialog_low_hz <= 0.0
|| role_targets.center_dialog_high_hz <= role_targets.center_dialog_low_hz
{
result.add_error(format!(
"target_response.role_targets center dialog band must be positive and ordered; got {}..{} Hz",
role_targets.center_dialog_low_hz, role_targets.center_dialog_high_hz
));
}
if role_targets.cinema_x_curve_start_hz <= 0.0 {
result.add_error(format!(
"target_response.role_targets.cinema_x_curve_start_hz ({}) must be positive",
role_targets.cinema_x_curve_start_hz
));
}
if let Some(distance_m) = role_targets.listening_distance_m
&& distance_m <= 0.0
{
result.add_error(format!(
"target_response.role_targets.listening_distance_m ({distance_m}) must be positive"
));
}
if role_targets.cinema_reference_distance_m <= 0.0 {
result.add_error(format!(
"target_response.role_targets.cinema_reference_distance_m ({}) must be positive",
role_targets.cinema_reference_distance_m
));
}
}
#[cfg(test)]
mod validate_optimizer_tests {
use super::*;
use crate::roomeq::types::OptimizerConfig;
fn default_config() -> OptimizerConfig {
OptimizerConfig::default()
}
#[test]
fn validate_normal_config_is_valid() {
let mut result = ValidationResult::valid();
let config = default_config();
validate_optimizer_config(&config, &mut result);
assert!(
result.is_valid,
"default config should be valid: {:?}",
result.errors
);
}
#[test]
fn validate_enabled_timbre_matching_requires_reference_and_finite_threshold() {
let mut config = default_config();
config.inter_channel_timbre_matching =
Some(crate::roomeq::types::InterChannelTimbreMatchingConfig {
enabled: true,
reference_channel: " ".to_string(),
min_improvement_db: f64::NAN,
});
let mut result = ValidationResult::valid();
validate_optimizer_config(&config, &mut result);
assert!(!result.is_valid);
assert!(
result
.errors
.iter()
.any(|error| error.contains("reference_channel"))
);
assert!(
result
.errors
.iter()
.any(|error| error.contains("min_improvement_db"))
);
}
#[test]
fn validate_height_alignment_requires_valid_bounds_and_an_objective() {
let mut config = default_config();
config.height_channel_alignment =
Some(crate::roomeq::types::HeightChannelAlignmentConfig {
enabled: true,
match_timbre: false,
match_level: false,
match_arrival_time: false,
match_phase: false,
min_timbre_improvement_db: -1.0,
max_delay_ms: f64::INFINITY,
..Default::default()
});
let mut result = ValidationResult::valid();
validate_optimizer_config(&config, &mut result);
assert!(!result.is_valid);
assert!(
result
.errors
.iter()
.any(|error| error.contains("min_timbre_improvement_db"))
);
assert!(
result
.errors
.iter()
.any(|error| error.contains("max_delay_ms"))
);
assert!(
result
.errors
.iter()
.any(|error| error.contains("at least one actionable"))
);
}
#[test]
fn validate_num_filters_zero_warns() {
let mut result = ValidationResult::valid();
let mut config = default_config();
config.num_filters = 0;
validate_optimizer_config(&config, &mut result);
assert!(result.is_valid, "zero filters is a warning, not an error");
assert!(
result
.warnings
.iter()
.any(|w| w.contains("num_filters is 0"))
);
}
#[test]
fn validate_min_freq_gte_max_freq_errors() {
let mut result = ValidationResult::valid();
let mut config = default_config();
config.min_freq = 200.0;
config.max_freq = 100.0;
validate_optimizer_config(&config, &mut result);
assert!(!result.is_valid);
assert!(
result
.errors
.iter()
.any(|e| e.contains("min_freq") && e.contains("max_freq"))
);
}
#[test]
fn validate_min_freq_non_positive_errors() {
let mut result = ValidationResult::valid();
let mut config = default_config();
config.min_freq = 0.0;
validate_optimizer_config(&config, &mut result);
assert!(!result.is_valid);
assert!(
result
.errors
.iter()
.any(|e| e.contains("min_freq") && e.contains("positive"))
);
}
#[test]
fn validate_max_freq_above_nyquist_warns() {
let mut result = ValidationResult::valid();
let mut config = default_config();
config.max_freq = 30000.0;
validate_optimizer_config(&config, &mut result);
assert!(result.is_valid);
assert!(result.warnings.iter().any(|w| w.contains("Nyquist")));
}
#[test]
fn validate_min_q_gte_max_q_errors() {
let mut result = ValidationResult::valid();
let mut config = default_config();
config.min_q = 5.0;
config.max_q = 2.0;
validate_optimizer_config(&config, &mut result);
assert!(!result.is_valid);
assert!(
result
.errors
.iter()
.any(|e| e.contains("min_q") && e.contains("max_q"))
);
}
#[test]
fn validate_min_q_non_positive_errors() {
let mut result = ValidationResult::valid();
let mut config = default_config();
config.min_q = 0.0;
validate_optimizer_config(&config, &mut result);
assert!(!result.is_valid);
assert!(
result
.errors
.iter()
.any(|e| e.contains("min_q") && e.contains("positive"))
);
}
#[test]
fn validate_smooth_n_out_of_range_errors() {
let mut result = ValidationResult::valid();
let mut config = default_config();
config.smooth_n = 0;
validate_optimizer_config(&config, &mut result);
assert!(!result.is_valid);
assert!(result.errors.iter().any(|e| e.contains("smooth_n")));
let mut result2 = ValidationResult::valid();
config.smooth_n = 50;
validate_optimizer_config(&config, &mut result2);
assert!(!result2.is_valid);
}
#[test]
fn validate_unknown_algorithm_warns() {
let mut result = ValidationResult::valid();
let mut config = default_config();
config.algorithm = "unknown:algo".to_string();
validate_optimizer_config(&config, &mut result);
assert!(result.is_valid);
assert!(
result
.warnings
.iter()
.any(|w| w.contains("Unknown algorithm"))
);
}
#[test]
fn validate_unknown_loss_type_errors() {
let mut result = ValidationResult::valid();
let mut config = default_config();
config.loss_type = "invalid".to_string();
validate_optimizer_config(&config, &mut result);
assert!(!result.is_valid);
assert!(
result
.errors
.iter()
.any(|e| e.contains("Unknown loss_type"))
);
}
#[test]
fn validate_unknown_peq_model_warns() {
let mut result = ValidationResult::valid();
let mut config = default_config();
config.peq_model = "unknown-model".to_string();
validate_optimizer_config(&config, &mut result);
assert!(result.is_valid);
assert!(
result
.warnings
.iter()
.any(|w| w.contains("Unknown peq_model"))
);
}
#[test]
fn validate_max_iter_zero_warns() {
let mut result = ValidationResult::valid();
let mut config = default_config();
config.max_iter = 0;
validate_optimizer_config(&config, &mut result);
assert!(result.is_valid);
assert!(result.warnings.iter().any(|w| w.contains("max_iter is 0")));
}
#[test]
fn validate_auto_optimizer_min_filters_gt_max_errors() {
let mut result = ValidationResult::valid();
let mut config = default_config();
config.auto_optimizer = Some(crate::roomeq::types::AutoOptimizerConfig {
enabled: true,
min_filters: 5,
max_filters: 3,
..Default::default()
});
validate_optimizer_config(&config, &mut result);
assert!(!result.is_valid);
assert!(
result
.errors
.iter()
.any(|e| e.contains("min_filters") && e.contains("max_filters"))
);
}
#[test]
fn validate_auto_optimizer_enabled_but_no_flags_warns() {
let mut result = ValidationResult::valid();
let mut config = default_config();
config.auto_optimizer = Some(crate::roomeq::types::AutoOptimizerConfig {
enabled: true,
filter_count: false,
q_bounds: false,
gain_bounds: false,
..Default::default()
});
validate_optimizer_config(&config, &mut result);
assert!(result.is_valid);
assert!(
result
.warnings
.iter()
.any(|w| w.contains("all automatic selection flags are disabled"))
);
}
#[test]
fn validate_min_db_gte_max_db_errors() {
let mut result = ValidationResult::valid();
let mut config = default_config();
config.min_db = 10.0;
config.max_db = 5.0;
validate_optimizer_config(&config, &mut result);
assert!(!result.is_valid);
assert!(
result
.errors
.iter()
.any(|e| e.contains("min_db") && e.contains("max_db"))
);
}
#[test]
fn validate_psychoacoustic_smoothing_zero_n_errors() {
let mut result = ValidationResult::valid();
let mut config = default_config();
config.psychoacoustic_smoothing = Some(crate::PsychoacousticSmoothingConfig {
low_freq_n: 0,
high_freq_n: 1,
..Default::default()
});
validate_optimizer_config(&config, &mut result);
assert!(!result.is_valid);
assert!(
result
.errors
.iter()
.any(|e| e.contains("psychoacoustic_smoothing"))
);
}
#[test]
fn validate_asymmetric_loss_config_negative_weight_errors() {
let mut result = ValidationResult::valid();
let mut config = default_config();
config.asymmetric_loss_config = Some(crate::AsymmetricLossConfig {
peak_weight: -1.0,
..Default::default()
});
validate_optimizer_config(&config, &mut result);
assert!(!result.is_valid);
assert!(
result
.errors
.iter()
.any(|e| e.contains("asymmetric_loss_config") && e.contains("weights"))
);
}
#[test]
fn validate_fir_taps_zero_errors() {
let mut result = ValidationResult::valid();
let mut config = default_config();
config.fir = Some(crate::roomeq::types::FirConfig {
taps: 0,
phase: "linear".to_string(),
..Default::default()
});
validate_optimizer_config(&config, &mut result);
assert!(!result.is_valid);
assert!(result.errors.iter().any(|e| e.contains("FIR taps")));
}
#[test]
fn validate_fir_phase_invalid_errors() {
let mut result = ValidationResult::valid();
let mut config = default_config();
config.fir = Some(crate::roomeq::types::FirConfig {
taps: 256,
phase: "invalid".to_string(),
..Default::default()
});
validate_optimizer_config(&config, &mut result);
assert!(!result.is_valid);
assert!(
result
.errors
.iter()
.any(|e| e.contains("Unknown FIR phase"))
);
}
#[test]
fn validate_cea2034_correction_score_mode_errors() {
let mut result = ValidationResult::valid();
let mut config = default_config();
config.cea2034_correction = Some(crate::roomeq::types::Cea2034CorrectionConfig {
enabled: true,
correction_mode: crate::roomeq::types::Cea2034CorrectionMode::Score,
..Default::default()
});
validate_optimizer_config(&config, &mut result);
assert!(!result.is_valid);
assert!(
result
.errors
.iter()
.any(|e| e.contains("score is not supported in roomeq"))
);
}
}
#[cfg(test)]
mod room_config_validation_tests {
use super::{RoomValidationContext, validate_room_config, validate_room_config_staged};
use crate::roomeq::types::{
AreaPriorKind, AreaQuadratureKind, AreaScalarisationKind, BootstrapScalarisation,
BootstrapUncertaintyConfig, CardioidConfig, ContinuousListeningAreaConfig, CrossoverConfig,
DBAConfig, MultiSeatConfig, MultiSeatStrategy, MultiSubGroup, OptimizerConfig, RoomConfig,
SpeakerConfig, SpeakerGroup, SupportingSourceGroup, SystemConfig, SystemModel,
TargetResponseConfig, TargetShape, ValidationStage,
};
use crate::{Curve, InlineMeasurement, MeasurementRef, MeasurementSingle, MeasurementSource};
use std::collections::HashMap;
use std::path::PathBuf;
fn default_room() -> RoomConfig {
RoomConfig {
version: crate::roomeq::types::default_config_version(),
system: None,
speakers: HashMap::new(),
crossovers: None,
target_curve: None,
optimizer: OptimizerConfig::default(),
provenance: Default::default(),
recording_config: None,
ctc: None,
cea2034_cache: None,
}
}
fn single_source(path: &str, speaker_name: Option<&str>) -> MeasurementSource {
MeasurementSource::Single(MeasurementSingle {
measurement: MeasurementRef::Path(PathBuf::from(path)),
speaker_name: speaker_name.map(String::from),
})
}
fn csv_backed_inline_source(csv_path: Option<&str>) -> MeasurementSource {
MeasurementSource::Single(MeasurementSingle {
measurement: MeasurementRef::Inline(InlineMeasurement {
frequencies: Vec::new(),
magnitude_db: Vec::new(),
phase_deg: None,
name: Some("legacy recording".to_string()),
wav_path: Some("recording.wav".to_string()),
csv_path: csv_path.map(String::from),
}),
speaker_name: None,
})
}
#[test]
fn model_validation_defers_csv_backed_inline_acoustic_loading() {
let mut config = default_room();
config.speakers.insert(
"L".to_string(),
SpeakerConfig::Single(csv_backed_inline_source(Some("measurement.csv"))),
);
let report = validate_room_config_staged(&config, RoomValidationContext::production());
assert!(!report.production_ready());
assert!(!report.stage_ran(ValidationStage::Acoustic));
assert!(
report
.errors()
.any(|error| error.contains("measurement path was not resolved")),
"{report:?}"
);
}
#[test]
fn production_validation_rejects_empty_inline_measurement_without_csv_fallback() {
let mut config = default_room();
config.speakers.insert(
"L".to_string(),
SpeakerConfig::Single(csv_backed_inline_source(None)),
);
let report = validate_room_config_staged(&config, RoomValidationContext::production());
assert!(
report
.errors()
.any(|error| error.contains("invalid inline frequency/SPL data"))
);
}
#[test]
fn unsupported_config_version_is_a_validation_error() {
let mut config = default_room();
config.version = "3.0.0".to_string();
config.speakers.insert(
"L".to_string(),
SpeakerConfig::Single(single_source("l.csv", None)),
);
let result = validate_room_config(&config);
assert!(!result.is_valid);
assert!(
result
.errors
.iter()
.any(|error| error.contains("unsupported RoomEQ config version"))
);
}
#[test]
fn target_curve_and_shaped_target_response_warn() {
let mut config = default_room();
config.target_curve = Some(crate::roomeq::types::TargetCurveConfig::Predefined(
"harman".to_string(),
));
config.optimizer.target_response = Some(TargetResponseConfig {
shape: TargetShape::Harman,
slope_db_per_octave: 0.0,
..Default::default()
});
config.speakers.insert(
"L".to_string(),
SpeakerConfig::Single(single_source("l.csv", None)),
);
let result = validate_room_config(&config);
assert!(result.is_valid);
assert!(
result
.warnings
.iter()
.any(|w| w.contains("target_response takes precedence"))
);
}
#[test]
fn speaker_group_variants_produce_errors_and_warnings() {
let mut config = default_room();
config.speakers.insert(
"L".to_string(),
SpeakerConfig::Group(SpeakerGroup {
name: "L".to_string(),
speaker_name: None,
measurements: vec![],
crossover: None,
}),
);
let result = validate_room_config(&config);
assert!(
result
.errors
.iter()
.any(|e| e.contains("has no measurements"))
);
let mut config = default_room();
config.speakers.insert(
"L".to_string(),
SpeakerConfig::Group(SpeakerGroup {
name: "L".to_string(),
speaker_name: None,
measurements: vec![single_source("m.csv", None)],
crossover: None,
}),
);
let result = validate_room_config(&config);
assert!(
result
.warnings
.iter()
.any(|w| w.contains("has only 1 measurement"))
);
let mut config = default_room();
config.speakers.insert(
"L".to_string(),
SpeakerConfig::Group(SpeakerGroup {
name: "L".to_string(),
speaker_name: None,
measurements: vec![single_source("w.csv", None), single_source("t.csv", None)],
crossover: None,
}),
);
let result = validate_room_config(&config);
assert!(
result
.errors
.iter()
.any(|e| e.contains("has multiple drivers but no crossover specified"))
);
let mut config = default_room();
config.speakers.insert(
"Sub".to_string(),
SpeakerConfig::MultiSub(MultiSubGroup {
name: "Sub".to_string(),
speaker_name: None,
subwoofers: vec![],
allpass_optimization: false,
}),
);
let result = validate_room_config(&config);
assert!(
result
.errors
.iter()
.any(|e| e.contains("has no subwoofers"))
);
let mut config = default_room();
config.speakers.insert(
"Sub".to_string(),
SpeakerConfig::MultiSub(MultiSubGroup {
name: "Sub".to_string(),
speaker_name: None,
subwoofers: vec![single_source("s.csv", None)],
allpass_optimization: false,
}),
);
let result = validate_room_config(&config);
assert!(
result
.warnings
.iter()
.any(|w| w.contains("only 1 subwoofer"))
);
let mut config = default_room();
config.speakers.insert(
"DBA".to_string(),
SpeakerConfig::Dba(DBAConfig {
name: "DBA".to_string(),
speaker_name: None,
front: vec![],
rear: vec![],
}),
);
let result = validate_room_config(&config);
assert!(
result
.errors
.iter()
.any(|e| e.contains("no front speakers"))
);
assert!(result.errors.iter().any(|e| e.contains("no rear speakers")));
let mut config = default_room();
config.speakers.insert(
"Card".to_string(),
SpeakerConfig::Cardioid(Box::new(CardioidConfig {
name: "Card".to_string(),
speaker_name: None,
front: single_source("f.csv", None),
rear: single_source("r.csv", None),
separation_meters: 0.0,
})),
);
let result = validate_room_config(&config);
assert!(
result
.errors
.iter()
.any(|e| e.contains("separation") && e.contains("must be > 0"))
);
let mut config = default_room();
config.speakers.insert(
"Support".to_string(),
SpeakerConfig::SupportingSource(SupportingSourceGroup {
name: "Support".to_string(),
speaker_name: None,
primary: single_source("p.csv", Some("Same")),
support: single_source("s.csv", Some("Same")),
supporting_source: Default::default(),
}),
);
let result = validate_room_config(&config);
assert!(
result
.warnings
.iter()
.any(|w| w.contains("same speaker_name for primary and support"))
);
let mut config = default_room();
config.speakers.insert(
"Support".to_string(),
SpeakerConfig::SupportingSource(SupportingSourceGroup {
name: "Support".to_string(),
speaker_name: None,
primary: single_source("p.csv", None),
support: single_source("s.csv", None),
supporting_source: crate::roomeq::types::SupportingSourceConfig {
delay_ms: 100.0,
..Default::default()
},
}),
);
let result = validate_room_config(&config);
assert!(result.errors.iter().any(|e| e.contains("delay_ms")));
let mut config = default_room();
config.speakers.insert(
"Support".to_string(),
SpeakerConfig::SupportingSource(SupportingSourceGroup {
name: "Support".to_string(),
speaker_name: None,
primary: single_source("p.csv", None),
support: single_source("s.csv", None),
supporting_source: crate::roomeq::types::SupportingSourceConfig {
fir_taps: 3,
..Default::default()
},
}),
);
let result = validate_room_config(&config);
assert!(result.errors.iter().any(|e| e.contains("fir_taps")));
}
#[test]
fn crossover_reference_validation() {
let mut config = default_room();
config.speakers.insert(
"L".to_string(),
SpeakerConfig::Group(SpeakerGroup {
name: "L".to_string(),
speaker_name: None,
measurements: vec![single_source("w.csv", None), single_source("t.csv", None)],
crossover: Some("xo".to_string()),
}),
);
let result = validate_room_config(&config);
assert!(
result
.errors
.iter()
.any(|e| e.contains("no crossovers defined"))
);
let mut config = default_room();
config.speakers.insert(
"L".to_string(),
SpeakerConfig::Group(SpeakerGroup {
name: "L".to_string(),
speaker_name: None,
measurements: vec![single_source("w.csv", None), single_source("t.csv", None)],
crossover: Some("xo".to_string()),
}),
);
config.crossovers = Some(HashMap::new());
let result = validate_room_config(&config);
assert!(
result
.errors
.iter()
.any(|e| e.contains("non-existent crossover"))
);
let mut config = default_room();
config.speakers.insert(
"L".to_string(),
SpeakerConfig::Group(SpeakerGroup {
name: "L".to_string(),
speaker_name: None,
measurements: vec![
single_source("w.csv", None),
single_source("m.csv", None),
single_source("t.csv", None),
],
crossover: Some("xo".to_string()),
}),
);
config.crossovers = Some(HashMap::from([(
"xo".to_string(),
CrossoverConfig {
crossover_type: "LR24".to_string(),
frequency: Some(1000.0),
frequencies: None,
frequency_range: None,
},
)]));
let result = validate_room_config(&config);
assert!(
result
.warnings
.iter()
.any(|w| w.contains("single frequency but speaker") && w.contains("has 3 drivers"))
);
let mut config = default_room();
config.speakers.insert(
"L".to_string(),
SpeakerConfig::Group(SpeakerGroup {
name: "L".to_string(),
speaker_name: None,
measurements: vec![
single_source("w.csv", None),
single_source("m.csv", None),
single_source("t.csv", None),
],
crossover: Some("xo".to_string()),
}),
);
config.crossovers = Some(HashMap::from([(
"xo".to_string(),
CrossoverConfig {
crossover_type: "LR24".to_string(),
frequency: None,
frequencies: Some(vec![1000.0]),
frequency_range: None,
},
)]));
let result = validate_room_config(&config);
assert!(
result
.errors
.iter()
.any(|e| e.contains("needs 2 for 3 drivers"))
);
let mut config = default_room();
config.speakers.insert(
"L".to_string(),
SpeakerConfig::Group(SpeakerGroup {
name: "L".to_string(),
speaker_name: None,
measurements: vec![single_source("w.csv", None), single_source("t.csv", None)],
crossover: Some("xo".to_string()),
}),
);
config.crossovers = Some(HashMap::from([(
"xo".to_string(),
CrossoverConfig {
crossover_type: "LR24".to_string(),
frequency: None,
frequencies: None,
frequency_range: None,
},
)]));
let result = validate_room_config(&config);
assert!(
result
.warnings
.iter()
.any(|w| w.contains("will be auto-optimized"))
);
}
#[test]
fn multi_measurement_weight_length_mismatch() {
let mut config = default_room();
config.speakers.insert(
"L".to_string(),
SpeakerConfig::Single(MeasurementSource::InMemoryMultiple(vec![
Curve {
freq: ndarray::array![20.0, 100.0],
spl: ndarray::array![0.0, 0.0],
phase: None,
..Default::default()
},
Curve {
freq: ndarray::array![20.0, 100.0],
spl: ndarray::array![0.0, 0.0],
phase: None,
..Default::default()
},
Curve {
freq: ndarray::array![20.0, 100.0],
spl: ndarray::array![0.0, 0.0],
phase: None,
..Default::default()
},
])),
);
config.optimizer.multi_measurement = Some(crate::roomeq::types::MultiMeasurementConfig {
weights: Some(vec![0.5, 0.5]),
..Default::default()
});
let result = validate_room_config(&config);
assert!(
result
.errors
.iter()
.any(|e| e.contains("multi_measurement.weights has 2 entries")
&& e.contains("has 3 measurements"))
);
}
#[test]
fn multi_measurement_numeric_contracts_are_rejected() {
for weights in [
vec![-1.0, 2.0],
vec![f64::NAN, 1.0],
vec![f64::INFINITY, 1.0],
vec![0.0, 0.0],
vec![f64::MAX, f64::MAX],
] {
let mut config = default_room();
config.optimizer.multi_measurement =
Some(crate::roomeq::types::MultiMeasurementConfig {
weights: Some(weights),
..Default::default()
});
let result = validate_room_config(&config);
assert!(
result
.errors
.iter()
.any(|error| error.contains("multi_measurement.weights"))
);
}
for variance_lambda in [-1.0, f64::NAN, f64::INFINITY] {
let mut config = default_room();
config.optimizer.multi_measurement =
Some(crate::roomeq::types::MultiMeasurementConfig {
variance_lambda,
..Default::default()
});
let result = validate_room_config(&config);
assert!(
result
.errors
.iter()
.any(|error| { error.contains("multi_measurement.variance_lambda") })
);
}
}
#[test]
fn bootstrap_uncertainty_validation_errors() {
let mut config = default_room();
config.speakers.insert(
"L".to_string(),
SpeakerConfig::Single(single_source("l.csv", None)),
);
config.optimizer.multi_measurement = Some(crate::roomeq::types::MultiMeasurementConfig {
strategy: crate::roomeq::types::MultiMeasurementStrategy::MinimaxUncertainty,
bootstrap_uncertainty: Some(BootstrapUncertaintyConfig {
effective_spatial_sample_size: Some(0.0),
repeat_sweep_noise_std_db: Some(f64::NAN),
calibration_uncertainty_std_db: Some(-0.1),
num_resamples: 0,
alpha: 0.0,
scalarisation: BootstrapScalarisation::Cvar,
cvar_alpha: 0.0,
..Default::default()
}),
..Default::default()
});
let result = validate_room_config(&config);
assert!(
result
.errors
.iter()
.any(|e| e.contains("num_resamples must be > 0"))
);
assert!(
result
.errors
.iter()
.any(|e| e.contains("alpha must be in (0, 1)") && e.contains("got 0"))
);
assert!(
result
.errors
.iter()
.any(|e| e.contains("cvar_alpha must be in (0, 1]") && e.contains("got 0"))
);
assert!(
result
.errors
.iter()
.any(|e| e.contains("effective_spatial_sample_size"))
);
assert!(
result
.errors
.iter()
.any(|e| e.contains("repeat_sweep_noise_std_db"))
);
assert!(
result
.errors
.iter()
.any(|e| e.contains("calibration_uncertainty_std_db"))
);
}
#[test]
fn continuous_listening_area_validation_errors() {
let make_config = |area: ContinuousListeningAreaConfig| {
let mut config = default_room();
config.speakers.insert(
"L".to_string(),
SpeakerConfig::Single(single_source("l.csv", None)),
);
config.optimizer.multi_seat = Some(MultiSeatConfig {
enabled: true,
strategy: MultiSeatStrategy::ContinuousArea,
continuous_area: Some(area),
..Default::default()
});
config
};
let mut config = default_room();
config.speakers.insert(
"L".to_string(),
SpeakerConfig::Single(single_source("l.csv", None)),
);
config.optimizer.multi_seat = Some(MultiSeatConfig {
enabled: true,
strategy: MultiSeatStrategy::ContinuousArea,
continuous_area: None,
..Default::default()
});
let result = validate_room_config(&config);
assert!(
result
.errors
.iter()
.any(|e| e.contains("continuous_area to be set"))
);
let result = validate_room_config(&make_config(ContinuousListeningAreaConfig {
dimensions: 4,
bounds: vec![(0.0, 1.0)],
seat_positions: vec![vec![0.5]],
prior: AreaPriorKind::Uniform,
quadrature: AreaQuadratureKind::Sobol {
num_points: 1,
seed: 0,
},
scalarisation: AreaScalarisationKind::ExpectedValue,
idw_power: 2.0,
}));
assert!(
result
.errors
.iter()
.any(|e| e.contains("dimensions must be 1, 2, or 3"))
);
let result = validate_room_config(&make_config(ContinuousListeningAreaConfig {
dimensions: 2,
bounds: vec![(0.0, 1.0)],
seat_positions: vec![vec![0.5, 0.5]],
prior: AreaPriorKind::Uniform,
quadrature: AreaQuadratureKind::Sobol {
num_points: 1,
seed: 0,
},
scalarisation: AreaScalarisationKind::ExpectedValue,
idw_power: 2.0,
}));
assert!(
result
.errors
.iter()
.any(|e| e.contains("bounds length 1 must equal dimensions 2"))
);
let result = validate_room_config(&make_config(ContinuousListeningAreaConfig {
dimensions: 1,
bounds: vec![(1.0, 1.0)],
seat_positions: vec![vec![0.5]],
prior: AreaPriorKind::Uniform,
quadrature: AreaQuadratureKind::Sobol {
num_points: 1,
seed: 0,
},
scalarisation: AreaScalarisationKind::ExpectedValue,
idw_power: 2.0,
}));
assert!(
result
.errors
.iter()
.any(|e| e.contains("bounds[0] = (1, 1) is degenerate"))
);
let result = validate_room_config(&make_config(ContinuousListeningAreaConfig {
dimensions: 1,
bounds: vec![(0.0, 1.0)],
seat_positions: vec![],
prior: AreaPriorKind::Uniform,
quadrature: AreaQuadratureKind::Sobol {
num_points: 1,
seed: 0,
},
scalarisation: AreaScalarisationKind::ExpectedValue,
idw_power: 2.0,
}));
assert!(
result
.errors
.iter()
.any(|e| e.contains("seat_positions must contain at least one position"))
);
let result = validate_room_config(&make_config(ContinuousListeningAreaConfig {
dimensions: 1,
bounds: vec![(0.0, 1.0)],
seat_positions: vec![vec![0.5, 0.5]],
prior: AreaPriorKind::Uniform,
quadrature: AreaQuadratureKind::Sobol {
num_points: 1,
seed: 0,
},
scalarisation: AreaScalarisationKind::ExpectedValue,
idw_power: 2.0,
}));
assert!(
result
.errors
.iter()
.any(|e| e.contains("seat_positions[0] has length 2 (expected 1)"))
);
let result = validate_room_config(&make_config(ContinuousListeningAreaConfig {
dimensions: 1,
bounds: vec![(0.0, 1.0)],
seat_positions: vec![vec![0.5]],
prior: AreaPriorKind::Uniform,
quadrature: AreaQuadratureKind::Sobol {
num_points: 1,
seed: 0,
},
scalarisation: AreaScalarisationKind::ExpectedValue,
idw_power: 0.0,
}));
assert!(
result
.errors
.iter()
.any(|e| e.contains("idw_power must be > 0"))
);
let result = validate_room_config(&make_config(ContinuousListeningAreaConfig {
dimensions: 1,
bounds: vec![(0.0, 1.0)],
seat_positions: vec![vec![0.5]],
prior: AreaPriorKind::Gaussian {
mean: vec![0.5, 0.5],
cov_diag: vec![0.1],
truncation_sigmas: 4.0,
},
quadrature: AreaQuadratureKind::Sobol {
num_points: 1,
seed: 0,
},
scalarisation: AreaScalarisationKind::ExpectedValue,
idw_power: 2.0,
}));
assert!(
result
.errors
.iter()
.any(|e| e.contains("prior.gaussian.mean length 2 must equal dimensions 1"))
);
let result = validate_room_config(&make_config(ContinuousListeningAreaConfig {
dimensions: 1,
bounds: vec![(0.0, 1.0)],
seat_positions: vec![vec![0.5]],
prior: AreaPriorKind::Gaussian {
mean: vec![0.5],
cov_diag: vec![-0.1],
truncation_sigmas: 4.0,
},
quadrature: AreaQuadratureKind::Sobol {
num_points: 1,
seed: 0,
},
scalarisation: AreaScalarisationKind::ExpectedValue,
idw_power: 2.0,
}));
assert!(
result
.errors
.iter()
.any(|e| e.contains("prior.gaussian.cov_diag[0] must be > 0"))
);
let result = validate_room_config(&make_config(ContinuousListeningAreaConfig {
dimensions: 1,
bounds: vec![(0.0, 1.0)],
seat_positions: vec![vec![0.5]],
prior: AreaPriorKind::Gaussian {
mean: vec![0.5],
cov_diag: vec![0.1],
truncation_sigmas: 0.0,
},
quadrature: AreaQuadratureKind::Sobol {
num_points: 1,
seed: 0,
},
scalarisation: AreaScalarisationKind::ExpectedValue,
idw_power: 2.0,
}));
assert!(
result
.errors
.iter()
.any(|e| e.contains("prior.gaussian.truncation_sigmas must be > 0"))
);
let result = validate_room_config(&make_config(ContinuousListeningAreaConfig {
dimensions: 1,
bounds: vec![(0.0, 1.0)],
seat_positions: vec![vec![0.5]],
prior: AreaPriorKind::Uniform,
quadrature: AreaQuadratureKind::Sobol {
num_points: 0,
seed: 0,
},
scalarisation: AreaScalarisationKind::ExpectedValue,
idw_power: 2.0,
}));
assert!(
result
.errors
.iter()
.any(|e| e.contains("quadrature.num_points must be > 0"))
);
let result = validate_room_config(&make_config(ContinuousListeningAreaConfig {
dimensions: 1,
bounds: vec![(0.0, 1.0)],
seat_positions: vec![vec![0.5]],
prior: AreaPriorKind::Uniform,
quadrature: AreaQuadratureKind::GaussLegendre { points_per_axis: 0 },
scalarisation: AreaScalarisationKind::ExpectedValue,
idw_power: 2.0,
}));
assert!(
result
.errors
.iter()
.any(|e| e.contains("quadrature.points_per_axis must be > 0"))
);
let result = validate_room_config(&make_config(ContinuousListeningAreaConfig {
dimensions: 1,
bounds: vec![(0.0, 1.0)],
seat_positions: vec![vec![0.5]],
prior: AreaPriorKind::Uniform,
quadrature: AreaQuadratureKind::Sobol {
num_points: 1,
seed: 0,
},
scalarisation: AreaScalarisationKind::WorstCase {
inner_maxiter: 0,
inner_seed: 0,
},
idw_power: 2.0,
}));
assert!(
result
.errors
.iter()
.any(|e| e.contains("worst_case.inner_maxiter must be > 0"))
);
let result = validate_room_config(&make_config(ContinuousListeningAreaConfig {
dimensions: 1,
bounds: vec![(0.0, 1.0)],
seat_positions: vec![vec![0.5]],
prior: AreaPriorKind::Uniform,
quadrature: AreaQuadratureKind::Sobol {
num_points: 1,
seed: 0,
},
scalarisation: AreaScalarisationKind::Cvar { alpha: 0.0 },
idw_power: 2.0,
}));
assert!(
result
.errors
.iter()
.any(|e| e.contains("scalarisation.cvar.alpha must be in (0, 1]"))
);
}
#[test]
fn cea2034_correction_plausibility_warning() {
let mut config = default_room();
config.speakers.insert(
"L".to_string(),
SpeakerConfig::Single(single_source("inroom.csv", None)),
);
config.optimizer.cea2034_correction = Some(crate::roomeq::types::Cea2034CorrectionConfig {
enabled: true,
..Default::default()
});
let result = validate_room_config(&config);
assert!(result.warnings.iter().any(|w| w.contains(
"cea2034_correction is enabled but no speaker looks like a CEA2034/spinorama"
)));
}
#[test]
fn bass_management_validation() {
let mut config = default_room();
config.speakers.insert(
"Sub".to_string(),
SpeakerConfig::Single(single_source("sub.csv", None)),
);
config.system = Some(SystemConfig {
model: SystemModel::HomeCinema,
speakers: HashMap::new(),
subwoofers: None,
bass_management: Some(crate::roomeq::types::BassManagementConfig {
enabled: true,
lfe_playback_gain_db: 30.0,
lfe_low_pass_hz: 10.0,
max_sub_boost_db: -1.0,
headroom_margin_db: -2.0,
apply_lfe_gain_to_chain: true,
redirect_bass: true,
..Default::default()
}),
supporting_source_outputs: None,
});
let result = validate_room_config(&config);
assert!(
result
.warnings
.iter()
.any(|w| w.contains("bass_management is enabled but system.subwoofers is missing"))
);
assert!(
result
.warnings
.iter()
.any(|w| w.contains("apply_lfe_gain_to_chain=true while redirect_bass=true"))
);
assert!(
result
.errors
.iter()
.any(|e| e.contains("lfe_playback_gain_db") && e.contains("outside the safe"))
);
assert!(
result
.errors
.iter()
.any(|e| e.contains("lfe_low_pass_hz") && e.contains("20..=250 Hz"))
);
assert!(
result
.errors
.iter()
.any(|e| e.contains("max_sub_boost_db") && e.contains("must be non-negative"))
);
assert!(
result
.errors
.iter()
.any(|e| e.contains("headroom_margin_db") && e.contains("must be non-negative"))
);
}
#[test]
fn role_targets_validation() {
let mut config = default_room();
config.speakers.insert(
"C".to_string(),
SpeakerConfig::Single(single_source("c.csv", None)),
);
config.optimizer.target_response = Some(TargetResponseConfig {
role_targets: Some(crate::roomeq::types::RoleTargetConfig {
enabled: true,
center_dialog_low_hz: 500.0,
center_dialog_high_hz: 200.0,
cinema_x_curve_start_hz: 0.0,
listening_distance_m: Some(-1.0),
cinema_reference_distance_m: 0.0,
..Default::default()
}),
..Default::default()
});
let result = validate_room_config(&config);
assert!(
result
.errors
.iter()
.any(|e| e.contains("center dialog band"))
);
assert!(
result
.errors
.iter()
.any(|e| e.contains("cinema_x_curve_start_hz") && e.contains("must be positive"))
);
assert!(
result
.errors
.iter()
.any(|e| e.contains("listening_distance_m") && e.contains("must be positive"))
);
assert!(
result.errors.iter().any(
|e| e.contains("cinema_reference_distance_m") && e.contains("must be positive")
)
);
}
#[test]
fn audit_optimizer_numeric_bounds_must_be_finite() {
let mut config = default_room();
config.optimizer.min_freq = f64::NAN;
config.optimizer.max_q = f64::INFINITY;
let result = validate_room_config(&config);
assert!(
result
.errors
.iter()
.any(|e| e.contains("min_freq") && e.contains("finite"))
);
assert!(
result
.errors
.iter()
.any(|e| e.contains("max_q") && e.contains("finite"))
);
}
#[test]
fn audit_boost_envelope_must_be_finite_positive_and_strictly_sorted() {
let mut config = default_room();
config.optimizer.max_boost_envelope = Some(vec![(20.0, 6.0), (200.0, 3.0), (200.0, 2.0)]);
let result = validate_room_config(&config);
assert!(
result
.errors
.iter()
.any(|e| e.contains("max_boost_envelope") && e.contains("strictly increasing"))
);
}
#[test]
fn audit_system_speaker_mapping_must_reference_existing_measurement() {
let mut config = default_room();
config.speakers.insert(
"LeftMeasurement".to_string(),
SpeakerConfig::Single(single_source("left.csv", None)),
);
config.system = Some(SystemConfig {
model: SystemModel::Stereo,
speakers: HashMap::from([("L".to_string(), "Typo".to_string())]),
subwoofers: None,
bass_management: None,
supporting_source_outputs: None,
});
let result = validate_room_config(&config);
assert!(
result
.errors
.iter()
.any(|e| e.contains("system.speakers") && e.contains("Typo"))
);
}
#[test]
fn audit_crossover_type_is_validated_at_config_load() {
let mut config = default_room();
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 result = validate_room_config(&config);
assert!(
result
.errors
.iter()
.any(|e| e.contains("Crossover 'main'") && e.contains("unsupported type"))
);
}
}