expand test suite with new capability and playback tests

Author: JaskRendix

tests/test_backend_trait.rs

@@ -34,7 +34,7 @@ impl Backend for FakeBackend {
         Ok(RawDeviceInfo {
             name: "Fake Device".into(),
             capacity: 16,
-            features: vec![u64::MAX],
+            features: vec![u64::MAX, u64::MAX],
         })
     }
 
@@ -76,6 +76,11 @@ impl Backend for FakeBackend {
         }
     }
 
+    fn is_playing(handle: &Self::Handle, id: i32) -> ShakeResult<bool> {
+        let lock = handle.effects.lock().unwrap();
+        Ok(lock.get(id as usize).and_then(|e| e.as_ref()).is_some())
+    }
+
     fn set_gain(_handle: &Self::Handle, _value: u16) -> ShakeResult<()> {
         Ok(())
     }
@@ -157,15 +162,15 @@ fn backend_capabilities_match_raw_features() {
     let handle = open_first().unwrap();
     let caps = FakeBackend::capabilities(&handle).unwrap();
 
-    // RawDeviceInfo.features = [u64::MAX], so all bits are set.
     assert!(caps.rumble);
     assert!(caps.periodic);
+    assert!(caps.constant);
+    assert!(caps.ramp);
     assert!(caps.spring);
     assert!(caps.friction);
     assert!(caps.damper);
     assert!(caps.inertia);
 
-    // max_effects must match RawDeviceInfo.capacity
     assert_eq!(caps.max_effects, 16);
 }
 
