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

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

环境准备

下载

shell 复制代码
git clone https://github.com/google/googletest.git
# 或者
wget https://github.com/google/googletest/releases/tag/release-1.11.0

安装

shell 复制代码
cd googletest
cmake CMakeLists.txt 
make
sudo make install

重要文件

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

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

shell 复制代码
g++ sample.cc -o sample -lgtest -lgtest_main -lpthread 
g++ sample.cc -o sample -lgmock -lgmock_main -lpthread

否则

shell 复制代码
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有很多类似的宏用来判断数值的关系、判断条件的真假、判断字符串的关系。

条件判断
text 复制代码
ASSERT_TRUE(condition);  // 判断条件是否为真
ASSERT_FALSE(condition); // 判断条件是否为假

EXPECT_TRUE(condition);  // 判断条件是否为真
EXPECT_FALSE(condition); // 判断条件是否为假
数值比较
text 复制代码
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); // 判断是否大于等于
字符串比较
text 复制代码
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 提供更详细的错误消息;

c 复制代码
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);
cpp 复制代码
// 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

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

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

cpp 复制代码
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之后运行
代码示例
cpp 复制代码
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_;
};
测试集代码
cpp 复制代码
// 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"

什么时候使用?

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

使用方法

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

cpp 复制代码
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;
};

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

cpp 复制代码
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系列
cpp 复制代码
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的方法

c 复制代码
//   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。也就是说用户第一次支付前处于在线状态,并可以支付成功。而第二次将因为不处于在线状态,要触发登录行为,而登录行为将失败。我们看下这个逻辑该怎么写

cpp 复制代码
    {
        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的用户通过我们方法登录并支付,则可以这么写

cpp 复制代码
    {
        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的用户登录,则返回成功,这个案例要怎么写呢?

cpp 复制代码
    {
        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次,之后的支付都失败。这个案例可以这么写

cpp 复制代码
    {
        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.

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

相关推荐
Asthenia04121 分钟前
InnoDB文件存储结构与Socket技术(从Linux的FD到Java的API)
后端
普if加的帕8 分钟前
java Springboot使用扣子Coze实现实时音频对话智能客服
java·开发语言·人工智能·spring boot·实时音视频·智能客服
我的作业错错错12 分钟前
搭建私人网站
服务器·阿里云·私人网站
Asthenia041222 分钟前
RocketMQ 消息不丢失与持久化机制详解-生产者与Broker之间的详解
后端
王景程32 分钟前
如何测试短信接口
java·服务器·前端
2301_8076114938 分钟前
77. 组合
c++·算法·leetcode·深度优先·回溯
〆、风神1 小时前
Spring Boot 整合 Lock4j + Redisson 实现分布式锁实战
spring boot·分布式·后端
Asthenia04121 小时前
Select、Poll、Epoll 详细分析与面试深度剖析/C代码详解
后端
安冬的码畜日常1 小时前
【AI 加持下的 Python 编程实战 2_10】DIY 拓展:从扫雷小游戏开发再探问题分解与 AI 代码调试能力(中)
开发语言·前端·人工智能·ai·扫雷游戏·ai辅助编程·辅助编程
烛阴1 小时前
Node.js中必备的中间件大全:提升性能、安全与开发效率的秘密武器
javascript·后端·express