memscope_rs/analysis/quality/

checker.rs

use std::collections::HashMap;
use std::time::{Duration, Instant};

/// Performance checker for memory analysis operations
pub struct PerformanceChecker {
    benchmarks: HashMap<String, PerformanceBenchmark>,
    thresholds: PerformanceThresholds,
    config: CheckerConfig,
}

impl PerformanceChecker {
    pub fn config(&self) -> &CheckerConfig {
        &self.config
    }
}

/// Memory leak detection checker
pub struct MemoryLeakChecker {
    baseline_measurements: HashMap<String, MemoryBaseline>,
    config: LeakDetectionConfig,
    sensitivity: LeakSensitivity,
}

impl MemoryLeakChecker {
    pub fn config(&self) -> &LeakDetectionConfig {
        &self.config
    }
}

/// Safety checker for memory operations
pub struct SafetyChecker {
    violation_patterns: Vec<SafetyPattern>,
    safety_requirements: HashMap<String, SafetyRequirement>,
    config: SafetyConfig,
}

impl SafetyChecker {
    pub fn violation_patterns(&self) -> &[SafetyPattern] {
        &self.violation_patterns
    }
    pub fn safety_requirements(&self) -> &HashMap<String, SafetyRequirement> {
        &self.safety_requirements
    }
    pub fn config(&self) -> &SafetyConfig {
        &self.config
    }
}

/// Performance benchmark for specific operation
#[derive(Debug, Clone)]
pub struct PerformanceBenchmark {
    /// Operation identifier
    pub operation: String,
    /// Expected average duration
    pub expected_duration: Duration,
    /// Maximum acceptable duration
    pub max_duration: Duration,
    /// Expected memory usage
    pub expected_memory: usize,
    /// Maximum acceptable memory
    pub max_memory: usize,
    /// Expected throughput (operations per second)
    pub expected_throughput: f64,
    /// Minimum acceptable throughput
    pub min_throughput: f64,
}

/// Performance thresholds for different operations
#[derive(Debug, Clone)]
pub struct PerformanceThresholds {
    /// Allocation tracking latency threshold
    pub allocation_latency: Duration,
    /// Symbol resolution time threshold
    pub symbol_resolution: Duration,
    /// Stack trace capture time threshold
    pub stack_trace_capture: Duration,
    /// Memory overhead percentage threshold
    pub memory_overhead_pct: f64,
    /// Minimum tracking completeness
    pub min_completeness: f64,
}

/// Memory baseline for leak detection
#[derive(Debug, Clone)]
pub struct MemoryBaseline {
    /// Initial memory usage
    pub initial_memory: usize,
    /// Expected memory growth pattern
    pub growth_pattern: GrowthPattern,
    /// Measurement timestamp
    pub timestamp: Instant,
    /// Number of allocations at baseline
    pub allocation_count: usize,
}

/// Expected memory growth patterns
#[derive(Debug, Clone, PartialEq)]
pub enum GrowthPattern {
    /// Memory usage should remain constant
    Constant,
    /// Memory should grow linearly with allocations
    Linear { bytes_per_allocation: f64 },
    /// Memory should grow logarithmically
    Logarithmic,
    /// Memory should stabilize after initial growth
    Stabilizing { max_growth: usize },
    /// Custom growth pattern
    Custom { description: String },
}

/// Leak detection sensitivity levels
#[derive(Debug, Clone, PartialEq)]
pub enum LeakSensitivity {
    /// Only detect obvious leaks
    Low,
    /// Detect moderate leaks
    Medium,
    /// Detect subtle leaks
    High,
    /// Detect any unusual growth
    Paranoid,
}

/// Safety violation patterns
#[derive(Debug, Clone)]
pub struct SafetyPattern {
    /// Pattern identifier
    pub id: String,
    /// Pattern description
    pub description: String,
    /// Detection function
    pub detector: SafetyDetector,
    /// Severity of violation
    pub severity: SafetySeverity,
}

/// Safety detection function type
pub type SafetyDetector = fn(&SafetyContext) -> Vec<SafetyViolation>;

/// Safety requirement for operations
#[derive(Debug, Clone)]
pub struct SafetyRequirement {
    /// Required safety properties
    pub properties: Vec<SafetyProperty>,
    /// Whether operation must be thread-safe
    pub thread_safe: bool,
    /// Whether operation must handle errors
    pub error_handling: bool,
    /// Maximum acceptable risk level
    pub max_risk_level: RiskLevel,
}

/// Safety properties that operations should have
#[derive(Debug, Clone, PartialEq)]
pub enum SafetyProperty {
    /// No memory leaks
    NoMemoryLeaks,
    /// No data races
    NoDataRaces,
    /// No use after free
    NoUseAfterFree,
    /// No buffer overflows
    NoBufferOverflow,
    /// Proper error propagation
    ErrorPropagation,
    /// Resource cleanup
    ResourceCleanup,
}

/// Safety violation severity
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub enum SafetySeverity {
    /// Minor safety concern
    Low,
    /// Moderate safety issue
    Medium,
    /// Serious safety problem
    High,
    /// Critical safety violation
    Critical,
}

/// Risk assessment levels
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub enum RiskLevel {
    /// Minimal risk
    Minimal,
    /// Low risk
    Low,
    /// Medium risk
    Medium,
    /// High risk
    High,
    /// Critical risk
    Critical,
}

