Add libusbwrapper for unit tests and UsbDevice unit tests

tests/cli_parser_test/cli_parser_test.cpp

@@ -0,0 +1,365 @@
+/*
+    ptrnt - print labels on linux
+    Copyright (C) 2025  Moritz Martinius
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+ */
+
+#include <gtest/gtest.h>
+
+#include <cstring>
+#include <vector>
+
+#include "cli/CliParser.hpp"
+
+namespace ptprnt::cli {
+
+class CliParserTest : public ::testing::Test {
+   protected:
+    void SetUp() override {
+        parser = std::make_unique<CliParser>("Test Application", "v1.0.0");
+    }
+
+    void TearDown() override { parser.reset(); }
+
+    // Helper to convert vector of strings to argc/argv
+    std::vector<char*> makeArgv(const std::vector<std::string>& args) {
+        argv_storage.clear();
+        argv_storage.reserve(args.size());
+
+        for (const auto& arg : args) {
+            argv_storage.push_back(const_cast<char*>(arg.c_str()));
+        }
+
+        return argv_storage;
+    }
+
+    std::unique_ptr<CliParser> parser;
+    std::vector<char*> argv_storage;
+};
+
+// Test: Constructor
+TEST_F(CliParserTest, Constructor) {
+    EXPECT_NO_THROW(CliParser("App", "v1.0"));
+}
+
+// Test: Parse with no arguments
+TEST_F(CliParserTest, ParseNoArguments) {
+    std::vector<std::string> args = {"ptprnt"};
+    auto argv = makeArgv(args);
+
+    int result = parser->parse(args.size(), argv.data());
+
+    EXPECT_EQ(result, 0);
+    const auto& options = parser->getOptions();
+    EXPECT_FALSE(options.verbose);
+    EXPECT_FALSE(options.trace);
+    EXPECT_FALSE(options.listDrivers);
+    EXPECT_EQ(options.printerSelection, "auto");
+    EXPECT_TRUE(options.commands.empty());
+}
+
+// Test: Parse verbose flag
+TEST_F(CliParserTest, ParseVerboseShort) {
+    std::vector<std::string> args = {"ptprnt", "-v"};
+    auto argv = makeArgv(args);
+
+    int result = parser->parse(args.size(), argv.data());
+
+    EXPECT_EQ(result, 0);
+    EXPECT_TRUE(parser->getOptions().verbose);
+}
+
+TEST_F(CliParserTest, ParseVerboseLong) {
+    std::vector<std::string> args = {"ptprnt", "--verbose"};
+    auto argv = makeArgv(args);
+
+    int result = parser->parse(args.size(), argv.data());
+
+    EXPECT_EQ(result, 0);
+    EXPECT_TRUE(parser->getOptions().verbose);
+}
+
+// Test: Parse trace flag
+TEST_F(CliParserTest, ParseTrace) {
+    std::vector<std::string> args = {"ptprnt", "--trace"};
+    auto argv = makeArgv(args);
+
+    int result = parser->parse(args.size(), argv.data());
+
+    EXPECT_EQ(result, 0);
+    EXPECT_TRUE(parser->getOptions().trace);
+}
+
+// Test: Parse list drivers flag
+TEST_F(CliParserTest, ParseListDrivers) {
+    std::vector<std::string> args = {"ptprnt", "--list-all-drivers"};
+    auto argv = makeArgv(args);
+
+    int result = parser->parse(args.size(), argv.data());
+
+    EXPECT_EQ(result, 0);
+    EXPECT_TRUE(parser->getOptions().listDrivers);
+}
+
+// Test: Parse printer selection short
+TEST_F(CliParserTest, ParsePrinterShort) {
+    std::vector<std::string> args = {"ptprnt", "-p", "P700"};
+    auto argv = makeArgv(args);
+
+    int result = parser->parse(args.size(), argv.data());
+
+    EXPECT_EQ(result, 0);
+    EXPECT_EQ(parser->getOptions().printerSelection, "P700");
+}
+
+// Test: Parse printer selection long
+TEST_F(CliParserTest, ParsePrinterLong) {
+    std::vector<std::string> args = {"ptprnt", "--printer", "FakePrinter"};
+    auto argv = makeArgv(args);
+
+    int result = parser->parse(args.size(), argv.data());
+
+    EXPECT_EQ(result, 0);
+    EXPECT_EQ(parser->getOptions().printerSelection, "FakePrinter");
+}
+
+// Test: Parse single text
+TEST_F(CliParserTest, ParseSingleText) {
+    std::vector<std::string> args = {"ptprnt", "-t", "Hello"};
+    auto argv = makeArgv(args);
+
+    int result = parser->parse(args.size(), argv.data());
+
+    EXPECT_EQ(result, 0);
+    const auto& commands = parser->getOptions().commands;
+    ASSERT_EQ(commands.size(), 1);
+    EXPECT_EQ(commands[0].first, CommandType::Text);
+    EXPECT_EQ(commands[0].second, "Hello");
+}
+
+// Test: Parse multiple texts
+TEST_F(CliParserTest, ParseMultipleTexts) {
+    std::vector<std::string> args = {"ptprnt", "-t", "Hello", "-t", "World"};
+    auto argv = makeArgv(args);
+
+    int result = parser->parse(args.size(), argv.data());
+
+    EXPECT_EQ(result, 0);
+    const auto& commands = parser->getOptions().commands;
+    ASSERT_EQ(commands.size(), 2);
+    EXPECT_EQ(commands[0].first, CommandType::Text);
+    EXPECT_EQ(commands[0].second, "Hello");
+    EXPECT_EQ(commands[1].first, CommandType::Text);
+    EXPECT_EQ(commands[1].second, "World");
+}
+
+// Test: Parse font
+TEST_F(CliParserTest, ParseFont) {
+    std::vector<std::string> args = {"ptprnt", "-f", "monospace", "-t", "Test"};
+    auto argv = makeArgv(args);
+
+    int result = parser->parse(args.size(), argv.data());
+
+    EXPECT_EQ(result, 0);
+    const auto& commands = parser->getOptions().commands;
+    ASSERT_EQ(commands.size(), 2);
+    EXPECT_EQ(commands[0].first, CommandType::Font);
+    EXPECT_EQ(commands[0].second, "monospace");
+}
+
+// Test: Parse font size
+TEST_F(CliParserTest, ParseFontSize) {
+    std::vector<std::string> args = {"ptprnt", "-s", "48", "-t", "Large"};
+    auto argv = makeArgv(args);
+
+    int result = parser->parse(args.size(), argv.data());
+
+    EXPECT_EQ(result, 0);
+    const auto& commands = parser->getOptions().commands;
+    ASSERT_GE(commands.size(), 1);
+    EXPECT_EQ(commands[0].first, CommandType::FontSize);
+    EXPECT_EQ(commands[0].second, "48");
+}
+
+// Test: Parse horizontal alignment
+TEST_F(CliParserTest, ParseHAlign) {
+    std::vector<std::string> args = {"ptprnt", "--halign", "center", "-t", "Centered"};
+    auto argv = makeArgv(args);
+
+    int result = parser->parse(args.size(), argv.data());
+
+    EXPECT_EQ(result, 0);
+    const auto& commands = parser->getOptions().commands;
+    ASSERT_GE(commands.size(), 1);
+    EXPECT_EQ(commands[0].first, CommandType::HAlign);
+    EXPECT_EQ(commands[0].second, "center");
+}
+
+// Test: Parse vertical alignment
+TEST_F(CliParserTest, ParseVAlign) {
+    std::vector<std::string> args = {"ptprnt", "--valign", "top", "-t", "Top"};
+    auto argv = makeArgv(args);
+
+    int result = parser->parse(args.size(), argv.data());
+
+    EXPECT_EQ(result, 0);
+    const auto& commands = parser->getOptions().commands;
+    ASSERT_GE(commands.size(), 1);
+    EXPECT_EQ(commands[0].first, CommandType::VAlign);
+    EXPECT_EQ(commands[0].second, "top");
+}
+
+// Test: Parse new label flag
+TEST_F(CliParserTest, ParseNewLabel) {
+    std::vector<std::string> args = {"ptprnt", "-t", "First", "--new", "-t", "Second"};
+    auto argv = makeArgv(args);
+
+    int result = parser->parse(args.size(), argv.data());
+
+    EXPECT_EQ(result, 0);
+    const auto& commands = parser->getOptions().commands;
+    ASSERT_EQ(commands.size(), 3);
+    EXPECT_EQ(commands[0].first, CommandType::Text);
+    EXPECT_EQ(commands[1].first, CommandType::NewLabel);
+    EXPECT_EQ(commands[2].first, CommandType::Text);
+}
+
+// Test: Parse complex command sequence
+TEST_F(CliParserTest, ParseComplexSequence) {
+    std::vector<std::string> args = {
+        "ptprnt",
+        "-f", "serif",
+        "-s", "24",
+        "--halign", "center",
+        "--valign", "middle",
+        "-t", "Title",
+        "--new",
+        "-f", "monospace",
+        "-s", "16",
+        "-t", "Body"
+    };
+    auto argv = makeArgv(args);
+
+    int result = parser->parse(args.size(), argv.data());
+
+    EXPECT_EQ(result, 0);
+    const auto& commands = parser->getOptions().commands;
+    ASSERT_EQ(commands.size(), 9);
+
+    // Verify order is preserved
+    EXPECT_EQ(commands[0].first, CommandType::Font);
+    EXPECT_EQ(commands[1].first, CommandType::FontSize);
+    EXPECT_EQ(commands[2].first, CommandType::HAlign);
+    EXPECT_EQ(commands[3].first, CommandType::VAlign);
+    EXPECT_EQ(commands[4].first, CommandType::Text);
+    EXPECT_EQ(commands[5].first, CommandType::NewLabel);
+    EXPECT_EQ(commands[6].first, CommandType::Font);
+    EXPECT_EQ(commands[7].first, CommandType::FontSize);
+    EXPECT_EQ(commands[8].first, CommandType::Text);
+}
+
+// Test: Parse with verbose and printer options
+TEST_F(CliParserTest, ParseCombinedOptions) {
+    std::vector<std::string> args = {
+        "ptprnt",
+        "-v",
+        "--trace",
+        "-p", "P700",
+        "-t", "Test"
+    };
+    auto argv = makeArgv(args);
+
+    int result = parser->parse(args.size(), argv.data());
+
+    EXPECT_EQ(result, 0);
+    EXPECT_TRUE(parser->getOptions().verbose);
+    EXPECT_TRUE(parser->getOptions().trace);
+    EXPECT_EQ(parser->getOptions().printerSelection, "P700");
+    EXPECT_FALSE(parser->getOptions().commands.empty());
+}
+
+// Test: Parse help flag (should return 1)
+TEST_F(CliParserTest, ParseHelp) {
+    std::vector<std::string> args = {"ptprnt", "-h"};
+    auto argv = makeArgv(args);
+
+    int result = parser->parse(args.size(), argv.data());
+
+    EXPECT_EQ(result, 1);  // Signal clean exit
+}
+
+TEST_F(CliParserTest, ParseHelpLong) {
+    std::vector<std::string> args = {"ptprnt", "--help"};
+    auto argv = makeArgv(args);
+
+    int result = parser->parse(args.size(), argv.data());
+
+    EXPECT_EQ(result, 1);  // Signal clean exit
+}
+
+// Test: Parse version flag (should return 1)
+TEST_F(CliParserTest, ParseVersion) {
+    std::vector<std::string> args = {"ptprnt", "-V"};
+    auto argv = makeArgv(args);
+
+    int result = parser->parse(args.size(), argv.data());
+
+    EXPECT_EQ(result, 1);  // Signal clean exit
+}
+
+TEST_F(CliParserTest, ParseVersionLong) {
+    std::vector<std::string> args = {"ptprnt", "--version"};
+    auto argv = makeArgv(args);
+
+    int result = parser->parse(args.size(), argv.data());
+
+    EXPECT_EQ(result, 1);  // Signal clean exit
+}
+
+// Test: Parse invalid option (should return -1)
+TEST_F(CliParserTest, ParseInvalidOption) {
+    std::vector<std::string> args = {"ptprnt", "--invalid-option"};
+    auto argv = makeArgv(args);
+
+    int result = parser->parse(args.size(), argv.data());
+
+    EXPECT_EQ(result, -1);  // Signal error
+}
+
+// Test: Default printer selection is "auto"
+TEST_F(CliParserTest, DefaultPrinterSelection) {
+    std::vector<std::string> args = {"ptprnt", "-t", "Test"};
+    auto argv = makeArgv(args);
+
+    parser->parse(args.size(), argv.data());
+
+    EXPECT_EQ(parser->getOptions().printerSelection, "auto");
+}
+
+// Test: Long text with spaces
+TEST_F(CliParserTest, ParseTextWithSpaces) {
+    std::vector<std::string> args = {"ptprnt", "-t", "Hello World"};
+    auto argv = makeArgv(args);
+
+    int result = parser->parse(args.size(), argv.data());
+
+    EXPECT_EQ(result, 0);
+    const auto& commands = parser->getOptions().commands;
+    ASSERT_EQ(commands.size(), 1);
+    EXPECT_EQ(commands[0].second, "Hello World");
+}
+
+}  // namespace ptprnt::cli

