Google Test Primer 详解:miniblink49 仓库内嵌 gtest 的 C++ 单元测试入门与实践

原创2026-09-17 16:44:502,213 阅读
文章标签:桌面应用UI组件图形学

Google Test Primer 详解:miniblink49 仓库内嵌 gtest 的 C++ 单元测试入门与实践

导读

本文以 miniblink49 仓库内嵌的 Google C++ Testing Framework(Google Test)1.5 入门文档(v8_7_5/testing/gtest/docs/V1_5_Primer.md)为骨架,系统讲解从零搭建测试工程、编写断言、组织测试用例与测试夹具、以及驱动 main() 运行的全部基础技能。miniblink49 作为一个轻量 Blink 浏览器内核,其依赖的 v8_7_5 目录完整携带了 gtest 源码、头文件、构建脚本与示例程序,读完本文你将能在该仓库内直接定位并复用这些测试基础设施,为内核中的 C++ 模块编写独立、可重复、可移植的单元测试。

为什么要用 Google C++ Testing Framework

Google Test 帮助开发者写出更好的 C++ 测试。无论你在 Linux、Windows 还是 macOS 上工作,只要写 C++ 代码,Google Test 都能派上用场。原文档给出了它信奉的六条测试设计准则,也是理解整个框架设计动机的钥匙:

  1. 测试应当独立且可重复:Google Test 为每个测试创建独立的对象来隔离状态,测试失败时可以单独运行该测试快速调试;
  2. 测试应当组织良好并反映被测代码的结构:相关的测试被组织成 test case(测试用例组),可以共享数据和子程序,便于维护与跨项目协作;
  3. 测试应当可移植、可复用:框架可在不同操作系统、不同编译器(gcc、MSVC 等)、有无异常支持的环境下工作;
  4. 失败时提供尽可能多的信息:框架不会在第一个失败处停止,而是停止当前测试继续下一个;EXPECT_* 非致命断言失败后当前测试还能继续,从而在一次"编辑-编译-运行"循环中发现并修复多个 bug;
  5. 把测试作者从家务活中解放出来:框架自动跟踪所有已定义的测试,无需手动枚举即可运行;
  6. 测试应当快速:通过跨测试复用共享资源,只为 setup/teardown 付一次代价,同时又不让测试相互依赖。

Google Test 基于流行的 xUnit 架构,用过 JUnit 或 PyUnit 的开发者会感到非常熟悉;没用过的话,大约 10 分钟就能掌握基础并开始使用。原文档也提示:Google Test 有时被非正式地称为 Google Test,正式名称是 Google C++ Testing Framework。

在 miniblink49 仓库中,gtest 以完整的第三方依赖形式内嵌于 v8_7_5/testing/gtest,包含 src/(框架实现)、include/(公共头文件)、samples/(示例程序)、docs/(从 1.5 到 1.7 的多版本文档)以及 make/、msvc/、xcode/、codegear/ 等多套构建文件,还提供了 BUILD.gn 以便接入 Chromium/V8 的 GN 构建体系。

搭建一个新的测试工程

编译 Google Test 库

要编写使用 Google Test 的测试程序,需要先把 Google Test 编译成库,再把测试链接进去。仓库为多种主流构建系统提供了现成构建文件:

  • msvc/:Visual Studio
  • xcode/:Mac Xcode
  • make/:GNU make
  • codegear/:Borland C++ Builder
  • 根目录的 autotools 脚本(configure.ac)

如果你的构建系统不在上述列表中,可以参考 make/Makefile 了解编译方式:本质上就是把 src/gtest-all.cc 编译成目标文件,并把 GTEST_ROOT 和 GTEST_ROOT/include 加入头文件搜索路径,其中 GTEST_ROOT 是 gtest 根目录。仓库中 make/Makefile 的核心片段印证了这一点:

GTEST_DIR = ..
USER_DIR = ../samples

# 把 Google Test 的头文件目录作为系统目录,避免编译警告
CPPFLAGS += -isystem $(GTEST_DIR)/include
CXXFLAGS += -g -Wall -Wextra -pthread

