使用示例：C++ 项目 Google Test 单元测试

本文档演示如何使用 Vibe Kanban 编排多个 AI 代理，为 C++ 项目编写基于 Google Test 框架的单元测试。

场景背景

假设你有一个 C++ 项目，包含以下模块：

my-cpp-project/
├── src/
│   ├── core/
│   │   ├── Engine.cpp
│   │   ├── Engine.h
│   │   ├── Config.cpp
│   │   └── Config.h
│   ├── utils/
│   │   ├── StringUtils.cpp
│   │   ├── StringUtils.h
│   │   ├── MathUtils.cpp
│   │   ├── MathUtils.h
│   │   ├── FileUtils.cpp
│   │   └── FileUtils.h
│   ├── network/
│   │   ├── HttpClient.cpp
│   │   ├── HttpClient.h
│   │   ├── TcpServer.cpp
│   │   └── TcpServer.h
│   └── data/
│       ├── JsonParser.cpp
│       ├── JsonParser.h
│       ├── Database.cpp
│       └── Database.h
├── include/
│   └── myproject/
│       └── api.h
├── tests/                    # 当前为空，需要编写测试
├── CMakeLists.txt
└── conanfile.txt            # 或 vcpkg.json

目标：使用 Google Test 框架为整个项目编写单元测试，目标覆盖率 80%+。

挑战：

C++ 项目模块依赖复杂
需要正确配置 CMake 和 Google Test
不同模块需要不同的 Mock 策略（如网络、文件 I/O）
需要处理 C++ 特有的内存管理测试

安全约束：

⛔ 禁止修改 src/ 和 include/ 目录下的任何源代码
✅ 只允许在 tests/ 目录下创建和修改测试文件
✅ 只允许修改 CMakeLists.txt 添加测试目标
⛔ 如发现源代码 bug，只记录不修复

解决方案：使用 Vibe Kanban 编排多个 AI 代理并行工作。

Google Test 环境准备

CMakeLists.txt 测试配置

cmake

