Tests for Noolite::sendCommand was added

interfaces/iusbdevice.h

@@ -3,10 +3,13 @@
 
 #include <stdint.h>
 #include <chrono>
+#include <vector>
 
 namespace noolitelib
 {
 
+using Data = std::vector<unsigned char>;
+
 class IUsbDevice
 {
 public:
@@ -14,7 +17,7 @@ public:
 
     virtual void openDevice(uint16_t vendorId, uint16_t productId) = 0;
     virtual void close() = 0;
-    virtual bool sendDataToDevice(unsigned char *data, uint16_t length, std::chrono::milliseconds timeout) = 0;
+    virtual bool sendDataToDevice(const Data &data, std::chrono::milliseconds timeout) = 0;
 };
 
 }

src/libusbdevice.cpp

@@ -33,7 +33,7 @@ void LibUsbDevice::close()
     }
 }
 
-bool LibUsbDevice::sendDataToDevice(unsigned char *data, uint16_t length, std::chrono::milliseconds timeout)
+bool LibUsbDevice::sendDataToDevice(const Data &data, std::chrono::milliseconds timeout)
 {
     if (!m_device) {
         std::cout << "Device not opened" << std::endl;
@@ -42,7 +42,10 @@ bool LibUsbDevice::sendDataToDevice(unsigned char *data, uint16_t length, std::c
     auto requestType = LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_CLASS | LIBUSB_RECIPIENT_INTERFACE;
     auto request = LIBUSB_REQUEST_SET_CONFIGURATION;
 
-    auto status = libusb_control_transfer(m_device, requestType, request, 0, 0, data, length, timeout.count());
+    unsigned char package[data.size()];
+    std::copy(data.begin(), data.end(), package);
+
+    auto status = libusb_control_transfer(m_device, requestType, request, 0, 0, package, data.size(), timeout.count());
 
     if (status) {
         std::cout << "Sending data error: " << libusb_strerror(status) << std::endl;

src/libusbdevice.h

@@ -17,7 +17,7 @@ public:
 
     void openDevice(uint16_t vendorId, uint16_t productId) override;
     void close() override;
-    bool sendDataToDevice(unsigned char *data, uint16_t length, std::chrono::milliseconds timeout = std::chrono::seconds(1)) override;
+    bool sendDataToDevice(const Data &data, std::chrono::milliseconds timeout = std::chrono::seconds(1)) override;
 
 private:
     libusb_context *m_context = nullptr;

src/noolite.cpp

@@ -25,5 +25,14 @@ Noolite::~Noolite()
     delete m_device;
 }
 
+bool Noolite::sendCommand(int channel, Command command, Params params)
+{
+    (void) channel;
+    (void) command;
+    (void) params;
+
+    return false;
+}
+
 }
 

src/noolite.h

@@ -1,6 +1,8 @@
 #ifndef NOOLITE_H
 #define NOOLITE_H
 
+#include <vector>
+
 #include "interfaces/iusbdevice.h"
 
 namespace noolitelib
@@ -27,12 +29,16 @@ enum Command
     EffectSpeed
 };
 
+using Params = std::vector<int>;
+
 class Noolite
 {
 public:
     Noolite(IUsbDevice *device = nullptr);
     ~Noolite();
 
+    bool sendCommand(int channel, Command command, Params params = Params());
+
 private:
     IUsbDevice *m_device;
 };

tests/mocks/usbdevicemock.h

@@ -10,7 +10,7 @@ class UsbDeviceMock : public noolitelib::IUsbDevice
 public:
     MOCK_METHOD(void, openDevice, (uint16_t, uint16_t), (override));
     MOCK_METHOD(void, close, (), (override));
-    MOCK_METHOD(bool, sendDataToDevice, (unsigned char *, uint16_t, std::chrono::milliseconds), (override));
+    MOCK_METHOD(bool, sendDataToDevice, (const noolitelib::Data &data, std::chrono::milliseconds), (override));
 };
 
 #endif // USBDEVICEMOCK_H

