cranpose-ui 0.1.164

UI primitives for Cranpose
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

use super::*;

#[test]
fn schedule_and_process_repasses() {
    let _app_context = crate::render_state::app_context_test_scope();
    clear_pointer_repasses();

    let node1: NodeId = 1;
    let node2: NodeId = 2;

    schedule_pointer_repass(node1);
    schedule_pointer_repass(node2);

    assert!(has_pending_pointer_repasses());

    let mut processed = Vec::new();
    process_pointer_repasses(|node_id| {
        processed.push(node_id);
    });

    assert_eq!(processed.len(), 2);
    assert!(processed.contains(&node1));
    assert!(processed.contains(&node2));
    assert!(!has_pending_pointer_repasses());
}

#[test]
fn duplicate_schedules_deduplicated() {
    let _app_context = crate::render_state::app_context_test_scope();
    clear_pointer_repasses();

    let node: NodeId = 42;
    schedule_pointer_repass(node);
    schedule_pointer_repass(node);
    schedule_pointer_repass(node);

    let mut count = 0;
    process_pointer_repasses(|_| {
        count += 1;
    });

    assert_eq!(count, 1);
}

#[test]
fn process_repasses_recovers_after_processor_panic() {
    let _app_context = crate::render_state::app_context_test_scope();
    clear_pointer_repasses();

    schedule_pointer_repass(1);
    let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
        process_pointer_repasses(|_| panic!("pointer repass processor panic"));
    }));
    assert!(result.is_err());

    schedule_pointer_repass(2);
    let mut processed = Vec::new();
    process_pointer_repasses(|node_id| processed.push(node_id));

    assert!(
        processed.contains(&2),
        "pointer repass processing must not stay stuck after a processor panic"
    );
    assert!(!has_pending_pointer_repasses());
}

#[test]
fn process_repasses_allows_processor_to_schedule_more_work() {
    let _app_context = crate::render_state::app_context_test_scope();
    clear_pointer_repasses();

    schedule_pointer_repass(1);
    let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
        process_pointer_repasses(|_| schedule_pointer_repass(2));
    }));
    assert!(
        result.is_ok(),
        "pointer repass processors must be able to enqueue follow-up repasses"
    );
    assert!(has_pending_pointer_repasses());

    let mut processed = Vec::new();
    process_pointer_repasses(|node_id| processed.push(node_id));

    assert_eq!(processed, vec![2]);
    assert!(!has_pending_pointer_repasses());
}

#[test]
fn pointer_repasses_are_scoped_by_app_context() {
    let _app_context = crate::render_state::app_context_test_scope();
    let first = crate::render_state::AppContext::new_with_density(1.0);
    let second = crate::render_state::AppContext::new_with_density(1.0);

    first.enter(|| {
        clear_pointer_repasses();
        schedule_pointer_repass(7);
        assert!(has_pending_pointer_repasses());
    });

    second.enter(|| {
        clear_pointer_repasses();
        assert!(!has_pending_pointer_repasses());
        schedule_pointer_repass(9);
    });

    first.enter(|| {
        let mut processed = Vec::new();
        process_pointer_repasses(|node_id| processed.push(node_id));
        assert_eq!(processed, vec![7]);
    });

    second.enter(|| {
        let mut processed = Vec::new();
        process_pointer_repasses(|node_id| processed.push(node_id));
        assert_eq!(processed, vec![9]);
    });
}