Content
Matcher（匹配器） 基数（Cardinalities） 行为（Actions） 序列（Sequences） Google Mock 入门 概述 Google Mock使用 Mock实践 Google Mock Cookbook 什么是Mock? Google Mock概述 参考文档 最简单的例子 典型的流程 自定义方法/成员函数的期望行为 我改过的例子 现实中的例子 Mock protected、private方法 Mock 模版类（Template Class） Nice Mocks 和 Strict Mocks

Google Mock 入门

概述

什么是Mock?

Mock，更确切地说应该是Mock Object。它究竟是什么？它有什么作用？在这里，我也只能先说说我的理解。 比如当我们在单元测试、模块的接口测试时，当这个模块需要依赖另外一个/几个类，而这时这些个类还没有开发好（那名开发同学比较懒，呵呵），这时我们就可以定义了Mock对象来模拟那些类的行为。
说得更直白一些，就是自己实现一个假的依赖类，对这个类的方法你想要什么行为就可以有什么行为，你想让这个方法返回什么结果就可以返回怎么样的结果。
但这时很多同学往往会提出一个问题："那既然是我自己实现一个假的依赖类"，那和那些市面上的Mock框架有什么关系啊？
这个其实是这样的，这些个Mock框架可以帮助你比较方便、比较轻松地实现这些个假的依赖类。毕竟，如果你实现这么一个假的依赖类的时间花费过场的话，那我还不如等待那位懒惰的同学吧。

Google Mock概述

Google Mock（简称gmock）是Google在2008年推出的一套针对C++的Mock框架，它灵感取自于jMock、EasyMock、harcreat。它提供了以下这些特性：

• 轻松地创建mock类
• 支持丰富的匹配器（Matcher）和行为（Action）
• 支持有序、无序、部分有序的期望行为的定义
• 多平台的支持

参考文档

• 新人手册
• Cheat Sheet
• Cheat Sheet中文翻译
• Cookbook

Google Mock使用

最简单的例子

我比较喜欢举例来说明这些个、那些个玩意，因此我们先来看看Google Mock就简单的用法和作用。

• 首先，那个懒惰的同学已经定义好了这么一个接口（万幸，他至少把接口定义好了）：

FooInterface.h

1. #ifndef FOOINTERFACE_H_
2. #define FOOINTERFACE_H_
3.  
4. #include <string>
5.  
6. namespace seamless {
7.  
8. class FooInterface {
9. public:
10.         virtual ~FooInterface() {}
11.  
12. public:
13.         virtual std::string getArbitraryString() = 0;
14. };
15.  
16. }  // namespace seamless
17.  
18. #endif // FOOINTERFACE_H_

现在我们用Google Mock来定义Mock类 FooMock.h

1. #ifndef MOCKFOO_H_
2. #define MOCKFOO_H_
3.  
4. #include <gmock/gmock.h>
5. #include <string>
6. #include "FooInterface.h"
7.  
8. namespace seamless {
9.  
10. class MockFoo: public FooInterface {
11. public:
12.         MOCK_METHOD0(getArbitraryString, std::string());
13. };
14.  
15. }  // namespace seamless
16.  
17. #endif // MOCKFOO_H_

FooMain.cc

1. #include <cstdlib>
2. #include <gmock/gmock.h>
3. #include <gtest/gtest.h>
4. #include <iostream>
5. #include <string>
6.  
7. #include "MockFoo.h"
8.  
9. using namespace seamless;
10. using namespace std;
11.  
12. using ::testing::Return;
13.  
14. int main(int argc, char** argv) {
15.         ::testing::InitGoogleMock(&argc, argv);
16.  
17.         string value = "Hello World!";
18.         MockFoo mockFoo;
19.         EXPECT_CALL(mockFoo, getArbitraryString()).Times(1).
20.                 WillOnce(Return(value));
21.         string returnValue = mockFoo.getArbitraryString();
22.         cout << "Returned Value: " << returnValue << endl;
23.  
24.         return EXIT_SUCCESS;
25. }

