Gmock使用说明

Gmock是C++中的一个接口测试框架，一般来说和Google Test搭配使用，但Google Test也可以和其他Mock框架一起使用。本部分是Google Mock基础常用的用法，如需要特殊用法，请查阅Google Mock官方文档。

一、安装部署

依次执行下面命令即可：

git clone https://github.com/google/googletest
git checkout release-1.8.0
cd ~/googletest && cmake .
make && sudo make install

官方文档：https://google.github.io/googletest/

二、用法说明

Fake、Mock、Stub
- Fake对象有具体的实现，但采取一些捷径，比如用内存替代真实的数据库读取
- Stub对象没有具体的实现，只是返回提前准备好的数据
- Mock对象和Stub类似，只是在测试中需要调用时，针对某种输入指定期望的行为，Mock和Stub的区别是，Mock除了返回数据还可以指定期望以验证行为。
简单示例

Tutle类：
```
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;
};
```
MockTurtle类：
```
#include "gmock/gmock.h"

class MockTurtle : public Turtle {
public:
	...
	MOCK_METHOD(void, PenUp, (), (override));
	MOCK_METHOD(void, PenDown, (), (override));
	MOCK_METHOD(void, Forward, (int distance), (override));
	MOCK_METHOD(void, Turn, (int degrees), (override));
	MOCK_METHOD(void, GoTo, (int x, int y), (override));
	MOCK_METHOD(int, GetX, (), (const, override));
	MOCK_METHOD(int, GetY, (), (const, override));
};
```
创建Mock类的步骤：
1. MockTutle继承Tutle
2. 找到Tutle的一个虚函数
3. 在public的部分，写一个MOCK_METHOD()
4. 将虚函数的函数签名复制进MOCK_METHOD()中，加两个逗号：
  
  一个在返回类型和函数名之间，另一个在函数名和参数列表之间
  
  例如：void PenDown() 有三部分：void、PenDown、和()，这三部分就是MOCK_METHOD的前三个参数
5. 如果要模拟const方法，添加一个包含const的第四个参数，必须到括号
6. 建议添加override关键字。所以对于const方法，第四个参数变为（const, override），对于非const方法，第四个参数变为override。这不是强制性的。
7. 重复步骤直至完成要模拟的所有虚拟函数
在测试中使用Mock

在测试中使用Mock的步骤：
1. 从testing名称空间导入gmock.h的函数名(每个文件只需要执行一次)
2. 创建一些Mock对象
3. 指定对它们的期望(方法将被调用多少次? 带有什么参数? 每次应该做什么? 返回什么值等等)
4. 使用Mock对象；可以使用googletest断言检查结果。如果mock函数的调用超出预期或参数错误，将会立即收到错误信息。
5. 当Mock对象被销毁时，gmock自动检查对模拟的所有期望是否得到满足
```
#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
}
```
在这个例子中,我们期望tutle的PenDown()至少被调用一次。如果在tutle对象被销毁时,PenDown()还没有被调用或者调用两次以上，测试会失败。
指定期望

EXCEPT_CALL(指定期望)是使用Google Mock的核心。EXCEPT_CALL的作用是两方面的：
1. 告诉这个Mock（假）方法如何模拟原始方法：
  
  我们在EXPECT_CALL中告诉Google Mock，某个对象的某个方法第一次被调用时，会修改某个参数，会返回某个值，第二次调用时，会修改某个参数，会返回某个值......
2. 验证被调用的情况
  
  我们在EXPECT_CALL中告诉Google Mock，某个对象的某个方法总共会被调用N次（或大于N次，小于N次）。如果
  
  最终次数不符合预期，会导致测试失败。
4.1 基本语法
```
EXPECT_CALL(mock_object, method(matchers))
	.Times(cardinality)
	.WillOnce(action)
	.WillRepeatedly(action);
```
- mock_object是对象
- method(matchers)用于匹配相应的函数调用
- cardinality指定基数(被调用次数情况)
- action指定被调用时的行为
例子：
```
using ::testing::Return;
...
EXPECT_CALL(turtle, GetX())
	.Times(5)
	.WillOnce(Return(100))
	.WillOnce(Return(150))
	.WillRepeatedly(Return(200));
```
这个EXPECT_CALL()指定的期望是：在turtle这个Mock对象销毁之前，turtle的getX()函数会被调用五次。第一次返回100，第二次返回150，第三次及以后都返回200。指定期望后， 5次对getX的调用会有这些行为。但如果最终调用次数不为5次，则测试失败。

