From 34b4e10c62575e619f986e25043c333f34b87210 Mon Sep 17 00:00:00 2001 From: Moritz Martinius Date: Tue, 21 Oct 2025 20:29:33 +0200 Subject: [PATCH] Rename occurences Libusb -> LibUsb --- .../{LibusbWrapper.cpp => LibUsbWrapper.cpp} | 46 +++---- .../{LibusbWrapper.hpp => LibUsbWrapper.hpp} | 34 ++--- src/libusbwrap/UsbDevice.cpp | 36 +++-- src/libusbwrap/UsbDevice.hpp | 12 +- src/libusbwrap/UsbDeviceFactory.cpp | 25 ++-- src/libusbwrap/UsbDeviceFactory.hpp | 13 +- src/libusbwrap/interface/ILibUsbWrapper.hpp | 0 src/meson.build | 4 +- tests/meson.build | 6 +- ...ibusbWrapper.hpp => MockLibUsbWrapper.hpp} | 8 +- tests/usb_device_test/usb_device_test.cpp | 130 ++++++++---------- 11 files changed, 143 insertions(+), 171 deletions(-) rename src/libusbwrap/{LibusbWrapper.cpp => LibUsbWrapper.cpp} (59%) rename src/libusbwrap/{LibusbWrapper.hpp => LibUsbWrapper.hpp} (83%) create mode 100644 src/libusbwrap/interface/ILibUsbWrapper.hpp rename tests/mocks/{MockLibusbWrapper.hpp => MockLibUsbWrapper.hpp} (93%) diff --git a/src/libusbwrap/LibusbWrapper.cpp b/src/libusbwrap/LibUsbWrapper.cpp similarity index 59% rename from src/libusbwrap/LibusbWrapper.cpp rename to src/libusbwrap/LibUsbWrapper.cpp index c3dc7b7..9d18be8 100644 --- a/src/libusbwrap/LibusbWrapper.cpp +++ b/src/libusbwrap/LibUsbWrapper.cpp @@ -17,91 +17,91 @@ */ -#include "LibusbWrapper.hpp" +#include "LibUsbWrapper.hpp" #include "libusb.h" namespace libusbwrap { -// LibusbDeviceDeleter implementation -void LibusbDeviceDeleter::operator()(libusb_device* dev) const { +// LibUsbDeviceDeleter +void LibUsbDeviceDeleter::operator()(libusb_device* dev) const { if (dev && wrapper) { wrapper->unrefDevice(dev); } } -// LibusbWrapper implementation - thin forwarding to libusb C API +// LibUsbWrapper -int LibusbWrapper::init(libusb_context** ctx) { +int LibUsbWrapper::init(libusb_context** ctx) { return libusb_init(ctx); } -void LibusbWrapper::exit(libusb_context* ctx) { +void LibUsbWrapper::exit(libusb_context* ctx) { libusb_exit(ctx); } -ssize_t LibusbWrapper::getDeviceList(libusb_context* ctx, libusb_device*** list) { +ssize_t LibUsbWrapper::getDeviceList(libusb_context* ctx, libusb_device*** list) { return libusb_get_device_list(ctx, list); } -void LibusbWrapper::freeDeviceList(libusb_device** list, int unrefDevices) { +void LibUsbWrapper::freeDeviceList(libusb_device** list, int unrefDevices) { libusb_free_device_list(list, unrefDevices); } -void LibusbWrapper::refDevice(libusb_device* dev) { +void LibUsbWrapper::refDevice(libusb_device* dev) { libusb_ref_device(dev); } -void LibusbWrapper::unrefDevice(libusb_device* dev) { +void LibUsbWrapper::unrefDevice(libusb_device* dev) { libusb_unref_device(dev); } -int LibusbWrapper::getDeviceDescriptor(libusb_device* dev, libusb_device_descriptor* desc) { +int LibUsbWrapper::getDeviceDescriptor(libusb_device* dev, libusb_device_descriptor* desc) { return libusb_get_device_descriptor(dev, desc); } -int LibusbWrapper::open(libusb_device* dev, libusb_device_handle** handle) { +int LibUsbWrapper::open(libusb_device* dev, libusb_device_handle** handle) { return libusb_open(dev, handle); } -void LibusbWrapper::close(libusb_device_handle* handle) { +void LibUsbWrapper::close(libusb_device_handle* handle) { libusb_close(handle); } -int LibusbWrapper::getSpeed(libusb_device* dev) { +int LibUsbWrapper::getSpeed(libusb_device* dev) { return libusb_get_device_speed(dev); } -uint8_t LibusbWrapper::getBusNumber(libusb_device* dev) { +uint8_t LibUsbWrapper::getBusNumber(libusb_device* dev) { return libusb_get_bus_number(dev); } -uint8_t LibusbWrapper::getPortNumber(libusb_device* dev) { +uint8_t LibUsbWrapper::getPortNumber(libusb_device* dev) { return libusb_get_port_number(dev); } -int LibusbWrapper::kernelDriverActive(libusb_device_handle* handle, int interfaceNo) { +int LibUsbWrapper::kernelDriverActive(libusb_device_handle* handle, int interfaceNo) { return libusb_kernel_driver_active(handle, interfaceNo); } -int LibusbWrapper::detachKernelDriver(libusb_device_handle* handle, int interfaceNo) { +int LibUsbWrapper::detachKernelDriver(libusb_device_handle* handle, int interfaceNo) { return libusb_detach_kernel_driver(handle, interfaceNo); } -int LibusbWrapper::claimInterface(libusb_device_handle* handle, int interfaceNo) { +int LibUsbWrapper::claimInterface(libusb_device_handle* handle, int interfaceNo) { return libusb_claim_interface(handle, interfaceNo); } -int LibusbWrapper::releaseInterface(libusb_device_handle* handle, int interfaceNo) { +int LibUsbWrapper::releaseInterface(libusb_device_handle* handle, int interfaceNo) { return libusb_release_interface(handle, interfaceNo); } -int LibusbWrapper::bulkTransfer(libusb_device_handle* handle, uint8_t endpoint, unsigned char* data, int length, - int* transferred, unsigned int timeout) { +int LibUsbWrapper::bulkTransfer(libusb_device_handle* handle, uint8_t endpoint, unsigned char* data, int length, + int* transferred, unsigned int timeout) { return libusb_bulk_transfer(handle, endpoint, data, length, transferred, timeout); } -const char* LibusbWrapper::errorName(int errorCode) { +const char* LibUsbWrapper::errorName(int errorCode) { return libusb_error_name(errorCode); } diff --git a/src/libusbwrap/LibusbWrapper.hpp b/src/libusbwrap/LibUsbWrapper.hpp similarity index 83% rename from src/libusbwrap/LibusbWrapper.hpp rename to src/libusbwrap/LibUsbWrapper.hpp index 191ad11..dd042ed 100644 --- a/src/libusbwrap/LibusbWrapper.hpp +++ b/src/libusbwrap/LibUsbWrapper.hpp @@ -19,10 +19,8 @@ #pragma once -#include #include #include -#include // Forward declarations to avoid pulling in libusb.h in header struct libusb_context; @@ -33,26 +31,24 @@ struct libusb_device_descriptor; namespace libusbwrap { // Forward declaration -class ILibusbWrapper; +class ILibUsbWrapper; // Custom deleter for libusb_device that uses the wrapper -// Implementation in LibusbWrapper.cpp -struct LibusbDeviceDeleter { - std::shared_ptr wrapper; +struct LibUsbDeviceDeleter { + std::shared_ptr wrapper; void operator()(libusb_device* dev) const; }; -using LibusbDevicePtr = std::unique_ptr; + +using LibUsbDevicePtr = std::unique_ptr; /** * @brief Thin wrapper around libusb C API * * This class provides a 1:1 mapping to libusb C functions. - * NO LOGIC - just wraps the C calls directly. - * All logic (RAII, error handling, etc.) belongs in UsbDevice/UsbDeviceFactory. */ -class ILibusbWrapper { +class ILibUsbWrapper { public: - virtual ~ILibusbWrapper() = default; + virtual ~ILibUsbWrapper() = default; // Context management (raw pointers - caller manages lifecycle) virtual int init(libusb_context** ctx) = 0; @@ -60,20 +56,20 @@ class ILibusbWrapper { // Device enumeration (raw pointers - caller manages lifecycle) virtual ssize_t getDeviceList(libusb_context* ctx, libusb_device*** list) = 0; - virtual void freeDeviceList(libusb_device** list, int unrefDevices) = 0; - virtual void refDevice(libusb_device* dev) = 0; - virtual void unrefDevice(libusb_device* dev) = 0; + virtual void freeDeviceList(libusb_device** list, int unrefDevices) = 0; + virtual void refDevice(libusb_device* dev) = 0; + virtual void unrefDevice(libusb_device* dev) = 0; // Device descriptor virtual int getDeviceDescriptor(libusb_device* dev, libusb_device_descriptor* desc) = 0; // Device opening/closing (raw pointers - caller manages lifecycle) virtual int open(libusb_device* dev, libusb_device_handle** handle) = 0; - virtual void close(libusb_device_handle* handle) = 0; + virtual void close(libusb_device_handle* handle) = 0; // Device information - virtual int getSpeed(libusb_device* dev) = 0; - virtual uint8_t getBusNumber(libusb_device* dev) = 0; + virtual int getSpeed(libusb_device* dev) = 0; + virtual uint8_t getBusNumber(libusb_device* dev) = 0; virtual uint8_t getPortNumber(libusb_device* dev) = 0; // Kernel driver management @@ -81,7 +77,7 @@ class ILibusbWrapper { virtual int detachKernelDriver(libusb_device_handle* handle, int interfaceNo) = 0; // Interface management - virtual int claimInterface(libusb_device_handle* handle, int interfaceNo) = 0; + virtual int claimInterface(libusb_device_handle* handle, int interfaceNo) = 0; virtual int releaseInterface(libusb_device_handle* handle, int interfaceNo) = 0; // Data transfer @@ -95,7 +91,7 @@ class ILibusbWrapper { /** * @brief Concrete implementation - thin wrapper forwarding to libusb C API */ -class LibusbWrapper : public ILibusbWrapper { +class LibUsbWrapper : public ILibUsbWrapper { public: int init(libusb_context** ctx) override; void exit(libusb_context* ctx) override; diff --git a/src/libusbwrap/UsbDevice.cpp b/src/libusbwrap/UsbDevice.cpp index 6c4b390..1492724 100644 --- a/src/libusbwrap/UsbDevice.cpp +++ b/src/libusbwrap/UsbDevice.cpp @@ -24,21 +24,19 @@ #include "libusb.h" #include "libusbwrap/LibUsbTypes.hpp" -#include "libusbwrap/LibusbWrapper.hpp" +#include "libusbwrap/LibUsbWrapper.hpp" #include "libusbwrap/interface/IUsbDevice.hpp" namespace libusbwrap { // Default constructor delegates to DI constructor UsbDevice::UsbDevice(libusb_device* device, const libusb_device_descriptor& desc) - : UsbDevice(device, desc, std::make_shared()) {} + : UsbDevice(device, desc, std::make_shared()) {} // Constructor with dependency injection UsbDevice::UsbDevice(libusb_device* device, const libusb_device_descriptor& desc, - std::shared_ptr libusbWrapper) - : mLibusb(libusbWrapper), - mDevice(device, LibusbDeviceDeleter{libusbWrapper}), - mDeviceDescriptor(desc) { + std::shared_ptr libusbWrapper) + : mLibUsb(libusbWrapper), mDevice(device, LibUsbDeviceDeleter{libusbWrapper}), mDeviceDescriptor(desc) { if (!mDevice) { throw std::invalid_argument("device is nullptr"); } @@ -46,13 +44,13 @@ UsbDevice::UsbDevice(libusb_device* device, const libusb_device_descriptor& desc UsbDevice::~UsbDevice() { if (mIsOpen && mDeviceHandle) { - mLibusb->close(mDeviceHandle); + mLibUsb->close(mDeviceHandle); } - // mDevice auto-deleted by unique_ptr (calls LibusbDeviceDeleter) + // mDevice auto-deleted by unique_ptr (calls LibUsbDeviceDeleter) } bool UsbDevice::open() { - int openStatus = mLibusb->open(mDevice.get(), &mDeviceHandle); + int openStatus = mLibUsb->open(mDevice.get(), &mDeviceHandle); if (openStatus != 0) { mLastError = static_cast(openStatus); return false; @@ -64,7 +62,7 @@ bool UsbDevice::open() { void UsbDevice::close() { if (mDeviceHandle) { - mLibusb->close(mDeviceHandle); + mLibUsb->close(mDeviceHandle); mDeviceHandle = nullptr; mIsOpen = false; } @@ -72,9 +70,9 @@ void UsbDevice::close() { bool UsbDevice::detachKernelDriver(int interfaceNo) { // TODO: cover the other status codes that can be returned - int kernelDriverStatus = mLibusb->kernelDriverActive(mDeviceHandle, interfaceNo); + int kernelDriverStatus = mLibUsb->kernelDriverActive(mDeviceHandle, interfaceNo); if (kernelDriverStatus == 1) { // kernel driver is active, we have to detach to continue... - int detachStatus = mLibusb->detachKernelDriver(mDeviceHandle, interfaceNo); + int detachStatus = mLibUsb->detachKernelDriver(mDeviceHandle, interfaceNo); if (detachStatus != 0) { mLastError = static_cast(detachStatus); return false; @@ -86,7 +84,7 @@ bool UsbDevice::detachKernelDriver(int interfaceNo) { bool UsbDevice::claimInterface(int interfaceNo) { // TODO: cover the other status codes that can be returned - int claimInterfaceStatus = mLibusb->claimInterface(mDeviceHandle, interfaceNo); + int claimInterfaceStatus = mLibUsb->claimInterface(mDeviceHandle, interfaceNo); if (claimInterfaceStatus != 0) { mLastError = static_cast(claimInterfaceStatus); return false; @@ -95,7 +93,7 @@ bool UsbDevice::claimInterface(int interfaceNo) { } bool UsbDevice::releaseInterface(int interfaceNo) { - int releaseInterfaceStatus = mLibusb->releaseInterface(mDeviceHandle, interfaceNo); + int releaseInterfaceStatus = mLibUsb->releaseInterface(mDeviceHandle, interfaceNo); if (releaseInterfaceStatus != 0) { mLastError = static_cast(releaseInterfaceStatus); return false; @@ -105,7 +103,7 @@ bool UsbDevice::releaseInterface(int interfaceNo) { bool UsbDevice::bulkTransfer(uint8_t endpoint, const std::vector& data, int* tx, unsigned int timeout) { // TODO: implement error handling for incomplete transactions (tx length != data length) - int bulkTransferStatus = mLibusb->bulkTransfer(mDeviceHandle, endpoint, const_cast(data.data()), + int bulkTransferStatus = mLibUsb->bulkTransfer(mDeviceHandle, endpoint, const_cast(data.data()), data.size(), tx, timeout); if (bulkTransferStatus != 0) { mLastError = static_cast(bulkTransferStatus); @@ -119,15 +117,15 @@ const usbId UsbDevice::getUsbId() { } const device::Speed UsbDevice::getSpeed() { - return static_cast(mLibusb->getSpeed(mDevice.get())); + return static_cast(mLibUsb->getSpeed(mDevice.get())); } const uint8_t UsbDevice::getBusNumber() { - return mLibusb->getBusNumber(mDevice.get()); + return mLibUsb->getBusNumber(mDevice.get()); } const uint8_t UsbDevice::getPortNumber() { - return mLibusb->getPortNumber(mDevice.get()); + return mLibUsb->getPortNumber(mDevice.get()); } const Error UsbDevice::getLastError() { @@ -135,6 +133,6 @@ const Error UsbDevice::getLastError() { } const std::string UsbDevice::getLastErrorString() { - return std::string(mLibusb->errorName(static_cast(mLastError))); + return std::string(mLibUsb->errorName(static_cast(mLastError))); } } // namespace libusbwrap \ No newline at end of file diff --git a/src/libusbwrap/UsbDevice.hpp b/src/libusbwrap/UsbDevice.hpp index d58c499..9ffe8d9 100644 --- a/src/libusbwrap/UsbDevice.hpp +++ b/src/libusbwrap/UsbDevice.hpp @@ -24,19 +24,19 @@ #include "libusb.h" #include "libusbwrap/LibUsbTypes.hpp" -#include "libusbwrap/LibusbWrapper.hpp" +#include "libusbwrap/LibUsbWrapper.hpp" #include "libusbwrap/interface/IUsbDevice.hpp" namespace libusbwrap { class UsbDevice : public IUsbDevice { public: - // Default constructor (uses real LibusbWrapper) + // Default constructor (uses real LibUsbWrapper) UsbDevice(libusb_device* device, const libusb_device_descriptor& desc); // Constructor for testing (inject mock wrapper) UsbDevice(libusb_device* device, const libusb_device_descriptor& desc, - std::shared_ptr libusbWrapper); + std::shared_ptr libusbWrapper); ~UsbDevice() override; @@ -66,11 +66,11 @@ class UsbDevice : public IUsbDevice { const std::string getLastErrorString() override; private: - std::shared_ptr mLibusb; // Injectable wrapper + std::shared_ptr mLibUsb; // Injectable wrapper // RAII wrappers (UsbDevice owns the lifecycle logic) - LibusbDevicePtr mDevice; // unique_ptr with custom deleter - libusb_device_handle* mDeviceHandle = nullptr; // Managed by UsbDevice (calls mLibusb->close()) + LibUsbDevicePtr mDevice; // unique_ptr with custom deleter + libusb_device_handle* mDeviceHandle = nullptr; // Managed by UsbDevice (calls mLibUsb->close()) libusb_device_descriptor mDeviceDescriptor{0}; std::atomic mIsOpen = false; diff --git a/src/libusbwrap/UsbDeviceFactory.cpp b/src/libusbwrap/UsbDeviceFactory.cpp index 72c8fd3..9383a7b 100644 --- a/src/libusbwrap/UsbDeviceFactory.cpp +++ b/src/libusbwrap/UsbDeviceFactory.cpp @@ -27,23 +27,22 @@ #include #include "libusb.h" -#include "libusbwrap/LibusbWrapper.hpp" +#include "libusbwrap/LibUsbWrapper.hpp" #include "libusbwrap/UsbDevice.hpp" #include "libusbwrap/interface/IUsbDevice.hpp" namespace libusbwrap { // Default constructor delegates to DI constructor -UsbDeviceFactory::UsbDeviceFactory() : UsbDeviceFactory(std::make_shared()) {} +UsbDeviceFactory::UsbDeviceFactory() : UsbDeviceFactory(std::make_shared()) {} // Constructor with dependency injection -UsbDeviceFactory::UsbDeviceFactory(std::shared_ptr libusbWrapper) - : mLibusb(std::move(libusbWrapper)) {} +UsbDeviceFactory::UsbDeviceFactory(std::shared_ptr libusbWrapper) : mLibUsb(std::move(libusbWrapper)) {} UsbDeviceFactory::~UsbDeviceFactory() { mDeviceList.clear(); // Release devices first if (mContext) { - mLibusb->exit(mContext); + mLibUsb->exit(mContext); } } @@ -60,7 +59,7 @@ std::vector> UsbDeviceFactory::findDevices(uint16_t ssize_t UsbDeviceFactory::refreshDeviceList() { libusb_device** list{nullptr}; - ssize_t count = mLibusb->getDeviceList(mContext, &list); + ssize_t count = mLibUsb->getDeviceList(mContext, &list); mDeviceList.clear(); if (count < 0) { @@ -69,13 +68,13 @@ ssize_t UsbDeviceFactory::refreshDeviceList() { spdlog::warn("No USB devices found"); } else { for (ssize_t i = 0; i < count; i++) { - mLibusb->refDevice(list[i]); // Increment refcount - // Create LibusbDevicePtr with deleter that uses the wrapper - mDeviceList.emplace_back(list[i], LibusbDeviceDeleter{mLibusb}); + mLibUsb->refDevice(list[i]); // Increment refcount + // Create LibUsbDevicePtr with deleter that uses the wrapper + mDeviceList.emplace_back(list[i], LibUsbDeviceDeleter{mLibUsb}); } } - mLibusb->freeDeviceList(list, false); // Don't unref (we did that above) + mLibUsb->freeDeviceList(list, false); // Don't unref (we did that above) return count; } @@ -86,7 +85,7 @@ std::vector> UsbDeviceFactory::buildMaskedDeviceVect for (auto& dev : mDeviceList) { libusb_device_descriptor desc{}; - int ret = mLibusb->getDeviceDescriptor(dev.get(), &desc); + int ret = mLibUsb->getDeviceDescriptor(dev.get(), &desc); spdlog::trace("Detected Device {:04x}:{:04x} ", desc.idVendor, desc.idProduct); if (ret >= 0 && ((desc.idVendor & vidMask) == vid) && ((desc.idProduct & pidMask) == pid)) { @@ -94,14 +93,14 @@ std::vector> UsbDeviceFactory::buildMaskedDeviceVect libusb_device* raw_dev = dev.release(); // Create UsbDevice with same wrapper instance - matchedDevices.push_back(std::make_unique(raw_dev, desc, mLibusb)); + matchedDevices.push_back(std::make_unique(raw_dev, desc, mLibUsb)); } } return matchedDevices; } bool UsbDeviceFactory::init() { - int err = mLibusb->init(&mContext); + int err = mLibUsb->init(&mContext); if (err != (int)Error::SUCCESS) { spdlog::error("Could not initialize libusb"); diff --git a/src/libusbwrap/UsbDeviceFactory.hpp b/src/libusbwrap/UsbDeviceFactory.hpp index 812b31f..ebcc42f 100644 --- a/src/libusbwrap/UsbDeviceFactory.hpp +++ b/src/libusbwrap/UsbDeviceFactory.hpp @@ -23,7 +23,7 @@ #include #include "libusb.h" -#include "libusbwrap/LibusbWrapper.hpp" +#include "libusbwrap/LibUsbWrapper.hpp" #include "libusbwrap/UsbDevice.hpp" #include "libusbwrap/interface/IUsbDeviceFactory.hpp" @@ -33,11 +33,11 @@ constexpr const uint16_t LIBUSB_BITMASK_ALL = 0xffff; class UsbDeviceFactory : public IUsbDeviceFactory { public: - // Default constructor (uses real LibusbWrapper) + // Default constructor (uses real LibUsbWrapper) UsbDeviceFactory(); // Constructor for testing (inject mock wrapper) - explicit UsbDeviceFactory(std::shared_ptr libusbWrapper); + explicit UsbDeviceFactory(std::shared_ptr libusbWrapper); virtual ~UsbDeviceFactory(); @@ -67,13 +67,12 @@ class UsbDeviceFactory : public IUsbDeviceFactory { private: // methods ssize_t refreshDeviceList(); - std::vector> buildMaskedDeviceVector(uint16_t vidMask, - uint16_t pidMask, uint16_t vid, + std::vector> buildMaskedDeviceVector(uint16_t vidMask, uint16_t pidMask, uint16_t vid, uint16_t pid); // members - std::shared_ptr mLibusb; + std::shared_ptr mLibUsb; libusb_context* mContext{nullptr}; // Factory manages lifecycle - std::vector mDeviceList{}; + std::vector mDeviceList{}; bool mDeviceListInitialized = false; }; } // namespace libusbwrap \ No newline at end of file diff --git a/src/libusbwrap/interface/ILibUsbWrapper.hpp b/src/libusbwrap/interface/ILibUsbWrapper.hpp new file mode 100644 index 0000000..e69de29 diff --git a/src/meson.build b/src/meson.build index 34e32fd..f21d1e2 100644 --- a/src/meson.build +++ b/src/meson.build @@ -7,7 +7,7 @@ ptprnt_hpps = files( 'graphics/LabelBuilder.hpp', 'graphics/Monochrome.hpp', 'libusbwrap/LibUsbTypes.hpp', - 'libusbwrap/LibusbWrapper.hpp', + 'libusbwrap/LibUsbWrapper.hpp', 'libusbwrap/UsbDevice.hpp', 'libusbwrap/UsbDeviceFactory.hpp', 'libusbwrap/interface/IUsbDevice.hpp', @@ -27,7 +27,7 @@ ptprnt_srcs = files( 'graphics/Label.cpp', 'graphics/LabelBuilder.cpp', 'graphics/Monochrome.cpp', - 'libusbwrap/LibusbWrapper.cpp', + 'libusbwrap/LibUsbWrapper.cpp', 'libusbwrap/UsbDevice.cpp', 'libusbwrap/UsbDeviceFactory.cpp', 'printers/FakePrinter.cpp', diff --git a/tests/meson.build b/tests/meson.build index c169341..177f41d 100644 --- a/tests/meson.build +++ b/tests/meson.build @@ -34,7 +34,7 @@ test_sources = [ '../src/PtouchPrint.cpp', # Source files under test - USB - '../src/libusbwrap/LibusbWrapper.cpp', + '../src/libusbwrap/LibUsbWrapper.cpp', '../src/libusbwrap/UsbDevice.cpp', '../src/libusbwrap/UsbDeviceFactory.cpp', ] @@ -44,7 +44,7 @@ test_exe = executable( sources: test_sources, include_directories: incdir, dependencies: [ - gmock_dep, # GMock includes GTest + gmock_dep, # GMock includes GTest usb_dep, log_dep, pangocairo_dep, @@ -53,4 +53,4 @@ test_exe = executable( ) # Single test that runs all test suites -test('all_tests', test_exe) +test('all_tests', test_exe) \ No newline at end of file diff --git a/tests/mocks/MockLibusbWrapper.hpp b/tests/mocks/MockLibUsbWrapper.hpp similarity index 93% rename from tests/mocks/MockLibusbWrapper.hpp rename to tests/mocks/MockLibUsbWrapper.hpp index bde1cd9..9aac781 100644 --- a/tests/mocks/MockLibusbWrapper.hpp +++ b/tests/mocks/MockLibUsbWrapper.hpp @@ -21,24 +21,24 @@ #include -#include "libusbwrap/LibusbWrapper.hpp" +#include "libusbwrap/LibUsbWrapper.hpp" namespace libusbwrap { /** - * @brief GMock implementation of ILibusbWrapper for unit testing + * @brief GMock implementation of ILibUsbWrapper for unit testing * * This mock allows tests to verify that UsbDevice and UsbDeviceFactory * correctly interact with the libusb API without requiring actual USB hardware. */ -class MockLibusbWrapper : public ILibusbWrapper { +class MockLibUsbWrapper : public ILibUsbWrapper { public: // Context management MOCK_METHOD(int, init, (libusb_context * *ctx), (override)); MOCK_METHOD(void, exit, (libusb_context * ctx), (override)); // Device enumeration - MOCK_METHOD(ssize_t, getDeviceList, (libusb_context * ctx, libusb_device***list), (override)); + MOCK_METHOD(ssize_t, getDeviceList, (libusb_context * ctx, libusb_device*** list), (override)); MOCK_METHOD(void, freeDeviceList, (libusb_device * *list, int unrefDevices), (override)); MOCK_METHOD(void, refDevice, (libusb_device * dev), (override)); MOCK_METHOD(void, unrefDevice, (libusb_device * dev), (override)); diff --git a/tests/usb_device_test/usb_device_test.cpp b/tests/usb_device_test/usb_device_test.cpp index 6d57665..37576e1 100644 --- a/tests/usb_device_test/usb_device_test.cpp +++ b/tests/usb_device_test/usb_device_test.cpp @@ -17,8 +17,6 @@ */ -#include "libusbwrap/UsbDevice.hpp" - #include #include @@ -26,7 +24,8 @@ #include "libusb.h" #include "libusbwrap/LibUsbTypes.hpp" -#include "mocks/MockLibusbWrapper.hpp" +#include "libusbwrap/UsbDevice.hpp" +#include "mocks/MockLibUsbWrapper.hpp" using ::testing::_; using ::testing::DoAll; @@ -40,7 +39,7 @@ namespace libusbwrap { class UsbDeviceTest : public ::testing::Test { protected: void SetUp() override { - mockLibusb = std::make_shared>(); + mockLibUsb = std::make_shared>(); // Create mock device pointer mockDevice = reinterpret_cast(0x1000); @@ -53,15 +52,14 @@ class UsbDeviceTest : public ::testing::Test { desc.idProduct = 0x2042; // P700 product ID // Default behaviors - ON_CALL(*mockLibusb, open(_, _)) - .WillByDefault(DoAll(SetArgPointee<1>(mockHandle), Return(0))); - ON_CALL(*mockLibusb, getSpeed(_)).WillByDefault(Return(LIBUSB_SPEED_FULL)); - ON_CALL(*mockLibusb, getBusNumber(_)).WillByDefault(Return(1)); - ON_CALL(*mockLibusb, getPortNumber(_)).WillByDefault(Return(2)); - ON_CALL(*mockLibusb, errorName(_)).WillByDefault(Return("LIBUSB_SUCCESS")); + ON_CALL(*mockLibUsb, open(_, _)).WillByDefault(DoAll(SetArgPointee<1>(mockHandle), Return(0))); + ON_CALL(*mockLibUsb, getSpeed(_)).WillByDefault(Return(LIBUSB_SPEED_FULL)); + ON_CALL(*mockLibUsb, getBusNumber(_)).WillByDefault(Return(1)); + ON_CALL(*mockLibUsb, getPortNumber(_)).WillByDefault(Return(2)); + ON_CALL(*mockLibUsb, errorName(_)).WillByDefault(Return("LIBUSB_SUCCESS")); } - std::shared_ptr mockLibusb; + std::shared_ptr mockLibUsb; libusb_device* mockDevice; libusb_device_handle* mockHandle; libusb_device_descriptor desc{}; @@ -70,56 +68,54 @@ class UsbDeviceTest : public ::testing::Test { // Constructor tests TEST_F(UsbDeviceTest, ConstructorWithValidDevice) { EXPECT_NO_THROW({ - auto device = std::make_unique(mockDevice, desc, mockLibusb); + auto device = std::make_unique(mockDevice, desc, mockLibUsb); EXPECT_NE(device, nullptr); }); } TEST_F(UsbDeviceTest, ConstructorWithNullptrThrows) { - EXPECT_THROW({ auto device = std::make_unique(nullptr, desc, mockLibusb); }, std::invalid_argument); + EXPECT_THROW({ auto device = std::make_unique(nullptr, desc, mockLibUsb); }, std::invalid_argument); } // Open/Close tests TEST_F(UsbDeviceTest, OpenSuccess) { - auto device = std::make_unique(mockDevice, desc, mockLibusb); + auto device = std::make_unique(mockDevice, desc, mockLibUsb); - EXPECT_CALL(*mockLibusb, open(mockDevice, _)) - .WillOnce(DoAll(SetArgPointee<1>(mockHandle), Return(0))); + EXPECT_CALL(*mockLibUsb, open(mockDevice, _)).WillOnce(DoAll(SetArgPointee<1>(mockHandle), Return(0))); EXPECT_TRUE(device->open()); } TEST_F(UsbDeviceTest, OpenFailure) { - auto device = std::make_unique(mockDevice, desc, mockLibusb); + auto device = std::make_unique(mockDevice, desc, mockLibUsb); - EXPECT_CALL(*mockLibusb, open(mockDevice, _)) - .WillOnce(Return(LIBUSB_ERROR_ACCESS)); + EXPECT_CALL(*mockLibUsb, open(mockDevice, _)).WillOnce(Return(LIBUSB_ERROR_ACCESS)); EXPECT_FALSE(device->open()); EXPECT_EQ(device->getLastError(), Error::ACCESS); } TEST_F(UsbDeviceTest, CloseWithOpenDevice) { - auto device = std::make_unique(mockDevice, desc, mockLibusb); + auto device = std::make_unique(mockDevice, desc, mockLibUsb); device->open(); - EXPECT_CALL(*mockLibusb, close(mockHandle)).Times(1); + EXPECT_CALL(*mockLibUsb, close(mockHandle)).Times(1); device->close(); } TEST_F(UsbDeviceTest, CloseWithoutOpenDevice) { - auto device = std::make_unique(mockDevice, desc, mockLibusb); + auto device = std::make_unique(mockDevice, desc, mockLibUsb); // Should not call close if device was never opened - EXPECT_CALL(*mockLibusb, close(_)).Times(0); + EXPECT_CALL(*mockLibUsb, close(_)).Times(0); device->close(); } TEST_F(UsbDeviceTest, DestructorClosesOpenDevice) { - EXPECT_CALL(*mockLibusb, close(mockHandle)).Times(1); + EXPECT_CALL(*mockLibUsb, close(mockHandle)).Times(1); { - auto device = std::make_unique(mockDevice, desc, mockLibusb); + auto device = std::make_unique(mockDevice, desc, mockLibUsb); device->open(); // Device goes out of scope, destructor should call close } @@ -127,37 +123,31 @@ TEST_F(UsbDeviceTest, DestructorClosesOpenDevice) { // Kernel driver tests TEST_F(UsbDeviceTest, DetachKernelDriverWhenActive) { - auto device = std::make_unique(mockDevice, desc, mockLibusb); + auto device = std::make_unique(mockDevice, desc, mockLibUsb); device->open(); - EXPECT_CALL(*mockLibusb, kernelDriverActive(mockHandle, 0)) - .WillOnce(Return(1)); // Active - EXPECT_CALL(*mockLibusb, detachKernelDriver(mockHandle, 0)) - .WillOnce(Return(0)); // Success + EXPECT_CALL(*mockLibUsb, kernelDriverActive(mockHandle, 0)).WillOnce(Return(1)); // Active + EXPECT_CALL(*mockLibUsb, detachKernelDriver(mockHandle, 0)).WillOnce(Return(0)); // Success EXPECT_TRUE(device->detachKernelDriver(0)); } TEST_F(UsbDeviceTest, DetachKernelDriverWhenNotActive) { - auto device = std::make_unique(mockDevice, desc, mockLibusb); + auto device = std::make_unique(mockDevice, desc, mockLibUsb); device->open(); - EXPECT_CALL(*mockLibusb, kernelDriverActive(mockHandle, 0)) - .WillOnce(Return(0)); // Not active - EXPECT_CALL(*mockLibusb, detachKernelDriver(_, _)) - .Times(0); // Should not call detach + EXPECT_CALL(*mockLibUsb, kernelDriverActive(mockHandle, 0)).WillOnce(Return(0)); // Not active + EXPECT_CALL(*mockLibUsb, detachKernelDriver(_, _)).Times(0); // Should not call detach EXPECT_TRUE(device->detachKernelDriver(0)); } TEST_F(UsbDeviceTest, DetachKernelDriverFailure) { - auto device = std::make_unique(mockDevice, desc, mockLibusb); + auto device = std::make_unique(mockDevice, desc, mockLibUsb); device->open(); - EXPECT_CALL(*mockLibusb, kernelDriverActive(mockHandle, 0)) - .WillOnce(Return(1)); // Active - EXPECT_CALL(*mockLibusb, detachKernelDriver(mockHandle, 0)) - .WillOnce(Return(LIBUSB_ERROR_NOT_FOUND)); + EXPECT_CALL(*mockLibUsb, kernelDriverActive(mockHandle, 0)).WillOnce(Return(1)); // Active + EXPECT_CALL(*mockLibUsb, detachKernelDriver(mockHandle, 0)).WillOnce(Return(LIBUSB_ERROR_NOT_FOUND)); EXPECT_FALSE(device->detachKernelDriver(0)); EXPECT_EQ(device->getLastError(), Error::NOT_FOUND); @@ -165,42 +155,38 @@ TEST_F(UsbDeviceTest, DetachKernelDriverFailure) { // Interface tests TEST_F(UsbDeviceTest, ClaimInterfaceSuccess) { - auto device = std::make_unique(mockDevice, desc, mockLibusb); + auto device = std::make_unique(mockDevice, desc, mockLibUsb); device->open(); - EXPECT_CALL(*mockLibusb, claimInterface(mockHandle, 0)) - .WillOnce(Return(0)); + EXPECT_CALL(*mockLibUsb, claimInterface(mockHandle, 0)).WillOnce(Return(0)); EXPECT_TRUE(device->claimInterface(0)); } TEST_F(UsbDeviceTest, ClaimInterfaceFailure) { - auto device = std::make_unique(mockDevice, desc, mockLibusb); + auto device = std::make_unique(mockDevice, desc, mockLibUsb); device->open(); - EXPECT_CALL(*mockLibusb, claimInterface(mockHandle, 0)) - .WillOnce(Return(LIBUSB_ERROR_BUSY)); + EXPECT_CALL(*mockLibUsb, claimInterface(mockHandle, 0)).WillOnce(Return(LIBUSB_ERROR_BUSY)); EXPECT_FALSE(device->claimInterface(0)); EXPECT_EQ(device->getLastError(), Error::BUSY); } TEST_F(UsbDeviceTest, ReleaseInterfaceSuccess) { - auto device = std::make_unique(mockDevice, desc, mockLibusb); + auto device = std::make_unique(mockDevice, desc, mockLibUsb); device->open(); - EXPECT_CALL(*mockLibusb, releaseInterface(mockHandle, 0)) - .WillOnce(Return(0)); + EXPECT_CALL(*mockLibUsb, releaseInterface(mockHandle, 0)).WillOnce(Return(0)); EXPECT_TRUE(device->releaseInterface(0)); } TEST_F(UsbDeviceTest, ReleaseInterfaceFailure) { - auto device = std::make_unique(mockDevice, desc, mockLibusb); + auto device = std::make_unique(mockDevice, desc, mockLibUsb); device->open(); - EXPECT_CALL(*mockLibusb, releaseInterface(mockHandle, 0)) - .WillOnce(Return(LIBUSB_ERROR_NOT_FOUND)); + EXPECT_CALL(*mockLibUsb, releaseInterface(mockHandle, 0)).WillOnce(Return(LIBUSB_ERROR_NOT_FOUND)); EXPECT_FALSE(device->releaseInterface(0)); EXPECT_EQ(device->getLastError(), Error::NOT_FOUND); @@ -208,27 +194,26 @@ TEST_F(UsbDeviceTest, ReleaseInterfaceFailure) { // Bulk transfer tests TEST_F(UsbDeviceTest, BulkTransferSuccess) { - auto device = std::make_unique(mockDevice, desc, mockLibusb); + auto device = std::make_unique(mockDevice, desc, mockLibUsb); device->open(); std::vector data = {0x01, 0x02, 0x03}; - int transferred = 0; + int transferred = 0; - EXPECT_CALL(*mockLibusb, bulkTransfer(mockHandle, 0x02, _, 3, _, 1000)) + EXPECT_CALL(*mockLibUsb, bulkTransfer(mockHandle, 0x02, _, 3, _, 1000)) .WillOnce(DoAll(SetArgPointee<4>(3), Return(0))); EXPECT_TRUE(device->bulkTransfer(0x02, data, &transferred, 1000)); } TEST_F(UsbDeviceTest, BulkTransferFailure) { - auto device = std::make_unique(mockDevice, desc, mockLibusb); + auto device = std::make_unique(mockDevice, desc, mockLibUsb); device->open(); std::vector data = {0x01, 0x02, 0x03}; - int transferred = 0; + int transferred = 0; - EXPECT_CALL(*mockLibusb, bulkTransfer(mockHandle, 0x02, _, 3, _, 1000)) - .WillOnce(Return(LIBUSB_ERROR_TIMEOUT)); + EXPECT_CALL(*mockLibUsb, bulkTransfer(mockHandle, 0x02, _, 3, _, 1000)).WillOnce(Return(LIBUSB_ERROR_TIMEOUT)); EXPECT_FALSE(device->bulkTransfer(0x02, data, &transferred, 1000)); EXPECT_EQ(device->getLastError(), Error::TIMEOUT); @@ -236,7 +221,7 @@ TEST_F(UsbDeviceTest, BulkTransferFailure) { // Getter tests TEST_F(UsbDeviceTest, GetUsbId) { - auto device = std::make_unique(mockDevice, desc, mockLibusb); + auto device = std::make_unique(mockDevice, desc, mockLibUsb); auto usbId = device->getUsbId(); EXPECT_EQ(usbId.first, 0x04f9); // vid @@ -244,51 +229,46 @@ TEST_F(UsbDeviceTest, GetUsbId) { } TEST_F(UsbDeviceTest, GetSpeed) { - auto device = std::make_unique(mockDevice, desc, mockLibusb); + auto device = std::make_unique(mockDevice, desc, mockLibUsb); - EXPECT_CALL(*mockLibusb, getSpeed(mockDevice)) - .WillOnce(Return(LIBUSB_SPEED_HIGH)); + EXPECT_CALL(*mockLibUsb, getSpeed(mockDevice)).WillOnce(Return(LIBUSB_SPEED_HIGH)); EXPECT_EQ(device->getSpeed(), device::Speed::HIGH); } TEST_F(UsbDeviceTest, GetBusNumber) { - auto device = std::make_unique(mockDevice, desc, mockLibusb); + auto device = std::make_unique(mockDevice, desc, mockLibUsb); - EXPECT_CALL(*mockLibusb, getBusNumber(mockDevice)) - .WillOnce(Return(5)); + EXPECT_CALL(*mockLibUsb, getBusNumber(mockDevice)).WillOnce(Return(5)); EXPECT_EQ(device->getBusNumber(), 5); } TEST_F(UsbDeviceTest, GetPortNumber) { - auto device = std::make_unique(mockDevice, desc, mockLibusb); + auto device = std::make_unique(mockDevice, desc, mockLibUsb); - EXPECT_CALL(*mockLibusb, getPortNumber(mockDevice)) - .WillOnce(Return(3)); + EXPECT_CALL(*mockLibUsb, getPortNumber(mockDevice)).WillOnce(Return(3)); EXPECT_EQ(device->getPortNumber(), 3); } TEST_F(UsbDeviceTest, GetLastError) { - auto device = std::make_unique(mockDevice, desc, mockLibusb); + auto device = std::make_unique(mockDevice, desc, mockLibUsb); // Initially no error EXPECT_EQ(device->getLastError(), Error::SUCCESS); // After a failed operation - EXPECT_CALL(*mockLibusb, open(_, _)) - .WillOnce(Return(LIBUSB_ERROR_NO_DEVICE)); + EXPECT_CALL(*mockLibUsb, open(_, _)).WillOnce(Return(LIBUSB_ERROR_NO_DEVICE)); device->open(); EXPECT_EQ(device->getLastError(), Error::NO_DEVICE); } TEST_F(UsbDeviceTest, GetLastErrorString) { - auto device = std::make_unique(mockDevice, desc, mockLibusb); + auto device = std::make_unique(mockDevice, desc, mockLibUsb); - EXPECT_CALL(*mockLibusb, errorName(static_cast(Error::SUCCESS))) - .WillOnce(Return("LIBUSB_SUCCESS")); + EXPECT_CALL(*mockLibUsb, errorName(static_cast(Error::SUCCESS))).WillOnce(Return("LIBUSB_SUCCESS")); EXPECT_EQ(device->getLastErrorString(), "LIBUSB_SUCCESS"); }