最后我们运行编译，得到的结果如下：

 

这就是我们最简单的使用Google Mock的例子了，使用起来的确比较简便吧。

典型的流程

通过上述的例子，已经可以看出使用Mock类的一般流程如下：

• 引入你要用到的Google Mock名称. 除宏或其它特别提到的之外所有Google Mock名称都位于*testing*命名空间之下.
• 建立模拟对象(Mock Objects).
• 可选的,设置模拟对象的默认动作.
• 在模拟对象上设置你的预期(它们怎样被调用,应该怎样回应?).

自定义方法/成员函数的期望行为

从上述的例子中可以看出，当我们针对懒同学的接口定义好了Mock类后，在单元测试/主程序中使用这个Mock类中的方法时最关键的就是对期望行为的定义。
对方法期望行为的定义的语法格式如下：

1. EXPECT_CALL(mock_object, method(matcher1, matcher2, ...))
2.     .With(multi_argument_matcher)
3.     .Times(cardinality)
4.     .InSequence(sequences)
5.     .After(expectations)
6.     .WillOnce(action)
7.     .WillRepeatedly(action)
8.     .RetiresOnSaturation();

我稍微先举个例子来说明一下，后面有针对更为详细的说明：

1. EXPECT_CALL(mockTurtle, getX()).Times(testing::AtLeast(5)).
2.                 WillOnce(testing::Return(100)).WillOnce(testing::Return(150)).
3.                 WillRepeatedly(testing::Return(200))

Matcher（匹配器）

Matcher用于定义Mock类中的方法的形参的值（当然，如果你的方法不需要形参时，可以保持match为空。），它有以下几种类型：（更详细的介绍可以参见Google Mock Wiki上的Matcher介绍）
通配符

一般比较

浮点数的比较

字符串匹配
这里的字符串即可以是C风格的字符串，也可以是C++风格的。

容器的匹配
很多STL的容器的比较都支持==这样的操作，对于这样的容器可以使用上述的Eq(container)来比较。但如果你想写得更为灵活，可以使用下面的这些容器匹配方法：

上述的一些匹配器都比较简单，我就随便打包举几最简单的例子演示一下吧： 我稍微修改一下之前的Foo.h和MockFoo.h， MockFoo.h 增加了2个方法

1. #ifndef MOCKFOO_H_
2. #define MOCKFOO_H_
3.  
4. #include <gmock/gmock.h>
5. #include <string>
6. #include <vector>
7. #include "FooInterface.h"
8.  
9. namespace seamless {
10.  
11. class MockFoo: public FooInterface {
12. public:
13.         MOCK_METHOD0(getArbitraryString, std::string());
14.         MOCK_METHOD1(setValue, void(std::string& value));
15.         MOCK_METHOD2(setDoubleValues, void(int x, int y));
16. };
17.  
18. }  // namespace seamless
19.  
20. #endif // MOCKFOO_H_

FooMain.h

1. #include <cstdlib>
2. #include <gmock/gmock.h>
3. #include <iostream>
4. #include <string>
5.  
6. #include "MockFoo.h"
7.  
8. using namespace seamless;
9. using namespace std;
10.  
11. using ::testing::Assign;
12. using ::testing::Eq;
13. using ::testing::Ge;
14. using ::testing::Return;
15.  
16. int main(int argc, char** argv) {
17.         ::testing::InitGoogleMock(&argc, argv);
18.  
19.         string value = "Hello World!";
20.         MockFoo mockFoo;
21.  
22.         EXPECT_CALL(mockFoo, setValue(testing::_));
23.         mockFoo.setValue(value);
24.  
25.         // 这里我故意犯错
26.         EXPECT_CALL(mockFoo, setDoubleValues(Eq(1), Ge(1)));
27.         mockFoo.setDoubleValues(1, 0);
28.  
29.         return EXIT_SUCCESS;
30. }

上述的那些匹配器都比较简单，下面我们来看看那些比较复杂的匹配吧。
成员匹配器