# 编译 gtest-all.cc 生成 gtest.a
gtest-all.o : $(GTEST_SRCS_)
	$(CXX) $(CPPFLAGS) -I$(GTEST_DIR) $(CXXFLAGS) -c \
            $(GTEST_DIR)/src/gtest-all.cc

gtest.a : gtest-all.o
	$(AR) $(ARFLAGS) $@ $^

# 链接 gtest_main.a 时,无需自己编写 main()(见后文)
gtest_main.a : gtest-all.o gtest_main.o
	$(AR) $(ARFLAGS) $@ $^

GN 构建体系下,BUILD.gn 同样暴露了 gtest(静态库)与 gtest_main(source set)两个目标,并注明 Chromium 代码必须通过该目标引用 gtest,而不是直接深入 //third_party/googletest 内部。

配置测试工程

库编译完成后,为你的测试程序创建工程或构建目标,并确保:

  • 头文件搜索路径中包含 GTEST_ROOT/include,让编译器在编译测试时能找到 <gtest/gtest.h>;
  • 测试工程链接 Google Test 库(例如在 Visual Studio 中通过添加对 gtest.vcproj 的依赖完成)。

如果还有疑问,可以看 Google Test 自带的测试是如何构建的,并把它们当作范例——仓库中的 samples 目录正是为此准备的。

基本概念

使用 Google Test 时,你从编写 assertion(断言) 开始——断言是检查某个条件是否为真的语句。断言结果有三种:success(成功)、nonfatal failure(非致命失败)、fatal failure(致命失败)。致命失败会中止当前函数,否则程序继续正常执行。

Test(测试) 用断言来验证被测代码的行为:如果测试崩溃或断言失败,则该测试 失败;否则 成功。

Test case(测试用例组) 包含一个或多个测试,你应该把测试按照被测代码的结构分组到 test case 中。当 test case 中的多个测试需要共享公共对象和子程序时,可以把它们放进 test fixture(测试夹具) 类。

Test program(测试程序) 可以包含多个 test case。

下面的内容从单个断言讲起,逐步上升到测试与测试用例组。

断言(Assertions)

Google Test 的断言是形似函数调用的宏。断言失败时,Google Test 会打印断言的源文件和行号,以及失败信息;你也可以通过流式语法追加自定义失败信息。

断言以成对形式出现,测试内容相同但对当前函数的影响不同:

  • ASSERT_* 失败时产生 致命失败,立即中止当前函数;
  • EXPECT_* 失败时产生 非致命失败,不中止当前函数。

通常优先使用 EXPECT_*,因为它允许在一次测试中报告多个失败;但当断言失败后继续执行没有意义时,应改用 ASSERT_*。

需要注意:失败的 ASSERT_* 会立即从当前函数返回,可能跳过其后的清理代码,从而造成空间泄漏(堆检查器可能报错,是否修复取决于泄漏性质)。

自定义失败消息

自定义失败消息只需用 << 运算符(或一串 <<)把内容流式传入宏:

ASSERT_EQ(x.size(), y.size()) << "Vectors x and y are of unequal length";

for (int i = 0; i < x.size(); ++i) {
  EXPECT_EQ(x[i], y[i]) << "Vectors x and y differ at index " << i;
}

任何能流向 ostream 的东西都可以流向断言宏——特别是 C 字符串和 string 对象。宽字符串(wchar_t*、Windows UNICODE 模式下的 TCHAR*、std::wstring)被打印时会转换为 UTF-8。

基础断言

这些断言做基本的真假条件测试:

致命断言 非致命断言 验证
ASSERT_TRUE(condition); EXPECT_TRUE(condition); condition 为真
ASSERT_FALSE(condition); EXPECT_FALSE(condition); condition 为假

可用平台:Linux、Windows、Mac。

二元比较断言

比较两个值的断言:

致命断言 非致命断言 验证
ASSERT_EQ(expected, actual); EXPECT_EQ(expected, actual); expected == actual
ASSERT_NE(val1, val2); EXPECT_NE(val1, val2); val1 != val2
ASSERT_LT(val1, val2); EXPECT_LT(val1, val2); val1 < val2
ASSERT_LE(val1, val2); EXPECT_LE(val1, val2); val1 <= val2
ASSERT_GT(val1, val2); EXPECT_GT(val1, val2); val1 > val2
ASSERT_GE(val1, val2); EXPECT_GE(val1, val2); val1 >= val2

