quantrs2-circuit 0.1.3

Quantum circuit representation and DSL for the QuantRS2 framework
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

//! Tests for the profiler module

use super::*;
use crate::builder::Circuit;

mod tests {
    use super::*;
    use quantrs2_core::gate::single::Hadamard;

    #[test]
    fn test_profiler_creation() {
        let circuit = Circuit::<1>::new();
        let profiler = QuantumProfiler::new(circuit);

        assert!(profiler.config.enable_gate_profiling);
        assert!(profiler.config.enable_memory_profiling);
        assert!(profiler.config.enable_resource_profiling);
    }

    #[test]
    fn test_profiler_configuration() {
        let circuit = Circuit::<1>::new();
        let config = ProfilerConfig {
            precision_level: PrecisionLevel::Ultra,
            enable_scirs2_analysis: true,
            ..Default::default()
        };

        let profiler = QuantumProfiler::with_config(circuit, config);

        match profiler.config.precision_level {
            PrecisionLevel::Ultra => (),
            _ => panic!("Expected Ultra precision level"),
        }
    }

    #[test]
    fn test_profiling_session() {
        let mut circuit = Circuit::<1>::new();
        circuit
            .add_gate(Hadamard { target: QubitId(0) })
            .expect("Failed to add Hadamard gate to circuit");

        let mut profiler = QuantumProfiler::new(circuit);
        let session_id = profiler
            .start_profiling()
            .expect("Failed to start profiling session");

        // Simulate some profiling
        std::thread::sleep(Duration::from_millis(10));

        let report = profiler
            .stop_profiling(&session_id)
            .expect("Failed to stop profiling session");
        assert_eq!(report.session_id, session_id);
    }

    #[test]
    fn test_realtime_metrics() {
        let circuit = Circuit::<1>::new();
        let profiler = QuantumProfiler::new(circuit);

        let metrics = profiler
            .get_realtime_metrics()
            .expect("Failed to get realtime metrics");
        assert!(metrics.current_metrics.len() <= 10);
    }

    #[test]
    fn test_performance_analysis() {
        let mut circuit = Circuit::<1>::new();
        circuit
            .add_gate(Hadamard { target: QubitId(0) })
            .expect("Failed to add Hadamard gate to circuit");

        let mut profiler = QuantumProfiler::new(circuit);
        let _analysis = profiler
            .analyze_performance()
            .expect("Failed to analyze performance");

        // Analysis should complete without errors
    }

    #[test]
    fn test_regression_detection() {
        let circuit = Circuit::<1>::new();
        let mut profiler = QuantumProfiler::new(circuit);

        let regressions = profiler
            .detect_regressions()
            .expect("Failed to detect regressions");
        // Should return empty list for new profiler
        assert!(regressions.is_empty());
    }
}