Rename occurences Libusb -> LibUsb

src/libusbwrap/LibUsbWrapper.cpp

@@ -17,91 +17,91 @@
 
  */
 
-#include "LibusbWrapper.hpp"
+#include "LibUsbWrapper.hpp"
 
 #include "libusb.h"
 
 namespace libusbwrap {
 
-// LibusbDeviceDeleter implementation
+// LibUsbDeviceDeleter
-void LibusbDeviceDeleter::operator()(libusb_device* dev) const {
+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 LibUsbWrapper::bulkTransfer(libusb_device_handle* handle, uint8_t endpoint, unsigned char* data, int length,
-                                 int* transferred, unsigned int timeout) {
+                                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);
 }
 

src/libusbwrap/LibUsbWrapper.hpp

@@ -19,10 +19,8 @@
 
 #pragma once
 
-#include <cstddef>
 #include <cstdint>
 #include <memory>
-#include <string>
 
 // 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 {
-struct LibusbDeviceDeleter {
+    std::shared_ptr<ILibUsbWrapper> wrapper;
-    std::shared_ptr<ILibusbWrapper> wrapper;
     void operator()(libusb_device* dev) const;
 };
-using LibusbDevicePtr = std::unique_ptr<libusb_device, LibusbDeviceDeleter>;
+
+using LibUsbDevicePtr = std::unique_ptr<libusb_device, LibUsbDeviceDeleter>;
 
 /**
  * @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 freeDeviceList(libusb_device** list, int unrefDevices)       = 0;
-    virtual void refDevice(libusb_device* dev) = 0;
+    virtual void refDevice(libusb_device* dev)                                = 0;
-    virtual void unrefDevice(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 int getSpeed(libusb_device* dev)          = 0;
-    virtual uint8_t getBusNumber(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;

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<LibusbWrapper>()) {}
+    : UsbDevice(device, desc, std::make_shared<LibUsbWrapper>()) {}
 
 // Constructor with dependency injection
 UsbDevice::UsbDevice(libusb_device* device, const libusb_device_descriptor& desc,
-                     std::shared_ptr<ILibusbWrapper> libusbWrapper)
+                     std::shared_ptr<ILibUsbWrapper> libusbWrapper)
-    : mLibusb(libusbWrapper),
+    : mLibUsb(libusbWrapper), mDevice(device, LibUsbDeviceDeleter{libusbWrapper}), mDeviceDescriptor(desc) {
-      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<Error>(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<Error>(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<Error>(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<Error>(releaseInterfaceStatus);
         return false;
@@ -105,7 +103,7 @@ bool UsbDevice::releaseInterface(int interfaceNo) {
 
 bool UsbDevice::bulkTransfer(uint8_t endpoint, const std::vector<uint8_t>& 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<unsigned char*>(data.data()),
+    int bulkTransferStatus = mLibUsb->bulkTransfer(mDeviceHandle, endpoint, const_cast<unsigned char*>(data.data()),
                                                    data.size(), tx, timeout);
     if (bulkTransferStatus != 0) {
         mLastError = static_cast<Error>(bulkTransferStatus);
@@ -119,15 +117,15 @@ const usbId UsbDevice::getUsbId() {
 }
 
 const device::Speed UsbDevice::getSpeed() {
-    return static_cast<device::Speed>(mLibusb->getSpeed(mDevice.get()));
+    return static_cast<device::Speed>(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<int>(mLastError)));
+    return std::string(mLibUsb->errorName(static_cast<int>(mLastError)));
 }
 }  // namespace libusbwrap

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<ILibusbWrapper> libusbWrapper);
+              std::shared_ptr<ILibUsbWrapper> libusbWrapper);
 
     ~UsbDevice() override;
 
@@ -66,11 +66,11 @@ class UsbDevice : public IUsbDevice {
     const std::string getLastErrorString() override;
 
    private:
-    std::shared_ptr<ILibusbWrapper> mLibusb;  // Injectable wrapper
+    std::shared_ptr<ILibUsbWrapper> mLibUsb;  // Injectable wrapper
 
     // RAII wrappers (UsbDevice owns the lifecycle logic)
-    LibusbDevicePtr mDevice;                       // unique_ptr with custom deleter
+    LibUsbDevicePtr mDevice;                        // unique_ptr with custom deleter
-    libusb_device_handle* mDeviceHandle = nullptr;  // Managed by UsbDevice (calls mLibusb->close())
+    libusb_device_handle* mDeviceHandle = nullptr;  // Managed by UsbDevice (calls mLibUsb->close())
 
     libusb_device_descriptor mDeviceDescriptor{0};
     std::atomic<bool> mIsOpen = false;

src/libusbwrap/UsbDeviceFactory.cpp

@@ -27,23 +27,22 @@
 #include <vector>
 
 #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<LibusbWrapper>()) {}
+UsbDeviceFactory::UsbDeviceFactory() : UsbDeviceFactory(std::make_shared<LibUsbWrapper>()) {}
 
 // Constructor with dependency injection
-UsbDeviceFactory::UsbDeviceFactory(std::shared_ptr<ILibusbWrapper> libusbWrapper)
+UsbDeviceFactory::UsbDeviceFactory(std::shared_ptr<ILibUsbWrapper> libusbWrapper) : mLibUsb(std::move(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<std::unique_ptr<IUsbDevice>> 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
+            mLibUsb->refDevice(list[i]);  // Increment refcount
-            // Create LibusbDevicePtr with deleter that uses the wrapper
+            // Create LibUsbDevicePtr with deleter that uses the wrapper
-            mDeviceList.emplace_back(list[i], LibusbDeviceDeleter{mLibusb});
+            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<std::unique_ptr<IUsbDevice>> 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<std::unique_ptr<IUsbDevice>> UsbDeviceFactory::buildMaskedDeviceVect
             libusb_device* raw_dev = dev.release();
 
             // Create UsbDevice with same wrapper instance
-            matchedDevices.push_back(std::make_unique<UsbDevice>(raw_dev, desc, mLibusb));
+            matchedDevices.push_back(std::make_unique<UsbDevice>(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");

src/libusbwrap/UsbDeviceFactory.hpp

@@ -23,7 +23,7 @@
 #include <memory>
 
 #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<ILibusbWrapper> libusbWrapper);
+    explicit UsbDeviceFactory(std::shared_ptr<ILibUsbWrapper> libusbWrapper);
 
     virtual ~UsbDeviceFactory();
 
@@ -67,13 +67,12 @@ class UsbDeviceFactory : public IUsbDeviceFactory {
    private:
     // methods
     ssize_t refreshDeviceList();
-    std::vector<std::unique_ptr<IUsbDevice>> buildMaskedDeviceVector(uint16_t vidMask,
+    std::vector<std::unique_ptr<IUsbDevice>> buildMaskedDeviceVector(uint16_t vidMask, uint16_t pidMask, uint16_t vid,
-                                                                     uint16_t pidMask, uint16_t vid,
                                                                      uint16_t pid);
     // members
-    std::shared_ptr<ILibusbWrapper> mLibusb;
+    std::shared_ptr<ILibUsbWrapper> mLibUsb;
     libusb_context* mContext{nullptr};  // Factory manages lifecycle
-    std::vector<LibusbDevicePtr> mDeviceList{};
+    std::vector<LibUsbDevicePtr> mDeviceList{};
     bool mDeviceListInitialized = false;
 };
 }  // namespace libusbwrap

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',

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)

tests/mocks/MockLibUsbWrapper.hpp

@@ -21,24 +21,24 @@
 
 #include <gmock/gmock.h>
 
-#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));

tests/usb_device_test/usb_device_test.cpp

@@ -17,8 +17,6 @@
 
  */
 
-#include "libusbwrap/UsbDevice.hpp"
-
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
@@ -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<NiceMock<MockLibusbWrapper>>();
+        mockLibUsb = std::make_shared<NiceMock<MockLibUsbWrapper>>();
 
         // Create mock device pointer
         mockDevice = reinterpret_cast<libusb_device*>(0x1000);
@@ -53,15 +52,14 @@ class UsbDeviceTest : public ::testing::Test {
         desc.idProduct = 0x2042;  // P700 product ID
 
         // Default behaviors
-        ON_CALL(*mockLibusb, open(_, _))
+        ON_CALL(*mockLibUsb, open(_, _)).WillByDefault(DoAll(SetArgPointee<1>(mockHandle), Return(0)));
-            .WillByDefault(DoAll(SetArgPointee<1>(mockHandle), Return(0)));
+        ON_CALL(*mockLibUsb, getSpeed(_)).WillByDefault(Return(LIBUSB_SPEED_FULL));
-        ON_CALL(*mockLibusb, getSpeed(_)).WillByDefault(Return(LIBUSB_SPEED_FULL));
+        ON_CALL(*mockLibUsb, getBusNumber(_)).WillByDefault(Return(1));
-        ON_CALL(*mockLibusb, getBusNumber(_)).WillByDefault(Return(1));
+        ON_CALL(*mockLibUsb, getPortNumber(_)).WillByDefault(Return(2));
-        ON_CALL(*mockLibusb, getPortNumber(_)).WillByDefault(Return(2));
+        ON_CALL(*mockLibUsb, errorName(_)).WillByDefault(Return("LIBUSB_SUCCESS"));
-        ON_CALL(*mockLibusb, errorName(_)).WillByDefault(Return("LIBUSB_SUCCESS"));
     }
 
-    std::shared_ptr<MockLibusbWrapper> mockLibusb;
+    std::shared_ptr<MockLibUsbWrapper> 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<UsbDevice>(mockDevice, desc, mockLibusb);
+        auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibUsb);
         EXPECT_NE(device, nullptr);
     });
 }
 
 TEST_F(UsbDeviceTest, ConstructorWithNullptrThrows) {
-    EXPECT_THROW({ auto device = std::make_unique<UsbDevice>(nullptr, desc, mockLibusb); }, std::invalid_argument);
+    EXPECT_THROW({ auto device = std::make_unique<UsbDevice>(nullptr, desc, mockLibUsb); }, std::invalid_argument);
 }
 
 // Open/Close tests
 TEST_F(UsbDeviceTest, OpenSuccess) {
-    auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibusb);
+    auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibUsb);
 
