memscope_rs/quality/

analyzer.rs

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

/// Code quality analyzer for memory analysis operations
pub struct CodeAnalyzer {
    /// Quality metrics configuration
    config: AnalyzerConfig,
    /// Historical analysis data
    history: AnalysisHistory,
    /// Quality baselines
    baselines: HashMap<String, QualityBaseline>,
}

/// Configuration for code analysis
#[derive(Debug, Clone)]
pub struct AnalyzerConfig {
    /// Depth of analysis to perform
    pub analysis_depth: AnalysisDepth,
    /// Whether to track quality trends
    pub track_trends: bool,
    /// Maximum time to spend on analysis
    pub max_analysis_time: Duration,
    /// Quality thresholds
    pub thresholds: QualityThresholds,
}

/// Depth levels for code analysis
#[derive(Debug, Clone, PartialEq)]
pub enum AnalysisDepth {
    /// Basic quality checks only
    Surface,
    /// Standard analysis depth
    Standard,
    /// Comprehensive deep analysis
    Deep,
    /// Exhaustive analysis (slow)
    Exhaustive,
}

/// Quality thresholds for different metrics
#[derive(Debug, Clone)]
pub struct QualityThresholds {
    /// Minimum acceptable code quality score
    pub min_quality_score: f64,
    /// Maximum acceptable complexity
    pub max_complexity: u32,
    /// Minimum test coverage percentage
    pub min_coverage: f64,
    /// Maximum acceptable technical debt
    pub max_technical_debt: f64,
}

/// Historical analysis data
#[derive(Debug)]
struct AnalysisHistory {
    /// Previous analysis results
    results: Vec<AnalysisResult>,
    /// Maximum history entries to keep
    max_entries: usize,
}

/// Quality baseline for comparison
#[derive(Debug, Clone)]
pub struct QualityBaseline {
    /// Component name
    pub component: String,
    /// Baseline quality score
    pub quality_score: f64,
    /// Baseline complexity
    pub complexity: u32,
    /// Baseline performance metrics
    pub performance: BaselinePerformance,
    /// When baseline was established
    pub timestamp: Instant,
}

/// Baseline performance metrics
#[derive(Debug, Clone)]
pub struct BaselinePerformance {
    /// Average execution time
    pub avg_execution_time: Duration,
    /// Memory usage per operation
    pub memory_per_operation: usize,
    /// Error rate percentage
    pub error_rate: f64,
}

/// Comprehensive analysis report
#[derive(Debug, Clone)]
pub struct AnalysisReport {
    /// Component being analyzed
    pub component: String,
    /// Overall quality assessment
    pub quality_assessment: QualityAssessment,
    /// Individual quality metrics
    pub metrics: Vec<QualityMetric>,
    /// Detected issues
    pub issues: Vec<QualityIssue>,
    /// Performance analysis
    pub performance_analysis: PerformanceAnalysis,
    /// Recommendations for improvement
    pub recommendations: Vec<Recommendation>,
    /// Trend analysis if available
    pub trend_analysis: Option<TrendAnalysis>,
    /// Analysis execution time
    pub analysis_duration: Duration,
}

/// Overall quality assessment
#[derive(Debug, Clone)]
pub struct QualityAssessment {
    /// Overall quality score (0.0 to 1.0)
    pub overall_score: f64,
    /// Quality grade
    pub grade: QualityGrade,
    /// Assessment confidence level
    pub confidence: f64,
    /// Key strengths
    pub strengths: Vec<String>,
    /// Key weaknesses
    pub weaknesses: Vec<String>,
}

/// Quality grade classifications
#[derive(Debug, Clone, PartialEq)]
pub enum QualityGrade {
    /// Excellent quality (90-100%)
    A,
    /// Good quality (80-89%)
    B,
    /// Acceptable quality (70-79%)
    C,
    /// Poor quality (60-69%)
    D,
    /// Failing quality (<60%)
    F,
}

impl PartialOrd for QualityGrade {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        Some(self.cmp(other))
    }
}

