medius 2.0.0

Host control library for the medius transparent mouse passthrough 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

//! IMPERFECT command + QUERY (§3.10 / §4.14): payload bytes, `ImperfectStatus` decoding through
//! `parse_resp`, the command frame, and the query roundtrip. Bytes are pinned to the firmware wire
//! format in `ctrl_proto.h`.

#[cfg(feature = "mock")]
use crate::protocol::FrameType;
use crate::protocol::command::imperfect_payload;
use crate::protocol::{Resp, parse_resp};
use crate::types::ImperfectStatus;

#[test]
fn imperfect_payload_bytes() {
    assert_eq!(imperfect_payload(true), [1]);
    assert_eq!(imperfect_payload(false), [0]);
}

#[test]
fn decode_imperfect_through_parse_resp() {
    // [what=9][allowed][over_capacity][clone_imperfect]
    let Some(Resp::Imperfect(i)) = parse_resp(&[9, 1, 1, 1]) else {
        panic!("expected Imperfect");
    };
    assert_eq!(
        i,
        ImperfectStatus {
            allowed: true,
            over_capacity: true,
            clone_imperfect: true
        }
    );
    let Some(Resp::Imperfect(none)) = parse_resp(&[9, 0, 0, 0]) else {
        panic!("expected Imperfect");
    };
    assert_eq!(none, ImperfectStatus::default());
    assert!(parse_resp(&[9, 0, 0]).is_none()); // needs 4
}

#[cfg(feature = "mock")]
#[test]
fn allow_imperfect_clones_sends_an_imperfect_frame() {
    use crate::{Device, MockBox};
    let mock = MockBox::new();
    let device = Device::with_mock(mock.clone());
    device.allow_imperfect_clones(true).unwrap();
    let frame = mock
        .recorded_frames()
        .into_iter()
        .find(|f| f.ty == FrameType::Imperfect)
        .expect("an IMPERFECT frame was recorded");
    assert_eq!(frame.payload, vec![1]);
}

#[cfg(feature = "mock")]
#[test]
fn imperfect_query_roundtrips_the_status() {
    use crate::{Device, MockBox};
    let status = ImperfectStatus {
        allowed: true,
        over_capacity: true,
        clone_imperfect: true,
    };
    let mock = MockBox::new().with_imperfect_status(status);
    let device = Device::with_mock(mock);
    assert_eq!(device.query_imperfect().unwrap(), status);
}

#[cfg(all(feature = "async", feature = "mock"))]
#[test]
fn async_imperfect_query_roundtrips_the_status() {
    use crate::{Device, MockBox};
    use futures::executor::block_on;
    let status = ImperfectStatus {
        allowed: true,
        over_capacity: true,
        clone_imperfect: true,
    };
    let mock = MockBox::new().with_imperfect_status(status);
    let device = Device::with_mock(mock).into_async();
    assert_eq!(block_on(device.query_imperfect()).unwrap(), status);
}