Robomongo 仓库中的 Google Mock 入门指南:用 C++ 编写 Mock 类与交互测试
Robomongo 仓库中的 Google Mock 入门指南:用 C++ 编写 Mock 类与交互测试
导读
本文以 robomongo 仓库内置的 googlemock ForDummies.md 为主体,系统讲解 Google C++ Mocking Framework(Google Mock)的核心概念、Mock 类的定义方法、期望(Expectation)的设定语法,以及它在 C++ 单元测试中的应用流程。读完本文,你将掌握如何使用 MOCK_METHODn 宏快速生成 Mock 类、用 EXPECT_CALL / ON_CALL 描述调用次数、参数匹配与返回值行为,并能把这些技巧直接用于本仓库(以及任何基于 googletest 的 C++ 项目)的测试编写。
Google Mock 是什么:Mock 对象与交互验证
当你编写原型或测试时,往往不宜(也不现实)完全依赖真实对象。Mock 对象(mock object)实现了与真实对象相同的接口(因此可以被当作真实对象使用),但它允许你在运行时指定它将被如何使用、应当做什么——哪些方法会被调用?按什么顺序?调用多少次?带什么参数?返回什么?这些都可由测试代码预先规定。
在测试驱动开发(TDD)社区中,容易混淆两个术语:
- Fake(假对象):拥有可工作的实现,但通常走某种捷径(例如让操作更廉价),因此不适合生产环境。内存文件系统就是 fake 的典型例子。
- Mock(模拟对象):预先用**期望(expectations)**编程的对象,这些期望构成了"它应当收到哪些调用"的规格说明。
最关键的一点是:Mock 允许你检查被测代码与使用它的代码之间的交互(interaction),而不只是最终结果。Google Mock 之于 C++,正如 jMock、EasyMock 之于 Java。
Google Mock 的使用过程可归纳为三步:
- 用简单的宏描述你想要 Mock 的接口,宏会自动展开为 Mock 类的实现;
- 创建 Mock 对象,用直观的语法指定其期望与行为;
- 运行使用这些 Mock 对象的代码,一旦期望被违反,Google Mock 会立刻报告。
从仓库源码看,用户只需包含主头文件 gmock/gmock.h,它聚合了 actions、cardinalities、matchers、function-mockers、nice-strict 等全部子头文件,并在 testing 命名空间中声明了 InitGoogleMock() 与若干控制 flag。
为什么需要 Google Mock:手动 Mock 的痛点
在 C++ 中手工编写 Mock 是困难的:实现 Mock 既繁琐又易错;手写 Mock 的质量参差不齐;从一个 Mock 上学到的知识难以迁移到下一个。而 Java、Python 社区已有成熟的 Mock 框架,Mocking 在那里被证明是高效且广泛采用的技术。
Google Mock 专为 C++ 设计,以下场景都适合引入它:
- 你被困在次优设计中,希望更早、更频繁地做原型验证,而 C++ 的"快速原型"并不快速;
- 测试依赖过多库或昂贵资源(如数据库)而变得缓慢;
- 测试依赖不可靠的资源(如网络)而变得脆弱;
- 你想测试代码如何处理故障(如文件校验和错误),但难以人为制造;
- 你需要确认模块与其他模块的交互方式是否正确,但交互难以直接观察,只能事后观察副作用;
- 你想"Mock 掉"依赖,但它们还没有现成的 Mock 实现,你也不满意手写的那些。
因此 Google Mock 被鼓励用作两种工具:一是设计工具——让你早期、频繁地试验接口设计,更多迭代带来更好设计;二是测试工具——削减测试的外向依赖,探测模块与其协作者之间的交互。
快速开始:两个头文件
在 C++ 源文件中只需包含两个头文件即可开始:
#include "gtest/gtest.h"
#include "gmock/gmock.h"
仓库中 Google Mock 1.8.1 与 Google Test 同捆于 src/third-party/googletest-1.8.1 目录下,其中 googlemock/include/gmock/ 存放全部公开头文件,googletest/include/gtest/ 存放 Google Test 头文件。Google Mock 构建在 Google Test 之上并依赖它,官方建议使用捆绑的 Google Test 版本。
一个经典案例:Mock 乌龟(A Case for Mock Turtles)
假设你正在开发一个依赖 LOGO 式绘图 API 的图形程序,如何测试它画得对不对?运行后与"金图快照"对比是昂贵且脆弱的(换一块抗锯齿更好的显卡,所有金图都得更新)。正确的做法是依赖注入:不让应用直接调用绘图 API,而是把 API 包装成接口(例如 Turtle),让代码面向接口编程:
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 已经由他人实现;否则就自己写——Google Mock 把这件事变成了"游戏"。
如何定义 Mock 类
以 Turtle 接口为例,步骤如下:
- 从
Turtle派生一个类MockTurtle; - 取出
Turtle的一个 virtual 函数(用模板技术也可 Mock 非 virtual 方法,但复杂得多),数清它的参数个数; - 在子类的
public:区写MOCK_METHODn();(Mock const 方法用MOCK_CONST_METHODn();),其中n是参数个数——如果数错了,编译器会以报错的方式提醒你; - 把函数签名中函数名剪切粘贴为宏的第一个参数,剩余部分作为第二个参数(即函数的类型);
- 对所有想 Mock 的 virtual 函数重复上述过程。
完成后应得到类似代码:
#include "gmock/gmock.h" // Brings in 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 是一份 Pump 模板,其中 $var n = 10 声明了支持的最大参数个数为 10,并通过 $for i 循环展开生成 MOCK_METHOD0 到 MOCK_METHOD10 以及 _T、_WITH_CALLTYPE、MOCK_CONST_METHOD* 等全套变体;生成的 gmock-generated-function-mockers.h 可在同目录找到。每个 MOCK_METHODn 展开后会声明一个 FunctionMocker 成员(如 GMOCK_MOCKER_(...) 命名的 mutable ::testing::FunctionMocker<__VA_ARGS__>),并生成对应的期望设置方法 gmock_##Method(...)。
提示:如果连这一步都嫌多,Google Mock 还提供了 gmock_gen.py 工具(位于 googlemock/scripts/generator/gmock_gen.py,源自 cppclean 项目,以 Apache License 发布)。它需要 Python 2.4,你给它一个 C++ 文件及其中的抽象类名,它会打印出对应的 Mock 类定义。由于 C++ 语言复杂度,该脚本未必总能成功,但可用时相当方便。
Mock 类放在哪里
定义 Mock 类时需要决定放置位置。有人把它放进 *_test.cc:当被 Mock 的接口(如 Foo)归属同一人或同一团队时没问题;否则当 Foo 的维护者修改接口时,你的测试可能随之破碎。
经验法则:如果你要 Mock 的 Foo 归他人所有,就把 Mock 类定义在 Foo 所属的包中(最好放在 testing 子包里,以便清晰分离生产代码与测试工具),命名为 mock_foo.h。这样所有人测试时都能引用 mock_foo.h;Foo 一旦变化,只需修改一份 MockFoo,且只需修复依赖变化方法的那些测试。
另一种方式:在 Foo 之上引入薄适配层 FooAdaptor,代码面向新接口编程。虽然初期工作更多,但精心选择适配器接口能让代码更易写、更可读(长期看是净收益),因为你可以选择比 Foo 更贴合自身领域的 FooAdaptor。
在测试中使用 Mock
有了 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) {
// The following line must be executed to initialize Google Mock
// (and Google Test) before running the tests.
::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.
关于 InitGoogleMock:它必须在使用 Google Mock(以及 Google Test)之前执行。从 gmock.h 源码看,它解析命令行中 Google Mock 认识的 flag(如 --gmock_verbose、--gmock_catch_leaked_mocks),将其从 argv 移除并更新 argc;同时初始化 Google Test 并解析其 flag(如果尚未完成)。还提供了一个 wchar_t** 重载版本,供 Windows UNICODE 模式程序使用。
提示 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) {
// The following line causes Google Mock to throw an exception on failure,
// which will be interpreted by your testing framework as a test failure.
::testing::GTEST_FLAG(throw_on_failure) = true;
::testing::InitGoogleMock(&argc, argv);
... whatever your testing framework requires ...
}
这种做法的缺点是:有时会让 Mock 对象在析构函数中抛出异常,某些编译器下会导致测试程序崩溃——你仍能察觉测试失败,但不够优雅。更好的方案是利用 Google Test 的 事件监听器 API,实现事件监听器接口的 OnTestPartResult() 方法,把测试失败正确地报告给你的测试框架。如果嫌麻烦,官方建议直接用 Google Test——它与 Google Mock 无缝协作(事实上 Google Mock 在技术上就包含 Google Test)。
设定期望(Setting Expectations)
使用 Mock 对象成功的关键是设定恰到好处的期望:太严格,测试会因无关变化而失败;太宽松,bug 会溜走。Google Mock 提供了"恰到好处"的手段。
通用语法
用 EXPECT_CALL() 宏在 Mock 方法上设定期望,通用语法为:
EXPECT_CALL(mock_object, method(matchers))
.Times(cardinality)
.WillOnce(action)
.WillRepeatedly(action);
宏有两个参数:第一个是 Mock 对象,第二个是方法及其参数。注意两者用逗号(,)分隔而非句点(.)(这是技术原因造成的)。宏后可跟若干可选子句(clauses),提供期望的更多信息。
这种语法让期望读起来像英文。例如:
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 能在失败信息中包含期望所在的源文件位置,方便调试。这一点也可从 gmock.h 中注释给出的 ON_CALL / EXPECT_CALL 完整子句链看到。
Matchers:期望什么参数
当 Mock 函数带参数时,必须指定期望的参数。例如:
// Expects the turtle to move forward by 100 units.
EXPECT_CALL(turtle, Forward(100));
有时你不必过于具体(过度指定会导致脆弱的测试、掩盖测试意图,官方鼓励只指定必要的部分)。若只关心 Forward() 被调用而不关心参数,可用 _ 表示"任意值":
using ::testing::_;
...
// Expects the turtle to move forward.
EXPECT_CALL(turtle, Forward(_));
_ 是所谓 matcher(匹配器) 的一个实例。matcher 类似谓词,能测试参数是否符合预期;你可以在 EXPECT_CALL() 中任何函数参数的位置使用 matcher。内置 matcher 的完整列表见 CheatSheet。例如 Ge(大于等于):
using ::testing::Ge;
...
EXPECT_CALL(turtle, Forward(Ge(100)));
这检查乌龟被要求前进的步数至少为 100。此外还有 Eq/value、Gt、Le、Lt、Ne、IsNull()、NotNull()、Ref() 等比较类 matcher,以及浮点(DoubleEq、FloatNear)、字符串(StartsWith、EndsWith、HasSubstr、MatchesRegex)、容器(ElementsAre、UnorderedElementsAre、SizeIs)、成员(Field、Property、Pair)、指针(Pointee)、复合(AllOf、AnyOf、Not)等各类 matcher。
Cardinalities:期望调用多少次
EXPECT_CALL() 之后可指定的第一个子句是 Times(),其参数称为 cardinality(基数),说明调用应当发生多少次。它让你不必重复书写同样的期望多次;更重要的是,cardinality 可以像 matcher 一样"模糊",从而精确表达测试意图。
一个有趣的特殊情形是 Times(0):表示带给定参数的函数根本不应被调用,一旦(错误地)被调用,Google Mock 就会报告一次 Google Test 失败。AtLeast(n) 是模糊 cardinality 的例子,内置 cardinality 完整列表见 CheatSheet,包括 AnyNumber()、AtMost(n)、Between(m, n)、Exactly(n) 或直接用 n。
Times() 子句可以省略。省略时 Google Mock 会自动推断 cardinality,规则易于记忆:
- 若
EXPECT_CALL()中既没有WillOnce()也没有WillRepeatedly(),推断为Times(1); - 若有
n个WillOnce()但没有WillRepeatedly()(n >= 1),cardinality 为Times(n); - 若有
n个WillOnce()且有一个WillRepeatedly()(n >= 0),cardinality 为Times(AtLeast(n))。
小测验:一个函数预期被调用两次,实际被调用了四次,会发生什么?(提示:会触发上限违例失败。)
Actions:它应该做什么
Mock 对象没有真正的实现,用户必须告诉它在方法被调用时做什么。这很容易。
首先,如果 Mock 函数的返回类型是内置类型或指针,函数有默认动作(default action):void 函数直接返回,bool 函数返回 false,其他函数返回 0。C++11 及以上,返回类型可默认构造(有默认构造函数)的 Mock 函数,默认动作是返回一个默认构造的值。什么都不说就用这个行为。
其次,若 Mock 函数没有默认动作,或默认动作不合适,可以用一系列 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() 将被调用至少两次(两个 WillOnce() 加一个 WillRepeatedly() 且无显式 Times()),第一次返回 100,第二次返回 200,从第三次起返回 300。
当然,如果显式写了 Times(),Google Mock 不会自行推断。若指定次数大于 WillOnce() 子句数,那么在 WillOnce() 全部用完之后,Google Mock 每次都会执行该函数的默认动作(除非有 WillRepeatedly())。
WillOnce() 里除了 Return() 还能做什么?可以 ReturnRef(variable) 返回引用,或调用预定义函数等(更多见 CheatSheet 的 Actions 一节,如 ReturnArg<N>()、ReturnNew<T>(...)、ReturnNull()、ReturnPointee(ptr)、Assign(&var, value)、SetArgPointee<N>(value)、Invoke(f)、DoAll(...)、DoDefault() 等)。
重要注意: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 对象,然后每次都返回同一指针。若希望副作用每次发生,需要定义自定义动作(见 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 无序调用
默认情况下,即使前面的期望尚未满足,后面的期望也可能匹配某次调用——也就是说,调用不必按期望定义的顺序发生。
有时你希望所有期望的调用严格按顺序发生。在 Google Mock 中这很容易:
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 一节。更复杂的顺序约束还可使用 Sequence 与 .InSequence(s1, s2)、.After(expectation) 等子句。)
所有期望默认是"粘性"的
来做个小测验:如何测试乌龟被要求"走到原点"恰好两次(忽略它收到的其他指令)?参考答案:
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() 会匹配并立即导致"上限超限"错误——这段代码没什么用。
表达"依次返回 10、20、30……"的正确方式,是明确说明期望不粘,即饱和后立即退休(retire):
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();
}
}
顺便一提,期望不粘的另一种情形是它处于序列中:一旦序列中排在其后的另一个期望被使用,它自动退休(不再匹配任何调用)。
无趣的调用(Uninteresting Calls)
Mock 对象可能有很多方法,并非全部"有趣"。例如某些测试中你不关心 GetX()、GetY() 被调用了多少次。
在 Google Mock 中,如果对某方法不感兴趣,直接不提它即可。若该方法被调用,测试输出中会出现警告,但不算失败。这背后的机制在仓库源码中有明确实现:gmock-generated-nice-strict.h.pump 生成了三个类模板——NiceMock<MockFoo>(忽略所有无趣调用)、NaggyMock<MockFoo>(无趣调用发生时打印警告)、StrictMock<MockFoo>(把所有无趣调用视为错误)。其中指出"当前 Mock 默认是 naggy"(所以 MockFoo 与 NaggyMock<MockFoo> 行为相同)。它们"继承"基类构造函数,因此可以写 NiceMock<MockFoo>(5, "a") 来构造带参的 nice mock。注意已知限制:NiceMock/NaggyMock/StrictMock 只对直接在 MockFoo 类中通过 MOCK_METHOD* 宏定义的方法生效,且不支持嵌套使用。
在 Robomongo 仓库中的实际落地
本仓库在 src/third-party/googletest-1.8.1 中完整捆绑了 Google Mock 1.8.1 与 Google Test 1.8.1(含 googlemock、googletest 两个子目录及其 CMake 构建脚本)。虽然 Robomongo 自身的单元测试目前主要直接使用 Google Test 的 gtest/gtest_main 库(见 src/robomongo-unit-tests/CMakeLists.txt,其中按"测试文件 Foo_test.cpp + 源文件 Foo.cpp/Foo.h"的规范组织测试),但它为我们示范了 Google Test/Google Mock 生态在真实项目中的集成方式:
- 单元测试可执行文件
robo_unit_tests链接gtest、gtest_main及 Qt 等依赖;现有测试包括 RoboCrypt_test.cpp(对RoboCrypt::encrypt/decrypt做往返加解密的EXPECT_EQ断言)、StringOperations_test.cpp与HexUtils_test.cpp。 - Google Mock 自己的构建则通过 googlemock/CMakeLists.txt 定义
gmock与gmock_main两个库目标(gmock_main额外包含src/gmock_main.cc,提供带main()的入口),并可通过-Dgmock_build_tests=ON构建其全部自身测试。 - 若要在现有 CMake 项目中引入 Google Mock,官方做法是把
target_link_libraries(example gtest_main)改为target_link_libraries(example gmock_main),因为gmock_main库已随 Google Test 一起编译。
下一步
到这里,你已经掌握了足以开始使用 Google Mock 的知识。若想进一步提升,官方推荐阅读:
- CheatSheet:常用内容速查表,涵盖 Mock 类定义、Matchers、Actions、Cardinalities、期望顺序、验证与重置 Mock(
Mock::VerifyAndClearExpectations、Mock::VerifyAndClear、Mock::AllowLeak)以及--gmock_catch_leaked_mocks、--gmock_verbose等运行时 flag; - CookBook:高级技巧食谱,包括 Mock 非 virtual 方法、自定义 matcher/action、偏序期望、检查点等;
- FrequentlyAskedQuestions:包含"如何理解可怕的模板编译错误"等常见问题的解答(Google Mock Doctor)。
仓库内相关文档与源码均可直接查阅:教程原文 ForDummies.md、主头文件 gmock.h、宏生成模板 gmock-generated-function-mockers.h.pump 与 gmock-generated-nice-strict.h.pump。把期望设定在 Mock 方法被调用之前、把具体 matcher 放在宽泛 matcher 之后、善用 RetiresOnSaturation() 与 InSequence——记住这些要点,你就能写出既能精确捕捉 bug、又不会因无关变化而脆弱的 C++ 交互测试。