gtest gmock gtest gmock注入

转载

mob64ca1417eedd 2024-02-18 20:38:37

文章标签 gtest gmock c语言字符串 EQ #include 文章分类 架构后端开发

Ubuntu搭建gtest环境

在terminal中依次输入如下命令

# 下载googletest
$ sudo apt-get install libgtest-dev

# 如果没有安装cmake，执行该步骤安装
$ sudo apt-get install cmake

# 进入googletest目录
$ cd /usr/src/googletest

# 执行cmake && make
$ sudo cmake ./CMakeLists.txt
$ sudo make
$ sudo make install

测试代码

#include <gtest/gtest.h>

TEST(GTest, HandleGTest)
{
    std::cout << "This is a test!" << std::endl;
}

int main(int argc,char*argv[])
{
   testing::InitGoogleTest(&argc,argv);
   return RUN_ALL_TESTS();
}

编译命令：

g++ gtest.cpp -lgtest -lpthread

结果：

gtest gmock gtest gmock注入_字符串

语法规则

测试代码运行顺序

从上到下顺序执行每个TEST_F或者TEST宏

TEST_F 和 TEST

TEST_F提供了一个初始化函数（SetUp）和一个清理函数(TearDown)，在TEST_F中使用的变量可以在初始化函数SetUp中初始化，在TearDown中销毁，并且所有的TEST_F是互相独立的，都是在初始化以后的状态开始运行，一个TEST_F不会影响另一个TEST_F所使用的数据。

/*
	TEST语法定义：
	-test_case_name第一个参数是测试用例名, 通常是取测试函数名或者测试类名
	-test_name 第二个参数是测试名这个随便取
	-当测试完成后显示的测试结果将以"测试用例名.测试名"的形式给出
*/
TEST(test_case_name, test_name);

/*
	TEST_F语法定义：
	-test_case_name第一个参数是测试用例名,必须取类名
	-test_name 第二个参数是测试名这个随便取
	-使用TEST_F时必须继承::testing::Test类。并且该类提供了两个接口void SetUp(); void TearDown();
*/
TEST_F(test_case_name, test_name);

TEST_F 示例

#include <gtest/gtest.h>

class BaseAPI {
public:
    virtual int getValue() = 0;
    virtual void setValue(int) = 0;
};

class Base : public BaseAPI {
public:
    Base(int value) {
        std::cout << "Create Base" << std::endl;
        this->m_value = value;
    }

    ~Base() {
        std::cout << "Destory Base" << std::endl;
    }

    int getValue() {
        return this->m_value;
    }

    void setValue(int value) {
        this->m_value = value;
    }

private:
    int m_value;
};

class BaseTest : public ::testing::Test {
protected:
    void SetUp() override {
        std::cout << "SetUp BaseTest" << std::endl;
        m_base = std::make_shared<Base>(999);
    }

    void TearDown() override {
        std::cout << "SetUp TearDown" << std::endl;
    }

    std::shared_ptr<Base> m_base;
};

TEST_F(BaseTest, testValue)
{
    std::cout << "[1] value: " << m_base->getValue() << std::endl;

    m_base->setValue(777);
    std::cout << "[2] value: " << m_base->getValue() << std::endl;
}

int main(int argc,char*argv[])
{
   testing::InitGoogleTest(&argc,argv);
   return RUN_ALL_TESTS();
}

运行结果

gtest gmock gtest gmock注入_#include_02

模拟类Mock及其常用宏

一般正常类的类名前面加上Mock前缀，表示模拟类。模拟类需要继承正常类。

MOCK_METHODx
x可以是0、1、2、3、4…，模拟的函数有多少个参数x就等于多少。

MOCK_CONST_METHODx
类似于MOCK_METHODx，只不过被模拟的函数是一个常量成员函数。

示例

class BaseAPI {
public:
    virtual std::string getName() = 0;
    virtual void setName(std::string name) = 0;
    virtual void printName() const = 0;
};

class MockBaseAPI : public BaseAPI {
public:
    MOCK_METHOD1(setName, void(std::string name));
    MOCK_METHOD0(getName, std::string());
    MOCK_CONST_METHOD0(printName, void());
};

EXPECT_CALL

使用MOCK_METHODx宏声明的类成员函数，使用EXPECT_CALL等一系列宏来指定这些函数在被调用时所做的动作。

/*
	-mock_object: Mock对象
	-method(matcher): method是Mock类中的函数，matcher匹配器实例，可以为_，表示不关心参数，参数为任何东西
	-Times(cardinality): 函数应该被调用的次数是cardinality次，调用需要在同一个TEST_F
	-WillOnce(action)：执行一次method，所期望的action
	-WillRepeatedly(action)：每次执行method，所期望的action
	-action: 希望应该怎么办，如果不设定预期action，则使用默认action
	-如果使用WillOnce，那么WillOnce的数量需要和Times设定的次数匹配，或者直接不指定Times
	-如果使用WillRepeatedly，那么就不关心跟Times匹配的问题
*/
EXPECT_CALL(mock_object, method(matcher))
	.Times(cardinality)
	.WillOnce(action)
	.WillRepeatedly(action)