4.2 参数匹配：哪次调用
```
using ::testing::_;
using ::testing::Ge;
// 只与Forward(100)匹配
EXPECT_CALL(turtle, Forward(100));
// 与GoTo(x,y)匹配, 只要x>=50
EXPECT_CALL(turtle, GoTo(Ge(50), _));
```
- _ 相当于“任何”
- 100相当于Eq(100)
- Ge(50)指参数大于或等于50
- 如果不关心参数，只写函数名就可以。比如：EXPECT_CALL(turtle, GoTo)
4.3 基数：被调用几次

用Times(m)，TIme(AtLeast(n))等来指定期待的调用次数

Times可以被省略。比如整个EXPECT_CALL只有一个WillOnce(action)相当于也说明了调用次数只能为1

4.4 行为：该做什么

常用模式：如果需要指定前几次调用的特殊情况，并且之后的调用情况相同。使用一系列WillOnce()之后有WillRepeatedly()

除了用来指定调用返回值的Return()，Google Mock中常用行为中还有：SetArgPointee(value),SetArgPointee将第N个指针参数(从0开始)指向的变量赋值为value。

比如void getObject(Object* response){...}的EXCEPT_CALL：
```
Object* a = new Object;
EXPECT_CALL(object, request)
	.WillOnce(SetArgPointee<1>(*a));
```
就修改了传入的指针response，使其指向了一个我们新创建的对象。

如果有多个行为，应该使用DoALL(a1, a2, ..., an)。DoAll指向所有n个action并返回an的结果。

4.5 使用多个预期

例子：
```
using ::testing::_;
...
EXPECT_CALL(turtle, Forward(_))		// #1
	.Times(3);  	
EXPECT_CALL(turtle, Forward(10))  	// #2
	.Times(2);
...mock对象函数被调用...
	//Forward(10);						// 与#2匹配
	//Forward(20);						// 与#1匹配
```
正常情况下，Google Mock以倒序搜索预期：如果和多个EXCEPT_CALL都可以匹配，只有之前的，距离调用最近的一个EXPECT_CALL()会被匹配。例如：
- 连续三次调用Forward(10)会产生错误因为它和 #2 匹配
- 连续三次调用Forward(20)不会有错误因为它和 #1 匹配
一旦匹配，该预期会被一直绑定，即使执行次数达到上限之后，还是生效的，这就是为什么三次调用Forward（10）超过了2号的EXPECT_CALL的上限时,不会去试图调用绑定1号EXPECT_CALL而报错的原因。

为了明确地让某一个EXPECT_CALL “退休”, 可以加上RetiresOnSaturation()，例如：
```
using ::testing::Return;

EXPECT_CALL(turtle, GetX())		// #1
	.WillOnce(Return(10))
	.RetiresOnSaturation();
EXPECT_CALL(turtle, GetX())		// #2
	.WillOnce(Return(20))
	.RetiresOnSaturation();

turtle.GetX()					// 与#2匹配，返回20，然后#2“退休”
turtle.GetX()					// 与#1匹配，返回10
```
在这个例子中，第一次GetX()调用和#2匹配,返回20，然后这个EXPECT_CALL就 “退休”了；第二次 GetX()调用和 #1匹配，返回10

4.6 Sequence

可以用sequence来指定期望匹配的顺序
```
using ::testing::Return;
using ::testing::Sequence;
Sequence s1, s2;
...
EXPECT_CALL(foo, Reset())
    .InSequence(s1, s2)
    .WillOnce(Return(true));
EXPECT_CALL(foo, GetSize())
    .InSequence(s1)
    .WillOnce(Return(1));
EXPECT_CALL(foo, Describe(A<const char*>()))
    .InSequence(s2)
    .WillOnce(Return("dummy"));
```
在上面的例子中，创建了两个Sequence s1 和 s2，属于 s1 的有Reset() 和 GetSize()，所以Reset（）必须在GetSize（）之前执行。属于s2的有Reset()和Describe(A<const char*>())，所以Reset（）必须在Describe(A<const char >())之前执行。所以，Reset()必须在Describe(A<const char>())之前执行，而GetSize（）和Describe（）这两者之间没有顺序约束。

