openlogi-hid 0.6.20

HID++ device discovery for OpenLogi, wrapping the hidpp crate over async-hid.
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

use std::assert_matches;

use super::*;
use hidpp::feature::smartshift::WheelMode;

use crate::SmartShiftMode;
use crate::write::smartshift::{
    is_missing_enhanced, smartshift_to_wheel, wheel_mode_to_smartshift,
};

#[test]
fn capabilities_sort_and_deduplicate_values() -> Result<(), WriteError> {
    let caps = DpiCapabilities::new(vec![1600, 400, 800, 800])?;

    assert_eq!(caps.values(), [400, 800, 1600]);
    assert_eq!(caps.min(), 400);
    assert_eq!(caps.max(), 1600);
    Ok(())
}

#[test]
fn capabilities_reject_empty_list() {
    assert_matches!(
        DpiCapabilities::new(Vec::new()),
        Err(WriteError::EmptyDpiList)
    );
}

#[test]
fn nearest_returns_closest_supported_value() -> Result<(), WriteError> {
    let caps = DpiCapabilities::new(vec![400, 800, 1600])?;

    assert_eq!(caps.nearest(390), 400);
    assert_eq!(caps.nearest(1000), 800);
    assert_eq!(caps.nearest(2000), 1600);
    Ok(())
}

#[test]
fn step_hint_returns_smallest_positive_gap() -> Result<(), WriteError> {
    let caps = DpiCapabilities::new(vec![400, 800, 1200, 2000])?;

    assert_eq!(caps.step_hint(), 400);
    Ok(())
}

#[test]
fn adjacent_test_target_prefers_next_then_previous_value() -> Result<(), WriteError> {
    let caps = DpiCapabilities::new(vec![400, 800, 1600])?;

    assert_eq!(caps.adjacent_test_target(400), Some(800));
    assert_eq!(caps.adjacent_test_target(800), Some(1600));
    assert_eq!(caps.adjacent_test_target(1600), Some(800));
    Ok(())
}

#[test]
fn adjacent_test_target_handles_current_outside_list() -> Result<(), WriteError> {
    let caps = DpiCapabilities::new(vec![400, 800, 1600])?;

    assert_eq!(caps.adjacent_test_target(1000), Some(1600));
    assert_eq!(caps.adjacent_test_target(2000), Some(1600));
    Ok(())
}

#[test]
fn smartshift_and_wheel_mode_byte_encodings_match() {
    // The whole design relies on 0x2110 WheelMode and 0x2111
    // SmartShiftMode sharing one wire encoding (Free/Freespin = 1,
    // Ratchet = 2). If the fork ever renumbers WheelMode this fails loudly.
    assert_eq!(
        u8::from(SmartShiftMode::Free),
        u8::from(WheelMode::Freespin)
    );
    assert_eq!(
        u8::from(SmartShiftMode::Ratchet),
        u8::from(WheelMode::Ratchet)
    );
}

#[test]
fn wheel_mode_maps_to_smartshift_mode() {
    assert_eq!(
        wheel_mode_to_smartshift(WheelMode::Freespin),
        SmartShiftMode::Free
    );
    assert_eq!(
        wheel_mode_to_smartshift(WheelMode::Ratchet),
        SmartShiftMode::Ratchet
    );
}

#[test]
fn smartshift_to_wheel_round_trips() {
    // smartshift_to_wheel is the inverse of wheel_mode_to_smartshift.
    for mode in [SmartShiftMode::Free, SmartShiftMode::Ratchet] {
        assert_eq!(wheel_mode_to_smartshift(smartshift_to_wheel(mode)), mode);
    }
}

#[test]
fn missing_enhanced_triggers_fallback() {
    assert!(is_missing_enhanced(&WriteError::FeatureUnsupported {
        feature_hex: 0x2111,
    }));
}

#[test]
fn missing_legacy_does_not_trigger_fallback() {
    // A device missing 0x2110 must NOT loop back — it genuinely has no
    // SmartShift.
    assert!(!is_missing_enhanced(&WriteError::FeatureUnsupported {
        feature_hex: 0x2110,
    }));
}

#[test]
fn transport_errors_do_not_trigger_fallback() {
    // Real failures must propagate, not be masked by a fallback attempt.
    assert!(!is_missing_enhanced(&WriteError::DeviceUnreachable {
        index: 0xff,
    }));
    assert!(!is_missing_enhanced(&WriteError::Hidpp("boom".into())));
}