Fix failing device tests

Author: Henri

.github/workflows/rust.yml

@@ -26,6 +26,8 @@ jobs:
       run: cargo test --verbose
     - name: Doc
       run: cargo doc --all-features
+    - name: Run device tests
+      run: sudo -E env "PATH=$PATH" cargo test --tests --features device-test
 
   cross-linux:
     runs-on: ubuntu-latest

Cargo.toml

@@ -13,6 +13,7 @@ rust-version = "1.64"
 serde = ["dep:serde"]
 tokio = ["dep:tokio"]
 stream-trait = ["tokio", "futures-core"]
+device-test = []
 
 [dependencies]
 libc = { version = "0.2.121", features = ["extra_traits"]}

src/sync_stream.rs

@@ -889,7 +889,6 @@ pub use tokio_stream::EventStream;
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::tests::{get_test_device, key_event};
 
     fn result_events_iter(
         events: &[input_event],
@@ -957,23 +956,4 @@ mod tests {
         assert_eq!(next(), (Err(false), None));
         assert_eq!(next(), (Err(false), None));
     }
-
-    #[test]
-    pub fn test_get_key_state() -> Result<(), Box<dyn std::error::Error>> {
-        let (input, mut output) = get_test_device()?;
-
-        output.emit(&[key_event(KeyCode::KEY_DOT, 1)])?;
-
-        assert_eq!(1, input.get_key_state()?.iter().count());
-        assert!(input
-            .get_key_state()?
-            .iter()
-            .all(|e| e.code() == KeyCode::KEY_DOT.code()));
-
-        output.emit(&[key_event(KeyCode::KEY_DOT, 0)])?;
-
-        assert_eq!(0, input.get_key_state()?.iter().count());
-
-        Ok(())
-    }
 }

src/tests/attribute_set.rs