还是举例说明一下：

1. TEST(TestField, Simple) {
2.         MockFoo mockFoo;
3.         Bar bar;
4.         EXPECT_CALL(mockFoo, get(Field(&Bar::num, Ge(0)))).Times(1);
5.         mockFoo.get(bar);
6. }
7.  
8. int main(int argc, char** argv) {
9.         ::testing::InitGoogleMock(&argc, argv);
10.         return RUN_ALL_TESTS();
11. }

上面这个是正确的例子，我们为了说明Field的作用，传入一个bar.num = -1试试。

1. TEST(TestField, Simple) {
2.         MockFoo mockFoo;
3.         Bar bar;
4.         bar.num = -1;
5.         EXPECT_CALL(mockFoo, get(Field(&Bar::num, Ge(0)))).Times(1);
6.         mockFoo.get(bar);
7. }

匹配函数或函数对象的返回值

指针匹配器

复合匹配器

1. EXPECT_CALL(foo, DoThis(AllOf(Gt(5), Ne(10))));

1. EXPECT_CALL(foo, DoThat(Not(HasSubstr("blah")), NULL));

基数（Cardinalities）

基数用于Times()中来指定模拟函数将被调用多少次|

行为（Actions）

Actions（行为）用于指定Mock类的方法所期望模拟的行为：比如返回什么样的值、对引用、指针赋上怎么样个值，等等。 值的返回

另一面的作用（Side Effects）

使用函数或者函数对象（Functor）作为行为

复合动作

这里我举个例子来解释一下DoAll()的作用，我个人认为这个DoAll()还是挺实用的。例如有一个Mock方法：

1. virtual int getParamter(std::string* name,  std::string* value) = 0

对于这个方法，我这回需要操作的结果是将name指向value的地址，并且得到方法的返回值。
类似这样的需求，我们就可以这样定义期望过程：

1. TEST(SimpleTest, F1) {
2.     std::string* a = new std::string("yes");
3.     std::string* b = new std::string("hello");
4.     MockIParameter mockIParameter;
5.     EXPECT_CALL(mockIParameter, getParamter(testing::_, testing::_)).Times(1).\
6.         WillOnce(testing::DoAll(testing::Assign(&a, b), testing::Return(1)));
7.     mockIParameter.getParamter(a, b);
8. }

序列（Sequences）

默认时，对于定义要的期望行为是无序（Unordered）的，即当我定义好了如下的期望行为：

1.         MockFoo mockFoo;
2.         EXPECT_CALL(mockFoo, getSize()).WillOnce(Return(1));
3.         EXPECT_CALL(mockFoo, getValue()).WillOnce(Return(string("Hello World")));

但有时候我们需要定义有序的（Ordered）的调用方式，即序列 (Sequences) 指定预期的顺序. 在同一序列里的所有预期调用必须按它们指定的顺序发生; 反之则可以是任意顺序.

1. using ::testing::Return;
2. using ::testing::Sequence;
3.  
4. int main(int argc, char **argv) {
5.         ::testing::InitGoogleMock(&argc, argv);
6.  
7.         Sequence s1, s2;
8.         MockFoo mockFoo;
9.         EXPECT_CALL(mockFoo, getSize()).InSequence(s1, s2).WillOnce(Return(1));
10.         EXPECT_CALL(mockFoo, getValue()).InSequence(s1).WillOnce(Return(
11.                 string("Hello World!")));
12.         cout << "First:\t" << mockFoo.getSize() << endl;
13.         cout << "Second:\t" << mockFoo.getValue() << endl;
14.  
15.         return EXIT_SUCCESS;
16. }

当我尝试一下把mockFoo.getSize()和mockFoo.getValue()的调用对调时试试：

1.         cout << "Second:\t" << mockFoo.getValue() << endl;
2.         cout << "First:\t" << mockFoo.getSize() << endl;

另外，我们还有一个偷懒的方法，就是不要这么傻乎乎地定义这些个Sequence s1, s2的序列，而根据我定义期望行为（EXPECT_CALL）的顺序而自动地识别调用顺序，这种方式可能更为地通用。

