GTest基础学习-04-第3个单元测试-测试夹具test fixture

待我称王封你为后i 2022-12-02 01:26 238阅读 0赞

这篇来学习一下Gtest中更高级一些的特性test fixture，测试夹具的基本上使用。什么的场景需要使用到测试夹具呢？测试夹具是哪个宏，这篇来学习这个主题。

**1.什么叫test fixture**

什么是测试夹具，这个概念在任何xUnit系列的单元测试框架都会出现。一般是指，所有的测试用例都可以共享的步骤，例如初始化和事后清理操作，能提供这个功能的对象叫test fixture。

在test fixture是这样使用的，我们需要单独写一个类并且继承testing::Test，如果有必要都需要实现SetUp()和TearDown()函数，当然这两个至少有一个需要实现，不然我们不会去使用test fixture这个功能。在SetUp()函数中一般写一些初始化操作，例如测试对象的创建，对象的成员变量的初始化等，在TearDown()一般用来集中清除资源操作，例如销毁在SetUp()中创建的被测试对象。

**2.测试夹具使用**

sample03.h代码

#ifndef GTEST_SAMPLES_SAMPLE03_INL_H_
    #define GTEST_SAMPLES_SAMPLE03_INL_H_
    
    #include <stddef.h>
    
    
    // Queue类是一个简单的队列，内部是基于单链表实现
    //
    // 元素数据类型必须支持拷贝构造
    template <typename E>  // E 是元素的类型。使用了模板类
    class Queue;
    
    // QueueNode 是Queue对象中的一个结点, 存储元素E和指向下一个结点的指针
    template <typename E>  // E 是元素的类型。使用了模板类
    class QueueNode {
    	friend class Queue<E>;
    
    public:
    	// 获取结点中的元素
    	const E& element() const { return element_; }
    
    	// 获取下一个结点
    	QueueNode* next() { return next_; }
    	const QueueNode* next() const { return next_; }
    
    private:
    	// 创建一个结点，元素是参数element，下一个结点的指针设置为NULL
    	explicit QueueNode(const E& an_element)
    		: element_(an_element), next_(nullptr) {}
    
    	// 这里禁用默认的赋值操作和构造
    	const QueueNode& operator = (const QueueNode&);
    	QueueNode(const QueueNode&);
    
    	E element_;
    	QueueNode* next_;
    };
    
    template <typename E>  // E 是可以任意类型
    class Queue {
    public:
    	// 创建一个空的队列
    	Queue() : head_(nullptr), last_(nullptr), size_(0) {}
    
    	// 析构函数 清空队列
    	~Queue() { Clear(); }
    
    	// 清空队列函数
    	void Clear() {
    		if (size_ > 0) {
    			// 1. 删除每一个结点
    			QueueNode<E>* node = head_;
    			QueueNode<E>* next = node->next();
    			for (; ;) {
    				delete node;
    				node = next;
    				if (node == nullptr) break;  //跳槽循环在这行
    				next = node->next();
    			}
    
    			// 2.重置成员变量，队列大小为0，头结点和尾结点都设置为空指针
    			head_ = last_ = nullptr;
    			size_ = 0;
    		}
    	}
    
    	// 获取队列元素个数
    	size_t Size() const { return size_; }
    
    	// 获取队列头部元素, 如果队列为空返回NULL
    	QueueNode<E>* Head() { return head_; }
    	const QueueNode<E>* Head() const { return head_; }
    
    	// 获取队列尾部元素, 如果队列为空返回NULL
    	QueueNode<E>* Last() { return last_; }
    	const QueueNode<E>* Last() const { return last_; }
    
    	// 往队列尾部插入一个元素，使用拷贝构造创建这个元素并存储在队列中 
    	//对队列中的元素所做的更改不会影响源对象，反之亦然。
    	void Enqueue(const E& element) {
    		QueueNode<E>* new_node = new QueueNode<E>(element);
    
    		if (size_ == 0) {
    			head_ = last_ = new_node;
    			size_ = 1;
    		}
    		else {
    			last_->next_ = new_node;
    			last_ = new_node;
    			size_++;
    		}
    	}
    
    	// 删除头部元素并返回这个元素，如果队列为空，返回NULL
    	E* Dequeue() {
    		if (size_ == 0) {
    			return nullptr;
    		}
    
    		const QueueNode<E>* const old_head = head_;
    		head_ = head_->next_;
    		size_--;
    		if (size_ == 0) {
    			last_ = nullptr;
    		}
    
    		E* element = new E(old_head->element());
    		delete old_head;
    
    		return element;
    	}
    
    	// 提供一个函数，遍历队列中每一元素，调用这个函数，返回结果存储在一个新的队列，源队列对象不受影响
    	template <typename F>
    	Queue* Map(F function) const {
    		Queue* new_queue = new Queue();
    		for (const QueueNode<E>* node = head_; node != nullptr;
    			node = node->next_) {
    			new_queue->Enqueue(function(node->element()));
    		}
    
    		return new_queue;
    	}
    
    private:
    	QueueNode<E>* head_;  // 队列头结点
    	QueueNode<E>* last_;  // 队列尾结点
    	size_t size_;  // 队列元素个数
    
    	// 这里不允许复制队列.
    	Queue(const Queue&);
    	const Queue& operator = (const Queue&);
    };
    
    #endif  // GTEST_SAMPLES_SAMPLE03_INL_H_

