C++单元测试GoogleTest和GoogleMock十分钟快速上手(gtestgmock)

2023-10-28 21:04
文章标签 c++ 快速 十分钟 单元测试 googletest googlemock gtestgmock

本文主要是介绍C++单元测试GoogleTest和GoogleMock十分钟快速上手(gtestgmock)，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

C++单元测试GoogleTest和GoogleMock(gtest&gmock)

环境准备

下载

git clone https://github.com/google/googletest.git
# 或者
wget https://github.com/google/googletest/releases/tag/release-1.11.0

安装

cd googletest
cmake CMakeLists.txt 
make
sudo make install

重要文件

googletest
  • gtest/gtest.h
  • libgtest.a
  • libgtest_main.a

当不想写 main 函数的时候，可以直接引入 libgtest_main.a;

g++ sample.cc -o sample -lgtest -lgtest_main -lpthread 
g++ sample.cc -o sample -lgmock -lgmock_main -lpthread

否则

g++ sample.cc -o sample -lgtest -lpthread
googlemock
  • gmock/gmock.h
  • libgmock.a
  • libgmock_main.a

GoogleTest

一 .断言

gtest中的断言分成两大类：

  1. ASSERT_\*系列：如果检测失败就直接退出当前函数

  2. EXPECT_\*系列：如果检测失败发出提示，并继续往下执行

通常情况应该首选使用EXPECT_，因为ASSERT_在报告完错误后不会进行清理工作，有可能导致内存泄露问题。

gtest有很多类似的宏用来判断数值的关系、判断条件的真假、判断字符串的关系。

条件判断
ASSERT_TRUE(condition);  // 判断条件是否为真
ASSERT_FALSE(condition); // 判断条件是否为假EXPECT_TRUE(condition);  // 判断条件是否为真
EXPECT_FALSE(condition); // 判断条件是否为假
数值比较
ASSERT_EQ(val1, val2); // 判断是否相等
ASSERT_NE(val1, val2); // 判断是否不相等
ASSERT_LT(val1, val2); // 判断是否小于
ASSERT_LE(val1, val2); // 判断是否小于等于
ASSERT_GT(val1, val2); // 判断是否大于
ASSERT_GE(val1, val2); // 判断是否大于等于EXPECT_EQ(val1, val2); // 判断是否相等
EXPECT_NE(val1, val2); // 判断是否不相等
EXPECT_LT(val1, val2); // 判断是否小于
EXPECT_LE(val1, val2); // 判断是否小于等于
EXPECT_GT(val1, val2); // 判断是否大于
EXPECT_GE(val1, val2); // 判断是否大于等于
字符串比较
ASSERT_STREQ(str1,str2); // 判断字符串是否相等
ASSERT_STRNE(str1,str2); // 判断字符串是否不相等
ASSERT_STRCASEEQ(str1,str2); // 判断字符串是否相等，忽视大小写
ASSERT_STRCASENE(str1,str2); // 判断字符串是否不相等，忽视大小写EXPECT_STREQ(str1,str2); // 判断字符串是否相等
EXPECT_STRNE(str1,str2); // 判断字符串是否不相等
EXPECT_STRCASEEQ(str1,str2); // 判断字符串是否相等，忽视大小写
EXPECT_STRCASENE(str1,str2); // 判断字符串是否不相等，忽视大小写
谓词断言

谓词断言能比 EXPECT_TRUE 提供更详细的错误消息；

EXPECT_PRED1(pred,val1);
EXPECT_PRED2(pred,val1,val2);
EXPECT_PRED3(pred,val1,val2,val3);
EXPECT_PRED4(pred,val1,val2,val3,val4);
EXPECT_PRED5(pred,val1,val2,val3,val4,val5);ASSERT_PRED1(pred,val1);
ASSERT_PRED2(pred,val1,val2);
ASSERT_PRED3(pred,val1,val2,val3);
ASSERT_PRED4(pred,val1,val2,val3,val4);
ASSERT_PRED5(pred,val1,val2,val3,val4,val5);

// Returns true if m and n have no common divisors except 1. 
bool MutuallyPrime(int m, int n) { ... }
...
const int a = 3;
const int b = 4;
const int c = 10;
...
EXPECT_PRED2(MutuallyPrime, a, b);  // Succeeds
EXPECT_PRED2(MutuallyPrime, b, c);  // Fails

能得到错误信息：

MutuallyPrime(b, c) is false, where 
b is 4
c is 10

二 .宏测试