-    EXPECT_CALL(*mockLibusb, open(mockDevice, _))
+    EXPECT_CALL(*mockLibUsb, open(mockDevice, _)).WillOnce(DoAll(SetArgPointee<1>(mockHandle), Return(0)));
-        .WillOnce(DoAll(SetArgPointee<1>(mockHandle), Return(0)));
 
     EXPECT_TRUE(device->open());
 }
 
 TEST_F(UsbDeviceTest, OpenFailure) {
-    auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibusb);
+    auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibUsb);
 
-    EXPECT_CALL(*mockLibusb, open(mockDevice, _))
+    EXPECT_CALL(*mockLibUsb, open(mockDevice, _)).WillOnce(Return(LIBUSB_ERROR_ACCESS));
-        .WillOnce(Return(LIBUSB_ERROR_ACCESS));
 
     EXPECT_FALSE(device->open());
     EXPECT_EQ(device->getLastError(), Error::ACCESS);
 }
 
 TEST_F(UsbDeviceTest, CloseWithOpenDevice) {
-    auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibusb);
+    auto device = std::make_unique<UsbDevice>(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<UsbDevice>(mockDevice, desc, mockLibusb);
+    auto device = std::make_unique<UsbDevice>(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<UsbDevice>(mockDevice, desc, mockLibusb);
+        auto device = std::make_unique<UsbDevice>(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<UsbDevice>(mockDevice, desc, mockLibusb);
+    auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibUsb);
     device->open();
 
-    EXPECT_CALL(*mockLibusb, kernelDriverActive(mockHandle, 0))
+    EXPECT_CALL(*mockLibUsb, kernelDriverActive(mockHandle, 0)).WillOnce(Return(1));  // Active
-        .WillOnce(Return(1));  // Active
+    EXPECT_CALL(*mockLibUsb, detachKernelDriver(mockHandle, 0)).WillOnce(Return(0));  // Success
-    EXPECT_CALL(*mockLibusb, detachKernelDriver(mockHandle, 0))
-        .WillOnce(Return(0));  // Success
 
     EXPECT_TRUE(device->detachKernelDriver(0));
 }
 
 TEST_F(UsbDeviceTest, DetachKernelDriverWhenNotActive) {
-    auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibusb);
+    auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibUsb);
     device->open();
 
