详细介绍 C++ 单元测试框架 Google Test (gtest) 的使用。内容包括 Linux 和 Windows 环境下的安装配置方法，核心概念如测试套件与测试用例的定义，以及致命与非致命断言的区别。重点讲解了测试夹具（Fixture）的生命周期管理、参数化测试和死亡测试等进阶功能。通过字符串工具类的实战案例，演示了从编写测试代码到编译运行的完整流程，旨在帮助开发者构建可靠的测试体系并集成至 CI/CD 流程。
gtest 是由 Google 开发的开源 C++ 单元测试框架，遵循 BSD 开源协议，支持 Linux、Windows、Mac 等多种操作系统，可与 CMake、Visual Studio、GCC 等主流开发工具和编译环境无缝集成。其核心优势包括：
gtest 的安装配置方式主要分为源码编译安装和包管理器安装，以下分别介绍 Linux（Ubuntu）和 Windows（Visual Studio）环境下的配置方法。
Ubuntu 系统可通过 apt-get 直接安装预编译的 gtest 包，命令如下：
sudo apt-get update
sudo apt-get install libgtest-dev
注意：libgtest-dev 仅安装源码和头文件，并未自动编译生成库文件，需手动编译：
cd /usr/src/gtest
sudo mkdir build && cd build
sudo cmake .
sudo make
sudo cp libgtest.a libgtest_main.a /usr/lib
从 GitHub 获取最新源码并编译安装：
git clone https://github.com/google/googletest.git
cd googletest
mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release
make -j4
sudo make install
在使用 gtest 前，需理解其两个核心概念：测试套件（Test Suite）和测试用例（Test Case）。
示例：
#include <gtest/gtest.h>
// 测试套件：Calculator（计算器模块）
// 测试用例：AddTest（加法功能测试）
TEST(Calculator, AddTest) {
// 断言：验证 1+1 是否等于 2
EXPECT_EQ(1 + 1, 2);
}
// 测试用例：SubtractTest（减法功能测试）
TEST(Calculator, SubtractTest) {
EXPECT_EQ(3 - 1, 2);
}
此外，gtest 还提供了测试夹具（Test Fixture）机制，用于处理多个测试用例的共享初始化和清理逻辑（如创建对象、打开文件、释放资源等），通过继承 testing::Test 类实现。
断言是 gtest 的核心功能，用于判断测试代码的执行结果是否符合预期。gtest 将断言分为两类：
推荐优先使用非致命断言，以便在一次测试中发现多个问题。以下是常用断言分类整理：
| 断言宏 | 说明 | 示例 |
|---|---|---|
| ASSERT_TRUE(condition) | 致命断言：condition 为真 | ASSERT_TRUE(1 > 0) |
| ASSERT_FALSE(condition) | 致命断言：condition 为假 | ASSERT_FALSE(1 < 0) |
| EXPECT_TRUE(condition) | 非致命断言：condition 为真 | EXPECT_TRUE(isEven(2)) |
| EXPECT_FALSE(condition) | 非致命断言：condition 为假 | EXPECT_FALSE(isEven(3)) |
| 断言宏 | 说明 | 示例 |
|---|---|---|
| ASSERT_EQ(a, b) | 致命断言：a == b（EQ=Equal） | ASSERT_EQ(2+3, 5) |
| ASSERT_NE(a, b) | 致命断言：a != b（NE=Not Equal） | ASSERT_NE(5, 6) |
| ASSERT_LT(a, b) | 致命断言：a < b（LT=Less Than） | ASSERT_LT(3, 5) |
| ASSERT_LE(a, b) | 致命断言：a <= b（LE=Less or Equal） | ASSERT_LE(4, 5) |
| ASSERT_GT(a, b) | 致命断言：a > b（GT=Greater Than） | ASSERT_GT(6, 5) |
| ASSERT_GE(a, b) | 致命断言：a >= b（GE=Greater or Equal） | ASSERT_GE(5, 5) |
注：EXPECT_系列对应的宏（如 EXPECT_EQ、EXPECT_NE）功能相同，仅为非致命断言。
| 断言宏 | 说明 | 示例 |
|---|---|---|
| ASSERT_STREQ(s1, s2) | 致命断言：C 风格字符串 s1 == s2（区分大小写） | ASSERT_STREQ("hello", "hello") |
| ASSERT_STRNE(s1, s2) | 致命断言：C 风格字符串 s1 != s2 | ASSERT_STRNE("hello", "world") |
| ASSERT_STRCASEEQ(s1, s2) | 致命断言：C 风格字符串 s1 == s2（不区分大小写） | ASSERT_STRCASEEQ("Hello", "hello") |
| EXPECT_STREQ(s1, s2) | 非致命断言：C 风格字符串 s1 == s2 | EXPECT_STREQ(getName(), "Alice") |
用于验证函数是否抛出预期的异常：
#include <gtest/gtest.h>
#include <stdexcept>
// 测试函数是否抛出 std::invalid_argument 异常
TEST(ExceptionTest, DivideByZero) {
auto divide = [](int a, int b) {
if (b == 0) {
throw std::invalid_argument("divide by zero");
}
return a / b;
};
// 断言：调用 divide(5, 0) 时抛出 std::invalid_argument 异常
ASSERT_THROW(divide(5, 0), std::invalid_argument);
// 断言：调用 divide(6, 2) 时不抛出异常
ASSERT_NO_THROW(divide(6, 2));
}
gtest 提供了三级测试环境的生命周期管理机制，通过重写不同的 SetUp（初始化）和 TearDown（清理）方法，可实现不同范围的资源管控。各环境的执行时机有明确区分，核心分为全局环境、局部环境和最小环境三类：
全局环境需通过 testing::AddGlobalTestEnvironment 方法注册才能生效；局部环境和最小环境则通过测试夹具类的重写实现，具体示例如下：
当多个测试用例需要共享初始化和清理逻辑时，使用测试夹具。步骤如下：
示例：测试计算器类的多个方法，结合全局环境、局部环境和最小环境实现资源的分级管控：
#include <gtest/gtest.h>
#include <iostream>
// 1. 全局环境类：继承 testing::Environment
class GlobalEnv : public testing::Environment {
public:
// 全局初始化：所有测试用例执行前执行一次
void SetUp() override {
std::cout << "全局环境 SetUp：执行所有测试前的初始化（如加载全局配置）" << std::endl;
}
// 全局清理：所有测试用例执行后执行一次
void TearDown() override {
std::cout << "全局环境 TearDown：执行所有测试后的清理（如释放全局资源）" << std::endl;
}
};
// 待测试的计算器类
class Calculator {
public:
int Add(int a, int b) { return a + b; }
int Subtract(int a, int b) { return a - b; }
int Multiply(int a, int b) { return a * b; }
int Divide(int a, int b) {
if (b == 0) throw std::invalid_argument("divide by zero");
return a / b;
}
};
// 2. 测试夹具类（含局部环境和最小环境）：继承 testing::Test
class CalculatorFixture : public testing::Test {
protected:
// 共享的计算器对象（最小环境使用）
Calculator calc;
// 局部环境 - 初始化：当前夹具的第一个测试用例执行前执行一次
static void SetUpTestCase() {
std::cout << "局部环境 SetUpTestCase：CalculatorFixture 测试套件执行前初始化（如创建共享测试数据）" << std::endl;
}
// 局部环境 - 清理：当前夹具的最后一个测试用例执行后执行一次
static void TearDownTestCase() {
std::cout << "局部环境 TearDownTestCase：CalculatorFixture 测试套件执行后清理（如删除共享测试数据）" << std::endl;
}
// 最小环境 - 初始化：每个测试用例执行前执行一次
void SetUp() override {
std::cout << "最小环境 SetUp：单个测试用例执行前初始化（如重置计算器状态）" << std::endl;
}
// 最小环境 - 清理：每个测试用例执行后执行一次
void TearDown() override {
std::cout << "最小环境 TearDown：单个测试用例执行后清理（如释放测试用例专属资源）" << std::endl;
}
};
// 注册全局环境（必须注册才能生效）
TEST(GlobalEnvTest, Register) {
testing::AddGlobalTestEnvironment(new GlobalEnv);
}
// 3. 测试夹具对应的测试用例
TEST_F(CalculatorFixture, AddTest) {
EXPECT_EQ(calc.Add(1, 2), 3);
EXPECT_EQ(calc.Add(-1, -2), -3);
}
TEST_F(CalculatorFixture, SubtractTest) {
EXPECT_EQ(calc.Subtract(5, 3), 2);
EXPECT_EQ(calc.Subtract(3, 5), -2);
}
TEST_F(CalculatorFixture, DivideTest) {
EXPECT_EQ(calc.Divide(6, 2), 3);
ASSERT_THROW(calc.Divide(5, 0), std::invalid_argument);
}
// 其他独立测试用例
TEST(OtherTest, Test1) {
std::cout << "执行独立测试用例 Test1" << std::endl;
EXPECT_TRUE(1 == 1);
}
TEST(OtherTest, Test3) {
std::cout << "执行独立测试用例 Test3" << std::endl;
EXPECT_FALSE(1 == 0);
}
// 主函数
int main(int argc, char **argv) {
testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
上述示例的执行顺序与输出说明：
通过这种分级管控机制，可精准控制不同范围资源的创建和释放时机，避免资源冗余占用，同时提升测试代码的可维护性。
当需要对同一功能使用多组输入数据进行测试时（如测试加法的多个输入对），可使用参数化测试，避免编写重复代码。步骤如下：
示例：测试加法的多组输入：
#include <gtest/gtest.h>
// 1. 定义参数类型：输入 a、输入 b、预期结果
struct AddParam {
int a;
int b;
int expected;
};
// 2. 定义参数化测试夹具
class AddParameterizedTest : public testing::TestWithParam<AddParam> {};
// 3. 使用 TEST_P 定义测试用例
TEST_P(AddParameterizedTest, MultipleAddCases) {
// 获取当前测试参数
AddParam param = GetParam();
// 待测试的加法逻辑
int result = param.a + param.b;
// 断言结果是否符合预期
EXPECT_EQ(result, param.expected);
}
// 4. 注册测试套件，指定参数列表
INSTANTIATE_TEST_SUITE_P(
AddTestCases, // 测试套件名称（自定义）
AddParameterizedTest, // 参数化测试夹具类名
testing::Values(
AddParam{1, 2, 3}, // 测试用例 1：1+2=3
AddParam{-1, -2, -3}, // 测试用例 2：-1+(-2)=-3
AddParam{0, 0, 0}, // 测试用例 3：0+0=0
AddParam{100, 200, 300} // 测试用例 4：100+200=300
)
);
死亡测试用于验证程序在特定条件下是否会正常退出（如断言失败、调用 exit()），gtest 通过 ASSERT_EXIT、EXPECT_EXIT 等宏实现。
示例：测试程序在断言失败时是否退出：
#include <gtest/gtest.h>
#include <cassert>
// 测试函数：当 x<0 时触发断言失败
void CheckPositive(int x) {
assert(x > 0); // 断言：x 必须为正数
}
TEST(DeathTest, AssertFailure) {
// 断言：调用 CheckPositive(-1) 时，程序正常退出（退出码非 0）
ASSERT_EXIT(
CheckPositive(-1), // 待测试的代码
testing::KilledBySignal(SIGABRT), // 预期：被 SIGABRT 信号终止（断言失败信号）
"" // 预期的输出信息（为空表示不检查）
);
}
gtest 需要在 main 函数中初始化并运行测试，可直接使用 gtest 提供的默认 main 函数（需链接 gtest_main.lib），也可自定义 main 函数：
#include <gtest/gtest.h>
// 自定义 main 函数（可选）
int main(int argc, char **argv) {
testing::InitGoogleTest(&argc, argv); // 初始化 gtest
return RUN_ALL_TESTS(); // 运行所有测试用例
}
以 Linux 环境为例，假设有测试文件 calc_test.cpp，编译命令如下：
g++ calc_test.cpp -o calc_test -lgtest -lpthread
./calc_test
运行测试程序后，gtest 会输出详细的测试报告，示例如下：
[==========] Running 5 tests from 2 test suites.
[----------] Global test environment set-up.
[----------] 3 tests from AddTestCases/AddParameterizedTest
[ RUN ] AddTestCases/AddParameterizedTest.MultipleAddCases/0
[ OK ] AddTestCases/AddParameterizedTest.MultipleAddCases/0 (0 ms)
[ RUN ] AddTestCases/AddParameterizedTest.MultipleAddCases/1
[ OK ] AddTestCases/AddParameterizedTest.MultipleAddCases/1 (0 ms)
[ RUN ] AddTestCases/AddParameterizedTest.MultipleAddCases/2
[ OK ] AddTestCases/AddParameterizedTest.MultipleAddCases/2 (0 ms)
[----------] 3 tests from AddTestCases/AddParameterizedTest (0 ms total)
[----------] 2 tests from CalculatorFixture
[ RUN ] CalculatorFixture.DivideTest
[ OK ] CalculatorFixture.DivideTest (0 ms)
[ RUN ] CalculatorFixture.SubtractTest
[ OK ] CalculatorFixture.SubtractTest (0 ms)
[----------] 2 tests from CalculatorFixture (0 ms total)
[----------] Global test environment tear-down
[==========] 5 tests passed.
[ PASSED ] 5 tests.
报告关键信息：
[==========]：测试开始/结束的分隔线。[ RUN ]：正在执行的测试用例。[ OK ]：测试用例执行成功。[ FAILED ]：测试用例执行失败，会显示失败的断言位置和原因。当测试用例较多时，可通过命令行参数过滤需要执行的测试用例：
# 只执行测试套件为 CalculatorFixture 的所有测试用例
./calc_test --gtest_filter=CalculatorFixture.*
# 只执行测试用例名称包含 Add 的测试
./calc_test --gtest_filter=*Add*
# 排除某个测试用例
./calc_test --gtest_filter=-CalculatorFixture.DivideTest
以下通过实战案例，完整演示 gtest 的使用流程：测试一个简单的字符串工具类 StringUtil，包含字符串拼接、判空、转大写三个功能。
#pragma once
#include <string>
class StringUtil {
public:
// 字符串拼接
static std::string Concat(const std::string& a, const std::string& b) {
return a + b;
}
// 判断字符串是否为空（空字符串或全空格）
static bool IsEmpty(const std::string& s) {
for (char c : s) {
if (!isspace(static_cast<unsigned char>(c))) {
return false;
}
}
return true;
}
// 字符串转大写
static std::string ToUpper(const std::string& s) {
std::string result;
for (char c : s) {
result += toupper(static_cast<unsigned char>(c));
}
return result;
}
};
#include <gtest/gtest.h>
#include "string_util.h"
// 测试套件：StringUtil
// 测试用例：ConcatTest（拼接功能测试）
TEST(StringUtil, ConcatTest) {
EXPECT_EQ(StringUtil::Concat("hello", "world"), "helloworld");
EXPECT_EQ(StringUtil::Concat("", "test"), "test");
EXPECT_EQ(StringUtil::Concat("test", ""), "test");
EXPECT_EQ(StringUtil::Concat("a", "b"), "ab");
}
// 测试用例：IsEmptyTest（判空功能测试）
TEST(StringUtil, IsEmptyTest) {
EXPECT_TRUE(StringUtil::IsEmpty("")); // 空字符串
EXPECT_TRUE(StringUtil::IsEmpty(" ")); // 全空格
EXPECT_FALSE(StringUtil::IsEmpty("hello")); // 非空字符串
EXPECT_FALSE(StringUtil::IsEmpty(" test ")); // 包含非空格字符
}
// 测试用例：ToUpperTest（转大写功能测试）
TEST(StringUtil, ToUpperTest) {
EXPECT_EQ(StringUtil::ToUpper("hello"), "HELLO");
EXPECT_EQ(StringUtil::ToUpper("World"), "WORLD");
EXPECT_EQ(StringUtil::ToUpper("123abc"), "123ABC");
EXPECT_EQ(StringUtil::ToUpper(""), "");
EXPECT_EQ(StringUtil::ToUpper(" test "), " TEST ");
}
// 主函数
int main(int argc, char **argv) {
testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
g++ string_util_test.cpp -o string_util_test -lgtest -lpthread -std=c++11
./string_util_test
[==========] Running 3 tests from 1 test suite.
[----------] Global test environment set-up.
[----------] 3 tests from StringUtil
[ RUN ] StringUtil.ConcatTest
[ OK ] StringUtil.ConcatTest (0 ms)
[ RUN ] StringUtil.IsEmptyTest
[ OK ] StringUtil.IsEmptyTest (0 ms)
[ RUN ] StringUtil.ToUpperTest
[ OK ] StringUtil.ToUpperTest (0 ms)
[----------] 3 tests from StringUtil (0 ms total)
[----------] Global test environment tear-down
[==========] 3 tests passed.
[ PASSED ] 3 tests.
所有测试用例执行成功，说明 StringUtil 类的三个功能符合预期。
本文详细介绍了 gtest 的安装配置、核心概念、常用断言及进阶功能，并通过实战案例演示了完整的测试流程。gtest 作为一款成熟的 C++ 单元测试框架，不仅能满足基础的单元测试需求，其参数化测试、测试夹具等高级功能还能大幅提升测试效率，适配复杂项目的测试场景。
扩展学习：
通过熟练掌握 gtest，开发者可以构建可靠的测试体系，提前发现代码中的问题，提升软件质量和开发效率。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML转Markdown 互为补充。 在线工具，Markdown转HTML在线工具，online
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML转Markdown在线工具，online
通过删除不必要的空白来缩小和压缩JSON。 在线工具，JSON 压缩在线工具，online
将JSON字符串修饰为友好的可读格式。 在线工具，JSON美化和格式化在线工具，online