@@ -1,11 +1,12 @@
-use crate::tests::get_test_device;
 use crate::{AttributeSet, KeyCode};
 
 #[test]
 pub fn test_iteration_keys() -> std::io::Result<()> {
-    let (input, _) = get_test_device()?;
+    let mut keys: AttributeSet<KeyCode> = AttributeSet::new();
 
-    let keys = input.supported_keys().unwrap();
+    for code in 1..59 {
+        keys.insert(KeyCode::new(code));
+    }
 
     assert_eq!(58, keys.iter().count());
 

src/tests/mod.rs

@@ -1,87 +1 @@
 mod attribute_set;
-mod compensate;
-
-use crate::uinput::VirtualDevice;
-use crate::{AttributeSet, BusType, Device, EventType, InputEvent, InputId, KeyCode, SwitchCode};
-use std::path::PathBuf;
-use std::thread;
-use std::time::Duration;
-
-pub fn key_click(key: KeyCode) -> Vec<InputEvent> {
-    vec![key_event(key, 1), key_event(key, 0)]
-}
-
-pub fn key_event(key: KeyCode, key_state: i32) -> InputEvent {
-    InputEvent::new(EventType::KEY.0, key.code(), key_state)
-}
-
-pub fn get_test_device() -> std::io::Result<(Device, VirtualDevice)> {
-    let (name, output) = get_device()?;
-
-    let mut input = Device::open(&name)?;
-
-    input.grab()?;
-
-    Ok((input, output))
-}
-
-pub fn get_device() -> std::io::Result<(PathBuf, VirtualDevice)> {
-    let mut keys: AttributeSet<KeyCode> = AttributeSet::new();
-    for code in 1..59 {
-        let key = KeyCode::new(code);
-        let name = format!("{:?}", key);
-        if name.starts_with("KEY_") {
-            keys.insert(key);
-        }
-    }
-
-    let mut sw: AttributeSet<SwitchCode> = AttributeSet::new();
-
-    sw.insert(SwitchCode::SW_LID);
-    sw.insert(SwitchCode::SW_TABLET_MODE);
-
-    let mut device = VirtualDevice::builder()?
-        .input_id(InputId::new(BusType::BUS_USB, 0x1234, 0x5678, 0x111))
-        .name("test device")
-        .with_keys(&keys)?
-        .with_switches(&sw)?
-        .build()?;
-
-    // Fetch name.
-    let d: Vec<std::path::PathBuf> = device
-        .enumerate_dev_nodes_blocking()?
-        .map(|p| p.unwrap())
-        .collect();
-
-    thread::sleep(Duration::from_millis(100)); // To avoid permission denied.
-
-    Ok((d.first().unwrap().clone(), device))
-}
-
-pub fn final_dot_state(start_state: i32, events: impl Iterator<Item = InputEvent>) -> i32 {
-    events.fold(start_state, |state, ev| {
-        if ev.event_type() == EventType::KEY && ev.code() == KeyCode::KEY_DOT.code() {
-            if ev.value() == 0 {
-                0
-            } else {
-                1
-            }
-        } else {
-            state
-        }
-    })
-}
-
-pub fn final_event_state(key: KeyCode, events: &Vec<InputEvent>) -> Option<i32> {
-    events.iter().fold(None, |state, ev| {
-        if ev.event_type() == EventType::KEY && ev.code() == key.code() {
-            if ev.value() == 0 {
-                Some(0)
-            } else {
-                Some(1)
-            }
-        } else {
-            state
-        }
-    })
-}

tests/common/mod.rs

@@ -0,0 +1,86 @@
+#![allow(dead_code)]
+
+use evdev::uinput::VirtualDevice;
+use evdev::{AttributeSet, BusType, Device, EventType, InputEvent, InputId, KeyCode, SwitchCode};
+use std::path::PathBuf;
+use std::thread;
+use std::time::Duration;
+
+pub fn key_click(key: KeyCode) -> Vec<InputEvent> {
+    vec![key_event(key, 1), key_event(key, 0)]
+}
+
+pub fn key_event(key: KeyCode, key_state: i32) -> InputEvent {
+    InputEvent::new(EventType::KEY.0, key.code(), key_state)
+}
+
+pub fn get_test_device() -> std::io::Result<(Device, VirtualDevice)> {
+    let (name, output) = get_device()?;
+
+    let mut input = Device::open(&name)?;
+
+    input.grab()?;
+
+    Ok((input, output))
+}
+
+pub fn get_device() -> std::io::Result<(PathBuf, VirtualDevice)> {
+    let mut keys: AttributeSet<KeyCode> = AttributeSet::new();
+    for code in 1..59 {
+        let key = KeyCode::new(code);
+        let name = format!("{:?}", key);
+        if name.starts_with("KEY_") {
+            keys.insert(key);
+        }
+    }
+
+    let mut sw: AttributeSet<SwitchCode> = AttributeSet::new();
+
+    sw.insert(SwitchCode::SW_LID);
+    sw.insert(SwitchCode::SW_TABLET_MODE);
+
+    let mut device = VirtualDevice::builder()?
+        .input_id(InputId::new(BusType::BUS_USB, 0x1234, 0x5678, 0x111))
+        .name("test device")
+        .with_keys(&keys)?
+        .with_switches(&sw)?
+        .build()?;
+
+    // Fetch name.
+    let d: Vec<std::path::PathBuf> = device
+        .enumerate_dev_nodes_blocking()?
+        .map(|p| p.unwrap())
+        .collect();
+
+    thread::sleep(Duration::from_millis(100)); // To avoid permission denied.
+
+    Ok((d.first().unwrap().clone(), device))
+}
+
+pub fn final_dot_state(start_state: i32, events: impl Iterator<Item = InputEvent>) -> i32 {
+    events.fold(start_state, |state, ev| {
+        if ev.event_type() == EventType::KEY && ev.code() == KeyCode::KEY_DOT.code() {
+            if ev.value() == 0 {
+                0
+            } else {
+                1
+            }
+        } else {
+            state
+        }
+    })
+}
+
+pub fn final_event_state(key: KeyCode, events: &Vec<InputEvent>) -> Option<i32> {
+    events.iter().fold(None, |state, ev| {
+        if ev.event_type() == EventType::KEY && ev.code() == key.code() {
+            if ev.value() == 0 {
+                Some(0)
+            } else {
+                Some(1)
+            }
+        } else {
+            state
+        }
+    })
+}

src/tests/compensate.rs renamed to tests/compensate.rs

@@ -1,5 +1,9 @@
-use crate::tests::{final_dot_state, final_event_state, get_test_device, key_click, key_event};
-use crate::{EventType, InputEvent, KeyCode, SwitchCode};
+#![cfg(feature = "device-test")]
+
+mod common;
+
+use common::{final_dot_state, final_event_state, get_test_device, key_click, key_event};
+use evdev::{EventType, InputEvent, KeyCode, SwitchCode};
 
 #[test]
 pub fn test_compensate_keys() -> std::io::Result<()> {

tests/device.rs

@@ -0,0 +1,25 @@
+#![cfg(feature = "device-test")]
+
+mod common;
+
+use common::{get_test_device, key_event};
+use evdev::KeyCode;
+
+#[test]
+pub fn test_get_key_state() -> Result<(), Box<dyn std::error::Error>> {
+    let (input, mut output) = get_test_device()?;
+
+    output.emit(&[key_event(KeyCode::KEY_DOT, 1)])?;
+
+    assert_eq!(1, input.get_key_state()?.iter().count());
+    assert!(input
+        .get_key_state()?
+        .iter()
+        .all(|e| e.code() == KeyCode::KEY_DOT.code()));
+
+    output.emit(&[key_event(KeyCode::KEY_DOT, 0)])?;
+
+    assert_eq!(0, input.get_key_state()?.iter().count());
+
+    Ok(())
+}