/// Context for safety checking
#[derive(Debug)]
pub struct SafetyContext {
    /// Operation being checked
    pub operation: String,
    /// Memory access patterns
    pub memory_accesses: Vec<MemoryAccess>,
    /// Thread interactions
    pub thread_interactions: Vec<ThreadInteraction>,
    /// Error handling status
    pub error_handling: bool,
    /// Resource usage
    pub resource_usage: ResourceUsage,
}

/// Memory access information
#[derive(Debug, Clone)]
pub struct MemoryAccess {
    /// Type of access
    pub access_type: AccessType,
    /// Memory address (if known)
    pub address: Option<usize>,
    /// Size of access
    pub size: usize,
    /// Whether access is synchronized
    pub synchronized: bool,
}

/// Types of memory access
#[derive(Debug, Clone, PartialEq)]
pub enum AccessType {
    /// Reading memory
    Read,
    /// Writing memory
    Write,
    /// Allocating memory
    Allocate,
    /// Deallocating memory
    Deallocate,
}

/// Thread interaction information
#[derive(Debug, Clone)]
pub struct ThreadInteraction {
    /// Type of interaction
    pub interaction_type: InteractionType,
    /// Shared resource identifier
    pub resource_id: String,
    /// Synchronization mechanism used
    pub synchronization: Option<SyncMechanism>,
}

/// Types of thread interactions
#[derive(Debug, Clone, PartialEq)]
pub enum InteractionType {
    /// Shared read access
    SharedRead,
    /// Exclusive write access
    ExclusiveWrite,
    /// Message passing
    MessagePassing,
    /// Lock acquisition
    LockAcquisition,
}

/// Synchronization mechanisms
#[derive(Debug, Clone, PartialEq)]
pub enum SyncMechanism {
    /// Mutex lock
    Mutex,
    /// Read-write lock
    RwLock,
    /// Atomic operations
    Atomic,
    /// Lock-free data structure
    LockFree,
    /// None (unsafe)
    None,
}

/// Resource usage information
#[derive(Debug, Clone)]
pub struct ResourceUsage {
    /// Memory usage in bytes
    pub memory_bytes: usize,
    /// File descriptors used
    pub file_descriptors: usize,
    /// Network connections
    pub network_connections: usize,
    /// CPU time used
    pub cpu_time: Duration,
}

/// Safety violation detected
#[derive(Debug, Clone)]
pub struct SafetyViolation {
    /// Violation type
    pub violation_type: String,
    /// Severity level
    pub severity: SafetySeverity,
    /// Description of the issue
    pub description: String,
    /// Suggested fix
    pub suggestion: String,
    /// Location where violation was detected
    pub location: Option<String>,
}

/// Configuration for checkers
#[derive(Debug, Clone)]
pub struct CheckerConfig {
    /// Whether to enable deep analysis
    pub deep_analysis: bool,
    /// Maximum time to spend checking
    pub max_check_time: Duration,
    /// Whether to check during operation
    pub realtime_checking: bool,
    /// Sampling rate for performance monitoring
    pub sample_rate: f64,
}

/// Leak detection configuration
#[derive(Debug, Clone)]
pub struct LeakDetectionConfig {
    /// Minimum time between measurements
    pub measurement_interval: Duration,
    /// Number of measurements to keep
    pub measurement_history: usize,
    /// Growth threshold for leak detection
    pub growth_threshold: f64,
    /// Whether to track individual allocations
    pub track_allocations: bool,
}

/// Safety checking configuration
#[derive(Debug, Clone)]
pub struct SafetyConfig {
    /// Safety patterns to check
    pub enabled_patterns: Vec<String>,
    /// Minimum severity to report
    pub min_severity: SafetySeverity,
    /// Whether to check thread safety
    pub check_thread_safety: bool,
    /// Whether to check memory safety
    pub check_memory_safety: bool,
}

impl PerformanceChecker {
    /// Create performance checker with default thresholds
    pub fn new() -> Self {
        Self {
            benchmarks: HashMap::new(),
            thresholds: PerformanceThresholds::default(),
            config: CheckerConfig::default(),
        }
    }

    /// Add performance benchmark for operation
    pub fn add_benchmark(&mut self, benchmark: PerformanceBenchmark) {
        self.benchmarks
            .insert(benchmark.operation.clone(), benchmark);
    }

    /// Check operation performance against benchmarks
    pub fn check_performance(
        &self,
        operation: &str,
        actual: &PerformanceMetrics,
    ) -> PerformanceCheckResult {
        let mut violations = Vec::new();

        // Check against specific benchmark if available
        if let Some(benchmark) = self.benchmarks.get(operation) {
            violations.extend(self.check_against_benchmark(benchmark, actual));
        }

        // Check against general thresholds
        violations.extend(self.check_against_thresholds(operation, actual));

        let status = if violations
            .iter()
            .any(|v| v.severity == PerformanceIssueType::Critical)
        {
            PerformanceStatus::Critical
        } else if violations
            .iter()
            .any(|v| v.severity == PerformanceIssueType::Major)
        {
            PerformanceStatus::Poor
        } else if violations
            .iter()
            .any(|v| v.severity == PerformanceIssueType::Minor)
        {
            PerformanceStatus::Acceptable
        } else {
            PerformanceStatus::Optimal
        };

        let overall_score = self.calculate_performance_score(&violations);

        PerformanceCheckResult {
            operation: operation.to_string(),
            status,
            violations,
            overall_score,
        }
    }