impl Ord for QualityGrade {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        let self_score = match self {
            QualityGrade::A => 5,
            QualityGrade::B => 4,
            QualityGrade::C => 3,
            QualityGrade::D => 2,
            QualityGrade::F => 1,
        };
        let other_score = match other {
            QualityGrade::A => 5,
            QualityGrade::B => 4,
            QualityGrade::C => 3,
            QualityGrade::D => 2,
            QualityGrade::F => 1,
        };
        self_score.cmp(&other_score)
    }
}

impl Eq for QualityGrade {}

/// Individual quality metric
#[derive(Debug, Clone)]
pub struct QualityMetric {
    /// Metric name
    pub name: String,
    /// Metric category
    pub category: MetricCategory,
    /// Current value
    pub value: f64,
    /// Target value
    pub target: f64,
    /// Whether metric meets target
    pub meets_target: bool,
    /// Metric importance weight
    pub weight: f64,
    /// Trend direction
    pub trend: TrendDirection,
}

/// Categories of quality metrics
#[derive(Debug, Clone, PartialEq)]
pub enum MetricCategory {
    /// Performance metrics
    Performance,
    /// Reliability metrics
    Reliability,
    /// Maintainability metrics
    Maintainability,
    /// Security metrics
    Security,
    /// Efficiency metrics
    Efficiency,
}

/// Quality issue detected
#[derive(Debug, Clone)]
pub struct QualityIssue {
    /// Issue identifier
    pub id: String,
    /// Issue title
    pub title: String,
    /// Detailed description
    pub description: String,
    /// Issue severity
    pub severity: IssueSeverity,
    /// Issue category
    pub category: IssueCategory,
    /// Location in code
    pub location: Option<String>,
    /// Estimated fix effort
    pub fix_effort: FixEffort,
    /// Impact if not fixed
    pub impact: ImpactLevel,
}

/// Issue severity levels
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub enum IssueSeverity {
    /// Minor issue
    Minor,
    /// Moderate issue
    Moderate,
    /// Major issue
    Major,
    /// Critical issue
    Critical,
    /// Blocker issue
    Blocker,
}

/// Categories of quality issues
#[derive(Debug, Clone, PartialEq)]
pub enum IssueCategory {
    /// Memory management issues
    MemoryManagement,
    /// Performance problems
    Performance,
    /// Thread safety issues
    ThreadSafety,
    /// Error handling problems
    ErrorHandling,
    /// Code style violations
    CodeStyle,
    /// Design issues
    Design,
}

/// Estimated effort to fix issue
#[derive(Debug, Clone, PartialEq)]
pub enum FixEffort {
    /// Quick fix (< 1 hour)
    Trivial,
    /// Easy fix (1-4 hours)
    Easy,
    /// Medium fix (4-16 hours)
    Medium,
    /// Hard fix (16-40 hours)
    Hard,
    /// Very hard fix (> 40 hours)
    VeryHard,
}

/// Impact level if issue not fixed
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub enum ImpactLevel {
    /// Minimal impact
    Minimal,
    /// Low impact
    Low,
    /// Medium impact
    Medium,
    /// High impact
    High,
    /// Critical impact
    Critical,
}

/// Performance analysis results
#[derive(Debug, Clone)]
pub struct PerformanceAnalysis {
    /// Performance score (0.0 to 1.0)
    pub score: f64,
    /// Performance bottlenecks
    pub bottlenecks: Vec<PerformanceBottleneck>,
    /// Memory efficiency
    pub memory_efficiency: f64,
    /// CPU efficiency
    pub cpu_efficiency: f64,
    /// Scalability assessment
    pub scalability: ScalabilityAssessment,
}

/// Performance bottleneck information
#[derive(Debug, Clone)]
pub struct PerformanceBottleneck {
    /// Bottleneck location
    pub location: String,
    /// Type of bottleneck
    pub bottleneck_type: BottleneckType,
    /// Severity of bottleneck
    pub severity: f64,
    /// Description
    pub description: String,
    /// Suggested optimization
    pub optimization: String,
}

/// Types of performance bottlenecks
#[derive(Debug, Clone, PartialEq)]
pub enum BottleneckType {
    /// CPU intensive operation
    CpuBound,
    /// Memory allocation bottleneck
    MemoryBound,
    /// I/O bottleneck
    IoBound,
    /// Lock contention
    LockContention,
    /// Cache misses
    CacheMiss,
    /// Algorithm inefficiency
    AlgorithmInefficiency,
}

