gtest学习笔记--2测试夹具(类)TEST_F

相关的配置与参考可以看相同系列的第一篇。本篇只提供代码。
test_02.h

#ifndef GTEST_SAMPLES_SAMPLE3_INL_H_
#define GTEST_SAMPLES_SAMPLE3_INL_H_

#include <stddef.h>


// Queue is a simple queue implemented as a singled-linked list.
//
// The element type must support copy constructor.
template <typename E>  // E is the element type
class Queue;

// QueueNode is a node in a Queue, which consists of an element of
// type E and a pointer to the next node.
template <typename E>  // E is the element type
class QueueNode {
	friend class Queue<E>;

public:
	// Gets the element in this node.
	const E& element() const { return element_; }

	// Gets the next node in the queue.
	QueueNode* next() { return next_; }
	const QueueNode* next() const { return next_; }

private:
	// Creates a node with a given element value.  The next pointer is
	// set to NULL.
	explicit QueueNode(const E& an_element)
		: element_(an_element), next_(nullptr) {}

	// We disable the default assignment operator and copy c'tor.
	const QueueNode& operator = (const QueueNode&);
	QueueNode(const QueueNode&);

	E element_;
	QueueNode* next_;
};

template <typename E>  // E is the element type.
class Queue {
public:
	// Creates an empty queue.
	Queue() : head_(nullptr), last_(nullptr), size_(0) {}

	// D'tor.  Clears the queue.
	~Queue() { Clear(); }

	// Clears the queue.
	void Clear() {
		if (size_ > 0) {
			// 1. Deletes every node.
			QueueNode<E>* node = head_;
			QueueNode<E>* next = node->next();
			for (; ;) {
				delete node;
				node = next;
				if (node == nullptr) break;
				next = node->next();
			}

			// 2. Resets the member variables.
			head_ = last_ = nullptr;
			size_ = 0;
		}
	}

	// Gets the number of elements.
	size_t Size() const { return size_; }

	// Gets the first element of the queue, or NULL if the queue is empty.
	QueueNode<E>* Head() { return head_; }
	const QueueNode<E>* Head() const { return head_; }

	// Gets the last element of the queue, or NULL if the queue is empty.
	QueueNode<E>* Last() { return last_; }
	const QueueNode<E>* Last() const { return last_; }

	// Adds an element to the end of the queue.  A copy of the element is
	// created using the copy constructor, and then stored in the queue.
	// Changes made to the element in the queue doesn't affect the source
	// object, and vice versa.
	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_++;
		}
	}

	// Removes the head of the queue and returns it.  Returns NULL if
	// the queue is empty.
	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;
	}

	// Applies a function/functor on each element of the queue, and
	// returns the result in a new queue.  The original queue is not
	// affected.
	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_;  // The first node of the queue.
	QueueNode<E>* last_;  // The last node of the queue.
	size_t size_;  // The number of elements in the queue.

				   // We disallow copying a queue.
	Queue(const Queue&);
	const Queue& operator = (const Queue&);
};

#endif  // GTEST_SAMPLES_SAMPLE3_INL_H_

test_02.cpp

#include "gtest/gtest.h"
#include "test_02.h"
#ifndef _WIN64
#pragma  comment(lib,"../lib86/gmock.lib")
#pragma  comment(lib,"../lib86/gmock_main.lib")
#pragma  comment(lib,"../lib86/gtest.lib")
#pragma  comment(lib,"../lib86/gtest_main.lib")
#else
#pragma  comment(lib,"../lib64/gmock.lib")
#pragma  comment(lib,"../lib64/gmock_main.lib")
#pragma  comment(lib,"../lib64/gtest.lib")
#pragma  comment(lib,"../lib64/gtest_main.lib")
#endif // !_WIN64

/*
///测试类
https://www.cnblogs.com/coderzh/archive/2009/04/06/1430396.html
*/
class QueueTestSmpl3 : public testing::Test
{
	protected:
	void SetUp() override {
		q1_.Enqueue(1);
		q2_.Enqueue(2);
		q2_.Enqueue(3);
	}

	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_;
};

//测试类要用TEST_F
// When you have a test fixture, you define a test using TEST_F
// instead of TEST.

// Tests the default c'tor.
TEST_F(QueueTestSmpl3, DefaultConstructor)
{
	// You can access data in the test fixture here.
	//访问类数据
	EXPECT_EQ(0, 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_);
}

int test_02(int argc, char **argv) {

	try
	{
		testing::InitGoogleTest(&argc, argv);
		RUN_ALL_TESTS();
	}
	catch (std::exception& e)
	{
		std::cout << e.what() << std::endl;
	}
	system("pause");
	return 0;
}