    fn check_against_benchmark(
        &self,
        benchmark: &PerformanceBenchmark,
        actual: &PerformanceMetrics,
    ) -> Vec<PerformanceViolation> {
        let mut violations = Vec::new();

        // Check duration
        if actual.duration > benchmark.max_duration {
            violations.push(PerformanceViolation {
                metric: "duration".to_string(),
                expected: benchmark.expected_duration.as_micros() as f64,
                actual: actual.duration.as_micros() as f64,
                severity: PerformanceIssueType::Major,
                description: format!(
                    "Duration {:.2}ms exceeds maximum {:.2}ms",
                    actual.duration.as_millis(),
                    benchmark.max_duration.as_millis()
                ),
            });
        }

        // Check memory usage
        if actual.memory_usage > benchmark.max_memory {
            violations.push(PerformanceViolation {
                metric: "memory".to_string(),
                expected: benchmark.expected_memory as f64,
                actual: actual.memory_usage as f64,
                severity: PerformanceIssueType::Major,
                description: format!(
                    "Memory usage {:.2}MB exceeds maximum {:.2}MB",
                    actual.memory_usage as f64 / (1024.0 * 1024.0),
                    benchmark.max_memory as f64 / (1024.0 * 1024.0)
                ),
            });
        }

        // Check throughput
        if actual.throughput < benchmark.min_throughput {
            violations.push(PerformanceViolation {
                metric: "throughput".to_string(),
                expected: benchmark.expected_throughput,
                actual: actual.throughput,
                severity: PerformanceIssueType::Minor,
                description: format!(
                    "Throughput {:.0}/sec below minimum {:.0}/sec",
                    actual.throughput, benchmark.min_throughput
                ),
            });
        }

        violations
    }

    fn check_against_thresholds(
        &self,
        operation: &str,
        actual: &PerformanceMetrics,
    ) -> Vec<PerformanceViolation> {
        let mut violations = Vec::new();

        // Check allocation latency for tracking operations
        if operation.contains("allocation") && actual.duration > self.thresholds.allocation_latency
        {
            violations.push(PerformanceViolation {
                metric: "allocation_latency".to_string(),
                expected: self.thresholds.allocation_latency.as_micros() as f64,
                actual: actual.duration.as_micros() as f64,
                severity: PerformanceIssueType::Critical,
                description: "Allocation tracking latency exceeds threshold".to_string(),
            });
        }

        // Check symbol resolution time
        if operation.contains("symbol") && actual.duration > self.thresholds.symbol_resolution {
            violations.push(PerformanceViolation {
                metric: "symbol_resolution".to_string(),
                expected: self.thresholds.symbol_resolution.as_millis() as f64,
                actual: actual.duration.as_millis() as f64,
                severity: PerformanceIssueType::Major,
                description: "Symbol resolution time exceeds threshold".to_string(),
            });
        }

        violations
    }

    fn calculate_performance_score(&self, violations: &[PerformanceViolation]) -> f64 {
        if violations.is_empty() {
            return 1.0;
        }

        let penalty: f64 = violations
            .iter()
            .map(|v| match v.severity {
                PerformanceIssueType::Critical => 0.5,
                PerformanceIssueType::Major => 0.3,
                PerformanceIssueType::Minor => 0.1,
            })
            .sum();

        (1.0 - penalty).max(0.0)
    }
}

impl MemoryLeakChecker {
    /// Create memory leak checker
    pub fn new() -> Self {
        Self {
            baseline_measurements: HashMap::new(),
            config: LeakDetectionConfig::default(),
            sensitivity: LeakSensitivity::Medium,
        }
    }

    /// Set baseline memory measurement for operation
    pub fn set_baseline(&mut self, operation: &str, memory: usize, allocations: usize) {
        let baseline = MemoryBaseline {
            initial_memory: memory,
            growth_pattern: GrowthPattern::Constant,
            timestamp: Instant::now(),
            allocation_count: allocations,
        };
        self.baseline_measurements
            .insert(operation.to_string(), baseline);
    }

    /// Check for memory leaks
    pub fn check_for_leaks(&self, operation: &str, current: &MemorySnapshot) -> LeakCheckResult {
        if let Some(baseline) = self.baseline_measurements.get(operation) {
            let growth_rate = self.calculate_growth_rate(baseline, current);
            let leak_indicators = self.detect_leak_indicators(baseline, current, growth_rate);

            let severity = self.assess_leak_severity(&leak_indicators);
            let confidence = self.calculate_confidence(&leak_indicators);

            LeakCheckResult {
                operation: operation.to_string(),
                leak_detected: !leak_indicators.is_empty(),
                severity,
                confidence,
                indicators: leak_indicators,
                growth_rate,
            }
        } else {
            LeakCheckResult {
                operation: operation.to_string(),
                leak_detected: false,
                severity: LeakSeverity::None,
                confidence: 0.0,
                indicators: Vec::new(),
                growth_rate: 0.0,
            }
        }
    }

    fn calculate_growth_rate(&self, baseline: &MemoryBaseline, current: &MemorySnapshot) -> f64 {
        let time_elapsed = baseline.timestamp.elapsed().as_secs_f64();
        if time_elapsed > 0.0 {
            (current.memory_usage as f64 - baseline.initial_memory as f64) / time_elapsed
        } else {
            0.0
        }
    }

