Robomongo 仓库中的 Google Mock 入门指南:用 C++ 编写 Mock 类与交互测试

原创2026-09-25 20:12:402,211 阅读
文章标签:桌面应用数据库客户端开发者工具

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 的使用过程可归纳为三步:

  1. 用简单的宏描述你想要 Mock 的接口,宏会自动展开为 Mock 类的实现;
  2. 创建 Mock 对象,用直观的语法指定其期望与行为;
  3. 运行使用这些 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 接口为例,步骤如下:

  1. 从 Turtle 派生一个类 MockTurtle;
  2. 取出 Turtle 的一个 virtual 函数(用模板技术也可 Mock 非 virtual 方法,但复杂得多),数清它的参数个数;
  3. 在子类的 public: 区写 MOCK_METHODn();(Mock const 方法用 MOCK_CONST_METHODn();),其中 n 是参数个数——如果数错了,编译器会以报错的方式提醒你;
  4. 把函数签名中函数名剪切粘贴为宏的第一个参数,剩余部分作为第二个参数(即函数的类型);
  5. 对所有想 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 类之后,典型工作流是:

  1. 从 testing 命名空间导入 Google Mock 的名字,以便不加限定符使用(每个文件只需一次);
  2. 创建若干 Mock 对象;
  3. 设定对它们的期望(方法会被调用多少次?带什么参数?应该做什么?);
  4. 运行使用 Mock 的代码;可选地用 Google Test 断言检查结果。如果 Mock 方法被调用次数超过期望或参数错误,会立即得到错误;
  5. 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++ 交互测试。

登录后查看全文
robomongo