moritz/ptprnt
1
0
Fork 0
Code Issues Pull Requests Actions Projects Releases 1 Wiki Activity

Create more unit tests for USB Devices and Printer Driver #21

Merged
moritz merged 6 commits from up-coverage-1 into master 2025-10-21 18:55:33 +00:00
Conversation 0 Commits 6 Files Changed 30 +143 -171
11 changed files with 143 additions and 171 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 34b4e10c62 - Show all commits

46
src/libusbwrap/LibusbWrapper.cpp → src/libusbwrap/LibUsbWrapper.cpp
View File

@@ -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);
}

34
src/libusbwrap/LibusbWrapper.hpp → src/libusbwrap/LibUsbWrapper.hpp
View File

@@ -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 {
std::shared_ptr<ILibusbWrapper> wrapper;
struct LibUsbDeviceDeleter {
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 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;

36
src/libusbwrap/UsbDevice.cpp
View File

@@ -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)
: mLibusb(libusbWrapper),
mDevice(device, LibusbDeviceDeleter{libusbWrapper}),
mDeviceDescriptor(desc) {
std::shared_ptr<ILibUsbWrapper> 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<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

12
src/libusbwrap/UsbDevice.hpp
View File

@@ -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
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<bool> mIsOpen = false;

25
src/libusbwrap/UsbDeviceFactory.cpp
View File

@@ -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)
: mLibusb(std::move(libusbWrapper)) {}
UsbDeviceFactory::UsbDeviceFactory(std::shared_ptr<ILibUsbWrapper> 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
// 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<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");

13
src/libusbwrap/UsbDeviceFactory.hpp
View File

@@ -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,
uint16_t pidMask, uint16_t vid,
std::vector<std::unique_ptr<IUsbDevice>> buildMaskedDeviceVector(uint16_t vidMask, 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

0
src/libusbwrap/interface/ILibUsbWrapper.hpp Normal file
View File

4
src/meson.build
View File

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

6
tests/meson.build
View File

@@ -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)

8
tests/mocks/MockLibusbWrapper.hpp → tests/mocks/MockLibUsbWrapper.hpp
View File

@@ -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));

130
tests/usb_device_test/usb_device_test.cpp
View File

@@ -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(_, _))
.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<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, _))
.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<UsbDevice>(mockDevice, desc, mockLibusb);
auto device = std::make_unique<UsbDevice>(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<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))
.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<UsbDevice>(mockDevice, desc, mockLibusb);
auto device = std::make_unique<UsbDevice>(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<UsbDevice>(mockDevice, desc, mockLibusb);
auto device = std::make_unique<UsbDevice>(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<UsbDevice>(mockDevice, desc, mockLibusb);
auto device = std::make_unique<UsbDevice>(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<UsbDevice>(mockDevice, desc, mockLibusb);
auto device = std::make_unique<UsbDevice>(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<UsbDevice>(mockDevice, desc, mockLibusb);
auto device = std::make_unique<UsbDevice>(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<UsbDevice>(mockDevice, desc, mockLibusb);
auto device = std::make_unique<UsbDevice>(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<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))
.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<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))
.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<UsbDevice>(mockDevice, desc, mockLibusb);
auto device = std::make_unique<UsbDevice>(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<UsbDevice>(mockDevice, desc, mockLibusb);
auto device = std::make_unique<UsbDevice>(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<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(_, _))
.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<UsbDevice>(mockDevice, desc, mockLibusb);
auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibUsb);
EXPECT_CALL(*mockLibusb, errorName(static_cast<int>(Error::SUCCESS)))
.WillOnce(Return("LIBUSB_SUCCESS"));
EXPECT_CALL(*mockLibUsb, errorName(static_cast<int>(Error::SUCCESS))).WillOnce(Return("LIBUSB_SUCCESS"));
EXPECT_EQ(device->getLastErrorString(), "LIBUSB_SUCCESS");
}