使用CMake进行代码覆盖率分析的完整指南从基础配置到高级技巧助你轻松掌握项目测试质量评估方法

威震华夏关云长

引言

代码覆盖率分析是软件开发生命周期中至关重要的一环，它帮助开发团队评估测试用例的有效性，识别未被测试的代码区域，从而提高软件质量和可靠性。CMake作为一个跨平台的构建系统，提供了强大的功能来支持代码覆盖率分析，使开发人员能够轻松地将覆盖率检查集成到他们的构建和测试流程中。

本文将详细介绍如何使用CMake进行代码覆盖率分析，从基础配置到高级技巧，帮助您全面掌握项目测试质量评估方法。无论您是CMake的新手还是有经验的用户，本指南都将为您提供有价值的见解和实用的技巧。

代码覆盖率分析基础

在深入CMake配置之前，让我们先了解代码覆盖率分析的基本概念。

什么是代码覆盖率？

代码覆盖率是衡量测试用例执行过程中覆盖了多少源代码的指标。它通常以百分比表示，表示被测试执行的代码量占总代码量的比例。高代码覆盖率通常意味着测试更全面，但需要注意的是，100%的覆盖率并不一定意味着没有bug，它只是表示所有代码都已被执行过。

覆盖率类型

常见的代码覆盖率类型包括：

1. 行覆盖率（Line Coverage）：测量有多少行代码被执行。
2. 分支覆盖率（Branch Coverage）：测量代码中的每个分支（如if语句的true和false分支）是否都被执行。
3. 函数覆盖率（Function Coverage）：测量有多少函数被调用。
4. 语句覆盖率（Statement Coverage）：类似于行覆盖率，但更精确地计算每个语句的执行情况。
5. 路径覆盖率（Path Coverage）：测量代码中可能的执行路径有多少被测试覆盖。

为什么代码覆盖率很重要？

• 识别未测试代码：帮助开发人员找到未被测试覆盖的代码区域。
• 提高代码质量：通过增加测试覆盖率，可以及早发现潜在的bug。
• 指导测试开发：为测试团队提供明确的测试目标。
• 评估测试效果：量化测试用例的有效性。
• 满足合规要求：某些行业和项目有特定的覆盖率要求。

CMake基础配置

CMake提供了多种方式来配置代码覆盖率分析。在本节中，我们将介绍如何设置CMake项目以支持基本的代码覆盖率分析。

创建支持覆盖率的基本CMake项目

首先，让我们创建一个简单的CMake项目结构：

2. coverage_example/
3. ├── CMakeLists.txt
4. ├── src/
5. │   ├── CMakeLists.txt
6. │   └── math_functions.cpp
7. └── tests/
8.     ├── CMakeLists.txt
9.     └── test_math_functions.cpp

复制代码

2. cmake_minimum_required(VERSION 3.10)
3. project(coverage_example VERSION 1.0 LANGUAGES CXX)
5. # 设置C++标准
6. set(CMAKE_CXX_STANDARD 11)
7. set(CMAKE_CXX_STANDARD_REQUIRED ON)
9. # 添加编译选项，如果启用了覆盖率
10. option(ENABLE_COVERAGE "Enable coverage reporting" OFF)
12. if(ENABLE_COVERAGE)
13.     # 添加覆盖率编译选项
14.     if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
15.         add_compile_options(-fprofile-arcs -ftest-coverage)
16.         set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage")
17.     elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
18.         add_compile_options(/profile)
19.     endif()
20. endif()
22. # 添加子目录
23. add_subdirectory(src)
24. add_subdirectory(tests)

复制代码

2. # 创建库
3. add_library(math_functions math_functions.cpp)
5. # 包含目录
6. target_include_directories(math_functions
7.     PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/..
8. )

复制代码

2. #include "math_functions.h"
4. int add(int a, int b) {
5.     return a + b;
6. }
8. int subtract(int a, int b) {
9.     return a - b;
10. }
12. int multiply(int a, int b) {
13.     return a * b;
14. }
16. double divide(int a, int b) {
17.     if (b == 0) {
18.         return 0; // 简化处理，实际应用中可能需要抛出异常
19.     }
20.     return static_cast<double>(a) / b;
21. }
23. bool is_prime(int n) {
24.     if (n <= 1) return false;
25.     if (n == 2) return true;
26.     if (n % 2 == 0) return false;
27.    
28.     for (int i = 3; i * i <= n; i += 2) {
29.         if (n % i == 0) {
30.             return false;
31.         }
32.     }
33.     return true;
34. }

复制代码

2. # 查找并配置Google Test
3. find_package(GTest REQUIRED)
4. include_directories(${GTEST_INCLUDE_DIRS})
6. # 创建测试可执行文件
7. add_executable(test_math_functions test_math_functions.cpp)
9. # 链接库
10. target_link_libraries(test_math_functions
11.     math_functions
12.     ${GTEST_LIBRARIES}
13.     pthread
14. )
16. # 包含目录
17. target_include_directories(test_math_functions
18.     PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/..
19. )
21. # 启用测试
22. enable_testing()
24. # 添加测试
25. add_test(NAME math_functions_test COMMAND test_math_functions)

复制代码

