Refactor tests to take rusb r/t device handle

Need to support a test that hard resets the device and ensures that it
re-enumerates.  The current model supplies a device handle to the test
case, but this case will require a handle to the rusb context so that it
can determine when the device has enumerated.

Author: ianrrees

tests/test_class_host/device.rs

@@ -1,7 +1,11 @@
 use rusb::{ConfigDescriptor, Context, DeviceDescriptor, DeviceHandle, Language, UsbContext as _};
+use std::thread;
 use std::time::Duration;
+use usb_device::device::CONFIGURATION_VALUE;
 use usb_device::test_class;
 
+const TEST_INTERFACE: u8 = 0;
+
 pub const TIMEOUT: Duration = Duration::from_secs(1);
 pub const EN_US: u16 = 0x0409;
 
@@ -18,6 +22,7 @@ impl DeviceHandles {
     pub fn is_high_speed(&self) -> bool {
         self.handle.device().speed() == rusb::Speed::High
     }
+
     /// Returns the max packet size for the `TestClass` bulk endpoint(s).
     pub fn bulk_max_packet_size(&self) -> u16 {
         self.config_descriptor
@@ -34,6 +39,40 @@ impl DeviceHandles {
             .next()
             .expect("TestClass has at least one bulk endpoint")
     }
+
+    /// Puts the device in a consistent state for running a test
+    pub fn pre_test(&mut self) -> rusb::Result<()> {
+        let res = self.reset();
+        if let Err(err) = res {
+            println!("Failed to reset the device: {}", err);
+            return res;
+        }
+
+        let res = self.set_active_configuration(CONFIGURATION_VALUE);
+        if let Err(err) = res {
+            println!("Failed to set active configuration: {}", err);
+            return res;
+        }
+
+        let res = self.claim_interface(TEST_INTERFACE);
+        if let Err(err) = res {
+            println!("Failed to claim interface: {}", err);
+            return res;
+        }
+
+        Ok(())
+    }
+
+    /// Cleanup the device following a test
+    pub fn post_test(&mut self) -> rusb::Result<()> {
+        let res = self.release_interface(TEST_INTERFACE);
+        if let Err(err) = res {
+            println!("Failed to release interface: {}", err);
+            return res;
+        }
+
+        Ok(())
+    }
 }
 
 impl ::std::ops::Deref for DeviceHandles {
@@ -50,38 +89,102 @@ impl ::std::ops::DerefMut for DeviceHandles {
     }
 }
 
-pub fn open_device(ctx: &Context) -> rusb::Result<DeviceHandles> {
-    for device in ctx.devices()?.iter() {
-        let device_descriptor = device.device_descriptor()?;
+pub struct UsbContext {
+    /// rusb Context handle
+    inner: Context,
+    device: Option<DeviceHandles>,
+}
 
-        if !(device_descriptor.vendor_id() == test_class::VID
-            && device_descriptor.product_id() == test_class::PID)
-        {
-            continue;
-        }
+impl UsbContext {
+    pub fn new() -> rusb::Result<Self> {
+        let inner = rusb::Context::new()?;
 
-        let mut handle = device.open()?;
+        Ok(Self {
+            inner,
+            device: None,
+        })
+    }
+
+    /// Attempt to open the test device once
+    fn try_open_device(&self) -> rusb::Result<DeviceHandles> {
+        for device in self.inner.devices()?.iter() {
+            let device_descriptor = device.device_descriptor()?;
+
+            if !(device_descriptor.vendor_id() == test_class::VID
+                && device_descriptor.product_id() == test_class::PID)
+            {
+                continue;
+            }
+
+            let mut handle = device.open()?;
+
+            let langs = handle.read_languages(TIMEOUT)?;
+            if langs.is_empty() || langs[0].lang_id() != EN_US {
+                continue;
+            }
+
+            let prod = handle.read_product_string(langs[0], &device_descriptor, TIMEOUT)?;
+
+            if prod == test_class::PRODUCT {
+                handle.reset()?;
+
+                let config_descriptor = device.config_descriptor(0)?;
 
-        let langs = handle.read_languages(TIMEOUT)?;
-        if langs.is_empty() || langs[0].lang_id() != EN_US {
-            continue;
+                return Ok(DeviceHandles {
+                    device_descriptor,
+                    config_descriptor,
+                    handle,
+                    en_us: langs[0],
+                });
+            }
         }
 
-        let prod = handle.read_product_string(langs[0], &device_descriptor, TIMEOUT)?;
+        Err(rusb::Error::NoDevice)
+    }
 
-        if prod == test_class::PRODUCT {
-            handle.reset()?;
+    /// Look for the device for about 5 seconds in case it hasn't finished enumerating yet
+    pub fn open_device(&mut self) -> rusb::Result<&mut DeviceHandles> {
+        if self.device.is_none() {
+            for _ in 0..50 {
+                if let Ok(dev) = self.try_open_device() {
+                    self.device = Some(dev);
+                    break;
+                }
+                thread::sleep(Duration::from_millis(100));
+            }
+        }
 
-            let config_descriptor = device.config_descriptor(0)?;
+        match self.device.as_mut() {
+            Some(device) => Ok(device),
+            None => Err(rusb::Error::NoDevice),
+        }
+    }
 
-            return Ok(DeviceHandles {
-                device_descriptor,
-                config_descriptor,
-                handle,
-                en_us: langs[0],
-            });
+    /// Attempts to open (if necessary) and (re-)initialize a device for a test
+    pub fn device_for_test(&mut self) -> rusb::Result<&mut DeviceHandles> {
+        let dev = match self.open_device() {
+            Ok(dev) => dev,
+            Err(err) => {
+                println!("Did not find a TestClass device. Make sure the device is correctly programmed and plugged in. Last error: {}", err);
+                return Err(err);
+            }
+        };
+
+        match dev.pre_test() {
+            Ok(()) => Ok(dev),
+            Err(err) => {
+                println!("Failed to prepare for test: {}", err);
+                Err(err)
+            }
         }
     }
 
-    Err(rusb::Error::NoDevice)
+    /// Releases resources that might have been used in a test
+    pub fn cleanup_after_test(&mut self) -> rusb::Result<()> {
+        if let Some(dev) = &mut self.device {
+            dev.post_test()
+        } else {
+            Ok(())
+        }
+    }
 }

tests/test_class_host/main.rs

@@ -6,66 +6,27 @@ mod device;
 /// cannot be run in parallel.
 mod tests;
 
-use crate::device::open_device;
+use crate::device::UsbContext;
 use crate::tests::{get_tests, TestFn};
 use std::io::prelude::*;
 use std::io::stdout;
 use std::panic;
-use std::thread;
-use std::time::Duration;
-use usb_device::device::CONFIGURATION_VALUE;
 
 fn main() {
     let tests = get_tests();
     run_tests(&tests[..]);
 }
 
 fn run_tests(tests: &[(&str, TestFn)]) {
-    const INTERFACE: u8 = 0;
-
     println!("test_class_host starting");
     println!("looking for device...");
 
-    let ctx = rusb::Context::new().expect("create libusb context");
-
-    // Look for the device for about 5 seconds in case it hasn't finished enumerating yet
-    let mut dev = Err(rusb::Error::NoDevice);
-    for _ in 0..50 {
-        dev = open_device(&ctx);
-        if dev.is_ok() {
-            break;
-        }
-
-        thread::sleep(Duration::from_millis(100));
-    }
-
-    let mut dev = match dev {
-        Ok(d) => d,
-        Err(err) => {
-            println!("Did not find a TestClass device. Make sure the device is correctly programmed and plugged in. Last error: {}", err);
-            return;
-        }
-    };
+    let mut ctx = UsbContext::new().expect("create libusb context");
 
     println!("\nrunning {} tests", tests.len());
 
     let mut success = 0;
     for (name, test) in tests {
-        if let Err(err) = dev.reset() {
-            println!("Failed to reset the device: {}", err);
-            return;
-        }
-
-        if let Err(err) = dev.set_active_configuration(CONFIGURATION_VALUE) {
-            println!("Failed to set active configuration: {}", err);
-            return;
-        }
-
-        if let Err(err) = dev.claim_interface(INTERFACE) {
-            println!("Failed to claim interface: {}", err);
-            return;
-        }
-
         print!("test {} ... ", name);
         let _ = stdout().flush();
 
@@ -75,15 +36,14 @@ fn run_tests(tests: &[(&str, TestFn)]) {
             let hook = panic::take_hook();
             panic::set_hook(Box::new(|_| {}));
             let res = panic::catch_unwind(panic::AssertUnwindSafe(|| {
-                test(&mut dev, &mut out);
+                test(&mut ctx, &mut out);
             }));
             panic::set_hook(hook);
 
             res
         };
 
-        dev.release_interface(INTERFACE)
-            .expect("failed to release interface");
+        ctx.cleanup_after_test().expect("post test cleanup failed");
 
         if let Err(err) = res {
             let err = if let Some(err) = err.downcast_ref::<&'static str>() {