    fn detect_leak_indicators(
        &self,
        baseline: &MemoryBaseline,
        current: &MemorySnapshot,
        growth_rate: f64,
    ) -> Vec<LeakIndicator> {
        let mut indicators = Vec::new();

        // Check for unexpected growth
        if growth_rate > self.config.growth_threshold {
            indicators.push(LeakIndicator {
                indicator_type: "excessive_growth".to_string(),
                description: format!(
                    "Memory growing at {:.2}MB/sec",
                    growth_rate / (1024.0 * 1024.0)
                ),
                severity: LeakSeverity::High,
            });
        }

        // Check allocation/deallocation imbalance
        let alloc_growth = current.allocation_count as f64 - baseline.allocation_count as f64;
        let memory_growth = current.memory_usage as f64 - baseline.initial_memory as f64;

        if alloc_growth > 0.0 && memory_growth / alloc_growth > 1024.0 {
            // More than 1KB per allocation
            indicators.push(LeakIndicator {
                indicator_type: "allocation_imbalance".to_string(),
                description: "High memory per allocation ratio".to_string(),
                severity: LeakSeverity::Medium,
            });
        }

        indicators
    }

    fn assess_leak_severity(&self, indicators: &[LeakIndicator]) -> LeakSeverity {
        indicators
            .iter()
            .map(|i| &i.severity)
            .max()
            .cloned()
            .unwrap_or(LeakSeverity::None)
    }

    fn calculate_confidence(&self, indicators: &[LeakIndicator]) -> f64 {
        if indicators.is_empty() {
            0.0
        } else {
            match self.sensitivity {
                LeakSensitivity::Low => 0.5,
                LeakSensitivity::Medium => 0.7,
                LeakSensitivity::High => 0.85,
                LeakSensitivity::Paranoid => 0.95,
            }
        }
    }
}

// Additional types for results and metrics
#[derive(Debug, Clone)]
pub struct PerformanceMetrics {
    pub duration: Duration,
    pub memory_usage: usize,
    pub throughput: f64,
    pub cpu_usage: f64,
}

#[derive(Debug, Clone)]
pub struct PerformanceCheckResult {
    pub operation: String,
    pub status: PerformanceStatus,
    pub violations: Vec<PerformanceViolation>,
    pub overall_score: f64,
}

#[derive(Debug, Clone, PartialEq)]
pub enum PerformanceStatus {
    Optimal,
    Acceptable,
    Poor,
    Critical,
}

#[derive(Debug, Clone)]
pub struct PerformanceViolation {
    pub metric: String,
    pub expected: f64,
    pub actual: f64,
    pub severity: PerformanceIssueType,
    pub description: String,
}

#[derive(Debug, Clone, PartialEq)]
pub enum PerformanceIssueType {
    Minor,
    Major,
    Critical,
}

/// One of several same-named `MemorySnapshot` types in this crate: this one is the
/// the quality-checker snapshot used for integrity validation.
///
/// Convert at the module boundary instead of passing it across; a global rename is
/// deliberately avoided (see DATA_ACCURACY_DEVELOPMENT_PLAN §14.2).
#[derive(Debug, Clone)]
pub struct MemorySnapshot {
    pub memory_usage: usize,
    pub allocation_count: usize,
    pub timestamp: Instant,
}

#[derive(Debug, Clone)]
pub struct LeakCheckResult {
    pub operation: String,
    pub leak_detected: bool,
    pub severity: LeakSeverity,
    pub confidence: f64,
    pub indicators: Vec<LeakIndicator>,
    pub growth_rate: f64,
}

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub enum LeakSeverity {
    None,
    Low,
    Medium,
    High,
    Critical,
}

#[derive(Debug, Clone)]
pub struct LeakIndicator {
    pub indicator_type: String,
    pub description: String,
    pub severity: LeakSeverity,
}

// Default implementations
impl Default for PerformanceThresholds {
    fn default() -> Self {
        Self {
            allocation_latency: Duration::from_micros(50),
            symbol_resolution: Duration::from_millis(5),
            stack_trace_capture: Duration::from_millis(10),
            memory_overhead_pct: 5.0,
            min_completeness: 0.95,
        }
    }
}

impl Default for CheckerConfig {
    fn default() -> Self {
        Self {
            deep_analysis: true,
            max_check_time: Duration::from_secs(5),
            realtime_checking: false,
            sample_rate: 0.1,
        }
    }
}

impl Default for LeakDetectionConfig {
    fn default() -> Self {
        Self {
            measurement_interval: Duration::from_secs(60),
            measurement_history: 100,
            growth_threshold: 1024.0 * 1024.0, // 1MB/sec
            track_allocations: true,
        }
    }
}

impl Default for SafetyConfig {
    fn default() -> Self {
        Self {
            enabled_patterns: vec![
                "memory_safety".to_string(),
                "thread_safety".to_string(),
                "error_handling".to_string(),
            ],
            min_severity: SafetySeverity::Low,
            check_thread_safety: true,
            check_memory_safety: true,
        }
    }
}

impl Default for PerformanceChecker {
    fn default() -> Self {
        Self::new()
    }
}

