test(coop): add cooperation core module coverage tests

tests/coop/CMakeLists.txt

@@ -69,7 +69,15 @@ add_executable(coop_tests ${COOP_SRC}
     ${CMAKE_SOURCE_DIR}/tests/session_core/protoendpoint_test.cpp
     ${CMAKE_SOURCE_DIR}/tests/session_core/protoclient_server_test.cpp
     ${CMAKE_SOURCE_DIR}/tests/session_core/cooperationcore_test.cpp
-    ${CMAKE_SOURCE_DIR}/tests/session_core/discover_extra_test.cpp)
+    ${CMAKE_SOURCE_DIR}/tests/session_core/discover_extra_test.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/settings_test.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/configmanager_test.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/commonutils_test.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/filesystem_test.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/cooperation_extra_test.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/phone_smoke_test.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/discover_safe_test.cpp
+    ${CMAKE_SOURCE_DIR}/tests/session_core/session_integration_test.cpp)
 target_compile_options(coop_tests PRIVATE -fno-access-control -fprofile-arcs -ftest-coverage)
 target_compile_definitions(coop_tests PRIVATE EXECUTABLE_PROG_DIR="${CMAKE_BINARY_DIR}" ENABLE_PHONE=1)
 target_include_directories(coop_tests PRIVATE
@@ -91,5 +99,5 @@ endif()
 if(VNCCLIENT_LIBRARY)
     target_link_libraries(coop_tests PRIVATE ${VNCCLIENT_LIBRARY})
 endif()
-target_link_options(coop_tests PRIVATE -fprofile-arcs -ftest-coverage)
+target_link_options(coop_tests PRIVATE -fprofile-arcs -ftest-coverage -Wl,--allow-multiple-definition)
 add_test(NAME coop_tests COMMAND coop_tests)

tests/coop/commonutils_test.cpp

@@ -0,0 +1,116 @@
+// SPDX-FileCopyrightText: 2026 UnionTech Software Technology Co., Ltd.
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include <gtest/gtest.h>
+
+#include "common/commonutils.h"
+
+#include <QCoreApplication>
+#include <QStandardPaths>
+#include <QFile>
+#include <QString>
+
+using deepin_cross::CommonUitls;
+
+TEST(CommonUitlsTest, GenerateRandomPasswordIsSixDigits)
+{
+    QString pwd = CommonUitls::generateRandomPassword();
+    EXPECT_EQ(pwd.length(), 6);
+    for (const QChar &c : pwd) {
+        EXPECT_TRUE(c.isDigit());
+    }
+}
+
+TEST(CommonUitlsTest, GenerateRandomPasswordProducesVariedOutput)
+{
+    QString a = CommonUitls::generateRandomPassword();
+    QString b = CommonUitls::generateRandomPassword();
+    EXPECT_EQ(a.length(), 6);
+    EXPECT_EQ(b.length(), 6);
+}
+
+TEST(CommonUitlsTest, ElidedTextShortReturnsUnchanged)
+{
+    EXPECT_EQ(CommonUitls::elidedText("hi", Qt::ElideRight, 5).toStdString(), "hi");
+    EXPECT_EQ(CommonUitls::elidedText("hi", Qt::ElideLeft, 5).toStdString(), "hi");
+    EXPECT_EQ(CommonUitls::elidedText("hi", Qt::ElideMiddle, 5).toStdString(), "hi");
+    EXPECT_EQ(CommonUitls::elidedText("hi", Qt::ElideNone, 5).toStdString(), "hi");
+}
+
+TEST(CommonUitlsTest, ElidedTextElideRight)
+{
+    QString out = CommonUitls::elidedText("abcdefghij", Qt::ElideRight, 5);
+    EXPECT_EQ(out.length(), 8);
+    EXPECT_TRUE(out.endsWith("..."));
+    EXPECT_EQ(out.left(5).toStdString(), "abcde");
+}
+
+TEST(CommonUitlsTest, ElidedTextElideLeft)
+{
+    QString out = CommonUitls::elidedText("abcdefghij", Qt::ElideLeft, 5);
+    EXPECT_EQ(out.length(), 8);
+    EXPECT_TRUE(out.startsWith("..."));
+    EXPECT_EQ(out.right(5).toStdString(), "fghij");
+}
+
+TEST(CommonUitlsTest, ElidedTextElideMiddle)
+{
+    QString out = CommonUitls::elidedText("abcdefghij", Qt::ElideMiddle, 5);
+    EXPECT_EQ(out.length(), 5);
+    EXPECT_TRUE(out.contains("..."));
+}
+
+TEST(CommonUitlsTest, ElidedTextElideNoneReturnsOriginal)
+{
+    QString out = CommonUitls::elidedText("abcdefghij", Qt::ElideNone, 5);
+    EXPECT_EQ(out.toStdString(), "abcdefghij");
+}
+
+TEST(CommonUitlsTest, IsPortInUsePrivilegedPortOne)
+{
+    EXPECT_FALSE(CommonUitls::isPortInUse(1));
+}
+
+TEST(CommonUitlsTest, GetAvailablePortInRange)
+{
+    int port = CommonUitls::getAvailablePort();
+    EXPECT_GE(port, 13628);
+    EXPECT_LT(port, 23628);
+}
+
+TEST(CommonUitlsTest, IpcServerNameContainsAppName)
+{
+    QString name = CommonUitls::ipcServerName("myapp");
+    EXPECT_FALSE(name.isEmpty());
+    EXPECT_TRUE(name.contains("myapp"));
+    EXPECT_TRUE(name.contains(".ipc"));
+}
+
+TEST(CommonUitlsTest, TipConfPathEndsWithFlag)
+{
+    QString path = CommonUitls::tipConfPath();
+    EXPECT_FALSE(path.isEmpty());
+    EXPECT_TRUE(path.endsWith("tip.flag"));
+}
+
+TEST(CommonUitlsTest, IsFirstStartFlagTransitions)
+{
+    QString flagPath = QString("%1/%2/%3/first_run.flag")
+                               .arg(QStandardPaths::writableLocation(QStandardPaths::GenericCacheLocation))
+                               .arg(qApp->organizationName())
+                               .arg(qApp->applicationName());
+    QFile::remove(flagPath);
+
+    EXPECT_TRUE(CommonUitls::isFirstStart());
+    EXPECT_FALSE(CommonUitls::isFirstStart());
+}
+
+TEST(CommonUitlsTest, GetFirstIpDoesNotCrash)
+{
+    std::string ip = CommonUitls::getFirstIp();
+    EXPECT_NO_FATAL_FAILURE(CommonUitls::getFirstIp());
+    if (!ip.empty()) {
+        EXPECT_GT(ip.length(), static_cast<size_t>(0));
+    }
+}

tests/coop/configmanager_test.cpp

@@ -0,0 +1,47 @@
+// SPDX-FileCopyrightText: 2026 UnionTech Software Technology Co., Ltd.
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include <gtest/gtest.h>
+
+#include "configs/settings/configmanager.h"
+#include "configs/settings/settings.h"
+
+#include <QVariant>
+
+TEST(CoopConfigManagerTest, InstanceIsSingleton)
+{
+    EXPECT_EQ(ConfigManager::instance(), ConfigManager::instance());
+}
+
+TEST(CoopConfigManagerTest, AppSettingReturnsValidSettings)
+{
+    Settings *s = ConfigManager::instance()->appSetting();
+    ASSERT_NE(s, nullptr);
+    EXPECT_NE(s, nullptr);
+}
+
+TEST(CoopConfigManagerTest, SetAndReadAppAttributeRoundTrip)
+{
+    ConfigManager::instance()->setAppAttribute("CoopUnitTestGroup", "someKey", 12345);
+    QVariant v = ConfigManager::instance()->appAttribute("CoopUnitTestGroup", "someKey");
+    EXPECT_EQ(v.toInt(), 12345);
+}
+
+TEST(CoopConfigManagerTest, AppAttributeUnknownReturnsInvalid)
+{
+    QVariant v = ConfigManager::instance()->appAttribute("NoSuchCoopGroup", "NoSuchKey");
+    EXPECT_FALSE(v.isValid());
+}
+
+TEST(CoopConfigManagerTest, AppAttributeStringRoundTrip)
+{
+    ConfigManager::instance()->setAppAttribute("CoopStrGroup", "name", QVariant("hello"));
+    QVariant v = ConfigManager::instance()->appAttribute("CoopStrGroup", "name");
+    EXPECT_EQ(v.toString().toStdString(), "hello");
+}
+
+TEST(CoopConfigManagerTest, SyncAppAttributeReturnsBool)
+{
+    EXPECT_NO_FATAL_FAILURE(ConfigManager::instance()->syncAppAttribute());
+}

tests/coop/cooperation_extra_test.cpp

@@ -0,0 +1,140 @@
+// SPDX-FileCopyrightText: 2026 UnionTech Software Technology Co., Ltd.
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include <gtest/gtest.h>
+
+#include <QString>
+#include <QVariantMap>
+
+#include "lib/cooperation/core/utils/cooperationutil.h"
+#include "lib/cooperation/core/discover/deviceinfo.h"
+#include "lib/cooperation/core/net/helper/sharehelper.h"
+#include "lib/cooperation/core/net/helper/transferhelper.h"
+#include "base/baseutils.h"
+
+using cooperation_core::CooperationUtil;
+using cooperation_core::DeviceInfo;
+using cooperation_core::ShareHelper;
+using cooperation_core::TransferHelper;
+using ::DeviceInfoPointer;
+using deepin_cross::BaseUtils;
+
+TEST(CooperationExtraTest, MainWindowWidgetNullWithoutRegisteredWindow)
+{
+    EXPECT_EQ(CooperationUtil::instance()->mainWindowWidget(), nullptr);
+}
+
+TEST(CooperationExtraTest, ActivateWindowNoCrashWithoutWindow)
+{
+    EXPECT_NO_FATAL_FAILURE(CooperationUtil::instance()->activateWindow());
+}
+
+TEST(CooperationExtraTest, RegisterDeviceOperationNoCrashWithoutWindow)
+{
+    QVariantMap map;
+    map.insert("id", QString("test-op"));
+    map.insert("description", QString("desc"));
+    EXPECT_NO_FATAL_FAILURE(CooperationUtil::instance()->registerDeviceOperation(map));
+}
+
+TEST(CooperationExtraTest, DeviceInfoReturnsExpectedKeys)
+{
+    QVariantMap info = CooperationUtil::deviceInfo();
+    EXPECT_FALSE(info.isEmpty());
+    EXPECT_TRUE(info.contains(AppSettings::IPAddress));
+    EXPECT_TRUE(info.contains(AppSettings::OSType));
+    EXPECT_TRUE(info.contains(AppSettings::DeviceNameKey));
+    EXPECT_TRUE(info.contains(AppSettings::DiscoveryModeKey));
+    EXPECT_TRUE(info.contains(AppSettings::TransferModeKey));
+    EXPECT_TRUE(info.contains(AppSettings::StoragePathKey));
+    EXPECT_TRUE(info.contains(AppSettings::LinkDirectionKey));
+}
+
+TEST(CooperationExtraTest, DeviceInfoDefaultOsTypeIsOther)
+{
+    DeviceInfoPointer info(new DeviceInfo);
+    EXPECT_EQ(info->osType(), BaseUtils::OS_TYPE::kOther);
+}
+
+TEST(CooperationExtraTest, DeviceInfoOsTypeRoundTripAllValues)
+{
+    DeviceInfoPointer info(new DeviceInfo("1.1.1.1", "host"));
+
+    info->setOsType(BaseUtils::OS_TYPE::kLinux);
+    EXPECT_EQ(info->osType(), BaseUtils::OS_TYPE::kLinux);
+
+    info->setOsType(BaseUtils::OS_TYPE::kWindows);
+    EXPECT_EQ(info->osType(), BaseUtils::OS_TYPE::kWindows);
+
+    info->setOsType(BaseUtils::OS_TYPE::kMacOS);
+    EXPECT_EQ(info->osType(), BaseUtils::OS_TYPE::kMacOS);
+
+    info->setOsType(BaseUtils::OS_TYPE::kOther);
+    EXPECT_EQ(info->osType(), BaseUtils::OS_TYPE::kOther);
+}
+
+TEST(CooperationExtraTest, DeviceInfoOsTypePersistsViaVariantMap)
+{
+    DeviceInfoPointer original(new DeviceInfo("2.2.2.2", "host2"));
+    original->setOsType(BaseUtils::OS_TYPE::kWindows);
+
+    QVariantMap map = original->toVariantMap();
+    EXPECT_EQ(map.value(AppSettings::OSType).toInt(), static_cast<int>(BaseUtils::OS_TYPE::kWindows));
+
+    DeviceInfoPointer restored = DeviceInfo::fromVariantMap(map);
+    ASSERT_NE(restored, nullptr);
+    EXPECT_EQ(restored->osType(), BaseUtils::OS_TYPE::kWindows);
+}
+
+TEST(CooperationExtraTest, DeviceInfoDeviceTypeDirectSetterRoundTrip)
+{
+    DeviceInfoPointer pc(new DeviceInfo("3.3.3.3", "pc"));
+    pc->setDeviceType(DeviceInfo::DeviceType::PC);
+    EXPECT_EQ(pc->deviceType(), DeviceInfo::DeviceType::PC);
+
+    DeviceInfoPointer mob(new DeviceInfo("4.4.4.4", "phone"));
+    mob->setDeviceType(DeviceInfo::DeviceType::Mobile);
+    EXPECT_EQ(mob->deviceType(), DeviceInfo::DeviceType::Mobile);
+}
+
+TEST(CooperationExtraTest, ShareHelperInstanceNonNull)
+{
+    EXPECT_NE(ShareHelper::instance(), nullptr);
+}
+
+TEST(CooperationExtraTest, ShareHelperInstanceSamePointer)
+{
+    auto *a = ShareHelper::instance();
+    auto *b = ShareHelper::instance();
+    EXPECT_EQ(a, b);
+}
+
+TEST(CooperationExtraTest, ShareHelperRegistConnectBtnNoCrash)
+{
+    EXPECT_NO_FATAL_FAILURE(ShareHelper::instance()->registConnectBtn());
+}
+
+TEST(CooperationExtraTest, TransferHelperInstanceNonNull)
+{
+    EXPECT_NE(TransferHelper::instance(), nullptr);
+}
+
+TEST(CooperationExtraTest, TransferHelperInstanceSamePointer)
+{
+    auto *a = TransferHelper::instance();
+    auto *b = TransferHelper::instance();
+    EXPECT_EQ(a, b);
+}
+
+TEST(CooperationExtraTest, TransferHelperRegistBtnNoCrash)
+{
+    EXPECT_NO_FATAL_FAILURE(TransferHelper::instance()->registBtn());
+}
+
+TEST(CooperationExtraTest, TransferHelperStatusEnumValues)
+{
+    EXPECT_NE(TransferHelper::Idle, TransferHelper::Confirming);
+    EXPECT_NE(TransferHelper::Connecting, TransferHelper::Transfering);
+    EXPECT_EQ(TransferHelper::instance()->transferStatus(), TransferHelper::Idle);
+}