C++ 测试框架 Gtest学习——qt版本

一、参考文档

官方文档

介绍的比较详细的博客

二、获取Gtest

参考

三、使用

（一）qt项目导入Gtest

在项目中创建下面两个文件夹：

• include
• lib
  创建后将gtest的依赖放入里面。依赖获取可以参考获取Gtest

或者在这里获取跟我一样的依赖

（二）修改pro文件

TEMPLATE = app
CONFIG += console c++11
CONFIG -= app_bundle
CONFIG -= qt

# 项目根目录
CPP_ROOT     = $${PWD}

# include 所在目录
INC_PATH     = $${CPP_ROOT}/include
# lib所在目录
LIB_PATH     = $${CPP_ROOT}/lib


# 导入依赖,注意-L 和 -l 是有含义的。详细：https://blog.csdn.net/weixin_42156552/article/details/121871417
INCLUDEPATH += $$INC_PATH/gtest
LIBS        += -L$$LIB_PATH/-lgtest

SOURCES += main.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

（三）一个简单的例子

#include 
#include 

using namespace std;

//一个测试，里面的参数表示这个测试属于那个分组的。如果不会（简单的使用一下），名字可以随便写。
TEST(a1, b2)
{
    int a = 2;
    int b = 1;
    //判断a是不是等于b ，如果不等于会输出 "a!=b" 。EXPECT_EQ 是有特定含义的，用来判断是否相等
    EXPECT_EQ(a, b) << "a!=b" ;

}