使用要点:

  • 失败时 Google Test 会同时打印两个操作数的值;在 *_EQ* 系列断言中,把被测表达式放在 actual 位置、期望值放在 expected 位置,因为失败消息的格式为此约定做了优化;
  • 值必须能用断言的比较运算符比较,否则编译报错;值还必须支持 << 流式输出,所有内建类型都满足;
  • 自定义类型需要定义对应的比较运算符(如 ==、<),定义后优先用 ASSERT_*() 宏,因为失败时不仅能打印比较结果还能打印两个操作数;
  • 参数总是恰好求值一次,所以参数带副作用是允许的;但和普通 C/C++ 函数一样,参数求值顺序未定义,代码不应依赖任何特定顺序;
  • ASSERT_EQ() 对指针做指针相等比较:用于两个 C 字符串时,它测试的是它们是否指向同一内存位置,而不是内容是否相等。因此要按值比较 C 字符串(如 const char*),应使用后文介绍的 ASSERT_STREQ();要断言 C 字符串为 NULL,用 ASSERT_STREQ(NULL, c_string);而比较两个 string 对象则应使用 ASSERT_EQ;
  • 本组宏同时支持窄/宽字符串对象(string 和 wstring)。

可用平台:Linux、Windows、Mac。

字符串比较断言

这组断言比较两个 C 字符串;若要比较两个 string 对象,请改用 EXPECT_EQ、EXPECT_NE 等:

致命断言 非致命断言 验证
ASSERT_STREQ(expected_str, actual_str); EXPECT_STREQ(expected_str, actual_str); 两个 C 字符串内容相同
ASSERT_STRNE(str1, str2); EXPECT_STRNE(str1, str2); 两个 C 字符串内容不同
ASSERT_STRCASEEQ(expected_str, actual_str); EXPECT_STRCASEEQ(expected_str, actual_str); 忽略大小写后内容相同
ASSERT_STRCASENE(str1, str2); EXPECT_STRCASENE(str1, str2); 忽略大小写后内容不同

注意事项:

  • 断言名中的 "CASE" 表示忽略大小写;
  • *STREQ* 和 *STRNE* 也接受宽 C 字符串(wchar_t*),宽字符串比较失败时值会以 UTF-8 窄字符串形式打印;
  • NULL 指针与空字符串被视为不同;
  • 更多字符串比较技巧(子串、前缀、后缀、正则表达式匹配等)见 v8_7_5/testing/gtest/docs/V1_5_AdvancedGuide.md。

可用平台:Linux、Windows、Mac。

简单测试(Simple Tests)

创建一个测试分三步:

  1. 用 TEST() 宏定义并命名一个测试函数,它是普通的、不返回值的 C++ 函数;
  2. 在函数体内,用各种 Google Test 断言检查值;
  3. 测试结果由断言决定:若任一断言失败(致命或非致命)或测试崩溃,整个测试失败;否则成功。
TEST(test_case_name, test_name) {
  ... test body ...
}

TEST() 的参数从一般到具体:第一个参数是 test case 名称,第二个参数是该 test case 内的测试名称。一个 test case 可以包含任意数量的测试。测试的完整名称由"所在 test case 名 + 单个测试名"构成,不同 test case 中的测试可以使用相同的单独名称。

以阶乘函数为例:

int Factorial(int n); // Returns the factorial of n

对应的测试用例组:

// Tests factorial of 0.
TEST(FactorialTest, HandlesZeroInput) {
  EXPECT_EQ(1, Factorial(0));
}

// Tests factorial of positive numbers.
TEST(FactorialTest, HandlesPositiveInput) {
  EXPECT_EQ(1, Factorial(1));
  EXPECT_EQ(2, Factorial(2));
  EXPECT_EQ(6, Factorial(3));
  EXPECT_EQ(40320, Factorial(8));
}

Google Test 按 test case 分组展示测试结果,因此逻辑相关的测试应放在同一个 test case 中——也就是 TEST() 的第一个参数保持一致。上例中 HandlesZeroInput 和 HandlesPositiveInput 同属 FactorialTest 测试用例组。