示例

#include <gtest/gtest.h>
#include <gmock/gmock.h>

using ::testing::_;
using ::testing::Return;

class BaseAPI {
public:
    virtual int getValue() = 0;
    virtual void setValue(int value) = 0;
    virtual void printValue(int value) const = 0;
};

class MockBaseAPI : public BaseAPI {
public:
    MOCK_METHOD0(getValue, int());
    MOCK_METHOD1(setValue, void(int value));
    MOCK_CONST_METHOD1(printValue, void(int value));
};

class BaseTest : public ::testing::Test {
protected:
    void SetUp() override {
        std::cout << "SetUp BaseTest" << std::endl;
    }

    void TearDown() override {
        std::cout << "SetUp TearDown" << std::endl;
    }
};

TEST_F(BaseTest, testValue)
{
    MockBaseAPI* m_MockBaseAPI = new MockBaseAPI();

    // 期望后续会调用getValue() 3次，期望调用的返回值分别是3/6/9。如果getValue()少调用一次，或者多调用一次，都会出现错误。
    // 有3个WillOnce，Times必须要等于3
    EXPECT_CALL(*m_MockBaseAPI, getValue()).Times(3)
        .WillOnce(Return(3))
        .WillOnce(Return(6))
        .WillOnce(Return(9));
    
    /*
    	EXPECT_CALL(*m_MockBaseAPI, getValue()).WillRepeatedly(Return(9));
    	// 这种方式，getValue()函数可以被调用无数次，每次都是返回9，也可以一次都不调用，不会报错
    */

    std::cout << m_MockBaseAPI->getValue() << std::endl; // 打印 3
    std::cout << m_MockBaseAPI->getValue() << std::endl; // 打印 6
    std::cout << m_MockBaseAPI->getValue() << std::endl; // 打印 9

	// 期望后续会调用setValue() 1次，不关心参数
	EXPECT_CALL(*m_MockBaseAPI, setValue(_)).Times(1);
    m_MockBaseAPI->setValue(1); // 因为不关心参数，所以传入任意数值都会成功

	// 期望后续会调用printValue() 1次，参数必须是3，如果不是3就是fail
    EXPECT_CALL(*m_MockBaseAPI, printValue(3)).Times(1);
    m_MockBaseAPI->printValue(3);
   
    delete m_MockBaseAPI;
}

int main(int argc,char*argv[])
{
   testing::InitGoogleTest(&argc,argv);
   return RUN_ALL_TESTS();
}

正常的调用结果

gtest gmock gtest gmock注入_gtest gmock_03

少了一次getValue调用的结果

gtest gmock gtest gmock注入_EQ_04

printValue传入的参数不是3的结果

gtest gmock gtest gmock注入_字符串_05

ASSERT 和 EXPECT 断言宏

ASSERT 是如果当前点检测失败则退出当前函数，EXPECT 是如果当前点检测失败则继续往下执行，宏类型类似ASSERT。

BOOL类型

ASSERT_TRUE (参数)：期望值为参数 = TRUE
ASSERT_FALSE (参数)：期望值为参数 = FALSE

数值类型

ASSERT_EQ (参数1, 参数2)：期望值为参数1 == 参数2
ASSERT_NE (参数1, 参数2)：期望值为参数1 != 参数2
ASSERT_LT (参数1, 参数2)：期望值为参数1 < 参数2
ASSERT_GT (参数1, 参数2)：期望值为参数1 > 参数2
ASSERT_LE (参数1, 参数2)：期望值为参数1 <= 参数2
ASSERT_GE (参数1, 参数2)：期望值为参数1 >= 参数2

字符串类型

字符串的类型为C语言类型的字符串

ASSERT_STREQ (字符串1, 字符串2)：期望值为字符串1 == 字符串2
ASSERT_STRNE (字符串1, 字符串2)：期望值为字符串1 != 字符串2

示例

#include <gtest/gtest.h>
#include <gmock/gmock.h>

using ::testing::_;
using ::testing::Return;

class BaseAPI {
public:
    virtual int getValue() = 0;
    virtual void setValue(int value) = 0;
    virtual void printValue(int value) const = 0;
};

class MockBaseAPI : public BaseAPI {
public:
    MOCK_METHOD0(getValue, int());
    MOCK_METHOD1(setValue, void(int value));
    MOCK_CONST_METHOD1(printValue, void(int value));
};

class BaseTest : public ::testing::Test {
protected:
    void SetUp() override {
        std::cout << "SetUp BaseTest" << std::endl;
    }

    void TearDown() override {
        std::cout << "SetUp TearDown" << std::endl;
    }
};

