miniblink49 内置 Google Mock 入门:用 C++ Mock 框架写出可验证交互的单元测试
miniblink49 内置 Google Mock 入门:用 C++ Mock 框架写出可验证交互的单元测试
导读:本仓库(miniblink49 浏览器内核)的 v8_5_7/testing/ 目录随 V8 引擎携带了 Google C++ Mocking Framework(Google Mock)的完整源码与文档。本文以 Google Mock 1.7 官方入门文档(ForDummies.md)为骨架,结合仓库内 gmock.h、gmock-cardinalities.h 等真实实现,系统讲解 Mock 对象的核心概念、MOCK_METHOD* 宏定义、EXPECT_CALL() 期望语法、Matcher / Cardinality / Action 三大组件以及顺序与粘性规则。读完本文,你将具备在 C++ 测试中独立编写 Mock 类并验证“模块与协作者之间交互”的实战能力。
什么是 Google C++ Mocking Framework
编写原型或测试时,往往无法(也不应该)完全依赖真实对象。Mock 对象实现了与真实对象相同的接口(因此可以被当作真实对象使用),但允许你在运行时指定它将被如何使用、应当做什么:哪些方法会被调用?以什么顺序?调用多少次?参数是什么?返回什么?
在测试驱动开发(TDD)社区中,**Fake(假对象)**与 **Mock(模拟对象)**含义截然不同:
- Fake 拥有可工作的实现,但通常走了捷径(比如让操作更廉价),因此不适合用于生产环境,内存文件系统就是一个典型例子;
- Mock 是预先用**期望(expectations)**编程的对象,这些期望构成了“它应当接收到哪些调用”的规格说明。
最关键的一点是:Mock 允许你检查它自身与使用它的代码之间的交互。这一差异在你真正开始使用 Mock 之后会愈发清晰。
Google Mock 是一个用于创建 Mock 类并使用它们的库(官方文档也常称其为 framework)。它之于 C++,相当于 jMock 与 EasyMock 之于 Java。使用 Google Mock 只需三个基本步骤:
- 用几个简单的宏描述你想 Mock 的接口,宏会展开成 Mock 类的实现;
- 创建若干 Mock 对象,用直观的语法指定其期望与行为;
- 运行使用了这些 Mock 对象的代码——只要期望被违反,Google Mock 会立刻捕获。
在仓库中,Google Mock 的完整实现位于 v8_5_7/testing/gmock/:公共头文件集中在 v8_5_7/testing/gmock/include/gmock/,其中 gmock.h 是用户应包含的唯一主头文件;gmock-actions.h、gmock-cardinalities.h、gmock-matchers.h、gmock-generated-function-mockers.h 等分别承载 Action、Cardinality、Matcher 与 MOCK_METHOD* 宏的实现。
为什么选择 Google Mock
手动编写 Mock 在 C++ 中是一件苦差事:
- 必须有人去实现 Mock,这项工作通常乏味且容易出错;
- 手写 Mock 的质量参差不齐,可能被赶工拼凑出来、带各种临时性限制;
- 从一个 Mock 上学到的经验无法迁移到下一个。
相比之下,Java 和 Python 社区拥有优秀的 Mock 框架,能自动完成 Mock 创建,Mock 因此在那些社区成为被广泛验证的有效实践。Google Mock 正是为 C++ 程序员补上这块短板而构建的——它受 jMock 与 EasyMock 启发,但针对 C++ 的特性重新设计。如果你正被以下问题困扰,它就是你的朋友:
- 设计不尽人意却为时已晚,而 C++ 的原型开发远谈不上“快速”;
- 测试过慢,因为依赖太多库或昂贵资源(如数据库);
- 测试脆弱,因为依赖的网络等资源不可靠;
- 想测试代码对故障(如文件校验和错误)的处理,却很难人为制造故障;
- 需要确认模块与其他模块的交互方式正确,但难以直接观察交互,只能笨拙地观察动作结束后的副作用;
- 想“Mock 掉”依赖,但它们还没有 Mock 实现,又对手写 Mock 不放心。
官方文档建议把 Google Mock 同时当作:
- 设计工具:尽早、频繁地试验接口设计,更多迭代带来更好的设计;
- 测试工具:切断测试的外部依赖,探查模块与其协作者之间的交互。
快速开始:包含头文件
在 C++ 源文件中,只需要两行 include 即可开始:
#include "gtest/gtest.h"
#include "gmock/gmock.h"
其中 gmock/gmock.h 会进一步展开引入 gmock-actions.h、gmock-cardinalities.h、gmock-generated-function-mockers.h、gmock-generated-nice-strict.h 等全部子头文件,并声明 InitGoogleMock() 等入口函数。
案例:Mock 一只“乌龟”
文档用绘图程序的 LOGO 风格绘图 API 举例。假设绘图程序依赖一个 Turtle 接口:与其让应用直接调用绘图 API,不如把 API 封装进接口、面向接口编程(依赖注入)。
class Turtle {
...
virtual ~Turtle() {}
virtual void PenUp() = 0;
virtual void PenDown() = 0;
virtual void Forward(int distance) = 0;
virtual void Turn(int degrees) = 0;
virtual void GoTo(int x, int y) = 0;
virtual int GetX() const = 0;
virtual int GetY() const = 0;
};
注意:Turtle 的析构函数必须是 virtual——所有打算被继承的类都应如此,否则通过基类指针 delete 对象时不会调用派生类析构函数,可能造成内存泄漏等状态损坏。
PenUp() / PenDown() 控制移动是否留下痕迹,Forward()、Turn()、GoTo() 控制移动,GetX() / GetY() 返回当前位置。程序中正常使用真实实现,测试中则换成 Mock 实现,从而轻松检查程序调用了哪些绘图原语、参数是什么、顺序如何。这样写的测试更健壮(不会因新机器抗锯齿算法不同而失败)、更易读易维护(测试意图写在代码里而非二进制图像中),而且快得多。
编写 Mock 类
如何定义:MOCK_METHOD 宏
以 Turtle 为例,步骤非常简单:
- 从
Turtle派生一个类MockTurtle; - 选取一个
Turtle的虚函数(虽然也能用模板技巧 Mock 非虚方法,但要复杂得多),数清它的参数个数; - 在子类的
public:段写MOCK_METHODn();(Mock const 方法时用MOCK_CONST_METHODn();),n是参数个数——数错了编译器会报错告诉你; - 把函数签名中的函数名粘贴为宏的第一个参数,剩下的(即函数的类型)作为第二个参数;
- 对所有要 Mock 的虚函数重复上述过程。
完成后应得到类似这样的 Mock 类:
#include "gmock/gmock.h" // 引入 Google Mock
class MockTurtle : public Turtle {
public:
...
MOCK_METHOD0(PenUp, void());
MOCK_METHOD0(PenDown, void());
MOCK_METHOD1(Forward, void(int distance));
MOCK_METHOD1(Turn, void(int degrees));
MOCK_METHOD2(GoTo, void(int x, int y));
MOCK_CONST_METHOD0(GetX, int());
MOCK_CONST_METHOD0(GetY, int());
};
无需在其他地方定义这些 Mock 方法——MOCK_METHOD* 宏会自动生成定义。这些宏的实际展开定义位于 gmock-generated-function-mockers.h(其模板源文件为同目录下的 .pump 文件),仓库中还保留了 v1_5、v1_6、v1_7 各版本的历史文档可供对比 API 演进。
提示:如果连这个都嫌麻烦,可以使用 Google Mock 自带的 gmock_gen.py 工具——位于仓库 v8_5_7/testing/gmock/scripts/generator/gmock_gen.py,源自 cppclean 项目。这个命令行工具要求系统装有 Python 2.4,用法是:
gmock_gen.py header-file.h [ClassName]...
给它一个 C++ 头文件和其中定义的抽象类名,它就会打印出对应的 Mock 类定义;不指定类名时输出文件中的所有类。由于 C++ 语言的复杂性,脚本不一定总能正确工作,但可用时相当方便。还可以通过环境变量 INDENT 调整缩进,例如 INDENT=4 gmock_gen.py header-file.h ClassName。其局限(如模板信息丢失、多指针/引用组合渲染问题)记录在同目录 README 中。
把 Mock 类放在哪里
Mock 类定义位置有讲究。放在 *_test.cc 中,仅当被 Mock 的接口(如 Foo)由同一人或团队拥有时才合适;否则 Foo 一改,你的测试就可能挂掉。经验法则是:如果 Foo 归别人所有,就把 Mock 类定义在 Foo 所在的包中(最好放在 testing 子包,以清晰区分生产代码与测试工具),放在 mock_foo.h 里,让所有测试引用同一个 mock_foo.h。这样 Foo 变化时只需改一处 MockFoo,只有依赖变化方法的测试需要修复。
另一个方案:在 Foo 之上引入薄适配层 FooAdaptor,面向新接口编程。由于适配器归你所有,能更从容地吸收 Foo 的变化;虽然初期工作更多,但精心挑选适配器接口能让代码更易写易读,长远来看是净收益。
在测试中使用 Mock
典型工作流:
- 从
testing命名空间导入 Google Mock 名字(每个文件只需一次),以便不加限定符使用; - 创建若干 Mock 对象;
- 设定期望(方法会被调用多少次?参数是什么?应当做什么?);
- 运行使用 Mock 的代码,可选地用 Google Test 断言检查结果——如果 Mock 方法被调用次数超过期望或参数错误,会立刻报错;
- Mock 被析构时,Google Mock 会自动检查其所有期望是否已满足。
完整示例:
#include "path/to/mock-turtle.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
using ::testing::AtLeast; // #1
TEST(PainterTest, CanDrawSomething) {
MockTurtle turtle; // #2
EXPECT_CALL(turtle, PenDown()) // #3
.Times(AtLeast(1));
Painter painter(&turtle); // #4
EXPECT_TRUE(painter.DrawCircle(0, 0, 10));
} // #5
int main(int argc, char** argv) {
// 运行测试前必须执行此行以初始化 Google Mock(及 Google Test)。
::testing::InitGoogleMock(&argc, argv);
return RUN_ALL_TESTS();
}
该测试检查 PenDown() 至少被调用一次。如果 painter 没调用它,测试会输出类似这样的失败信息:
path/to/my_test.cc:119: Failure
Actual function call count doesn't match this expectation:
Actually: never called;
Expected: called at least once.
提示 1:在 Emacs 缓冲区中运行测试时,把光标放在错误信息显示的行号上按 <Enter> 可直接跳到失败的期望处。
提示 2:如果 Mock 对象从不被删除,最后的验证就不会发生。因此在堆上分配 Mock 时,最好配合堆泄漏检查器运行测试。
重要规则:Google Mock 要求期望必须在 Mock 函数被调用之前设置,否则行为未定义——尤其不要交错书写 EXPECT_CALL() 与对 Mock 函数的调用。也就是说,EXPECT_CALL() 应理解为“预期将来会发生一次调用”,而不是“已经发生了一次调用”。这样设计的原因在于:提前声明期望,能让 Google Mock 在违规刚刚发生时(此时栈回溯等上下文仍然可用)就报告,调试容易得多。
与其他测试框架协同
不想用 Google Test(比如用 CppUnit、CxxTest)时,只需修改 main():
int main(int argc, char** argv) {
// 此行让 Google Mock 在失败时抛出异常,
// 由你的测试框架将其解释为测试失败。
::testing::GTEST_FLAG(throw_on_failure) = true;
::testing::InitGoogleMock(&argc, argv);
... whatever your testing framework requires ...
}
这种方案有个缺点:Google Mock 有时会从 Mock 对象的析构函数里抛异常,某些编译器下会导致测试程序崩溃——你仍能注意到测试失败,但失败并不优雅。更好的方案是利用 Google Test 的事件监听器 API,实现监听接口中的 OnTestPartResult() 方法把测试失败正确上报给框架。如果这些都太麻烦,官方建议直接使用与 Google Mock 无缝协作(事实上就是其组成部分)的 Google Test。
设置期望:EXPECT_CALL 详解
正确使用 Mock 的关键是设置恰到好处的期望:太严格,测试会因无关变化而失败;太宽松,bug 会漏网。Google Mock 提供了做到“恰到好处”的全部手段。
通用语法
EXPECT_CALL() 宏在 mock 方法上设置期望,一般语法为:
EXPECT_CALL(mock_object, method(matchers))
.Times(cardinality)
.WillOnce(action)
.WillRepeatedly(action);
宏有两个参数:先是 Mock 对象,然后是方法及其参数。注意两者用**逗号(,)**分隔而非句点(.)(出于技术原因必须用逗号)。宏后面可以跟若干可选子句,提供期望的更多信息。
这套语法设计得让期望读起来像英文。例如:
using ::testing::Return;
...
EXPECT_CALL(turtle, GetX())
.Times(5)
.WillOnce(Return(100))
.WillOnce(Return(150))
.WillRepeatedly(Return(200));
意思是:turtle 的 GetX() 将被调用 5 次,第一次返回 100,第二次返回 150,之后每次都返回 200。这种风格常被称为领域特定语言(DSL)。为什么用宏实现?两个目的:一是让期望容易识别(无论是 grep 还是人眼),二是允许 Google Mock 在失败信息中包含期望的源文件位置,方便调试。
Matchers:期望什么参数
Mock 函数带参数时,必须指定期望的参数。例如:
// 期望乌龟向前移动 100 个单位。
EXPECT_CALL(turtle, Forward(100));
有时你不想要太具体的匹配(过度指定会让测试脆弱并模糊测试意图,应只指定必要内容——不多不少)。如果只关心 Forward() 被调用、不关心实际参数,用 _ 表示“任意值”:
using ::testing::_;
...
// 期望乌龟向前移动。
EXPECT_CALL(turtle, Forward(_));
_ 是 matcher(匹配器) 的一个实例。matcher 类似谓词,能测试参数是否符合预期;凡是期望函数参数的地方都能嵌入 matcher。内置 matcher 清单见 CheatSheet。例如 Ge(大于等于)matcher:
using ::testing::Ge;
...
EXPECT_CALL(turtle, Forward(Ge(100)));
这检查乌龟被要求向前移动至少 100 个单位。
Cardinalities:会被调用多少次
EXPECT_CALL() 之后可指定的第一个子句是 Times(),其参数称为 cardinality(基数),描述调用应发生的次数。cardinality 可以是“模糊”的——就像 matcher 可以模糊一样——从而精确表达测试意图。
一个有趣的特殊情况是 Times(0):表示该函数不应以给定参数被调用,一旦被(错误地)调用,Google Mock 就会报告测试失败。前面见过的 AtLeast(n) 就是模糊基数的一例。可用内置基数清单同样见 CheatSheet。仓库中 Times、AtLeast、AnyNumber 等基数类的实现位于 gmock-cardinalities.h,它同时定义了 CardinalityInterface 接口,用户可实现该接口扩展自定义基数。
Times() 子句可以省略。省略时 Google Mock 会自动推断基数,规则很好记:
- 若
EXPECT_CALL()中既没有WillOnce()也没有WillRepeatedly(),推断基数为Times(1); - 若有
n个WillOnce()且没有WillRepeatedly()(n >= 1),基数为Times(n); - 若有
n个WillOnce()且有一个WillRepeatedly()(n >= 0),基数为Times(AtLeast(n))。
小测验:如果一个函数期望被调用两次,实际却被调用了四次,会发生什么?(答案见后文“所有期望默认粘性”一节。)
Actions:它应当做什么
Mock 对象本身没有真正的工作实现,用户必须告诉它在方法被调用时做什么。
首先,若 Mock 函数的返回类型是内建类型或指针,函数有默认动作(void 函数直接返回,bool 函数返回 false,其他函数返回 0)。不写任何东西时使用该默认行为。
其次,若函数没有默认动作、或默认动作不合用,可以用一系列 WillOnce() 子句加可选的 WillRepeatedly() 指定每次匹配时执行的动作。例如:
using ::testing::Return;
...
EXPECT_CALL(turtle, GetX())
.WillOnce(Return(100))
.WillOnce(Return(200))
.WillOnce(Return(300));
表示 turtle.GetX() 将被调用恰好三次(因为没写 Times(),Google Mock 从 WillOnce() 的数量推断得出),依次返回 100、200、300。
using ::testing::Return;
...
EXPECT_CALL(turtle, GetY())
.WillOnce(Return(100))
.WillOnce(Return(200))
.WillRepeatedly(Return(300));
表示 turtle.GetY() 将被调用至少两次,第一次返回 100、第二次 200、第三次起一直返回 300。
当然,显式写了 Times() 时 Google Mock 不会自行推断。如果指定的次数多于 WillOnce() 子句数,那么所有 WillOnce() 用完后,每次调用执行该函数的默认动作(除非写了 WillRepeatedly())。
除 Return() 外,WillOnce() 里还能用 ReturnRef(variable) 返回引用、调用预定义函数等(完整 Action 清单见 CheatSheet)。
重要提示:EXPECT_CALL() 语句只对动作子句求值一次,即使动作会被执行多次,因此要小心副作用。下面代码可能不符合你的预期:
int n = 100;
EXPECT_CALL(turtle, GetX())
.Times(4)
.WillRepeatedly(Return(n++));
它并不会依次返回 100、101、102……而是每次都返回 100,因为 n++ 只求值一次。同理,Return(new Foo) 在 EXPECT_CALL() 执行时创建一个 Foo 对象,之后每次返回同一个指针。若希望副作用每次发生,需要定义自定义 Action(详见 CookBook)。
再考一题,下面代码是什么意思?
using ::testing::Return;
...
EXPECT_CALL(turtle, GetY())
.Times(4)
.WillOnce(Return(100));
显然 turtle.GetY() 预期被调用四次,但如果认为它每次都返回 100 就错了——每次调用都会消耗一个 WillOnce() 子句,之后执行默认动作。正确答案是:第一次返回 100,从第二次起返回 0(0 是 int 函数的默认动作)。
多个期望的匹配顺序
更现实的情况是同时对多个 Mock 方法(可能来自多个 Mock 对象)设置期望。默认情况下,mock 方法被调用时,Google Mock 会按定义顺序的逆序搜索期望,找到第一个匹配参数的活跃期望即停止(可以理解为“较新的规则覆盖较旧的”)。如果匹配的期望已无法再接受调用,会得到“超出上限”的失败。示例:
using ::testing::_;
...
EXPECT_CALL(turtle, Forward(_)); // #1
EXPECT_CALL(turtle, Forward(10)) // #2
.Times(2);
如果 Forward(10) 连续被调用三次,第三次会报错,因为最后匹配的期望 #2 已饱和;但如果第三次调用的是 Forward(20),则没问题,因为此时 #1 会成为匹配期望。
为什么按逆序搜索?这样用户可以在 Mock 对象构造函数或测试夹具 setUp 阶段设置默认期望,然后在测试体内写更具体的期望来定制 Mock。所以同一方法上有多个期望时,更具体的 matcher 要写在后面,否则更具体的规则会被排在后面的通用规则遮蔽。
有序调用 vs 无序调用
默认情况下,即使更早的期望尚未满足,期望也可以匹配调用——也就是说调用不必按期望书写顺序发生。若要求所有期望调用严格按序发生,用 InSequence:
using ::testing::InSequence;
...
TEST(FooTest, DrawsLineSegment) {
...
{
InSequence dummy;
EXPECT_CALL(turtle, PenDown());
EXPECT_CALL(turtle, Forward(100));
EXPECT_CALL(turtle, PenUp());
}
Foo();
}
创建 InSequence 对象后,其作用域内的所有期望被放入一个序列,必须按顺序发生——这里只是借助对象的构造函数和析构函数完成工作,因此它的名字无关紧要。本例验证 Foo() 按书写顺序调用三个期望函数,乱序即为错误。若只关心部分调用之间的相对顺序(任意偏序),可参考 CookBook 中的“Expecting Partially Ordered Calls”一节。
所有期望默认是“粘性”的
考考你:如何测试乌龟被要求恰好两次移动到原点(忽略它收到的其他指令)?先自己想,再看答案:
using ::testing::_;
...
EXPECT_CALL(turtle, GoTo(_, _)) // #1
.Times(AnyNumber());
EXPECT_CALL(turtle, GoTo(0, 0)) // #2
.Times(2);
假设 turtle.GoTo(0, 0) 被调用三次:第三次时,Google Mock 发现参数匹配期望 #2(记住总是选择最后一个匹配期望),而 #2 只允许两次这样的调用,于是立即报错。
这个例子说明:Google Mock 中的期望默认是“粘性(sticky)”的——即使达到调用上限,期望仍保持活跃。这是必须牢记的重要规则,它影响规格的含义,也与许多其他 Mock 框架的做法不同(官方解释是:这使常见用例更容易表达和理解)。
检验一下你是否真正理解了:下面代码表示什么?
using ::testing::Return;
...
for (int i = n; i > 0; i--) {
EXPECT_CALL(turtle, GetX())
.WillOnce(Return(10*i));
}
如果认为它表示 turtle.GetX() 被调用 n 次并依次返回 10、20、30……那就错了。因为期望是粘性的:第二次调用 GetX() 时,最后(最新)的那个 EXPECT_CALL() 会匹配并立刻触发“超出上限”错误——这段代码没什么用!
正确表达“GetX() 依次返回 10、20、30……”的方法是显式声明期望不粘性,即饱和后立即退役:
using ::testing::Return;
...
for (int i = n; i > 0; i--) {
EXPECT_CALL(turtle, GetX())
.WillOnce(Return(10*i))
.RetiresOnSaturation();
}
还有更好的做法:本例中调用本就应发生在特定顺序,动作也按顺序排列,既然顺序重要,就应显式用序列表达:
using ::testing::InSequence;
using ::testing::Return;
...
{
InSequence s;
for (int i = 1; i <= n; i++) {
EXPECT_CALL(turtle, GetX())
.WillOnce(Return(10*i))
.RetiresOnSaturation();
}
}
顺带一提,期望可能不粘性的另一种情况是在序列中——一旦序列中排在它后面的期望被使用,它就自动退役(不再用于匹配任何调用)。
回到前面的小测验:函数期望被调用两次、实际调用四次时会发生什么?答案是:按逆序匹配,前两次调用命中该期望并成功,之后该期望饱和;后续调用若没有其他可匹配的期望,就会触发“超出上限”的失败。
不关心的调用
Mock 对象可能方法众多,并非所有方法都值得关心——例如某些测试中并不在意 GetX()、GetY() 被调用多少次。Google Mock 中,不感兴趣的方法什么都不用写。若这类方法被调用,测试输出中会出现警告,但不算失败。
下一步
到这里你已经掌握了使用 Google Mock 所需的核心知识。仓库中的配套资料可以继续深入:
- CheatSheet.md:内置 Matcher、Cardinality、Action 的速查清单,写期望时的案头参考;
- CookBook.md:Mock 非虚方法、自定义 Action、部分有序调用等进阶技巧;
- FrequentlyAskedQuestions.md:常见编译错误排查(编译报错令人费解时,也可参考仓库内 gmock_doctor.py 这类辅助脚本的思路);
- gmock.h:主头文件,其中注释还总结了
ON_CALL(mock_object.Method(...)).WillByDefault(...)与EXPECT_CALL的完整子句语法(.With()、.Times()、.InSequence()、.WillOnce()、.WillRepeatedly()、.RetiresOnSaturation()); - gmock-gen 脚本:自动生成 Mock 类的命令行工具。
需要说明的是,本仓库是浏览器内核项目,随 V8 5.7 源码树携带了这套 testing 组件,主要服务于 V8 / Blink 系组件的单元测试场景;在阅读和复用 v8_5_7/testing/gmock/ 下的代码时,应以仓库内实际版本(对应 Google Mock 1.7 文档)为准。现在,你可以打开 ForDummies 原始文档 对照,或直接翻开 CheatSheet,开始编写你的第一批 C++ Mock 测试了。