Add tests for libusbp_write_pipe.

DavidEGrayson · DavidEGrayson · commit b4666d15ec7f · 2018-11-23T16:56:54.000-08:00
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
@@ -21,10 +21,6 @@ set(USE_TEST_DEVICE_B FALSE CACHE BOOL
 
 file(GLOB test_sources *.cpp)
 
-if (APPLE)
-  set (link_flags "-framework CoreFoundation ${link_flags}")
-endif ()
-
 add_executable(run_test ${test_sources})
 
 set_target_properties(run_test PROPERTIES
diff --git a/test/device_test.cpp b/test/device_test.cpp
@@ -210,7 +210,7 @@ TEST_CASE("Test Device A", "[tda]")
     {
         // If this test fails, you should probably update
         // your Test Device A with the latest firmware.
-        REQUIRE(device.get_revision() == 0x0006);
+        REQUIRE(device.get_revision() == 0x0007);
     }
 
     SECTION("device instance id")
@@ -230,3 +230,22 @@ TEST_CASE("Test Device A", "[tda]")
     }
 }
 #endif
+
+#ifdef USE_TEST_DEVICE_B
+TEST_CASE("Test Device B", "[tdb]")
+{
+    libusbp::device device = find_test_device_b();
+
+    SECTION("present")
+    {
+        REQUIRE(device);
+    }
+
+    SECTION("revision code")
+    {
+        // If this test fails, you should probably update
+        // your Test Device B with the latest firmware.
+        REQUIRE(device.get_revision() == 0x0007);
+    }
+}
+#endif
diff --git a/test/firmware/wixel/main.c b/test/firmware/wixel/main.c
@@ -30,6 +30,9 @@
 #define ADC_DATA_ENDPOINT            2
 #define ADC_DATA_FIFO                USBF2
 #define ADC_DATA_PACKET_SIZE         5
+#define CMD_ENDPOINT                 3
+#define CMD_PACKET_SIZE              32
+#define CMD_FIFO                     USBF3
 
 #ifdef COMPOSITE
 #define NATIVE_INTERFACE_1           1
@@ -120,7 +123,7 @@ USB_DESCRIPTOR_DEVICE CODE usbDeviceDescriptor =
 #else
     0xDA01,                 // Product ID: USB Test Device A
 #endif
-    0x0006,                 // Device release number in BCD format
+    0x0007,                 // Device release number in BCD format
     1,                      // Index of Manufacturer String Descriptor
     2,                      // Index of Product String Descriptor
     3,                      // Index of Serial Number String Descriptor