2. #include <gtest/gtest.h>
3. #include "math_functions.h"
5. TEST(MathFunctionsTest, Add) {
6.     EXPECT_EQ(add(2, 3), 5);
7.     EXPECT_EQ(add(-1, 1), 0);
8.     EXPECT_EQ(add(0, 0), 0);
9. }
11. TEST(MathFunctionsTest, Subtract) {
12.     EXPECT_EQ(subtract(5, 3), 2);
13.     EXPECT_EQ(subtract(1, 1), 0);
14.     EXPECT_EQ(subtract(0, 5), -5);
15. }
17. TEST(MathFunctionsTest, Multiply) {
18.     EXPECT_EQ(multiply(2, 3), 6);
19.     EXPECT_EQ(multiply(-1, 5), -5);
20.     EXPECT_EQ(multiply(0, 5), 0);
21. }
23. TEST(MathFunctionsTest, Divide) {
24.     EXPECT_DOUBLE_EQ(divide(10, 2), 5.0);
25.     EXPECT_DOUBLE_EQ(divide(5, 2), 2.5);
26.     EXPECT_DOUBLE_EQ(divide(0, 5), 0.0);
27.     // 注意：我们没有测试除以零的情况
28. }
30. TEST(MathFunctionsTest, IsPrime) {
31.     EXPECT_FALSE(is_prime(0));
32.     EXPECT_FALSE(is_prime(1));
33.     EXPECT_TRUE(is_prime(2));
34.     EXPECT_TRUE(is_prime(3));
35.     EXPECT_FALSE(is_prime(4));
36.     EXPECT_TRUE(is_prime(5));
37.     EXPECT_FALSE(is_prime(9));
38.     EXPECT_TRUE(is_prime(17));
39. }
41. int main(int argc, char **argv) {
42.     ::testing::InitGoogleTest(&argc, argv);
43.     return RUN_ALL_TESTS();
44. }

复制代码

构建和运行测试

现在我们已经设置了基本的项目结构，可以构建并运行测试：

2. # 创建构建目录
3. mkdir build && cd build
5. # 配置项目，启用覆盖率
6. cmake -DENABLE_COVERAGE=ON ..
8. # 构建项目
9. make
11. # 运行测试
12. ./tests/test_math_functions

复制代码

集成覆盖率工具

在CMake中启用覆盖率编译选项后，我们需要使用特定的工具来收集覆盖率数据并生成报告。常用的覆盖率工具包括gcov、lcov和llvm-cov等。

使用gcov和lcov

gcov是GCC自带的覆盖率分析工具，而lcov是gcov的前端工具，可以生成更友好的HTML报告。

在Ubuntu/Debian系统上：

2. sudo apt-get install gcovr lcov

复制代码

在CentOS/RHEL系统上：

2. sudo yum install lcov

复制代码

在macOS系统上（使用Homebrew）：

2. brew install lcov

复制代码

让我们修改主CMakeLists.txt文件，添加对lcov的支持：

2. cmake_minimum_required(VERSION 3.10)
3. project(coverage_example VERSION 1.0 LANGUAGES CXX)
5. # 设置C++标准
6. set(CMAKE_CXX_STANDARD 11)
7. set(CMAKE_CXX_STANDARD_REQUIRED ON)
9. # 添加编译选项，如果启用了覆盖率
10. option(ENABLE_COVERAGE "Enable coverage reporting" OFF)
12. if(ENABLE_COVERAGE)
13.     # 添加覆盖率编译选项
14.     if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
15.         add_compile_options(-fprofile-arcs -ftest-coverage)
16.         set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage")
17.         
18.         # 添加lcov目标
19.         find_program(LCOV_EXECUTABLE lcov)
20.         find_program(GENHTML_EXECUTABLE genhtml)
21.         
22.         if(LCOV_EXECUTABLE AND GENHTML_EXECUTABLE)
23.             # 定义覆盖率目录
24.             set(COVERAGE_DIR "${CMAKE_BINARY_DIR}/coverage")
25.             
26.             # 创建覆盖率目标
27.             add_custom_target(coverage
28.                 COMMAND mkdir -p ${COVERAGE_DIR}
29.                 COMMAND ${LCOV_EXECUTABLE} --directory . --capture --output-file ${COVERAGE_DIR}/coverage.info
30.                 COMMAND ${LCOV_EXECUTABLE} --remove ${COVERAGE_DIR}/coverage.info '/usr/*' '${CMAKE_BINARY_DIR}/*' --output-file ${COVERAGE_DIR}/coverage.info.cleaned
31.                 COMMAND ${GENHTML_EXECUTABLE} ${COVERAGE_DIR}/coverage.info.cleaned --output-directory ${COVERAGE_DIR}
32.                 WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
33.                 COMMENT "Generating coverage report"
34.             )
35.         endif()
36.     elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
37.         add_compile_options(/profile)
38.     endif()
39. endif()
41. # 添加子目录
42. add_subdirectory(src)
43. add_subdirectory(tests)

复制代码

现在，我们可以使用以下命令生成覆盖率报告：

2. # 构建项目并运行测试
3. mkdir build && cd build
4. cmake -DENABLE_COVERAGE=ON ..
5. make
7. # 运行测试以生成覆盖率数据
8. ./tests/test_math_functions
10. # 生成覆盖率报告
11. make coverage

复制代码

生成的HTML报告将位于build/coverage/index.html，您可以在浏览器中打开它查看详细的覆盖率信息。

使用gcovr

gcovr是另一个流行的覆盖率工具，它可以生成XML和HTML报告，并且与Jenkins等CI工具集成良好。

在Ubuntu/Debian系统上：

2. sudo apt-get install gcovr

复制代码

在CentOS/RHEL系统上：

2. sudo yum install gcovr

复制代码

或者使用pip安装：

2. pip install gcovr

复制代码