如果需要指定很多期望的顺序，有另一种写法：
```
using ::testing::InSequence;
{
  InSequence seq;

  EXPECT_CALL(...)...;
  EXPECT_CALL(...)...;
  ...
  EXPECT_CALL(...)...;
}
```
在这种用法中，scope(大括号中)的期望必须遵守严格的顺序。

三、情景示例

在这部分，我们找一个示例项目来演示，如何在不同的情景中使用Google Test和 Google Mock写单元测试用例。
1. 项目结构
  
  示例项目是一个C++命令行聊天室软件，包含服务器和客户端。
```
.
├── CMakeLists.txt
├── README.md
├── client_main.cpp
├── server_main.cpp
├── include
│   ├── chat_client.hpp
│   ├── chat_message.hpp
│   ├── chat_participant.hpp
│   ├── chat_room.hpp
│   ├── chat_server.hpp
│   ├── chat_session.hpp
│   ├── http_request.hpp
│   ├── http_request_impl.hpp
│   ├── message_dao.hpp
│   └── message_dao_impl.hpp
├── src
│   ├── chat_client.cpp
│   ├── chat_message.cpp
│   ├── chat_room.cpp
│   ├── chat_server.cpp
│   ├── chat_session.cpp
│   ├── http_request_impl.cpp
│   └── message_dao_impl.cpp
└── tests
    ├── chat_message_unittest.cpp
    └── chat_room_unittest.cpp
```
2. 普通测试
  
  如果被测试的函数不包含外部依赖，用Google Test基础的用法就可以完成用例编写。
  
  原函数：
```
void chat_message::body_length(std::size_t new_length) {
    body_length_ = new_length;
    if (body_length_ > 512)
        body_length_ = 512;
}
```
  这个函数很简单，就是给body_length_赋值，但是有最大值限制。测试用例可以这样写：
```
TEST(ChatMessageTest, BodyLengthNegative) {
    chat_message c;
    c.body_length(-50);
    EXPECT_EQ(512, c.body_length());
}

TEST(ChatMessageTest, BodyLength0) {
    chat_message c;
    c.body_length(0);
    EXPECT_EQ(0, c.body_length());
}

TEST(ChatMessageTest, BodyLength100) {
    chat_message c;
    c.body_length(100);
    EXPECT_EQ(100, c.body_length());
}

TEST(ChatMessageTest, BodyLength512) {
    chat_message c;
    c.body_length(512);
    EXPECT_EQ(512, c.body_length());
}

TEST(ChatMessageTest, BodyLength513) {
    chat_message c;
    c.body_length(513);
    EXPECT_EQ(512, c.body_length());
}
```
  我们可以看到，对于这类函数，用例编写很直接简单，步骤都是构造变量，再用合适的Google Test宏来验证变量值或者函数调用的返回值。
3. 简单Mock
  
  原函数
```
void chat_room::leave(chat_participant_ptr participant) {
    participants_.erase(participant);
}
```
  participants_类型是 std::set<chat_participant_ptr>。这个函数的目的很明显，将一个participant从set中移除。
  
  真实地创建一个聊天参与者participant对象可能条件比较严苛或者成本比较高。为了有效率地验证这个函数，我们可以新建一些Mock的chat_participant_ptr而不用严格地去创建participant对象。
  
  chat_participant 对象：
```
class chat_participant {
public:
    virtual ~chat_participant() {}
    virtual void deliver(const chat_message &msg) = 0;
};
```
  Mock对象:
```
class mock_chat_participant : public chat_participant {
public:
    MOCK_METHOD(void, deliver, (const chat_message &msg), (override));
};
```
  测试用例：