1. using ::testing::InSequence;
2. using ::testing::Return;
3.  
4. int main(int argc, char **argv) {
5.         ::testing::InitGoogleMock(&argc, argv);
6.  
7.         InSequence dummy;
8.         MockFoo mockFoo;
9.         EXPECT_CALL(mockFoo, getSize()).WillOnce(Return(1));
10.         EXPECT_CALL(mockFoo, getValue()).WillOnce(Return(string("Hello World")));
11.  
12.         cout << "First:\t" << mockFoo.getSize() << endl;
13.         cout << "Second:\t" << mockFoo.getValue() << endl;
14.  
15.         return EXIT_SUCCESS;
16. }

Mock实践

下面我从我在工作中参与的项目中选取了一个实际的例子来实践Mock。
这个例子的背景是用于搜索引擎的：

• 引擎接收一个查询的Query，比如http://127.0.0.1/search?q=mp3&retailwholesale=0&isuse_alipay=1
• 引擎接收到这个Query后，将解析这个Query，将Query的Segment（如q=mp3、retail_wholesale=0放到一个数据结构中）
• 引擎会调用另外内部模块具体根据这些Segment来处理相应的业务逻辑。

由于Google Mock不能Mock模版方法，因此我稍微更改了一下原本的接口，以便演示：

我改过的例子

我们先来看看引擎定义好的接口们：
VariantField.h 一个联合体，用于保存Query中的Segment的值

1. #ifndef VARIANTFIELD_H_
2. #define VARIANTFIELD_H_
3.  
4. #include <boost/cstdint.hpp>
5.  
6. namespace seamless {
7.  
8. union VariantField
9. {
10.     const char * strVal;
11.     int32_t intVal;
12. };
13.  
14. }  // namespace mlr_isearch_api
15.  
16. #endif // VARIANTFIELD_H_

IParameterInterface.h 提供一个接口，用于得到Query中的各个Segment的值

1. #ifndef IPARAMETERINTERFACE_H_
2. #define IPARAMETERINTERFACE_H_
3.  
4. #include <boost/cstdint.hpp>
5.  
6. #include "VariantField.h"
7.  
8. namespace seamless {
9.  
10. class IParameterInterface {
11. public:
12.         virtual ~IParameterInterface() {};
13.  
14. public:
15.         virtual int32_t getParameter(const char* name,  VariantField*& value) = 0;
16. };
17.  
18. }  // namespace
19.  
20. #endif // IPARAMETERINTERFACE_H_

IAPIProviderInterface.h 一个统一的外部接口

1. #ifndef IAPIPROVIDERINTERFACE_H_
2. #define IAPIPROVIDERINTERFACE_H_
3.  
4. #include <boost/cstdint.hpp>
5.  
6. #include "IParameterInterface.h"
7. #include "VariantField.h"
8.  
9. namespace seamless {
10.  
11. class IAPIProviderInterface {
12. public:
13.         IAPIProviderInterface() {}
14.         virtual ~IAPIProviderInterface() {}
15.  
16. public:
17.         virtual IParameterInterface* getParameterInterface() = 0;
18. };
19.  
20. }
21.  
22. #endif // IAPIPROVIDERINTERFACE_H_

引擎定义好的接口就以上三个，下面是引擎中的一个模块用于根据Query中的Segment接合业务处理的。Rank.h 头文件

1. #ifndef RANK_H_
2. #define RANK_H_
3.  
4. #include "IAPIProviderInterface.h"
5.  
6. namespace seamless {
7.  
8. class Rank {
9. public:
10.         virtual ~Rank() {}
11.  
12. public:
13.         void processQuery(IAPIProviderInterface* iAPIProvider);
14. };
15.  
16. }  // namespace seamless
17.  
18. #endif // RANK_H_

Rank.cc 实现