tests/tst_adapter.cpp

@@ -18,3 +18,238 @@ TEST(noolite, createAndDeleteAdapter)
     noolitelib::Noolite *adapter = new noolitelib::Noolite(usbDevice);
     delete adapter;
 }
+
+TEST(noolite, sendCommand_Off)
+{
+    UsbDeviceMock *usbDevice = new UsbDeviceMock();
+
+    noolitelib::Noolite adapter(usbDevice);
+
+    noolitelib::Data expectedData{ 0x30, 0x0, 0x0, 0x0, 3, 0x0, 0x0, 0x0 };
+    EXPECT_CALL(*usbDevice, sendDataToDevice(expectedData, std::chrono::milliseconds())).
+        WillOnce(Return(true));
+
+    EXPECT_TRUE(adapter.sendCommand(3, noolitelib::Off));
+}
+
+TEST(noolite, sendCommand_DecreaseBrightnes)
+{
+    UsbDeviceMock *usbDevice = new UsbDeviceMock();
+
+    noolitelib::Noolite adapter(usbDevice);
+
+    noolitelib::Data expectedData{ 0x30, 0x01, 0x0, 0x0, 3, 0x0, 0x0, 0x0 };
+    EXPECT_CALL(*usbDevice, sendDataToDevice(expectedData, std::chrono::milliseconds())).
+        WillOnce(Return(true));
+
+    EXPECT_TRUE(adapter.sendCommand(3, noolitelib::DecraseBrightnes));
+}
+
+TEST(noolite, sendCommand_On)
+{
+    UsbDeviceMock *usbDevice = new UsbDeviceMock();
+
+    noolitelib::Noolite adapter(usbDevice);
+
+    noolitelib::Data expectedData{ 0x30, 0x02, 0x0, 0x0, 3, 0x0, 0x0, 0x0 };
+    EXPECT_CALL(*usbDevice, sendDataToDevice(expectedData, std::chrono::milliseconds())).
+        WillOnce(Return(true));
+
+    EXPECT_TRUE(adapter.sendCommand(3, noolitelib::On));
+}
+
+TEST(noolite, sendCommand_IncreaseBrightnes)
+{
+    UsbDeviceMock *usbDevice = new UsbDeviceMock();
+
+    noolitelib::Noolite adapter(usbDevice);
+
+    noolitelib::Data expectedData{ 0x30, 0x03, 0x0, 0x0, 3, 0x0, 0x0, 0x0 };
+    EXPECT_CALL(*usbDevice, sendDataToDevice(expectedData, std::chrono::milliseconds())).
+        WillOnce(Return(true));
+
+    EXPECT_TRUE(adapter.sendCommand(3, noolitelib::IncreaseBrightnes));
+}
+
+TEST(noolite, sendCommand_Switch)
+{
+    UsbDeviceMock *usbDevice = new UsbDeviceMock();
+
+    noolitelib::Noolite adapter(usbDevice);
+
+    noolitelib::Data expectedData{ 0x30, 0x04, 0x0, 0x0, 3, 0x0, 0x0, 0x0 };
+    EXPECT_CALL(*usbDevice, sendDataToDevice(expectedData, std::chrono::milliseconds())).
+        WillOnce(Return(true));
+
+    EXPECT_TRUE(adapter.sendCommand(3, noolitelib::Switch));
+}
+
+TEST(noolite, sendCommand_InvertBrightnes)
+{
+    UsbDeviceMock *usbDevice = new UsbDeviceMock();
+
+    noolitelib::Noolite adapter(usbDevice);
+
+    noolitelib::Data expectedData{ 0x30, 0x05, 0x0, 0x0, 3, 0x0, 0x0, 0x0 };
+    EXPECT_CALL(*usbDevice, sendDataToDevice(expectedData, std::chrono::milliseconds())).
+        WillOnce(Return(true));
+
+    EXPECT_TRUE(adapter.sendCommand(3, noolitelib::InvertBrightnes));
+}
+
+TEST(noolite, sendCommand_Set_OneChannel)
+{
+    UsbDeviceMock *usbDevice = new UsbDeviceMock();
+
+    noolitelib::Noolite adapter(usbDevice);
+
+    noolitelib::Data expectedData{ 0x30, 0x06, 0x01, 0x0, 3, 0x2A, 0x0, 0x0 };
+    EXPECT_CALL(*usbDevice, sendDataToDevice(expectedData, std::chrono::milliseconds())).
+        WillOnce(Return(true));
+
+    EXPECT_TRUE(adapter.sendCommand(3, noolitelib::Set, noolitelib::Params{ 42 }));
+}
+
+TEST(noolite, sendCommand_Set_ThreeChannels)
+{
+    UsbDeviceMock *usbDevice = new UsbDeviceMock();
+
+    noolitelib::Noolite adapter(usbDevice);
+
+    noolitelib::Data expectedData{ 0x30, 0x06, 0x03, 0x0, 3, 0x28, 0x29, 0x2A };
+    EXPECT_CALL(*usbDevice, sendDataToDevice(expectedData, std::chrono::milliseconds())).
+        WillOnce(Return(true));
+
+    EXPECT_TRUE(adapter.sendCommand(3, noolitelib::Set, noolitelib::Params{ 40, 41, 42 }));
+}
+
+TEST(noolite, sendCommand_Set_BadArguments)
+{
+    UsbDeviceMock *usbDevice = new UsbDeviceMock();
+
+    noolitelib::Noolite adapter(usbDevice);
+
+    EXPECT_CALL(*usbDevice, sendDataToDevice(_, _)).
+        Times(0);
+
+    EXPECT_FALSE(adapter.sendCommand(3, noolitelib::Set));
+    EXPECT_FALSE(adapter.sendCommand(3, noolitelib::Set, noolitelib::Params{ 40, 41 }));
+    EXPECT_FALSE(adapter.sendCommand(3, noolitelib::Set, noolitelib::Params{ 40, 41, 42, 43 }));
+}
+
+TEST(noolite, sendCommand_CallScenario)
+{
+    UsbDeviceMock *usbDevice = new UsbDeviceMock();
+
+    noolitelib::Noolite adapter(usbDevice);
+
+    noolitelib::Data expectedData{ 0x30, 0x07, 0x0, 0x0, 3, 0x0, 0x0, 0x0 };
+    EXPECT_CALL(*usbDevice, sendDataToDevice(expectedData, std::chrono::milliseconds())).
+        WillOnce(Return(true));
+
+    EXPECT_TRUE(adapter.sendCommand(3, noolitelib::CallScenario));
+}
+
+TEST(noolite, sendCommand_SaveScenario)
+{
+    UsbDeviceMock *usbDevice = new UsbDeviceMock();
+
+    noolitelib::Noolite adapter(usbDevice);
+
+    noolitelib::Data expectedData{ 0x30, 0x08, 0x0, 0x0, 3, 0x0, 0x0, 0x0 };
+    EXPECT_CALL(*usbDevice, sendDataToDevice(expectedData, std::chrono::milliseconds())).
+        WillOnce(Return(true));
+
+    EXPECT_TRUE(adapter.sendCommand(3, noolitelib::SaveScenario));
+}
+
+TEST(noolite, sendCommand_Unbind)
+{
+    UsbDeviceMock *usbDevice = new UsbDeviceMock();
+
+    noolitelib::Noolite adapter(usbDevice);
+
+    noolitelib::Data expectedData{ 0x30, 0x09, 0x0, 0x0, 3, 0x0, 0x0, 0x0 };
+    EXPECT_CALL(*usbDevice, sendDataToDevice(expectedData, std::chrono::milliseconds())).
+        WillOnce(Return(true));
+
+    EXPECT_TRUE(adapter.sendCommand(3, noolitelib::Unbind));
+}
+
+TEST(noolite, sendCommand_StopColorSelection)
+{
+    UsbDeviceMock *usbDevice = new UsbDeviceMock();
+
+    noolitelib::Noolite adapter(usbDevice);
+
+    noolitelib::Data expectedData{ 0x30, 0x0A, 0x0, 0x0, 3, 0x0, 0x0, 0x0 };
+    EXPECT_CALL(*usbDevice, sendDataToDevice(expectedData, std::chrono::milliseconds())).
+        WillOnce(Return(true));
+
+    EXPECT_TRUE(adapter.sendCommand(3, noolitelib::StopColorSelection));
+}
+
+TEST(noolite, sendCommand_Bind)
+{
+    UsbDeviceMock *usbDevice = new UsbDeviceMock();
+
+    noolitelib::Noolite adapter(usbDevice);
+
+    noolitelib::Data expectedData{ 0x30, 0x0B, 0x0, 0x0, 3, 0x0, 0x0, 0x0 };
+    EXPECT_CALL(*usbDevice, sendDataToDevice(expectedData, std::chrono::milliseconds())).
+        WillOnce(Return(true));
+
+    EXPECT_TRUE(adapter.sendCommand(3, noolitelib::Bind));
+}
+
+TEST(noolite, sendCommand_ColorSelection)
+{
+    UsbDeviceMock *usbDevice = new UsbDeviceMock();
+
+    noolitelib::Noolite adapter(usbDevice);
+
+    noolitelib::Data expectedData{ 0x30, 0x0C, 0x04, 0x0, 3, 0x0, 0x0, 0x0 };
+    EXPECT_CALL(*usbDevice, sendDataToDevice(expectedData, std::chrono::milliseconds())).
+        WillOnce(Return(true));
+
+    EXPECT_TRUE(adapter.sendCommand(3, noolitelib::ColorSelection));
+}
+
+TEST(noolite, sendCommand_ColorSwitch)
+{
+    UsbDeviceMock *usbDevice = new UsbDeviceMock();
+
+    noolitelib::Noolite adapter(usbDevice);
+
+    noolitelib::Data expectedData{ 0x30, 0x0D, 0x04, 0x0, 3, 0x0, 0x0, 0x0 };
+    EXPECT_CALL(*usbDevice, sendDataToDevice(expectedData, std::chrono::milliseconds())).
+        WillOnce(Return(true));
+
+    EXPECT_TRUE(adapter.sendCommand(3, noolitelib::ColorSwitch));
+}
+
+TEST(noolite, sendCommand_ModeSwitch)
+{
+    UsbDeviceMock *usbDevice = new UsbDeviceMock();
+
+    noolitelib::Noolite adapter(usbDevice);
+
+    noolitelib::Data expectedData{ 0x30, 0x0E, 0x04, 0x0, 3, 0x0, 0x0, 0x0 };
+    EXPECT_CALL(*usbDevice, sendDataToDevice(expectedData, std::chrono::milliseconds())).
+        WillOnce(Return(true));
+
+    EXPECT_TRUE(adapter.sendCommand(3, noolitelib::ModeSwitch));
+}
+
+TEST(noolite, sendCommand_EffectSpeed)
+{
+    UsbDeviceMock *usbDevice = new UsbDeviceMock();
+
+    noolitelib::Noolite adapter(usbDevice);
+
+    noolitelib::Data expectedData{ 0x30, 0x0F, 0x04, 0x0, 3, 0x0, 0x0, 0x0 };
+    EXPECT_CALL(*usbDevice, sendDataToDevice(expectedData, std::chrono::milliseconds())).
+        WillOnce(Return(true));
+
+    EXPECT_TRUE(adapter.sendCommand(3, noolitelib::EffectSpeed));
+}