win-auto-utils 0.2.2

Universal Windows automation utilities with memory, window, input, and color operations
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

//! Integration tests for AddressSource functionality

use win_auto_utils::memory_resolver::{AddressSource, MemoryAddress};

#[test]
fn test_address_source_static_creation() {
    // Test creating static address source
    let addr = MemoryAddress::new_x86("game.exe+1000").unwrap();
    let source = AddressSource::from_static(addr);
    
    // Verify it's a Static variant
    match source {
        AddressSource::Static(_) => {},
        _ => panic!("Expected Static variant"),
    }
}

#[test]
fn test_address_source_aob_creation() {
    // Test creating AOB address source
    let source = AddressSource::from_aob_scan("48 89 5C ?? 48").unwrap();
    
    // Verify it's an AobScan variant
    match source {
        AddressSource::AobScan { pattern, .. } => {
            assert_eq!(pattern, "48 89 5C ?? 48");
        },
        _ => panic!("Expected AobScan variant"),
    }
}

#[test]
fn test_address_source_aob_with_range() {
    // Test creating AOB with custom range
    let source = AddressSource::from_aob_scan_range(
        "E8 ?? ?? ?? ??",
        0x10000000,
        0x1000000
    ).unwrap();
    
    match source {
        AddressSource::AobScan { pattern, start_address, length, find_first } => {
            assert_eq!(pattern, "E8 ?? ?? ?? ??");
            assert_eq!(start_address, 0x10000000);
            assert_eq!(length, 0x1000000);
            assert_eq!(find_first, true);
        },
        _ => panic!("Expected AobScan variant"),
    }
}

#[test]
fn test_address_source_try_from_str() {
    // Test TryFrom<&str> implementation
    use std::convert::TryFrom;
    
    let source = AddressSource::try_from("game.exe+1000").unwrap();
    
    match source {
        AddressSource::Static(addr) => {
            match addr.base {
                win_auto_utils::memory_resolver::AddressBase::Module { name, offset } => {
                    assert_eq!(name, "game.exe");
                    assert_eq!(offset, 0x1000);
                },
                _ => panic!("Expected Module base"),
            }
        },
        _ => panic!("Expected Static variant"),
    }
}

#[test]
fn test_address_source_invalid_aob_pattern() {
    // AOB pattern is validated at scan time, not creation time
    // So creating an AddressSource with any pattern string should succeed
    let result = AddressSource::from_aob_scan("GG HH II");
    
    // Creation should succeed (validation happens during scan)
    assert!(result.is_ok(), "AddressSource creation should succeed even with potentially invalid patterns");
    
    // The pattern is stored as-is
    match result.unwrap() {
        AddressSource::AobScan { pattern, .. } => {
            assert_eq!(pattern, "GG HH II");
        },
        _ => panic!("Expected AobScan variant"),
    }
}

#[test]
fn test_address_source_clone() {
    // Test that AddressSource can be cloned
    let source = AddressSource::from_static(
        MemoryAddress::new_x86("game.exe+1000").unwrap()
    );
    
    let cloned = source.clone();
    
    // Both should be valid
    match (source, cloned) {
        (AddressSource::Static(_), AddressSource::Static(_)) => {},
        _ => panic!("Both should be Static variants"),
    }
}