impl Default for MemoryLeakChecker {
    fn default() -> Self {
        Self::new()
    }
}

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

    #[test]
    fn test_performance_checker() {
        let mut checker = PerformanceChecker::new();

        let benchmark = PerformanceBenchmark {
            operation: "allocation_tracking".to_string(),
            expected_duration: Duration::from_micros(10),
            max_duration: Duration::from_micros(50),
            expected_memory: 1024,
            max_memory: 2048,
            expected_throughput: 10000.0,
            min_throughput: 5000.0,
        };

        checker.add_benchmark(benchmark);

        let good_metrics = PerformanceMetrics {
            duration: Duration::from_micros(20),
            memory_usage: 1500,
            throughput: 8000.0,
            cpu_usage: 5.0,
        };

        let result = checker.check_performance("allocation_tracking", &good_metrics);
        assert!(matches!(
            result.status,
            PerformanceStatus::Optimal | PerformanceStatus::Acceptable
        ));

        let bad_metrics = PerformanceMetrics {
            duration: Duration::from_micros(100),
            memory_usage: 3000,
            throughput: 1000.0,
            cpu_usage: 50.0,
        };

        let result = checker.check_performance("allocation_tracking", &bad_metrics);
        assert!(matches!(
            result.status,
            PerformanceStatus::Poor | PerformanceStatus::Critical
        ));
        assert!(!result.violations.is_empty());
    }

    #[test]
    fn test_memory_leak_checker() {
        let mut checker = MemoryLeakChecker::new();

        checker.set_baseline("test_operation", 1024 * 1024, 100);

        let current = MemorySnapshot {
            memory_usage: 1200 * 1024,
            allocation_count: 120,
            timestamp: Instant::now(),
        };

        let result = checker.check_for_leaks("test_operation", &current);
        let _ = result;
    }

    #[test]
    fn test_growth_patterns() {
        assert_eq!(GrowthPattern::Constant, GrowthPattern::Constant);

        let linear = GrowthPattern::Linear {
            bytes_per_allocation: 64.0,
        };
        assert!(matches!(linear, GrowthPattern::Linear { .. }));
    }

    #[test]
    fn test_performance_checker_default() {
        let checker = PerformanceChecker::default();
        assert!(checker.benchmarks.is_empty());
    }

    #[test]
    fn test_memory_leak_checker_default() {
        let checker = MemoryLeakChecker::default();
        assert!(checker.baseline_measurements.is_empty());
    }

    #[test]
    fn test_checker_config_default() {
        let config = CheckerConfig::default();
        assert!(config.deep_analysis);
        assert_eq!(config.max_check_time, Duration::from_secs(5));
        assert!(!config.realtime_checking);
        assert!((config.sample_rate - 0.1).abs() < f64::EPSILON);
    }

    #[test]
    fn test_leak_detection_config_default() {
        let config = LeakDetectionConfig::default();
        assert_eq!(config.measurement_interval, Duration::from_secs(60));
        assert_eq!(config.measurement_history, 100);
        assert!((config.growth_threshold - 1024.0 * 1024.0).abs() < f64::EPSILON);
        assert!(config.track_allocations);
    }

    #[test]
    fn test_safety_config_default() {
        let config = SafetyConfig::default();
        assert_eq!(config.enabled_patterns.len(), 3);
        assert_eq!(config.min_severity, SafetySeverity::Low);
        assert!(config.check_thread_safety);
        assert!(config.check_memory_safety);
    }

    #[test]
    fn test_performance_thresholds_default() {
        let thresholds = PerformanceThresholds::default();
        assert_eq!(thresholds.allocation_latency, Duration::from_micros(50));
        assert_eq!(thresholds.symbol_resolution, Duration::from_millis(5));
        assert_eq!(thresholds.stack_trace_capture, Duration::from_millis(10));
        assert!((thresholds.memory_overhead_pct - 5.0).abs() < f64::EPSILON);
        assert!((thresholds.min_completeness - 0.95).abs() < f64::EPSILON);
    }

    #[test]
    fn test_leak_sensitivity_variants() {
        let sensitivities = vec![
            LeakSensitivity::Low,
            LeakSensitivity::Medium,
            LeakSensitivity::High,
            LeakSensitivity::Paranoid,
        ];

        for sensitivity in sensitivities {
            let checker = MemoryLeakChecker {
                baseline_measurements: HashMap::new(),
                config: LeakDetectionConfig::default(),
                sensitivity: sensitivity.clone(),
            };
            assert_eq!(checker.sensitivity, sensitivity);
        }
    }

    #[test]
    fn test_growth_pattern_variants() {
        let patterns = vec![
            GrowthPattern::Constant,
            GrowthPattern::Linear {
                bytes_per_allocation: 64.0,
            },
            GrowthPattern::Logarithmic,
            GrowthPattern::Stabilizing { max_growth: 1024 },
            GrowthPattern::Custom {
                description: "custom".to_string(),
            },
        ];

        for pattern in patterns {
            let baseline = MemoryBaseline {
                initial_memory: 1024,
                growth_pattern: pattern.clone(),
                timestamp: Instant::now(),
                allocation_count: 10,
            };
            assert_eq!(baseline.growth_pattern, pattern);
        }
    }

    #[test]
    fn test_safety_severity_ordering() {
        assert!(SafetySeverity::Critical > SafetySeverity::High);
        assert!(SafetySeverity::High > SafetySeverity::Medium);
        assert!(SafetySeverity::Medium > SafetySeverity::Low);
    }

    #[test]
    fn test_risk_level_ordering() {
        assert!(RiskLevel::Critical > RiskLevel::High);
        assert!(RiskLevel::High > RiskLevel::Medium);
        assert!(RiskLevel::Medium > RiskLevel::Low);
        assert!(RiskLevel::Low > RiskLevel::Minimal);
    }

    #[test]
    fn test_leak_severity_ordering() {
        assert!(LeakSeverity::Critical > LeakSeverity::High);
        assert!(LeakSeverity::High > LeakSeverity::Medium);
        assert!(LeakSeverity::Medium > LeakSeverity::Low);
        assert!(LeakSeverity::Low > LeakSeverity::None);
    }

    #[test]
    fn test_access_type_variants() {
        let access_types = vec![
            AccessType::Read,
            AccessType::Write,
            AccessType::Allocate,
            AccessType::Deallocate,
        ];

        for access_type in access_types {
            let access = MemoryAccess {
                access_type: access_type.clone(),
                address: Some(0x1000),
                size: 64,
                synchronized: true,
            };
            assert_eq!(access.access_type, access_type);
        }
    }

    #[test]
    fn test_interaction_type_variants() {
        let interaction_types = vec![
            InteractionType::SharedRead,
            InteractionType::ExclusiveWrite,
            InteractionType::MessagePassing,
            InteractionType::LockAcquisition,
        ];

        for interaction_type in interaction_types {
            let interaction = ThreadInteraction {
                interaction_type: interaction_type.clone(),
                resource_id: "test".to_string(),
                synchronization: None,
            };
            assert_eq!(interaction.interaction_type, interaction_type);
        }
    }

    #[test]
    fn test_sync_mechanism_variants() {
        let mechanisms = vec![
            SyncMechanism::Mutex,
            SyncMechanism::RwLock,
            SyncMechanism::Atomic,
            SyncMechanism::LockFree,
            SyncMechanism::None,
        ];

        for mechanism in mechanisms {
            let interaction = ThreadInteraction {
                interaction_type: InteractionType::LockAcquisition,
                resource_id: "test".to_string(),
                synchronization: Some(mechanism.clone()),
            };
            assert_eq!(interaction.synchronization, Some(mechanism));
        }
    }

    #[test]
    fn test_safety_property_variants() {
        let properties = vec![
            SafetyProperty::NoMemoryLeaks,
            SafetyProperty::NoDataRaces,
            SafetyProperty::NoUseAfterFree,
            SafetyProperty::NoBufferOverflow,
            SafetyProperty::ErrorPropagation,
            SafetyProperty::ResourceCleanup,
        ];

        for property in properties {
            let requirement = SafetyRequirement {
                properties: vec![property.clone()],
                thread_safe: true,
                error_handling: true,
                max_risk_level: RiskLevel::Low,
            };
            assert!(requirement.properties.contains(&property));
        }
    }

    #[test]
    fn test_performance_status_variants() {
        let statuses = vec![
            PerformanceStatus::Optimal,
            PerformanceStatus::Acceptable,
            PerformanceStatus::Poor,
            PerformanceStatus::Critical,
        ];

        for status in statuses {
            let result = PerformanceCheckResult {
                operation: "test".to_string(),
                status: status.clone(),
                violations: vec![],
                overall_score: 1.0,
            };
            assert_eq!(result.status, status);
        }
    }

    #[test]
    fn test_performance_issue_type_variants() {
        let issue_types = vec![
            PerformanceIssueType::Minor,
            PerformanceIssueType::Major,
            PerformanceIssueType::Critical,
        ];

        for issue_type in issue_types {
            let violation = PerformanceViolation {
                metric: "test".to_string(),
                expected: 100.0,
                actual: 200.0,
                severity: issue_type.clone(),
                description: "test".to_string(),
            };
            assert_eq!(violation.severity, issue_type);
        }
    }

    #[test]
    fn test_performance_benchmark_creation() {
        let benchmark = PerformanceBenchmark {
            operation: "test_op".to_string(),
            expected_duration: Duration::from_micros(10),
            max_duration: Duration::from_micros(50),
            expected_memory: 1024,
            max_memory: 2048,
            expected_throughput: 1000.0,
            min_throughput: 500.0,
        };

        assert_eq!(benchmark.operation, "test_op");
        assert_eq!(benchmark.expected_memory, 1024);
    }

    #[test]
    fn test_memory_baseline_creation() {
        let baseline = MemoryBaseline {
            initial_memory: 1024 * 1024,
            growth_pattern: GrowthPattern::Constant,
            timestamp: Instant::now(),
            allocation_count: 100,
        };

        assert_eq!(baseline.initial_memory, 1024 * 1024);
        assert_eq!(baseline.allocation_count, 100);
    }

    #[test]
    fn test_safety_pattern_creation() {
        fn test_detector(_ctx: &SafetyContext) -> Vec<SafetyViolation> {
            vec![]
        }

        let pattern = SafetyPattern {
            id: "test_pattern".to_string(),
            description: "Test pattern".to_string(),
            detector: test_detector,
            severity: SafetySeverity::Medium,
        };

        assert_eq!(pattern.id, "test_pattern");
        assert_eq!(pattern.severity, SafetySeverity::Medium);
    }

    #[test]
    fn test_safety_requirement_creation() {
        let requirement = SafetyRequirement {
            properties: vec![SafetyProperty::NoMemoryLeaks, SafetyProperty::NoDataRaces],
            thread_safe: true,
            error_handling: true,
            max_risk_level: RiskLevel::Medium,
        };

        assert_eq!(requirement.properties.len(), 2);
        assert!(requirement.thread_safe);
    }

    #[test]
    fn test_safety_context_creation() {
        let context = SafetyContext {
            operation: "test_op".to_string(),
            memory_accesses: vec![MemoryAccess {
                access_type: AccessType::Read,
                address: Some(0x1000),
                size: 64,
                synchronized: true,
            }],
            thread_interactions: vec![],
            error_handling: true,
            resource_usage: ResourceUsage {
                memory_bytes: 1024,
                file_descriptors: 2,
                network_connections: 1,
                cpu_time: Duration::from_millis(100),
            },
        };

        assert_eq!(context.operation, "test_op");
        assert_eq!(context.memory_accesses.len(), 1);
    }

    #[test]
    fn test_memory_access_creation() {
        let access = MemoryAccess {
            access_type: AccessType::Write,
            address: Some(0x2000),
            size: 128,
            synchronized: false,
        };

        assert_eq!(access.access_type, AccessType::Write);
        assert_eq!(access.size, 128);
        assert!(!access.synchronized);
    }

    #[test]
    fn test_thread_interaction_creation() {
        let interaction = ThreadInteraction {
            interaction_type: InteractionType::ExclusiveWrite,
            resource_id: "shared_data".to_string(),
            synchronization: Some(SyncMechanism::Mutex),
        };

        assert_eq!(
            interaction.interaction_type,
            InteractionType::ExclusiveWrite
        );
        assert_eq!(interaction.resource_id, "shared_data");
    }

    #[test]
    fn test_resource_usage_creation() {
        let usage = ResourceUsage {
            memory_bytes: 1024 * 1024,
            file_descriptors: 5,
            network_connections: 2,
            cpu_time: Duration::from_secs(1),
        };

        assert_eq!(usage.memory_bytes, 1024 * 1024);
        assert_eq!(usage.file_descriptors, 5);
    }

    #[test]
    fn test_safety_violation_creation() {
        let violation = SafetyViolation {
            violation_type: "use_after_free".to_string(),
            severity: SafetySeverity::Critical,
            description: "Memory accessed after free".to_string(),
            suggestion: "Check lifetime".to_string(),
            location: Some("test.rs:42".to_string()),
        };

        assert_eq!(violation.violation_type, "use_after_free");
        assert_eq!(violation.severity, SafetySeverity::Critical);
    }

    #[test]
    fn test_performance_metrics_creation() {
        let metrics = PerformanceMetrics {
            duration: Duration::from_micros(50),
            memory_usage: 2048,
            throughput: 1000.0,
            cpu_usage: 25.0,
        };

        assert_eq!(metrics.duration, Duration::from_micros(50));
        assert_eq!(metrics.memory_usage, 2048);
    }

    #[test]
    fn test_performance_check_result_creation() {
        let result = PerformanceCheckResult {
            operation: "test".to_string(),
            status: PerformanceStatus::Optimal,
            violations: vec![],
            overall_score: 1.0,
        };

        assert_eq!(result.operation, "test");
        assert_eq!(result.status, PerformanceStatus::Optimal);
    }

    #[test]
    fn test_performance_violation_creation() {
        let violation = PerformanceViolation {
            metric: "latency".to_string(),
            expected: 50.0,
            actual: 100.0,
            severity: PerformanceIssueType::Major,
            description: "Latency too high".to_string(),
        };

        assert_eq!(violation.metric, "latency");
        assert!((violation.actual - 100.0).abs() < f64::EPSILON);
    }

    #[test]
    fn test_memory_snapshot_creation() {
        let snapshot = MemorySnapshot {
            memory_usage: 1024 * 1024,
            allocation_count: 100,
            timestamp: Instant::now(),
        };

        assert_eq!(snapshot.memory_usage, 1024 * 1024);
        assert_eq!(snapshot.allocation_count, 100);
    }

    #[test]
    fn test_leak_check_result_creation() {
        let result = LeakCheckResult {
            operation: "test".to_string(),
            leak_detected: true,
            severity: LeakSeverity::High,
            confidence: 0.85,
            indicators: vec![],
            growth_rate: 1024.0,
        };

        assert!(result.leak_detected);
        assert_eq!(result.severity, LeakSeverity::High);
    }

    #[test]
    fn test_leak_indicator_creation() {
        let indicator = LeakIndicator {
            indicator_type: "excessive_growth".to_string(),
            description: "Memory growing too fast".to_string(),
            severity: LeakSeverity::Medium,
        };

        assert_eq!(indicator.indicator_type, "excessive_growth");
    }

    #[test]
    fn test_check_performance_no_benchmark() {
        let checker = PerformanceChecker::new();
        let metrics = PerformanceMetrics {
            duration: Duration::from_micros(50),
            memory_usage: 1024,
            throughput: 1000.0,
            cpu_usage: 10.0,
        };

        let result = checker.check_performance("unknown_operation", &metrics);
        assert!(matches!(
            result.status,
            PerformanceStatus::Optimal | PerformanceStatus::Acceptable
        ));
    }

    #[test]
    fn test_check_performance_allocation_latency() {
        let checker = PerformanceChecker::new();
        let metrics = PerformanceMetrics {
            duration: Duration::from_micros(100), // Exceeds threshold
            memory_usage: 1024,
            throughput: 1000.0,
            cpu_usage: 10.0,
        };

        let result = checker.check_performance("allocation_tracking", &metrics);
        assert!(matches!(
            result.status,
            PerformanceStatus::Critical | PerformanceStatus::Poor
        ));
    }

    #[test]
    fn test_check_performance_symbol_resolution() {
        let checker = PerformanceChecker::new();
        let metrics = PerformanceMetrics {
            duration: Duration::from_millis(10), // Exceeds threshold
            memory_usage: 1024,
            throughput: 1000.0,
            cpu_usage: 10.0,
        };

        let result = checker.check_performance("symbol_resolution", &metrics);
        assert!(matches!(
            result.status,
            PerformanceStatus::Poor | PerformanceStatus::Critical
        ));
    }

    #[test]
    fn test_check_for_leaks_no_baseline() {
        let checker = MemoryLeakChecker::new();
        let snapshot = MemorySnapshot {
            memory_usage: 1024,
            allocation_count: 10,
            timestamp: Instant::now(),
        };

        let result = checker.check_for_leaks("unknown_operation", &snapshot);
        assert!(!result.leak_detected);
        assert_eq!(result.severity, LeakSeverity::None);
        assert!((result.confidence - 0.0).abs() < f64::EPSILON);
    }

    #[test]
    fn test_check_for_leaks_high_growth() {
        let mut checker = MemoryLeakChecker::new();
        checker.set_baseline("test", 1024, 10);

        let snapshot = MemorySnapshot {
            memory_usage: 10 * 1024 * 1024, // 10MB growth
            allocation_count: 20,
            timestamp: Instant::now(),
        };

        let result = checker.check_for_leaks("test", &snapshot);
        // High growth should trigger leak detection
        let _ = result;
    }

    #[test]
    fn test_performance_checker_config() {
        let checker = PerformanceChecker::new();
        assert!(checker.config().deep_analysis);
    }

    #[test]
    fn test_memory_leak_checker_config() {
        let checker = MemoryLeakChecker::new();
        assert!(checker.config().track_allocations);
    }

    #[test]
    fn test_safety_checker_violation_patterns() {
        let checker = SafetyChecker {
            violation_patterns: vec![],
            safety_requirements: HashMap::new(),
            config: SafetyConfig::default(),
        };
        assert!(checker.violation_patterns().is_empty());
    }

    #[test]
    fn test_safety_checker_safety_requirements() {
        let checker = SafetyChecker {
            violation_patterns: vec![],
            safety_requirements: HashMap::new(),
            config: SafetyConfig::default(),
        };
        assert!(checker.safety_requirements().is_empty());
    }

    #[test]
    fn test_safety_checker_config() {
        let checker = SafetyChecker {
            violation_patterns: vec![],
            safety_requirements: HashMap::new(),
            config: SafetyConfig::default(),
        };
        assert!(checker.config().check_thread_safety);
    }

    #[test]
    fn test_performance_score_calculation_no_violations() {
        let checker = PerformanceChecker::new();
        let metrics = PerformanceMetrics {
            duration: Duration::from_micros(10),
            memory_usage: 512,
            throughput: 2000.0,
            cpu_usage: 5.0,
        };

        let result = checker.check_performance("test", &metrics);
        assert!((result.overall_score - 1.0).abs() < f64::EPSILON);
    }

    #[test]
    fn test_performance_score_with_violations() {
        let mut checker = PerformanceChecker::new();
        let benchmark = PerformanceBenchmark {
            operation: "test".to_string(),
            expected_duration: Duration::from_micros(10),
            max_duration: Duration::from_micros(20),
            expected_memory: 512,
            max_memory: 1024,
            expected_throughput: 2000.0,
            min_throughput: 1000.0,
        };
        checker.add_benchmark(benchmark);

        let metrics = PerformanceMetrics {
            duration: Duration::from_micros(50), // Exceeds max
            memory_usage: 2048,                  // Exceeds max
            throughput: 500.0,                   // Below min
            cpu_usage: 50.0,
        };

        let result = checker.check_performance("test", &metrics);
        assert!(result.overall_score < 1.0);
    }

    #[test]
    fn test_growth_pattern_equality() {
        assert_eq!(GrowthPattern::Constant, GrowthPattern::Constant);
        assert_ne!(GrowthPattern::Constant, GrowthPattern::Logarithmic);
    }

    #[test]
    fn test_leak_sensitivity_equality() {
        assert_eq!(LeakSensitivity::Low, LeakSensitivity::Low);
        assert_ne!(LeakSensitivity::Low, LeakSensitivity::High);
    }

    #[test]
    fn test_access_type_equality() {
        assert_eq!(AccessType::Read, AccessType::Read);
        assert_ne!(AccessType::Read, AccessType::Write);
    }

    #[test]
    fn test_interaction_type_equality() {
        assert_eq!(InteractionType::SharedRead, InteractionType::SharedRead);
        assert_ne!(InteractionType::SharedRead, InteractionType::ExclusiveWrite);
    }

    #[test]
    fn test_sync_mechanism_equality() {
        assert_eq!(SyncMechanism::Mutex, SyncMechanism::Mutex);
        assert_ne!(SyncMechanism::Mutex, SyncMechanism::RwLock);
    }

    #[test]
    fn test_safety_property_equality() {
        assert_eq!(SafetyProperty::NoMemoryLeaks, SafetyProperty::NoMemoryLeaks);
        assert_ne!(SafetyProperty::NoMemoryLeaks, SafetyProperty::NoDataRaces);
    }

    #[test]
    fn test_performance_status_equality() {
        assert_eq!(PerformanceStatus::Optimal, PerformanceStatus::Optimal);
        assert_ne!(PerformanceStatus::Optimal, PerformanceStatus::Critical);
    }

    #[test]
    fn test_performance_issue_type_equality() {
        assert_eq!(PerformanceIssueType::Minor, PerformanceIssueType::Minor);
        assert_ne!(PerformanceIssueType::Minor, PerformanceIssueType::Major);
    }

    #[test]
    fn test_debug_implementations() {
        let benchmark = PerformanceBenchmark {
            operation: "test".to_string(),
            expected_duration: Duration::from_micros(10),
            max_duration: Duration::from_micros(50),
            expected_memory: 1024,
            max_memory: 2048,
            expected_throughput: 1000.0,
            min_throughput: 500.0,
        };

        let debug_str = format!("{:?}", benchmark);
        assert!(debug_str.contains("PerformanceBenchmark"));
    }
}