int main(int argc, char* argv[])
{
    //固定代码  启动gtest
    testing::InitGoogleTest(&argc, argv);
    //运行所有测试（符合条件的）用例
    return  RUN_ALL_TESTS();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

（四）EXPECT（期望）和ASSERT（断言）介绍

上面的例子中的EXPECT_EQ（a,b） 可以理解为期望a和b相等。

EXPECT 和 ASSERT 可以看作是测试类型的两大分类。EXPECT 类型的测试如果条件不满足，会继续执行接下来的测试。ASSERT 如果遇到一个不满足的，就会停止整个测试 ，注意：ASSERT 是停止一个{}中的所以测试。，不会继续运行其他测试。

• 例子

#include 
#include 

using namespace std;

//一个测试，里面的参数表示这个测试属于那个分组的。如果不会（简单的使用一下），名字可以随便写。
TEST(a1, b1)
{
    int a = 2;
    int b = 1;
    EXPECT_EQ(2, 1) << "2!=1" ;

    EXPECT_EQ(3, 1) << "3!=1" ;

    //判断a是不是等于b ，如果不等于会输出 "a!=b" EXPECT_EQ 是有特定含义的。用来判断是否相等
    
    //遇到断言不满足，停止运行
    ASSERT_EQ(a, b) << "a!=b" ;

    EXPECT_EQ(4, 1) << "4!=1" ;

    //ASSERT_EQ(a, b) << "a!=b" ;
}

//如果b1测试中的断言为flase，不会影响b2测试的进行，只会影响b1后面的测试。
TEST(a1, b2)
{
    EXPECT_EQ(2, 1) << "2!=1" ;

    EXPECT_EQ(3, 1) << "3!=1" ;
}

int main(int argc, char* argv[])
{
    //固定代码  启动gtest
    testing::InitGoogleTest(&argc, argv);
    //运行所有测试（符合条件的）用例
    return  RUN_ALL_TESTS();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

ASSERT_EQ(a, b) << “a!=b” ; 在 EXPECT_EQ(4, 1) << “4!=1” ; 之前测试，结果为：

ASSERT_EQ(a, b) << “a!=b” 在之后

（五）EXPECT（ASSERT）分类

如下：

更多查看官网，跳转

（六）TEST（测试分类）

参考官方文档

1、TEST

TEST(TestSuiteName, TestName) 
{
  
}
1
2
3
4

在测试套件 TestSuiteName 中定义一个名为 TestName 的单个测试，该测试由给定的语句组成。
参数 TestSuiteName 和 TestName 都必须是有效的C++标识符，并且不得包含下划线 （）。不同测试套件中的测试可以具有相同的单个名称。
测试主体中的语句可以是任何受测代码。测试机构中使用的断言决定了测试的结果。

第一个参数 TestSuiteName，为测试组的名字，一般将相同类型的测试分成一组，名字可以随意取，但是命名要符合规范。
第二个参数 TestName，为该测试的名字，是唯一的，不能重名，名字可以随意取，但是命名要符合规范。

#include 
#include 

using namespace std;

//一个测试，里面的参数表示这个测试属于那个分组的。如果不会（简单的使用一下），名字可以随便写。
//a1组中的，b1测试
TEST(a1, b1)
{
    int a = 2;
    int b = 1;
    EXPECT_EQ(2, 1) << "2!=1" ;

    EXPECT_EQ(3, 1) << "3!=1" ;

    //判断a是不是等于b ，如果不等于会输出 "a!=b" EXPECT_EQ 是有特定含义的。用来判断是否相等

    //遇到断言不满足，停止运行
    //ASSERT_EQ(a, b) << "a!=b" ;

    EXPECT_EQ(4, 1) << "4!=1" ;

    ASSERT_EQ(a, b) << "a!=b" ;
}

//a1组中的，b2测试
TEST(a1, b2)
{
    int a = 2;
    int b = 1;
    EXPECT_EQ(2, 1) << "2!=1" ;

    EXPECT_EQ(3, 1) << "3!=1" ;

    //判断a是不是等于b ，如果不等于会输出 "a!=b" EXPECT_EQ 是有特定含义的。用来判断是否相等

    //遇到断言不满足，停止运行
    //ASSERT_EQ(a, b) << "a!=b" ;

    EXPECT_EQ(4, 1) << "4!=1" ;

    ASSERT_EQ(a, b) << "a!=b" ;
}

int main(int argc, char* argv[])
{
    //固定代码  启动gtest
    testing::InitGoogleTest(&argc, argv);
    //运行所有测试（符合条件的）用例
    return  RUN_ALL_TESTS();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

2、TEST_F

这种方式需要结合类使用，继承Gtest提供的接口类。

TEST_F(TestFixtureName, TestName) {
 
}
1
2
3

定义一个名为 TestName 的单个测试，该测试使用测试夹具类 TestFixtureName。测试套件名称为 TestFixtureName。

参数 TestFixtureName（一个继承了::testing::Test 的类） 和 TestName 都必须是有效的标识符C++并且不得包含下划线，不能重名。

• mian

#include 
#include 
#include "testfixture.h"
using namespace std;


TEST_F(TestFixture, test1)
{
    EXPECT_EQ(id, 1);

    EXPECT_EQ(name, "xiaoming");
}

//将测试用例存放到 QueueTest里面。能重复调用测试用例
TEST_F(TestFixture, test2)
{
    EXPECT_EQ(age, 20);
}

int main(int argc, char* argv[])
{
    //固定代码  启动gtest
    testing::InitGoogleTest(&argc, argv);
    //运行所有测试（符合条件的）用例
    return  RUN_ALL_TESTS();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

• TestFixture.h

#include "gtest.h"


using namespace std;


class TestFixture : public ::testing::Test
{

    // Test interface
protected:
    //测试开始前框架会调用这个方法，（初始化测试数据）
    void SetUp() override;
    //测试完后运行这个方法
    void TearDown() override;

public:
    TestFixture();
    int id = 1;
    string name = "lihua";
    int age = 18;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

• TestFixture.cpp

#include "testfixture.h"
#include 

using namespace std;

TestFixture::TestFixture()
{

}

void TestFixture::SetUp()
{
    cout << "------------before testing!!!------------" << endl;
    //初始化测试数据
    id = 2;
    name = "xiaoming";
    age  = 12;
}

void TestFixture::TearDown()
{
    cout << "-----------after the test!!!--------------" << endl;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

运行过程：

1. 谷歌测试构造一个对象（我们称之为）。TestFixture t1 （框架创建的对象）
2. t1.SetUp()初始化。（在测试前调用初始化方法）
3. 运行测试名为： test1的测试。
4. 测试完成后调用 t1.TearDown() 进行（处理业务）清理数据。
5. t1对象销毁。
6. 在另一个对象上重复上述步骤，这次运行测试。test2

3、TEST_P

没搞懂。

TEST_P

其他讲解