2. cmake_minimum_required(VERSION 3.10)
3. project(coverage_example VERSION 1.0 LANGUAGES CXX)
5. # 设置C++标准
6. set(CMAKE_CXX_STANDARD 11)
7. set(CMAKE_CXX_STANDARD_REQUIRED ON)
9. # 添加编译选项，如果启用了覆盖率
10. option(ENABLE_COVERAGE "Enable coverage reporting" OFF)
12. if(ENABLE_COVERAGE)
13.     # 添加覆盖率编译选项
14.     if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
15.         add_compile_options(-fprofile-arcs -ftest-coverage)
16.         set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage")
17.         
18.         # 添加gcovr目标
19.         find_program(GCOVR_EXECUTABLE gcovr)
20.         
21.         if(GCOVR_EXECUTABLE)
22.             # 定义覆盖率目录
23.             set(COVERAGE_DIR "${CMAKE_BINARY_DIR}/coverage")
24.             
25.             # 创建覆盖率目标
26.             add_custom_target(coverage
27.                 COMMAND mkdir -p ${COVERAGE_DIR}
28.                 COMMAND ${GCOVR_EXECUTABLE} --root ${CMAKE_SOURCE_DIR} --exclude ${CMAKE_BINARY_DIR} --html --html-details -o ${COVERAGE_DIR}/coverage.html
29.                 COMMAND ${GCOVR_EXECUTABLE} --root ${CMAKE_SOURCE_DIR} --exclude ${CMAKE_BINARY_DIR} --xml -o ${COVERAGE_DIR}/coverage.xml
30.                 COMMAND ${GCOVR_EXECUTABLE} --root ${CMAKE_SOURCE_DIR} --exclude ${CMAKE_BINARY_DIR} --sonarqube -o ${COVERAGE_DIR}/sonarqube.xml
31.                 WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
32.                 COMMENT "Generating coverage report with gcovr"
33.             )
34.         endif()
35.     elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
36.         add_compile_options(/profile)
37.     endif()
38. endif()
40. # 添加子目录
41. add_subdirectory(src)
42. add_subdirectory(tests)

复制代码

使用gcovr生成覆盖率报告的步骤与lcov类似：

2. # 构建项目并运行测试
3. mkdir build && cd build
4. cmake -DENABLE_COVERAGE=ON ..
5. make
7. # 运行测试以生成覆盖率数据
8. ./tests/test_math_functions
10. # 生成覆盖率报告
11. make coverage

复制代码

生成的HTML报告将位于build/coverage/coverage.html，XML报告位于build/coverage/coverage.xml，SonarQube兼容的报告位于build/coverage/sonarqube.xml。

使用llvm-cov

如果您使用的是Clang编译器，可以使用llvm-cov进行覆盖率分析。

2. cmake_minimum_required(VERSION 3.10)
3. project(coverage_example VERSION 1.0 LANGUAGES CXX)
5. # 设置C++标准
6. set(CMAKE_CXX_STANDARD 11)
7. set(CMAKE_CXX_STANDARD_REQUIRED ON)
9. # 添加编译选项，如果启用了覆盖率
10. option(ENABLE_COVERAGE "Enable coverage reporting" OFF)
12. if(ENABLE_COVERAGE)
13.     # 添加覆盖率编译选项
14.     if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
15.         add_compile_options(-fprofile-arcs -ftest-coverage)
16.         set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage")
17.         
18.         # 添加lcov目标
19.         find_program(LCOV_EXECUTABLE lcov)
20.         find_program(GENHTML_EXECUTABLE genhtml)
21.         
22.         if(LCOV_EXECUTABLE AND GENHTML_EXECUTABLE)
23.             # 定义覆盖率目录
24.             set(COVERAGE_DIR "${CMAKE_BINARY_DIR}/coverage")
25.             
26.             # 创建覆盖率目标
27.             add_custom_target(coverage
28.                 COMMAND mkdir -p ${COVERAGE_DIR}
29.                 COMMAND ${LCOV_EXECUTABLE} --directory . --capture --output-file ${COVERAGE_DIR}/coverage.info
30.                 COMMAND ${LCOV_EXECUTABLE} --remove ${COVERAGE_DIR}/coverage.info '/usr/*' '${CMAKE_BINARY_DIR}/*' --output-file ${COVERAGE_DIR}/coverage.info.cleaned
31.                 COMMAND ${GENHTML_EXECUTABLE} ${COVERAGE_DIR}/coverage.info.cleaned --output-directory ${COVERAGE_DIR}
32.                 WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
33.                 COMMENT "Generating coverage report"
34.             )
35.         endif()
36.     elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
37.         # 使用Clang的覆盖率标志
38.         add_compile_options(-fprofile-instr-generate -fcoverage-mapping)
39.         set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fprofile-instr-generate")
40.         
41.         # 添加llvm-cov目标
42.         find_program(LLVM_COV_EXECUTABLE llvm-cov)
43.         find_program(LLVM_PROFDATA_EXECUTABLE llvm-profdata)
44.         
45.         if(LLVM_COV_EXECUTABLE AND LLVM_PROFDATA_EXECUTABLE)
46.             # 定义覆盖率目录
47.             set(COVERAGE_DIR "${CMAKE_BINARY_DIR}/coverage")
48.             
49.             # 创建覆盖率目标
50.             add_custom_target(coverage
51.                 COMMAND mkdir -p ${COVERAGE_DIR}
52.                 # 合并原始配置文件
53.                 COMMAND ${LLVM_PROFDATA_EXECUTABLE} merge -sparse default.profraw -o ${COVERAGE_DIR}/coverage.profdata
54.                 # 生成HTML报告
55.                 COMMAND ${LLVM_COV_EXECUTABLE} show ./tests/test_math_functions -instr-profile=${COVERAGE_DIR}/coverage.profdata -format=html -output-dir=${COVERAGE_DIR} -show-line-counts-or-regions
56.                 # 生成文本报告
57.                 COMMAND ${LLVM_COV_EXECUTABLE} report ./tests/test_math_functions -instr-profile=${COVERAGE_DIR}/coverage.profdata > ${COVERAGE_DIR}/coverage.txt
58.                 WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
59.                 COMMENT "Generating coverage report with llvm-cov"
60.             )
61.         endif()
62.     elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
63.         add_compile_options(/profile)
64.     endif()
65. endif()
67. # 添加子目录
68. add_subdirectory(src)
69. add_subdirectory(tests)