/// Scalability assessment
#[derive(Debug, Clone)]
pub struct ScalabilityAssessment {
    /// Scalability score (0.0 to 1.0)
    pub score: f64,
    /// Expected scaling behavior
    pub scaling_behavior: ScalingBehavior,
    /// Resource scaling factors
    pub resource_scaling: ResourceScaling,
    /// Scalability limitations
    pub limitations: Vec<String>,
}

/// Expected scaling behavior
#[derive(Debug, Clone, PartialEq)]
pub enum ScalingBehavior {
    /// Constant time complexity
    Constant,
    /// Linear scaling
    Linear,
    /// Logarithmic scaling
    Logarithmic,
    /// Quadratic scaling
    Quadratic,
    /// Exponential scaling (bad)
    Exponential,
}

/// Resource scaling characteristics
#[derive(Debug, Clone)]
pub struct ResourceScaling {
    /// Memory scaling factor
    pub memory_factor: f64,
    /// CPU scaling factor
    pub cpu_factor: f64,
    /// Network scaling factor
    pub network_factor: f64,
}

/// Improvement recommendation
#[derive(Debug, Clone)]
pub struct Recommendation {
    /// Recommendation title
    pub title: String,
    /// Detailed description
    pub description: String,
    /// Priority level
    pub priority: RecommendationPriority,
    /// Expected impact
    pub impact: ImpactLevel,
    /// Implementation effort
    pub effort: FixEffort,
    /// Related quality issues
    pub related_issues: Vec<String>,
}

/// Priority levels for recommendations
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub enum RecommendationPriority {
    /// Low priority
    Low,
    /// Medium priority
    Medium,
    /// High priority
    High,
    /// Critical priority
    Critical,
}

/// Trend analysis over time
#[derive(Debug, Clone)]
pub struct TrendAnalysis {
    /// Quality trend direction
    pub quality_trend: TrendDirection,
    /// Performance trend direction
    pub performance_trend: TrendDirection,
    /// Complexity trend direction
    pub complexity_trend: TrendDirection,
    /// Trend confidence level
    pub confidence: f64,
    /// Analysis time period
    pub time_period: Duration,
}

/// Trend direction indicators
#[derive(Debug, Clone, PartialEq)]
pub enum TrendDirection {
    /// Improving trend
    Improving,
    /// Stable trend
    Stable,
    /// Declining trend
    Declining,
    /// Unknown trend
    Unknown,
}

/// Analysis result for historical tracking
#[derive(Debug, Clone)]
struct AnalysisResult {
    /// Component analyzed
    component: String,
    /// Quality score achieved
    quality_score: f64,
    /// Analysis timestamp
    #[allow(dead_code)]
    timestamp: Instant,
    /// Key metrics
    #[allow(dead_code)]
    metrics: HashMap<String, f64>,
}

impl CodeAnalyzer {
    /// Create new code analyzer
    pub fn new() -> Self {
        Self {
            config: AnalyzerConfig::default(),
            history: AnalysisHistory {
                results: Vec::new(),
                max_entries: 100,
            },
            baselines: HashMap::new(),
        }
    }

    /// Create analyzer with custom configuration
    pub fn with_config(config: AnalyzerConfig) -> Self {
        Self {
            config,
            history: AnalysisHistory {
                results: Vec::new(),
                max_entries: 100,
            },
            baselines: HashMap::new(),
        }
    }

    /// Set quality baseline for component
    pub fn set_baseline(&mut self, component: &str, baseline: QualityBaseline) {
        self.baselines.insert(component.to_string(), baseline);
    }

    /// Analyze code quality for component
    pub fn analyze_quality(
        &mut self,
        component: &str,
        context: &AnalysisContext,
    ) -> AnalysisReport {
        let start_time = Instant::now();

        // Perform quality analysis
        let metrics = self.calculate_quality_metrics(context);
        let issues = self.detect_quality_issues(context);
        let performance_analysis = self.analyze_performance(context);
        let quality_assessment = self.assess_overall_quality(&metrics, &issues);
        let recommendations = self.generate_recommendations(&issues, &performance_analysis);
        let trend_analysis = if self.config.track_trends {
            Some(self.analyze_trends(component))
        } else {
            None
        };

        let analysis_duration = start_time.elapsed();

        // Store result in history
        self.store_analysis_result(component, &quality_assessment, &metrics);

        AnalysisReport {
            component: component.to_string(),
            quality_assessment,
            metrics,
            issues,
            performance_analysis,
            recommendations,
            trend_analysis,
            analysis_duration,
        }
    }

