medius 3.4.6

Rust library for Medius, replacement firmware for the MAKCU box
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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

#![cfg(feature = "mock")]

use std::time::Duration;

use crate::{
    Button, CatchFilter, ClipAction, ClipBuilder, ClipPacketTrigger, ClipTrigger, Device,
    Direction, Edge, FrameType, MockBox, TrafficClass,
};

const PAST_ONE_CADENCE: Duration = Duration::from_millis(650);

#[test]
fn keepalive_reasserts_catch_while_subscribed() {
    let mock = MockBox::new();
    let device = Device::with_mock(mock.clone());
    let _stream = device.catch_events([CatchFilter::everything()]).unwrap();
    mock.clear_recorded();
    std::thread::sleep(PAST_ONE_CADENCE);
    assert!(
        mock.saw(FrameType::Catch),
        "keepalive must re-send CATCH while subscribed (restores the mask after a device-side clear, \
         and feeds the silence timer); saw {} frames",
        mock.recorded()
    );
    drop(device);
}

#[test]
fn keepalive_fires_while_a_button_is_held() {
    let mock = MockBox::new();
    let device = Device::with_mock(mock.clone());
    device.press(Button::LEFT).unwrap();
    mock.clear_recorded();
    std::thread::sleep(PAST_ONE_CADENCE);
    assert!(
        mock.saw(FrameType::Query),
        "keepalive must send a QUERY while a button is held (saw {} frames)",
        mock.recorded()
    );
    drop(device);
}

// 1 s of control silence clears the clip and triggers on the box. A retained clip armed on a
// trigger is exactly when the host goes quiet, waiting for the button.
#[test]
fn keepalive_fires_while_a_clip_waits_on_a_trigger() {
    let mock = MockBox::new();
    let device = Device::with_mock(mock.clone());
    let clip = device.clip();
    clip.bind(ClipTrigger::new(
        Button::SIDE1,
        Edge::Press,
        ClipAction::Start,
    ))
    .unwrap();
    mock.clear_recorded();
    std::thread::sleep(PAST_ONE_CADENCE);
    assert!(
        mock.saw(FrameType::Query),
        "a bound trigger must hold the keepalive open (saw {} frames)",
        mock.recorded()
    );

    clip.clear_triggers().unwrap();
    let mut b = ClipBuilder::new();
    b.move_by(1, 0);
    clip.append(&b).unwrap();
    mock.clear_recorded();
    std::thread::sleep(PAST_ONE_CADENCE);
    assert!(mock.saw(FrameType::Query), "and so must a loaded clip");

    // A manual reapply runs on a live link, where the box still holds the clip.
    device.reapply().unwrap();
    mock.clear_recorded();
    std::thread::sleep(PAST_ONE_CADENCE);
    assert!(
        mock.saw(FrameType::Query),
        "a reapply must leave the loaded clip held"
    );

    clip.clear().unwrap();
    mock.clear_recorded();
    std::thread::sleep(PAST_ONE_CADENCE);
    assert!(
        !mock.saw(FrameType::Query),
        "with the clip cleared and nothing bound the keepalive idles"
    );
    drop(device);
}

#[test]
fn keepalive_is_silent_while_idle() {
    let mock = MockBox::new();
    let device = Device::with_mock(mock.clone());
    mock.clear_recorded();
    std::thread::sleep(PAST_ONE_CADENCE);
    assert_eq!(
        mock.recorded(),
        0,
        "keepalive must stay silent while idle so the firmware auto-clear can release on a real crash"
    );
    drop(device);
}

#[test]
fn keepalive_stops_after_the_device_is_dropped() {
    let mock = MockBox::new();
    let device = Device::with_mock(mock.clone());
    device.press(Button::LEFT).unwrap();
    std::thread::sleep(PAST_ONE_CADENCE);
    drop(device);
    mock.clear_recorded();
    std::thread::sleep(PAST_ONE_CADENCE);
    assert_eq!(
        mock.recorded(),
        0,
        "no frames may be sent after the device is dropped (keepalive thread must have stopped)"
    );
}

// Each clip call records what it sent, and the keepalive runs exactly while any of it stands.
#[test]
fn keepalive_follows_a_clip_setting_and_a_trigger_binding() {
    let mock = MockBox::new();
    let device = Device::with_mock(mock.clone());
    let clip = device.clip();
    let fires = || {
        mock.clear_recorded();
        std::thread::sleep(PAST_ONE_CADENCE);
        mock.saw(FrameType::Query)
    };

    clip.append(&ClipBuilder::new()).unwrap();
    assert!(!fires(), "an append of nothing loads nothing");

    clip.set_ride(true).unwrap();
    assert!(fires(), "a setting off its default is held");
    clip.set_ride(false).unwrap();
    assert!(!fires(), "and back on it is not");

    clip.bind(ClipTrigger::new(
        Button::SIDE1,
        Edge::Press,
        ClipAction::Start,
    ))
    .unwrap();
    assert!(fires(), "a bound trigger is held");
    clip.unbind(Button::SIDE1, Edge::Press).unwrap();
    assert!(!fires(), "and unbound it is not");

    // A packet trigger waits on the real device the way an input trigger waits on a button.
    let packet = ClipPacketTrigger::new(TrafficClass::HidIn, 2, Direction::IN, ClipAction::Start)
        .matching([0x07, 0x20], [0xFF, 0x20]);
    clip.bind_packet(&packet).unwrap();
    assert!(fires(), "a bound packet trigger is held");
    clip.unbind_packet(&packet).unwrap();
    assert!(!fires(), "and unbound it is not");
    drop(device);
}