```
TEST(ChatRoomTest, leave) {
    auto p1 = std::make_shared<mock_chat_participant>();	//新建第一个Mock指针
    auto p2 = std::make_shared<mock_chat_participant>();	//新建第二个Mock指针
    auto p3 = std::make_shared<mock_chat_participant>();	//新建第三个Mock指针
    auto p4 = std::make_shared<mock_chat_participant>();	//新建第四个Mock指针
    chat_room cr;											//新建待测试对象chat_room
    cr.join(p1);
    cr.join(p2);
    cr.join(p3);
    cr.join(p4);
    EXPECT_EQ(cr.participants().size(), 4);
    cr.leave(p4);
    EXPECT_EQ(cr.participants().size(), 3);
    cr.leave(p4);
    EXPECT_EQ(cr.participants().size(), 3);
    cr.leave(p2);
    EXPECT_EQ(cr.participants().size(), 2);
}
```
4. Web请求
  
  chat_room中有一个log()，依赖网络请求。原函数：
```
std::string chat_room::log() {
    std::string* response;
    this->requester->execute("request",response);		// web访问，结果存在response指针中
    return *response;
}
```
  在单元测试中，我们只关心被测试部分的逻辑。为了测试这个函数，我们不应该创建真实的 requester，应该使用mock。
  
  http_request对象：
```
class http_request {
public:
    virtual ~http_request(){}
    virtual bool execute(std::string request, std::string* response)=0;
};
```
  Mock对象：
```
class mock_http_request : public http_request {
public:
    MOCK_METHOD(bool, execute, (std::string request, std::string * response), (override));
};
```
  测试用例：
```
TEST(ChatRoomTest, log) {
    testing::NiceMock<mock_message_dao> mock_dao;	//在下一部分会提到mock_message_dao
    mock_http_request mock_requester;				//Mock对象
    std::string response = "response";				//期待调用函数的第二个参数将指向这个string对象
    EXPECT_CALL(mock_requester, execute)
    	.WillRepeatedly(							//每次调用都会（WillRepeatedly）执行
    		testing::DoAll(							//每次执行包含多个行为
    			testing::SetArgPointee<1>(response),//将传入参数指针变量response指向response
    			testing::Return(true)));			//返回值为true
    chat_room cr 
    	= chat_room(&mock_dao, &mock_requester);	//将mock对象通过chat_room的constructor注入
    EXPECT_EQ(cr.log(),"response");					//调用和Google Test断言
}
```
5. 数据库访问
  
  chat_room 对象会将聊天者发送的消息存储在redis中。当新用户加入时，chat_room对象从数据库获取所有历史消息发送给该新用户。
  
  join函数：
```
void chat_room::join(chat_participant_ptr participant) {
    participants_.insert(participant);
    std::vector<std::string> recent_msg_strs = 
    	this->dao->get_messages(); 			//从数据库中获取历史消息
    for (std::string recent_msg_str: recent_msg_strs) {
										    //将每一个消息发送给该聊天参与者	
        auto msg = chat_message();
        msg.set_body_string(recent_msg_str);
        participant->deliver(msg);
    }
}
```
  message_dao对象：
```
class message_dao {
public:
    virtual ~message_dao(){}
    virtual bool add_message(std::string m)=0;
    virtual std::vector<std::string> get_messages()=0;
};
```
  Mock对象：
```
class mock_message_dao : public message_dao {
public:
    MOCK_METHOD(bool, add_message, (std::string m), (override));
    MOCK_METHOD(std::vector<std::string>, get_messages, (), (override));
};
```
  测试用例：
```
EST(ChatRoomTest, join) {
    mock_message_dao mock_dao;				//创建mock对象（需要注入chat_room）
    http_request_impl requester;			//创建web访问对象（也需要注入chat_room）
    auto mock_p1 = std::make_shared<mock_chat_participant>();
    										//创建participant的mock指针
    EXPECT_CALL(mock_dao, get_messages)
    	.WillOnce(testing::Return(std::vector<std::string>{"test_msg_body_1", "test_msg_body_2", "test_msg_body_3"}));
    										//指定get_messages调用的返回值
    EXPECT_CALL(*mock_p1, deliver).Times(3);
    										//指定deliver调用的次数
    chat_room cr = chat_room(&mock_dao, &requester);
    										//创建chat_room对象，注入dao和requester
    cr.join(mock_p1);						//调用
}
```
四、FAQ

