selfware 0.6.0

Your personal AI workshop — software you own, software that lasts
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
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

use super::*;

#[test]
fn test_rate_limiter_allows_first_action() {
    let limiter = ActionRateLimiter::new(5);
    assert!(limiter.check());
}

#[test]
fn test_rate_limiter_allows_within_limit() {
    let limiter = ActionRateLimiter::new(5);
    for _ in 0..5 {
        assert!(limiter.check());
    }
}

#[test]
fn test_rate_limiter_blocks_over_limit() {
    let limiter = ActionRateLimiter::new(2);
    assert!(limiter.check()); // 1st
    assert!(limiter.check()); // 2nd
    assert!(!limiter.check()); // 3rd should fail
}

#[test]
fn test_rate_limiter_default() {
    let limiter = ActionRateLimiter::default();
    assert_eq!(limiter.max_actions_per_sec, 10);
    // First action should always pass
    assert!(limiter.check());
}

#[test]
fn rate_limiter_caps_concurrent_burst() {
    use std::sync::atomic::{AtomicU64, Ordering};
    use std::sync::Arc;
    // Many threads hammering a fresh limiter within one ~1s window must not
    // let a burst through: the CAS window-claim prevents multiple threads
    // from each resetting the counter (the old Relaxed load/store race).
    let limiter = Arc::new(ActionRateLimiter::new(10));
    let allowed = Arc::new(AtomicU64::new(0));
    let mut handles = Vec::new();
    for _ in 0..8 {
        let l = Arc::clone(&limiter);
        let a = Arc::clone(&allowed);
        handles.push(std::thread::spawn(move || {
            for _ in 0..50 {
                if l.check() {
                    a.fetch_add(1, Ordering::Relaxed);
                }
            }
        }));
    }
    for h in handles {
        h.join().unwrap();
    }
    let total = allowed.load(Ordering::Relaxed);
    // 400 attempts complete in microseconds (~1 window). Allow 2 windows of
    // slack for a rare boundary crossing; without the fix this blew far past.
    assert!(
        (1..=20).contains(&total),
        "concurrent burst must be capped near the limit, got {total}"
    );
}

#[test]
fn test_blocked_combos() {
    assert!(is_blocked_combo("ctrl+alt+delete"));
    assert!(is_blocked_combo("Ctrl+Alt+Delete"));
    assert!(is_blocked_combo("cmd+q"));
    assert!(is_blocked_combo("alt+f4"));
    assert!(is_blocked_combo("ctrl+alt+f1"));
    assert!(is_blocked_combo("ctrl+alt+f2"));
    assert!(is_blocked_combo("ctrl+alt+f3"));
    assert!(!is_blocked_combo("ctrl+c"));
    assert!(!is_blocked_combo("ctrl+v"));
    assert!(!is_blocked_combo("ctrl+s"));
    assert!(!is_blocked_combo("ctrl+shift+t"));
    assert!(!is_blocked_combo(""));
}

#[test]
fn test_blocked_combos_whitespace_normalization() {
    // Spaces should be stripped
    assert!(is_blocked_combo("ctrl + alt + delete"));
    assert!(is_blocked_combo("cmd + q"));
}

#[test]
fn test_movement_profile_default() {
    let profile = MovementProfile::default();
    assert!(matches!(profile, MovementProfile::Linear));
}

#[test]
fn test_movement_profile_serde_roundtrip() {
    let profiles = vec![
        MovementProfile::Linear,
        MovementProfile::EaseInOut,
        MovementProfile::Bezier,
    ];
    for profile in profiles {
        let json = serde_json::to_string(&profile).unwrap();
        let parsed: MovementProfile = serde_json::from_str(&json).unwrap();
        let _ = format!("{:?}", parsed);
    }
}

#[test]
fn test_typing_profile_default() {
    let profile = TypingProfile::default();
    assert_eq!(profile.base_delay_ms, 0);
    assert_eq!(profile.variation_ms, 0);
}

#[test]
fn test_typing_profile_serde_roundtrip() {
    let profile = TypingProfile {
        base_delay_ms: 50,
        variation_ms: 10,
    };
    let json = serde_json::to_string(&profile).unwrap();
    let parsed: TypingProfile = serde_json::from_str(&json).unwrap();
    assert_eq!(parsed.base_delay_ms, 50);
    assert_eq!(parsed.variation_ms, 10);
}

#[test]
fn test_typing_profile_serde_defaults() {
    // Missing fields should default to 0
    let parsed: TypingProfile = serde_json::from_str("{}").unwrap();
    assert_eq!(parsed.base_delay_ms, 0);
    assert_eq!(parsed.variation_ms, 0);
}