pmat 3.11.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

//! Tests for cache base module

use super::*;
use std::time::Duration;

#[test]
fn test_cache_entry_creation() {
    let value = "test_value".to_string();
    let entry = CacheEntry::new(value.clone(), 100);

    assert_eq!(*entry.value, value);
    assert_eq!(entry.size_bytes, 100);
    assert_eq!(
        entry
            .access_count
            .load(std::sync::atomic::Ordering::Relaxed),
        0
    );
}

#[test]
fn test_cache_entry_access() {
    let entry = CacheEntry::new("test".to_string(), 50);

    // Initial access count should be 0
    assert_eq!(
        entry
            .access_count
            .load(std::sync::atomic::Ordering::Relaxed),
        0
    );

    // Access the entry
    entry.access();
    assert_eq!(
        entry
            .access_count
            .load(std::sync::atomic::Ordering::Relaxed),
        1
    );

    // Access again
    entry.access();
    assert_eq!(
        entry
            .access_count
            .load(std::sync::atomic::Ordering::Relaxed),
        2
    );
}

#[test]
fn test_cache_entry_age() {
    let entry = CacheEntry::new("test".to_string(), 50);

    // Age should be very small right after creation
    let age = entry.age();
    assert!(age < Duration::from_secs(1));

    // Test that age calculation works
    std::thread::sleep(Duration::from_millis(10));
    let age2 = entry.age();
    assert!(age2 >= Duration::from_millis(10));
}

#[test]
fn test_cache_stats_new() {
    let stats = CacheStats::new();

    assert_eq!(stats.hits.load(std::sync::atomic::Ordering::Relaxed), 0);
    assert_eq!(stats.misses.load(std::sync::atomic::Ordering::Relaxed), 0);
    assert_eq!(
        stats.total_bytes.load(std::sync::atomic::Ordering::Relaxed),
        0
    );
    assert_eq!(
        stats.evictions.load(std::sync::atomic::Ordering::Relaxed),
        0
    );
}

#[test]
fn test_cache_stats_operations() {
    let stats = CacheStats::new();

    // Test hit recording
    stats.record_hit();
    assert_eq!(stats.hits.load(std::sync::atomic::Ordering::Relaxed), 1);

    // Test miss recording
    stats.record_miss();
    assert_eq!(stats.misses.load(std::sync::atomic::Ordering::Relaxed), 1);

    // Test eviction recording
    stats.record_eviction();
    assert_eq!(
        stats.evictions.load(std::sync::atomic::Ordering::Relaxed),
        1
    );

    // Test bytes operations
    stats.add_bytes(100);
    assert_eq!(
        stats.total_bytes.load(std::sync::atomic::Ordering::Relaxed),
        100
    );

    stats.remove_bytes(30);
    assert_eq!(
        stats.total_bytes.load(std::sync::atomic::Ordering::Relaxed),
        70
    );
}

struct TestStrategy;

impl CacheStrategy for TestStrategy {
    type Key = String;
    type Value = String;

    fn cache_key(&self, input: &Self::Key) -> String {
        format!("test_{}", input)
    }

    fn validate(&self, _key: &Self::Key, _value: &Self::Value) -> bool {
        true
    }

    fn ttl(&self) -> Option<Duration> {
        Some(Duration::from_secs(60))
    }

    fn max_size(&self) -> usize {
        1000
    }
}

#[test]
fn test_cache_strategy_trait() {
    let strategy = TestStrategy;

    assert_eq!(strategy.cache_key(&"key".to_string()), "test_key");
    assert!(strategy.validate(&"key".to_string(), &"value".to_string()));
    assert_eq!(strategy.ttl(), Some(Duration::from_secs(60)));
    assert_eq!(strategy.max_size(), 1000);
}