test: unify test gate to BUILD_TESTING and add coverage target

1. Rename the test gate option from BUILD_TEST to BUILD_TESTING
2. Enable coverage instrumentation for test targets by default
3. Add coverage target that runs ctest and generates the lcov report

Log: Unify the test gate to BUILD_TESTING and add a coverage target

test: 统一测试门控为 BUILD_TESTING 并新增 coverage 目标

1. 将测试门控选项由 BUILD_TEST 重命名为 BUILD_TESTING
2. 默认开启测试目标的覆盖率插桩
3. 新增 coverage 目标，执行 ctest 并生成 lcov 报告

Log: 统一测试门控为 BUILD_TESTING，并新增 coverage 目标

Author: MyLeeJiEun

CMakeLists.txt

@@ -6,7 +6,7 @@ cmake_minimum_required(VERSION 3.10)
 
 project(dde-launchpad VERSION 0.7.0)
 
-option(BUILD_TEST "Whether or not to build the tests" OFF)
+option(BUILD_TESTING "Whether or not to build the tests" OFF)
 option(CMAKE_EXPORT_COMPILE_COMMANDS "clangd support" ON)
 
 set(CMAKE_CXX_STANDARD 17) # blurhash requires 17, otherwish we can still use 14
@@ -65,7 +65,7 @@ add_subdirectory(src/treelandintegration)
 add_subdirectory(src/models)
 add_subdirectory(qml/windowed)
 
-if(BUILD_TEST)
+if(BUILD_TESTING)
     enable_testing()
     add_subdirectory(tests)
 endif()

tests/CMakeLists.txt

@@ -8,6 +8,15 @@ find_package(Qt6Core CONFIG REQUIRED Private)      # sortproxymodel.cpp uses QAb
 
 qt_standard_project_setup()
 
+# Coverage instrumentation (on by default so `coverage` produces a report).
+# Only the test-directory targets (OBJECT libs + test executables) are affected;
+# the production `launchpadcommon` shared library is left untouched.
+option(ENABLE_COVERAGE "Enable coverage instrumentation for tests" ON)
+if(ENABLE_COVERAGE)
+    add_compile_options(--coverage)
+    add_link_options(--coverage)
+endif()
+
 # ---------------------------------------------------------------------------
 # Tested-source OBJECT libraries
 #
