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

Rename occurences Libusb -> LibUsb
All checks were successful
Build ptprnt / build (push) Successful in 3m0s
Details

Browse Source
This commit is contained in:
Moritz Martinius
2025-10-21 20:29:33 +02:00
parent 7f0082ddbe
commit 34b4e10c62
11 changed files with 143 additions and 171 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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