tests/meson.build

@@ -9,6 +9,9 @@ test_sources = [
     'printer_service_test/printer_service_test.cpp',
     'p700_printer_test/p700_printer_test.cpp',
     'fake_printer_test/fake_printer_test.cpp',
+    'cli_parser_test/cli_parser_test.cpp',
+    'ptouch_print_test/ptouch_print_test.cpp',
+    'usb_device_test/usb_device_test.cpp',
 
     # Source files under test - graphics
     '../src/graphics/Bitmap.cpp',
@@ -24,7 +27,14 @@ test_sources = [
     '../src/printers/P700Printer.cpp',
     '../src/printers/FakePrinter.cpp',
 
+    # Source files under test - CLI
+    '../src/cli/CliParser.cpp',
+
+    # Source files under test - Main app
+    '../src/PtouchPrint.cpp',
+
     # Source files under test - USB
+    '../src/libusbwrap/LibusbWrapper.cpp',
     '../src/libusbwrap/UsbDevice.cpp',
     '../src/libusbwrap/UsbDeviceFactory.cpp',
 ]

tests/mocks/MockLibusbWrapper.hpp

@@ -0,0 +1,76 @@
+/*
+    ptrnt - print labels on linux
+    Copyright (C) 2025  Moritz Martinius
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+ */
+
+#pragma once
+
+#include <gmock/gmock.h>
+
+#include "libusbwrap/LibusbWrapper.hpp"
+
+namespace libusbwrap {
+
+/**
+ * @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 {
+   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(void, freeDeviceList, (libusb_device * *list, int unrefDevices), (override));
+    MOCK_METHOD(void, refDevice, (libusb_device * dev), (override));
+    MOCK_METHOD(void, unrefDevice, (libusb_device * dev), (override));
+
+    // Device descriptor
+    MOCK_METHOD(int, getDeviceDescriptor, (libusb_device * dev, libusb_device_descriptor* desc), (override));
+
+    // Device opening/closing
+    MOCK_METHOD(int, open, (libusb_device * dev, libusb_device_handle** handle), (override));
+    MOCK_METHOD(void, close, (libusb_device_handle * handle), (override));
+
+    // Device information
+    MOCK_METHOD(int, getSpeed, (libusb_device * dev), (override));
+    MOCK_METHOD(uint8_t, getBusNumber, (libusb_device * dev), (override));
+    MOCK_METHOD(uint8_t, getPortNumber, (libusb_device * dev), (override));
+
+    // Kernel driver management
+    MOCK_METHOD(int, kernelDriverActive, (libusb_device_handle * handle, int interfaceNo), (override));
+    MOCK_METHOD(int, detachKernelDriver, (libusb_device_handle * handle, int interfaceNo), (override));
+
+    // Interface management
+    MOCK_METHOD(int, claimInterface, (libusb_device_handle * handle, int interfaceNo), (override));
+    MOCK_METHOD(int, releaseInterface, (libusb_device_handle * handle, int interfaceNo), (override));
+
+    // Data transfer
+    MOCK_METHOD(int, bulkTransfer,
+                (libusb_device_handle * handle, uint8_t endpoint, unsigned char* data, int length, int* transferred,
+                 unsigned int timeout),
+                (override));
+
+    // Error handling
+    MOCK_METHOD(const char*, errorName, (int errorCode), (override));
+};
+
+}  // namespace libusbwrap

tests/ptouch_print_test/ptouch_print_test.cpp

@@ -0,0 +1,374 @@
+/*
+    ptrnt - print labels on linux
+    Copyright (C) 2025  Moritz Martinius
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+ */
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "PtouchPrint.hpp"
+#include "cli/interface/ICliParser.hpp"
+#include "core/interface/IPrinterService.hpp"
+#include "printers/interface/IPrinterDriver.hpp"
+
+using ::testing::_;
+using ::testing::NiceMock;
+using ::testing::Return;
+using ::testing::ReturnRef;
+
+namespace ptprnt {
+
+// Mock CLI Parser
+class MockCliParser : public cli::ICliParser {
+   public:
+    MOCK_METHOD(int, parse, (int argc, char** argv), (override));
+    MOCK_METHOD(const cli::CliOptions&, getOptions, (), (const, override));
+
+    cli::CliOptions options;
+};
+
+// Mock Printer Service
+class MockPrinterService : public core::IPrinterService {
+   public:
+    MOCK_METHOD(bool, initialize, (), (override));
+    MOCK_METHOD(std::vector<std::shared_ptr<IPrinterDriver>>, detectPrinters, (), (override));
+    MOCK_METHOD(std::shared_ptr<IPrinterDriver>, selectPrinter, (const std::string& selection), (override));
+    MOCK_METHOD(std::shared_ptr<IPrinterDriver>, getCurrentPrinter, (), (const, override));
+    MOCK_METHOD(bool, printLabel, (std::unique_ptr<graphics::ILabel> label), (override));
+};
+
+// Mock Printer Driver
+class MockPrinterDriver : public IPrinterDriver {
+   public:
+    MOCK_METHOD(std::string_view, getDriverName, (), (override));
+    MOCK_METHOD(std::string_view, getName, (), (override));
+    MOCK_METHOD(libusbwrap::usbId, getUsbId, (), (override));
+    MOCK_METHOD(std::string_view, getVersion, (), (override));
+    MOCK_METHOD(PrinterInfo, getPrinterInfo, (), (override));
+    MOCK_METHOD(PrinterStatus, getPrinterStatus, (), (override));
+    MOCK_METHOD(bool, attachUsbDevice, (std::shared_ptr<libusbwrap::IUsbDevice> usbHndl), (override));
+    MOCK_METHOD(bool, detachUsbDevice, (), (override));
+    MOCK_METHOD(bool, printBitmap, (const graphics::Bitmap<graphics::ALPHA8>& bitmap), (override));
+    MOCK_METHOD(bool, printMonochromeData, (const graphics::MonochromeData& data), (override));
+    MOCK_METHOD(bool, printLabel, (std::unique_ptr<graphics::ILabel> label), (override));
+    MOCK_METHOD(bool, print, (), (override));
+};
+
+class PtouchPrintTest : public ::testing::Test {
+   protected:
+    void SetUp() override {
+        mockCliParser = std::make_unique<NiceMock<MockCliParser>>();
+        mockPrinterService = std::make_unique<NiceMock<MockPrinterService>>();
+
+        // Store raw pointers for setting expectations
+        cliParserPtr = mockCliParser.get();
+        printerServicePtr = mockPrinterService.get();
+
+        // Default behavior: parse succeeds and returns empty options
+        ON_CALL(*cliParserPtr, parse(_, _)).WillByDefault(Return(0));
+        ON_CALL(*cliParserPtr, getOptions()).WillByDefault(ReturnRef(cliParserPtr->options));
+        ON_CALL(*printerServicePtr, initialize()).WillByDefault(Return(true));
+        ON_CALL(*printerServicePtr, printLabel(_)).WillByDefault(Return(true));
+    }
+
+    void TearDown() override {}
+
+    std::unique_ptr<MockCliParser> mockCliParser;
+    std::unique_ptr<MockPrinterService> mockPrinterService;
+    MockCliParser* cliParserPtr;
+    MockPrinterService* printerServicePtr;
+};
+
+// Test: Constructor with default implementations
+TEST_F(PtouchPrintTest, ConstructorDefault) {
+    EXPECT_NO_THROW(PtouchPrint app("v1.0.0"));
+}
+
+// Test: Constructor with custom implementations
+TEST_F(PtouchPrintTest, ConstructorCustom) {
+    EXPECT_NO_THROW({
+        PtouchPrint app("v1.0.0", std::move(mockCliParser), std::move(mockPrinterService));
+    });
+}
+
+// Test: init with successful parse
+TEST_F(PtouchPrintTest, InitSuccess) {
+    PtouchPrint app("v1.0.0", std::move(mockCliParser), std::move(mockPrinterService));
+
+    char* argv[] = {(char*)"ptprnt"};
+    int result = app.init(1, argv);
+
+    EXPECT_EQ(result, 0);
+}
+
+// Test: init with parse returning help (should return 1)
+TEST_F(PtouchPrintTest, InitHelp) {
+    ON_CALL(*cliParserPtr, parse(_, _)).WillByDefault(Return(1));
+
+    PtouchPrint app("v1.0.0", std::move(mockCliParser), std::move(mockPrinterService));
+
+    char* argv[] = {(char*)"ptprnt", (char*)"-h"};
+    int result = app.init(2, argv);
+
+    EXPECT_EQ(result, 1);  // Clean exit
+}
+
+// Test: init with parse error (should return -1)
+TEST_F(PtouchPrintTest, InitParseError) {
+    ON_CALL(*cliParserPtr, parse(_, _)).WillByDefault(Return(-1));
+
+    PtouchPrint app("v1.0.0", std::move(mockCliParser), std::move(mockPrinterService));
+
+    char* argv[] = {(char*)"ptprnt", (char*)"--invalid"};
+    int result = app.init(2, argv);
+
+    EXPECT_EQ(result, -1);  // Error
+}
+
+// Test: init with printer service initialization failure
+TEST_F(PtouchPrintTest, InitPrinterServiceFailure) {
+    ON_CALL(*printerServicePtr, initialize()).WillByDefault(Return(false));
+
+    PtouchPrint app("v1.0.0", std::move(mockCliParser), std::move(mockPrinterService));
+
+    char* argv[] = {(char*)"ptprnt"};
+    int result = app.init(1, argv);
+
+    EXPECT_EQ(result, -1);  // Error
+}
+
+// Test: run with list drivers option
+TEST_F(PtouchPrintTest, RunListDrivers) {
+    cliParserPtr->options.listDrivers = true;
+
+    PtouchPrint app("v1.0.0", std::move(mockCliParser), std::move(mockPrinterService));
+
+    char* argv[] = {(char*)"ptprnt"};
+    app.init(1, argv);
+
+    int result = app.run();
+
+    EXPECT_EQ(result, 0);
+}
+
+// Test: run with no commands (should warn but succeed)
+TEST_F(PtouchPrintTest, RunNoCommands) {
+    auto mockPrinter = std::make_shared<NiceMock<MockPrinterDriver>>();
+    PrinterStatus status{.tapeWidthMm = 12};
+
+    ON_CALL(*mockPrinter, getPrinterStatus()).WillByDefault(Return(status));
+    ON_CALL(*printerServicePtr, selectPrinter(_)).WillByDefault(Return(mockPrinter));
+
+    cliParserPtr->options.commands.clear();
+
+    PtouchPrint app("v1.0.0", std::move(mockCliParser), std::move(mockPrinterService));
+
+    char* argv[] = {(char*)"ptprnt"};
+    app.init(1, argv);
+
+    int result = app.run();
+
+    EXPECT_EQ(result, 0);
+}
+
+// Test: run with printer selection failure
+TEST_F(PtouchPrintTest, RunPrinterSelectionFailure) {
+    ON_CALL(*printerServicePtr, selectPrinter(_)).WillByDefault(Return(nullptr));
+
+    cliParserPtr->options.commands.push_back({cli::CommandType::Text, "Test"});
+
+    PtouchPrint app("v1.0.0", std::move(mockCliParser), std::move(mockPrinterService));
+
+    char* argv[] = {(char*)"ptprnt"};
+    app.init(1, argv);
+
+    int result = app.run();
+
+    EXPECT_EQ(result, -1);
+}
+
+// Test: run with simple text command
+TEST_F(PtouchPrintTest, RunSimpleText) {
+    auto mockPrinter = std::make_shared<NiceMock<MockPrinterDriver>>();
+    PrinterInfo info{.driverName = "Test", .name = "Test", .version = "v1.0", .usbId = {0, 0}, .pixelLines = 128};
+    PrinterStatus status{.tapeWidthMm = 12};
+
+    ON_CALL(*mockPrinter, getPrinterInfo()).WillByDefault(Return(info));
+    ON_CALL(*mockPrinter, getPrinterStatus()).WillByDefault(Return(status));
+    ON_CALL(*mockPrinter, printLabel(_)).WillByDefault(Return(true));
+    ON_CALL(*printerServicePtr, selectPrinter(_)).WillByDefault(Return(mockPrinter));
+
+    cliParserPtr->options.commands.push_back({cli::CommandType::Text, "Hello"});
+
+    PtouchPrint app("v1.0.0", std::move(mockCliParser), std::move(mockPrinterService));
+
+    char* argv[] = {(char*)"ptprnt"};
+    app.init(1, argv);
+
+    int result = app.run();
+
+    EXPECT_EQ(result, 0);
+}
+
+// Test: run with font and text commands
+TEST_F(PtouchPrintTest, RunWithFormatting) {
+    auto mockPrinter = std::make_shared<NiceMock<MockPrinterDriver>>();
+    PrinterInfo info{.driverName = "Test", .name = "Test", .version = "v1.0", .usbId = {0, 0}, .pixelLines = 128};
+    PrinterStatus status{.tapeWidthMm = 12};
+
+    ON_CALL(*mockPrinter, getPrinterInfo()).WillByDefault(Return(info));
+    ON_CALL(*mockPrinter, getPrinterStatus()).WillByDefault(Return(status));
+    ON_CALL(*mockPrinter, printLabel(_)).WillByDefault(Return(true));
+    ON_CALL(*printerServicePtr, selectPrinter(_)).WillByDefault(Return(mockPrinter));
+
+    cliParserPtr->options.commands.push_back({cli::CommandType::Font, "monospace"});
+    cliParserPtr->options.commands.push_back({cli::CommandType::FontSize, "48"});
+    cliParserPtr->options.commands.push_back({cli::CommandType::Text, "Formatted"});
+
+    PtouchPrint app("v1.0.0", std::move(mockCliParser), std::move(mockPrinterService));
+
+    char* argv[] = {(char*)"ptprnt"};
+    app.init(1, argv);
+
+    int result = app.run();
+
+    EXPECT_EQ(result, 0);
+}
+
+// Test: run with alignment commands
+TEST_F(PtouchPrintTest, RunWithAlignment) {
+    auto mockPrinter = std::make_shared<NiceMock<MockPrinterDriver>>();
+    PrinterInfo info{.driverName = "Test", .name = "Test", .version = "v1.0", .usbId = {0, 0}, .pixelLines = 128};
+    PrinterStatus status{.tapeWidthMm = 12};
+
+    ON_CALL(*mockPrinter, getPrinterInfo()).WillByDefault(Return(info));
+    ON_CALL(*mockPrinter, getPrinterStatus()).WillByDefault(Return(status));
+    ON_CALL(*mockPrinter, printLabel(_)).WillByDefault(Return(true));
+    ON_CALL(*printerServicePtr, selectPrinter(_)).WillByDefault(Return(mockPrinter));
+
+    cliParserPtr->options.commands.push_back({cli::CommandType::HAlign, "center"});
+    cliParserPtr->options.commands.push_back({cli::CommandType::VAlign, "middle"});
+    cliParserPtr->options.commands.push_back({cli::CommandType::Text, "Centered"});
+
+    PtouchPrint app("v1.0.0", std::move(mockCliParser), std::move(mockPrinterService));
+
+    char* argv[] = {(char*)"ptprnt"};
+    app.init(1, argv);
+
+    int result = app.run();
+
+    EXPECT_EQ(result, 0);
+}
+
+// Test: run with invalid alignment (should handle gracefully)
+TEST_F(PtouchPrintTest, RunWithInvalidAlignment) {
+    auto mockPrinter = std::make_shared<NiceMock<MockPrinterDriver>>();
+    PrinterInfo info{.driverName = "Test", .name = "Test", .version = "v1.0", .usbId = {0, 0}, .pixelLines = 128};
+    PrinterStatus status{.tapeWidthMm = 12};
+
+    ON_CALL(*mockPrinter, getPrinterInfo()).WillByDefault(Return(info));
+    ON_CALL(*mockPrinter, getPrinterStatus()).WillByDefault(Return(status));
+    ON_CALL(*mockPrinter, printLabel(_)).WillByDefault(Return(true));
+    ON_CALL(*printerServicePtr, selectPrinter(_)).WillByDefault(Return(mockPrinter));
+
+    cliParserPtr->options.commands.push_back({cli::CommandType::HAlign, "invalid"});
+    cliParserPtr->options.commands.push_back({cli::CommandType::Text, "Test"});
+
+    PtouchPrint app("v1.0.0", std::move(mockCliParser), std::move(mockPrinterService));
+
+    char* argv[] = {(char*)"ptprnt"};
+    app.init(1, argv);
+
+    int result = app.run();
+
+    EXPECT_EQ(result, 0);  // Should handle gracefully
+}
+
+// Test: run with new label command
+TEST_F(PtouchPrintTest, RunWithNewLabel) {
+    auto mockPrinter = std::make_shared<NiceMock<MockPrinterDriver>>();
+    PrinterInfo info{.driverName = "Test", .name = "Test", .version = "v1.0", .usbId = {0, 0}, .pixelLines = 128};
+    PrinterStatus status{.tapeWidthMm = 12};
+
+    ON_CALL(*mockPrinter, getPrinterInfo()).WillByDefault(Return(info));
+    ON_CALL(*mockPrinter, getPrinterStatus()).WillByDefault(Return(status));
+    ON_CALL(*mockPrinter, printLabel(_)).WillByDefault(Return(true));
+    ON_CALL(*printerServicePtr, selectPrinter(_)).WillByDefault(Return(mockPrinter));
+
+    cliParserPtr->options.commands.push_back({cli::CommandType::Text, "First"});
+    cliParserPtr->options.commands.push_back({cli::CommandType::NewLabel, ""});
+    cliParserPtr->options.commands.push_back({cli::CommandType::Text, "Second"});
+
+    PtouchPrint app("v1.0.0", std::move(mockCliParser), std::move(mockPrinterService));
+
+    char* argv[] = {(char*)"ptprnt"};
+    app.init(1, argv);
+
+    int result = app.run();
+
+    EXPECT_EQ(result, 0);
+}
+
+// Test: run with verbose option
+TEST_F(PtouchPrintTest, RunWithVerbose) {
+    auto mockPrinter = std::make_shared<NiceMock<MockPrinterDriver>>();
+    PrinterInfo info{.driverName = "Test", .name = "Test", .version = "v1.0", .usbId = {0, 0}, .pixelLines = 128};
+    PrinterStatus status{.tapeWidthMm = 12};
+
+    ON_CALL(*mockPrinter, getPrinterInfo()).WillByDefault(Return(info));
+    ON_CALL(*mockPrinter, getPrinterStatus()).WillByDefault(Return(status));
+    ON_CALL(*mockPrinter, printLabel(_)).WillByDefault(Return(true));
+    ON_CALL(*printerServicePtr, selectPrinter(_)).WillByDefault(Return(mockPrinter));
+
+    cliParserPtr->options.verbose = true;
+    cliParserPtr->options.commands.push_back({cli::CommandType::Text, "Test"});
+
+    PtouchPrint app("v1.0.0", std::move(mockCliParser), std::move(mockPrinterService));
+
+    char* argv[] = {(char*)"ptprnt"};
+    app.init(1, argv);
+
+    int result = app.run();
+
+    EXPECT_EQ(result, 0);
+}
+
+// Test: run with trace option
+TEST_F(PtouchPrintTest, RunWithTrace) {
+    auto mockPrinter = std::make_shared<NiceMock<MockPrinterDriver>>();
+    PrinterInfo info{.driverName = "Test", .name = "Test", .version = "v1.0", .usbId = {0, 0}, .pixelLines = 128};
+    PrinterStatus status{.tapeWidthMm = 12};
+
+    ON_CALL(*mockPrinter, getPrinterInfo()).WillByDefault(Return(info));
+    ON_CALL(*mockPrinter, getPrinterStatus()).WillByDefault(Return(status));
+    ON_CALL(*mockPrinter, printLabel(_)).WillByDefault(Return(true));
+    ON_CALL(*printerServicePtr, selectPrinter(_)).WillByDefault(Return(mockPrinter));
+
+    cliParserPtr->options.trace = true;
+    cliParserPtr->options.commands.push_back({cli::CommandType::Text, "Test"});
+
+    PtouchPrint app("v1.0.0", std::move(mockCliParser), std::move(mockPrinterService));
+
+    char* argv[] = {(char*)"ptprnt"};
+    app.init(1, argv);
+
+    int result = app.run();
+
+    EXPECT_EQ(result, 0);
+}
+
+}  // namespace ptprnt

tests/usb_device_test/usb_device_test.cpp

@@ -0,0 +1,296 @@
+/*
+    ptrnt - print labels on linux
+    Copyright (C) 2025  Moritz Martinius
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+ */
+
+#include "libusbwrap/UsbDevice.hpp"
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <memory>
+
+#include "libusb.h"
+#include "libusbwrap/LibUsbTypes.hpp"
+#include "mocks/MockLibusbWrapper.hpp"
+
+using ::testing::_;
+using ::testing::DoAll;
+using ::testing::NiceMock;
+using ::testing::Return;
+using ::testing::SetArgPointee;
+
+namespace libusbwrap {
+
+// Test fixture for UsbDevice tests
+class UsbDeviceTest : public ::testing::Test {
+   protected:
+    void SetUp() override {
+        mockLibusb = std::make_shared<NiceMock<MockLibusbWrapper>>();
+
+        // Create mock device pointer
+        mockDevice = reinterpret_cast<libusb_device*>(0x1000);
+
+        // Create mock device handle
+        mockHandle = reinterpret_cast<libusb_device_handle*>(0x2000);
+
+        // Setup device descriptor
+        desc.idVendor  = 0x04f9;  // Brother vendor ID
+        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"));
+    }
+
+    std::shared_ptr<MockLibusbWrapper> mockLibusb;
+    libusb_device* mockDevice;
+    libusb_device_handle* mockHandle;
+    libusb_device_descriptor desc{};
+};
+
+// Constructor tests
+TEST_F(UsbDeviceTest, ConstructorWithValidDevice) {
+    EXPECT_NO_THROW({
+        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);
+}
+
+// Open/Close tests
+TEST_F(UsbDeviceTest, OpenSuccess) {
+    auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibusb);
+
+    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);
+
+    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);
+    device->open();
+
+    EXPECT_CALL(*mockLibusb, close(mockHandle)).Times(1);
+    device->close();
+}
+
+TEST_F(UsbDeviceTest, CloseWithoutOpenDevice) {
+    auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibusb);
+
+    // Should not call close if device was never opened
+    EXPECT_CALL(*mockLibusb, close(_)).Times(0);
+    device->close();
+}
+
+TEST_F(UsbDeviceTest, DestructorClosesOpenDevice) {
+    EXPECT_CALL(*mockLibusb, close(mockHandle)).Times(1);
+
+    {
+        auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibusb);
+        device->open();
+        // Device goes out of scope, destructor should call close
+    }
+}
+
+// Kernel driver tests
+TEST_F(UsbDeviceTest, DetachKernelDriverWhenActive) {
+    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_TRUE(device->detachKernelDriver(0));
+}
+
+TEST_F(UsbDeviceTest, DetachKernelDriverWhenNotActive) {
+    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_TRUE(device->detachKernelDriver(0));
+}
+
+TEST_F(UsbDeviceTest, DetachKernelDriverFailure) {
+    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_FALSE(device->detachKernelDriver(0));
+    EXPECT_EQ(device->getLastError(), Error::NOT_FOUND);
+}
+
+// Interface tests
+TEST_F(UsbDeviceTest, ClaimInterfaceSuccess) {
+    auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibusb);
+    device->open();
+
+    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);
+    device->open();
+
+    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);
+    device->open();
+
+    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);
+    device->open();
+
+    EXPECT_CALL(*mockLibusb, releaseInterface(mockHandle, 0))
+        .WillOnce(Return(LIBUSB_ERROR_NOT_FOUND));
+
+    EXPECT_FALSE(device->releaseInterface(0));
+    EXPECT_EQ(device->getLastError(), Error::NOT_FOUND);
+}
+
+// Bulk transfer tests
+TEST_F(UsbDeviceTest, BulkTransferSuccess) {
+    auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibusb);
+    device->open();
+
+    std::vector<uint8_t> data = {0x01, 0x02, 0x03};
+    int transferred            = 0;
+
+    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);
+    device->open();
+
+    std::vector<uint8_t> data = {0x01, 0x02, 0x03};
+    int transferred            = 0;
+
+    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);
+}
+
+// Getter tests
+TEST_F(UsbDeviceTest, GetUsbId) {
+    auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibusb);
+
+    auto usbId = device->getUsbId();
+    EXPECT_EQ(usbId.first, 0x04f9);   // vid
+    EXPECT_EQ(usbId.second, 0x2042);  // pid
+}
+
+TEST_F(UsbDeviceTest, GetSpeed) {
+    auto device = std::make_unique<UsbDevice>(mockDevice, desc, mockLibusb);
+
+    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);
+
+    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);
+
+    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);
+
+    // Initially no error
+    EXPECT_EQ(device->getLastError(), Error::SUCCESS);
+
+    // After a failed operation
+    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);
+
+    EXPECT_CALL(*mockLibusb, errorName(static_cast<int>(Error::SUCCESS)))
+        .WillOnce(Return("LIBUSB_SUCCESS"));
+
+    EXPECT_EQ(device->getLastErrorString(), "LIBUSB_SUCCESS");
+}
+
+}  // namespace libusbwrap