quantrs2_anneal/advanced_testing_framework/
analytics.rs

1//! Test result analytics and reporting
2
3use super::{
4    AnalyticsEngineType, AnalyticsOutputFormat, ApplicationResult, ChartType, ConditionOperator,
5    ConditionType, Duration, FailurePatternType, HashMap, Instant, PlatformTestResult,
6    PropertyTestResult, PropertyValue, RegressionTestResult, RenderingEngineType, ReportFormat,
7    RetentionPolicy, ScenarioTestResult, StressTestResult, TestErrorType, TestExecutionResult,
8    TestSuiteResults, TrendDirection, VecDeque,
9};
10
11use std::fmt::Write;
12/// Test result analytics
13#[derive(Debug)]
14pub struct TestAnalytics {
15    /// Result database
16    pub result_database: TestResultDatabase,
17    /// Analytics engines
18    pub analytics_engines: Vec<AnalyticsEngine>,
19    /// Report generators
20    pub report_generators: Vec<ReportGenerator>,
21    /// Visualization tools
22    pub visualization_tools: Vec<VisualizationTool>,
23}
24
25/// Test result database
26#[derive(Debug)]
27pub struct TestResultDatabase {
28    /// Execution records
29    pub execution_records: HashMap<String, Vec<TestExecutionRecord>>,
30    /// Performance trends
31    pub performance_trends: HashMap<String, PerformanceTrend>,
32    /// Failure patterns
33    pub failure_patterns: HashMap<String, FailurePattern>,
34    /// Database statistics
35    pub statistics: DatabaseStatistics,
36}
37
38/// Test execution record
39#[derive(Debug, Clone)]
40pub struct TestExecutionRecord {
41    /// Record identifier
42    pub id: String,
43    /// Test identifier
44    pub test_id: String,
45    /// Execution timestamp
46    pub timestamp: Instant,
47    /// Execution result
48    pub result: TestExecutionResult,
49    /// Test configuration
50    pub config: HashMap<String, String>,
51    /// Environment information
52    pub environment: HashMap<String, String>,
53}
54
55/// Performance trend analysis
56#[derive(Debug)]
57pub struct PerformanceTrend {
58    /// Metric being tracked
59    pub metric: String,
60    /// Trend direction
61    pub trend_direction: TrendDirection,
62    /// Trend magnitude
63    pub trend_magnitude: f64,
64    /// Confidence level
65    pub confidence: f64,
66    /// Data points
67    pub data_points: VecDeque<(Instant, f64)>,
68}
69
70/// Failure pattern analysis
71#[derive(Debug)]
72pub struct FailurePattern {
73    /// Pattern identifier
74    pub id: String,
75    /// Pattern type
76    pub pattern_type: FailurePatternType,
77    /// Occurrence frequency
78    pub frequency: f64,
79    /// Pattern conditions
80    pub conditions: Vec<PatternCondition>,
81    /// Associated failures
82    pub failures: Vec<FailureInstance>,
83}
84
85/// Conditions for pattern matching
86#[derive(Debug, Clone)]
87pub struct PatternCondition {
88    /// Condition type
89    pub condition_type: ConditionType,
90    /// Condition value
91    pub value: PropertyValue,
92    /// Condition operator
93    pub operator: ConditionOperator,
94}
95
96/// Instance of failure occurrence
97#[derive(Debug, Clone)]
98pub struct FailureInstance {
99    /// Failure timestamp
100    pub timestamp: Instant,
101    /// Test identifier
102    pub test_id: String,
103    /// Failure details
104    pub details: TestError,
105    /// Context information
106    pub context: HashMap<String, String>,
107}
108
109/// Test error information
110#[derive(Debug, Clone)]
111pub struct TestError {
112    /// Error type
113    pub error_type: TestErrorType,
114    /// Error message
115    pub message: String,
116    /// Error code
117    pub code: Option<i32>,
118    /// Error location
119    pub location: Option<String>,
120    /// Stack trace
121    pub stack_trace: Option<String>,
122}
123
124/// Database statistics
125#[derive(Debug, Clone)]
126pub struct DatabaseStatistics {
127    /// Total test executions
128    pub total_executions: usize,
129    /// Success rate
130    pub success_rate: f64,
131    /// Average execution time
132    pub avg_execution_time: Duration,
133    /// Data retention policy
134    pub retention_policy: RetentionPolicy,
135}
136
137/// Analytics engine for test data
138#[derive(Debug)]
139pub struct AnalyticsEngine {
140    /// Engine identifier
141    pub id: String,
142    /// Engine type
143    pub engine_type: AnalyticsEngineType,
144    /// Analysis algorithms
145    pub algorithms: Vec<AnalysisAlgorithm>,
146    /// Output format
147    pub output_format: AnalyticsOutputFormat,
148}
149
150/// Analysis algorithm
151#[derive(Debug)]
152pub struct AnalysisAlgorithm {
153    /// Algorithm identifier
154    pub id: String,
155    /// Algorithm type
156    pub algorithm_type: String,
157    /// Algorithm parameters
158    pub parameters: HashMap<String, f64>,
159    /// Required input data types
160    pub input_types: Vec<String>,
161}
162
163/// Report generator
164#[derive(Debug)]
165pub struct ReportGenerator {
166    /// Generator identifier
167    pub id: String,
168    /// Report type
169    pub report_type: ReportType,
170    /// Template configuration
171    pub template_config: ReportTemplate,
172    /// Output format
173    pub output_format: ReportFormat,
174}
175
176/// Report types
177#[derive(Debug, Clone, PartialEq, Eq)]
178pub enum ReportType {
179    /// Performance summary
180    PerformanceSummary,
181    /// Failure analysis
182    FailureAnalysis,
183    /// Trend analysis
184    TrendAnalysis,
185    /// Comparison report
186    Comparison,
187    /// Custom report
188    Custom(String),
189}
190
191/// Report template
192#[derive(Debug)]
193pub struct ReportTemplate {
194    /// Template identifier
195    pub id: String,
196    /// Template content
197    pub content: String,
198    /// Template variables
199    pub variables: HashMap<String, String>,
200    /// Styling configuration
201    pub styling: ReportStyling,
202}
203
204/// Report styling configuration
205#[derive(Debug)]
206pub struct ReportStyling {
207    /// Color scheme
208    pub color_scheme: String,
209    /// Font configuration
210    pub font_config: HashMap<String, String>,
211    /// Layout settings
212    pub layout_settings: HashMap<String, String>,
213}
214
215/// Visualization tool
216#[derive(Debug)]
217pub struct VisualizationTool {
218    /// Tool identifier
219    pub id: String,
220    /// Chart types supported
221    pub supported_charts: Vec<ChartType>,
222    /// Rendering engine
223    pub rendering_engine: RenderingEngine,
224    /// Interactive features
225    pub interactive_features: Vec<InteractiveFeature>,
226}
227
228/// Rendering engine configuration
229#[derive(Debug)]
230pub struct RenderingEngine {
231    /// Engine type
232    pub engine_type: RenderingEngineType,
233    /// Configuration parameters
234    pub config: HashMap<String, String>,
235    /// Performance settings
236    pub performance_settings: HashMap<String, f64>,
237}
238
239/// Interactive features for visualizations
240#[derive(Debug, Clone, PartialEq, Eq)]
241pub enum InteractiveFeature {
242    /// Zoom functionality
243    Zoom,
244    /// Pan functionality
245    Pan,
246    /// Hover tooltips
247    Tooltips,
248    /// Drill-down capability
249    DrillDown,
250    /// Data filtering
251    Filtering,
252    /// Export functionality
253    Export,
254}
255
256impl TestAnalytics {
257    #[must_use]
258    pub fn new() -> Self {
259        Self {
260            result_database: TestResultDatabase {
261                execution_records: HashMap::new(),
262                performance_trends: HashMap::new(),
263                failure_patterns: HashMap::new(),
264                statistics: DatabaseStatistics {
265                    total_executions: 0,
266                    success_rate: 0.0,
267                    avg_execution_time: Duration::default(),
268                    retention_policy: RetentionPolicy {
269                        retention_period: Duration::from_secs(30 * 24 * 3600),
270                        cleanup_frequency: Duration::from_secs(7 * 24 * 3600),
271                        archive_policy: None,
272                    },
273                },
274            },
275            analytics_engines: Self::create_default_engines(),
276            report_generators: Self::create_default_generators(),
277            visualization_tools: Self::create_default_visualization_tools(),
278        }
279    }
280
281    /// Create default analytics engines
282    fn create_default_engines() -> Vec<AnalyticsEngine> {
283        vec![
284            AnalyticsEngine {
285                id: "statistical_analyzer".to_string(),
286                engine_type: AnalyticsEngineType::Statistical,
287                algorithms: vec![
288                    AnalysisAlgorithm {
289                        id: "descriptive_stats".to_string(),
290                        algorithm_type: "descriptive_statistics".to_string(),
291                        parameters: HashMap::new(),
292                        input_types: vec!["numerical".to_string()],
293                    },
294                    AnalysisAlgorithm {
295                        id: "correlation_analysis".to_string(),
296                        algorithm_type: "correlation".to_string(),
297                        parameters: HashMap::new(),
298                        input_types: vec!["time_series".to_string()],
299                    },
300                ],
301                output_format: AnalyticsOutputFormat::JSON,
302            },
303            AnalyticsEngine {
304                id: "trend_analyzer".to_string(),
305                engine_type: AnalyticsEngineType::TimeSeries,
306                algorithms: vec![AnalysisAlgorithm {
307                    id: "trend_detection".to_string(),
308                    algorithm_type: "linear_regression".to_string(),
309                    parameters: {
310                        let mut params = HashMap::new();
311                        params.insert("window_size".to_string(), 30.0);
312                        params
313                    },
314                    input_types: vec!["time_series".to_string()],
315                }],
316                output_format: AnalyticsOutputFormat::CSV,
317            },
318            AnalyticsEngine {
319                id: "pattern_recognizer".to_string(),
320                engine_type: AnalyticsEngineType::PatternRecognition,
321                algorithms: vec![AnalysisAlgorithm {
322                    id: "failure_clustering".to_string(),
323                    algorithm_type: "k_means".to_string(),
324                    parameters: {
325                        let mut params = HashMap::new();
326                        params.insert("num_clusters".to_string(), 5.0);
327                        params
328                    },
329                    input_types: vec!["failure_data".to_string()],
330                }],
331                output_format: AnalyticsOutputFormat::JSON,
332            },
333        ]
334    }
335
336    /// Create default report generators
337    fn create_default_generators() -> Vec<ReportGenerator> {
338        vec![
339            ReportGenerator {
340                id: "performance_reporter".to_string(),
341                report_type: ReportType::PerformanceSummary,
342                template_config: ReportTemplate {
343                    id: "performance_template".to_string(),
344                    content:
345                        "# Performance Summary\n\n{{performance_metrics}}\n\n{{trend_analysis}}"
346                            .to_string(),
347                    variables: HashMap::new(),
348                    styling: ReportStyling {
349                        color_scheme: "blue".to_string(),
350                        font_config: HashMap::new(),
351                        layout_settings: HashMap::new(),
352                    },
353                },
354                output_format: ReportFormat::HTML,
355            },
356            ReportGenerator {
357                id: "failure_reporter".to_string(),
358                report_type: ReportType::FailureAnalysis,
359                template_config: ReportTemplate {
360                    id: "failure_template".to_string(),
361                    content: "# Failure Analysis\n\n{{failure_patterns}}\n\n{{recommendations}}"
362                        .to_string(),
363                    variables: HashMap::new(),
364                    styling: ReportStyling {
365                        color_scheme: "red".to_string(),
366                        font_config: HashMap::new(),
367                        layout_settings: HashMap::new(),
368                    },
369                },
370                output_format: ReportFormat::PDF,
371            },
372        ]
373    }
374
375    /// Create default visualization tools
376    fn create_default_visualization_tools() -> Vec<VisualizationTool> {
377        vec![
378            VisualizationTool {
379                id: "chart_generator".to_string(),
380                supported_charts: vec![
381                    ChartType::Line,
382                    ChartType::Bar,
383                    ChartType::Scatter,
384                    ChartType::Histogram,
385                ],
386                rendering_engine: RenderingEngine {
387                    engine_type: RenderingEngineType::SVG,
388                    config: HashMap::new(),
389                    performance_settings: HashMap::new(),
390                },
391                interactive_features: vec![
392                    InteractiveFeature::Zoom,
393                    InteractiveFeature::Tooltips,
394                    InteractiveFeature::Export,
395                ],
396            },
397            VisualizationTool {
398                id: "heatmap_generator".to_string(),
399                supported_charts: vec![ChartType::Heatmap],
400                rendering_engine: RenderingEngine {
401                    engine_type: RenderingEngineType::Canvas,
402                    config: HashMap::new(),
403                    performance_settings: HashMap::new(),
404                },
405                interactive_features: vec![
406                    InteractiveFeature::Tooltips,
407                    InteractiveFeature::DrillDown,
408                ],
409            },
410        ]
411    }
412
413    /// Process test results
414    pub fn process_test_results(&mut self, results: &TestSuiteResults) -> ApplicationResult<()> {
415        println!("Processing test results for analytics");
416
417        // Process scenario results
418        for scenario_result in &results.scenario_results {
419            self.process_scenario_result(scenario_result)?;
420        }
421
422        // Process regression results
423        for regression_result in &results.regression_results {
424            self.process_regression_result(regression_result)?;
425        }
426
427        // Process platform results
428        for platform_result in &results.platform_results {
429            self.process_platform_result(platform_result)?;
430        }
431
432        // Process stress results
433        for stress_result in &results.stress_results {
434            self.process_stress_result(stress_result)?;
435        }
436
437        // Process property results
438        for property_result in &results.property_results {
439            self.process_property_result(property_result)?;
440        }
441
442        // Update database statistics
443        self.update_database_statistics()?;
444
445        // Analyze trends and patterns
446        self.analyze_trends_and_patterns()?;
447
448        Ok(())
449    }
450
451    /// Process scenario test result
452    fn process_scenario_result(&mut self, result: &ScenarioTestResult) -> ApplicationResult<()> {
453        let record = TestExecutionRecord {
454            id: format!(
455                "scenario_{}_{}",
456                result.scenario_id,
457                Instant::now().elapsed().as_nanos()
458            ),
459            test_id: result.scenario_id.clone(),
460            timestamp: Instant::now(),
461            result: result.test_result.clone(),
462            config: HashMap::new(),
463            environment: HashMap::new(),
464        };
465
466        self.result_database
467            .execution_records
468            .entry(result.scenario_id.clone())
469            .or_insert_with(Vec::new)
470            .push(record);
471
472        Ok(())
473    }
474
475    /// Process regression test result
476    fn process_regression_result(
477        &mut self,
478        result: &RegressionTestResult,
479    ) -> ApplicationResult<()> {
480        if result.regression_detected {
481            // Record as potential failure pattern
482            let failure = FailureInstance {
483                timestamp: Instant::now(),
484                test_id: result.test_id.clone(),
485                details: TestError {
486                    error_type: TestErrorType::RuntimeError,
487                    message: "Performance regression detected".to_string(),
488                    code: None,
489                    location: None,
490                    stack_trace: None,
491                },
492                context: {
493                    let mut context = HashMap::new();
494                    context.insert("confidence".to_string(), result.confidence.to_string());
495                    context.insert("p_value".to_string(), result.p_value.to_string());
496                    context
497                },
498            };
499
500            let pattern_id = format!("regression_{}", result.test_id);
501            let pattern = self
502                .result_database
503                .failure_patterns
504                .entry(pattern_id.clone())
505                .or_insert_with(|| FailurePattern {
506                    id: pattern_id,
507                    pattern_type: FailurePatternType::Temporal,
508                    frequency: 0.0,
509                    conditions: Vec::new(),
510                    failures: Vec::new(),
511                });
512
513            pattern.failures.push(failure);
514            pattern.frequency = pattern.failures.len() as f64;
515        }
516
517        Ok(())
518    }
519
520    /// Process platform test result
521    fn process_platform_result(&mut self, result: &PlatformTestResult) -> ApplicationResult<()> {
522        // Store platform compatibility data
523        let record_id = format!(
524            "platform_{}_{}",
525            result.platform_id,
526            Instant::now().elapsed().as_nanos()
527        );
528
529        // Create a synthetic execution result for platform test
530        let execution_result = TestExecutionResult {
531            solution_quality: result.compatibility_score,
532            execution_time: Duration::from_secs(1),
533            final_energy: -result.compatibility_score,
534            best_solution: vec![1],
535            convergence_achieved: result.compatibility_score > 0.9,
536            memory_used: 1024,
537        };
538
539        let record = TestExecutionRecord {
540            id: record_id,
541            test_id: result.platform_id.clone(),
542            timestamp: Instant::now(),
543            result: execution_result,
544            config: HashMap::new(),
545            environment: {
546                let mut env = HashMap::new();
547                env.insert("test_type".to_string(), "platform_validation".to_string());
548                env.insert(
549                    "compatibility_score".to_string(),
550                    result.compatibility_score.to_string(),
551                );
552                env
553            },
554        };
555
556        self.result_database
557            .execution_records
558            .entry(result.platform_id.clone())
559            .or_insert_with(Vec::new)
560            .push(record);
561
562        Ok(())
563    }
564
565    /// Process stress test result
566    fn process_stress_result(&mut self, result: &StressTestResult) -> ApplicationResult<()> {
567        let record_id = format!(
568            "stress_{}_{}",
569            result.test_id,
570            Instant::now().elapsed().as_nanos()
571        );
572
573        let execution_result = TestExecutionResult {
574            solution_quality: result.success_rate,
575            execution_time: Duration::from_secs(60), // Simplified
576            final_energy: -result.success_rate,
577            best_solution: vec![1],
578            convergence_achieved: result.success_rate > 0.9,
579            memory_used: 2048,
580        };
581
582        let record = TestExecutionRecord {
583            id: record_id,
584            test_id: result.test_id.clone(),
585            timestamp: Instant::now(),
586            result: execution_result,
587            config: HashMap::new(),
588            environment: {
589                let mut env = HashMap::new();
590                env.insert("test_type".to_string(), "stress_test".to_string());
591                env.insert("max_load".to_string(), result.max_load.to_string());
592                env.insert("throughput".to_string(), result.throughput.to_string());
593                env
594            },
595        };
596
597        self.result_database
598            .execution_records
599            .entry(result.test_id.clone())
600            .or_insert_with(Vec::new)
601            .push(record);
602
603        Ok(())
604    }
605
606    /// Process property test result
607    fn process_property_result(&mut self, result: &PropertyTestResult) -> ApplicationResult<()> {
608        let record_id = format!(
609            "property_{}_{}",
610            result.property_id,
611            Instant::now().elapsed().as_nanos()
612        );
613
614        let execution_result = TestExecutionResult {
615            solution_quality: result.confidence,
616            execution_time: result.execution_time,
617            final_energy: -result.confidence,
618            best_solution: vec![1],
619            convergence_achieved: result.confidence > 0.95,
620            memory_used: 512,
621        };
622
623        let record = TestExecutionRecord {
624            id: record_id,
625            test_id: result.property_id.clone(),
626            timestamp: Instant::now(),
627            result: execution_result,
628            config: HashMap::new(),
629            environment: {
630                let mut env = HashMap::new();
631                env.insert("test_type".to_string(), "property_test".to_string());
632                env.insert("cases_tested".to_string(), result.cases_tested.to_string());
633                env.insert("cases_passed".to_string(), result.cases_passed.to_string());
634                env
635            },
636        };
637
638        self.result_database
639            .execution_records
640            .entry(result.property_id.clone())
641            .or_insert_with(Vec::new)
642            .push(record);
643
644        Ok(())
645    }
646
647    /// Update database statistics
648    fn update_database_statistics(&mut self) -> ApplicationResult<()> {
649        let mut total_executions = 0;
650        let mut successful_executions = 0;
651        let mut total_time = Duration::default();
652
653        for records in self.result_database.execution_records.values() {
654            for record in records {
655                total_executions += 1;
656                total_time += record.result.execution_time;
657
658                if record.result.convergence_achieved {
659                    successful_executions += 1;
660                }
661            }
662        }
663
664        self.result_database.statistics.total_executions = total_executions;
665        self.result_database.statistics.success_rate = if total_executions > 0 {
666            f64::from(successful_executions) / total_executions as f64
667        } else {
668            0.0
669        };
670
671        self.result_database.statistics.avg_execution_time = if total_executions > 0 {
672            total_time / total_executions as u32
673        } else {
674            Duration::default()
675        };
676
677        Ok(())
678    }
679
680    /// Analyze trends and patterns
681    fn analyze_trends_and_patterns(&mut self) -> ApplicationResult<()> {
682        // Analyze performance trends for each test type
683        for (test_id, records) in &self.result_database.execution_records {
684            if records.len() >= 5 {
685                // Need minimum data points
686                let trend = self.calculate_performance_trend(test_id, records)?;
687                self.result_database
688                    .performance_trends
689                    .insert(test_id.clone(), trend);
690            }
691        }
692
693        // Analyze failure patterns
694        self.analyze_failure_patterns()?;
695
696        Ok(())
697    }
698
699    /// Calculate performance trend
700    fn calculate_performance_trend(
701        &self,
702        test_id: &str,
703        records: &[TestExecutionRecord],
704    ) -> ApplicationResult<PerformanceTrend> {
705        let mut data_points = VecDeque::new();
706
707        // Extract quality data points
708        for record in records.iter().rev().take(50) {
709            // Last 50 records
710            data_points.push_back((record.timestamp, record.result.solution_quality));
711        }
712
713        // Simple trend analysis
714        let values: Vec<f64> = data_points.iter().map(|(_, v)| *v).collect();
715        let n = values.len() as f64;
716
717        if n < 2.0 {
718            return Ok(PerformanceTrend {
719                metric: "solution_quality".to_string(),
720                trend_direction: TrendDirection::Stable,
721                trend_magnitude: 0.0,
722                confidence: 0.0,
723                data_points,
724            });
725        }
726
727        // Calculate linear trend
728        let x_sum = (0..values.len()).map(|i| i as f64).sum::<f64>();
729        let y_sum = values.iter().sum::<f64>();
730        let xy_sum = values
731            .iter()
732            .enumerate()
733            .map(|(i, &y)| i as f64 * y)
734            .sum::<f64>();
735        let x2_sum = (0..values.len()).map(|i| (i as f64).powi(2)).sum::<f64>();
736
737        let slope = n.mul_add(xy_sum, -(x_sum * y_sum)) / x_sum.mul_add(-x_sum, n * x2_sum);
738
739        let trend_direction = if slope > 0.01 {
740            TrendDirection::Improving
741        } else if slope < -0.01 {
742            TrendDirection::Degrading
743        } else {
744            TrendDirection::Stable
745        };
746
747        Ok(PerformanceTrend {
748            metric: "solution_quality".to_string(),
749            trend_direction,
750            trend_magnitude: slope.abs(),
751            confidence: 0.8, // Simplified
752            data_points,
753        })
754    }
755
756    /// Analyze failure patterns
757    fn analyze_failure_patterns(&mut self) -> ApplicationResult<()> {
758        // Update frequency for existing patterns
759        for pattern in self.result_database.failure_patterns.values_mut() {
760            // Calculate recent frequency (last 30 days)
761            let cutoff = Instant::now()
762                .checked_sub(Duration::from_secs(30 * 24 * 3600))
763                .unwrap_or_else(Instant::now);
764            let recent_failures = pattern
765                .failures
766                .iter()
767                .filter(|f| f.timestamp > cutoff)
768                .count();
769
770            pattern.frequency = recent_failures as f64;
771        }
772
773        Ok(())
774    }
775
776    /// Generate reports
777    pub fn generate_reports(&mut self) -> ApplicationResult<()> {
778        println!("Generating test reports");
779
780        for generator in &self.report_generators {
781            let report = self.generate_report_with_generator(generator)?;
782            println!(
783                "Generated {:?} report: {} bytes",
784                generator.report_type,
785                report.len()
786            );
787        }
788
789        Ok(())
790    }
791
792    /// Generate report with specific generator
793    fn generate_report_with_generator(
794        &self,
795        generator: &ReportGenerator,
796    ) -> ApplicationResult<String> {
797        match generator.report_type {
798            ReportType::PerformanceSummary => self.generate_performance_summary(),
799            ReportType::FailureAnalysis => self.generate_failure_analysis(),
800            ReportType::TrendAnalysis => self.generate_trend_analysis(),
801            _ => Ok("Report type not implemented".to_string()),
802        }
803    }
804
805    /// Generate performance summary report
806    fn generate_performance_summary(&self) -> ApplicationResult<String> {
807        let mut report = String::new();
808        report.push_str("# Performance Summary Report\n\n");
809
810        // Overall statistics
811        let _ = writeln!(report, "## Overall Statistics\n- Total Executions: {}\n- Success Rate: {:.2}%\n- Average Execution Time: {:?}\n",
812            self.result_database.statistics.total_executions,
813            self.result_database.statistics.success_rate * 100.0,
814            self.result_database.statistics.avg_execution_time);
815
816        // Performance by test type
817        report.push_str("## Performance by Test Type\n");
818        for (test_id, records) in &self.result_database.execution_records {
819            if !records.is_empty() {
820                let avg_quality = records
821                    .iter()
822                    .map(|r| r.result.solution_quality)
823                    .sum::<f64>()
824                    / records.len() as f64;
825
826                let _ = write!(
827                    report,
828                    "- {}: {:.3} average quality ({} executions)\n",
829                    test_id,
830                    avg_quality,
831                    records.len()
832                );
833            }
834        }
835
836        report.push_str("\n");
837
838        // Trend analysis
839        if !self.result_database.performance_trends.is_empty() {
840            report.push_str("## Performance Trends\n");
841            for (test_id, trend) in &self.result_database.performance_trends {
842                let _ = write!(
843                    report,
844                    "- {}: {:?} trend (magnitude: {:.4})\n",
845                    test_id, trend.trend_direction, trend.trend_magnitude
846                );
847            }
848        }
849
850        Ok(report)
851    }
852
853    /// Generate failure analysis report
854    fn generate_failure_analysis(&self) -> ApplicationResult<String> {
855        let mut report = String::new();
856        report.push_str("# Failure Analysis Report\n\n");
857
858        if self.result_database.failure_patterns.is_empty() {
859            report.push_str("No failure patterns detected.\n");
860            return Ok(report);
861        }
862
863        report.push_str("## Detected Failure Patterns\n");
864        for pattern in self.result_database.failure_patterns.values() {
865            let _ = write!(
866                report,
867                "### Pattern: {}\n- Type: {:?}\n- Frequency: {:.1}\n- Failures: {}\n\n",
868                pattern.id,
869                pattern.pattern_type,
870                pattern.frequency,
871                pattern.failures.len()
872            );
873        }
874
875        Ok(report)
876    }
877
878    /// Generate trend analysis report
879    fn generate_trend_analysis(&self) -> ApplicationResult<String> {
880        let mut report = String::new();
881        report.push_str("# Trend Analysis Report\n\n");
882
883        if self.result_database.performance_trends.is_empty() {
884            report.push_str("No trends detected.\n");
885            return Ok(report);
886        }
887
888        for (test_id, trend) in &self.result_database.performance_trends {
889            let _ = write!(report, "## {}\n- Metric: {}\n- Direction: {:?}\n- Magnitude: {:.4}\n- Confidence: {:.2}\n- Data Points: {}\n\n",
890                test_id,
891                trend.metric,
892                trend.trend_direction,
893                trend.trend_magnitude,
894                trend.confidence,
895                trend.data_points.len());
896        }
897
898        Ok(report)
899    }
900
901    /// Get analytics summary
902    #[must_use]
903    pub fn get_analytics_summary(&self) -> AnalyticsSummary {
904        AnalyticsSummary {
905            total_tests: self.result_database.statistics.total_executions,
906            success_rate: self.result_database.statistics.success_rate,
907            avg_execution_time: self.result_database.statistics.avg_execution_time,
908            active_trends: self.result_database.performance_trends.len(),
909            detected_patterns: self.result_database.failure_patterns.len(),
910            data_retention_days: self
911                .result_database
912                .statistics
913                .retention_policy
914                .retention_period
915                .as_secs()
916                / (24 * 3600),
917        }
918    }
919}
920
921/// Analytics summary information
922#[derive(Debug, Clone)]
923pub struct AnalyticsSummary {
924    /// Total number of tests executed
925    pub total_tests: usize,
926    /// Overall success rate
927    pub success_rate: f64,
928    /// Average execution time
929    pub avg_execution_time: Duration,
930    /// Number of active performance trends
931    pub active_trends: usize,
932    /// Number of detected failure patterns
933    pub detected_patterns: usize,
934    /// Data retention period in days
935    pub data_retention_days: u64,
936}
quantrs2_anneal/advanced_testing_framework/analytics.rs

quantrs2_anneal/advanced_testing_framework/
analytics.rs
