borrowscope-macro 0.1.1

Procedural macros for BorrowScope ownership tracking
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
135
136
137
138
139
140
141
142

//! Tests for attribute parameter parsing and configuration

use borrowscope_macro::trace_borrow;
use borrowscope_runtime::*;

mod test_utils {
    use std::sync::Mutex;
    pub static TEST_LOCK: Mutex<()> = Mutex::new(());
}

use test_utils::TEST_LOCK;

#[test]
fn test_default_tracking() {
    let _lock = TEST_LOCK.lock();
    reset();

    #[trace_borrow]
    fn example() {
        let x = 42;
        let _y = &x;
    }

    example();

    let events = get_events();
    // Should have: New, Borrow, Drop events
    assert!(events.len() >= 2, "Default should track new and borrow");
    assert!(events.iter().any(|e| e.is_new()));
    assert!(events.iter().any(|e| e.is_borrow()));
}

#[test]
fn test_quiet_mode() {
    let _lock = TEST_LOCK.lock();
    reset();

    #[trace_borrow(quiet)]
    fn example() {
        let x = 42;
        let _y = &x;
        for _i in 0..2 {}
    }

    example();

    let events = get_events();
    // Quiet mode: ownership only (new, move, drop, borrow)
    // Should NOT have loop events
    assert!(events.iter().any(|e| e.is_new()));
    assert!(!events.iter().any(|e| matches!(e, Event::LoopEnter { .. })));
}

#[test]
fn test_skip_loops() {
    let _lock = TEST_LOCK.lock();
    reset();

    #[trace_borrow(skip = "loops")]
    fn example() {
        let x = 42;
        for _i in 0..2 {
            let _ = x;
        }
    }

    example();

    let events = get_events();
    // Should have new but NOT loop events
    assert!(events.iter().any(|e| e.is_new()));
    assert!(!events.iter().any(|e| matches!(e, Event::LoopEnter { .. })));
}

#[test]
fn test_skip_branches() {
    let _lock = TEST_LOCK.lock();
    reset();

    #[trace_borrow(skip = "branches")]
    fn example() {
        let x = 42;
        if x > 0 {
            let _ = 1;
        }
    }

    example();

    let events = get_events();
    // Should have new but NOT branch events
    assert!(events.iter().any(|e| e.is_new()));
    assert!(!events.iter().any(|e| matches!(e, Event::Branch { .. })));
}

#[test]
fn test_only_ownership() {
    let _lock = TEST_LOCK.lock();
    reset();

    #[trace_borrow(only = "ownership")]
    fn example() {
        let x = 42;
        let _y = &x;
        for _i in 0..2 {}
        if x > 0 {}
    }

    example();

    let events = get_events();
    // Only ownership events (new, move, drop, borrow)
    for event in &events {
        assert!(
            event.is_new() || event.is_move() || event.is_drop() || event.is_borrow(),
            "Only ownership events expected, got: {:?}",
            event
        );
    }
}

#[test]
fn test_skip_multiple() {
    let _lock = TEST_LOCK.lock();
    reset();

    #[trace_borrow(skip = "loops, branches, methods")]
    fn example() {
        let x = vec![1, 2, 3];
        let _y = x.clone();
        for _i in 0..2 {}
        if true {}
    }

    example();

    let events = get_events();
    // Should NOT have loop, branch, or clone events
    assert!(!events.iter().any(|e| matches!(e, Event::LoopEnter { .. })));
    assert!(!events.iter().any(|e| matches!(e, Event::Branch { .. })));
    assert!(!events.iter().any(|e| matches!(e, Event::Clone { .. })));
}