Merge pull request #160 from hpccc53/main

Author: emberian

src/attribute_set.rs

@@ -38,11 +38,6 @@ impl<T: EvdevEnum> AttributeSetRef<T> {
         self.into_iter()
     }
 
-    #[inline]
-    pub(crate) fn slice(&self, start: T) -> &Self {
-        Self::new(&self.bitslice[start.to_index()..])
-    }
-
     pub fn insert(&mut self, attr: T) {
         self.set(attr, true)
     }
@@ -56,6 +51,17 @@ impl<T: EvdevEnum> AttributeSetRef<T> {
     pub(crate) fn set(&mut self, attr: T, on: bool) {
         self.bitslice.set(attr.to_index(), on)
     }
+
+    #[inline]
+    pub(crate) fn slice_iter(&self, start: T) -> AttributeSetRefIter<T> {
+        let slice = Self::new(&self.bitslice[start.to_index()..]);
+
+        AttributeSetRefIter {
+            _indexer: std::marker::PhantomData,
+            inner: slice.bitslice.iter_ones(),
+            offset: start.to_index(),
+        }
+    }
 }
 
 impl<T: EvdevEnum + fmt::Debug> fmt::Debug for AttributeSetRef<T> {
@@ -83,20 +89,24 @@ impl<'a, T: EvdevEnum> IntoIterator for &'a AttributeSetRef<T> {
         AttributeSetRefIter {
             _indexer: std::marker::PhantomData,
             inner: self.bitslice.iter_ones(),
+            offset: 0,
         }
     }
 }
 
 pub struct AttributeSetRefIter<'a, T> {
     _indexer: std::marker::PhantomData<&'a T>,
     inner: bitvec::slice::IterOnes<'a, u8, Lsb0>,
+    offset: usize,
 }
 
 impl<T: EvdevEnum> Iterator for AttributeSetRefIter<'_, T> {
     type Item = T;
 
     fn next(&mut self) -> Option<Self::Item> {
-        self.inner.next().map(T::from_index)
+        self.inner
+            .next()
+            .map(|idx| T::from_index(self.offset + idx))
     }
 }
 

src/lib.rs

@@ -175,6 +175,8 @@ pub mod raw_stream;
 mod scancodes;
 mod sync_stream;
 mod sys;
+#[cfg(test)]
+mod tests;
 pub mod uinput;
 
 use crate::compat::{input_absinfo, input_event, uinput_abs_setup};

src/sync_stream.rs

