Module validation 

Validation system for parsed OpenSCENARIO content

This module provides comprehensive validation of OpenSCENARIO documents beyond basic XML parsing, ensuring logical consistency and adherence to domain-specific constraints.

Features

• Multi-level validation - structure, references, constraints, and semantics
• Detailed error reporting with location context and fix suggestions
• Performance metrics and caching for large scenario validation
• Configurable validation modes (strict, lenient, custom rules)
• Cross-reference checking for entities, catalogs, and parameters

Basic Usage

Simple Validation

use openscenario_rs::parser::validation::ScenarioValidator;
use openscenario_rs::parser::xml::parse_from_file;

// Parse and validate a scenario
let scenario = parse_from_file("scenario.xosc")?;
let mut validator = ScenarioValidator::new();
let result = validator.validate_scenario(&scenario);

if result.is_valid() {
    println!("✓ Scenario is valid");
} else {
    println!("✗ Found {} errors:", result.errors.len());
    for error in &result.errors {
        println!("  - {}: {}", error.location, error.message);
        if let Some(suggestion) = &error.suggestion {
            println!("    Suggestion: {}", suggestion);
        }
    }
}

// Check warnings too
if !result.warnings.is_empty() {
    println!("⚠ {} warnings found", result.warnings.len());
    for warning in &result.warnings {
        println!("  - {}: {}", warning.location, warning.message);
    }
}

Custom Validation Configuration

use openscenario_rs::parser::validation::{ScenarioValidator, ValidationConfig};
use openscenario_rs::parse_from_file;

let config = ValidationConfig {
    strict_mode: true,           // Treat warnings as errors
    validate_references: true,   // Check entity/catalog references
    validate_constraints: true,  // Check business rules
    validate_semantics: true,    // Check logical consistency
    max_errors: 50,             // Stop after 50 errors
    use_cache: true,            // Enable performance caching
};

let mut validator = ScenarioValidator::with_config(config);
let result = validator.validate_scenario(&scenario);

println!("Validation completed in {}ms", result.metrics.duration_ms);
println!("Validated {} elements", result.metrics.elements_validated);

Validation Categories

The validator checks multiple categories of issues:

Structural Validation

• Required fields and attributes
• Valid data types and ranges
• Schema compliance

Reference Validation

// Checks that entity references point to defined entities
// Validates catalog references exist and are accessible
// Ensures parameter references resolve correctly

Constraint Validation

// Enforces OpenSCENARIO business rules
// Checks unique names and IDs
// Validates value ranges and relationships

Semantic Validation

// Ensures logical consistency
// Detects impossible scenarios
// Validates temporal relationships

Error Categories and Handling

use openscenario_rs::parser::validation::ValidationErrorCategory;

for error in &result.errors {
    match error.category {
        ValidationErrorCategory::MissingRequired => {
            // Handle missing required fields
            eprintln!("Missing required field: {}", error.location);
        }
        ValidationErrorCategory::InvalidReference => {
            // Handle broken references
            eprintln!("Invalid reference at {}: {}", error.location, error.message);
        }
        ValidationErrorCategory::ConstraintViolation => {
            // Handle business rule violations
            eprintln!("Constraint violation: {}", error.message);
        }
        ValidationErrorCategory::SemanticError => {
            // Handle logical inconsistencies
            eprintln!("Semantic error: {}", error.message);
        }
        ValidationErrorCategory::TypeMismatch => {
            // Handle type errors
            eprintln!("Type mismatch: {}", error.message);
        }
        ValidationErrorCategory::ParameterError => {
            // Handle parameter resolution errors
            eprintln!("Parameter error: {}", error.message);
        }
    }
}

Performance Optimization

For large scenarios or repeated validations:

use openscenario_rs::parser::validation::{ScenarioValidator, ValidationConfig};
use openscenario_rs::parser::xml::parse_from_file;

let config = ValidationConfig {
    use_cache: true,         // Enable validation caching
    max_errors: 20,          // Stop early to save time
    validate_semantics: false, // Skip expensive semantic checks
    ..Default::default()
};

let mut validator = ScenarioValidator::with_config(config);

// Validate multiple scenarios efficiently
for scenario_file in scenario_files {
    let scenario = parse_from_file(scenario_file)?;
    let result = validator.validate_scenario(&scenario);

    println!("Cache hit ratio: {:.1}%", result.metrics.cache_hit_ratio * 100.0);
}

Integration with Parsing

use openscenario_rs::parser::{xml, validation};

// Parse and validate in one step
let scenario = xml::parse_from_file_validated("scenario.xosc")?;

// Then do domain-specific validation
let mut validator = validation::ScenarioValidator::new();
let validation_result = validator.validate_scenario(&scenario);

// Check both parsing and validation results
if validation_result.is_clean() {
    println!("Scenario is fully valid and clean");
}

Structs

ScenarioValidator

Comprehensive validation engine for OpenSCENARIO documents

ValidationConfig

Configuration for validation behavior

ValidationError

Detailed validation error information

ValidationMetrics

Performance metrics for validation

ValidationResult

Result of validation operation

ValidationWarning

Validation warning information

Enums

ValidationErrorCategory

Categories of validation errors

ValidationWarningCategory

Categories of validation warnings