TestSample03.cpp代码

//在这个例子中，我们使用Gtest中更高级一点的特性，叫test fixture, 一般翻译测试夹具
    //
    // 测试夹具是用来放置对象和函数，并共享给所有的测试用例在一个测试cpp文件中
    // 使用测试夹具能够避免测试代码重复，特别是哪些每个测试都需要用到的初始化和清除操作
    //
    //测试从代码共享的意义上共享的是测试夹具，而不是数据共享。
    //每个测试都有自己的最新副本夹具。 您不能期望一次测试修改的数据是传递给另一个测试，这是一个坏主意.
    //
    // 这么设计的原因是保持测试的独立性和可重复性  
    // 一个测试不能受其他的测试失败而导致失败
    //如果一个测试依赖于另一个测试，这两个测试应该是被看作一个大的测试
    //
    // 响应测试成功或失败的宏（例如 EXPECT_TRUE, FAIL, 等）需要知道当前的测试是什么
    // 当Google test打印测试结果，如果遇到失败，打印结果会告诉失败是哪一个测试
    //从技术上讲，这些宏会调用Test类的成员函数。 因此，您不能在全局函数中使用他们。
    //这就是为什么您应该放置测试子例程在测试夹具中。
    //
    
    #include "sample03.h"
    #include "gtest/gtest.h"
    namespace {
    	// 想要使用测试夹具，需要定义一个类并继承testing::Test 
    	class QueueTestSmpl3 : public testing::Test {
    	protected:  // 这里使用保护关键字，成员都受访问保护，可以从子类中访问到父类受保护的成员
    
    	// 每个TEST宏的测试在开始运行之前都会调用virtual void SetUp() 
    	//应该实现这个SetUp()，例如一些变量初始化，如果用不到就不需要提供SetUp()
    				
    	void SetUp() override {
    		q1_.Enqueue(1);
    		q2_.Enqueue(2);
    		q2_.Enqueue(3);
    	}
    
    	// 每个TEST宏的测试在结束之前都会调用virtual void TearDown() 
    	// 你应该定义在TearDown中做哪些清除操作，否则不应该提供这个TearDown函数
    	//
    	// virtual void TearDown() {
    	// }
    
    	// 一个帮助函数，有些测试需要用到
    	static int Double(int n) {
    		return 2 * n;
    	}
    
    	// 一个帮助函数，为了测试 Queue::Map().
    	void MapTester(const Queue<int> * q) {
    		// 新建一个对象，队列中每一个元素都是q中元素的两倍大小
    		const Queue<int> * const new_q = q->Map(Double);
    
    		// 确认新的队列大小和q是一样大
    		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_;
    	};
    
    	// 当你有需要测试夹具（ fixture翻译为夹具），需要使用 TEST_F宏编写测试用例，不用TEST宏
    
    	// 测试默认构造函数
    	TEST_F(QueueTestSmpl3, DefaultConstructor) {
    		// 可以访问元素使用TEST_IF
    		EXPECT_EQ(0u, q0_.Size());
    	}
    
    	// 测试 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;
    	}
    
    	// 测试函数Queue::Map() 
    	TEST_F(QueueTestSmpl3, Map) {
    		MapTester(&q0_);
    		MapTester(&q1_);
    		MapTester(&q2_);
    	}
    }  // namespace