@@ -485,12 +485,12 @@ fn compensate_events(state: &mut Option<SyncState>, dev: &mut Device) -> Option<
     macro_rules! try_compensate {
         ($time:expr, $start:ident : $typ:ident, $evtype:ident, $sync:ident, $supporteds:ident, $state:ty, $get_state:expr, $get_value:expr) => {
             if let Some(supported_types) = dev.$supporteds() {
-                let types_to_check = supported_types.slice(*$start);
+                let types_to_check = supported_types.slice_iter(*$start);
                 let get_state: fn(&DeviceState) -> $state = $get_state;
                 let vals = get_state(&dev.state);
                 let old_vals = get_state(&dev.prev_state);
                 let get_value: fn($state, $typ) -> _ = $get_value;
-                for typ in types_to_check.iter() {
+                for typ in types_to_check {
                     let prev = get_value(old_vals, typ);
                     let value = get_value(vals, typ);
                     if prev != value {
@@ -889,6 +889,7 @@ 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],
@@ -956,4 +957,23 @@ 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

@@ -0,0 +1,36 @@
+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 keys = input.supported_keys().unwrap();
+
+    assert_eq!(58, keys.iter().count());
+
+    let mut expected: i16 = 58;
+
+    for typ in keys.iter() {
+        expected -= 1;
+
+        assert_eq!(
+            expected as usize,
+            keys.slice_iter(KeyCode(typ.0 + 1)).count()
+        );
+    }
+
+    Ok(())
+}
+
+#[test]
+pub fn test_first_element_in_slice_iter() -> std::io::Result<()> {
+    let mut keys: AttributeSet<KeyCode> = AttributeSet::new();
+    keys.insert(KeyCode(0));
+    keys.insert(KeyCode(1));
+
+    assert_eq!(KeyCode(0), keys.slice_iter(KeyCode(0)).nth(0).unwrap());
+    assert_eq!(KeyCode(1), keys.slice_iter(KeyCode(1)).nth(0).unwrap());
+
+    Ok(())
+}

src/tests/compensate.rs

@@ -0,0 +1,93 @@
+use crate::tests::{final_dot_state, final_event_state, get_test_device, key_click, key_event};
+use crate::{EventType, InputEvent, KeyCode, SwitchCode};
+
+#[test]
+pub fn test_compensate_keys() -> std::io::Result<()> {
+    let (mut input, mut output) = get_test_device()?;
+
+    let dot_state: i32 = 0;
+
+    // Make overflow.
+    for _ in 0..30 {
+        output.emit(&key_click(KeyCode::KEY_DOT))?;
+    }
+
+    let dot_state = final_dot_state(dot_state, input.fetch_events()?);
+
+    assert_eq!(0, dot_state);
+
+    // Press and release.
+    output.emit(&key_click(KeyCode::KEY_DOT))?;
+
+    let dot_state = final_dot_state(dot_state, input.fetch_events()?);
+
+    assert_eq!(0, dot_state);
+
+    // Just press.
+    output.emit(&[key_event(KeyCode::KEY_DOT, 1)])?;
+
+    let dot_state = final_dot_state(dot_state, input.fetch_events()?);
+
+    assert_eq!(1, dot_state);
+
+    Ok(())
+}
+
+#[test]
+pub fn test_compensate_with_key_down() -> std::io::Result<()> {
+    let (mut input, mut output) = get_test_device()?;
+
+    output.emit(&[InputEvent::new(EventType::KEY.0, KeyCode::KEY_A.0, 1)])?;
+    output.emit(&[InputEvent::new(EventType::KEY.0, KeyCode::KEY_B.0, 1)])?;
+
+    // Make overflow.
+    for _ in 0..30 {
+        output.emit(&key_click(KeyCode::KEY_DOT))?;
+    }
+
+    assert_eq!(0, input.fetch_events()?.into_iter().count());
+
+    // Press and release.
+    output.emit(&key_click(KeyCode::KEY_DOT))?;
+
+    let events = input
+        .fetch_events()?
+        .into_iter()
+        .collect::<Vec<InputEvent>>();
+
+    assert_eq!(Some(1), final_event_state(KeyCode::KEY_A, &events));
+    assert_eq!(Some(1), final_event_state(KeyCode::KEY_B, &events));
+
+    Ok(())
+}
+
+#[test]
+pub fn test_compensate_with_switch_down() -> std::io::Result<()> {
+    let (mut input, mut output) = get_test_device()?;
+
+    let dot_state: i32 = 0;
+
+    output.emit(&[InputEvent::new(
+        EventType::SWITCH.0,
+        SwitchCode::SW_LID.0,
+        1,
+    )])?;
+
+    // Make overflow.
+    for _ in 0..30 {
+        output.emit(&key_click(KeyCode::KEY_DOT))?;
+    }
+
+    let dot_state = final_dot_state(dot_state, input.fetch_events()?);
+
+    assert_eq!(0, dot_state);
+
+    // Press and release.
+    output.emit(&key_click(KeyCode::KEY_DOT))?;
+
+    let dot_state = final_dot_state(dot_state, input.fetch_events()?);
+
+    assert_eq!(0, dot_state);
+
+    Ok(())
+}

src/tests/mod.rs

@@ -0,0 +1,87 @@
+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
+        }
+    })
+}