复制代码

使用llvm-cov生成覆盖率报告的步骤：

2. # 构建项目并运行测试
3. mkdir build && cd build
4. cmake -DENABLE_COVERAGE=ON ..
5. make
7. # 运行测试以生成原始配置文件
8. LLVM_PROFILE_FILE="default.profraw" ./tests/test_math_functions
10. # 生成覆盖率报告
11. make coverage

复制代码

生成的HTML报告将位于build/coverage/index.html，文本报告位于build/coverage/coverage.txt。

生成覆盖率报告

在上一节中，我们已经集成了各种覆盖率工具并生成了基本的覆盖率报告。本节将更详细地介绍如何生成和解读覆盖率报告。

lcov报告详解

lcov生成的HTML报告非常直观，它提供了以下信息：

1. 总体覆盖率：显示行覆盖率、函数覆盖率和分支覆盖率的总体百分比。
2. 目录视图：按目录组织显示覆盖率信息。
3. 文件视图：显示每个源文件的详细覆盖率信息。
4. 源代码视图：在源代码中标记已执行和未执行的行。

• 绿色行：表示已执行的代码行。
• 红色行：表示未执行的代码行。
• 黄色标记：表示分支覆盖情况。

在我们的示例中，您可能会注意到divide函数中的除以零情况没有被测试覆盖，这显示为红色行。这提示我们需要添加相应的测试用例。

gcovr报告详解

gcovr生成的报告与lcov类似，但提供了一些额外的功能：

1. 多种输出格式：支持HTML、XML、文本和SonarQube格式。
2. 分支覆盖信息：详细显示每个分支的覆盖情况。
3. 汇总信息：提供项目整体覆盖率的汇总。

gcovr的HTML报告提供了与lcov类似的视图，但布局略有不同。它还提供了XML报告，可以与CI工具集成。

llvm-cov报告详解

llvm-cov生成的报告提供了以下信息：

1. 区域覆盖率：比行覆盖率更细粒度的覆盖率指标。
2. 函数覆盖率：显示每个函数的覆盖情况。
3. 行覆盖率：显示每行代码的执行次数。

llvm-cov的HTML报告非常详细，它显示了每行代码的执行次数，并用颜色区分覆盖情况。它还提供了函数级别的覆盖率信息。

高级技巧

现在我们已经掌握了基本的CMake覆盖率分析配置，让我们探索一些高级技巧，以进一步提高我们的覆盖率分析能力。

条件编译和覆盖率

有时，我们可能希望只在特定条件下启用覆盖率分析，例如在CI环境中或特定的构建类型中。

2. # 在CMakeLists.txt中添加以下内容
4. # 检查是否是CI环境
5. if(DEFINED ENV{CI})
6.     set(ENABLE_COVERAGE ON CACHE BOOL "Enable coverage reporting in CI environment")
7. endif()
9. # 或者只在Debug构建中启用覆盖率
10. if(CMAKE_BUILD_TYPE STREQUAL "Debug")
11.     set(ENABLE_COVERAGE ON CACHE BOOL "Enable coverage reporting in Debug builds")
12. endif()

复制代码

排除特定文件或目录

在实际项目中，我们可能希望排除某些文件或目录的覆盖率分析，例如第三方代码或自动生成的文件。

2. # 修改CMakeLists.txt中的coverage目标
3. add_custom_target(coverage
4.     COMMAND mkdir -p ${COVERAGE_DIR}
5.     # 捕获覆盖率数据
6.     COMMAND ${LCOV_EXECUTABLE} --directory . --capture --output-file ${COVERAGE_DIR}/coverage.info
7.     # 排除特定文件和目录
8.     COMMAND ${LCOV_EXECUTABLE} --remove ${COVERAGE_DIR}/coverage.info
9.         '/usr/*'
10.         '${CMAKE_BINARY_DIR}/*'
11.         '*/third_party/*'
12.         '*/tests/*'
13.         '*/mocks/*'
14.         --output-file ${COVERAGE_DIR}/coverage.info.cleaned
15.     # 生成HTML报告
16.     COMMAND ${GENHTML_EXECUTABLE} ${COVERAGE_DIR}/coverage.info.cleaned --output-directory ${COVERAGE_DIR}
17.     WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
18.     COMMENT "Generating coverage report"
19. )

复制代码

2. # 修改CMakeLists.txt中的coverage目标
3. add_custom_target(coverage
4.     COMMAND mkdir -p ${COVERAGE_DIR}
5.     # 生成HTML报告，排除特定文件和目录
6.     COMMAND ${GCOVR_EXECUTABLE}
7.         --root ${CMAKE_SOURCE_DIR}
8.         --exclude ${CMAKE_BINARY_DIR}
9.         --exclude '*/third_party/*'
10.         --exclude '*/tests/*'
11.         --exclude '*/mocks/*'
12.         --html --html-details
13.         -o ${COVERAGE_DIR}/coverage.html
14.     # 生成XML报告
15.     COMMAND ${GCOVR_EXECUTABLE}
16.         --root ${CMAKE_SOURCE_DIR}
17.         --exclude ${CMAKE_BINARY_DIR}
18.         --exclude '*/third_party/*'
19.         --exclude '*/tests/*'
20.         --exclude '*/mocks/*'
21.         --xml
22.         -o ${COVERAGE_DIR}/coverage.xml
23.     WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
24.     COMMENT "Generating coverage report with gcovr"
25. )

