gtest入门

介绍

gtest是谷歌开发的用来做C++单元测试的测试框架

基本概念

使用gtest，你就需要写断言(assertions)，用来检查一个表达式是否为true。断言的结果有三个：正确、非致命错误、致命错误。如果出现致命错误，就会退出当前函数，否则继续执行当前函数的后续部分。

测试用例(tests)使用断言来核实被测试代码的行为。

测试组件(suits)可以包含一个或多个测试用例。通过把测试用例分组到不同的测试组件，可以展现测试代码的结构。如果同一个测试组件中的测试用例需要共享某些对象，你可以把它们放到一个 fixture 类中。

一个测试程序，可以包含多个测试组件。

断言

gtest的断言就像函数调用一样是一些宏。通过断言一个类或者函数的表现来测试它们。如果一个断言失败了，gtest会打印出失败的源文件和行号，连同失败的信息。你可以定义失败信息，这会被附加到gtest的输出信息上。

 ASSERT_* 版本的断言失败的时候生成致命错误，并退出当前函数。EXPECT_* 版本的断言生成非致命错误，不会退出当前函数。通常来说，更推荐EXPECT_*宏，因为它们可以在一个用例中报告出更多的失败测试。不过，如果断言失败时，继续执行下去没有意义，你就应该使用ASERT_* 断言。

因为测试用例失败的时候，ASSERT_* 断言会立刻从函数中退出，所以，可能这样会跳过资源清理的代码，这或许会导致内存泄漏。

为了提供一个定制的错误信息，仅仅使用重定向操作符到断言的宏就可以了：

ASSERT_EQ(x.size(), y.size()) << "Vectors x and y are of unequal length";

for (int i = 0; i < x.size(); ++i) {
  EXPECT_EQ(x[i], y[i]) << "Vectors x and y differ at index " << i;
}

任何能被重定向到 std::ostream 的对象，都可以被重定向到断言的宏，包括 C风格的字符串或者 std::string 对象。如果一个宽字节的字符串重定向到了断言，打印输出的时候，它会被转为UTF-8格式。

基本的断言

true/false 条件判断

Fatal assertion	Nonfatal assertion	Verifies
ASSERT_TRUE(condition)	EXPECT_TRUE(condition)	condition is true
ASSERT_FALSE(condition)	EXPECT_FALSE(condition)	condition is false

二进制比较

这一块是比较两个值的断言

Fatal assertion	Nonfatal assertion	Verifier
ASSERT_EQ(v1, v2)	EXPECT_EQ(v1, v2)	v1 == v2
ASSERT_NE(v1, v2)	EXPECT_NE(v1, v2)	v1 != v2
ASSERT_LT(v1, v2)	EXPECT_LT(v1, v2)	v1 < v2
ASSERT_GT(v1, v2)	EXPECT_GT(v1, v2)	v1 > v2

两个值必须是运算符可比的，否则会编译错误。如果重载了需要的运算符，这些断言可以用在用户自定义的类型上。

一般来说，相对于 ASSERT_TRUE(actual == expected)，ASSERT_EQ(actual, expected)更被推荐使用，因为失败的时候，它可以告诉你两个参数的值。

参数只被评判一次，因此参数可以有副作用。不过，参数的顺序是未定义的，所以测试代码不应该依赖其它的测试。

ASSERT_EQ指的是指针相等，如果判断C语言风格字符串，它判断的是内存位置是否相等，不是是否有相同的值。如果你想比较 const char* 类型的字符串，使用ASSERT_STREQ。判断字符串是否为NULL，使用ASSERT_STREQ(str, NULL)。比较两个 std::string 对象，应该使用ASSERT_EQ。

对于指针比较，使用 *_EQ(ptr, nullptr)和 *_NE(ptr, nullptr)

对于浮点型数值的比较，看advanced文档

字符串比较

比较C风格的字符串

Fatal assertion	Nonfatal assertion	Verifier
ASSERT_STREQ(s1, s2)	EXPECT_STREQ(s1, s2)	字符串内容相同
ASSERT_STRNE(s1, s2)	EXPECT_STRNE(s1, s2)	字符串内容不同
ASSERT_STRCASEEQ(s1, s2)	EXPECT_STRCASEEQ(s1, s2)	忽略大小写，字符串内容相同
ASSERT_STRCASENE(s1, s2)	EXPECT_STRCASENE(s1, s2)	忽略大小写，字符串内容不同

CASE意味着忽略大小写。NULL 和空字符串("")是不同的

STREQ和STRNE也接受宽字节字符串

简单的测试例子

创建一个测试步骤

1. 使用 TEST() 宏定义并命名一个测试函数。
2. 在这个函数中，可以放入任何有效的C++表达式，并使用gtest断言检查值
3. 测试结果被断言来判断。如果任何断言失败，测试就失败。

TEST(TestSuiteName, TestName) {
  ... test body ...
}

TEST() 宏的第一个参数为测试组件的名字，第二个参数为用例名字。两个名字都必须是有效的C++标识符，不能包含下划线。一个测试的全名包含测试组件和用例名字。不同的测试组件里的用例名字可以相同。

比如，一个简单的整形函数：

int Factorial(int n);  // Returns the factorial of n

该函数的测试组件可以如下：

// Tests factorial of 0.
TEST(FactorialTest, HandlesZeroInput) {
  EXPECT_EQ(Factorial(0), 1);
}

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

gtest通过组件来分组测试结果。所以，逻辑相关的测试应该划分到相同的组件，也就是，第一个参数应该相同。上面的例子，我们有两个测试用例，HandlesZeroInput 和 HandlesPositiveInput 都属于组件 FactorialTest

