Google Mock CookBook 实战全解:在 Weex 仓库中编写高质量 C++ 单元测试的完整指南
Google Mock CookBook 实战全解:在 Weex 仓库中编写高质量 C++ 单元测试的完整指南
本文以仓库 weex_core/test/third_party/googletest/googlemock/docs/CookBook.md 为骨架展开,系统讲解 Google Mock 从 Mock 类创建、Matcher 匹配、期望设置到自定义扩展的完整技术栈。Weex 的 C++ 核心(weex_core)在 test/src/CMakeLists.txt 中通过链接
gtest_main引入 Google Test/Google Mock 进行单元测试,本文所有概念均可直接落地到该测试体系中。读完你将掌握:如何为任意接口编写 Mock 类、如何用 Matcher 精确描述参数约束、如何用EXPECT_CALL/ON_CALL编排调用期望,以及如何用MATCHER*/ACTION*宏快速扩展测试框架。
Google Mock 运行在 testing 命名空间下。为了可读性,官方建议在文件中先写一次 using ::testing::Foo; 再使用 Google Mock 定义的符号;下文的示例出于简洁省略了这些 using 语句,但读者在自己的代码中应当补上。
一、创建 Mock 类:从接口到测试替身
1.1 对私有或受保护方法进行 Mock
无论被 Mock 的方法在基类中是 public、protected 还是 private,Mock 方法的定义(MOCK_METHOD*)必须始终放在 Mock 类的 public: 区段。这是因为 ON_CALL 和 EXPECT_CALL 需要在 Mock 类外部引用这些函数,而 C++ 允许子类以不同于基类的访问级别声明虚函数。例如:
class Foo {
public:
virtual bool Transform(Gadget* g) = 0;
protected:
virtual void Resume();
private:
virtual int GetTimeOut();
};
class MockFoo : public Foo {
public:
MOCK_METHOD1(Transform, bool(Gadget* g));
// 尽管基类中是 protected/private,这里必须放在 public 区段。
MOCK_METHOD0(Resume, void());
MOCK_METHOD0(GetTimeOut, int());
};
1.2 对重载方法进行 Mock
重载函数可以直接逐一 Mock,无需特殊处理。但需要注意 const 重载(如 GetBar() 与 GetBar() const)应分别使用 MOCK_METHOD0 与 MOCK_CONST_METHOD0:
class MockFoo : public Foo {
public:
MOCK_METHOD1(Add, int(Element x));
MOCK_METHOD2(Add, int(int times, Element x)); // 参数个数不同
MOCK_METHOD0(GetBar, Bar&());
MOCK_CONST_METHOD0(GetBar, const Bar&()); // const 重载
};
若只 Mock 其中一个版本,编译器会警告基类的其他重载被隐藏。解决办法是用 using Foo::Add; 把其余版本引入作用域:
class MockFoo : public Foo {
public:
using Foo::Add;
MOCK_METHOD1(Add, int(Element x)); // 故意不 Mock int Add(int, Element)
};
1.3 对类模板进行 Mock
Mock 类模板只需在 MOCK_* 宏后面追加 _T 后缀:
template <typename Elem>
class MockStack : public StackInterface<Elem> {
public:
MOCK_CONST_METHOD0_T(GetSize, int());
MOCK_METHOD1_T(Push, void(const Elem& x));
};
1.4 对非虚方法进行 Mock(高性能依赖注入)
Google Mock 支持对非虚函数进行 Mock,用于所谓 hi-perf dependency injection(高性能依赖注入)。此时 Mock 类与被 Mock 的类没有继承关系,只是包含相同签名的方法:
class ConcretePacketStream { // 真实类,所有成员都非虚
public:
void AppendPacket(Packet* new_packet);
const Packet* GetPacket(size_t packet_number) const;
size_t NumberOfPackets() const;
};
class MockPacketStream { // Mock 类,不继承任何类
public:
MOCK_CONST_METHOD1(GetPacket, const Packet*(size_t packet_number));
MOCK_CONST_METHOD0(NumberOfPackets, size_t());
};
由于两个类互不相关且方法非虚,选择用哪个类必须在编译期决定(而非运行期)。标准做法是把使用方模板化:
template <class PacketStream>
void CreateConnection(PacketStream* stream) { ... }
template <class PacketStream>
class PacketReader {
public:
void ReadPackets(PacketStream* stream, size_t packet_num);
};
生产代码用 CreateConnection<ConcretePacketStream>()、PacketReader<ConcretePacketStream>;测试代码用 MockPacketStream 实例化同一模板并设置 EXPECT_CALL。
1.5 对自由函数进行 Mock
自由函数(C 风格函数或静态方法)本身不能被 Mock,但可以把它包装进一个接口:定义抽象类 FileInterface,让具体类 File 调用自由函数 OpenFile。生产代码面向 FileInterface 编程,测试时即可轻松 Mock 整个接口。实践中多个相关函数往往可以放进同一个接口,因此每个函数的语法开销很低。
如果担心虚函数调用有性能开销且分析证实了这一点,可以结合上一节的非虚方法 Mock 技巧(templatize 编译期注入)来规避。
1.6 The Nice, the Strict, and the Naggy:三种 Mock 风格
当一个 Mock 方法没有任何 EXPECT_CALL 却仍被调用时,Google Mock 会打印 "uninteresting call"(无趣调用)警告。其设计理由是:接口可能在测试编写后新增方法,不应因为调用了测试不知道的方法就让测试失败;但同时这可能意味着测试有 bug,所以也不能保持沉默。
三种风格的区别如下:
| 风格 | 写法 | 无趣调用的处理 |
|---|---|---|
| Naggy(默认) | MockFoo mock_foo; |
打印警告,测试继续 |
| Nice | NiceMock<MockFoo> mock_foo; |
静默,不打印警告 |
| Strict | StrictMock<MockFoo> mock_foo; |
视为错误,测试失败 |
NiceMock<MockFoo> 是 MockFoo 的子类,任何接受 MockFoo 的地方都可以使用它,且它"继承"了 MockFoo 的构造函数(如 NiceMock<MockFoo> mock_foo(5, "hi");)。
使用时有几个来自 C++ 语言限制的注意事项:
NiceMock/StrictMock只对直接在MockFoo类中用MOCK_METHOD*宏定义的方法生效;如果 Mock 方法定义在MockFoo的基类中,则修饰可能失效(取决于编译器)。尤其不支持嵌套NiceMock<StrictMock<MockFoo>>。- 基 Mock 的构造函数不能有以非 const 引用传递的参数。
- 在
MockFoo的构造或析构期间,Mock 对象不是 nice 或 strict 的——因为此时虚函数会按基类语义解析。
最后一条重要建议:默认(naggy)用于开发调试测试,大多数情况下推荐 nice,strict 只作为最后手段,因为它会让测试变得脆弱、难以维护——无意义的重构都可能让 strict 测试失败。
1.7 简化接口而不破坏现有代码
当接口方法参数冗长(如日志 send() 有 7 个参数)时,直接在 Mock 中使用很不方便,而改造接口又需要改所有调用方。技巧是在 Mock 类中重分发:把长参数方法转成精简参数的 Mock 方法:
class ScopedMockLog : public LogSink {
public:
virtual void send(LogSeverity severity, const char* full_filename,
const char* base_filename, int line, const tm* tm_time,
const char* message, size_t message_len) {
Log(severity, full_filename, std::string(message, message_len));
}
MOCK_METHOD3(Log, void(LogSeverity severity, const string& file_path,
const string& message));
};
1.8 面向接口而非 Mock 具体类
遇到没有实现接口的具体类 Concrete 时,不要轻易把它的方法改成虚函数再来 Mock——把非虚函数变成虚函数会创建一个扩展点,削弱你对类不变量的控制。正确做法是"coding to interfaces":定义自己的接口,用适配器包住 Concrete,测试时 Mock 该接口。这虽然引入了虚调用开销和更多抽象,但换来更好的可测试性、可维护性,还能让接口更贴合你的问题域。
1.9 委托调用给 Fake(Delegate to Fake)
有时你已有一个非平凡的 Fake 实现(如 FakeFoo),希望在 Mock 中复用其默认行为,而不是在 Mock 里重复实现。模式是定义 DelegateToFake() 方法,在构造函数/设置阶段用 ON_CALL 配合 Invoke 把默认动作指向 Fake:
class MockFoo : public Foo {
public:
MOCK_METHOD1(DoThis, char(int n));
MOCK_METHOD2(DoThat, void(const char* s, int* p));
void DelegateToFake() { // 必须在使用自定义 ON_CALL 之前调用
ON_CALL(*this, DoThis(_)).WillByDefault(Invoke(&fake_, &FakeFoo::DoThis));
ON_CALL(*this, DoThat(_, _)).WillByDefault(Invoke(&fake_, &FakeFoo::DoThat));
}
private:
FakeFoo fake_;
};
此后未显式指定动作的调用都会落到 Fake 上;你仍可通过 ON_CALL 或 .WillOnce()/.WillRepeatedly() 覆盖默认行为。文档特别警告:混用 mock 与 fake 往往是设计有问题的信号(例如 System 类既管文件又管 I/O,角色过多),建议拆分接口,只在重构过渡期使用此技巧。
1.10 委托调用给真实对象(Delegating to Real)
当测试替身与真实对象行为出现偏差(有意模拟错误或无意写错)时,可以使用委托给真实对象的技术:Mock 对象负责验证调用(次数、参数、顺序),真实对象负责执行行为,"两全其美":
class MockFoo : public Foo {
public:
MockFoo() {
ON_CALL(*this, DoThis()).WillByDefault(Invoke(&real_, &Foo::DoThis));
ON_CALL(*this, DoThat(_)).WillByDefault(Invoke(&real_, &Foo::DoThat));
}
MOCK_METHOD0(DoThis, ...);
MOCK_METHOD1(DoThat, ...);
private:
Foo real_;
};
1.11 委托调用给父类(Delegating to Parent Class)
当需要 Mock 一个已有实现(非纯虚)的方法时,MOCK_METHOD1(Concrete, ...) 会遮蔽 Foo::Concrete()。若测试想调用真实实现(如作为 stub 动作),可以在 Mock 类中留一个"后门":
class MockFoo : public Foo {
public:
MOCK_METHOD1(Pure, void(int n));
MOCK_METHOD1(Concrete, int(const char* str));
int FooConcrete(const char* str) { return Foo::Concrete(str); } // 后门
};
然后用 EXPECT_CALL(foo, Concrete(_)).WillOnce(Invoke(&foo, &MockFoo::FooConcrete)); 或 ON_CALL(...).WillByDefault(...) 调用。不能直接写 Invoke(&foo, &Foo::Concrete)——因为 Foo::Concrete() 是虚函数,那样会递归调用 MockFoo::Concrete() 造成死循环。
二、使用 Matchers 精确描述参数
2.1 精确匹配、简单 Matcher 与组合
EXPECT_CALL(foo, DoThis(5)) 要求参数恰好等于 5;DoThat("Hello", bar) 要求第一个参数等于字符串 "Hello"、第二个参数等于 bar 对象。用 Matcher 可以表达"具有某种属性":
using ::testing::Ge;
using ::testing::NotNull;
using ::testing::Return;
EXPECT_CALL(foo, DoThis(Ge(5))) // 参数必须 >= 5
.WillOnce(Return('a'));
EXPECT_CALL(foo, DoThat("Hello", NotNull())); // 第二个参数不能是 NULL
_ 是最常用的通配 matcher,匹配任意值。用 AllOf()、AnyOf()、Not() 可以组合出复杂约束:
using ::testing::AllOf;
using ::testing::Gt;
using ::testing::HasSubstr;
using ::testing::Ne;
using ::testing::Not;
EXPECT_CALL(foo, DoThis(AllOf(Gt(5), Ne(10)))); // >5 且 !=10
EXPECT_CALL(foo, DoThat(Not(HasSubstr("blah")), NULL)); // 不含子串 "blah"
2.2 类型安全与 SafeMatcherCast
Google Mock 的 matcher 是静态类型的,用错类型(如用 Eq(5) 匹配 string)会被编译器拦下。但有时你确实知道自己在做什么,比如用一个 Matcher<long> 匹配 int 参数。此时可用 SafeMatcherCast<T>(m),它做三项安全检查(不满足则编译失败):
T能隐式转换为 matcher 接受类型U;- 当
T、U均为内建算术类型时,T→U的转换不损失精度; - 当
U是引用时,T也必须是引用。
MatcherCast<T>(m) 更宽松,只要 static_cast<T> 可行即可,本质上是绕过 C++ 类型系统,应谨慎使用。
2.3 选择重载函数
对 const 重载,用 Const() 包装器区分:
EXPECT_CALL(foo, GetBar()).WillOnce(ReturnRef(bar1)); // 非 const 版
EXPECT_CALL(Const(foo), GetBar()).WillOnce(ReturnRef(bar2)); // const 版
对参数类型不同但个数相同的重载,需要指定 matcher 的确切类型——用 Matcher<type>() 包装,或使用类型固定的 matcher(TypedEq<type>、An<type>() 等):
EXPECT_CALL(printer, Print(An<int>())); // 匹配 void Print(int);
EXPECT_CALL(printer, Print(Matcher<int>(Lt(5)))); // 匹配 void Print(int);
EXPECT_CALL(printer, Print(TypedEq<char>('a'))); // 匹配 void Print(char);
2.4 基于参数执行不同动作
Mock 方法被调用时,会选中仍然活跃的、最后匹配的那个期望("新的覆盖旧的")。因此可以先用通配 EXPECT_CALL(foo, DoThis(_)).WillRepeatedly(Return('b')); 设默认,再叠加更具体的 EXPECT_CALL(foo, DoThis(Lt(5))).WillRepeatedly(Return('a'));,实现按参数分流。
2.5 With():把多个参数当作整体匹配
单个参数的 matcher 无法表达"第一个参数小于第二个参数"这类约束,With() 子句可以:
EXPECT_CALL(foo, InRange(Ne(0), _))
.With(Lt());
With() 中的表达式必须是 Matcher< ::testing::tuple<A1, ..., An> > 类型。AllArgs(m) 与直接写 m 等价但更可读;Args<k1,...,kn>(m) 则选中指定下标参数组成的 tuple 交给 m:
EXPECT_CALL(foo, Blah(_, _, _))
.With(AllOf(Args<0, 1>(Lt()), Args<1, 2>(Lt()))); // x < y < z
若传入自定义谓词(如 Truly(&MyPredicate)),该谓词必须接受一个 ::testing::tuple 参数。
2.6 Matcher 与谓词的互相转换
- Matcher 当谓词用:用
Matches(m)把 matcher 包装成一元谓词 functor,可直接交给 STL<algorithm>:
const int count = count_if(v.begin(), v.end(), Matches(Ge(10)));
// 复杂组合:>=0 且 <=100 且 !=50
Matches(AllOf(Ge(0), Le(100), Ne(50)))
-
谓词当 matcher 用:用
Truly(predicate)包装任意一元谓词,返回值不必是bool,只要能用于if (condition)即可。 -
在 Google Test 断言中使用 matcher:
ASSERT_THAT(value, matcher)(致命)与EXPECT_THAT(value, matcher)(非致命),失败消息可读性极佳。例如EXPECT_THAT(Foo(), StartsWith("Hello"))失败时会输出 "Value of: Foo() / Actual: ... / Expected: starts with ..."。
2.7 匹配不可拷贝参数与对象成员
默认情况下 EXPECT_CALL(mock, Foo(bar)) 会保存 bar 的副本。对不可拷贝类型,可用 Eq(ByRef(bar))、Lt(ByRef(bar)) 让 Google Mock 保存引用(此时必须保证 bar 在期望存活期内不被修改,否则结果未定义)。
验证对象成员或 getter 返回值:
Field(&Foo::number, Ge(3)) // x.number >= 3
Property(&Foo::name, StartsWith("John ")) // x.name() 以 "John " 开头
注意 Property(&Foo::baz, ...) 中 baz() 必须无参且为 const。Field()/Property() 也支持裸指针(对 NULL 指针总是匹配失败);多个成员一起验证用 AllOf() 组合。
2.8 匹配指针指向的值:Pointee
Pointee(m) 匹配"指针指向的值满足 m"。它天然把 NULL 指针当作匹配失败,因此 Pointee(m) 可以替代 AllOf(NotNull(), Pointee(m)) 且不会崩溃。它同时支持裸指针和智能指针(shared_ptr、scoped_ptr 等),还可以嵌套(Pointee(Pointee(Lt(3))) 匹配双重指针)。
2.9 匹配容器
容器精确匹配可直接写 Eq(expected_container)。更灵活的方式是 ElementsAre() 与 UnorderedElementsAre():
EXPECT_CALL(mock, Foo(ElementsAre(1, Gt(0), _, 5))); // 顺序敏感
EXPECT_CALL(mock, Foo(UnorderedElementsAre(1, Gt(0), _, 5))); // 顺序无关
ElementsAre*() 重载支持 0 到 10 个参数,更多元素用 ElementsAreArray()(可传 C 风格数组、matcher 数组,或动态数组时额外传 size)。注意:
- 适用于任何实现 STL 迭代器模式(有
const_iterator与begin()/end())的容器; - 可嵌套匹配多维容器;
- 容器以指针传入时写
Pointee(ElementsAre*(...)); ElementsAre*()对顺序敏感,不要用于元素顺序未定义的容器(如hash_map)。
2.10 共享 Matcher
Matcher 对象内部是指向引用计数实现对象的指针,复制廉价。复杂 matcher 可以赋值给变量复用:
Matcher<int> in_range = AllOf(Gt(5), Le(10));
三、设置期望:ON_CALL 与 EXPECT_CALL
3.1 何时该用哪种:ON_CALL 是使用率最低的构造
ON_CALL 只定义"被调用时做什么",不隐含任何被调用的期望;EXPECT_CALL 不仅定义行为,还要求"方法将以给定参数、给定次数(及给定顺序)被调用"。文档强调:好的测试验证的是代码的契约,过度约束会让合法重构(如优化)反而弄坏测试。因此:
- 默认使用
ON_CALL,只在确实要验证"调用发生了"时才用EXPECT_CALL; - 一个测试只验证一件事;
- 在 fixture 中用
ON_CALL设置共享默认行为,在各TEST_F中稀疏地写EXPECT_CALL验证不同方面。
如果被无趣调用警告打扰,用 NiceMock 或在特定方法上加 EXPECT_CALL(...).Times(AnyNumber()),不要盲目堆 EXPECT_CALL。
3.2 忽略无趣调用与禁止意外调用
不关心某方法如何被调用就什么都不写,Google Mock 会执行默认动作让测试继续;不满意默认动作就用 DefaultValue<T>::Set() 或 ON_CALL() 覆盖。注意:一旦通过 EXPECT_CALL() 对某方法表达了兴趣,该方法的每次调用都必须匹配某个期望,否则就是错误。
明确禁止某方法被调用:EXPECT_CALL(foo, Bar(_)).Times(0);。允许部分调用、禁止其余:列出允许的期望,并给兜底期望加 .Times(AnyNumber()):
EXPECT_CALL(foo, Bar(5));
EXPECT_CALL(foo, Bar(Gt(10))).Times(AnyNumber());
3.3 无趣调用 vs 意外调用:两个截然不同的概念
- 无趣(uninteresting):对该方法完全没有任何
EXPECT_CALL。默认不是错误(不违反任何约束),但会警告。 - 意外(unexpected):存在
EXPECT_CALL但这次调用不匹配任何一个。意外调用永远是错误。
NiceMock 只抑制无趣警告,不改变意外调用的严重性;StrictMock 把无趣警告升级为错误。经典场景:EXPECT_CALL(mock_registry, GetDomainOwner("google.com")).WillRepeatedly(Return("Larry Page")); 会让 GetDomainOwner("yahoo.com") 变成意外调用错误,此时应加"兜底"期望(注意顺序,新期望优先):
EXPECT_CALL(mock_registry, GetDomainOwner(_)).Times(AnyNumber());
EXPECT_CALL(mock_registry, GetDomainOwner("google.com")).WillRepeatedly(Return("Larry Page"));
3.4 有序调用:InSequence 与 Sequence
默认情况下调用顺序不受限制。强制全序,用 InSequence 类把期望包在同一个块里:
{
InSequence s;
EXPECT_CALL(foo, DoThis(5));
EXPECT_CALL(bar, DoThat(_)).Times(2);
EXPECT_CALL(foo, DoThis(6));
}
部分有序(DAG 约束)用 Sequence 对象配合 .InSequence(s1, s2):
Sequence s1, s2;
EXPECT_CALL(foo, A()).InSequence(s1, s2); // s1: A->B, s2: A->C->D
EXPECT_CALL(bar, B()).InSequence(s1);
EXPECT_CALL(bar, C()).InSequence(s2);
EXPECT_CALL(foo, D()).InSequence(s2);
这表达:A 必须在 B 和 C 之前,C 在 D 之前;B 与 C、D 之间无顺序约束。与 After() 子句相比,InSequence() 在长串连续调用时更便捷(无需为期望起名)。
3.5 控制期望何时退休:RetiresOnSaturation
一个期望在创建时激活,当"必须先发生的调用"发生后退休。例如日志期望 #1 Times(AnyNumber()).InSequence(s1, s2) 会在 #2 或 #3 匹配后退休,之后若再出现 "File too large." 警告就是错误。
期望不会在饱和时自动退休——若两个警告都含 "File too large.",#2 会再次匹配并报上限超限错误。若希望"用一次就作废",加 .RetiresOnSaturation():
EXPECT_CALL(log, Log(WARNING, _, _)); // #1 兜底
EXPECT_CALL(log, Log(WARNING, _, "File too large.")) // #2 用一次即退休
.RetiresOnSaturation();
四、使用 Actions:让 Mock 方法有行为
4.1 返回引用与返回动态值
- 返回类型是引用时用
ReturnRef(x)(不能用Return())。 Return(x)在动作创建时保存x的副本,之后始终返回同一值。想返回"执行时的动态值":引用类型用ReturnRef;非引用类型 不能用Return(ByRef(x))(ByRef在创建时就被转换为具体值),必须用ReturnPointee(&x)——它在动作执行时取指针指向的值:
int x = 0;
EXPECT_CALL(foo, GetValue()).WillRepeatedly(ReturnPointee(&x));
x = 42;
EXPECT_EQ(42, foo.GetValue()); // 成功
4.2 DoAll:组合多个动作
DoAll(action_1, action_2, ..., action_n) 每次调用依次执行所有动作,只有最后一个动作的返回值被使用。
4.3 模拟副作用:SetArgPointee / SetArrayArgument
修改输出参数(指针参数指向的值):
EXPECT_CALL(mutator, Mutate(true, _)).WillOnce(SetArgPointee<1>(5)); // 写第 1 个参数
输出参数是数组时用 SetArrayArgument<N>(first, last),把源范围 first, last) 复制到第 N 个参数指向的数组;也支持输出迭代器(如 back_insert_iterator)。需要同时返回值时用 DoAll(SetArgPointee<0>(5), Return(true))。
4.4 基于状态改变 Mock 行为
用 InSequence 定义"调用前后行为不同":
{
InSequence seq;
EXPECT_CALL(my_mock, IsDirty()).WillRepeatedly(Return(true));
EXPECT_CALL(my_mock, Flush());
EXPECT_CALL(my_mock, IsDirty()).WillRepeatedly(Return(false));
}
更复杂的状态逻辑可用 SaveArg<0>(&var) 保存调用参数,配合 ReturnPointee(&var) 回读:
EXPECT_CALL(my_mock, GetPrevValue()).WillRepeatedly(ReturnPointee(&previous_value));
EXPECT_CALL(my_mock, UpdateValue(_)).WillRepeatedly(SaveArg<0>(&previous_value));
4.5 设置返回类型的默认值:DefaultValue
内建类型/指针默认返回 0;C++11 起带默认构造函数的类型默认返回默认构造值。想改变默认值或为未知类型指定默认值,用 ::testing::DefaultValue:
DefaultValue<Bar>::Set(default_bar);
EXPECT_CALL(foo, CalculateBar()); // 无需指定动作
foo.CalculateBar(); // 返回 default_bar
DefaultValue<Bar>::Clear(); // 用完清除
注意 DefaultValue<T> 是全局资源,会影响程序中所有存活的 Mock 对象,且不要在多个线程中或仍有 Mock 在工作时修改它;文档建议 Set()/Clear() 紧挨着使用代码,以便理解。
4.6 方法级默认动作:ON_CALL
类型级默认值粒度太粗时,用 ON_CALL 在方法级定制(后写的匹配优先,适合"先设共性、后设特例"):
ON_CALL(foo, Sign(_)).WillByDefault(Return(-1));
ON_CALL(foo, Sign(0)).WillByDefault(Return(0));
ON_CALL(foo, Sign(Gt(0))).WillByDefault(Return(1));
4.7 Invoke 系列:用函数/方法/functor 当动作
只要函数签名与 Mock 方法兼容(参数可隐式转换、返回类型可隐式转换),就能用 Invoke:
EXPECT_CALL(foo, Sum(_, _)).WillOnce(Invoke(CalculateSum)); // 自由函数
EXPECT_CALL(foo, ComplexJob(_)).WillOnce(Invoke(&helper, &Helper::ComplexJob)); // 成员函数
InvokeWithoutArgs(func):不传 Mock 参数,适合调用无参函数。InvokeArgument<N>(arg_1, ..., arg_m):调用 Mock 方法收到的第 N 个(0-based)可调用参数,并附上arg_1...arg_m。需要传引用时用ByRef()包一层;不包则传副本的引用(对临时值很友好,如InvokeArgument<0>(5.0, string("Hi")))。
4.8 IgnoreResult 与 WithArgs
IgnoreResult(action):丢弃非 void 动作的返回值,使其可用于返回 void 的 Mock 方法或DoAll非末尾位置(对已是 void 的动作使用会报编译错误)。WithArgs<N1, ..., Nk>(action):动作适配器,只把 Mock 方法的指定下标参数传给内层动作,避免手写适配函数:
EXPECT_CALL(mock, Foo(_, _, _, _, _, _, _))
.WillOnce(WithArgs<0, 2, 3>(Invoke(IsVisibleInQuadrant1)));
配套有 WithoutArgs(action) 与 WithArg<N>(action)(注意是单数 Arg);InvokeWithoutArgs(...) 即 WithoutArgs(Invoke(...)) 的语法糖。WithArgs 内层动作不限于 Invoke;可以重复/重排参数下标;被选参数类型不必精确匹配,只要可隐式转换。
4.9 用 Unused 忽略动作函数中不关心的参数
相比 WithArgs 包装,更简洁的做法是在动作函数里把不关心的参数声明为 Unused,这样同一动作可复用于多个不同签名的 Mock 方法:
double DistanceToOrigin(Unused, double x, double y) { return sqrt(x*x + y*y); }
EXPECT_CALL(mock, Foo("abc", _, _)).WillOnce(Invoke(DistanceToOrigin));
EXPECT_CALL(mock, Bar(5, _, _)).WillOnce(Invoke(DistanceToOrigin));
4.10 共享 Action 与状态
与 matcher 相同,action 对象内部也是引用计数的指针,复制廉价。无内部状态的 action 可赋值给变量复用:Action<bool(int*)> set_flag = DoAll(SetArgPointee<0>(5), Return(true));。但有内部状态的 action 不能共享:若 IncrementCounter(0) 生成带计数器的 action,两个 EXPECT_CALL 分别用 WillRepeatedly(IncrementCounter(0)) 则各自计数(1、2 与 1);若共用同一个 Action<int()> increment 变量则计数共享(1、2、3)。
五、进阶实战技巧
5.1 Mock 使用 Move-Only 类型的方法
std::unique_ptr<T> 等 move-only 类型可直接出现在 MOCK_METHOD 签名中。返回 move-only 值用 Return(ByMove(...))——ByMove() 必不可少,去掉将无法编译;且该动作只能执行一次(move 之后源值已被消耗,重复执行会运行期报错)。更灵活的方式是直接用 lambda:
EXPECT_CALL(mock_buzzer_, MakeBuzz("x"))
.WillRepeatedly([ {
return MakeUnique<Buzz>(AccessLevel::kInternal);
});
接收 move-only 参数的 Mock 方法基本可正常使用 Return 或 lambda,但 WithArgs、SaveArg、DeleteArg 等内置动作对 move-only 参数的支持尚未实现;DoAll 会内部拷贝参数,无法用于不可拷贝对象,需改用 functor。对于 2017 年 4 月之前的旧代码,文档记录了经典的 DoShareBuzz(Buzz*) 中转委托 workaround(将 ShareBuzz(unique_ptr) 转发给一个接收裸指针的 Mock 方法再设期望),如今已无必要,仅作参考。
5.2 加速编译:把构造函数/析构函数移出类体
Mock 类的构造/析构承担大量工作(期望验证等),且不同签名的方法类型不同导致编译器需分别生成。若头文件被 N 个文件 include,就会重复生成 N 次。解决:在 .h 中只声明 MockFoo(); 与 virtual ~MockFoo();,把空实现放到 .cpp:
// mock_foo.cpp
#include "path/to/mock_foo.h"
MockFoo::MockFoo() {}
MockFoo::~MockFoo() {}
5.3 强制验证:Mock::VerifyAndClearExpectations
Mock 对象在析构时自动验证所有期望并报告 Google Test 失败。但若对象由被测代码持有且可能未被正确释放,就会"测试通过却有 bug"。可强制验证:
Mock::VerifyAndClearExpectations(foo); // 返回 bool,可包在 ASSERT_TRUE 中
Mock::VerifyAndClear(&mock) 额外清除 ON_CALL 默认动作。这也是实现"检查点"(phases)的手段:在 SetUp() 把被测对象调整到目标状态后清空期望,在 TEST_F 中重新设置。另一个检查点技巧是用 MockFunction<F> 定义虚拟的 Call() 方法作为显式检查点,配合 InSequence 验证"某两段代码之间不应发生任何 Mock 调用":
MockFunction<void(string check_point_name)> check;
{
InSequence s;
EXPECT_CALL(mock, Bar("a"));
EXPECT_CALL(check, Call("1"));
EXPECT_CALL(check, Call("2"));
EXPECT_CALL(mock, Bar("a"));
}
5.4 Mock 析构函数
MOCK_METHOD0(~MockFoo, void()) 无法编译(析构函数是特殊函数)。标准模式是加一个 Die() 方法并在析构中调用它:
class MockFoo : public Foo {
public:
MOCK_METHOD0(Die, void());
virtual ~MockFoo() { Die(); }
};
于是"何时销毁"就转化为"何时调用 Die()",可放入 InSequence 约束,例如断言 *foo 在 bar->A() 之后、bar->B() 之前销毁。
5.5 Mock 与线程
以下规则仅适用于支持 pthreads 的平台(Linux、Mac 等,即 Google Mock 线程安全的平台):
- 测试代码(非被测代码)尽量在单线程中执行;
- 步骤 1(创建 Mock)无需加锁;步骤 2 与 5(设置期望/销毁)时确保没有其他线程访问
foo; - 步骤 3、4 可在任意线程进行,Google Mock 自行处理锁。
Google Mock 保证动作在调用它的线程中执行,但不保证不同线程的动作之间有顺序(强加顺序可能死锁,需要时自行加同步)。违反上述规则(如另一线程正在调用方法时设置期望)是未定义行为。
5.6 控制输出:--gmock_verbose
--gmock_verbose=LEVEL 有三个级别:
| 级别 | 输出内容 |
|---|---|
info |
所有信息、警告与错误(最详细,并记录所有 ON_CALL/EXPECT_CALL 调用) |
warning |
警告与错误(默认) |
error |
仅错误(最简) |
也可在代码中 ::testing::FLAGS_gmock_verbose = "error"; 动态设置。用 --gmock_verbose=info 可以"透视"每次 Mock 调用:输出会列出每条 EXPECT_CALL 被哪些调用命中、实际参数值以及未满足期望的调用次数统计,是排查"期望没匹配上"的利器(例如发现某个 EXPECT_CALL 里的字符串打错了,实际调用被更早的通配期望截获)。
5.7 在 Emacs 中运行测试与融合源码文件
在 Emacs 中构建运行测试时,错误位置会被高亮,<Enter> 跳转到出错行,C-x `` 跳到下一个错误。可在 ~/.emacs中绑定M-m 为编译、M-up/M-down` 在错误间跳转。
若想减少文件数量便于拷贝移植,官方提供实验性 Python 脚本 fuse_gmock_files.py(1.2.0 起可用),在 Python 2.4+ 环境下运行 python fuse_gmock_files.py OUTPUT_DIR 即可生成 gtest/gtest.h、gmock/gmock.h、gmock-gtest-all.cc 三个文件,包含使用 Google Mock 与 Google Test 所需的全部内容。
六、扩展 Google Mock:编写自己的 Matcher 与 Action
6.1 MATCHER* 宏:快速定义新 Matcher
MATCHER(name, description_string_expression) { statements; }
定义名为 name 的 matcher,statements 返回 bool 表示是否匹配;体内用 arg 引用被匹配值、arg_type 引用其类型。描述字符串可用 negation 变量区分正反描述;留空 "" 则自动用 matcher 名字生成描述:
MATCHER(IsDivisibleBy7, "") { return (arg % 7) == 0; }
通过 result_listener 可以流式补充匹配失败的额外信息,让报错更友好:
MATCHER(IsDivisibleBy7, "") {
if ((arg % 7) == 0) return true;
*result_listener << "the remainder is " << (arg % 7);
return false;
}
matcher 具有多态性(arg_type 由使用上下文决定);matcher 逻辑必须是纯函数——不得有副作用,尤其不能调用 Mock 函数(会影响 Mock 状态)。
6.2 参数化 Matcher:MATCHER_P* 系列
MATCHER_P(name, param, desc) 到 MATCHER_P10 支持带参数的 matcher,体内可用 param_type 引用参数类型:
MATCHER_P2(InClosedRange, low, hi,
std::string(negation ? "isn't" : "is") + " in range [" +
PrintToString(low) + ", " + PrintToString(hi) + "]") {
return low <= arg && arg <= hi;
}
描述字符串属于 matcher 的某个实例,因此通常要引用参数值(用 PrintToString)。类型上 MATCHER_Pk(Foo, p1, ..., pk, desc) 等价于模板工厂 FooMatcherPk<p1_type, ..., pk_type> Foo(...);不满意类型推导时可用 Foo<long, bool>(5, false) 显式实例化。matcher 可按参数个数重载(MATCHER_P(Blah, a, ...) 与 MATCHER_P2(Blah, a, b, ...))。
6.3 单态 Matcher:实现 MatcherInterface
需要更细类型控制(更好的编译错误信息)时,实现 ::testing::MatcherInterface<T>——接口含 MatchAndExplain(T, MatchResultListener*)(纯虚)、DescribeTo(ostream*)(纯虚)与 DescribeNegationTo(ostream*) 三个方法,再用 MakeMatcher 工厂包装:
class DivisibleBy7Matcher : public MatcherInterface<int> {
public:
virtual bool MatchAndExplain(int n, MatchResultListener* listener) const {
const int remainder = n % 7;
if (remainder != 0) *listener << "the remainder is " << remainder;
return remainder == 0;
}
virtual void DescribeTo(::std::ostream* os) const { *os << "is divisible by 7"; }
virtual void DescribeNegationTo(::std::ostream* os) const { *os << "is not divisible by 7"; }
};
inline Matcher<int> DivisibleBy7() { return MakeMatcher(new DivisibleBy7Matcher); }
6.4 多态 Matcher:MakePolymorphicMatcher
MakeMatcher 生成的 matcher 只针对单一参数类型。多态 matcher(如 Eq()、NotNull())用 MakePolymorphicMatcher:定义可拷贝的实现类(含 MatchAndExplain/DescribeTo/DescribeNegationTo,可为模板方法或普通方法,无需继承、方法无需虚),再包一层工厂:
class NotNullMatcher {
public:
template <typename T>
bool MatchAndExplain(T* p, MatchResultListener*) const { return p != NULL; }
void DescribeTo(::std::ostream* os) const { *os << "is not NULL"; }
void DescribeNegationTo(::std::ostream* os) const { *os << "is NULL"; }
};
inline PolymorphicMatcher<NotNullMatcher> NotNull() {
return MakePolymorphicMatcher(NotNullMatcher());
}
6.5 自定义 Cardinality:CardinalityInterface
Times() 接受的调用次数约束不必是精确值(如 AtLeast(5)、Between(2, 4))。内置不够用时实现 CardinalityInterface(IsSatisfiedByCallCount、IsSaturatedByCallCount、DescribeTo 三个纯虚方法),再用 MakeCardinality 包装。例如"必须被调用偶数次":
class EvenNumberCardinality : public CardinalityInterface {
public:
virtual bool IsSatisfiedByCallCount(int c) const { return (c % 2) == 0; }
virtual bool IsSaturatedByCallCount(int c) const { return false; }
virtual void DescribeTo(::std::ostream* os) const { *os << "called even number of times"; }
};
Cardinality EvenNumber() { return MakeCardinality(new EvenNumberCardinality); }
6.6 ACTION* 宏:快速定义新 Action
在命名空间作用域写 ACTION(name) { statements; } 即定义名为 name 的动作,statements 的返回值即动作返回值;体内用 argK 引用第 K 个(0-based)Mock 参数。无需声明参数类型,编译器保证类型安全:
ACTION(IncrementArg1) { return ++(*arg1); }
ACTION(Foo) {
(*arg2)(5); // 调用第 2 个参数(函数指针)
Blah();
*arg1 = 0;
return arg0;
}
体内还有预定义符号:argK_type(参数类型)、args(参数 tuple)、args_type、return_type、function_type。例如对 int DoSomething(bool flag, int* ptr):arg0=flag、arg1=ptr、args_type=::testing::tuple<bool, int*>、function_type=int(bool, int*)。
6.7 参数化 Action:ACTION_P* 与 ACTION_TEMPLATE
ACTION_P(name, param):带一个参数的动作,体内用param与param_type;ACTION_P2/ACTION_P3等支持多参数(如ACTION_P2(ReturnDistanceTo, x, y))。ACTION可视为 0 参数的特例;可按参数个数重载(ACTION_P(Plus, a)与ACTION_P2(Plus, a, b))。- 限制参数类型:可用
::testing::StaticAssertTypeEq<const char*, arg1_type>()(Google Test 的编译期断言)或把参数赋给目标类型变量。 ACTION_TEMPLATE(ActionName, HAS_m_TEMPLATE_PARAMS(kind1, name1, ...), AND_n_VALUE_PARAMS(p1, ...)):显式模板参数(kind可为typename、整型常量或模板)+ 值参数,如:
ACTION_TEMPLATE(DuplicateArg,
HAS_2_TEMPLATE_PARAMS(int, k, typename, T),
AND_1_VALUE_PARAMS(output)) {
*output = T(::testing::get<k>(args));
}
// 使用:EXPECT_CALL(mock, Foo(_, _)).WillOnce(DuplicateArg<1, unsigned char>(&n));
action 对象的类型有固定命名规则:ACTION(Foo) 的 Foo() 类型为 FooAction;ACTION_P(Bar, p) 的 Bar(int) 类型为 BarActionP<int>;ACTION_P2(Baz, p1, p2) 类型为 BazActionP2<bool, int>(ACTION_TEMPLATE 前缀模板参数)。不同参数个数用不同后缀以便重载。
6.8 手写单态/多态 Action
- 单态:实现
::testing::ActionInterface<F>(F为 Mock 函数类型),重写Perform(const ArgumentTuple& args),用::testing::get<i>(args)取参数,MakeAction包装:
class IncrementArgumentAction : public ActionInterface<IncrementMethod> {
public:
virtual int Perform(const ::testing::tuple<int*>& args) {
int* p = ::testing::get<0>(args);
return *p++;
}
};
Action<IncrementMethod> IncrementArgument() { return MakeAction(new IncrementArgumentAction); }
- 多态:定义含
template <typename Result, typename ArgumentTuple> Result Perform(const ArgumentTuple& args) const方法模板的实现类(无需继承),用MakePolymorphicAction包装。例如"返回第二个参数"的 action 可用于不同签名的多个 Mock 方法:foo.DoThis(true, 5)返回 5,foo.DoThat(1, "Hi", "Bye")返回 "Hi"。
6.9 教会 Google Mock 打印你的自定义类型
当无趣/意外调用发生或断言失败时,Google Mock/Google Test 用 Google Test 的可扩展值打印器输出参数值。它认识内建类型、原生数组、STL 容器和所有支持 << 的类型;其他类型则输出原始字节。通过 Google Test 的进阶指南(advanced.md)可以为自定义类型扩展打印逻辑,得到可读的输出。
七、在 Weex 仓库中的落地实践
本文讲解的整套 Google Mock 能力已被 Weex 核心引擎的测试体系真实采用:
- 测试依赖通过 CMake 引入:根测试工程 weex_core/test/CMakeLists.txt(
project(WeexCoreTest),C++14,enable_testing())依次add_subdirectory(third_party)与add_subdirectory(src);weex_core/test/src/CMakeLists.txt 定义可执行文件HelloTest并链接gtest_main,注册为 CTest 用例WeexTests。 - 冒烟测试示例:HelloTest.cpp 使用
TEST(WsonTest, ParseTest)与EXPECT_EQ(1, 1),展示了 Google Test 宏在引擎测试中的直接用法。 - 构建与运行脚本:init.sh(
cmake ../)与 test.sh(make test)给出了从配置到执行的完整流程。 - 完整框架源码位于 weex_core/test/third_party/googletest/:
googlemock/include/gmock/下可查阅 gmock.h、gmock-matchers.h、gmock-actions.h、gmock-spec-builders.h、gmock-nice-strict.h 等实现细节;gmock-function-mocker.h 定义了MOCK_METHOD*系列宏的底层实现。
结语
Google Mock 的价值在于把"验证调用"从笨拙的断言堆叠升级为声明式的契约描述:MOCK_METHOD* 声明替身,Matcher 描述参数约束,EXPECT_CALL/ON_CALL 编排行为与期望,InSequence/Sequence 表达顺序语义,MATCHER*/ACTION* 提供无限扩展空间。结合 Weex 仓库中现成的 googletest 集成,你可以在引擎的 C++ 测试中直接应用本文的全部配方。建议继续阅读配套文档 ForDummies.md(入门)、CheatSheet.md(速查表)与 FrequentlyAskedQuestions.md(FAQ),并结合 gmock-matchers_test.cc、gmock-actions_test.cc、gmock-nice-strict_test.cc 等官方测试来印证每个配方的实际行为。