google mock分享（全网最全最好的gmock文档，没有之一）

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

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

1. #ifndef MOCKFOO_H_
2. #define MOCKFOO_H_
4. #include <gmock/gmock.h>
5. #include <string>
6. #include <vector>
7. #include "FooInterface.h"
9. namespace seamless {
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. };
18. } // namespace seamless
20. #endif // MOCKFOO_H_

FooMain.h

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