C++ 测试与调试：保障代码质量与稳定性

3.2 Catch2 框架

Catch2 是另一个流行的 C++ 单元测试框架，它提供了更简洁的语法和更丰富的功能。

安装 Catch2

# Ubuntu/Debian
sudo apt-get install catch2
# macOS (Homebrew)
brew install catch2

Catch2 示例

#define CATCH_CONFIG_MAIN
#include <catch2/catch.hpp>
#include "MyClass.h"

// 测试 MyClass 的构造函数
TEST_CASE("MyClass Constructor Test", "[constructor]") {
    MyClass obj;
    REQUIRE(obj.getValue() == 0);
}

// 测试 MyClass 的 setValue 和 getValue 方法
TEST_CASE("MyClass Set and Get Value Test", "[setget]") {
    MyClass obj;
    obj.setValue(42);
    REQUIRE(obj.getValue() == 42);
}

// 测试 MyClass 的 add 方法
TEST_CASE("MyClass Add Test", "[add]") {
    MyClass obj;
    obj.setValue(10);
    int result = obj.add(20);
    REQUIRE(result == 30);
    REQUIRE(obj.getValue() == 30);
}

// 测试 MyClass 的 subtract 方法
TEST_CASE("MyClass Subtract Test", "[subtract]") {
    MyClass obj;
    obj.setValue(50);
    int result = obj.subtract(20);
    REQUIRE(result == 30);
    REQUIRE(obj.getValue() == 30);
}

四、调试工具

4.1 GDB 调试器

GDB 是 Linux 下常用的调试器，它提供了丰富的调试功能。

GDB 基本命令

# 编译程序时添加调试信息
g++ -g program.cpp -o program

# 启动 GDB
gdb program

# 常用 GDB 命令
break main          # 在 main 函数处设置断点
run                 # 运行程序
next                # 执行下一行代码（不进入函数）
step                # 执行下一行代码（进入函数）
print variable      # 打印变量的值
watch variable      # 监听变量的变化
backtrace           # 打印调用栈
continue            # 继续执行程序
quit                # 退出 GDB

GDB 调试示例

#include <iostream>
#include "MyClass.h"

int main() {
    MyClass obj;
    obj.setValue(42);
    int result = obj.add(20);
    std::cout << "结果：" << result << std::endl;
    return 0;
}

4.2 Visual Studio 调试器

Visual Studio 提供了强大的图形化调试器，支持断点、变量查看、调用栈等功能。

Visual Studio 调试步骤

1. 在代码中设置断点
2. 按 F5 启动调试
3. 程序会在断点处暂停
4. 使用调试工具窗口查看变量和调用栈
5. 继续执行程序

五、集成测试

5.1 集成测试的基本概念

集成测试是测试多个模块的集成功能，确保它们能够协同工作。集成测试可以分为以下几类：

• 自顶向下集成：从顶层模块开始，逐步集成底层模块
• 自底向上集成：从底层模块开始，逐步集成顶层模块
• 三明治集成：结合自顶向下和自底向上的方法

5.2 集成测试示例

#include <gtest/gtest.h>
#include "Calculator.h"
#include "Parser.h"

// 测试 Calculator 和 Parser 的集成功能
TEST(IntegrationTest, CalculateTest) {
    Calculator calculator;
    Parser parser;

    // 测试加法
    std::string expression = "10 + 20";
    int result = parser.parse(expression);
    EXPECT_EQ(result, 30);

    // 测试乘法
    expression = "10 * 20";
    result = parser.parse(expression);
    EXPECT_EQ(result, 200);

    // 测试括号
    expression = "(10 + 20) * 3";
    result = parser.parse(expression);
    EXPECT_EQ(result, 90);
}

六、综合案例：实现一个简单的计算器并进行测试

6.1 项目结构

CalculatorProject/
├── include/
│   ├── Calculator.h
│   └── Parser.h
├── src/
│   ├── Calculator.cpp
│   ├── Parser.cpp
│   └── main.cpp
├── tests/
│   ├── CalculatorTest.cpp
│   ├── ParserTest.cpp
│   └── IntegrationTest.cpp
└── CMakeLists.txt

6.2 核心代码

// include/Calculator.h
#ifndef CALCULATOR_H
#define CALCULATOR_H

class Calculator {
public:
    static int add(int a, int b);
    static int subtract(int a, int b);
    static int multiply(int a, int b);
    static int divide(int a, int b);
};

#endif // CALCULATOR_H

// src/Calculator.cpp
#include "Calculator.h"
#include <stdexcept>

int Calculator::add(int a, int b) {
    return a + b;
}

int Calculator::subtract(int a, int b) {
    return a - b;
}

int Calculator::multiply(int a, int b) {
    return a * b;
}

int Calculator::divide(int a, int b) {
    if (b == 0) {
        throw std::invalid_argument("除数不能为零");
    }
    return a / b;
}

// include/Parser.h
#ifndef PARSER_H
#define PARSER_H

#include <string>
#include "Calculator.h"

class Parser {
public:
    int parse(const std::string& expression);
};

#endif // PARSER_H

// src/Parser.cpp
#include "Parser.h"
#include <sstream>

int Parser::parse(const std::string& expression) {
    std::istringstream iss(expression);
    int a, b;
    char op;
    iss >> a >> op >> b;
    switch (op) {
    case '+': return Calculator::add(a, b);
    case '-': return Calculator::subtract(a, b);
    case '*': return Calculator::multiply(a, b);
    case '/': return Calculator::divide(a, b);
    default: throw std::invalid_argument("无效的运算符");
    }
}