TEST_F(BaseTest, testValue)
{
    MockBaseAPI* m_MockBaseAPI = new MockBaseAPI();

    // 期望后续会调用getValue() 3次，期望每次调用的返回值都是3。如果getValue()少调用一次，或者多调用一次，都会出现错误
    EXPECT_CALL(*m_MockBaseAPI, getValue()).Times(3).WillRepeatedly(Return(3));

	// 判断getValue()应该返回的值是否等于30，判断失败打印error log: [EXPECT_EQ] getValue FAIL!，但是下面的步骤会继续执行
    EXPECT_EQ(30, m_MockBaseAPI->getValue()) << "[EXPECT_EQ] getValue FAIL!";
     // 上面判断失败了，但是会继续执行。判断getValue()应该返回的值是否等于30，判断失败打印error log: [ASSERT_EQ 1] getValue FAIL!，同时下面的步骤会被中断
    ASSERT_EQ(30, m_MockBaseAPI->getValue()) << "[ASSERT_EQ 1] getValue FAIL!";
    // 上面的ASSERT_EQ执行失败，下面这句不会被执行到
    ASSERT_EQ(30, m_MockBaseAPI->getValue()) << "[ASSERT_EQ 2] getValue FAIL!";

    delete m_MockBaseAPI;
}

int main(int argc,char*argv[])
{
   testing::InitGoogleTest(&argc,argv);
   return RUN_ALL_TESTS();
}

测试结果

gtest gmock gtest gmock注入_#include_06

匹配器 MATCHER_Px

x的值可以是空、2、3…，表示的是匹配器的参数个数，匹配器名字不是参数。
MATCHER_P(name, parameter, "")：一个参数MATCHER_P2(name, parameter1, parameter2, "")：两个参数MATCHER_P3(name, parameter1, parameter2, parameter3, "")：三个参数

/* 
	-NameMatcher: 匹配器的名字，调用的时候调用该名字
	-str: 调用匹配器的时候，传入的参数
	-arg: 调用使用该匹配器的函数的时候，传入的参数
 */
MATCHER_P(NameMatcher, str, "") {
    return arg == str ? true : false;
}

示例

#include <gtest/gtest.h>
#include <gmock/gmock.h>

using ::testing::_;
using ::testing::Return;

// 函数调用的时候，函数的参数必须是等于该value
MATCHER_P(NameMatcher, value, "") {
    return arg == value ? true : false;
}

// 传入的参数value必须是369，否则直接报错。后续函数调用的时候，函数的参数必须是等于该value(369)
MATCHER_P(NameMatcher2, value, "") {
    if (value != 369) return false;
    return arg == value ? true : false;
}

class BaseAPI {
public:
    virtual int getValue() = 0;
    virtual void setValue(int value) = 0;
    virtual void printValue(int value) const = 0;
};

class MockBaseAPI : public BaseAPI {
public:
    MOCK_METHOD0(getValue, int());
    MOCK_METHOD1(setValue, void(int value));
    MOCK_CONST_METHOD1(printValue, void(int value));
};

class BaseTest : public ::testing::Test {
protected:
    void SetUp() override {
        std::cout << "SetUp BaseTest" << std::endl;
    }

    void TearDown() override {
        std::cout << "SetUp TearDown" << std::endl;
    }
};

TEST_F(BaseTest, testValue)
{
    MockBaseAPI* m_MockBaseAPI = new MockBaseAPI();

    // 期望后续会调用setValue()1次，对传入的参数不在意
    EXPECT_CALL(*m_MockBaseAPI, setValue(_)).Times(1);
    m_MockBaseAPI->setValue(123456); // 对参数不在意，所以可以是任意值

	// 期望后续会调用setValue()1次，传入的参数必须要是3，不是3就会失败
    EXPECT_CALL(*m_MockBaseAPI, setValue(NameMatcher(3))).Times(1);
    m_MockBaseAPI->setValue(3);

	// 期望后续会调用setValue()1次，NameMatcher2中传入的参数必须是369否则直接报错，另外调用的时候必须传入369，否则也会失败
    EXPECT_CALL(*m_MockBaseAPI, setValue(NameMatcher2(369))).Times(1);
    m_MockBaseAPI->setValue(369);

    delete m_MockBaseAPI;
}

int main(int argc,char*argv[])
{
   testing::InitGoogleTest(&argc,argv);
   return RUN_ALL_TESTS();
}

NameMatcher(3) 但是函数执行传入的不是3

gtest gmock gtest gmock注入_字符串_07

NameMatcher2(369) 匹配器传入的参数不是369

gtest gmock gtest gmock注入_gtest gmock_08

NameMatcher2(369) 匹配器传入的参数是369，但是函数执行传入的不是369

gtest gmock gtest gmock注入_#include_09

gtest_filter过滤器规则

--gtest_filter=testClass.testCase：仅运行testClass下的testCase
--gtest_filter=*str*：仅运行包含str字符串的测试case
--gtest_filter=-*str* ：包含字符串str的测试case跳过运行
--gtest_filter=-*str1*:*str2* ：包含"str1"或"str2"的测试case跳过运行
--gtest_filter=*str*:-*str1*:*str2* ：这将运行包含str且不包含str1或str2的测试case
“-”后的任何内容都将计入排除列表。