复制代码

设置覆盖率阈值

为了确保代码质量，我们可以设置覆盖率阈值，如果覆盖率低于阈值，则构建失败。

2. # 修改CMakeLists.txt中的coverage目标
3. add_custom_target(coverage
4.     COMMAND mkdir -p ${COVERAGE_DIR}
5.     # 生成报告并检查覆盖率阈值
6.     COMMAND ${GCOVR_EXECUTABLE}
7.         --root ${CMAKE_SOURCE_DIR}
8.         --exclude ${CMAKE_BINARY_DIR}
9.         --html --html-details
10.         -o ${COVERAGE_DIR}/coverage.html
11.         --fail-under-line 80  # 行覆盖率至少80%
12.         --fail-under-branch 70  # 分支覆盖率至少70%
13.     WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
14.     COMMENT "Generating coverage report with gcovr"
15. )

复制代码

合并多个测试运行的覆盖率数据

在大型项目中，我们可能有多个测试可执行文件，需要合并它们的覆盖率数据。

2. # 假设我们有多个测试可执行文件
3. add_custom_target(coverage
4.     COMMAND mkdir -p ${COVERAGE_DIR}
5.    
6.     # 为每个测试运行并收集数据
7.     COMMAND ${CMAKE_COMMAND} -E env LLVM_PROFILE_FILE="test1.profraw" ./tests/test_math_functions1
8.     COMMAND ${CMAKE_COMMAND} -E env LLVM_PROFILE_FILE="test2.profraw" ./tests/test_math_functions2
9.    
10.     # 合并原始配置文件
11.     COMMAND ${LLVM_PROFDATA_EXECUTABLE} merge -sparse test1.profraw test2.profraw -o ${COVERAGE_DIR}/coverage.profdata
12.    
13.     # 生成HTML报告
14.     COMMAND ${LLVM_COV_EXECUTABLE} show ./tests/test_math_functions1 -instr-profile=${COVERAGE_DIR}/coverage.profdata -format=html -output-dir=${COVERAGE_DIR} -show-line-counts-or-regions
15.    
16.     WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
17.     COMMENT "Generating coverage report"
18. )

复制代码

使用自定义函数简化CMake配置

为了在多个项目中重用覆盖率配置，我们可以创建自定义CMake函数。

2. # 在CMakeLists.txt中添加以下函数
4. function(enable_code_coverage target_name)
5.     if(NOT ENABLE_COVERAGE)
6.         return()
7.     endif()
8.    
9.     if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
10.         target_compile_options(${target_name} PRIVATE -fprofile-arcs -ftest-coverage)
11.         set_target_properties(${target_name} PROPERTIES LINK_FLAGS "-fprofile-arcs -ftest-coverage")
12.     elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
13.         target_compile_options(${target_name} PRIVATE /profile)
14.     endif()
15. endfunction()
17. function(add_coverage_target)
18.     if(NOT ENABLE_COVERAGE)
19.         return()
20.     endif()
21.    
22.     # 定义覆盖率目录
23.     set(COVERAGE_DIR "${CMAKE_BINARY_DIR}/coverage")
24.    
25.     # 根据编译器选择适当的工具
26.     if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
27.         find_program(LCOV_EXECUTABLE lcov)
28.         find_program(GENHTML_EXECUTABLE genhtml)
29.         
30.         if(LCOV_EXECUTABLE AND GENHTML_EXECUTABLE)
31.             add_custom_target(coverage
32.                 COMMAND mkdir -p ${COVERAGE_DIR}
33.                 COMMAND ${LCOV_EXECUTABLE} --directory . --capture --output-file ${COVERAGE_DIR}/coverage.info
34.                 COMMAND ${LCOV_EXECUTABLE} --remove ${COVERAGE_DIR}/coverage.info '/usr/*' '${CMAKE_BINARY_DIR}/*' --output-file ${COVERAGE_DIR}/coverage.info.cleaned
35.                 COMMAND ${GENHTML_EXECUTABLE} ${COVERAGE_DIR}/coverage.info.cleaned --output-directory ${COVERAGE_DIR}
36.                 WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
37.                 COMMENT "Generating coverage report"
38.             )
39.         endif()
40.     elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
41.         find_program(LLVM_COV_EXECUTABLE llvm-cov)
42.         find_program(LLVM_PROFDATA_EXECUTABLE llvm-profdata)
43.         
44.         if(LLVM_COV_EXECUTABLE AND LLVM_PROFDATA_EXECUTABLE)
45.             add_custom_target(coverage
46.                 COMMAND mkdir -p ${COVERAGE_DIR}
47.                 COMMAND ${LLVM_PROFDATA_EXECUTABLE} merge -sparse default.profraw -o ${COVERAGE_DIR}/coverage.profdata
48.                 COMMAND ${LLVM_COV_EXECUTABLE} show ./tests/test_math_functions -instr-profile=${COVERAGE_DIR}/coverage.profdata -format=html -output-dir=${COVERAGE_DIR} -show-line-counts-or-regions
49.                 WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
50.                 COMMENT "Generating coverage report with llvm-cov"
51.             )
52.         endif()
53.     endif()
54. endfunction()

复制代码

然后，在项目中使用这些函数：

2. # 为库启用覆盖率
3. add_library(math_functions math_functions.cpp)
4. enable_code_coverage(math_functions)
6. # 为测试启用覆盖率
7. add_executable(test_math_functions test_math_functions.cpp)
8. enable_code_coverage(test_math_functions)
10. # 添加覆盖率目标
11. add_coverage_target()

复制代码

使用CMake的CTest模块集成覆盖率测试

CMake的CTest模块提供了测试管理功能，我们可以利用它来集成覆盖率测试。