    fn calculate_quality_metrics(&self, context: &AnalysisContext) -> Vec<QualityMetric> {
        vec![
            // Performance metrics
            QualityMetric {
                name: "allocation_efficiency".to_string(),
                category: MetricCategory::Performance,
                value: context.performance_data.allocation_efficiency,
                target: 0.95,
                meets_target: context.performance_data.allocation_efficiency >= 0.95,
                weight: 0.3,
                trend: TrendDirection::Unknown,
            },
            // Reliability metrics
            QualityMetric {
                name: "error_rate".to_string(),
                category: MetricCategory::Reliability,
                value: context.reliability_data.error_rate,
                target: 0.01, // 1% max error rate
                meets_target: context.reliability_data.error_rate <= 0.01,
                weight: 0.25,
                trend: TrendDirection::Unknown,
            },
            // Memory efficiency
            QualityMetric {
                name: "memory_efficiency".to_string(),
                category: MetricCategory::Efficiency,
                value: context.memory_data.efficiency_ratio,
                target: 0.9,
                meets_target: context.memory_data.efficiency_ratio >= 0.9,
                weight: 0.2,
                trend: TrendDirection::Unknown,
            },
        ]
    }

    fn detect_quality_issues(&self, context: &AnalysisContext) -> Vec<QualityIssue> {
        let mut issues = Vec::new();

        // Check for memory leaks
        if context.memory_data.growth_rate > 1024.0 * 1024.0 {
            // 1MB/sec
            issues.push(QualityIssue {
                id: "memory_leak_detected".to_string(),
                title: "Potential Memory Leak".to_string(),
                description: format!(
                    "High memory growth rate: {:.2}MB/sec",
                    context.memory_data.growth_rate / (1024.0 * 1024.0)
                ),
                severity: IssueSeverity::Major,
                category: IssueCategory::MemoryManagement,
                location: Some("memory_tracking".to_string()),
                fix_effort: FixEffort::Medium,
                impact: ImpactLevel::High,
            });
        }

        // Check for performance issues
        if context.performance_data.avg_latency > Duration::from_micros(100) {
            issues.push(QualityIssue {
                id: "high_latency".to_string(),
                title: "High Operation Latency".to_string(),
                description: format!(
                    "Average latency {:.2}µs exceeds threshold",
                    context.performance_data.avg_latency.as_micros()
                ),
                severity: IssueSeverity::Moderate,
                category: IssueCategory::Performance,
                location: Some("allocation_tracking".to_string()),
                fix_effort: FixEffort::Easy,
                impact: ImpactLevel::Medium,
            });
        }

        issues
    }

    fn analyze_performance(&self, context: &AnalysisContext) -> PerformanceAnalysis {
        let bottlenecks = self.identify_bottlenecks(context);
        let memory_efficiency = context.memory_data.efficiency_ratio;
        let cpu_efficiency = 1.0 - (context.performance_data.cpu_usage / 100.0);

        let scalability = ScalabilityAssessment {
            score: 0.8, // Placeholder calculation
            scaling_behavior: ScalingBehavior::Linear,
            resource_scaling: ResourceScaling {
                memory_factor: 1.2,
                cpu_factor: 1.1,
                network_factor: 1.0,
            },
            limitations: vec!["Memory bandwidth may become bottleneck at scale".to_string()],
        };

        let score = (memory_efficiency + cpu_efficiency + scalability.score) / 3.0;

        PerformanceAnalysis {
            score,
            bottlenecks,
            memory_efficiency,
            cpu_efficiency,
            scalability,
        }
    }