1、单元测试文件应该放在项目的什么位置？

一般来说，我们是会在根目录创建一个tests文件夹，里面放单元测试部分的源码，从而不会和被测试代码混在一起

如果需要和其他测试（如接口测试、压力测试）等区分开，可以：

1、把tests改成unittests、utests等

2、在tests创建不同的子文件夹存放不同类型的测试代码

2、Google Mock只能Mock虚函数，如果我想Mock非虚函数怎么办？

由于Google Mock（及其他大部分Mock框架）通过继承来动态重载机制的限制，一般来说Google Mock只能Mock 虚函数。如果要Mock非虚函数，官方文档提供这几种思路：

1、Mock类和原类没有继承关系，测试对象使用函数模板。在测试中，测试对象接收Mock类。

2、创建一个接口（抽象类），原类继承自这个接口（抽象类）。在测试中Mock这个接口（抽象类）。

这两种方法，都需要对代码进行一定的修改或重构。如果不想修改被测试代码。可以考虑使用hook技术替换被 Mock的部分从而Mock一般函数。

使用TMock对非虚函数Mock的例子：

mock函数：
```
# include "tmock.h"

class MockClass
{
public:
    //注册mock类
    TMOCK_CLASS(MockClass);
    //声明mock类函数，TMOCK_METHOD{n}第一个参数与attach_func_lib第一个参数相同，其余参考与MOCK_METHOD{n}一致。
    TMOCK_METHOD1("original", original, uint32_t(const char * str_file_md5) )
};
```
单测中应用tmock的方法和Google Mock基本一致。但在结束的时候需要使用TMOCK_CLEAR清除exception，detach hook的函数，防止干扰其他单元测试。

3、Google Test官方文档中说测试套件名称、测试夹具名称、测试名称中不应该出现下划线_，为什么？

TEST(TestSuiteName, TestName)，生成名为TestSuiteName_TestName_Test的类。

下划线_是特殊的，因为C++保留以下内容供编译器和标准库使用。所以开头和结尾有下划线很容易让生成的类的标识符不合法。

另一方面，下划线可能让不同测试生成相同的类。比如TEST(Time, Files_Like_An_Arrow) {.....}都生成名为Time_Files_Like_An_Arrow_Test的类。

4、测试输出里有很多Uniteresting mock function call 警告怎么办？

创建的Mock对象的某些调用如果没有相应匹配的EXCEPT_CALL，Google Mock会生成这个警告。

为了去除这个警告，可以使用NiceMock。比如如果原本使用MockFoo nice_foo；新建mock对象的话,可以改成NiceMock nice_foo; NiceMock是MockFoo的子类。

五、实践小结

框架的使用，无非是一些语法糖的差异和使用的难易程度。不管使用什么语言，什么框架，最关键的是利用单元测试的思路，写出解耦的、可测试的、易于维护的代码，保证代码的质量。

单元测试是一种手段，能够一定程度的改善生产力。凡事有度，过犹不及。如果一味盲目的追求测试覆盖率，忽视了测试代码本身的质量。那么各种无效的单元测试反而带来了沉重的维护负担。因此单测的代码，本身也是代码，也是和项目本身的代码一样，需要重构、维护的。

posted @ 2021-10-13 09:04 砚台是黑的阅读(3207) 评论(0) 编辑收藏举报

刷新页面返回顶部

砚台是黑的

Gmock使用说明

一、安装部署

二、用法说明

4.1 基本语法

4.2 参数匹配：哪次调用

4.3 基数：被调用几次

4.4 行为：该做什么

4.5 使用多个预期

4.6 Sequence

三、情景示例

项目结构

普通测试

简单Mock

Web请求

数据库访问

四、FAQ

1、单元测试文件应该放在项目的什么位置？

2、Google Mock只能Mock虚函数，如果我想Mock非虚函数怎么办？

3、Google Test官方文档中说测试套件名称、测试夹具名称、测试名称中不应该出现下划线_，为什么？

4、测试输出里有很多Uniteresting mock function call 警告怎么办？

五、实践小结

公告