xremap 0.15.7

Dynamic key remap for X and Wayland
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

#![cfg(feature = "device-test")]

use crate::common::xremap_controller::{InputDeviceFilter, XremapController};
use crate::common::{
    assert_str_contains, get_random_device_name, get_virtual_device, get_virtual_device_without_wait, key_press,
};
use evdev::KeyCode as Key;
use std::time::Duration;

mod common;

#[test]
pub fn e2e_match_nothing_in_watch_mode() -> anyhow::Result<()> {
    let mut ctrl = XremapController::builder()
        .input_device(InputDeviceFilter::CustomFilter {
            filter: "match_nothing".into(),
        })
        .watch(true)
        .build()?;

    assert!(ctrl
        .kill_for_output()?
        .stdout
        .contains("No device was selected, but --watch is waiting for new devices."));

    ctrl.kill()
}

#[test]
pub fn e2e_connecting_device_in_watch_mode() -> anyhow::Result<()> {
    let name = get_random_device_name();

    let mut ctrl = XremapController::builder()
        .input_device(InputDeviceFilter::CustomFilter { filter: name.clone() })
        .watch(true)
        .build()?;

    ctrl.open_input_device(&name)?;

    let output = ctrl.kill_for_output()?;

    assert_str_contains("No device was selected, but --watch is waiting for new devices.", &output.stdout);
    // A poor test, that device is now selected.
    assert_str_contains(&format!(": {}", name), &output.stdout);

    ctrl.kill()
}

#[test]
pub fn e2e_connecting_two_devices_in_watch_mode() -> anyhow::Result<()> {
    let name = get_random_device_name();
    let name2 = format!("{name} 2");

    let mut ctrl = XremapController::builder()
        .input_device(InputDeviceFilter::CustomFilter { filter: name.clone() })
        .watch(true)
        .build()?;

    // Reveals a race-condition
    ctrl.open_input_device(&name)?;

    let _dev1 = get_virtual_device(&name)?;
    let _dev2 = get_virtual_device(&name2)?;

    // Give time to handle the event, otherwise it's a race-condition whether
    //  kill or handling-disconnect happens first.
    std::thread::sleep(std::time::Duration::from_millis(200));

    let output = ctrl.kill_for_output()?;

    assert_str_contains(&format!(": {}", name), &output.stdout);
    assert_str_contains(&format!(": {}", name2), &output.stdout);

    Ok(())
}

#[test]
pub fn e2e_disconnecting_device_in_watch_mode() -> anyhow::Result<()> {
    let mut ctrl = XremapController::builder().watch(true).build()?;

    ctrl.close_input_device()?;

    // Give time to handle the event, otherwise it's a race-condition whether
    //  kill or handling-disconnect happens first.
    std::thread::sleep(std::time::Duration::from_millis(200));

    let output = ctrl.kill_for_output()?;

    assert_str_contains(
        &format!("Found a removed device: \"{}\"", ctrl.get_input_device_name().as_ref().unwrap()),
        &output.stdout,
    );

    Ok(())
}

#[test]
pub fn e2e_disconnecting_two_devices_in_watch_mode() -> anyhow::Result<()> {
    let name = get_random_device_name();
    let name2 = format!("{name} 2");

    let mut ctrl = {
        let _dev1 = get_virtual_device(&name)?;
        let _dev2 = get_virtual_device(&name2)?;

        let ctrl = XremapController::builder()
            .input_device(InputDeviceFilter::CustomFilter { filter: name.clone() })
            .watch(true)
            .build()?;

        ctrl

        // Devices will now be dropped
    };

    // Give time to handle the event, otherwise it's a race-condition whether
    //  kill or handling-disconnect happens first.
    std::thread::sleep(std::time::Duration::from_millis(200));

    let output = ctrl.kill_for_output()?;

    assert!(output.stdout.contains(&format!("Found a removed device: \"{}\"", name)));

    assert!(output
        .stdout
        .contains(&format!("Found a removed device: \"{}\"", name2)));

    Ok(())
}

#[test]
pub fn e2e_fast_connect_and_disconnect_in_watch_mode() -> anyhow::Result<()> {
    let name = get_random_device_name();
    let ctrl = XremapController::builder()
        .input_device(InputDeviceFilter::CustomFilter { filter: name.clone() })
        .watch(true)
        .build()?;

    let mut device = get_virtual_device_without_wait(&name)?;
    // Make xremap spend more time in the race-condition
    // region from InputDevice::try_from() to device.grab()
    device.emit(&[key_press(Key::BTN_TRIGGER_HAPPY1)])?;

    // Allow xremap to go into wait-for-keys-loop
    std::thread::sleep(Duration::from_millis(100));

    // Force an ENODEV error, that must not be printed by xremap
    drop(device);

    std::thread::sleep(std::time::Duration::from_millis(200));

    ctrl.kill()
}