-    EXPECT_CALL(*mockLibusb, kernelDriverActive(mockHandle, 0))
+    EXPECT_CALL(*mockLibUsb, kernelDriverActive(mockHandle, 0)).WillOnce(Return(0));  // Not active
-        .WillOnce(Return(0));  // Not active
+    EXPECT_CALL(*mockLibUsb, detachKernelDriver(_, _)).Times(0);                      // Should not call detach
-    EXPECT_CALL(*mockLibusb, detachKernelDriver(_, _))
-        .Times(0);  // Should not call detach
 
     EXPECT_TRUE(device->detachKernelDriver(0));
 }
 
 TEST_F(UsbDeviceTest, DetachKernelDriverFailure) {
-    auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibusb);
+    auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibUsb);
     device->open();
 
-    EXPECT_CALL(*mockLibusb, kernelDriverActive(mockHandle, 0))
+    EXPECT_CALL(*mockLibUsb, kernelDriverActive(mockHandle, 0)).WillOnce(Return(1));  // Active
-        .WillOnce(Return(1));  // Active
+    EXPECT_CALL(*mockLibUsb, detachKernelDriver(mockHandle, 0)).WillOnce(Return(LIBUSB_ERROR_NOT_FOUND));
-    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<UsbDevice>(mockDevice, desc, mockLibusb);
+    auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibUsb);
     device->open();
 