仓库中的 samples/sample1_unittest.cc 是这一模式的原生范例,它同时覆盖 Factorial() 与 IsPrime() 两个被测函数:

// Tests factorial of negative numbers.
TEST(FactorialTest, Negative) {
  EXPECT_EQ(1, Factorial(-5));
  EXPECT_EQ(1, Factorial(-1));
  EXPECT_GT(Factorial(-10), 0);
}

// Tests some trivial cases.
TEST(IsPrimeTest, Trivial) {
  EXPECT_FALSE(IsPrime(0));
  EXPECT_FALSE(IsPrime(1));
  EXPECT_TRUE(IsPrime(2));
  EXPECT_TRUE(IsPrime(3));
}

示例注释还给出两条值得铭记的工程约定:test case 名与测试名都必须是合法的 C++ 标识符,且不要在名字中使用下划线(_);Google Test 保证每个测试恰好运行一次,但不保证执行顺序,因此测试结果不能依赖执行顺序。

可用平台:Linux、Windows、Mac。

测试夹具(Test Fixtures):为多个测试复用同一数据配置

当你发现两个或更多测试操作相似的数据时,可以用 test fixture 为多个不同测试复用同一对象配置。

创建夹具只需四步:

  1. 从 ::testing::Test 派生一个类,类体以 protected: 或 public: 开头(因为要在子类中访问夹具成员);
  2. 在类内声明要使用的对象;
  3. 如有必要,编写默认构造函数或 SetUp() 函数为每个测试准备对象。常见错误是把 SetUp() 写成小写 u 的 Setup()——不要犯这个错;
  4. 如有必要,编写析构函数或 TearDown() 函数释放 SetUp() 中分配的资源。关于何时用构造函数/析构函数、何时用 SetUp()/TearDown(),参见 v8_7_5/testing/gtest/docs/V1_5_FAQ.md 中的 FAQ 条目;
  5. 如有需要,定义测试共享的子程序。

使用夹具时,用 TEST_F() 代替 TEST(),以访问夹具中的对象和子程序:

TEST_F(test_case_name, test_name) {
  ... test body ...
}

与 TEST() 一样,第一个参数是 test case 名称,但 TEST_F() 中它必须是测试夹具类的名字——_F 代表 fixture。由于 C++ 宏系统的限制,无法用一个宏同时处理两种测试,用错宏会导致编译错误。另外,必须先定义夹具类再在 TEST_F() 中使用它,否则会得到 "virtual outside class declaration" 编译错误。

对于每个用 TEST_F() 定义的测试,Google Test 都会:

  1. 在运行时新建一个测试夹具;
  2. 立即通过 SetUp() 初始化它;
  3. 运行测试;
  4. 调用 TearDown() 清理;
  5. 删除测试夹具。

注意:同一 test case 中的不同测试拥有不同的夹具对象,Google Test 总是先删除一个夹具再创建下一个,不会跨测试复用同一个夹具,因此一个测试对夹具的修改不会影响其他测试。

以 FIFO 队列类 Queue 为例(接口如下):

template <typename E> // E is the element type.
class Queue {
 public:
  Queue();
  void Enqueue(const E& element);
  E* Dequeue(); // Returns NULL if the queue is empty.
  size_t size() const;
  ...
};

按惯例,夹具命名为 FooTest(Foo 为被测类)。先定义夹具:

class QueueTest : public ::testing::Test {
 protected:
  virtual void SetUp() {
    q1_.Enqueue(1);
    q2_.Enqueue(2);
    q2_.Enqueue(3);
  }

  // virtual void TearDown() {}

  Queue<int> q0_;
  Queue<int> q1_;
  Queue<int> q2_;
};

这个例子不需要 TearDown(),因为除了析构函数已做的清理外无需额外善后。

再用 TEST_F() 编写测试:

TEST_F(QueueTest, IsEmptyInitially) {
  EXPECT_EQ(0, q0_.size());
}