    fn identify_bottlenecks(&self, context: &AnalysisContext) -> Vec<PerformanceBottleneck> {
        let mut bottlenecks = Vec::new();

        if context.performance_data.cpu_usage > 80.0 {
            bottlenecks.push(PerformanceBottleneck {
                location: "allocation_tracking".to_string(),
                bottleneck_type: BottleneckType::CpuBound,
                severity: context.performance_data.cpu_usage / 100.0,
                description: "High CPU usage in allocation tracking".to_string(),
                optimization: "Consider optimizing hot paths or using faster data structures"
                    .to_string(),
            });
        }

        if context.memory_data.fragmentation_ratio > 0.3 {
            bottlenecks.push(PerformanceBottleneck {
                location: "memory_management".to_string(),
                bottleneck_type: BottleneckType::MemoryBound,
                severity: context.memory_data.fragmentation_ratio,
                description: "High memory fragmentation".to_string(),
                optimization: "Implement memory compaction or use memory pools".to_string(),
            });
        }

        bottlenecks
    }

    fn assess_overall_quality(
        &self,
        metrics: &[QualityMetric],
        issues: &[QualityIssue],
    ) -> QualityAssessment {
        // Calculate weighted quality score
        let weighted_score: f64 = metrics
            .iter()
            .map(|m| {
                if m.meets_target {
                    m.weight
                } else {
                    m.weight * (m.value / m.target)
                }
            })
            .sum();

        let total_weight: f64 = metrics.iter().map(|m| m.weight).sum();
        let overall_score = if total_weight > 0.0 {
            weighted_score / total_weight
        } else {
            0.0
        };

        // Apply penalty for critical issues
        let critical_penalty = issues
            .iter()
            .filter(|i| i.severity >= IssueSeverity::Critical)
            .count() as f64
            * 0.1;

        let adjusted_score = (overall_score - critical_penalty).max(0.0);

        let grade = match adjusted_score {
            s if s >= 0.9 => QualityGrade::A,
            s if s >= 0.8 => QualityGrade::B,
            s if s >= 0.7 => QualityGrade::C,
            s if s >= 0.6 => QualityGrade::D,
            _ => QualityGrade::F,
        };

        let strengths = metrics
            .iter()
            .filter(|m| m.meets_target && m.value > m.target * 1.1)
            .map(|m| format!("Excellent {}", m.name))
            .collect();

        let weaknesses = issues
            .iter()
            .filter(|i| i.severity >= IssueSeverity::Major)
            .map(|i| i.title.clone())
            .collect();

        QualityAssessment {
            overall_score: adjusted_score,
            grade,
            confidence: 0.85, // Based on analysis depth and data quality
            strengths,
            weaknesses,
        }
    }

    fn generate_recommendations(
        &self,
        issues: &[QualityIssue],
        performance: &PerformanceAnalysis,
    ) -> Vec<Recommendation> {
        let mut recommendations = Vec::new();

        // Recommendations based on issues
        for issue in issues {
            if issue.severity >= IssueSeverity::Major {
                recommendations.push(Recommendation {
                    title: format!("Fix {}", issue.title),
                    description: format!("Address {} to improve quality", issue.description),
                    priority: match issue.severity {
                        IssueSeverity::Critical | IssueSeverity::Blocker => {
                            RecommendationPriority::Critical
                        }
                        IssueSeverity::Major => RecommendationPriority::High,
                        _ => RecommendationPriority::Medium,
                    },
                    impact: issue.impact.clone(),
                    effort: issue.fix_effort.clone(),
                    related_issues: vec![issue.id.clone()],
                });
            }
        }

        // Performance-based recommendations
        if performance.score < 0.8 {
            recommendations.push(Recommendation {
                title: "Improve Performance".to_string(),
                description: "Overall performance score is below target".to_string(),
                priority: RecommendationPriority::High,
                impact: ImpactLevel::High,
                effort: FixEffort::Medium,
                related_issues: vec![],
            });
        }

        recommendations
    }