如果自己编写mian函数,那么需要调用testing::InitGoogleTest函数进行初始化然后调用RUN_ALL_TESTS(); 函数执行所有的测试集

TEST

进一步，为了更好的组织test cases，比如针对Factorial函数，输入是负数的cases为一组，输入是0的case为一组，正数cases为一组。gtest提供了一个宏TEST(TestSuiteName, TestName)，用于组织不同场景的cases，这个功能在gtest中称为test suite

原型
#define TEST(test_suite_name,test_name)
代码示例

TEST_F()宏的第一个参数（即test_suite_name的名称）必须是测试装置类的类名。

TEST(test_suite_name,test_name)
{//可以像普通函数一样定义变量之类的行为。EXPECT_TRUE(condition);EXPECT_EQ(val1, val2);EXPECT_PRED1(pred,val1);
}
TEST_F

我们想让多个Test使用同一套数据配置时，就需要用到测试装置，创建测试装置的具体方法如下：

  • 派生一个继承 ::testing::Test 的类，并将该类中的一些内容声明为 protected 类型，以便在子类中进行访问；
  • 根据实际情况，编写默认的构造函数或SetUp()函数，来为每个 test 准备所需内容；
  • 根据实际情况，编写默认的析构函数或TearDown()函数，来释放SetUp()中分配的资源；
  • 根据实际情况，定义 test 共享的子程序。

TEST_F()宏的第一个参数（即Test Case的名称）必须是测试装置类的类名。

它继承testing::Test类，然后根据我们的需要实现下面这两个虚函数：

  • virtual void SetUp()类似于构造函数,总是在测试用例开始时被调用
  • virtual void TearDown()类似于析构函数,总是在测试用例结束后被调用

此外，testing::Test还提供了两个static函数：

  • static void SetUpTestSuite()：在第一个TEST之前运行
  • static void TearDownTestSuite()：在最后一个TEST之后运行
代码示例
class QueueTestSmpl3 : public testing::Test { // 继承了 testing::Test
protected:  static void SetUpTestSuite() {std::cout<<"run before first case..."<<std::endl;} static void TearDownTestSuite() {std::cout<<"run after last case..."<<std::endl;}virtual void SetUp() override {std::cout<<"enter into SetUp()" <<std::endl;q1_.Enqueue(1);q2_.Enqueue(2);q2_.Enqueue(3);}virtual void TearDown() override {std::cout<<"exit from TearDown" <<std::endl;}static int Double(int n) {return 2*n;}void MapTester(const Queue<int> * q) {const Queue<int> * const new_q = q->Map(Double);ASSERT_EQ(q->Size(), new_q->Size());for (const QueueNode<int>*n1 = q->Head(), *n2 = new_q->Head();n1 != nullptr; n1 = n1->next(), n2 = n2->next()) {EXPECT_EQ(2 * n1->element(), n2->element());}delete new_q;}Queue<int> q0_;Queue<int> q1_;Queue<int> q2_;
};
测试集代码
// in sample3_unittest.cc// Tests the default c'tor.
TEST_F(QueueTestSmpl3, DefaultConstructor) {// !!! 在 TEST_F 中可以使用 QueueTestSmpl3 的成员变量、成员函数 EXPECT_EQ(0u, q0_.Size());
}// Tests Dequeue().
TEST_F(QueueTestSmpl3, Dequeue) {int * n = q0_.Dequeue();EXPECT_TRUE(n == nullptr);n = q1_.Dequeue();ASSERT_TRUE(n != nullptr);EXPECT_EQ(1, *n);EXPECT_EQ(0u, q1_.Size());delete n;n = q2_.Dequeue();ASSERT_TRUE(n != nullptr);EXPECT_EQ(2, *n);EXPECT_EQ(1u, q2_.Size());delete n;
}// Tests the Queue::Map() function.
TEST_F(QueueTestSmpl3, Map) {MapTester(&q0_);MapTester(&q1_);MapTester(&q2_);
}
运行结果
% ./sample3_unittest
Running main() from /Users/self_study/Cpp/OpenSource/demo/include/googletest/googletest/samples/sample3_unittest.cc
[==========] Running 3 tests from 1 test suite.
[----------] Global test environment set-up.
[----------] 3 tests from QueueTestSmpl3
run before first case...    # 所有的test case 之前运行
[ RUN      ] QueueTestSmpl3.DefaultConstructor
enter into SetUp()          # 每次都会运行
exit from TearDown
[       OK ] QueueTestSmpl3.DefaultConstructor (0 ms)
[ RUN      ] QueueTestSmpl3.Dequeue
enter into SetUp()          # 每次都会运行
exit from TearDown
[       OK ] QueueTestSmpl3.Dequeue (0 ms)
[ RUN      ] QueueTestSmpl3.Map
enter into SetUp()          # 每次都会运行
exit from TearDown
[       OK ] QueueTestSmpl3.Map (0 ms)
run after last case...      # 所有test case结束之后运行
[----------] 3 tests from QueueTestSmpl3 (0 ms total)[----------] Global test environment tear-down
[==========] 3 tests from 1 test suite ran. (0 ms total)
[  PASSED  ] 3 tests.