测试设备：多个用例使用同样的数据

如果你写了多个用例，测试同样的数据，你应该使用 fixture。这可以让你重用相同的配置。

创建一个 fixture 步骤：

1. 写一个类继承 testing::Test。使用 protected: 开始内容，因为我们从子类中访问类的成员
2. 在类中声明任何你打算使用的成员
3. 如果有必要，写一个默认构造函数或者SetUp() 函数为每个用例准备数据。常见的错误是把 SetUp 拼写成 Setup，这可以通过关键字 override 来避免这个问题
4. 如果有必要，写一个析构函数或者 TearDown() 函数来释放SetUp中申请的资源。在faq.md页面可以看到应该使用 构造/析构 还是 SetUp/TearDown
5. 如果需要的话，为你的测试定义一个子程序来实现复用。

当使用 fixture时，使用TEST_F() 而不是 TEST()：

TEST_F(TestFixtureName, TestName) {
  ... test body ...
}

TEST_F()，第一个参数为fixture类的名字，_F的意思是: fixture

当然，使用 TEST_F() 之前，你需要定义一个 fixture 类，否则会编译错误

对于每一个使用 TEST_F() 的测试用例，gtest 会在运行时创建一个全新的 fixture 对象，并立刻通过 SetUp 初始化，运行测试，通过 TearDown() 清理资源，然后析构这个对象。相同 suit 的不同测试用例使用不同的 fixture 对象，并且在创建一个新的 fixture 对象前，gtest 会删除老的 fixture 对象。fixture 对象不会被重用。

作为一个例子，我们为 FIFO 的 Queue 写一个用例，如下接口：

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

首先，定义一个 fixture 类：

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

  // void TearDown() override {}

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

TearDown 不是必须的，因为我们不需要在每个用例之后清理Queue。

现在，写一个测试组件：

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

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

  n = q1_.Dequeue();
  ASSERT_NE(n, nullptr);
  EXPECT_EQ(*n, 1);
  EXPECT_EQ(q1_.size(), 0);
  delete n;

  n = q2_.Dequeue();
  ASSERT_NE(n, nullptr);
  EXPECT_EQ(*n, 2);
  EXPECT_EQ(q2_.size(), 1);
  delete n;
}

上面的例子中，我们既使用了 ASSERT_*，也使用了 EXPECT_*。使用 EXPECT_* 是因为我们想让测试函数运行下去，即使某些用例失败了。使用 ASSERT_* 是因为某个用例失败后，继续运行下去，就没有意义了。比如如果某个指针为 nullptr，不能再判断该指针指向的值了。

当这个测试运行的时候，发生了下面的事情：

1. 构造一个 QueueTest 对象(t1)
2. t1.SetUp() 初始化 t1
3. 第一个用例 IsEmptyInitially 运行
4. t1.TearDown 执行清理工作
5. t1 被析构
6. 上面的步骤被重复执行，这次创建一个 t1 的对象，用来运行 DequeueWorks 用例

调用测试用例

TEST() 和 TEST_F() 只是注册了测试用例。所以你不需要为了运行它们，重新列出你定义的测试。

定义用例之后，你需要使用 RUN_ALL_TESTS() 来运行它们，这个宏会返回 0 如果所有的用例都是成功的，否则就是1。RUN_ALL_TESTS() 会运行所有的用例，即使是不同的组件，甚至不同的源文件。

RUN_ALL_TESTS()做了如下事情：

1. 保存所有 flags 的状态
2. 为第一个测试创建 fixture 对象
3. 通过 SetUp 初始化
4. 运行 fixture 对象的用例
5. 使用 TearDown 做清理工作
6. 析构 fixture 对象
7. 恢复所有的 flags 状态
8. 为下一个测试重复上面的步骤，知道所有用例结束

注意：你不能忽略 RUN_ALL_TESTS() 的返回值，否则会编译错误。这么设计的原因是：自动测试根据退出码来决定是否一个测试通过了，而不是在控制台的输出。同时，你只能调用 RUN_ALL_TESTS() 一次

写main函数

写自己的main函数，这里应该返回 RUN_ALL_TESTS()

样板如下：

#include "this/package/foo.h"
#include "gtest/gtest.h"

namespace {

// The fixture for testing class Foo.
class FooTest : public ::testing::Test {
 protected:
  // You can remove any or all of the following functions if its body
  // is empty.

  FooTest() {
     // You can do set-up work for each test here.
  }

  ~FooTest() override {
     // You can do clean-up work that doesn't throw exceptions here.
  }

  // If the constructor and destructor are not enough for setting up
  // and cleaning up each test, you can define the following methods:

  void SetUp() override {
     // Code here will be called immediately after the constructor (right
     // before each test).
  }

  void TearDown() override {
     // Code here will be called immediately after each test (right
     // before the destructor).
  }

  // Objects declared here can be used by all tests in the test suite for Foo.
};

// Tests that the Foo::Bar() method does Abc.
TEST_F(FooTest, MethodBarDoesAbc) {
  const std::string input_filepath = "this/package/testdata/myinputfile.dat";
  const std::string output_filepath = "this/package/testdata/myoutputfile.dat";
  Foo f;
  EXPECT_EQ(f.Bar(input_filepath, output_filepath), 0);
}

// Tests that Foo does Xyz.
TEST_F(FooTest, DoesXyz) {
  // Exercises the Xyz feature of Foo.
}

}  // namespace

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

testing::InitGoogleTest() 解析命令行参数，并且移除所有已识别的标志。

局限性

gtest 是线程安全的，但是这个线程安全仅仅在支持 pthread 的系统的可以。在其他系统中使用两个线程运行测试是不安全的，比如 windows。