2. # 在CMakeLists.txt中添加以下内容
4. # 启用CTest
5. include(CTest)
7. if(ENABLE_COVERAGE)
8.     # 添加覆盖率测试
9.     add_test(NAME coverage_test
10.         COMMAND ${CMAKE_MAKE_PROGRAM} coverage
11.         WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
12.     )
13.    
14.     # 设置测试属性
15.     set_tests_properties(coverage_test PROPERTIES
16.         LABELS "coverage"
17.         REQUIRED_FILES "${CMAKE_BINARY_DIR}/coverage/index.html"
18.     )
19. endif()

复制代码

然后，可以使用CTest运行所有测试，包括覆盖率测试：

2. # 运行所有测试
3. ctest
5. # 只运行覆盖率测试
6. ctest -R coverage

复制代码

最佳实践

在本节中，我们将介绍一些使用CMake进行代码覆盖率分析的最佳实践，帮助您在项目中有效地实施覆盖率分析。

在CI/CD中集成代码覆盖率分析

持续集成/持续部署（CI/CD）是现代软件开发的核心实践，将代码覆盖率分析集成到CI/CD流程中可以确保代码质量。

在Jenkins中，您可以使用以下步骤集成代码覆盖率分析：

1. 安装必要的插件，如”Cobertura Plugin”或”Coverage Plugin”。
2. 在Jenkinsfile中添加覆盖率分析步骤：

2. pipeline {
3.     agent any
4.     stages {
5.         stage('Build and Test') {
6.             steps {
7.                 sh 'mkdir -p build && cd build'
8.                 sh 'cmake -DENABLE_COVERAGE=ON ..'
9.                 sh 'make'
10.                 sh 'ctest --output-on-failure'
11.             }
12.         }
13.         stage('Generate Coverage') {
14.             steps {
15.                 sh 'cd build && make coverage'
16.             }
17.             post {
18.                 always {
19.                     // 发布Cobertura格式的覆盖率报告
20.                     publishCoverage adapters: [coberturaAdapter('build/coverage/coverage.xml')], sourceFileResolver: sourceFiles('STORE_LAST_BUILD')
21.                     
22.                     // 存储HTML报告
23.                     publishHTML([
24.                         allowMissing: false,
25.                         alwaysLinkToLastBuild: true,
26.                         keepAll: true,
27.                         reportDir: 'build/coverage',
28.                         reportFiles: 'index.html',
29.                         reportName: 'Coverage Report'
30.                     ])
31.                 }
32.             }
33.         }
34.     }
35. }

复制代码

在GitHub Actions中，您可以创建一个工作流文件来运行覆盖率分析：

2. name: CI with Coverage
4. on: [push, pull_request]
6. jobs:
7.   build-and-test:
8.     runs-on: ubuntu-latest
9.    
10.     steps:
11.     - uses: actions/checkout@v2
12.    
13.     - name: Install dependencies
14.       run: |
15.         sudo apt-get update
16.         sudo apt-get install -y lcov gcovr
17.    
18.     - name: Configure and build
19.       run: |
20.         mkdir -p build && cd build
21.         cmake -DENABLE_COVERAGE=ON ..
22.         make
23.    
24.     - name: Run tests
25.       run: |
26.         cd build
27.         ctest --output-on-failure
28.    
29.     - name: Generate coverage report
30.       run: |
31.         cd build
32.         make coverage
33.    
34.     - name: Upload coverage to Codecov
35.       uses: codecov/codecov-action@v1
36.       with:
37.         file: ./build/coverage/coverage.xml
38.         flags: unittests
39.         name: codecov-umbrella
40.         fail_ci_if_error: true

复制代码

在GitLab CI中，您可以创建一个.gitlab-ci.yml文件：

2. stages:
3.   - build
4.   - test
5.   - coverage
7. build:
8.   stage: build
9.   script:
10.     - mkdir -p build
11.     - cd build
12.     - cmake -DENABLE_COVERAGE=ON ..
13.     - make
15. test:
16.   stage: test
17.   script:
18.     - cd build
19.     - ctest --output-on-failure
20.   artifacts:
21.     paths:
22.       - build/
24. coverage:
25.   stage: coverage
26.   script:
27.     - cd build
28.     - make coverage
29.   artifacts:
30.     reports:
31.       cobertura: build/coverage/coverage.xml
32.     paths:
33.       - build/coverage/

复制代码

设置覆盖率目标

为项目设置合理的覆盖率目标是很重要的。这些目标应该基于项目的重要性、复杂性和团队的能力。

不要试图一次性达到100%的覆盖率。相反，设置渐进式的目标：

1. 初始目标：达到60%的行覆盖率。
2. 中期目标：达到80%的行覆盖率和70%的分支覆盖率。
3. 长期目标：达到90%的行覆盖率和85%的分支覆盖率。

核心业务逻辑应该有更高的覆盖率要求，而辅助代码（如日志记录、UI代码）可以有较低的覆盖率要求。

2. # 在CMakeLists.txt中设置不同模块的不同覆盖率阈值
4. add_custom_target(core_coverage
5.     COMMAND ${GCOVR_EXECUTABLE}
6.         --root ${CMAKE_SOURCE_DIR}
7.         --filter '*/core/*'
8.         --fail-under-line 90
9.         --fail-under-branch 85
10.         --html --html-details
11.         -o ${COVERAGE_DIR}/core_coverage.html
12.     WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
13.     COMMENT "Generating core coverage report"
14. )
16. add_custom_target(utils_coverage
17.     COMMAND ${GCOVR_EXECUTABLE}
18.         --root ${CMAKE_SOURCE_DIR}
19.         --filter '*/utils/*'
20.         --fail-under-line 70
21.         --fail-under-branch 60
22.         --html --html-details
23.         -o ${COVERAGE_DIR}/utils_coverage.html
24.     WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
25.     COMMENT "Generating utils coverage report"
26. )

