winshift 0.0.6

A cross-platform window change hook library
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

#![cfg(target_os = "macos")]

use std::hint::black_box;
use std::thread;
use std::time::Duration;
use sysinfo::{Pid, ProcessRefreshKind, ProcessesToUpdate, System};
use winshift::get_active_window_info;

fn current_rss_bytes() -> Option<u64> {
    let pid = Pid::from(std::process::id() as usize);
    let mut system = System::new();
    system.refresh_processes_specifics(
        ProcessesToUpdate::Some(&[pid]),
        false,
        ProcessRefreshKind::nothing().with_memory(),
    );
    system.process(pid).map(|process| process.memory())
}

#[test]
#[ignore = "manual macOS regression test; requires foreground GUI session and Accessibility permission"]
fn query_loop_memory_stays_bounded() {
    let baseline = current_rss_bytes().expect("baseline RSS should be available");
    let iterations = 5_000_u64;
    let max_delta_bytes = 8_u64 * 1024 * 1024;
    let mut ok = 0_u64;

    for iteration in 0..iterations {
        let info = get_active_window_info().unwrap_or_else(|err| {
            panic!(
                "get_active_window_info failed at iteration {}: {}",
                iteration + 1,
                err
            )
        });
        ok = ok.saturating_add(1);
        black_box((
            info.process_id,
            info.window_id,
            info.title.len(),
            info.app_name.len(),
        ));
        thread::sleep(Duration::from_millis(1));
    }

    let end = current_rss_bytes().expect("ending RSS should be available");
    let delta = end.saturating_sub(baseline);

    assert_eq!(ok, iterations, "all query iterations should succeed");
    assert!(
        delta <= max_delta_bytes,
        "query loop RSS delta too large: baseline={} end={} delta={} bytes",
        baseline,
        end,
        delta
    );
}