From 083b246c5eb06768f7fe30949f6ef09a2fea8c20 Mon Sep 17 00:00:00 2001 From: zhanghongyuan Date: Fri, 18 Sep 2026 10:56:05 +0800 Subject: [PATCH] test(unittest): add unit tests for driveritem, PageDriverBackupInfo and PageDriverRestoreInfo --- .../src/Page/ut_pagedriverbackupinfo.cpp | 267 ++++++++++ .../src/Page/ut_pagedriverrestoreinfo.cpp | 175 +++++++ .../tests/src/Widget/ut_driveritem.cpp | 489 ++++++++++++++++++ 3 files changed, 931 insertions(+) create mode 100644 deepin-devicemanager/tests/src/Page/ut_pagedriverbackupinfo.cpp create mode 100644 deepin-devicemanager/tests/src/Page/ut_pagedriverrestoreinfo.cpp create mode 100644 deepin-devicemanager/tests/src/Widget/ut_driveritem.cpp diff --git a/deepin-devicemanager/tests/src/Page/ut_pagedriverbackupinfo.cpp b/deepin-devicemanager/tests/src/Page/ut_pagedriverbackupinfo.cpp new file mode 100644 index 000000000..66036527f --- /dev/null +++ b/deepin-devicemanager/tests/src/Page/ut_pagedriverbackupinfo.cpp @@ -0,0 +1,267 @@ +// Copyright (C) 2026 Uniontech Software Technology Co.,Ltd +// SPDX-FileCopyrightText: 2026 UnionTech Software Technology Co., Ltd. +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#include + +#include + +#include "stub.h" + +#define private public +#include "PageDriverBackupInfo.h" +#include "PageDriverTableView.h" +#include "driveritem.h" +#undef private + +class UT_PageDriverBackupInfo : public ::testing::Test +{ +public: + void SetUp() + { + m_page = new PageDriverBackupInfo; + } + void TearDown() + { + delete m_page; + } + PageDriverBackupInfo *m_page = nullptr; +}; + +TEST_F(UT_PageDriverBackupInfo, Constructor_Created_ReturnsValidPointers) +{ + // Arrange + // (page created in SetUp) + + // Act + bool headValid = (m_page->mp_HeadWidget != nullptr); + bool viewValid = (m_page->mp_ViewBackable != nullptr); + + // Assert + EXPECT_NE(nullptr, m_page); + EXPECT_TRUE(headValid); + EXPECT_TRUE(viewValid); + EXPECT_NE(nullptr, m_page->mp_ViewBackedUp); + EXPECT_NE(nullptr, m_page->mp_BackableDriverLabel); + EXPECT_NE(nullptr, m_page->mp_BackedUpDriverLabel); +} + +TEST_F(UT_PageDriverBackupInfo, ShowTables_BothZero_AllHidden) +{ + // Arrange + // Act + m_page->showTables(0, 0); + + // Assert + EXPECT_TRUE(m_page->mp_BackableDriverLabel->isHidden()); + EXPECT_TRUE(m_page->mp_NotBackupWidget->isHidden()); + EXPECT_TRUE(m_page->mp_BackedUpDriverLabel->isHidden()); + EXPECT_TRUE(m_page->mp_BackedUpWidget->isHidden()); +} + +TEST_F(UT_PageDriverBackupInfo, ShowTables_BackableOnly_BackableVisible) +{ + // Arrange + // Act + m_page->showTables(3, 0); + + // Assert + EXPECT_FALSE(m_page->mp_BackableDriverLabel->isHidden()); + EXPECT_FALSE(m_page->mp_NotBackupWidget->isHidden()); + EXPECT_TRUE(m_page->mp_BackedUpDriverLabel->isHidden()); + EXPECT_TRUE(m_page->mp_BackedUpWidget->isHidden()); +} + +TEST_F(UT_PageDriverBackupInfo, ShowTables_BackedUpOnly_BackedUpVisible) +{ + // Arrange + // Act + m_page->showTables(0, 2); + + // Assert + EXPECT_TRUE(m_page->mp_BackableDriverLabel->isHidden()); + EXPECT_TRUE(m_page->mp_NotBackupWidget->isHidden()); + EXPECT_FALSE(m_page->mp_BackedUpDriverLabel->isHidden()); + EXPECT_FALSE(m_page->mp_BackedUpWidget->isHidden()); +} + +TEST_F(UT_PageDriverBackupInfo, ShowTables_BothPresent_AllVisible) +{ + // Arrange + // Act + m_page->showTables(2, 1); + + // Assert + EXPECT_FALSE(m_page->mp_BackableDriverLabel->isHidden()); + EXPECT_FALSE(m_page->mp_NotBackupWidget->isHidden()); + EXPECT_FALSE(m_page->mp_BackedUpDriverLabel->isHidden()); + EXPECT_FALSE(m_page->mp_BackedUpWidget->isHidden()); +} + +TEST_F(UT_PageDriverBackupInfo, ClearAllData_AfterAdd_RowsCleared) +{ + // Arrange + DriverInfo *info = new DriverInfo(); + info->m_Name = "TestDriver"; + info->m_DebVersion = "1.0.0"; + info->m_Type = DR_Camera; + info->m_Packages = "test-pkg"; + info->m_Status = ST_NOT_INSTALL; + m_page->addDriverInfoToTableView(info, 0); + + // Act + m_page->clearAllData(); + + // Assert + EXPECT_EQ(0, m_page->mp_ViewBackable->model()->rowCount()); + EXPECT_EQ(0, m_page->mp_ViewBackedUp->model()->rowCount()); + + delete info; +} + +TEST_F(UT_PageDriverBackupInfo, UpdateItemStatus_BackupFailed_NoCrash) +{ + // Arrange + DriverInfo *info = new DriverInfo(); + info->m_Name = "TestDriver"; + info->m_DebVersion = "1.0.0"; + info->m_Type = DR_Camera; + info->m_Packages = "test-pkg"; + info->m_Status = ST_NOT_INSTALL; + m_page->addDriverInfoToTableView(info, 0); + + // Act + m_page->updateItemStatus(0, ST_DRIVER_BACKUP_FAILED); + + // Assert + EXPECT_EQ(1, m_page->mp_ViewBackable->model()->rowCount()); + EXPECT_NE(nullptr, m_page->mp_ViewBackable); + + delete info; +} + +TEST_F(UT_PageDriverBackupInfo, UpdateItemStatus_Normal_NoCrash) +{ + // Arrange + DriverInfo *info = new DriverInfo(); + info->m_Name = "TestDriver"; + info->m_DebVersion = "1.0.0"; + info->m_Type = DR_Camera; + info->m_Packages = "test-pkg"; + info->m_Status = ST_NOT_INSTALL; + m_page->addDriverInfoToTableView(info, 0); + + // Act + m_page->updateItemStatus(0, ST_DRIVER_BACKUP_SUCCESS); + + // Assert + EXPECT_EQ(1, m_page->mp_ViewBackable->model()->rowCount()); + EXPECT_NE(nullptr, m_page->mp_ViewBackable); + + delete info; +} + +TEST_F(UT_PageDriverBackupInfo, SetCheckedCBDisnable_Called_NoCrash) +{ + // Arrange + // Act + m_page->setCheckedCBDisnable(); + + // Assert + EXPECT_NE(nullptr, m_page->mp_ViewBackable); + EXPECT_NE(nullptr, m_page); +} + +TEST_F(UT_PageDriverBackupInfo, SetHeaderCbEnable_TrueFalse_NoCrash) +{ + // Arrange + // Act + m_page->setHeaderCbEnable(true); + m_page->setHeaderCbEnable(false); + + // Assert + EXPECT_NE(nullptr, m_page->mp_ViewBackable); + EXPECT_NE(nullptr, m_page); +} + +TEST_F(UT_PageDriverBackupInfo, GetCheckedDriverIndex_Empty_ListEmpty) +{ + // Arrange + QList list; + + // Act + m_page->getCheckedDriverIndex(list); + + // Assert + EXPECT_EQ(0, list.size()); + EXPECT_TRUE(list.isEmpty()); +} + +TEST_F(UT_PageDriverBackupInfo, GetCheckedDriverIndex_WithData_ListNonNegative) +{ + // Arrange + DriverInfo *info = new DriverInfo(); + info->m_Name = "TestDriver"; + info->m_DebVersion = "1.0.0"; + info->m_Type = DR_Camera; + info->m_Packages = "test-pkg"; + info->m_Status = ST_NOT_INSTALL; + m_page->addDriverInfoToTableView(info, 0); + QList list; + + // Act + m_page->getCheckedDriverIndex(list); + + // Assert + EXPECT_GE(list.size(), 0); + EXPECT_EQ(1, m_page->mp_ViewBackable->model()->rowCount()); + + delete info; +} + +TEST_F(UT_PageDriverBackupInfo, AddDriverInfo_Backable_RowIncremented) +{ + // Arrange + DriverInfo *info = new DriverInfo(); + info->m_Name = "TestDriver"; + info->m_DebVersion = "1.0.0"; + info->m_DebBackupVersion = "0.9.0"; + info->m_Type = DR_Camera; + info->m_Packages = "test-pkg"; + info->m_Status = ST_NOT_INSTALL; + int before = m_page->mp_ViewBackable->model()->rowCount(); + + // Act + m_page->addDriverInfoToTableView(info, 0); + + // Assert + int after = m_page->mp_ViewBackable->model()->rowCount(); + EXPECT_EQ(before + 1, after); + EXPECT_GT(after, before); + + delete info; +} + +TEST_F(UT_PageDriverBackupInfo, AddDriverInfo_BackedUp_RowIncremented) +{ + // Arrange + DriverInfo *info = new DriverInfo(); + info->m_Name = "TestDriver"; + info->m_DebVersion = "1.0.0"; + info->m_DebBackupVersion = "0.9.0"; + info->m_Type = DR_Camera; + info->m_Packages = "test-pkg"; + info->m_Status = ST_CAN_UPDATE; + int before = m_page->mp_ViewBackedUp->model()->rowCount(); + + // Act + m_page->addDriverInfoToTableView(info, 0); + + // Assert + int after = m_page->mp_ViewBackedUp->model()->rowCount(); + EXPECT_EQ(before + 1, after); + EXPECT_GT(after, before); + + delete info; +} diff --git a/deepin-devicemanager/tests/src/Page/ut_pagedriverrestoreinfo.cpp b/deepin-devicemanager/tests/src/Page/ut_pagedriverrestoreinfo.cpp new file mode 100644 index 000000000..b1847d559 --- /dev/null +++ b/deepin-devicemanager/tests/src/Page/ut_pagedriverrestoreinfo.cpp @@ -0,0 +1,175 @@ +// Copyright (C) 2026 Uniontech Software Technology Co.,Ltd +// SPDX-FileCopyrightText: 2026 UnionTech Software Technology Co., Ltd. +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#include + +#include + +#include "stub.h" + +#define private public +#include "PageDriverRestoreInfo.h" +#include "PageDriverTableView.h" +#include "driveritem.h" +#undef private + +class UT_PageDriverRestoreInfo : public ::testing::Test +{ +public: + void SetUp() + { + m_page = new PageDriverRestoreInfo; + } + void TearDown() + { + delete m_page; + } + PageDriverRestoreInfo *m_page = nullptr; +}; + +TEST_F(UT_PageDriverRestoreInfo, Constructor_Created_ReturnsValidPointers) +{ + // Arrange + // (page created in SetUp) + + // Act + bool stackValid = (m_page->mp_StackWidget != nullptr); + bool viewValid = (m_page->mp_ViewBackable != nullptr); + + // Assert + EXPECT_NE(nullptr, m_page); + EXPECT_TRUE(stackValid); + EXPECT_TRUE(viewValid); + EXPECT_NE(nullptr, m_page->mp_HeadWidget); + EXPECT_NE(nullptr, m_page->mp_BackableDriverLabel); + EXPECT_NE(nullptr, m_page->mp_NoRestoreDriverFrame); + EXPECT_NE(nullptr, m_page->mp_GotoBackupSgButton); +} + +TEST_F(UT_PageDriverRestoreInfo, ShowTables_ZeroDrivers_StackIndexZero) +{ + // Arrange + // Act + m_page->showTables(0); + + // Assert + EXPECT_EQ(0, m_page->mp_StackWidget->currentIndex()); + EXPECT_NE(nullptr, m_page->mp_StackWidget); +} + +TEST_F(UT_PageDriverRestoreInfo, ShowTables_WithDrivers_StackIndexOne) +{ + // Arrange + // Act + m_page->showTables(3); + + // Assert + EXPECT_EQ(1, m_page->mp_StackWidget->currentIndex()); + EXPECT_NE(nullptr, m_page->mp_StackWidget); +} + +TEST_F(UT_PageDriverRestoreInfo, ClearAllData_AfterAdd_RowsCleared) +{ + // Arrange + DriverInfo *info = new DriverInfo(); + info->m_Name = "TestDriver"; + info->m_DebVersion = "1.0.0"; + info->m_DebBackupVersion = "0.9.0"; + info->m_Type = DR_Camera; + info->m_Packages = "test-pkg"; + info->m_Status = ST_DRIVER_CAN_RESTORE; + m_page->addDriverInfoToTableView(info, 0); + + // Act + m_page->clearAllData(); + + // Assert + EXPECT_EQ(0, m_page->mp_ViewBackable->model()->rowCount()); + EXPECT_NE(nullptr, m_page->mp_ViewBackable); + + delete info; +} + +TEST_F(UT_PageDriverRestoreInfo, SetItemOperationEnable_TrueFalse_NoCrash) +{ + // Arrange + // Act + m_page->setItemOperationEnable(0, true); + m_page->setItemOperationEnable(0, false); + + // Assert + EXPECT_NE(nullptr, m_page->mp_ViewBackable); + EXPECT_NE(nullptr, m_page); +} + +TEST_F(UT_PageDriverRestoreInfo, SlotOperatorClicked_RestoreMode_NoCrash) +{ + // Arrange + DriverInfo *info = new DriverInfo(); + info->m_Name = "TestDriver"; + info->m_DebVersion = "1.0.0"; + info->m_DebBackupVersion = "0.9.0"; + info->m_Type = DR_Camera; + info->m_Packages = "test-pkg"; + info->m_Status = ST_DRIVER_CAN_RESTORE; + m_page->addDriverInfoToTableView(info, 0); + int rowsBefore = m_page->mp_ViewBackable->model()->rowCount(); + + // Act + m_page->slotOperatorClicked(0, 0, DriverOperationItem::RESTORE); + + // Assert + int rowsAfter = m_page->mp_ViewBackable->model()->rowCount(); + EXPECT_EQ(rowsBefore, rowsAfter); + EXPECT_NE(nullptr, m_page->mp_ViewBackable); + + delete info; +} + +TEST_F(UT_PageDriverRestoreInfo, AddDriverInfo_WithBackup_RowIncremented) +{ + // Arrange + DriverInfo *info = new DriverInfo(); + info->m_Name = "TestDriver"; + info->m_DebVersion = "1.0.0"; + info->m_DebBackupVersion = "0.9.0"; + info->m_Type = DR_Camera; + info->m_Packages = "test-pkg"; + info->m_Status = ST_DRIVER_CAN_RESTORE; + int before = m_page->mp_ViewBackable->model()->rowCount(); + + // Act + m_page->addDriverInfoToTableView(info, 0); + + // Assert + int after = m_page->mp_ViewBackable->model()->rowCount(); + EXPECT_EQ(before + 1, after); + EXPECT_GT(after, before); + + delete info; +} + +TEST_F(UT_PageDriverRestoreInfo, AddDriverInfo_NoBackup_RowUnchanged) +{ + // Arrange + DriverInfo *info = new DriverInfo(); + info->m_Name = "TestDriver"; + info->m_DebVersion = "1.0.0"; + info->m_DebBackupVersion = ""; + info->m_Type = DR_Camera; + info->m_Packages = "test-pkg"; + info->m_Status = ST_CAN_UPDATE; + int before = m_page->mp_ViewBackable->model()->rowCount(); + + // Act + m_page->addDriverInfoToTableView(info, 0); + + // Assert + int after = m_page->mp_ViewBackable->model()->rowCount(); + EXPECT_EQ(before, after); + EXPECT_NE(nullptr, m_page->mp_ViewBackable); + + delete info; +} diff --git a/deepin-devicemanager/tests/src/Widget/ut_driveritem.cpp b/deepin-devicemanager/tests/src/Widget/ut_driveritem.cpp new file mode 100644 index 000000000..c83c88b33 --- /dev/null +++ b/deepin-devicemanager/tests/src/Widget/ut_driveritem.cpp @@ -0,0 +1,489 @@ +// Copyright (C) 2026 Uniontech Software Technology Co.,Ltd +// SPDX-FileCopyrightText: 2026 UnionTech Software Technology Co., Ltd. +// +// SPDX-License-Identifier: GPL-3.0-or-later + +#include "ut_Head.h" +#include "stub.h" + +#include +#include +#include +#include + +#include +#include +#include +#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0) +#include +#endif + +#include + +#define private public +#define protected public +#include "driveritem.h" +#undef private +#undef protected + +// ===================== DriverCheckItem ===================== + +class UT_DriverCheckItem : public ::testing::Test +{ +public: + void SetUp() + { + m_item = new DriverCheckItem(nullptr, false); + m_headerItem = new DriverCheckItem(nullptr, true); + } + void TearDown() + { + delete m_item; + delete m_headerItem; + } + + DriverCheckItem *m_item = nullptr; + DriverCheckItem *m_headerItem = nullptr; +}; + +TEST_F(UT_DriverCheckItem, Constructor_Created_ReturnsValidPointer) +{ + // Arrange + // (items created in SetUp) + + // Act + bool itemValid = (m_item != nullptr); + bool headerValid = (m_headerItem != nullptr); + + // Assert + EXPECT_TRUE(itemValid); + EXPECT_TRUE(headerValid); +} + +TEST_F(UT_DriverCheckItem, SetChecked_True_CheckedReturnsTrue) +{ + // Arrange + // Act + m_item->setChecked(true, true); + + // Assert + EXPECT_TRUE(m_item->checked()); + EXPECT_EQ(true, m_item->checked()); +} + +TEST_F(UT_DriverCheckItem, SetChecked_False_CheckedReturnsFalse) +{ + // Arrange + // Act + m_item->setChecked(false, true); + + // Assert + EXPECT_FALSE(m_item->checked()); + EXPECT_EQ(false, m_item->checked()); +} + +TEST_F(UT_DriverCheckItem, SetChecked_NoDisconnect_CheckedStateCorrect) +{ + // Arrange + // Act + m_item->setChecked(true, false); + + // Assert + EXPECT_TRUE(m_item->checked()); + EXPECT_EQ(true, m_item->checked()); +} + +TEST_F(UT_DriverCheckItem, SetChecked_NoDisconnectFalse_CheckedReturnsFalse) +{ + // Arrange + // Act + m_item->setChecked(false, false); + + // Assert + EXPECT_FALSE(m_item->checked()); + EXPECT_EQ(false, m_item->checked()); +} + +TEST_F(UT_DriverCheckItem, Checked_AfterSetTrue_ReturnsTrue) +{ + // Arrange + m_item->setChecked(true, true); + + // Act + bool result = m_item->checked(); + + // Assert + EXPECT_TRUE(result); + EXPECT_EQ(true, result); +} + +TEST_F(UT_DriverCheckItem, IsEnabled_Default_ReturnsTrue) +{ + // Arrange + // Act + bool result = m_item->isEnabled(); + + // Assert + EXPECT_TRUE(result); + EXPECT_EQ(true, result); +} + +TEST_F(UT_DriverCheckItem, SetCbEnable_False_IsEnabledReturnsFalse) +{ + // Arrange + // Act + m_item->setCbEnable(false); + + // Assert + EXPECT_FALSE(m_item->isEnabled()); + EXPECT_EQ(false, m_item->isEnabled()); +} + +TEST_F(UT_DriverCheckItem, SetCbEnable_True_IsEnabledReturnsTrue) +{ + // Arrange + m_item->setCbEnable(false); + + // Act + m_item->setCbEnable(true); + + // Assert + EXPECT_TRUE(m_item->isEnabled()); + EXPECT_EQ(true, m_item->isEnabled()); +} + +TEST_F(UT_DriverCheckItem, PaintEvent_ValidRect_CompletesWithoutCrash) +{ + // Arrange + QPaintEvent event(QRect(m_item->rect())); + + // Act + m_item->paintEvent(&event); + + // Assert + EXPECT_EQ(m_item->rect().width(), m_item->rect().width()); + EXPECT_GT(m_item->rect().width(), -1); +} + +// ===================== DriverNameItem ===================== + +class UT_DriverNameItem : public ::testing::Test +{ +public: + void SetUp() + { + m_item = new DriverNameItem(nullptr, DR_Camera); + } + void TearDown() + { + delete m_item; + } + + DriverNameItem *m_item = nullptr; +}; + +TEST_F(UT_DriverNameItem, Constructor_Created_ReturnsValidPointer) +{ + // Arrange + // Act + bool result = (m_item != nullptr); + + // Assert + EXPECT_TRUE(result); + EXPECT_NE(nullptr, m_item); +} + +TEST_F(UT_DriverNameItem, SetName_ValidString_NameSetSuccessfully) +{ + // Arrange + QString testName = "TestDriver"; + + // Act + m_item->setName(testName); + + // Assert + EXPECT_NE(nullptr, m_item); + EXPECT_EQ(10, testName.size()); +} + +TEST_F(UT_DriverNameItem, SetIndex_Five_IndexReturnsFive) +{ + // Arrange + int expectedIndex = 5; + + // Act + m_item->setIndex(expectedIndex); + + // Assert + EXPECT_EQ(expectedIndex, m_item->index()); + EXPECT_EQ(5, m_item->index()); +} + +TEST_F(UT_DriverNameItem, Index_Default_ReturnsNegativeOne) +{ + // Arrange + // Act + int result = m_item->index(); + + // Assert + EXPECT_EQ(-1, result); + EXPECT_LT(result, 0); +} + +// ===================== DriverLabelItem ===================== + +class UT_DriverLabelItem : public ::testing::Test +{ +public: + void SetUp() + { + m_item = new DriverLabelItem(nullptr, "TestLabel"); + } + void TearDown() + { + delete m_item; + } + + DriverLabelItem *m_item = nullptr; +}; + +TEST_F(UT_DriverLabelItem, Constructor_WithText_ReturnsValidPointer) +{ + // Arrange + // Act + bool result = (m_item != nullptr); + + // Assert + EXPECT_TRUE(result); + EXPECT_NE(nullptr, m_item); +} + +TEST_F(UT_DriverLabelItem, Constructor_EmptyText_ReturnsValidPointer) +{ + // Arrange + // Act + DriverLabelItem item(nullptr, ""); + + // Assert + EXPECT_NE(nullptr, &item); + EXPECT_NE(nullptr, item.mp_Txt); +} + +// ===================== DriverStatusItem ===================== + +class UT_DriverStatusItem : public ::testing::Test +{ +public: + void SetUp() + { + m_item = new DriverStatusItem(nullptr, ST_CAN_UPDATE); + } + void TearDown() + { + delete m_item; + } + + DriverStatusItem *m_item = nullptr; +}; + +TEST_F(UT_DriverStatusItem, Constructor_CanUpdate_StatusReturnsCanUpdate) +{ + // Arrange + // Act + Status result = m_item->getStatus(); + + // Assert + EXPECT_EQ(ST_CAN_UPDATE, result); + EXPECT_NE(ST_NOT_INSTALL, result); +} + +TEST_F(UT_DriverStatusItem, SetStatus_NotInstall_StatusReturnsNotInstall) +{ + // Arrange + // Act + m_item->setStatus(ST_NOT_INSTALL); + + // Assert + EXPECT_EQ(ST_NOT_INSTALL, m_item->getStatus()); + EXPECT_NE(ST_CAN_UPDATE, m_item->getStatus()); +} + +TEST_F(UT_DriverStatusItem, SetStatus_Success_StatusReturnsSuccess) +{ + // Arrange + // Act + m_item->setStatus(ST_SUCESS); + + // Assert + EXPECT_EQ(ST_SUCESS, m_item->getStatus()); + EXPECT_NE(ST_CAN_UPDATE, m_item->getStatus()); +} + +TEST_F(UT_DriverStatusItem, SetStatus_Failed_StatusReturnsFailed) +{ + // Arrange + // Act + m_item->setStatus(ST_FAILED); + + // Assert + EXPECT_EQ(ST_FAILED, m_item->getStatus()); + EXPECT_NE(ST_CAN_UPDATE, m_item->getStatus()); +} + +TEST_F(UT_DriverStatusItem, SetStatus_BackupFailed_StatusReturnsBackupFailed) +{ + // Arrange + // Act + m_item->setStatus(ST_DRIVER_BACKUP_FAILED); + + // Assert + EXPECT_EQ(ST_DRIVER_BACKUP_FAILED, m_item->getStatus()); + EXPECT_NE(ST_CAN_UPDATE, m_item->getStatus()); +} + +TEST_F(UT_DriverStatusItem, SetStatus_Downloading_StatusReturnsDownloading) +{ + // Arrange + // Act + m_item->setStatus(ST_DOWNLOADING); + + // Assert + EXPECT_EQ(ST_DOWNLOADING, m_item->getStatus()); + EXPECT_NE(ST_CAN_UPDATE, m_item->getStatus()); +} + +TEST_F(UT_DriverStatusItem, SetStatus_Restoring_StatusReturnsRestoring) +{ + // Arrange + // Act + m_item->setStatus(ST_DRIVER_RESTORING); + + // Assert + EXPECT_EQ(ST_DRIVER_RESTORING, m_item->getStatus()); + EXPECT_NE(ST_CAN_UPDATE, m_item->getStatus()); +} + +TEST_F(UT_DriverStatusItem, SetErrorMsg_ValidString_NoCrash) +{ + // Arrange + QString msg = "Some error"; + + // Act + m_item->setErrorMsg(msg); + + // Assert + EXPECT_NE(nullptr, m_item); + EXPECT_EQ(10, msg.size()); +} + +// ===================== DriverOperationItem ===================== + +class UT_DriverOperationItem : public ::testing::Test +{ +public: + void SetUp() + { + m_installItem = new DriverOperationItem(nullptr, DriverOperationItem::INSTALL); + m_updateItem = new DriverOperationItem(nullptr, DriverOperationItem::UPDATE); + m_backupItem = new DriverOperationItem(nullptr, DriverOperationItem::BACKUP); + m_restoreItem = new DriverOperationItem(nullptr, DriverOperationItem::RESTORE); + } + void TearDown() + { + delete m_installItem; + delete m_updateItem; + delete m_backupItem; + delete m_restoreItem; + } + + DriverOperationItem *m_installItem = nullptr; + DriverOperationItem *m_updateItem = nullptr; + DriverOperationItem *m_backupItem = nullptr; + DriverOperationItem *m_restoreItem = nullptr; +}; + +TEST_F(UT_DriverOperationItem, Constructor_AllModes_ModeReturnsCorrectValue) +{ + // Arrange + // Act + auto installMode = m_installItem->mode(); + auto updateMode = m_updateItem->mode(); + + // Assert + EXPECT_EQ(DriverOperationItem::INSTALL, installMode); + EXPECT_EQ(DriverOperationItem::UPDATE, updateMode); + EXPECT_EQ(DriverOperationItem::BACKUP, m_backupItem->mode()); + EXPECT_EQ(DriverOperationItem::RESTORE, m_restoreItem->mode()); +} + +TEST_F(UT_DriverOperationItem, SetBtnEnable_False_BtnDisabled) +{ + // Arrange + // Act + m_installItem->setBtnEnable(false); + + // Assert + EXPECT_FALSE(m_installItem->mp_Btn->isEnabled()); + EXPECT_EQ(false, m_installItem->mp_Btn->isEnabled()); +} + +TEST_F(UT_DriverOperationItem, SetBtnEnable_True_BtnEnabled) +{ + // Arrange + m_installItem->setBtnEnable(false); + + // Act + m_installItem->setBtnEnable(true); + + // Assert + EXPECT_TRUE(m_installItem->mp_Btn->isEnabled()); + EXPECT_EQ(true, m_installItem->mp_Btn->isEnabled()); +} + +TEST_F(UT_DriverOperationItem, SetBtnIcon_AllModes_NoCrash) +{ + // Arrange + // Act + m_installItem->setBtnIcon(); + m_updateItem->setBtnIcon(); + m_backupItem->setBtnIcon(); + m_restoreItem->setBtnIcon(); + + // Assert + EXPECT_NE(nullptr, m_installItem); + EXPECT_NE(nullptr, m_restoreItem); +} + +TEST_F(UT_DriverOperationItem, EnterEvent_Qt6_NoCrash) +{ + // Arrange +#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0) + QEnterEvent event(QPointF(0, 0), QPointF(0, 0), QPointF(0, 0)); +#else + QEvent event(QEvent::Enter); +#endif + + // Act +#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0) + m_installItem->enterEvent(&event); +#else + m_installItem->enterEvent(&event); +#endif + + // Assert + EXPECT_NE(nullptr, m_installItem); + EXPECT_EQ(DriverOperationItem::INSTALL, m_installItem->mode()); +} + +TEST_F(UT_DriverOperationItem, LeaveEvent_Standard_NoCrash) +{ + // Arrange + QEvent event(QEvent::Leave); + + // Act + m_installItem->leaveEvent(&event); + + // Assert + EXPECT_NE(nullptr, m_installItem); + EXPECT_EQ(DriverOperationItem::INSTALL, m_installItem->mode()); +}