TEST_F(QueueTest, DequeueWorks) {
  int* n = q0_.Dequeue();
  EXPECT_EQ(NULL, n);

  n = q1_.Dequeue();
  ASSERT_TRUE(n != NULL);
  EXPECT_EQ(1, *n);
  EXPECT_EQ(0, q1_.size());
  delete n;

  n = q2_.Dequeue();
  ASSERT_TRUE(n != NULL);
  EXPECT_EQ(2, *n);
  EXPECT_EQ(1, q2_.size());
  delete n;
}

上述代码同时演示了 ASSERT_* 与 EXPECT_* 的取舍经验:想在断言失败后继续揭示更多错误时用 EXPECT_*;失败后继续没有意义时用 ASSERT_*。例如 DequeueWorks 中的第二个断言用 ASSERT_TRUE(n != NULL),因为之后要解引用指针 n,若 n 为 NULL 将导致段错误。

这些测试运行时依次发生:

  1. Google Test 构造一个 QueueTest 对象(记为 t1);
  2. t1.SetUp() 初始化 t1;
  3. 第一个测试(IsEmptyInitially)在 t1 上运行;
  4. t1.TearDown() 在测试结束后清理;
  5. t1 被析构;
  6. 上述步骤在另一个 QueueTest 对象上重复,这次运行 DequeueWorks 测试。

补充说明:测试对象构造时 Google Test 会自动保存所有 Google Test 标志,析构时恢复它们。

可用平台:Linux、Windows、Mac。

运行测试(Invoking the Tests)

TEST() 和 TEST_F() 会隐式注册测试,因此与许多其他 C++ 测试框架不同,你不需要重新列出已定义的测试来运行它们。

定义完测试后,用 RUN_ALL_TESTS() 运行:全部成功返回 0,否则返回 1。注意 RUN_ALL_TESTS() 会运行链接单元中的全部测试——它们可以来自不同的 test case,甚至不同的源文件。

RUN_ALL_TESTS() 宏被调用时:

  1. 保存所有 Google Test 标志的状态;
  2. 为第一个测试创建测试夹具对象;
  3. 通过 SetUp() 初始化;
  4. 在夹具对象上运行测试;
  5. 通过 TearDown() 清理夹具;
  6. 删除夹具;
  7. 恢复所有 Google Test 标志的状态;
  8. 对下一个测试重复上述步骤,直到所有测试运行完毕。

此外,如果第 2 步夹具构造函数产生致命失败,则第 3–5 步没有意义会被跳过;同理,第 3 步产生致命失败则第 4 步被跳过。

重要:不能忽略 RUN_ALL_TESTS() 的返回值,否则 gcc 会报编译错误。设计理由:自动化测试服务根据退出码(而非 stdout/stderr 输出)判断测试是否通过,因此 main() 必须返回 RUN_ALL_TESTS() 的值。

另外,RUN_ALL_TESTS() 只能调用一次。多次调用会与某些高级特性(如线程安全的死亡测试)冲突,因此不受支持。

可用平台:Linux、Windows、Mac。

编写 main() 函数

可以从如下样板开始:

#include "this/package/foo.h"
#include <gtest/gtest.h>

namespace {

// The fixture for testing class Foo.
class FooTest : public ::testing::Test {
 protected:
  // 以下函数若有空函数体,可任意删除

  FooTest() {
    // 这里可以为每个测试做 set-up 工作
  }

  virtual ~FooTest() {
    // 这里可以做不抛异常的清理工作
  }

  // 如果构造函数/析构函数不足以完成 set-up/clean-up,可定义以下方法:

  virtual void SetUp() {
    // 在构造函数之后、每个测试之前立即调用
  }

  virtual void TearDown() {
    // 在每个测试之后、析构函数之前立即调用
  }

  // 这里声明的对象可供 Foo 的 test case 中的所有测试使用
};

// 测试 Foo::Bar() 方法的行为 Abc
TEST_F(FooTest, MethodBarDoesAbc) {
  const string input_filepath = "this/package/testdata/myinputfile.dat";
  const string output_filepath = "this/package/testdata/myoutputfile.dat";
  Foo f;
  EXPECT_EQ(0, f.Bar(input_filepath, output_filepath));
}

// 测试 Foo 的 Xyz 行为
TEST_F(FooTest, DoesXyz) {
  // 练习 Foo 的 Xyz 特性
}

}  // namespace

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

