ASSERT_ & EXPECT_

Bool

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

Value

Fatal assertion Nonfatal assertion Verifies
ASSERT_EQ(val1, val2); EXPECT_EQ(val1, val2); val1 == val2
ASSERT_NE(val1, val2); EXPECT_NE(val1, val2); val1 != val2
ASSERT_LT(val1, val2); EXPECT_LT(val1, val2); val1 < val2
ASSERT_LE(val1, val2); EXPECT_LE(val1, val2); val1 <= val2
ASSERT_GT(val1, val2); EXPECT_GT(val1, val2); val1 > val2
ASSERT_GE(val1, val2); EXPECT_GE(val1, val2); val1 >= val2

string

Fatal assertion Nonfatal assertion Verifies
ASSERT_STREQ(str1,str2); EXPECT_STREQ(str1,str2); the two C strings have the same content
ASSERT_STRNE(str1,str2); EXPECT_STRNE(str1,str2); the two C strings have different contents
ASSERT_STRCASEEQ(str1,str2); EXPECT_STRCASEEQ(str1,str2); the two C strings have the same content, ignoring case
ASSERT_STRCASENE(str1,str2); EXPECT_STRCASENE(str1,str2); the two C strings have different contents, ignoring case

注意:“CASE”表明忽略大小写,一个 NULL 指针和空字符串不一样

TEST

下面以 googletest/samples 中的 sample1_unittest.cc 中的 demo 为例,简单介绍下一个简单计算阶乘函数 Factorial 实现如下:

1
2
3
4
5
6
7
8
int Factorial(int n) {
int result = 1;
for (int i = 1; i <= n; i++) {
result *= i;
}

return result;
}

用法如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 下面三个 TEST 都是属于同一个 test suite,即 FactorialTest
// 正数为一组
TEST(FactorialTest, Negative) {
EXPECT_EQ(1, Factorial(-5));
EXPECT_EQ(1, Factorial(-1));
EXPECT_GT(Factorial(-10), 0);
}
// 0
TEST(FactorialTest, Zero) {
EXPECT_EQ(1, Factorial(0));
}
// 负数为一组
TEST(FactorialTest, Positive) {
EXPECT_EQ(1, Factorial(1));
EXPECT_EQ(2, Factorial(2));
EXPECT_EQ(6, Factorial(3));
EXPECT_EQ(40320, Factorial(8));
}

在 sample1_unittest.cc 的 main 函数中,添加 RUN_ALL_TESTS 函数即可。

1
2
3
4
5
int main(int argc, char **argv) {
printf("Running main() from %s\\n", __FILE__);
testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

在 TEST 宏函数中,也可以像个普通函数一样,定义变量之类的行为。

比如在 sample2_unittest.cc 中,测试一个自定义类 MyString 的复制构造函数是否表现正常:

1
2
3
4
5
6
7
8
const char kHelloString[] = "Hello, world!";

// 在 TEST 内部,定义变量
TEST(MyString, CopyConstructor) {
const MyString s1(kHelloString);
const MyString s2 = s1;
EXPECT_EQ(0, strcmp(s2.c_string(), kHelloString));
}

TEST_F

下面介绍 gtest 中更为高级的功能:test fixture,对应的宏函数是 TEST_F(TestFixtureName, TestName)。

fixture,其语义是固定的设施,而 test fixture 在 gtest 中的作用就是为每个 TEST 都执行一些同样的操作。

比如,要测试一个队列 Queue 的各个接口功能是否正常,因此就需要向队列中添加元素。如果使用一个 TEST 函数测试 Queue 的一个接口,那么每次执行 TEST 时,都需要在 TEST 宏函数中定义一个 Queue 对象,并向该对象中添加元素,就很冗余、繁琐。

怎么避免这部分冗余的过程?

TEST_F 就是完成这样的事情,它的第一个参数 TestFixtureName 是个类,需要继承 testing::Test,同时根据需要实现以下两个虚函数:

  • virtual void SetUp():在 TEST_F 中测试案例之前运行;
  • virtual void TearDown():在 TEST_F 之后运行。

可以类比对象的构造函数和析构函数。这样,同一个 TestFixtureName 下的每个 TEST_F 都会先执行 SetUp,最后执行 TearDwom。

此外,testing::Test 还提供了两个 static 函数:

  • static void SetUpTestSuite():在第一个 TEST 之前运行
  • static void TearDownTestSuite():在最后一个 TEST 之后运行

以 sample3-inl 中实现的 class Queue 为例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
class QueueTestSmpl3 : public testing::Test { // 继承了 testing::Test
protected:

static void SetUpTestSuite() {
std::cout<<"run before first case..."<<std::endl;
}

static void TearDownTestSuite() {
std::cout<<"run after last case..."<<std::endl;
}

virtual void SetUp() override {
std::cout<<"enter into SetUp()" <<std::endl;
q1_.Enqueue(1);
q2_.Enqueue(2);
q2_.Enqueue(3);
}

virtual void TearDown() override {
std::cout<<"exit from TearDown" <<std::endl;
}

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

下面是 sample3_unittest.cc 中的 TEST_F:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
// in sample3_unittest.cc

// Tests the default c'tor.
TEST_F(QueueTestSmpl3, DefaultConstructor) {
// !!! 在 TEST_F 中可以使用 QueueTestSmpl3 的成员变量、成员函数
EXPECT_EQ(0u, 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_);
}

以 TEST_F(QueueTestSmpl3, DefaultConstructor) 为例,再具体讲解下 TEST_F 的运行流程:

  • gtest 构造一个 QueueTestSmpl3 对象 t1;
  • t1.setUp 初始`t1
  • 第一个 TEST_F 即 DefaultConstructor 开始运行并结束
  • t1.TearDwon 运行,用于清理工作

EXPECT_CALL

1
2
3
4
EXPECT_CALL(mock_object, method(matcher))
.Times(cardinality)
.WillOnce(action)
.WillRepeatedly(action);
  • 第一行中 (matcher) 是可有可无的,只有存在函数同名重载的情况下,(matcher) 才是必须的,用于匹配入参格式
  • 第二行也是可有可无的,cardinality 表示函数应该被调用的次数。常见的有:Times(n) 应该被调用 n 次;Times(::testing::AtLeast(n)) 至少应该被调用 n 次
  • 第三行和第四行,表示做一次或重复做 action。常见的 action 有::testing::Return(n) 表示返回一个数字

例如:

1
2
3
EXPECT_CALL(mock_if_impl, some_func)
.Times(::testing::AtLeast(1))
.WillOnce(::testing::Return(true));