GoogleMock

当你写一个原型或测试，往往不能完全的依赖真实对象。一个 mock 对象实现与一个真实对象相同的接口，但让你在运行时指定它时，如何使用？它应该做什么？（哪些方法将被调用？什么顺序？多少次？有什么参数？会返回什么？等）

可以模拟检查它自己和调用者之间的交互；

mock 用于创建模拟类和使用它们；

  • 使用一些简单的宏描述你想要模拟的接口，他们将扩展到你的 mock 类的实现；
  • 创建一些模拟对象，并使用直观的语法指定其期望和行为；
  • 练习使用模拟对象的代码。 Google Mock会在出现任何违反期望的情况时立即处理。

注意

googlemock 依赖 googletest；调用 InitGoogleMock 时会自动调用 InitGoogleTest ；

头文件 #include “gmock/gmock.h”

什么时候使用？

  • 测试很慢，依赖于太多的库或使用昂贵的资源；
  • 测试脆弱，使用的一些资源是不可靠的（例如网络）；
  • 测试代码如何处理失败（例如，文件校验和错误），但不容易造成；
  • 确保模块以正确的方式与其他模块交互，但是很难观察到交互；因此你希望看到观察行动结束时的副作用；
  • 想模拟出复杂的依赖；

使用方法

我们假设一个支付场景逻辑开发业务。我们开发复杂的业务模块，而团队其他成员开发用户行为模块。他们和我们约定了如下接口

class User {
public:User() {};~User() {};
public:// 登录virtual bool Login(const std::string& username, const std::string& password) = 0;// 支付virtual bool Pay(int money) = 0;// 是否登录virtual bool Online() = 0;
};

我们的业务模块要让用户登录，并发起支付行为。于是我们的代码如下