@@ -176,9 +181,10 @@ fn backend_capabilities_are_stable() {
     let c1 = FakeBackend::capabilities(&handle).unwrap();
     let c2 = FakeBackend::capabilities(&handle).unwrap();
 
-    // Values must match exactly
     assert_eq!(c1.rumble, c2.rumble);
     assert_eq!(c1.periodic, c2.periodic);
+    assert_eq!(c1.constant, c2.constant);
+    assert_eq!(c1.ramp, c2.ramp);
     assert_eq!(c1.spring, c2.spring);
     assert_eq!(c1.friction, c2.friction);
     assert_eq!(c1.damper, c2.damper);
@@ -188,32 +194,26 @@ fn backend_capabilities_are_stable() {
 
 #[test]
 fn backend_capabilities_handle_empty_feature_vector() {
-    // Manually create a handle with no effects
     let handle = FakeHandle {
         effects: std::sync::Mutex::new(Vec::new()),
     };
 
-    // capabilities() must not panic even if the handle was not opened via scan/open
     let caps = FakeBackend::capabilities(&handle).unwrap();
 
-    // FakeBackend::query() always returns features = [u64::MAX]
-    // so all capability bits must be true
     assert!(caps.rumble);
     assert!(caps.periodic);
     assert!(caps.spring);
     assert!(caps.friction);
     assert!(caps.damper);
     assert!(caps.inertia);
 
-    // max_effects must match RawDeviceInfo.capacity
     assert_eq!(caps.max_effects, 16);
 }
 
 #[test]
 fn backend_capabilities_does_not_modify_effect_slots() {
     let handle = open_first().unwrap();
 
-    // Upload an effect
     let effect = Effect::Rumble(RumbleEffect {
         strong_magnitude: 1000,
         weak_magnitude: 500,
@@ -223,11 +223,7 @@ fn backend_capabilities_does_not_modify_effect_slots() {
     });
 
     let id = FakeBackend::upload(&handle, &effect).unwrap();
-
-    // Calling capabilities() must not erase or modify effects
     let _ = FakeBackend::capabilities(&handle).unwrap();
-
-    // Effect must still be playable
     FakeBackend::play(&handle, id).unwrap();
 }
 
@@ -297,8 +293,6 @@ fn backend_update_overwrites_effect() {
 
     let id = FakeBackend::upload(&handle, &e1).unwrap();
     FakeBackend::update(&handle, id, &e2).unwrap();
-
-    // play() must succeed, meaning the slot still exists
     FakeBackend::play(&handle, id).unwrap();
 }
 
@@ -318,20 +312,116 @@ fn backend_erase_does_not_shift_ids() {
     let id2 = FakeBackend::upload(&handle, &e).unwrap();
 
     FakeBackend::erase(&handle, id1).unwrap();
-
-    // id2 must still be valid
     FakeBackend::play(&handle, id2).unwrap();
 }
 
 #[test]
 fn backend_close_is_noop_and_safe() {
     let handle = open_first().unwrap();
 
-    // close must not panic
     FakeBackend::close(handle);
 
-    // open again must still work
     let handle2 = open_first().unwrap();
     let info = FakeBackend::query(&handle2).unwrap();
     assert_eq!(info.capacity, 16);
 }
+
+#[test]
+fn backend_is_playing_reports_status_correctly() {
+    let handle = open_first().unwrap();
+
+    let e = Effect::Rumble(RumbleEffect {
+        strong_magnitude: 1000,
+        weak_magnitude: 500,
+        duration: 200,
+        delay: 0,
+        direction: 0,
+    });
+
+    let id = FakeBackend::upload(&handle, &e).unwrap();
+    assert!(FakeBackend::is_playing(&handle, id).unwrap());
+
+    FakeBackend::erase(&handle, id).unwrap();
+    assert!(!FakeBackend::is_playing(&handle, id).unwrap());
+}
+
+#[test]
+fn backend_capabilities_includes_constant_and_ramp() {
+    let handle = open_first().unwrap();
+    let caps = FakeBackend::capabilities(&handle).unwrap();
+
+    assert!(caps.constant);
+    assert!(caps.ramp);
+}
+
+#[test]
+fn backend_capabilities_parses_partial_feature_masks() {
+    pub struct RestrictedBackend;
+
+    impl Backend for RestrictedBackend {
+        type Handle = FakeHandle;
+
+        fn scan() -> ShakeResult<Vec<PathBuf>> { Ok(vec![PathBuf::from("/dev/fake_restricted")]) }
+        fn open(_path: &Path) -> ShakeResult<Self::Handle> { Ok(FakeHandle { effects: std::sync::Mutex::new(Vec::new()) }) }
+        fn close(_handle: Self::Handle) {}
+
+        fn query(_handle: &Self::Handle) -> ShakeResult<RawDeviceInfo> {
+            let mut features = vec![0u64, 0u64];
+            features[1] |= 1 << (80 % 64); // FF_RUMBLE
+
+            Ok(RawDeviceInfo {
+                name: "Restricted Device".into(),
+                capacity: 4,
+                features,
+            })
+        }
+
+        fn upload(_: &Self::Handle, _: &Effect) -> ShakeResult<i32> { Ok(0) }
+        fn update(_: &Self::Handle, _: i32, _: &Effect) -> ShakeResult<()> { Ok(()) }
+        fn play(_: &Self::Handle, _: i32) -> ShakeResult<()> { Ok(()) }
+        fn stop(_: &Self::Handle, _: i32) -> ShakeResult<()> { Ok(()) }
+        fn erase(_: &Self::Handle, _: i32) -> ShakeResult<()> { Ok(()) }
+        fn is_playing(_: &Self::Handle, _: i32) -> ShakeResult<bool> { Ok(false) }
+        fn set_gain(_: &Self::Handle, _: u16) -> ShakeResult<()> { Ok(()) }
+        fn set_autocenter(_: &Self::Handle, _: u16) -> ShakeResult<()> { Ok(()) }
+    }
+
+    let handle = RestrictedBackend::open(Path::new("/dev/fake_restricted")).unwrap();
+    let caps = RestrictedBackend::capabilities(&handle).unwrap();
+
+    assert!(caps.rumble);
+    assert!(!caps.periodic);
+    assert!(!caps.constant);
+    assert!(!caps.spring);
+}
+
+#[test]
+fn backend_capabilities_handles_empty_or_short_feature_vectors() {
+    struct EmptyBackend;
+    impl Backend for EmptyBackend {
+        type Handle = FakeHandle;
+        fn scan() -> ShakeResult<Vec<PathBuf>> { Ok(vec![PathBuf::from("/dev/empty")]) }
+        fn open(_: &Path) -> ShakeResult<Self::Handle> { Ok(FakeHandle { effects: std::sync::Mutex::new(Vec::new()) }) }
+        fn close(_: Self::Handle) {}
+        fn query(_: &Self::Handle) -> ShakeResult<RawDeviceInfo> {
+            Ok(RawDeviceInfo { name: "Empty".into(), capacity: 0, features: vec![] })
+        }
+        fn upload(_: &Self::Handle, _: &Effect) -> ShakeResult<i32> { Ok(0) }
+        fn update(_: &Self::Handle, _: i32, _: &Effect) -> ShakeResult<()> { Ok(()) }
+        fn play(_: &Self::Handle, _: i32) -> ShakeResult<()> { Ok(()) }
+        fn stop(_: &Self::Handle, _: i32) -> ShakeResult<()> { Ok(()) }
+        fn erase(_: &Self::Handle, _: i32) -> ShakeResult<()> { Ok(()) }
+        fn is_playing(_: &Self::Handle, _: i32) -> ShakeResult<bool> { Ok(false) }
+        fn set_gain(_: &Self::Handle, _: u16) -> ShakeResult<()> { Ok(()) }
+        fn set_autocenter(_: &Self::Handle, _: u16) -> ShakeResult<()> { Ok(()) }
+    }
+
+    let handle = EmptyBackend::open(Path::new("/dev/empty")).unwrap();
+    let caps = EmptyBackend::capabilities(&handle).unwrap();
+
+    assert!(!caps.rumble);
+    assert!(!caps.periodic);
+    assert!(!caps.constant);
+    assert!(!caps.ramp);
+    assert_eq!(caps.max_effects, 0);
+}