1. #include <cstdlib>
2. #include <cstring>
3. #include <iostream>
4. #include <string>
5. #include "IAPIProviderInterface.h"
6. #include "IParameterInterface.h"
7. #include "VariantField.h"
8.  
9. #include "Rank.h"
10.  
11. using namespace seamless;
12. using namespace std;
13.  
14. namespace seamless {
15.  
16. void Rank::processQuery(IAPIProviderInterface* iAPIProvider) {
17.         IParameterInterface* iParameter = iAPIProvider->getParameterInterface();
18.         if (!iParameter) {
19.                 cerr << "iParameter is NULL" << endl;
20.                 return;
21.         }
22.  
23.         int32_t isRetailWholesale = 0;
24.         int32_t isUseAlipay = 0;
25.  
26.         VariantField* value = new VariantField;
27.  
28.         iParameter->getParameter("retail_wholesale", value);
29.         isRetailWholesale = (strcmp(value->strVal, "0")) ? 1 : 0;
30.  
31.         iParameter->getParameter("is_use_alipay", value);
32.         isUseAlipay = (strcmp(value->strVal, "0")) ? 1 : 0;
33.  
34.         cout << "isRetailWholesale:\t" << isRetailWholesale << endl;
35.         cout << "isUseAlipay:\t" << isUseAlipay << endl;
36.  
37.         delete value;
38.         delete iParameter;
39. }
40.  
41. }  // namespace seamless

下面我们开始Mock了：
MockIParameterInterface.h 模拟模拟IParameterInterface类

1. #ifndef MOCKIPARAMETERINTERFACE_H_
2. #define MOCKIPARAMETERINTERFACE_H_
3.  
4. #include <boost/cstdint.hpp>
5. #include <gmock/gmock.h>
6.  
7. #include "IParameterInterface.h"
8. #include "VariantField.h"
9.  
10. namespace seamless {
11.  
12. class MockIParameterInterface: public IParameterInterface {
13. public:
14.         MOCK_METHOD2(getParameter, int32_t(const char* name,  VariantField*& value));
15. };
16.  
17. }  // namespace seamless
18.  
19. #endif // MOCKIPARAMETERINTERFACE_H_

MockIAPIProviderInterface.h 模拟IAPIProviderInterface类

1. #ifndef MOCKIAPIPROVIDERINTERFACE_H_
2. #define MOCKIAPIPROVIDERINTERFACE_H_
3.  
4. #include <gmock/gmock.h>
5.  
6. #include "IAPIProviderInterface.h"
7. #include "IParameterInterface.h"
8.  
9. namespace seamless {
10.  
11. class MockIAPIProviderInterface: public IAPIProviderInterface{
12. public:
13.         MOCK_METHOD0(getParameterInterface, IParameterInterface*());
14. };
15.  
16. }  // namespace seamless
17.  
18. #endif // MOCKIAPIPROVIDERINTERFACE_H_

tester.cc 一个测试程序，试试我们的Mock成果

1. #include <boost/cstdint.hpp>
2. #include <boost/shared_ptr.hpp>
3. #include <cstdlib>
4. #include <gmock/gmock.h>
5.  
6. #include "MockIAPIProviderInterface.h"
7. #include "MockIParameterInterface.h"
8. #include "Rank.h"
9.  
10. using namespace seamless;
11. using namespace std;
12.  
13. using ::testing::_;
14. using ::testing::AtLeast;
15. using ::testing::DoAll;
16. using ::testing::Return;
17. using ::testing::SetArgumentPointee;
18.  
19. int main(int argc, char** argv) {
20.         ::testing::InitGoogleMock(&argc, argv);
21.  
22.         MockIAPIProviderInterface* iAPIProvider = new MockIAPIProviderInterface;
23.         MockIParameterInterface* iParameter = new MockIParameterInterface;
24.  
25.         EXPECT_CALL(*iAPIProvider, getParameterInterface()).Times(AtLeast(1)).
26.                 WillRepeatedly(Return(iParameter));
27.  
28.         boost::shared_ptr<VariantField> retailWholesaleValue(new VariantField);
29.         retailWholesaleValue->strVal = "0";
30.  
31.         boost::shared_ptr<VariantField> defaultValue(new VariantField);
32.         defaultValue->strVal = "9";
33.  
34.         EXPECT_CALL(*iParameter, getParameter(_, _)).Times(AtLeast(1)).
35.                 WillOnce(DoAll(SetArgumentPointee<1>(*retailWholesaleValue), Return(1))).
36.                 WillRepeatedly(DoAll(SetArgumentPointee<1>(*defaultValue), Return(1)));
37.  
38.         Rank rank;
39.         rank.processQuery(iAPIProvider);
40.  
41.         delete iAPIProvider;
42.  
43.         return EXIT_SUCCESS;
44. }