class Biz {
public:void SetUser(User* user) {_user = user;}std::string pay(const std::string& username, const std::string& password, int money) {std::string ret;if (!_user) {ret = "pointer is null.";return ret;}if (!_user->Online()) {ret = "logout status.";// 尚未登录，要求登录if (!_user->Login(username, password)) {// 登录失败ret += "login error.";return ret;} else {// 登录成功ret += "login success.";}} else {// 已登录ret = "login.status";}if (!_user->Pay(money)) {ret += "pay error.";} else {ret += "pay success.";}return ret;}private:User* _user;
};

第一步我们需要Mock接口类

  • MOCK_METHOD0(FUNC, TYPE);第一个参数填写函数名,第二个参数填写函数类型
  • MOCK_METHOD()后面的数字表示需要几个参数
  • const成员方法使用MOCK_CONST_METHOD系列
class TestUser : public User {
public:MOCK_METHOD2(Login, bool(const std::string&, const std::string&));MOCK_METHOD1(Pay, bool(int));MOCK_METHOD0(Online, bool());
};

第二步，我们就可以设计测试场景了。在设计场景之前，我们先看一些Gmock的方法

//   EXPECT_CALL(mock_object, Method(argument-matchers))
//       .With(multi-argument-matchers)
//       .Times(cardinality)
//       .InSequence(sequences)
//       .After(expectations)
//       .WillOnce(action)
//       .WillRepeatedly(action)
//       .RetiresOnSaturation();
//
// where all clauses are optional, and .InSequence()/.After()/
// .WillOnce() can appear any number of times.
  • EXPECT_CALL声明一个调用期待，就是我们期待这个对象的这个方法按什么样的逻辑去执行。
  • mock_object是我们mock的对象，上例中就是TestUser的一个对象。
  • Method是mock对象中的mock方法，它的参数可以通过argument-matchers规则去匹配。
  • With是多个参数的匹配方式指定。
  • Times表示这个方法可以被执行多少次。如果超过这个次数，则按默认值返回了。
  • InSequence用于指定函数执行的顺序。它是通过同一序列中声明期待的顺序确定的。
  • After方法用于指定某个方法只能在另一个方法之后执行。
  • WillOnce表示执行一次方法时，将执行其参数action的方法。一般我们使用Return方法，用于指定一次调用的输出。
  • WillRepeatedly表示一直调用一个方法时，将执行其参数action的方法。需要注意下它和WillOnce的区别，WillOnce是一次，WillRepeatedly是一直。
  • RetiresOnSaturation用于保证期待调用不会被相同的函数的期待所覆盖。

先举一个例子，我们要求Online在第一调用时返回true，之后都返回false。Login一直返回false。Pay一直返回true。也就是说用户第一次支付前处于在线状态，并可以支付成功。而第二次将因为不处于在线状态，要触发登录行为，而登录行为将失败。我们看下这个逻辑该怎么写

    {TestUser test_user;EXPECT_CALL(test_user, Online()).WillOnce(testing::Return(true));EXPECT_CALL(test_user, Login(_,_)).WillRepeatedly(testing::Return(false));EXPECT_CALL(test_user, Pay(_)).WillRepeatedly(testing::Return(true));Biz biz;biz.SetUser(&test_user);std::string admin_ret = biz.pay("user", "", 1);admin_ret = biz.pay("user", "", 1);}

第4行的意思是Online在调用一次后返回true，之后的调用返回默认的false。第5行意思是Login操作一直返回false，其中Login的参数是两个下划线（_），它是通配符，就是对任何输入参数都按之后要求执行。第6行意思是Pay操作总是返回true。那么我们在第10行和第11行分别得到如下输出

login status.pay success.
logout status.login error.

可以见得输出符合我们的预期。

​ 我们再看一种场景，这个场景我们使用了函数参数的过滤。比如我们不允许admin的用户通过我们方法登录并支付，则可以这么写

    {TestUser test_user;EXPECT_CALL(test_user, Online()).WillOnce(testing::Return(false));EXPECT_CALL(test_user, Login("admin",_)).WillRepeatedly(testing::Return(false));Biz biz;biz.SetUser(&test_user);std::string admin_ret = biz.pay("admin", "", 1);}

第3行表示，如果Login的第一个参数是admin，则总是返回false。于是07行返回是

logout status.login error.

那么如果不是admin的用户登录，则返回成功，这个案例要怎么写呢？

    {TestUser test_user;EXPECT_CALL(test_user, Online()).WillOnce(testing::Return(false));EXPECT_CALL(test_user, Login(StrNe("admin"),_)).WillRepeatedly(testing::Return(true));EXPECT_CALL(test_user, Pay(_)).WillRepeatedly(testing::Return(true));Biz biz;biz.SetUser(&test_user);std::string user_ret = biz.pay("user", "", 1);}

03行使用了StrNe的比较函数，即Login的第一个参数不等于admin时，总是返回true。08行的输出是

logout status.login success.pay success.

我们再看一个例子，我们要求非admin用户登录成功后，只能成功支付2次，之后的支付都失败。这个案例可以这么写

    {TestUser test_user;EXPECT_CALL(test_user, Online()).WillOnce(testing::Return(false));EXPECT_CALL(test_user, Login(StrNe("admin"),_)).WillRepeatedly(testing::Return(true));EXPECT_CALL(test_user, Pay(_)).Times(5).WillOnce(testing::Return(true)).WillOnce(testing::Return(true)).WillRepeatedly(testing::Return(false));Biz biz;biz.SetUser(&test_user);std::string user_ret = biz.pay("user", "", 1);user_ret = biz.pay("user", "", 1);user_ret = biz.pay("user", "", 1);}

第4行我们使用Times函数，它的参数5表示该函数期待被调用5次，从第6次的调用开始，返回默认值。Times函数后面跟着两个WillOnce，其行为都是返回true。这个可以解读为第一次和第二次调用Pay方法时，返回成功。最后的WillRepeatedly表示之后的对Pay的调用都返回false。我们看下执行的结果

logout status.login success.pay success.
logout status.login success.pay success.
logout status.login success.pay error.

从结果上看，前两次都支付成功了，而第三次失败。符合我们的期待。

这篇关于C++单元测试GoogleTest和GoogleMock十分钟快速上手(gtestgmock)的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/295943。

相关文章

使用Python快速实现链接转word文档

使用Python快速实现链接转word文档

《使用Python快速实现链接转word文档》这篇文章主要为大家详细介绍了如何使用Python快速实现链接转word文档功能,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 演示代码展示from newspaper import Articlefrom docx import
阅读更多...
c++中std::placeholders的使用方法

c++中std::placeholders的使用方法

《c++中std::placeholders的使用方法》std::placeholders是C++标准库中的一个工具,用于在函数对象绑定时创建占位符,本文就来详细的介绍一下,具有一定的参考价值,感兴... 目录1. 基本概念2. 使用场景3. 示例示例 1：部分参数绑定示例 2：参数重排序4. 注意事项5.
阅读更多...
使用C++将处理后的信号保存为PNG和TIFF格式

使用C++将处理后的信号保存为PNG和TIFF格式

《使用C++将处理后的信号保存为PNG和TIFF格式》在信号处理领域,我们常常需要将处理结果以图像的形式保存下来,方便后续分析和展示,C++提供了多种库来处理图像数据,本文将介绍如何使用stb_ima... 目录1. PNG格式保存使用stb_imagephp_write库1.1 安装和包含库1.2 代码解
阅读更多...
C++实现封装的顺序表的操作与实践

C++实现封装的顺序表的操作与实践

《C++实现封装的顺序表的操作与实践》在程序设计中,顺序表是一种常见的线性数据结构,通常用于存储具有固定顺序的元素,与链表不同,顺序表中的元素是连续存储的,因此访问速度较快,但插入和删除操作的效率可能... 目录一、顺序表的基本概念二、顺序表类的设计1. 顺序表类的成员变量2. 构造函数和析构函数三、顺序表
阅读更多...
使用C++实现单链表的操作与实践

使用C++实现单链表的操作与实践

《使用C++实现单链表的操作与实践》在程序设计中,链表是一种常见的数据结构,特别是在动态数据管理、频繁插入和删除元素的场景中,链表相比于数组,具有更高的灵活性和高效性,尤其是在需要频繁修改数据结构的应... 目录一、单链表的基本概念二、单链表类的设计1. 节点的定义2. 链表的类定义三、单链表的操作实现四、
阅读更多...
使用C/C++调用libcurl调试消息的方式

使用C/C++调用libcurl调试消息的方式

《使用C/C++调用libcurl调试消息的方式》在使用C/C++调用libcurl进行HTTP请求时,有时我们需要查看请求的/应答消息的内容（包括请求头和请求体）以方便调试,libcurl提供了多种... 目录1. libcurl 调试工具简介2. 输出请求消息使用 CURLOPT_VERBOSE使用 C
阅读更多...
C++实现获取本机MAC地址与IP地址

C++实现获取本机MAC地址与IP地址

《C++实现获取本机MAC地址与IP地址》这篇文章主要为大家详细介绍了C++实现获取本机MAC地址与IP地址的两种方式,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下... 实际工作中，项目上常常需要获取本机的IP地址和MAC地址，在此使用两种方案获取1.MFC中获取IP和MAC地址获取
阅读更多...
C/C++通过IP获取局域网网卡MAC地址

C/C++通过IP获取局域网网卡MAC地址

《C/C++通过IP获取局域网网卡MAC地址》这篇文章主要为大家详细介绍了C++如何通过Win32API函数SendARP从IP地址获取局域网内网卡的MAC地址,感兴趣的小伙伴可以跟随小编一起学习一下... C/C++通过IP获取局域网网卡MAC地址通过win32 SendARP获取MAC地址代码#i
阅读更多...
C++中使用vector存储并遍历数据的基本步骤

C++中使用vector存储并遍历数据的基本步骤

《C++中使用vector存储并遍历数据的基本步骤》C++标准模板库（STL）提供了多种容器类型,包括顺序容器、关联容器、无序关联容器和容器适配器,每种容器都有其特定的用途和特性,：本文主要介绍C... 目录（1）容器及简要描述‌php顺序容器‌‌关联容器‌‌无序关联容器‌（基于哈希表）：‌容器适配器‌：（
阅读更多...
C++中实现调试日志输出

C++中实现调试日志输出

《C++中实现调试日志输出》在C++编程中,调试日志对于定位问题和优化代码至关重要,本文将介绍几种常用的调试日志输出方法,并教你如何在日志中添加时间戳,希望对大家有所帮助... 目录1. 使用 #ifdef _DEBUG 宏2. 加入时间戳：精确到毫秒3.Windows 和 MFC 中的调试日志方法MFC
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2