// src/main.cpp
#include <iostream>
#include "Parser.h"

int main() {
    Parser parser;
    try {
        std::string expression;
        std::cout << "请输入表达式（例如：10 + 20）: ";
        std::getline(std::cin, expression);
        int result = parser.parse(expression);
        std::cout << "结果：" << result << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "错误：" << e.what() << std::endl;
        return 1;
    }
    return 0;
}

// tests/CalculatorTest.cpp
#include <gtest/gtest.h>
#include "Calculator.h"

// 测试 Calculator 的 add 方法
TEST(CalculatorTest, AddTest) {
    EXPECT_EQ(Calculator::add(10, 20), 30);
    EXPECT_EQ(Calculator::add(-10, 20), 10);
    EXPECT_EQ(Calculator::add(0, 0), 0);
}

// 测试 Calculator 的 subtract 方法
TEST(CalculatorTest, SubtractTest) {
    EXPECT_EQ(Calculator::subtract(20, 10), 10);
    EXPECT_EQ(Calculator::subtract(10, 20), -10);
    EXPECT_EQ(Calculator::subtract(0, 0), 0);
}

// 测试 Calculator 的 multiply 方法
TEST(CalculatorTest, MultiplyTest) {
    EXPECT_EQ(Calculator::multiply(10, 20), 200);
    EXPECT_EQ(Calculator::multiply(-10, 20), -200);
    EXPECT_EQ(Calculator::multiply(0, 10), 0);
}

// 测试 Calculator 的 divide 方法
TEST(CalculatorTest, DivideTest) {
    EXPECT_EQ(Calculator::divide(20, 10), 2);
    EXPECT_EQ(Calculator::divide(-20, 10), -2);
    EXPECT_THROW(Calculator::divide(10, 0), std::invalid_argument);
}

// tests/ParserTest.cpp
#include <gtest/gtest.h>
#include "Parser.h"

// 测试 Parser 的 parse 方法
TEST(ParserTest, ParseTest) {
    Parser parser;
    EXPECT_EQ(parser.parse("10 + 20"), 30);
    EXPECT_EQ(parser.parse("20 - 10"), 10);
    EXPECT_EQ(parser.parse("10 * 20"), 200);
    EXPECT_EQ(parser.parse("20 / 10"), 2);
    EXPECT_THROW(parser.parse("10 / 0"), std::invalid_argument);
    EXPECT_THROW(parser.parse("10 a 20"), std::invalid_argument);
}

// tests/IntegrationTest.cpp
#include <gtest/gtest.h>
#include "Parser.h"

// 测试 Parser 和 Calculator 的集成功能
TEST(IntegrationTest, CalculateTest) {
    Parser parser;
    EXPECT_EQ(parser.parse("10 + 20"), 30);
    EXPECT_EQ(parser.parse("20 - 10"), 10);
    EXPECT_EQ(parser.parse("10 * 20"), 200);
    EXPECT_EQ(parser.parse("20 / 10"), 2);
    EXPECT_THROW(parser.parse("10 / 0"), std::invalid_argument);
}

# CMakeLists.txt
cmake_minimum_required(VERSION 3.10)
project(CalculatorProject)

set(CMAKE_CXX_STANDARD 17)

# 添加头文件搜索路径
include_directories(include)

# 添加源文件
add_library(Calculator src/Calculator.cpp)
add_library(Parser src/Parser.cpp)

# 添加主程序
add_executable(CalculatorApp src/main.cpp)
target_link_libraries(CalculatorApp Calculator Parser)

# 添加测试
add_subdirectory(tests)

# tests/CMakeLists.txt
cmake_minimum_required(VERSION 3.10)

# 查找 Google Test 库
find_package(GTest REQUIRED)
include_directories(${GTEST_INCLUDE_DIRS})

# 添加测试源文件
add_executable(CalculatorTests CalculatorTest.cpp ParserTest.cpp IntegrationTest.cpp)

# 链接 Google Test 库和项目库
target_link_libraries(CalculatorTests ${GTEST_LIBRARIES} Calculator Parser pthread)

# 添加测试到 CTest
include(GoogleTest)
gtest_discover_tests(CalculatorTests)

6.3 项目构建与测试

# 创建构建目录
mkdir -p build && cd build

# 配置 CMake
cmake ..

# 编译项目
make

# 运行测试
ctest

七、总结与练习

7.1 本章总结

本章介绍了 C++ 测试与调试的核心知识，包括：

1. 测试的基本概念与分类
2. 单元测试框架 Google Test 和 Catch2 的使用
3. 调试工具 GDB 和 Visual Studio 调试器的使用
4. 集成测试的基本概念与方法
5. 综合案例：实现一个简单的计算器并进行测试

7.2 练习题

1. 写一个程序，使用 Google Test 测试一个简单的链表数据结构。
2. 编写一个函数，使用 GDB 调试一个内存泄漏的程序。
3. 写一个程序，使用 Visual Studio 调试器调试一个多线程程序。
4. 实现一个类，使用 Catch2 测试其功能。
5. 写一个程序，使用集成测试测试一个简单的银行账户系统。

7.3 进阶挑战

1. 研究如何使用 C++ 的模拟框架（如 Google Mock）进行单元测试。
2. 学习如何使用 C++ 的性能测试工具（如 Google Benchmark）进行性能测试。
3. 研究如何使用 C++ 的代码覆盖率工具（如 gcov）进行测试。
4. 学习如何使用 C++ 的静态分析工具（如 Clang Static Analyzer）进行代码检查。
5. 研究如何使用 C++ 的持续集成工具（如 GitHub Actions）自动化测试过程。