::testing::InitGoogleTest() 解析命令行中的 Google Test 标志并移除所有已识别的标志,从而允许用户通过各种标志控制测试程序行为(详见 v8_7_5/testing/gtest/docs/V1_5_AdvancedGuide.md)。必须在调用 RUN_ALL_TESTS() 之前调用它,否则标志无法正确初始化。在 Windows 上,InitGoogleTest() 同样支持宽字符串,可用于以 UNICODE 模式编译的程序。

如果你觉得每个测试工程都手写 main() 太麻烦,Google Test 已经提供了 main() 的基础实现——仓库中的 src/gtest_main.cc 就是这个实现:

GTEST_API_ int main(int argc, char **argv) {
  printf("Running main() from gtest_main.cc\n");
  testing::InitGoogleTest(&argc, argv);
  return RUN_ALL_TESTS();
}

只要把测试链接到 gtest_main 库即可直接使用。示例 samples/sample1_unittest.cc 正是通过链接 src/gtest_main.cc 省去了自写 main() 的步骤;make/Makefile 中 sample1_unittest : sample1.o sample1_unittest.o gtest_main.a 也印证了"带 main() 的测试链接 gtest_main.a"这一约定。

给 Visual C++ 用户的重要提示

如果把测试放进库(library),而 main() 在另一个库或 .exe 中,那些测试将不会运行。原因是 Visual C++ 链接器的一个已知行为:定义测试时 Google Test 会创建某些静态对象来注册它们,这些对象没有被其他地方引用,但它们的构造函数本应执行;当 Visual C++ 链接器看到库中没有任何东西被其他位置引用时,就会把该库丢弃。

解决办法是让主程序引用测试库,防止链接器将其丢弃。在库代码中声明一个函数:

__declspec(dllexport) int PullInMyLibrary() { return 0; }

如果测试放在静态库(而非 DLL)中,则不需要 __declspec(dllexport)。然后在主程序中调用它:

int PullInMyLibrary();
static int dummy = PullInMyLibrary();

这样会让测试保持被引用状态,并在启动时完成注册。

另外,如果在静态库中定义测试,需要为主程序链接器选项添加 /OPT:NOREF。在 MSVC++ IDE 中:进入 .exe 项目属性 → Configuration Properties → Linker → Optimization,把 References 设置为 Keep Unreferenced Data (/OPT:NOREF),防止链接器从最终可执行文件中丢弃测试生成的符号。

还有一个坑:如果把 Google Test 用作静态库(gtest.vcproj 中的默认形态),测试也必须放在静态库中;若必须把测试放进 DLL,则必须把 Google Test 也改为编译成 DLL,否则测试无法正确运行甚至完全不运行。总而言之——别把测试写进库,会让生活简单很多。

已知限制(Known Limitations)

Google Test 被设计为线程安全的:在提供 pthreads 库的系统上,实现是线程安全的;但在其他系统(如 Windows)上,目前不保证两个线程并发使用 Google Test 断言的安全性。大多数测试不受影响,因为断言通常在主线程中执行。如果你愿意,可以在 gtest-port.h 中为你的平台实现必要的同步原语。

下一步去哪里

恭喜!你已经掌握了 Google Test 的基础。现在可以:

  • 开始编写并运行自己的 Google Test 测试;
  • 阅读仓库中的 samples 示例程序(sample1 到 sample10 覆盖了简单断言、夹具、参数化测试、值参数化测试、类型参数化测试、事件监听器、死亡测试、界面测试等进阶用法);
  • 继续阅读 V1_5_AdvancedGuide.md,它介绍了大量更实用的高级特性;
  • 遇到疑问可查阅 V1_5_FAQ.md,其中解释了为什么选择 Google Test、如何生成 Windows 64 位二进制、以及各类疑难问题。

在 miniblink49 仓库中,gtest 的 docs 目录还保留了 V1_6、V1_7 等多版本文档(V1_7_Primer.md、V1_7_AdvancedGuide.md 等),可对照阅读;整套测试基础设施的源码、构建文件与示例均位于 v8_7_5/testing/gtest 目录下,随时可以作为你新测试工程的参照模板。

登录后查看全文
miniblink49