gtest 学习之四 testing::Test

本例是gtest中的第三个demo，有一个测试类，这个测试类是从testing::Test中继承而来，在测试类中有一个SetUp和一个TearDown方法，这两个事件是gtest中提供的事件，通过虚函数可以在继承类中重写这两个方法，这两个事件属于玩转gtest测试框架的事件机制中的TestCase事件。

头文件sample3.h定义：

#ifndef GTEST_SAMPLES_SAMPLE3_INL_H_
#define GTEST_SAMPLES_SAMPLE3_INL_H_

#include <stddef.h>

// Queue 是一个单向链表的简单实现.
//
// The element 必须支持拷贝构造.
template <typename E>  // E is the element type
class Queue;

// QueueNode 是组成 Queue的一个节点
// type E and a pointer to the next node.
template <typename E>  // E is the element type
class QueueNode {
friend class Queue<E>;

public:
// 获取本节点的 element.
const E& element() const { return element_; }

// 获取下一个节点.
QueueNode* next() { return next_; }
const QueueNode* next() const { return next_; }

private:
// 用给定的element创建一个节点，next pointer 被设定为空
QueueNode(const E& an_element) : element_(an_element), next_(NULL) {}

// 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:

// 创建一个空队列.
Queue() : head_(NULL), last_(NULL), 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 == NULL) break;
next = node->next();
}

// 2. Resets the member variables.
head_ = last_ = NULL;
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_; }

// 在队列的尾部加入一个元素，用element的构造函数创建一个element并存贮在队列的尾部
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 NULL;
}

const QueueNode<E>* const old_head = head_;
head_ = head_->next_;
size_--;
if (size_ == 0) {
last_ = NULL;
}

E* element = new E(old_head->element());
delete old_head;

return element;
}

// 在队列的每一个元素上应用function,并返回新队列。原队列不受影响
template <typename F>
Queue* Map(F function) const {
Queue* new_queue = new Queue();
for (const QueueNode<E>* node = head_; node != NULL; 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_SAMPLE3_INL_H_

main.cpp：

#include "sample3.h"
#include "gtest/gtest.h"

class QueueTest : public testing::Test {
protected:  // You should make the members protected s.t. they can be
// accessed from sub-classes.

// 虚函数SetUp将在所有测试用例之前调用，当有变量需要初始化时，应当定义这个函数
virtual void SetUp() {
q1_.Enqueue(1);
q2_.Enqueue(2);
q2_.Enqueue(3);
}

//虚函数 TearDown()将在所有测试用例运行后调用，这个函数用于清理类中的资源，没有资源需要清理时要以不定义
// virtual void TearDown() {
// }

// 用于测试的函数.
static int Double(int n) {
return 2*n;
}

// 用于测试Queue::Map()的函数.
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 != NULL; n1 = n1->next(), n2 = n2->next() ) {
EXPECT_EQ(2 * n1->element(), n2->element());
}

delete new_q;
}

// Declares the variables your tests want to use.
Queue<int> q0_;
Queue<int> q1_;
Queue<int> q2_;
};

// When you have a test fixture, you define a test using TEST_F
// instead of TEST.

// 测试默认构造函数
TEST_F(QueueTest, DefaultConstructor) {
// You can access data in the test fixture here.
EXPECT_EQ(0u, q0_.Size());
}

// Tests Dequeue().
TEST_F(QueueTest, Dequeue) {
int * n = q0_.Dequeue();
EXPECT_TRUE(n == NULL);

n = q1_.Dequeue();
ASSERT_TRUE(n != NULL);
EXPECT_EQ(1, *n);
EXPECT_EQ(0u, q1_.Size());
delete n;

n = q2_.Dequeue();
ASSERT_TRUE(n != NULL);
EXPECT_EQ(2, *n);
EXPECT_EQ(1u, q2_.Size());
delete n;
}

// Tests the Queue::Map() function.
TEST_F(QueueTest, Map) {
MapTester(&q0_);
MapTester(&q1_);
MapTester(&q2_);
}

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

运行结果：