@@ -134,6 +137,8 @@ struct CONFIG1 {
     USB_DESCRIPTOR_CONFIGURATION configuration;
     USB_DESCRIPTOR_INTERFACE nativeInterface0;
     USB_DESCRIPTOR_ENDPOINT adcDataIn;
+    USB_DESCRIPTOR_ENDPOINT cmdOut;
+    USB_DESCRIPTOR_ENDPOINT cmdIn;
     USB_DESCRIPTOR_INTERFACE nativeInterface1;
     USB_DESCRIPTOR_INTERFACE_ASSOCIATION portFunction;
     USB_DESCRIPTOR_INTERFACE portCommunicationInterface;
@@ -160,7 +165,7 @@ struct CONFIG1 {
         USB_DESCRIPTOR_TYPE_INTERFACE,
         NATIVE_INTERFACE_0,  // bInterfaceNumber
         0,                   // bAlternateSetting
-        1,                   // bNumEndpoints
+        3,                   // bNumEndpoints
         0xFF,                // bInterfaceClass: Vendor Specific
         0x00,                // bInterfaceSubClass
         0x00,                // bInterfaceProtocol
@@ -176,6 +181,24 @@ struct CONFIG1 {
         1,
     },
 
+    {
+        sizeof(USB_DESCRIPTOR_ENDPOINT),
+        USB_DESCRIPTOR_TYPE_ENDPOINT,
+        USB_ENDPOINT_ADDRESS_OUT | CMD_ENDPOINT,
+        USB_TRANSFER_TYPE_BULK,
+        CMD_PACKET_SIZE,
+        0,
+    },
+
+    {
+        sizeof(USB_DESCRIPTOR_ENDPOINT),
+        USB_DESCRIPTOR_TYPE_ENDPOINT,
+        USB_ENDPOINT_ADDRESS_IN | CMD_ENDPOINT,
+        USB_TRANSFER_TYPE_BULK,
+        CMD_PACKET_SIZE,
+        0,
+    },
+
     {
         sizeof(USB_DESCRIPTOR_INTERFACE),
         USB_DESCRIPTOR_TYPE_INTERFACE,
@@ -470,6 +493,8 @@ bool yellowOn = 0;
 void usbCallbackInitEndpoints()
 {
     usbInitEndpointIn(ADC_DATA_ENDPOINT, ADC_DATA_PACKET_SIZE);
+    usbInitEndpointOut(CMD_ENDPOINT, CMD_PACKET_SIZE);
+    usbInitEndpointIn(CMD_ENDPOINT, CMD_PACKET_SIZE);
 }
 
 void usbCallbackSetupHandler()
@@ -638,6 +663,55 @@ void adcDataTx()
     }
 }
 
+void cmdService()
+{
+    uint8_t count, cmd, i;
+    uint16_t delay;
+
+    if (usbDeviceState != USB_STATE_CONFIGURED) { return; }
+
+    USBINDEX = CMD_ENDPOINT;
+    if (!(USBCSOL & USBCSOL_OUTPKT_RDY))
+    {
+        // No command packet available right now.
+        return;
+    }
+
+    count = USBCNTL;
+
+    if (count == 0)
+    {
+        // Empty packet
+        dataBuffer[0] = 0x66;
+    }
+
+    if (count >= 2)
+    {
+      cmd = CMD_FIFO;
+
+      // Command 0x92: Set a byte in dataBuffer
+      if (cmd == 0x92)
+      {
+          dataBuffer[0] = CMD_FIFO;
+      }
+
+      // Command 0xDE: Delay
+      if (cmd == 0xDE)
+      {
+          delay = CMD_FIFO;
+          delay += CMD_FIFO << 8;
+          delayMs(delay);
+      }
+    }
+
+    for (i = 0; i < count; i++)
+    {
+      CMD_FIFO;
+    }
+
+    USBCSOL &= ~USBCSOL_OUTPKT_RDY;  // Done with this packet.
+}
+
 void main()
 {
     uint8_t x = 0;
@@ -650,6 +724,7 @@ void main()
         usbShowStatusWithGreenLed();
         usbPoll();
         adcDataTx();
+        cmdService();
         LED_YELLOW(yellowOn);
 
         if (!isPinHigh(0))
diff --git a/test/write_pipe_test.cpp b/test/write_pipe_test.cpp
@@ -0,0 +1,164 @@
+#include <test_helper.h>
+
+#ifdef USE_TEST_DEVICE_A
+TEST_CASE("write_pipe parameter checking")
+{
+    libusbp::device device = find_test_device_a();
+    libusbp::generic_interface gi(device, 0, true);
+    libusbp::generic_handle handle(gi);
+    const uint8_t pipe = 0x03;
+    size_t transferred = 0xFFFF;
+
+    SECTION("sets transferred to zero if possible")
+    {
+        size_t transferred = 1;
+        libusbp::error error(libusbp_write_pipe(NULL,
+            0, NULL, 0, &transferred));
+        REQUIRE(transferred == 0);
+    }
+
+    SECTION("requires the buffer to be non-NULL")
+    {
+        try
+        {
+            handle.write_pipe(pipe, NULL, 2, &transferred);
+            REQUIRE(0);
+        }
+        catch(const libusbp::error & error)
+        {
+            REQUIRE(std::string(error.what()) ==
+                "Failed to write to pipe.  "
+                "Buffer is null.");
+            REQUIRE(transferred == 0);
+        }
+    }
+
+    SECTION("requires the direction bit to be correct")
+    {
+        try
+        {
+            uint8_t buffer[5];
+            handle.write_pipe(0x83, buffer, sizeof(buffer), &transferred);
+            REQUIRE(0);
+        }
+        catch (const libusbp::error & error)
+        {
+            REQUIRE(std::string(error.what()) ==
+                "Failed to write to pipe.  "
+                "Invalid pipe ID 0x83.");
+            REQUIRE(transferred == 0);
+        }
+    }
+
+    SECTION("checks the size")
+    {
+        uint8_t buffer[5];
+
+        #if defined(_WIN32)
+        size_t too_large_size = (size_t)ULONG_MAX + 1;
+        #elif defined(__linux__)
+        size_t too_large_size = (size_t)UINT_MAX + 1;
+        #elif defined(__APPLE__)
+        size_t too_large_size = (size_t)UINT32_MAX + 1;
+        #else
+        #error add a case for this OS
+        #endif
+
+        if (too_large_size == 0) { return; }
+
+        try
+        {
+            handle.write_pipe(pipe, buffer, too_large_size, NULL);
+            REQUIRE(0);
+        }
+        catch (const libusbp::error & error)
+        {
+            REQUIRE(error.message() == "Failed to write to pipe.  "
+              "Transfer size is too large.");
+        }
+    }
+}
+
+TEST_CASE("write_pipe (synchronous) on a bulk endpoint ", "[wpi]")
+{
+    // We assume that if write_pipe works on a bulk endpoint, it will also
+    // work on an interrupt endpoint because of the details of the underlying
+    // APIs that libusbp uses.
+
+    libusbp::device device = find_test_device_a();
+    libusbp::generic_interface gi(device, 0, true);
+    libusbp::generic_handle handle(gi);
+    const uint8_t pipe = 0x03;
+    handle.set_timeout(pipe, 100);
+    size_t transferred = 0xFFFF;
+
+    SECTION("can write one small packet")
+    {
+        uint8_t buffer[2] = { 0x92, 0x44 };
+        handle.write_pipe(pipe, buffer, sizeof(buffer), &transferred);
+        REQUIRE(transferred == sizeof(buffer));
+
+        // Read the data back.
+        uint8_t buffer2[1];
+        handle.control_transfer(0xC0, 0x91, 0, 1, buffer2, 1, &transferred);
+        REQUIRE(transferred == 1);
+        REQUIRE(buffer2[0] == 0x44);
+    }
+
+    #ifndef _WIN32
+    // TODO: get this to pass by using WinUSB's SHORT_PACKET_TERMINATE mode
+    SECTION("sends zero-length packets")
+    {
+        uint8_t buffer[32] = { 0x92, 0x33 };
+        handle.write_pipe(pipe, buffer, sizeof(buffer), NULL);
+
+        // Expect dataBuffer to contain 0x66 because of the ZLP.
+        uint8_t buffer2[1];
+        handle.control_transfer(0xC0, 0x91, 0, 1, buffer2, 1, &transferred);
+        REQUIRE(transferred == 1);
+        REQUIRE(buffer2[0] == 0x66);
+    }
+    #endif
+
+    SECTION("can write one small packet with null transferred pointer")
+    {
+        uint8_t buffer[2] = { 0x92, 0x55 };
+        handle.write_pipe(pipe, buffer, sizeof(buffer), NULL);
+
+        // Read the data back.
+        uint8_t buffer2[1];
+        handle.control_transfer(0xC0, 0x91, 0, 1, buffer2, 1, &transferred);
+        REQUIRE(transferred == 1);
+        REQUIRE(buffer2[0] == 85);
+    }
+
+    SECTION("can send zero-length trasnfers")
+    {
+        handle.write_pipe(pipe, NULL, 0, NULL);
+
+        // Expect dataBuffer to contain 0x66
+        uint8_t buffer2[1];
+        handle.control_transfer(0xC0, 0x91, 0, 1, buffer2, 1, &transferred);
+        REQUIRE(transferred == 1);
+        REQUIRE(buffer2[0] == 0x66);
+    }
+
+    SECTION("can time out")
+    {
+      // First packet causes a 150 ms delay, so this transfer will timeout after
+      // a partial data transfer.  Need three packets because of double
+      // buffering on the device.
+      uint8_t buffer[32 * 3] = { 0xDE, 150, 0 };
+      try
+      {
+        handle.write_pipe(pipe, buffer, sizeof(buffer), &transferred);
+        REQUIRE(0);
+      }
+      catch (const libusbp::error & e)
+      {
+        REQUIRE(e.has_code(LIBUSBP_ERROR_TIMEOUT));
+        REQUIRE(transferred == 64);
+      }
+    }
+}
+#endif