复制代码

定期审查覆盖率报告

仅仅生成覆盖率报告是不够的，定期审查这些报告并采取行动才是关键。

1. 每周审查：每周安排一次会议，审查覆盖率报告，识别未覆盖的代码区域。
2. 任务分配：为团队成员分配任务，为未覆盖的代码编写测试。
3. 跟踪进度：使用图表跟踪覆盖率随时间的变化，确保持续改进。

结合其他质量指标

代码覆盖率只是代码质量的一个方面，结合其他质量指标可以获得更全面的视图：

1. 静态代码分析：使用工具如Cppcheck、Clang-Tidy等。
2. 动态分析：使用工具如Valgrind、AddressSanitizer等。
3. 代码复杂度：监控圈复杂度等指标。

2. # 在CMakeLists.txt中集成多种质量检查工具
4. if(ENABLE_CODE_QUALITY)
5.     # 添加静态分析
6.     find_program(CPPCHECK_EXECUTABLE cppcheck)
7.     if(CPPCHECK_EXECUTABLE)
8.         add_custom_target(cppcheck
9.             COMMAND ${CPPCHECK_EXECUTABLE}
10.                 --enable=all
11.                 --inconclusive
12.                 --xml
13.                 --xml-version=2
14.                 ${CMAKE_SOURCE_DIR}/src 2> cppcheck.xml
15.             WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
16.             COMMENT "Running static analysis with cppcheck"
17.         )
18.     endif()
19.    
20.     # 添加动态分析
21.     if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
22.         add_compile_options(-fsanitize=address -fsanitize=undefined)
23.         set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=address -fsanitize=undefined")
24.     endif()
25.    
26.     # 添加质量检查目标
27.     add_custom_target(quality_check
28.         DEPENDS coverage cppcheck
29.         COMMENT "Running all quality checks"
30.     )
31. endif()

复制代码

常见问题和解决方案

在使用CMake进行代码覆盖率分析时，您可能会遇到一些常见问题。本节将介绍这些问题及其解决方案。

问题1：覆盖率数据不准确

症状：生成的覆盖率报告显示的覆盖率与预期不符，某些已执行的代码被标记为未执行。

可能原因：

• 编译优化导致代码被优化掉或重新排序。
• 覆盖率数据文件（.gcda或.profraw）没有正确生成或合并。
• 源代码路径与构建路径不匹配。

解决方案：

1. 禁用编译优化：

2. if(ENABLE_COVERAGE)
3.     if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
4.         add_compile_options(-O0 -fprofile-arcs -ftest-coverage)
5.         set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage")
6.     endif()
7. endif()

复制代码

1. 确保在运行测试前删除旧的覆盖率数据：

2. add_custom_target(coverage
3.     COMMAND ${CMAKE_COMMAND} -E remove_directory ${COVERAGE_DIR}
4.     COMMAND mkdir -p ${COVERAGE_DIR}
5.     # ... 其余命令 ...
6. )

复制代码

1. 使用绝对路径或确保路径一致性：

2. # 使用gcovr时指定根目录
3. add_custom_target(coverage
4.     COMMAND ${GCOVR_EXECUTABLE}
5.         --root ${CMAKE_SOURCE_DIR}
6.         --html --html-details
7.         -o ${COVERAGE_DIR}/coverage.html
8.     WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
9. )

复制代码

问题2：多目录项目中的覆盖率问题

症状：在多目录项目中，某些目录的代码没有被正确包含在覆盖率报告中。

可能原因：

• 覆盖率工具没有正确递归到所有子目录。
• 某些目标没有启用覆盖率编译选项。

解决方案：

1. 确保所有目标都启用了覆盖率：

2. # 创建一个函数来为所有目标启用覆盖率
3. function(enable_coverage_for_all_targets)
4.     if(ENABLE_COVERAGE)
5.         get_all_targets(all_targets ${CMAKE_CURRENT_SOURCE_DIR})
6.         foreach(target ${all_targets})
7.             if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
8.                 target_compile_options(${target} PRIVATE -fprofile-arcs -ftest-coverage)
9.                 set_target_properties(${target} PROPERTIES LINK_FLAGS "-fprofile-arcs -ftest-coverage")
10.             endif()
11.         endforeach()
12.     endif()
13. endfunction()
15. # 获取所有目标的辅助函数
16. function(get_all_targets var dir)
17.     get_property(subdirectories DIRECTORY ${dir} PROPERTY SUBDIRECTORIES)
18.     foreach(subdir ${subdirectories})
19.         get_all_targets(${var} ${subdir})
20.     endforeach()
21.     get_property(current_targets DIRECTORY ${dir} PROPERTY BUILDSYSTEM_TARGETS)
22.     set(${var} ${current_targets} PARENT_SCOPE)
23. endfunction()

复制代码

1. 在覆盖率分析命令中包含所有相关目录：

2. add_custom_target(coverage
3.     COMMAND ${GCOVR_EXECUTABLE}
4.         --root ${CMAKE_SOURCE_DIR}
5.         --html --html-details
6.         -o ${COVERAGE_DIR}/coverage.html
7.     WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
8. )

复制代码

问题3：CI环境中的覆盖率问题

症状：在本地环境中覆盖率工作正常，但在CI环境中失败或产生不准确的结果。

可能原因：

• CI环境中缺少必要的工具或依赖项。
• CI环境的构建路径与本地不同。
• CI环境中的并行执行导致覆盖率数据冲突。

解决方案：

1. 在CI脚本中安装必要的工具：