现实中的例子

就如我之前所说的，上述的那个例子是我改过的，现实项目中哪有这么理想的结构（特别对于那些从来没有Develop for Debug思想的同学）。
因此我们来看看上述这个例子中实际的代码：其实只有IAPIProviderInterface.h不同，它定义了一个模版函数，用于统一各种类型的接口： IAPIProviderInterface.h 真正的IAPIProviderInterface.h，有一个模版函数

1. #ifndef IAPIPROVIDERINTERFACE_H_
2. #define IAPIPROVIDERINTERFACE_H_
3.  
4. #include <boost/cstdint.hpp>
5. #include <iostream>
6.  
7. #include "IBaseInterface.h"
8. #include "IParameterInterface.h"
9. #include "VariantField.h"
10.  
11. namespace seamless {
12.  
13. class IAPIProviderInterface: public IBaseInterface {
14. public:
15.         IAPIProviderInterface() {}
16.         virtual ~IAPIProviderInterface() {}
17.  
18. public:
19.         virtual int32_t queryInterface(IBaseInterface*& pInterface) = 0;
20.  
21.         template<typename InterfaceType>
22.         InterfaceType* getInterface() {
23.                 IBaseInterface* pInterface = NULL;
24.                 if (queryInterface(pInterface)) {
25.                         std::cerr << "Query Interface failed" << std::endl;
26.                 }
27.                 return static_cast<InterfaceType* >(pInterface);
28.         }
29. };
30.  
31. }
32.  
33. #endif // IAPIPROVIDERINTERFACE_H_

Rank.cc 既然IAPIProviderInterface.h改了，那Rank.cc中对它的调用其实也不是之前那样的。不过其实也就差一行代码：

1. //      IParameterInterface* iParameter = iAPIProvider->getParameterInterface();
2.         IParameterInterface* iParameter = iAPIProvider->getInterface<IParameterInterface>();

因为目前版本（1.5版本）的Google Mock还不支持模版函数，因此我们无法Mock IAPIProviderInterface中的getInterface，那我们现在怎么办？
如果你想做得比较完美的话我暂时也没想出办法，我现在能够想出的办法也只能这样：IAPIProviderInterface.h 修改其中的getInterface，让它根据模版类型，如果是IParameterInterface或者MockIParameterInterface则就返回一个MockIParameterInterface的对象