-    EXPECT_CALL(*mockLibusb, claimInterface(mockHandle, 0))
+    EXPECT_CALL(*mockLibUsb, claimInterface(mockHandle, 0)).WillOnce(Return(0));
-        .WillOnce(Return(0));
 
     EXPECT_TRUE(device->claimInterface(0));
 }
 
 TEST_F(UsbDeviceTest, ClaimInterfaceFailure) {
-    auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibusb);
+    auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibUsb);
     device->open();
 
-    EXPECT_CALL(*mockLibusb, claimInterface(mockHandle, 0))
+    EXPECT_CALL(*mockLibUsb, claimInterface(mockHandle, 0)).WillOnce(Return(LIBUSB_ERROR_BUSY));
-        .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<UsbDevice>(mockDevice, desc, mockLibusb);
+    auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibUsb);
     device->open();
 
-    EXPECT_CALL(*mockLibusb, releaseInterface(mockHandle, 0))
+    EXPECT_CALL(*mockLibUsb, releaseInterface(mockHandle, 0)).WillOnce(Return(0));
-        .WillOnce(Return(0));
 
     EXPECT_TRUE(device->releaseInterface(0));
 }
 
 TEST_F(UsbDeviceTest, ReleaseInterfaceFailure) {
-    auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibusb);
+    auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibUsb);
     device->open();
 
-    EXPECT_CALL(*mockLibusb, releaseInterface(mockHandle, 0))
+    EXPECT_CALL(*mockLibUsb, releaseInterface(mockHandle, 0)).WillOnce(Return(LIBUSB_ERROR_NOT_FOUND));
-        .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<UsbDevice>(mockDevice, desc, mockLibusb);
+    auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibUsb);
     device->open();
 
     std::vector<uint8_t> 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<UsbDevice>(mockDevice, desc, mockLibusb);
+    auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibUsb);
     device->open();
 
     std::vector<uint8_t> 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(Return(LIBUSB_ERROR_TIMEOUT));
-        .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<UsbDevice>(mockDevice, desc, mockLibusb);
+    auto device = std::make_unique<UsbDevice>(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<UsbDevice>(mockDevice, desc, mockLibusb);
+    auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibUsb);
 
-    EXPECT_CALL(*mockLibusb, getSpeed(mockDevice))
+    EXPECT_CALL(*mockLibUsb, getSpeed(mockDevice)).WillOnce(Return(LIBUSB_SPEED_HIGH));
-        .WillOnce(Return(LIBUSB_SPEED_HIGH));
 
     EXPECT_EQ(device->getSpeed(), device::Speed::HIGH);
 }
 
 TEST_F(UsbDeviceTest, GetBusNumber) {
-    auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibusb);
+    auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibUsb);
 
-    EXPECT_CALL(*mockLibusb, getBusNumber(mockDevice))
+    EXPECT_CALL(*mockLibUsb, getBusNumber(mockDevice)).WillOnce(Return(5));
-        .WillOnce(Return(5));
 
     EXPECT_EQ(device->getBusNumber(), 5);
 }
 
 TEST_F(UsbDeviceTest, GetPortNumber) {
-    auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibusb);
+    auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibUsb);
 
-    EXPECT_CALL(*mockLibusb, getPortNumber(mockDevice))
+    EXPECT_CALL(*mockLibUsb, getPortNumber(mockDevice)).WillOnce(Return(3));
-        .WillOnce(Return(3));
 
     EXPECT_EQ(device->getPortNumber(), 3);
 }
 
 TEST_F(UsbDeviceTest, GetLastError) {
-    auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibusb);
+    auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibUsb);
 
     // Initially no error
     EXPECT_EQ(device->getLastError(), Error::SUCCESS);
 
     // After a failed operation
-    EXPECT_CALL(*mockLibusb, open(_, _))
+    EXPECT_CALL(*mockLibUsb, open(_, _)).WillOnce(Return(LIBUSB_ERROR_NO_DEVICE));
-        .WillOnce(Return(LIBUSB_ERROR_NO_DEVICE));
     device->open();
 
     EXPECT_EQ(device->getLastError(), Error::NO_DEVICE);
 }
 
 TEST_F(UsbDeviceTest, GetLastErrorString) {
-    auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibusb);
+    auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibUsb);
 
-    EXPECT_CALL(*mockLibusb, errorName(static_cast<int>(Error::SUCCESS)))
+    EXPECT_CALL(*mockLibUsb, errorName(static_cast<int>(Error::SUCCESS))).WillOnce(Return("LIBUSB_SUCCESS"));
-        .WillOnce(Return("LIBUSB_SUCCESS"));
 
     EXPECT_EQ(device->getLastErrorString(), "LIBUSB_SUCCESS");
 }