2. # GitHub Actions示例
3. - name: Install dependencies
4.   run: |
5.     sudo apt-get update
6.     sudo apt-get install -y lcov gcovr

复制代码

1. 使用相对路径或环境变量来处理路径差异：

2. # 使用CMAKE_CURRENT_SOURCE_DIR和CMAKE_BINARY_DIR
3. add_custom_target(coverage
4.     COMMAND ${GCOVR_EXECUTABLE}
5.         --root ${CMAKE_SOURCE_DIR}
6.         --exclude ${CMAKE_BINARY_DIR}
7.         --html --html-details
8.         -o ${CMAKE_BINARY_DIR}/coverage/coverage.html
9.     WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
10. )

复制代码

1. 为每个测试使用唯一的覆盖率数据文件：

2. # 为每个测试创建唯一的覆盖率数据文件
3. foreach(test ${TESTS})
4.     add_test(NAME ${test}
5.         COMMAND ${CMAKE_COMMAND} -E env LLVM_PROFILE_FILE="${test}.profraw" $<TARGET_FILE:${test}>
6.         WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
7.     )
8. endforeach()
10. # 合并所有覆盖率数据文件
11. add_custom_target(coverage
12.     COMMAND mkdir -p ${COVERAGE_DIR}
13.     # 合并所有.profraw文件
14.     COMMAND ${LLVM_PROFDATA_EXECUTABLE} merge -sparse *.profraw -o ${COVERAGE_DIR}/coverage.profdata
15.     # 生成报告
16.     COMMAND ${LLVM_COV_EXECUTABLE} show $<TARGET_FILE:${TESTS}> -instr-profile=${COVERAGE_DIR}/coverage.profdata -format=html -output-dir=${COVERAGE_DIR}
17.     WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
18. )

复制代码

问题4：第三方库的覆盖率问题

症状：覆盖率报告包含大量第三方库的代码，稀释了项目本身的覆盖率数据。

可能原因：

• 覆盖率工具没有排除第三方库的代码。

解决方案：

1. 明确排除第三方库：

2. add_custom_target(coverage
3.     COMMAND ${GCOVR_EXECUTABLE}
4.         --root ${CMAKE_SOURCE_DIR}
5.         --exclude '*/third_party/*'
6.         --exclude '*/external/*'
7.         --html --html-details
8.         -o ${COVERAGE_DIR}/coverage.html
9.     WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
10. )

复制代码

1. 使用模式匹配排除特定目录：

2. add_custom_target(coverage
3.     COMMAND ${LCOV_EXECUTABLE} --directory . --capture --output-file ${COVERAGE_DIR}/coverage.info
4.     COMMAND ${LCOV_EXECUTABLE} --remove ${COVERAGE_DIR}/coverage.info
5.         '/usr/*'
6.         '${CMAKE_BINARY_DIR}/*'
7.         '*/third_party/*'
8.         '*/external/*'
9.         '*/boost/*'
10.         '*/gtest/*'
11.         --output-file ${COVERAGE_DIR}/coverage.info.cleaned
12.     COMMAND ${GENHTML_EXECUTABLE} ${COVERAGE_DIR}/coverage.info.cleaned --output-directory ${COVERAGE_DIR}
13.     WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
14. )

复制代码

问题5：模板代码的覆盖率问题

症状：模板代码的覆盖率不准确或不完整。

可能原因：

• 模板代码的实例化可能导致覆盖率数据不准确。
• 编译器可能为模板代码生成额外的代码，这些代码在源文件中不可见。

解决方案：

1. 确保模板代码的所有实例化都被测试覆盖：

2. // 在测试文件中显式实例化模板
3. template class MyTemplateClass<int>;
4. template class MyTemplateClass<double>;

复制代码

1. 使用编译器特定的选项来改善模板代码的覆盖率：

2. if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
3.     add_compile_options(-fno-inline-small-functions -fno-inline-functions-called-once)
4. elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
5.     add_compile_options(-fno-inline)
6. endif()

复制代码

结论

代码覆盖率分析是确保软件质量的重要工具，而CMake提供了强大的功能来支持这一过程。通过本文，我们详细介绍了如何使用CMake进行代码覆盖率分析，从基础配置到高级技巧。

我们首先了解了代码覆盖率的基础知识，包括不同类型的覆盖率指标及其重要性。然后，我们介绍了如何设置CMake项目以支持代码覆盖率分析，包括如何集成常用的覆盖率工具如gcov、lcov和llvm-cov。

我们还探讨了如何生成和解读覆盖率报告，以及如何使用高级技巧来提高覆盖率分析的效率和准确性。这些技巧包括条件编译、排除特定文件或目录、设置覆盖率阈值、合并多个测试运行的覆盖率数据等。

此外，我们还介绍了在CI/CD环境中集成代码覆盖率分析的最佳实践，以及如何设置合理的覆盖率目标。最后，我们讨论了一些常见问题及其解决方案，帮助您在使用CMake进行代码覆盖率分析时避免陷阱。

通过正确实施代码覆盖率分析，您可以：

1. 提高代码质量：通过识别未测试的代码区域，可以及早发现潜在的bug。
2. 指导测试开发：为测试团队提供明确的测试目标。
3. 评估测试效果：量化测试用例的有效性。
4. 满足合规要求：满足特定行业或项目的覆盖率要求。

记住，代码覆盖率只是衡量测试质量的指标之一，它应该与其他质量指标结合使用，如静态代码分析、动态分析和代码复杂度分析等。通过综合使用这些工具和技术，您可以建立一个全面的软件质量保证体系。

希望本文能帮助您掌握使用CMake进行代码覆盖率分析的方法，并在您的项目中有效地实施这些技术。