    fn analyze_trends(&self, component: &str) -> TrendAnalysis {
        let recent_results: Vec<_> = self
            .history
            .results
            .iter()
            .filter(|r| r.component == component)
            .rev()
            .take(10)
            .collect();

        if recent_results.len() < 3 {
            return TrendAnalysis {
                quality_trend: TrendDirection::Unknown,
                performance_trend: TrendDirection::Unknown,
                complexity_trend: TrendDirection::Unknown,
                confidence: 0.0,
                time_period: Duration::ZERO,
            };
        }

        // Simple trend analysis based on score progression
        let scores: Vec<f64> = recent_results.iter().map(|r| r.quality_score).collect();
        let quality_trend = if scores.first() > scores.last() {
            TrendDirection::Improving
        } else if scores.first() < scores.last() {
            TrendDirection::Declining
        } else {
            TrendDirection::Stable
        };

        TrendAnalysis {
            quality_trend,
            performance_trend: TrendDirection::Stable,
            complexity_trend: TrendDirection::Stable,
            confidence: 0.7,
            time_period: Duration::from_secs(3600), // 1 hour window
        }
    }

    fn store_analysis_result(
        &mut self,
        component: &str,
        assessment: &QualityAssessment,
        metrics: &[QualityMetric],
    ) {
        let mut metric_map = HashMap::new();
        for metric in metrics {
            metric_map.insert(metric.name.clone(), metric.value);
        }

        let result = AnalysisResult {
            component: component.to_string(),
            quality_score: assessment.overall_score,
            timestamp: Instant::now(),
            metrics: metric_map,
        };

        self.history.results.push(result);

        // Trim history if too large
        if self.history.results.len() > self.history.max_entries {
            self.history
                .results
                .drain(0..self.history.results.len() - self.history.max_entries);
        }
    }
}

/// Context data for quality analysis
#[derive(Debug)]
pub struct AnalysisContext {
    /// Performance measurement data
    pub performance_data: PerformanceData,
    /// Memory usage data
    pub memory_data: MemoryData,
    /// Reliability measurement data
    pub reliability_data: ReliabilityData,
}

/// Performance measurement data
#[derive(Debug)]
pub struct PerformanceData {
    /// Average operation latency
    pub avg_latency: Duration,
    /// CPU usage percentage
    pub cpu_usage: f64,
    /// Allocation efficiency ratio
    pub allocation_efficiency: f64,
    /// Throughput (operations per second)
    pub throughput: f64,
}

/// Memory usage data
#[derive(Debug)]
pub struct MemoryData {
    /// Current memory usage
    pub current_usage: usize,
    /// Memory growth rate (bytes per second)
    pub growth_rate: f64,
    /// Memory efficiency ratio
    pub efficiency_ratio: f64,
    /// Memory fragmentation ratio
    pub fragmentation_ratio: f64,
}

/// Reliability measurement data
#[derive(Debug)]
pub struct ReliabilityData {
    /// Error rate percentage
    pub error_rate: f64,
    /// Success rate percentage
    pub success_rate: f64,
    /// Mean time between failures
    pub mtbf: Duration,
}

impl Default for AnalyzerConfig {
    fn default() -> Self {
        Self {
            analysis_depth: AnalysisDepth::Standard,
            track_trends: true,
            max_analysis_time: Duration::from_secs(30),
            thresholds: QualityThresholds::default(),
        }
    }
}

impl Default for QualityThresholds {
    fn default() -> Self {
        Self {
            min_quality_score: 0.8,
            max_complexity: 10,
            min_coverage: 0.8,
            max_technical_debt: 0.2,
        }
    }
}

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

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

    #[test]
    fn test_code_analyzer_creation() {
        let analyzer = CodeAnalyzer::new();
        assert_eq!(analyzer.config.analysis_depth, AnalysisDepth::Standard);
        assert!(analyzer.config.track_trends);
    }

    #[test]
    fn test_quality_assessment() {
        let analyzer = CodeAnalyzer::new();

        let metrics = vec![QualityMetric {
            name: "test_metric".to_string(),
            category: MetricCategory::Performance,
            value: 0.9,
            target: 0.8,
            meets_target: true,
            weight: 1.0,
            trend: TrendDirection::Stable,
        }];

        let issues = vec![];
        let assessment = analyzer.assess_overall_quality(&metrics, &issues);

        assert!(assessment.overall_score >= 0.8);
        assert_eq!(assessment.grade, QualityGrade::A);
    }

    #[test]
    fn test_quality_grades() {
        assert!(QualityGrade::A > QualityGrade::B);
        assert!(QualityGrade::B > QualityGrade::C);
        assert!(QualityGrade::F < QualityGrade::D);
    }
}