在拷贝我的代码过程需要注意，我在每个cpp文件都右键-属性-预编译头中选择了不使用预编译头。

点击生成解决方案，查看gtest的运行输出结果

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE1NDE5NDY_size_16_color_FFFFFF_t_70][]

红圈这几个测试结果是本篇关于test fixture的用例运行结果，注意看倒数第3行，Global test environment tear-down，这个gtest在运行全部测试用例的时候，内部也使用了TearDown()这个机制。

**3.总结**

这篇重点是介绍学习test fixture的基本使用。被测试的对象是一个自定义的队列数据结构的MyQueue类。测试代码中用到了new开辟内存空间和delete删除内存空间，还有模板类的定义。

1.使用TEST\_F(测试夹具名称，测试用例名称)

这个测试夹具名称一般就是我们在cpp文件中提前写的自定义类的名称，这个类是必须继承testing::Test

本篇就新使用到了几个测试断言宏

ASSERT_EQ	//强断言 两个对象是否相等
    ASSERT_TRUE	//强断言，表达式或函数返回值是不是true

这个看起来和前面的EXPECT\_EQ和EXPECT\_TRUE是一样的作用，很自然，我们就会去想ASSER和EXPECT有什么区别。

**4.ASSERT和EXPECT的区别**

我们在gtest中光标定位在ASSERT\_TURE,按下键盘F12，可以看到定义这个方法的代码如下

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE1NDE5NDY_size_16_color_FFFFFF_t_70 1][]

通过对比ASSERT\_TRUE和EXPECT\_TRUE中调用代码的实现，发现两个断言宏的根本区别是在于NONFATAL 和FATAL的区别。上面可以看到EXPECT是调用NONFATAL，而ASSERT是调用FATAL实现。在不继续看代码之前，我们先搞清楚FATAL这个英文单词的意思，翻译过来就是致命。也就是ASSERT走的是致命失败，而EXPECT走的是非致命失败。

接着分别来看**GTEST\_NONFATAL\_FAILURE\_** 和**GTEST\_FATAL\_FAILURE\_**的内部实现

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE1NDE5NDY_size_16_color_FFFFFF_t_70 2][]

上面我们点击右侧TestPartResult这个接口，点击F12。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE1NDE5NDY_size_16_color_FFFFFF_t_70 3][]

马上就接近真相，通过红圈两个枚举的注释我们得到了答案。

**ASSERT\_TRUE ：如果失败，测试应该被终止**

**EXPECT\_TRUE：如果失败，测试可以继续往下运行**

根据这个结论，但是我们当前的水平不好写代码去验证，因为gtest的运行报告不会显示我们自己写的std::cout语句的打印数据。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE1NDE5NDY_size_16_color_FFFFFF_t_70]: /images/20221123/d093c22580b24687be05fdaabba8fd8a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE1NDE5NDY_size_16_color_FFFFFF_t_70 1]: /images/20221123/80866b7dd68d44a19f119f391d3efe1d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE1NDE5NDY_size_16_color_FFFFFF_t_70 2]: /images/20221123/a1447561deb849159aa230aed0ceaebc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE1NDE5NDY_size_16_color_FFFFFF_t_70 3]: /images/20221123/f79163cc006a47929e9dc53e9e5a486c.png