@@ -72,6 +81,14 @@ target_link_libraries(launchpad-test-utils PUBLIC
 macro(launchpad_add_tests)
     foreach(_testname ${ARGN})
         qt_add_executable(launchpad-${_testname} ${_testname}.cpp)
+        # Test sources include the headers under test by bare name (e.g.
+        # `#include "categoryutils.h"`), matching how src/ includes its own
+        # headers — no `../src/...` relative paths.
+        target_include_directories(launchpad-${_testname} PRIVATE
+            ${CMAKE_SOURCE_DIR}/src/models
+            ${CMAKE_SOURCE_DIR}/src/utils
+            ${CMAKE_SOURCE_DIR}/src/gioutils
+        )
         # OBJECT libs first: their symbols take precedence over launchpadcommon.so,
         # so the gcov-instrumented copies are the ones that execute at test time.
         target_link_libraries(launchpad-${_testname} PRIVATE
@@ -83,6 +100,7 @@ macro(launchpad_add_tests)
             launchpadcommon
         )
         add_test(NAME launchpad-${_testname} COMMAND launchpad-${_testname})
+        list(APPEND LAUNCHPAD_TEST_TARGETS launchpad-${_testname})
     endforeach()
 endmacro()
 
@@ -103,3 +121,31 @@ launchpad_add_tests(
     iconutilstest
     itemspagemodeltest
 )
+
+# ---- coverage: execute all tests and generate a coverage report ----
+# Produces: ${CMAKE_BINARY_DIR}/coverage_report/index.html
+find_program(LCOV_BIN lcov)
+find_program(GENHTML_BIN genhtml)
+set(_run_test_coverage "")
+if(LCOV_BIN AND GENHTML_BIN)
+    set(_run_test_coverage
+        COMMAND ${LCOV_BIN} --capture --directory ${CMAKE_BINARY_DIR}
+                --rc lcov_branch_coverage=1 --output-file ${CMAKE_BINARY_DIR}/coverage.info
+        COMMAND ${LCOV_BIN} --extract ${CMAKE_BINARY_DIR}/coverage.info
+                --rc lcov_branch_coverage=1
+                "${CMAKE_SOURCE_DIR}/src/models/*"
+                "${CMAKE_SOURCE_DIR}/src/utils/*"
+                "${CMAKE_SOURCE_DIR}/src/gioutils/*"
+                --output-file ${CMAKE_BINARY_DIR}/coverage_filtered.info
+        COMMAND ${GENHTML_BIN} ${CMAKE_BINARY_DIR}/coverage_filtered.info
+                --branch-coverage --output-directory ${CMAKE_BINARY_DIR}/coverage_report
+    )
+endif()
+add_custom_target(coverage
+    COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure
+    ${_run_test_coverage}
+    DEPENDS ${LAUNCHPAD_TEST_TARGETS}
+    WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+    COMMENT "Run all tests and generate coverage report"
+    VERBATIM
+)

tests/blurhashtest.cpp

@@ -3,14 +3,12 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 #include <QTest>
-#include <QLoggingCategory>
 
-#include "../src/utils/blurhash.hpp"
+#include "blurhash.hpp"
 
 #include <vector>
 
 namespace {
-Q_LOGGING_CATEGORY(logTest, "dde.launchpad.test")
 
 std::vector<unsigned char> solidImage(size_t width, size_t height,
                                       unsigned char r, unsigned char g, unsigned char b)
@@ -48,7 +46,6 @@ private slots:
 
 void TestBlurhash::decodeEmptyStringReturnsEmpty()
 {
-    qCInfo(logTest) << "Decoding an empty hash should return an empty image";
     const auto img = blurhash::decode(std::string_view{}, 8, 8);
     QVERIFY(img.image.empty());
     QCOMPARE(img.width, size_t(0));
@@ -57,14 +54,12 @@ void TestBlurhash::decodeEmptyStringReturnsEmpty()
 
 void TestBlurhash::decodeInvalidHashReturnsEmpty()
 {
-    qCInfo(logTest) << "Decoding a hash with invalid characters should return an empty image";
     const auto img = blurhash::decode(std::string_view("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"), 8, 8);
     QVERIFY(img.image.empty());
 }
 
 void TestBlurhash::encodeRejectsInvalidInput()
 {
-    qCInfo(logTest) << "encode should return an empty string for invalid parameters";
     std::vector<unsigned char> image = solidImage(4, 4, 255, 0, 0);
     QVERIFY(blurhash::encode(image.data(), 0, 4, 1, 1).empty());   // width 0
     QVERIFY(blurhash::encode(nullptr, 4, 4, 1, 1).empty());        // null image
@@ -74,7 +69,6 @@ void TestBlurhash::encodeRejectsInvalidInput()
 
 void TestBlurhash::encodedHashHasExpectedLength()
 {
-    qCInfo(logTest) << "encode should produce a hash of the documented length";
     std::vector<unsigned char> image = solidImage(8, 8, 128, 64, 200);
     QCOMPARE(blurhash::encode(image.data(), 8, 8, 1, 1).size(), size_t(6));                // no AC components
     QCOMPARE(blurhash::encode(image.data(), 8, 8, 1, 3).size(), expectedHashLength(1, 3)); // 10
@@ -84,7 +78,6 @@ void TestBlurhash::encodedHashHasExpectedLength()
 
 void TestBlurhash::decodedImageHasExpectedDimensions()
 {
-    qCInfo(logTest) << "decode should produce an image matching the requested dimensions";
     constexpr size_t width = 16, height = 16;
     std::vector<unsigned char> image = solidImage(width, height, 128, 64, 200);
     const std::string hash = blurhash::encode(image.data(), width, height, 2, 2);
@@ -98,7 +91,6 @@ void TestBlurhash::decodedImageHasExpectedDimensions()
 
 void TestBlurhash::roundTripPreservesAverageColor()
 {
-    qCInfo(logTest) << "Round-trip should preserve the average color (DC component)";
     constexpr size_t width = 16, height = 16;
     const unsigned char r = 128, g = 64, b = 200;
     std::vector<unsigned char> image = solidImage(width, height, r, g, b);
@@ -125,7 +117,6 @@ void TestBlurhash::roundTripPreservesAverageColor()
 
 void TestBlurhash::decodeWithFourBytesPerPixel()
 {
-    qCInfo(logTest) << "decode with bytesPerPixel=4 should produce a larger buffer";
     constexpr size_t width = 16, height = 16;
     std::vector<unsigned char> image = solidImage(width, height, 128, 64, 200);
     const std::string hash = blurhash::encode(image.data(), width, height, 3, 3);
@@ -142,15 +133,13 @@ void TestBlurhash::decodeWithFourBytesPerPixel()
 
 void TestBlurhash::decodeTooShortHashReturnsEmpty()
 {
-    qCInfo(logTest) << "decode with a hash shorter than 10 chars should return empty";
     // hash must be >= 10 chars (1 + 1 + 4 + at least 4 for 2x2 components - 1 AC = 2 bytes -> 8, but 10 is the minimum check)
     const auto img = blurhash::decode(std::string_view("short"), 8, 8);
     QVERIFY(img.image.empty());
 }
 
 void TestBlurhash::decodeWrongSizeForComponentsReturnsEmpty()
 {
-    qCInfo(logTest) << "decode with a hash whose length doesn't match the component count should return empty";
     // 1 component char says 4x4 = 16 components -> needs 1+1+4+(16-1)*2 = 36 chars
     // but we'll give only 12 chars
     const auto img = blurhash::decode(std::string_view("LFE.}?a]a]a]a]a]a]a]"), 8, 8);

tests/categoryutilstest.cpp

@@ -3,12 +3,10 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 #include <QTest>
-#include <QLoggingCategory>
 
-#include "../src/utils/categoryutils.h"
+#include "categoryutils.h"
 
 namespace {
-Q_LOGGING_CATEGORY(logTest, "dde.launchpad.test")
 
 using C = CategoryUtils::Categorytype;
 }
@@ -47,7 +45,6 @@ private slots:
 
 void TestCategoryUtils::parseDDECategoryStringKnown()
 {
-    qCInfo(logTest) << "parseDDECategoryString should map the known DDE category names";
     QCOMPARE(int(CategoryUtils::parseDDECategoryString(QStringLiteral("music"))), int(C::CategoryMusic));
     QCOMPARE(int(CategoryUtils::parseDDECategoryString(QStringLiteral("internet"))), int(C::CategoryInternet));
     QCOMPARE(int(CategoryUtils::parseDDECategoryString(QStringLiteral("development"))), int(C::CategoryDevelopment));
@@ -56,22 +53,19 @@ void TestCategoryUtils::parseDDECategoryStringKnown()
 
 void TestCategoryUtils::parseDDECategoryStringUnknown()
 {
-    qCInfo(logTest) << "Unknown DDE category strings should yield CategoryErr";
     QCOMPARE(int(CategoryUtils::parseDDECategoryString(QStringLiteral("unknown"))), int(C::CategoryErr));
     QCOMPARE(int(CategoryUtils::parseDDECategoryString(QStringLiteral("Music"))), int(C::CategoryErr)); // case sensitive
 }
 
 void TestCategoryUtils::parseXdgCategoryStringSingle()
 {
-    qCInfo(logTest) << "parseXdgCategoryString should map single-valued XDG categories";
     const auto result = CategoryUtils::parseXdgCategoryString(QStringLiteral("webbrowser"));
     QCOMPARE(result.size(), 1);
     QVERIFY(result.contains(C::CategoryInternet));
 }
 
 void TestCategoryUtils::parseXdgCategoryStringMultiValued()
 {
-    qCInfo(logTest) << "audiovideo should map to both music and video";
     const auto result = CategoryUtils::parseXdgCategoryString(QStringLiteral("audiovideo"));
     QCOMPARE(result.size(), 2);
     QVERIFY(result.contains(C::CategoryMusic));
@@ -80,61 +74,52 @@ void TestCategoryUtils::parseXdgCategoryStringMultiValued()
 
 void TestCategoryUtils::parseXdgCategoryStringUnknown()
 {
-    qCInfo(logTest) << "Unknown XDG category strings should yield an empty list";
     const auto result = CategoryUtils::parseXdgCategoryString(QStringLiteral("totally-unknown-category"));
     QVERIFY(result.isEmpty());
 }
 
 void TestCategoryUtils::bestMatchedSingleCategory()
 {
-    qCInfo(logTest) << "A single matching category should win";
     QCOMPARE(int(CategoryUtils::parseBestMatchedCategory({QStringLiteral("music")})), int(C::CategoryMusic));
     QCOMPARE(int(CategoryUtils::parseBestMatchedCategory({QStringLiteral("network")})), int(C::CategoryInternet));
     QCOMPARE(int(CategoryUtils::parseBestMatchedCategory({QStringLiteral("spreadsheet")})), int(C::CategoryOffice));
 }
 
 void TestCategoryUtils::bestMatchedEmptyReturnsOthers()
 {
-    qCInfo(logTest) << "An empty category list should be classified as others";
     QCOMPARE(int(CategoryUtils::parseBestMatchedCategory({})), int(C::CategoryOthers));
 }
 
 void TestCategoryUtils::bestMatchedOthersOnlyReturnsOthers()
 {
-    qCInfo(logTest) << "An only-others list should be classified as others";
     QCOMPARE(int(CategoryUtils::parseBestMatchedCategory({QStringLiteral("others")})), int(C::CategoryOthers));
 }
 
 void TestCategoryUtils::bestMatchedMusicVideoTiePrefersVideo()
 {
-    qCInfo(logTest) << "A music/video tie should prefer video";
     QCOMPARE(int(CategoryUtils::parseBestMatchedCategory({QStringLiteral("music"), QStringLiteral("video")})),
               int(C::CategoryVideo));
 }
 
 void TestCategoryUtils::bestMatchedPlayerMapsToVideo()
 {
-    qCInfo(logTest) << "player (maps to music+video) should resolve to video";
     QCOMPARE(int(CategoryUtils::parseBestMatchedCategory({QStringLiteral("player")})), int(C::CategoryVideo));
 }
 
 void TestCategoryUtils::bestMatchedMaxCountWins()
 {
-    qCInfo(logTest) << "The category with the highest count should win";
     QCOMPARE(int(CategoryUtils::parseBestMatchedCategory({QStringLiteral("game"), QStringLiteral("game"), QStringLiteral("music")})),
               int(C::CategoryGame));
 }
 
 void TestCategoryUtils::bestMatchedMultipleInternet()
 {
-    qCInfo(logTest) << "Several internet categories should aggregate into internet";
     QCOMPARE(int(CategoryUtils::parseBestMatchedCategory({QStringLiteral("webbrowser"), QStringLiteral("email")})),
               int(C::CategoryInternet));
 }
 
 void TestCategoryUtils::parseDDECategoryStringAllKnown()
 {
-    qCInfo(logTest) << "parseDDECategoryString should map all known DDE category names";
     QCOMPARE(int(CategoryUtils::parseDDECategoryString(QStringLiteral("chat"))), int(C::CategoryChat));
     QCOMPARE(int(CategoryUtils::parseDDECategoryString(QStringLiteral("video"))), int(C::CategoryVideo));
     QCOMPARE(int(CategoryUtils::parseDDECategoryString(QStringLiteral("graphics"))), int(C::CategoryGraphics));
@@ -146,7 +131,6 @@ void TestCategoryUtils::parseDDECategoryStringAllKnown()
 
 void TestCategoryUtils::parseXdgCategoryStringMultipleDistinctCategories()
 {
-    qCInfo(logTest) << "parseXdgCategoryString for several distinct known categories";
     // Each call returns the list for that single string; verify a batch of them
     QCOMPARE(CategoryUtils::parseXdgCategoryString(QStringLiteral("ide")).size(), 1);
     QVERIFY(CategoryUtils::parseXdgCategoryString(QStringLiteral("ide")).contains(C::CategoryDevelopment));
@@ -164,15 +148,13 @@ void TestCategoryUtils::parseXdgCategoryStringMultipleDistinctCategories()
 
 void TestCategoryUtils::parseXdgCategoryStringAudioMapsToMusic()
 {
-    qCInfo(logTest) << "audio should map to music";
     const auto result = CategoryUtils::parseXdgCategoryString(QStringLiteral("audio"));
     QCOMPARE(result.size(), 1);
     QVERIFY(result.contains(C::CategoryMusic));
 }
 
 void TestCategoryUtils::bestMatchedDDECategoryWinsOverXdg()
 {
-    qCInfo(logTest) << "A DDE category name should be matched before falling to XDG parsing";
     // 'music' is a DDE name -> CategoryMusic (via parseDDECategoryString)
     // 'audio' is an XDG name -> CategoryMusic (via parseXdgCategoryString)
     // mixing them should still yield Music
@@ -182,7 +164,6 @@ void TestCategoryUtils::bestMatchedDDECategoryWinsOverXdg()
 
 void TestCategoryUtils::bestMatchedGameVariants()
 {
-    qCInfo(logTest) << "Various game XDG categories should aggregate into game";
     QCOMPARE(int(CategoryUtils::parseBestMatchedCategory({QStringLiteral("actiongame"), QStringLiteral("arcadegame")})),
               int(C::CategoryGame));
     QCOMPARE(int(CategoryUtils::parseBestMatchedCategory({QStringLiteral("boardgame"), QStringLiteral("cardgame"), QStringLiteral("puzzlegame")})),
@@ -191,7 +172,6 @@ void TestCategoryUtils::bestMatchedGameVariants()
 
 void TestCategoryUtils::bestMatchedDevelopmentVariants()
 {
-    qCInfo(logTest) << "Development XDG categories should aggregate into development";
     QCOMPARE(int(CategoryUtils::parseBestMatchedCategory({QStringLiteral("ide"), QStringLiteral("debugger")})),
               int(C::CategoryDevelopment));
     QCOMPARE(int(CategoryUtils::parseBestMatchedCategory({QStringLiteral("building"), QStringLiteral("revisioncontrol")})),
@@ -200,14 +180,12 @@ void TestCategoryUtils::bestMatchedDevelopmentVariants()
 
 void TestCategoryUtils::bestMatchedReadingVariants()
 {
-    qCInfo(logTest) << "Reading XDG categories should aggregate into reading";
     QCOMPARE(int(CategoryUtils::parseBestMatchedCategory({QStringLiteral("news"), QStringLiteral("translation")})),
               int(C::CategoryReading));
 }
 
 void TestCategoryUtils::bestMatchedSystemVariants()
 {
-    qCInfo(logTest) << "System XDG categories should aggregate into system";
     QCOMPARE(int(CategoryUtils::parseBestMatchedCategory({QStringLiteral("desktopsettings"), QStringLiteral("packagemanager")})),
               int(C::CategorySystem));
     QCOMPARE(int(CategoryUtils::parseBestMatchedCategory({QStringLiteral("terminalemulator"), QStringLiteral("filemanager")})),
@@ -216,7 +194,6 @@ void TestCategoryUtils::bestMatchedSystemVariants()
 
 void TestCategoryUtils::bestMatchedGraphicsVariants()
 {
-    qCInfo(logTest) << "Graphics XDG categories should aggregate into graphics";
     QCOMPARE(int(CategoryUtils::parseBestMatchedCategory({QStringLiteral("2dgraphics"), QStringLiteral("rastergraphics")})),
               int(C::CategoryGraphics));
     QCOMPARE(int(CategoryUtils::parseBestMatchedCategory({QStringLiteral("photography"), QStringLiteral("viewer")})),
@@ -225,14 +202,12 @@ void TestCategoryUtils::bestMatchedGraphicsVariants()
 
 void TestCategoryUtils::bestMatchedChatVariants()
 {
-    qCInfo(logTest) << "Chat XDG categories should aggregate into chat";
     QCOMPARE(int(CategoryUtils::parseBestMatchedCategory({QStringLiteral("instantmessaging"), QStringLiteral("contactmanagement")})),
               int(C::CategoryChat));
 }
 
 void TestCategoryUtils::bestMatchedOfficeVariants()
 {
-    qCInfo(logTest) << "Office XDG categories should aggregate into office";
     QCOMPARE(int(CategoryUtils::parseBestMatchedCategory({QStringLiteral("spreadsheet"), QStringLiteral("presentation")})),
               int(C::CategoryOffice));
     QCOMPARE(int(CategoryUtils::parseBestMatchedCategory({QStringLiteral("science"), QStringLiteral("math")})),
@@ -241,7 +216,6 @@ void TestCategoryUtils::bestMatchedOfficeVariants()
 
 void TestCategoryUtils::bestMatchedMixedUnknownAndKnown()
 {
-    qCInfo(logTest) << "Unknown categories mixed with known ones should ignore unknowns";
     // 'totally-unknown' yields CategoryErr from DDE and empty from XDG -> ignored
     // 'music' yields CategoryMusic -> should win
     QCOMPARE(int(CategoryUtils::parseBestMatchedCategory({QStringLiteral("totally-unknown"), QStringLiteral("music")})),
@@ -250,14 +224,12 @@ void TestCategoryUtils::bestMatchedMixedUnknownAndKnown()
 
 void TestCategoryUtils::bestMatchedAudioVideoEditingTie()
 {
-    qCInfo(logTest) << "audiovideoediting maps to both music and video -> tie -> video";
     QCOMPARE(int(CategoryUtils::parseBestMatchedCategory({QStringLiteral("audiovideoediting")})),
               int(C::CategoryVideo));
 }
 
 void TestCategoryUtils::bestMatchedRecorderTie()
 {
-    qCInfo(logTest) << "recorder maps to both music and video -> tie -> video";
     QCOMPARE(int(CategoryUtils::parseBestMatchedCategory({QStringLiteral("recorder")})),
               int(C::CategoryVideo));
 }