Add test for interface descriptors

Author: mvirkkunen

src/test_class.rs

@@ -24,6 +24,7 @@ mod sizes {
 /// requests for testing USB peripheral drivers on actual hardware.
 pub struct TestClass<'a, B: UsbBus> {
     custom_string: StringIndex,
+    interface_string: StringIndex,
     iface: InterfaceNumber,
     ep_bulk_in: EndpointIn<'a, B>,
     ep_bulk_out: EndpointOut<'a, B>,
@@ -47,6 +48,7 @@ pub const MANUFACTURER: &'static str = "TestClass Manufacturer";
 pub const PRODUCT: &'static str = "virkkunen.net usb-device TestClass";
 pub const SERIAL_NUMBER: &'static str = "TestClass Serial";
 pub const CUSTOM_STRING: &'static str = "TestClass Custom String";
+pub const INTERFACE_STRING: &'static str = "TestClass Interface";
 
 pub const REQ_STORE_REQUEST: u8 = 1;
 pub const REQ_READ_BUFFER: u8 = 2;
@@ -63,6 +65,7 @@ impl<B: UsbBus> TestClass<'_, B> {
     pub fn new(alloc: &UsbBusAllocator<B>) -> TestClass<'_, B> {
         TestClass {
             custom_string: alloc.string(),
+            interface_string: alloc.string(),
             iface: alloc.interface(),
             ep_bulk_in: alloc.bulk(sizes::BULK_ENDPOINT),
             ep_bulk_out: alloc.bulk(sizes::BULK_ENDPOINT),
@@ -197,16 +200,21 @@ impl<B: UsbBus> UsbClass<B> for TestClass<'_, B> {
         writer.endpoint(&self.ep_bulk_out)?;
         writer.endpoint(&self.ep_interrupt_in)?;
         writer.endpoint(&self.ep_interrupt_out)?;
+        writer.interface_alt(self.iface, 1, 0xff, 0x01, 0x00, Some(self.interface_string))?;
 
         Ok(())
     }
 
     fn get_string(&self, index: StringIndex, lang_id: u16) -> Option<&str> {
-        if index == self.custom_string && lang_id == descriptor::lang_id::ENGLISH_US {
-            Some(CUSTOM_STRING)
-        } else {
-            None
+        if lang_id == descriptor::lang_id::ENGLISH_US {
+            if index == self.custom_string {
+                return Some(CUSTOM_STRING)
+            } else if index == self.interface_string {
+                return Some(INTERFACE_STRING);
+            }
         }
+
+        None
     }
 
     fn endpoint_in_complete(&mut self, addr: EndpointAddress) {

tests/test_class_host/tests.rs

@@ -30,28 +30,6 @@ macro_rules! tests {
 
 tests! {
 
-fn string_descriptors(dev, _out) {
-    assert_eq!(
-        dev.read_product_string(dev.en_us, &dev.device_descriptor, TIMEOUT)
-            .expect("read product string"),
-        test_class::PRODUCT);
-
-    assert_eq!(
-        dev.read_manufacturer_string(dev.en_us, &dev.device_descriptor, TIMEOUT)
-            .expect("read manufacturer string"),
-        test_class::MANUFACTURER);
-
-    assert_eq!(
-        dev.read_serial_number_string(dev.en_us, &dev.device_descriptor, TIMEOUT)
-            .expect("read serial number string"),
-        test_class::SERIAL_NUMBER);
-
-    assert_eq!(
-        dev.read_string_descriptor(dev.en_us, 4, TIMEOUT)
-            .expect("read custom string"),
-        test_class::CUSTOM_STRING);
-}
-
 fn control_request(dev, _out) {
     let mut rng = rand::thread_rng();
 
@@ -133,6 +111,58 @@ fn control_error(dev, _out) {
     }
 }
 
+fn string_descriptors(dev, _out) {
+    assert_eq!(
+        dev.read_product_string(dev.en_us, &dev.device_descriptor, TIMEOUT)
+            .expect("read product string"),
+        test_class::PRODUCT);
+
+    assert_eq!(
+        dev.read_manufacturer_string(dev.en_us, &dev.device_descriptor, TIMEOUT)
+            .expect("read manufacturer string"),
+        test_class::MANUFACTURER);
+
+    assert_eq!(
+        dev.read_serial_number_string(dev.en_us, &dev.device_descriptor, TIMEOUT)
+            .expect("read serial number string"),
+        test_class::SERIAL_NUMBER);
+
+    assert_eq!(
+        dev.read_string_descriptor(dev.en_us, 4, TIMEOUT)
+            .expect("read custom string"),
+        test_class::CUSTOM_STRING);
+}
+
+fn interface_descriptor(dev, _out) {
+    let iface = dev.config_descriptor
+        .interfaces()
+        .find(|i| i.number() == 0)
+        .expect("interface not found");
+
+    let default_alt_setting = iface.descriptors()
+        .find(|i| i.setting_number() == 0)
+        .expect("default alt setting not found");
+
+    assert_eq!(default_alt_setting.description_string_index(), None);
+    assert_eq!(default_alt_setting.class_code(), 0xff);
+    assert_eq!(default_alt_setting.sub_class_code(), 0x00);
+
+    let second_alt_setting = iface.descriptors()
+        .find(|i| i.setting_number() == 1)
+        .expect("second alt setting not found");
+
+    assert_eq!(second_alt_setting.class_code(), 0xff);
+    assert_eq!(second_alt_setting.sub_class_code(), 0x01);
+
+    let string_index = second_alt_setting.description_string_index()
+        .expect("second alt setting string is undefined");
+
+    assert_eq!(
+        dev.read_string_descriptor(dev.en_us, string_index, TIMEOUT)
+            .expect("read interface string"),
+        test_class::INTERFACE_STRING);
+}
+
 fn bulk_loopback(dev, _out) {
     for len in &[0, 1, 2, 32, 63, 64, 65, 127, 128, 129] {
         let data = random_data(*len);