1. #ifndef IAPIPROVIDERINTERFACE_H_
2. #define IAPIPROVIDERINTERFACE_H_
3.  
4. #include <boost/cstdint.hpp>
5. #include <iostream>
6.  
7. #include "IBaseInterface.h"
8. #include "IParameterInterface.h"
9. #include "VariantField.h"
10.  
11. // In order to Mock
12. #include <boost/shared_ptr.hpp>
13. #include <gmock/gmock.h>
14. #include "MockIParameterInterface.h"
15.  
16. namespace seamless {
17.  
18. class IAPIProviderInterface: public IBaseInterface {
19. public:
20.         IAPIProviderInterface() {}
21.         virtual ~IAPIProviderInterface() {}
22.  
23. public:
24.         virtual int32_t queryInterface(IBaseInterface*& pInterface) = 0;
25.  
26.         template<typename InterfaceType>
27.         InterfaceType* getInterface() {
28.                 IBaseInterface* pInterface = NULL;
29.                 if (queryInterface(pInterface) == 0) {
30.                         std::cerr << "Query Interface failed" << std::endl;
31.                 }
32.  
33.                 // In order to Mock
34.                 if ((typeid(InterfaceType) == typeid(IParameterInterface)) ||
35.                         (typeid(InterfaceType) == typeid(MockIParameterInterface))) {
36.                         using namespace ::testing;
37.                         MockIParameterInterface* iParameter = new MockIParameterInterface;
38.                         boost::shared_ptr<VariantField> retailWholesaleValue(new VariantField);
39.                         retailWholesaleValue->strVal = "0";
40.  
41.                         boost::shared_ptr<VariantField> defaultValue(new VariantField);
42.                         defaultValue->strVal = "9";
43.  
44.                         EXPECT_CALL(*iParameter, getParameter(_, _)).Times(AtLeast(1)).
45.                                 WillOnce(DoAll(SetArgumentPointee<1>(*retailWholesaleValue), Return(1))).
46.                                 WillRepeatedly(DoAll(SetArgumentPointee<1>(*defaultValue), Return(1)));
47.                         return static_cast<InterfaceType* >(iParameter);
48.                 }
49.                 // end of mock
50.  
51.                 return static_cast<InterfaceType* >(pInterface);
52.         }
53. };
54.  
55. }
56.  
57. #endif // IAPIPROVIDERINTERFACE_H_

tester.cc

1. int main(int argc, char** argv) {
2.         ::testing::InitGoogleMock(&argc, argv);
3.  
4.         MockIAPIProviderInterface* iAPIProvider = new MockIAPIProviderInterface;
5.  
6.         InSequence dummy;
7.         EXPECT_CALL(*iAPIProvider, queryInterface(_)).Times(AtLeast(1)).
8.                 WillRepeatedly(Return(1));
9.  
10.         Rank rank;
11.         rank.processQuery(iAPIProvider);
12.  
13.         delete iAPIProvider;
14.  
15.         return EXIT_SUCCESS;
16. }

Google Mock Cookbook

这里根据Google Mock Cookbook和我自己试用的一些经验，整理一些试用方面的技巧。

Mock protected、private方法

Google Mock也可以模拟protected和private方法，比较神奇啊（其实从这点上也可以看出，Mock类不是简单地继承原本的接口，然后自己把它提供的方法实现;Mock类其实就等于原本的接口）。
对protected和private方法的Mock和public基本类似，只不过在Mock类中需要将这些方法设置成public。
Foo.h 带private方法的接口

1. class Foo {
2. private:
3.         virtual void setValue(int value) {};
4.  
5. public:
6.         int value;
7. };

MockFoo.h

1. class MockFoo: public Foo {
2. public:
3.         MOCK_METHOD1(setValue, void(int value));
4. };

Mock 模版类（Template Class）

Google Mock可以Mock模版类，只要在宏MOCK*的后面加上T。
还是类似上述那个例子：
Foo.h 改成模版类

1. template <typename T>
2. class Foo {
3. public:
4.         virtual void setValue(int value) {};
5.  
6. public:
7.         int value;
8. };

MockFoo.h

1. template <typename T>
2. class Foo {
3. public:
4.         virtual void setValue(int value) {};
5.  
6. public:
7.         int value;
8. };

Nice Mocks 和 Strict Mocks

当在调用Mock类的方法时，如果之前没有使用EXPECT_CALL来定义该方法的期望行为时，Google Mock在运行时会给你一些警告信息：

对于这种情况，可以使用NiceMock来避免:

1.         // MockFoo mockFoo;
2.         NiceMock<MockFoo> mockFoo;

当然，另外还有一种办法，就是使用StrictMock来将这些调用都标为失败：

1. StrictMock<MockFoo> mockFoo;

这时得到的结果：

原文标题：《转一篇小亮同学的google mock分享》https://www.cnblogs.com/welkinwalker/archive/2011/11/29/2267225.html