Google C++单元测试框架---TestFixture使用

一、测试夹具(Test Fixtures)：对多个测试使用相同的数据配置

如果你发现自己写了两个或更多的测试来操作类似的数据，你可以使用测试夹具。它允许您为几个不同的测试重复使用相同的对象配置。

要创建夹具，只需：

1.从:: testing :: Test派生一个类。 使用protected：或public：开始它的主体，因为我们想从子类     访问fixture成员。
  2.在类中，声明你打算使用的任何对象。
  3.如果需要，可以编写默认构造函数或SetUp（）函数来为每个测试准备对象。 一个常见的错误是     拼写SetUp（）为Setup（）与一个小u -- 不要让这种情况发生在你身上。
  4.如果需要，写一个析构函数或TearDown（）函数来释放你在SetUp（）中分配的任何资源。 要     学习什么时候应该使用构造函数/析构函数，当你应该使用SetUp（）/ TearDown（）时，请阅读这个 FAQ entry.。
  5.如果需要，定义要分享的测试的子程序。

当使用夹具时，使用TEST_F（）而不是TEST（），因为它允许您访问测试夹具中的对象和子程序：

TEST_F(test_case_name, test_name) {
 ... test body ...
}?

和TEST（）一样，第一个参数是测试用例名，但是对于TEST_F（）必须是测试夹具类的名称。 你可能猜到了：_F是夹具。

不幸的是，C ++宏系统不允许我们创建一个可以处理两种类型的测试的宏。 使用错误的宏会导致编译器错误。

另外，在TEST_F（）中使用它之前，你必须首先定义一个测试夹具类，否则将得到编译器错误“virtual outside class declaration”。

对于使用TEST_F（）定义的每个测试，Google Test将：

1.在运行时创建一个新的测试夹具
  2.立即通过SetUp（）初始化，
  3.运行测试
  4.通过调用TearDown（）清除
  5.删除测试夹具。 请注意，同一测试用例中的不同测试具有不同的测试夹具对象，Google测试始     终会删除测试夹具，然后再创建下一个测试夹具。 Google测试不会为多个测试重复使用相同的       测试夹具。一个测试对夹具的任何更改不会影响其他测试。

例如，让我们为名为Queue的FIFO队列类编写测试，它有以下接口：

template <typename E> // E is the element type.
class Queue {
 public:
  Queue();
  void Enqueue(const E& element);
  E* Dequeue(); // Returns NULL if the queue is empty.
  size_t size() const;
  ...
};

　首先定义一个夹具类。按照惯例，你应该给它名称FooTest，其中Foo是被测试的类。　

class QueueTest : public ::testing::Test {
 protected:
  virtual void SetUp() {
    q1_.Enqueue(1);
    q2_.Enqueue(2);
    q2_.Enqueue(3);
  }

  // virtual void TearDown() {}

  Queue<int> q0_;
  Queue<int> q1_;
  Queue<int> q2_;
};

在这种情况下，不需要TearDown（），因为我们不必在每次测试后清理，除了析构函数已经做了什么。

现在我们将使用TEST_F（）和这个夹具编写测试。

TEST_F(QueueTest, IsEmptyInitially) {
  EXPECT_EQ(0, q0_.size());
}