cmake_minimum_required(VERSION 3.14)
project(MyProject VERSION 1.0.0 LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# 主项目源文件
add_library(myproject_lib
    src/core/Engine.cpp
    src/core/Config.cpp
    src/utils/StringUtils.cpp
    src/utils/MathUtils.cpp
    src/utils/FileUtils.cpp
    src/network/HttpClient.cpp
    src/network/TcpServer.cpp
    src/data/JsonParser.cpp
    src/data/Database.cpp
)

target_include_directories(myproject_lib PUBLIC
    ${CMAKE_CURRENT_SOURCE_DIR}/src
    ${CMAKE_CURRENT_SOURCE_DIR}/include
)

# ========== 测试配置 ==========
enable_testing()

# 获取 Google Test
include(FetchContent)
FetchContent_Declare(
    googletest
    GIT_REPOSITORY https://github.com/google/googletest.git
    GIT_TAG v1.14.0
)
FetchContent_MakeAvailable(googletest)

# 测试可执行文件
add_executable(unit_tests
    tests/main.cpp
    tests/core/EngineTest.cpp
    tests/core/ConfigTest.cpp
    tests/utils/StringUtilsTest.cpp
    tests/utils/MathUtilsTest.cpp
    tests/utils/FileUtilsTest.cpp
    tests/network/HttpClientTest.cpp
    tests/network/TcpServerTest.cpp
    tests/data/JsonParserTest.cpp
    tests/data/DatabaseTest.cpp
)

target_link_libraries(unit_tests
    myproject_lib
    GTest::gtest
    GTest::gtest_main
    GTest::gmock
    GTest::gmock_main
)

include(GoogleTest)
gtest_discover_tests(unit_tests)

测试主文件 (tests/main.cpp)

cpp

#include <gtest/gtest.h>

int main(int argc, char **argv) {
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}

工作流设计

整体流程图

┌─────────────────────────────────────────────────────────────────────┐
│                    Vibe Kanban - C++ Unit Testing                   │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  阶段 1: 分析        阶段 2: 规划        阶段 3: 编写               │
│  ┌──────────┐       ┌──────────┐       ┌──────────┐                │
│  │ C++ 代码 │──────▶│ 测试策略 │──────▶│ 并行编写 │                │
│  │ 结构分析 │       │ & Mock   │       │ GTest    │                │
│  └──────────┘       └──────────┘       └────┬─────┘                │
│       │                  │                  │                       │
│       ▼                  ▼                  ▼                       │
│  Claude Code        Claude Code      ┌─────────────┐               │
│  (分析头文件)       (设计 Mock)      │ Claude Code │ Utils         │
│                                      │ Gemini CLI  │ Network       │
│                                      │ Codex CLI   │ Data          │
│                                      └─────────────┘               │
│                                                                     │
│  阶段 4: 集成        阶段 5: 修复                                   │
│  ┌──────────┐       ┌──────────┐                                   │
│  │ CMake    │──────▶│ 编译运行 │                                   │
│  │ 集成测试 │       │ 修复失败 │                                   │
│  └──────────┘       └──────────┘                                   │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

代理分工策略

阶段	任务	推荐代理	理由
1. 分析	C++ 代码结构分析	Claude Code	理解复杂的 C++ 模板和继承
2. 规划	测试策略 & GMock 设计	Claude Code	设计 Mock 接口和依赖注入
3. 编写	Utils 层测试	Codex CLI	纯函数测试，快速生成
3. 编写	Network 层测试	Claude Code	复杂的异步和 Mock 场景
3. 编写	Data 层测试	Gemini CLI	数据解析测试
3. 编写	Core 层测试	Claude Code	核心业务逻辑
4. 集成	CMake 配置	Claude Code	构建系统集成
5. 修复	编译运行并修复	Claude Code	处理 C++ 编译错误

详细操作步骤

步骤 1：配置 MCP 服务

json

{
  "mcp": {
    "servers": {
      "filesystem": {
        "type": "local",
        "command": ["mcp-server-filesystem"],
        "args": ["--root", "/path/to/my-cpp-project"],
        "enabled": true,
        "permissions": {
          "read": ["src/**/*", "include/**/*", "tests/**/*", "CMakeLists.txt"],
          "write": ["tests/**/*", "CMakeLists.txt"],
          "deny_write": ["src/**/*", "include/**/*"]
        }
      },
      "cmake-runner": {
        "type": "local",
        "command": ["mcp-server-shell"],
        "args": ["--allowed-commands", "cmake,make,ctest,./unit_tests"],
        "enabled": true
      }
    }
  },
  "constraints": {
    "protected_paths": ["src/**/*", "include/**/*"],
    "writable_paths": ["tests/**/*", "CMakeLists.txt"],
    "on_violation": "block_and_warn"
  }
}

步骤 2：创建代码分析任务

任务：C++ 代码结构分析

markdown

## 任务描述
分析 C++ 项目代码结构，识别类、函数、依赖关系。

## 交付物
1. 类继承关系图
2. 头文件依赖图
3. 需要 Mock 的接口清单
4. 每个类的公开方法列表
5. 模板类/函数识别

## ⚠️ 约束条件
- 只读访问，禁止修改任何文件
- 重点分析 .h 头文件中的公开接口

## 提示词
请分析这个 C++ 项目的代码结构：
1. 列出所有类及其继承关系
2. 识别虚函数和纯虚函数（可 Mock 的接口）
3. 找出外部依赖（网络、文件 I/O、数据库）
4. 标注哪些函数是 const 成员函数
5. 识别模板类和模板函数
6. 分析构造函数和析构函数的复杂度

重要：只读分析，不修改任何代码。

步骤 3：创建 Mock 策略任务

任务：Google Mock 策略设计

markdown

## 任务描述
基于代码分析，设计 GMock 接口和依赖注入策略。

## 交付物
1. 需要 Mock 的接口列表
2. GMock 类定义模板
3. 依赖注入点识别
4. 测试 Fixture 设计

## ⚠️ 约束条件
- 禁止修改 src/ 和 include/ 目录
- 只能设计，不能实际创建文件

## 提示词
基于代码分析结果，设计 Google Mock 策略：

1. 为以下接口设计 Mock 类：
   - HttpClient（网络请求）
   - Database（数据库操作）
   - FileUtils（文件 I/O）

2. 设计依赖注入方式：
   - 构造函数注入
   - Setter 注入
   - 模板参数注入

3. 设计测试 Fixture：
   - 共享的 SetUp/TearDown
   - 参数化测试基类

示例 Mock 类模板：
```cpp
class MockHttpClient : public IHttpClient {
public:
    MOCK_METHOD(Response, Get, (const std::string& url), (override));
    MOCK_METHOD(Response, Post, (const std::string& url, const std::string& body), (override));
};

重要：只设计策略，不修改源代码。


### 步骤 4：创建并行测试编写任务

#### 任务 4.1：Utils 层测试

```markdown
## 任务描述
为 utils/ 目录下的工具类编写 Google Test 单元测试。

## 范围
- src/utils/StringUtils.h/.cpp
- src/utils/MathUtils.h/.cpp
- src/utils/FileUtils.h/.cpp

## 测试要求
- 使用 Google Test 框架
- 使用 TEST() 或 TEST_F() 宏
- 使用 EXPECT_* 和 ASSERT_* 断言
- 使用参数化测试 (TEST_P) 覆盖多种输入

## ⚠️ 约束条件
- ⛔ 禁止修改 src/ 目录下的任何文件
- ✅ 只能在 tests/utils/ 目录下创建测试文件
- ⛔ 即使测试失败也不能修改源代码
- 📝 如发现源代码 bug，记录到 BUG_REPORT.md

## 提示词
请为 StringUtils 编写 Google Test 单元测试：

```cpp
// tests/utils/StringUtilsTest.cpp
#include <gtest/gtest.h>
#include "utils/StringUtils.h"

// 基础测试
TEST(StringUtilsTest, TrimRemovesLeadingSpaces) {
    EXPECT_EQ(StringUtils::Trim("  hello"), "hello");
}

// 参数化测试
class StringUtilsTrimTest : public ::testing::TestWithParam<std::pair<std::string, std::string>> {};

TEST_P(StringUtilsTrimTest, TrimVariousInputs) {
    auto [input, expected] = GetParam();
    EXPECT_EQ(StringUtils::Trim(input), expected);
}

INSTANTIATE_TEST_SUITE_P(
    TrimTests,
    StringUtilsTrimTest,
    ::testing::Values(
        std::make_pair("  hello", "hello"),
        std::make_pair("hello  ", "hello"),
        std::make_pair("  hello  ", "hello"),
        std::make_pair("", ""),
        std::make_pair("   ", "")
    )
);

重要约束：你只能创建测试文件，绝对不能修改 src/ 下的源代码。


**指派代理**：Codex CLI (Build 模式)

#### 任务 4.2：Network 层测试

```markdown
## 任务描述
为 network/ 目录下的网络类编写 Google Test + GMock 单元测试。

## 范围
- src/network/HttpClient.h/.cpp
- src/network/TcpServer.h/.cpp

## 测试要求
- 使用 Google Mock 模拟网络操作
- 测试异步回调场景
- 测试错误处理（超时、连接失败）
- 测试重试逻辑

## ⚠️ 约束条件
- ⛔ 禁止修改 src/ 目录下的任何文件
- ✅ 只能在 tests/network/ 目录下创建测试文件
- ⛔ 即使测试失败也不能修改源代码
- 📝 如发现源代码 bug，记录到 BUG_REPORT.md

## 提示词
请为 HttpClient 编写 Google Test + GMock 单元测试：

```cpp
// tests/network/HttpClientTest.cpp
#include <gtest/gtest.h>
#include <gmock/gmock.h>
#include "network/HttpClient.h"

using ::testing::_;
using ::testing::Return;
using ::testing::Throw;

// Mock 底层 Socket
class MockSocket : public ISocket {
public:
    MOCK_METHOD(bool, Connect, (const std::string& host, int port), (override));
    MOCK_METHOD(std::string, Send, (const std::string& data), (override));
    MOCK_METHOD(void, Close, (), (override));
};

class HttpClientTest : public ::testing::Test {
protected:
    void SetUp() override {
        mockSocket = std::make_shared<MockSocket>();
        client = std::make_unique<HttpClient>(mockSocket);
    }

    std::shared_ptr<MockSocket> mockSocket;
    std::unique_ptr<HttpClient> client;
};

TEST_F(HttpClientTest, GetReturnsResponseOnSuccess) {
    EXPECT_CALL(*mockSocket, Connect("example.com", 80))
        .WillOnce(Return(true));
    EXPECT_CALL(*mockSocket, Send(_))
        .WillOnce(Return("HTTP/1.1 200 OK\r\n\r\nHello"));

    auto response = client->Get("http://example.com/");
    EXPECT_EQ(response.statusCode, 200);
}

TEST_F(HttpClientTest, GetThrowsOnConnectionFailure) {
    EXPECT_CALL(*mockSocket, Connect(_, _))
        .WillOnce(Return(false));

    EXPECT_THROW(client->Get("http://example.com/"), ConnectionException);
}

重要约束：你只能创建测试文件，绝对不能修改 src/ 下的源代码。


**指派代理**：Claude Code (Build 模式)

#### 任务 4.3：Data 层测试

```markdown
## 任务描述
为 data/ 目录下的数据处理类编写 Google Test 单元测试。

## 范围
- src/data/JsonParser.h/.cpp
- src/data/Database.h/.cpp

## 测试要求
- 测试 JSON 解析的各种场景
- Mock 数据库连接
- 测试事务处理
- 测试错误数据处理

## ⚠️ 约束条件
- ⛔ 禁止修改 src/ 目录下的任何文件
- ✅ 只能在 tests/data/ 目录下创建测试文件
- ⛔ 即使测试失败也不能修改源代码
- 📝 如发现源代码 bug，记录到 BUG_REPORT.md

## 提示词
请为 JsonParser 编写 Google Test 单元测试：

```cpp
// tests/data/JsonParserTest.cpp
#include <gtest/gtest.h>
#include "data/JsonParser.h"

class JsonParserTest : public ::testing::Test {
protected:
    JsonParser parser;
};

TEST_F(JsonParserTest, ParseValidJsonObject) {
    auto result = parser.Parse(R"({"name": "test", "value": 42})");
    ASSERT_TRUE(result.has_value());
    EXPECT_EQ(result->GetString("name"), "test");
    EXPECT_EQ(result->GetInt("value"), 42);
}

TEST_F(JsonParserTest, ParseInvalidJsonReturnsNullopt) {
    auto result = parser.Parse("{invalid json}");
    EXPECT_FALSE(result.has_value());
}

TEST_F(JsonParserTest, ParseNestedObject) {
    auto result = parser.Parse(R"({"outer": {"inner": "value"}})");
    ASSERT_TRUE(result.has_value());
    auto inner = result->GetObject("outer");
    EXPECT_EQ(inner.GetString("inner"), "value");
}

// 边界测试
TEST_F(JsonParserTest, ParseEmptyString) {
    auto result = parser.Parse("");
    EXPECT_FALSE(result.has_value());
}

TEST_F(JsonParserTest, ParseLargeJson) {
    std::string largeJson = GenerateLargeJson(10000);  // 10000 个元素
    auto result = parser.Parse(largeJson);
    EXPECT_TRUE(result.has_value());
}

重要约束：你只能创建测试文件，绝对不能修改 src/ 下的源代码。


**指派代理**：Gemini CLI (Build 模式)

#### 任务 4.4：Core 层测试

```markdown
## 任务描述
为 core/ 目录下的核心类编写 Google Test 单元测试。

## 范围
- src/core/Engine.h/.cpp
- src/core/Config.h/.cpp

## 测试要求
- 测试引擎初始化和生命周期
- 测试配置加载和验证
- Mock 外部依赖
- 测试状态转换

## ⚠️ 约束条件
- ⛔ 禁止修改 src/ 目录下的任何文件
- ✅ 只能在 tests/core/ 目录下创建测试文件
- ⛔ 即使测试失败也不能修改源代码
- 📝 如发现源代码 bug，记录到 BUG_REPORT.md

## 提示词
请为 Engine 和 Config 编写 Google Test 单元测试：

```cpp
// tests/core/EngineTest.cpp
#include <gtest/gtest.h>
#include <gmock/gmock.h>
#include "core/Engine.h"

class MockDatabase : public IDatabase {
public:
    MOCK_METHOD(bool, Connect, (), (override));
    MOCK_METHOD(void, Disconnect, (), (override));
    MOCK_METHOD(QueryResult, Execute, (const std::string& sql), (override));
};

class EngineTest : public ::testing::Test {
protected:
    void SetUp() override {
        mockDb = std::make_shared<MockDatabase>();
        config = Config::Default();
    }

    std::shared_ptr<MockDatabase> mockDb;
    Config config;
};

TEST_F(EngineTest, InitializeSucceedsWithValidConfig) {
    EXPECT_CALL(*mockDb, Connect()).WillOnce(Return(true));

    Engine engine(config, mockDb);
    EXPECT_TRUE(engine.Initialize());
    EXPECT_EQ(engine.GetState(), Engine::State::Running);
}

TEST_F(EngineTest, InitializeFailsWhenDatabaseUnavailable) {
    EXPECT_CALL(*mockDb, Connect()).WillOnce(Return(false));

    Engine engine(config, mockDb);
    EXPECT_FALSE(engine.Initialize());
    EXPECT_EQ(engine.GetState(), Engine::State::Error);
}

TEST_F(EngineTest, ShutdownReleasesResources) {
    EXPECT_CALL(*mockDb, Connect()).WillOnce(Return(true));
    EXPECT_CALL(*mockDb, Disconnect()).Times(1);

    Engine engine(config, mockDb);
    engine.Initialize();
    engine.Shutdown();

    EXPECT_EQ(engine.GetState(), Engine::State::Stopped);
}

重要约束：你只能创建测试文件，绝对不能修改 src/ 下的源代码。


**指派代理**：Claude Code (Build 模式)

### 步骤 5：创建 CMake 集成任务

**任务：CMake 测试集成**

```markdown
## 任务描述
更新 CMakeLists.txt，集成所有测试文件。

## ⚠️ 约束条件
- ✅ 只能修改 CMakeLists.txt 的测试部分
- ⛔ 不能修改主项目的编译配置
- ⛔ 不能修改 src/ 或 include/ 下的文件

## 提示词
更新 CMakeLists.txt 添加测试目标：

1. 添加所有测试源文件
2. 配置 Google Test 依赖
3. 启用 CTest 发现
4. 添加覆盖率配置（可选）

确保测试可以通过以下命令运行：
```bash
mkdir build && cd build
cmake ..
make
ctest --output-on-failure


### 步骤 6：创建编译运行任务

**任务：编译运行并修复测试**

```markdown
## 任务描述
编译项目，运行测试，修复编译错误和失败的测试。

## ⚠️ 约束条件
- ⛔ 禁止修改 src/ 目录下的任何文件
- ✅ 只能修复 tests/ 目录下的测试代码
- 📝 如发现源代码 bug，记录到 BUG_REPORT.md

## 执行步骤
1. 运行 cmake 配置
2. 编译项目
3. 运行 ctest
4. 分析失败原因
5. 修复测试代码（不修改源代码）
6. 重复直到全部通过

## 提示词
请执行以下操作：

```bash
# 配置和编译
mkdir -p build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Debug
make -j$(nproc)

# 运行测试
ctest --output-on-failure

# 生成覆盖率报告（如果配置了）
make coverage

分析失败原因时：

如果是编译错误 → 检查头文件包含和链接
如果是断言失败 → 检查预期值是否正确
如果是 Mock 配置错误 → 检查 EXPECT_CALL 设置
如果是源代码 bug → 记录但不修改，调整测试预期

重要：只能修复测试代码，不能修改源代码。


## 完整工作流配置文件

```yaml
# vibe-kanban-cpp-testing.yaml
name: "C++ Google Test Workflow"
description: "Multi-agent workflow for C++ unit testing with Google Test"

# 全局约束配置
constraints:
  protected_paths:
    - "src/**/*"
    - "include/**/*"
  writable_paths:
    - "tests/**/*"
    - "CMakeLists.txt"
    - "BUG_REPORT.md"
  on_violation: "block_and_warn"
  violation_message: "⛔ 禁止修改源代码！只能在 tests/ 目录下创建测试文件。"

stages:
  - name: analyze
    description: "C++ 代码结构分析"
    agent: claude-code
    mode: plan
    timeout: 15m
    constraints:
      read_only: true

  - name: mock-design
    description: "GMock 策略设计"
    agent: claude-code
    mode: plan
    depends_on: [analyze]
    timeout: 15m
    constraints:
      read_only: true

  - name: write-tests
    description: "并行编写测试"
    parallel: true
    depends_on: [mock-design]
    tasks:
      - name: utils
        agent: codex-cli
        mode: build
        scope: "src/utils/**/*"
        output_dir: "tests/utils/"
        timeout: 25m

      - name: network
        agent: claude-code
        mode: build
        scope: "src/network/**/*"
        output_dir: "tests/network/"
        timeout: 30m

      - name: data
        agent: gemini-cli
        mode: build
        scope: "src/data/**/*"
        output_dir: "tests/data/"
        timeout: 25m

      - name: core
        agent: claude-code
        mode: build
        scope: "src/core/**/*"
        output_dir: "tests/core/"
        timeout: 30m

  - name: cmake-integration
    description: "CMake 集成"
    agent: claude-code
    mode: build
    depends_on: [write-tests]
    timeout: 10m
    constraints:
      writable_paths: ["CMakeLists.txt"]

  - name: build-and-fix
    description: "编译运行并修复"
    agent: claude-code
    mode: build
    depends_on: [cmake-integration]
    timeout: 45m
    constraints:
      writable_paths: ["tests/**/*"]
    commands:
      - "cmake -B build -DCMAKE_BUILD_TYPE=Debug"
      - "cmake --build build"
      - "ctest --test-dir build --output-on-failure"

success_criteria:
  all_tests_pass: true
  source_code_unchanged: true
  coverage: 80

Google Test 最佳实践

1. 测试命名规范

cpp

// 格式：TEST(TestSuiteName, TestName)
// TestSuiteName: 被测试的类或模块名 + Test
// TestName: 描述测试场景，使用驼峰命名

TEST(StringUtilsTest, TrimRemovesLeadingAndTrailingSpaces)
TEST(HttpClientTest, GetThrowsExceptionOnTimeout)
TEST(JsonParserTest, ParseReturnsNulloptForInvalidInput)

2. 断言选择指南

场景	使用断言	说明
关键前置条件	`ASSERT_*`	失败时终止测试
一般验证	`EXPECT_*`	失败时继续执行
比较值	`EXPECT_EQ/NE/LT/GT`	提供详细失败信息
浮点数比较	`EXPECT_NEAR/FLOAT_EQ`	处理精度问题
字符串	`EXPECT_STREQ/STRNE`	C 风格字符串
异常	`EXPECT_THROW/NO_THROW`	异常测试

3. GMock 使用模式

cpp

// 设置期望
EXPECT_CALL(mockObj, Method(Arg1, Arg2))
    .Times(n)                    // 调用次数
    .WillOnce(Return(value))     // 首次返回
    .WillRepeatedly(Return(v2))  // 后续返回
    .WillOnce(Throw(exception)); // 抛出异常

// 参数匹配器
EXPECT_CALL(mock, Method(_))              // 任意参数
EXPECT_CALL(mock, Method(Gt(5)))          // 大于 5
EXPECT_CALL(mock, Method(HasSubstr("x"))) // 包含子串

4. 测试 Fixture 模式

cpp

class DatabaseTest : public ::testing::Test {
protected:
    // 每个测试前执行
    void SetUp() override {
        db = std::make_unique<MockDatabase>();
        // 初始化...
    }

    // 每个测试后执行
    void TearDown() override {
        db.reset();
    }

    // 共享资源
    std::unique_ptr<MockDatabase> db;
};

5. 代码保护策略

yaml

# 三层防护机制
protection:
  # 层级 1：MCP 文件系统权限
  mcp_permissions:
    deny_write: ["src/**/*", "include/**/*"]

  # 层级 2：工作流约束
  workflow_constraints:
    protected_paths: ["src/**/*", "include/**/*"]
    on_violation: "block_and_warn"

  # 层级 3：Git 预检查
  git_hooks:
    pre_commit: |
      if git diff --name-only | grep -qE '^(src|include)/'; then
        echo "Error: Source code modification detected!"
        exit 1
      fi

预期成果

指标	传统方式	Vibe Kanban
完成时间	16-24 小时	4-6 小时
覆盖率	50-60%	80-90%
Mock 完整性	容易遗漏	全面设计
编译错误	频繁调试	系统化处理

最终测试结构

tests/
├── main.cpp                    # 测试入口
├── core/
│   ├── EngineTest.cpp         # Claude Code
│   └── ConfigTest.cpp         # Claude Code
├── utils/
│   ├── StringUtilsTest.cpp    # Codex CLI
│   ├── MathUtilsTest.cpp      # Codex CLI
│   └── FileUtilsTest.cpp      # Codex CLI
├── network/
│   ├── HttpClientTest.cpp     # Claude Code
│   └── TcpServerTest.cpp      # Claude Code
├── data/
│   ├── JsonParserTest.cpp     # Gemini CLI
│   └── DatabaseTest.cpp       # Gemini CLI
├── mocks/
│   ├── MockDatabase.h
│   ├── MockHttpClient.h
│   └── MockFileSystem.h
└── fixtures/
    └── TestFixtures.h

下一步

多代理协作编写单元测试（Node.js） - 查看 Node.js 版本示例
多代理编排 - 深入了解代理编排配置
MCP 配置管理 - 学习 MCP 服务配置

使用示例：C++ 项目 Google Test 单元测试 ​

场景背景 ​

Google Test 环境准备 ​

CMakeLists.txt 测试配置 ​

测试主文件 (tests/main.cpp) ​

工作流设计 ​

整体流程图 ​

代理分工策略 ​

详细操作步骤 ​

步骤 1：配置 MCP 服务 ​

步骤 2：创建代码分析任务 ​

步骤 3：创建 Mock 策略任务 ​

Google Test 最佳实践 ​

1. 测试命名规范 ​

2. 断言选择指南 ​

3. GMock 使用模式 ​

4. 测试 Fixture 模式 ​

5. 代码保护策略 ​

预期成果 ​

最终测试结构 ​

下一步 ​

使用示例：C++ 项目 Google Test 单元测试

场景背景

Google Test 环境准备

CMakeLists.txt 测试配置

测试主文件 (tests/main.cpp)

工作流设计

整体流程图

代理分工策略

详细操作步骤

步骤 1：配置 MCP 服务

步骤 2：创建代码分析任务

步骤 3：创建 Mock 策略任务

Google Test 最佳实践

1. 测试命名规范

2. 断言选择指南

3. GMock 使用模式

4. 测试 Fixture 模式

5. 代码保护策略

预期成果

最终测试结构

下一步