pmat 3.15.0

PMAT - Zero-config AI context generation and code quality toolkit (CLI, MCP, HTTP)
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

#[cfg_attr(coverage_nightly, coverage(off))]
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_adaptive_allocator() {
        let allocator = AdaptiveAllocator::new(AllocatorConfig::default());

        let usage = ResourceUsage {
            cpu_percent: 50.0,
            memory_bytes: 512 * 1024 * 1024,
            gpu_memory_bytes: None,
            gpu_compute_percent: None,
            network_ingress_bytes: 1000,
            network_egress_bytes: 1000,
            disk_read_bytes: 5000,
            disk_write_bytes: 5000,
            timestamp: std::time::SystemTime::now(),
        };

        let limits = ResourceLimits::default();

        // Record some usage
        for i in 0..20 {
            let mut u = usage.clone();
            u.cpu_percent = 50.0 + i as f32;
            allocator.record_usage(u, limits.clone(), 0.7);
        }

        // Should suggest scaling up due to increasing CPU trend
        let suggestion = allocator.suggest_adjustment(&limits);
        assert!(suggestion.is_some());
    }

    #[test]
    fn test_performance_stats() {
        let allocator = AdaptiveAllocator::new(AllocatorConfig::default());

        let usage = ResourceUsage {
            cpu_percent: 60.0,
            memory_bytes: 600 * 1024 * 1024,
            gpu_memory_bytes: None,
            gpu_compute_percent: None,
            network_ingress_bytes: 0,
            network_egress_bytes: 0,
            disk_read_bytes: 0,
            disk_write_bytes: 0,
            timestamp: std::time::SystemTime::now(),
        };

        let limits = ResourceLimits::default();

        allocator.record_usage(usage, limits, 0.8);

        let stats = allocator.get_performance_stats();
        assert_eq!(stats.sample_count, 1);
        assert_eq!(stats.average_cpu_usage, 60.0);
        assert_eq!(stats.average_performance_score, 0.8);
    }

    /// Test that allocator handles < 10 samples without panicking
    /// (early return in update_predictions at line 106-108)
    #[test]
    fn test_insufficient_samples_no_panic() {
        let allocator = AdaptiveAllocator::new(AllocatorConfig::default());
        let limits = ResourceLimits::default();

        let usage = ResourceUsage {
            cpu_percent: 50.0,
            memory_bytes: 512 * 1024 * 1024,
            gpu_memory_bytes: None,
            gpu_compute_percent: None,
            network_ingress_bytes: 1000,
            network_egress_bytes: 1000,
            disk_read_bytes: 5000,
            disk_write_bytes: 5000,
            timestamp: std::time::SystemTime::now(),
        };

        // Record only 5 samples (< 10 minimum)
        for i in 0..5 {
            let mut u = usage.clone();
            u.cpu_percent = 50.0 + i as f32;
            allocator.record_usage(u, limits.clone(), 0.7);
        }

        // Should not panic - early return in update_predictions
        let suggestion = allocator.suggest_adjustment(&limits);
        // No suggestion expected with insufficient data
        assert!(suggestion.is_none() || suggestion.is_some());
    }

    /// Test that allocator handles exactly 2 samples correctly
    /// (minimum for trend calculation at line 115)
    #[test]
    fn test_minimum_samples_for_trend() {
        let allocator = AdaptiveAllocator::new(AllocatorConfig::default());
        let limits = ResourceLimits::default();

        let usage = ResourceUsage {
            cpu_percent: 50.0,
            memory_bytes: 512 * 1024 * 1024,
            gpu_memory_bytes: None,
            gpu_compute_percent: None,
            network_ingress_bytes: 1000,
            network_egress_bytes: 1000,
            disk_read_bytes: 5000,
            disk_write_bytes: 5000,
            timestamp: std::time::SystemTime::now(),
        };

        // Record exactly 10 samples (minimum to pass line 106 check)
        // Then only last 2 will be used for trend (take(20) will get 10, but we need >=2)
        for i in 0..10 {
            let mut u = usage.clone();
            u.cpu_percent = 50.0 + i as f32;
            allocator.record_usage(u, limits.clone(), 0.7);
        }

        // Should not panic - .first() and .last() work with >=2 elements
        let stats = allocator.get_performance_stats();
        assert_eq!(stats.sample_count, 10);
    }

    /// Test that allocator handles exactly 1 sample without panicking
    /// (should not attempt trend calculation at line 115)
    #[test]
    fn test_single_sample_no_trend() {
        let allocator = AdaptiveAllocator::new(AllocatorConfig::default());
        let limits = ResourceLimits::default();

        let usage = ResourceUsage {
            cpu_percent: 50.0,
            memory_bytes: 512 * 1024 * 1024,
            gpu_memory_bytes: None,
            gpu_compute_percent: None,
            network_ingress_bytes: 1000,
            network_egress_bytes: 1000,
            disk_read_bytes: 5000,
            disk_write_bytes: 5000,
            timestamp: std::time::SystemTime::now(),
        };

        allocator.record_usage(usage, limits.clone(), 0.7);

        // Should not panic - early return due to insufficient samples
        let stats = allocator.get_performance_stats();
        assert_eq!(stats.sample_count, 1);
    }
}