TEST_F(QueueTest, DequeueWorks) {
  int* n = q0_.Dequeue();
  EXPECT_EQ(NULL, n);

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

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

上面使用ASSERT_ *和EXPECT_ *断言。 经验法则( The rule of thumb )是当你希望测试在断言失败后继续显示更多错误时使用EXPECT_ *，或是在失败后继续使用ASSERT_ *没有意义。 例如，Dequeue测试中的第二个断言是ASSERT_TRUE（n！= NULL），因为我们需要稍后解引用指针n，这将导致n为NULL时的segfault。

当这些测试运行时，会发生以下情况：

1.Google Test构造了一个QueueTest对象（我们称之为t1）。 
  2.t1.SetUp（）初始化t1。 
  3.第一个测试（IsEmptyInitially）在t1上运行。 
  4.t1.TearDown（）在测试完成后清理。 
  5.t1被析构。 
  6.以上步骤在另一个QueueTest对象上重复，这次运行DequeueWorks测试。

二、如何通过字夹具使多个测试用例重用一个测试夹具

1. 当定义测试夹具时，您指定将使用此夹具的测试用例的名称。 因此，测试夹具只能由一个测试用例使用。
   有时，多个测试用例可能需要使用相同或稍微不同的测试夹具。 例如，您可能需要确保GUI库的所有测试不会泄漏重要的系统资源，如字体和画笔。 在Google测试中，您可以做到
  这通过将共享逻辑放在超级（如“超级类”）测试夹具中，然后让每个测试用例使用从这个超级夹具派生的夹具。
   在这个示例中，我们希望确保每个测试在?5秒内完成。 如果测试运行时间较长，我们认为测试失败。

我们把测试时间的代码放在一个叫做“QuickTest”的测试夹具中。 QuickTest旨在作为其他夹具派生的超级夹具，因此没有名为“QuickTest”的测试用例。

然后，我们将从QuickTest中导出多个测试夹具。

class QuickTest : public testing::Test {
protected:
	// Remember that SetUp() is run immediately before a test starts.
	// This is a good place to record the start time.
	//这个方法在每一个test之前执行
	virtual void SetUp() {
		start_time_ = time(NULL);
	}
	// TearDown() is invoked immediately after a test finishes.  Here we
	// check if the test was too slow.
	//这个方法在每一个test之后执行
	virtual void TearDown() {
		// Gets the time when the test finishes
		const time_t end_time = time(NULL);
		// Asserts that the test took no more than ~5 seconds.  Did you
		// know that you can use assertions in SetUp() and TearDown() as
		// well?
		EXPECT_TRUE(end_time - start_time_ <= 5) << "The test took too long.";
	}

	// The UTC time (in seconds) when the test starts
	time_t start_time_;
};

2.我们定义一个IntegerFunctionTest继承QuickTest， 使用该夹具的所有测试将自动要求快速。

class IntegerFunctionTest : public QuickTest {
	// We don‘t need any more logic than already in the QuickTest fixture.
	// Therefore the body is empty.
};

3.现在我们可以在Integer Function Test测试用例中写测试了。

TEST_F(IntegerFunctionTest, Factorial) {
	// Tests factorial of negative numbers.
	EXPECT_EQ(1, Factorial(-5));
	EXPECT_EQ(1, Factorial(-1));
	EXPECT_GT(Factorial(-10), 0);

	// Tests factorial of 0.
	EXPECT_EQ(1, Factorial(0));

	// Tests factorial of positive numbers.
	EXPECT_EQ(1, Factorial(1));
	EXPECT_EQ(2, Factorial(2));
	EXPECT_EQ(6, Factorial(3));
	EXPECT_EQ(40320, Factorial(8));
}

4. 下一个测试用例（名为“QueueTest”）也需要很快，所以我们从QuickTest派生另一个夹具。
QueueTest测试夹具有一些逻辑和共享对象，除了QuickTest中已有的。 我们像往常一样在测试夹具的主体内定义额外的东西。

class QueueTest : public QuickTest {
protected:
	virtual void SetUp() {
		// First, we need to set up the super fixture (QuickTest).
		QuickTest::SetUp();

		// Second, some additional setup for this fixture.
		q1_.Enqueue(1);
		q2_.Enqueue(2);
		q2_.Enqueue(3);
	}

	// By default, TearDown() inherits the behavior of
	// QuickTest::TearDown().  As we have no additional cleaning work
	// for QueueTest, we omit it here.
	//
	// virtual void TearDown() {
	//   QuickTest::TearDown();
	// }

	Queue<int> q0_;
	Queue<int> q1_;
	Queue<int> q2_;
};

　　接下来我们就可以用QueueTest写一些测试。

// Tests the default constructor.
TEST_F(QueueTest, DefaultConstructor) {
	EXPECT_EQ(0u, q0_.Size());
}

　　如有必要，您可以从派生的夹具本身获得进一步的测试夹具。 例如，您可以从QueueTest派生另一个夹具。 Google测试对层次结构的深度没有限制。 然而，在实践中，你可能不希望它太深以至于混淆。