血鸟导航 血鸟导航
推荐
立即推荐

【C++】Google Gtest测试框架的使用

随笔2个月前发布 端端妈
46 0 0

gtest模块的安装参考站内教程  ubuntu安装google gtest

本文使用的gtest版本为1.14.0；

1.gtest是用来干嘛的？

google gtest是一个c++的单元测试模块，它提供了一系列规范化的宏，来帮助我们进行函数的单元测试。

【C++】Google Gtest测试框架的使用

单元测试你可以理解为测试我们编写好的每个函数模块，确保这些函数的功能不会影响其他函数，并保证函数能依照预期的功能进行工作。

要知道，绝大部分的软件bug都是在设计、初次代码编写的过程中产生的，比如你写了一个add函数，但是错误的将运算符写成了-，add就变成sub函数了，如果这个add函数在其他功能模块完成之后才发现被写错，就闹大笑话了。

当然，上面这个add的例子并不合适，因为它太简单了。但实际项目中，就是由多个很简单的代码聚合而成的一个大软件模块。每一个看上去简单、不可能写错的地方，都有可能隐藏的出错的危险。

所以，这就需要我们在完成每个功能函数的编写后，通过单元测试来判断函数是否有问题。

2.gtest的代码基本框架

一般情况下，多模块的软件项目都会用cmake来实现批量化的编译和单元测试的运行。但本文只是对gtest模块使用的最基本教程，再加上我并没有学习cmake的使用，所以暂时使用g++直接对单模块进行编译并介绍gtest的测试宏。

 Testing Reference | GoogleTest

比较常用的是TEST和TEST_F这两个测试宏，更多测试宏请参考官方文档中的介绍。

2.1 TEST 单元测试模块

在gtest中，一个单元测试模块长下面这样

<code class="language-plain has-numbering hljs" id="code_id_0">TEST(TestSuiteName, TestName) {
  ... statements ...
}</code>

1.2.3.

你可以理解为，左侧是被测模块的名字，右侧是在这个被测模块中的某个测试的名字，statements是任意被测模块的代码；gtest框架建议使用大驼峰的命名方式，TEST的命名中不要带有_下划线。

比如我有一个模块A的单元测试，那么左侧可以填写为模块ATest，右侧填写为类中某个函数的测试。这两个名字可以随便起，但是在同一个TestSuiteName中不能有两个相同的TestName；

一个单元测试模块的成功与失败取决于内部定义的gtest断言宏，参考后文的介绍。

2.2 TEST_F 类测试模块

上述的TEST方式是用于测试普通函数的，还有一个TEST_F可以用于对类进行测试

<code class="language-plain has-numbering hljs" id="code_id_1">TEST_F(TestFixtureName, TestName) {
  ... statements ...
}</code>

1.2.3.

此时左侧的TestFixtureName不再是随便起的了，你必须定义一个继承于testing::Test的测试类，该类可以定义成员变量或对被测目标进行初始化、销毁操作。

<code class="language-plain has-numbering hljs" id="code_id_2">class MyClassTest : public testing::Test {
protected:  
    void SetUp() // 初始化，在每个TEST_F中都会被调用
    {}

    void TearDown() // 销毁，在每个TEST_F结束时都会调用
    {}
    
	// 可以定义一些成员变量，在TEST_F中能访问
    int _a;
};</code>

1.2.3.4.5.6.7.8.9.10.11.

最终的测试代码应该是下面这样的

<code class="language-plain has-numbering hljs" id="code_id_3">class MyClassTest : public testing::Test {
  ...
};

TEST_F(MyClassTest, HasPropertyA) { ... }
TEST_F(MyClassTest, HasPropertyB) { ... }</code>

1.2.3.4.5.6.

2.3 简单示例

下面是一个简单的gtest单元测试编写的示例，包含测试单元体和main函数。一个文件里面可以写N个TEST或TEST_F，它们会按顺序执行。

<code class="language-plain has-numbering hljs" id="code_id_4">#include <gtest/gtest.h>

// 一个函数测试
// 左侧是测试模块的名字，右侧是该模块测试的目的
TEST(ADDTEST, ADDTEST_TRUE)
{}

int main(int argc, char **argv)
{
	// 主函数
    testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}</code>

1.2.3.4.5.6.7.8.9.10.11.12.13.

使用如下g++命令编译该代码，注意gtest是一个动态库，需要使用-lgtest进行链接。

<code class="language-plain has-numbering hljs" id="code_id_5">g++ test.cpp -o test -lgtest</code>

1.

3.gtest提供的断言宏

官方文档： Assertions Reference | GoogleTest

gtest中提供的宏分为ASSERT和EXPECT两种，其中ASSERT宏会在检查到错误的时候直接终止单元测试用例的运行（注意是单个单元测试），而EXPECT不会。

<code class="language-plain has-numbering hljs" id="code_id_6">TEST(EXP,EXP1)
{
	ASSERT_EQ(1,1); // 如果这个出错了，后续不会执行
	// 这里不会被执行	
}

TEST(EXP,EXP2)
{
	EXPECT_EQ(1,1); // 如果这个出错了，还是会继续往后执行这个模块的其他代码。
	// 这里的代码能被执行
}</code>

1.2.3.4.5.6.7.8.9.10.11.

单元测试运行结束后，gtest会给出测试失败的模块汇总。

3.1 相等/大小判断

ASSERT宏

EXPECT宏

功能

参数个数

ASSERT_TRUE

EXPECT_TRUE

判真

1

ASSERT_FALSE

EXPECT_FALSE

判假

1

ASSERT_EQ

EXPECT_EQ

相等

2

ASSERT_NE

EXPECT_NE

不相等

2

ASSERT_GT

EXPECT_GT

第一个参数是否大于第二个参数

2

ASSERT_LT

EXPECT_LT

小于（原理同上）

2

ASSERT_GE

EXPECT_GE

大于等于

2

ASSERT_LE

EXPECT_LE

小于等于

2

ASSERT_FLOAT_EQ

EXPECT_FLOAT_EQ

单精度浮点数相等

2

ASSERT_DOUBLE_EQ

EXPECT_DOUBLE_EQ

双精度浮点数相等

2

ASSERT_NEAR

EXPECT_NEAR

浮点数是否接近（第三个参数为允许的误差值）

3

ASSERT_STREQ

EXPECT_STREQ

C字符串相等

2

ASSERT_STRNE

EXPECT_STRNE

C字符串不相等

2

ASSERT_STRCASEEQ

EXPECT_STRCASEEQ

C字符串相等（忽略大小写）

2

ASSERT_STRCASENE

EXPECT_STRCASENE

C字符串不相等（忽略大小写）

2

ASSERT_PRED1

EXPECT_PRED1

自定义谓词测试（有1到5级，对应不同参数个数的自定义函数）

2

ASSERT_THAT

EXPECT_THAT

判断函数返回值是否符合给定的matcher（gtest提供的）

2

3.2 异常相关

除了上述这种判断大小和相等的宏，还有和异常以及程序崩溃相关的宏

ASSERT宏

EXPECT宏

作用

参数个数

ASSERT_THROW

EXPECT_THROW

期待抛出指定异常，第一个参数是目标函数，第二个参数是异常类型

2

ASSERT_ANY_THROW

EXPECT_ANY_THROW

期待抛出任何异常

1

ASSERT_NO_THROW

EXPECT_NO_THROW

不希望抛出任何异常

1

ASSERT_EXIT

EXPECT_EXIT

期望程序以指定错误码exit，且标准错误输出符合第三个参数的regex表达式

3

ASSERT_DEATH

EXPECT_DEATH

期望程序错误退出（退出码非0），且标准错误输出符合第二个参数的regex表达式

2

ASSERT_DEBUG_DEATH

EXPECT_DEBUG_DEATH

同上，但是在调试模式下测试；非调试模式下只会执行函数，不做判断。

2

ASSERT_DEATH_IF_SUPPORTED

EXPECT_DEATH_IF_SUPPORTED

同DEATH，但是只有在支持的时候才会被调用，如果不支持则什么都不做。

2

3.3 直接表明成功和失败

还有两个宏是直接表明该单元测试是否成功，以及是否失败的。主动调用这两个宏会提前终止该单元测试用例。

<code class="language-plain has-numbering hljs" id="code_id_7">SUCCEED(); // 成功
FAIL();    // 失败</code>

1.2.

3.4 添加失败信息

有的时候gtest默认提供的ASSERT宏不够我们的使用，你可以用自定义的判断，并在不符合预期的时候将这个错误信息添加进去，Gtest在最后汇总的时候也会显示出来。

<code class="language-plain has-numbering hljs" id="code_id_8">// Generates a nonfatal failure, which allows the current function to continue running.
ADD_FAILURE();

// Generates a nonfatal failure at the file and line number specified.
ADD_FAILURE_AT(file_path,line_number);</code>

1.2.3.4.5.

这两个宏的效果和EXPECT类似，都允许继续往后执行该单元测试用例。

4.使用示例

大部分的使用都是一样的，下面只对几个有代表性的做使用示例；为了方便，只对ASSERT做示例，因为它的效果和EXPECT完全一致，上文已经提到了二者的区别了。

4.1 ASSERT_EXIT

ASSERT_EXIT有三个参数，分别为待测函数、退出码或退出信号、错误信息regex；待测函数必须以指定的错误码或错误信号退出程序，并在stderr中打印能被这个regex匹配的错误信息。

<code class="language-plain has-numbering hljs" id="code_id_9">ASSERT_EXIT(statement,predicate,matcher);</code>

1.

第二个参数的可选项，分别代表错误退出码和收到的错误信号

<code class="language-plain has-numbering hljs" id="code_id_10">// Returns true if the program exited normally with the given exit status code.
::testing::ExitedWithCode(exit_code);

// Returns true if the program was killed by the given signal.
// Not available on Windows.
::testing::KilledBySignal(signal_number);</code>

1.2.3.4.5.6.

第三个参数在官网上的描述是这样的

The parameter matcher is either a matcher for a const std::string&, or a regular expression (see  Regular Expression Syntax)—a bare string s (with no matcher) is treated as ContainsRegex(s), not Eq(s).

如果传入一个普通字符串，则会判断stderr输出的内容是否包含该字符串。

下面是一个简单的示例，我们的函数调用了exit(1)，使用ASSERT_EXIT来判断它是否以预期的错误码1退出程序。第三个参数.*是正则表达式，代表任意错误信息的匹配。

<code class="language-plain has-numbering hljs" id="code_id_11">#include <gtest/gtest.h>
#include <iostream>
#include <unistd.h>


void test_exit()
{
    std::cerr << "test exit
";
    exit(1);
    // int ret = 10/0;
}

TEST(EXPTEST, EXPTEST_EXIT)
{
    // 期望以错误码1退出
    ASSERT_EXIT(test_exit(),testing::ExitedWithCode(1),".*");
}

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

1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23.

编译后的执行效果如下，我们的单元测试成功了，因为函数的确是以错误码1退出的。

<code class="language-plain has-numbering hljs" id="code_id_12">❯ g++ test.cpp -o test -lgtest && ./test
[==========] Running 1 test from 1 test suite.
[----------] Global test environment set-up.
[----------] 1 test from EXPTEST
[ RUN      ] EXPTEST.EXPTEST_EXIT
[       OK ] EXPTEST.EXPTEST_EXIT (0 ms)
[----------] 1 test from EXPTEST (0 ms total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test suite ran. (0 ms total)
[  PASSED  ] 1 test.</code>

1.2.3.4.5.6.7.8.9.10.11.

那么如果换一个退出方式呢？比如因为除0错误退出

<code class="language-plain has-numbering hljs" id="code_id_13">❯ g++ test.cpp -o test -lgtest && ./test
test.cpp: In function 'void test_exit()':
test.cpp:11:17: warning: division by zero [-Wdiv-by-zero]
   11 |     int ret = 10/0;
      |               ~~^~
[==========] Running 1 test from 1 test suite.
[----------] Global test environment set-up.
[----------] 1 test from EXPTEST
[ RUN      ] EXPTEST.EXPTEST_EXIT
test.cpp:17: Failure
Death test: test_exit()
    Result: died but not with expected exit code:
            Terminated by signal 8
Actual msg:
[  DEATH   ] test exit
[  DEATH   ] 

[  FAILED  ] EXPTEST.EXPTEST_EXIT (0 ms)
[----------] 1 test from EXPTEST (0 ms total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test suite ran. (0 ms total)
[  PASSED  ] 0 tests.
[  FAILED  ] 1 test, listed below:
[  FAILED  ] EXPTEST.EXPTEST_EXIT

 1 FAILED TEST</code>

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.

这个时候单元测试就失败了，并会打印出失败行的位置和失败的原因。这里提到失败是因为受到了信号8，但我们预期是错误码1。

将预期修改为信号8，就能通过测试

<code class="language-plain has-numbering hljs" id="code_id_14">void test_exit()
{
    std::cerr << "test exit
";
    // exit(1);
    int ret = 10/0;
}

TEST(EXPTEST, EXPTEST_EXIT)
{
    // 期望以收到信号8退出
    ASSERT_EXIT(test_exit(),testing::KilledBySignal(8),".*");
}</code>

1.2.3.4.5.6.7.8.9.10.11.12.

注意这里的警告是g++编译器检测到除0错误后提供的，并非是运行时的错误。

<code class="language-plain has-numbering hljs" id="code_id_15">❯ g++ test.cpp -o test -lgtest && ./test
test.cpp: In function 'void test_exit()':
test.cpp:11:17: warning: division by zero [-Wdiv-by-zero]
   11 |     int ret = 10/0;
      |               ~~^~
[==========] Running 1 test from 1 test suite.
[----------] Global test environment set-up.
[----------] 1 test from EXPTEST
[ RUN      ] EXPTEST.EXPTEST_EXIT
[       OK ] EXPTEST.EXPTEST_EXIT (0 ms)
[----------] 1 test from EXPTEST (0 ms total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test suite ran. (0 ms total)
[  PASSED  ] 1 test.</code>

1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.

将第三个参数改为一个普通字符串，gtest会进行stderr输出是否包含该字符串的检查；

<code class="language-plain has-numbering hljs" id="code_id_16">void test_exit()
{
    std::cerr << "test exit
";
    int ret = 10/0;
}

TEST(EXPTEST, EXPTEST_EXIT)
{
    // 期望以收到信号退出
    ASSERT_EXIT(test_exit(),testing::KilledBySignal(8),"happy");
}</code>

1.2.3.4.5.6.7.8.9.10.11.

可以看到，单元测试失败的原因是“错误退出但是没有提供期望的error输出”。

<code class="language-plain has-numbering hljs" id="code_id_17">❯ g++ test.cpp -o test -lgtest && ./test
test.cpp: In function 'void test_exit()':
test.cpp:10:17: warning: division by zero [-Wdiv-by-zero]
   10 |     int ret = 10/0;
      |               ~~^~
[==========] Running 1 test from 1 test suite.
[----------] Global test environment set-up.
[----------] 1 test from EXPTEST
[ RUN      ] EXPTEST.EXPTEST_EXIT
test.cpp:16: Failure
Death test: test_exit()
    Result: died but not with expected error.
  Expected: contains regular expression "happy"
Actual msg:
[  DEATH   ] test exit
[  DEATH   ] 

[  FAILED  ] EXPTEST.EXPTEST_EXIT (0 ms)
[----------] 1 test from EXPTEST (0 ms total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test suite ran. (0 ms total)
[  PASSED  ] 0 tests.
[  FAILED  ] 1 test, listed below:
[  FAILED  ] EXPTEST.EXPTEST_EXIT

 1 FAILED TEST</code>

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.

如果在错误输出中包含happy字符串，则正常通过测试。

<code class="language-plain has-numbering hljs" id="code_id_18">void test_exit()
{
    std::cerr << "test exit happy
"; // 包含happy字符串
    int ret = 10/0;
}

TEST(EXPTEST, EXPTEST_EXIT)
{
    // 期望以收到信号退出
    ASSERT_EXIT(test_exit(),testing::KilledBySignal(8),"happy");
}</code>

1.2.3.4.5.6.7.8.9.10.11. 

<code class="language-plain has-numbering hljs" id="code_id_19">[==========] Running 1 test from 1 test suite.
[----------] Global test environment set-up.
[----------] 1 test from EXPTEST
[ RUN      ] EXPTEST.EXPTEST_EXIT
[       OK ] EXPTEST.EXPTEST_EXIT (1 ms)
[----------] 1 test from EXPTEST (1 ms total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test suite ran. (1 ms total)
[  PASSED  ] 1 test.</code>

1.2.3.4.5.6.7.8.9.10.

注意：函数内的assert错误对应的是信号6，如果需要用ASSERT_EXIT来捕捉assert错误，则需要使用testing::KilledBySignal(6)；

4.2 ASSERT_DEATH

ASSERT_DEATH和ASSERT_EXIT宏的作用基本一致，只不过ASSERT_DEATH不需要我们传入期望退出的错误码或信号。此时任意非0错误码退出和任意信号退出都会被视为ASSERT_DEATH的测试成功情况。

<code class="language-plain has-numbering hljs" id="code_id_20">EXPECT_DEATH(statement,matcher);
ASSERT_DEATH(statement,matcher);</code>

1.2.

这里的第二个参数和ASSERT_EXIT的第三个参数一致，可以是一个字符串，也可以是一个regex表达式。

示例代码和测试结果如下：

<code class="language-plain has-numbering hljs" id="code_id_21">#include <gtest/gtest.h>
#include <iostream>
#include <unistd.h>


void test_exit()
{
    std::cerr << "test exit
";
    exit(1);
}

TEST(EXPTEST, EXPTEST_EXIT)
{
    ASSERT_DEATH(test_exit(),".*");
}

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

1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21. 

<code class="language-plain has-numbering hljs" id="code_id_22">❯ g++ test.cpp -o test -lgtest && ./test
[==========] Running 1 test from 1 test suite.
[----------] Global test environment set-up.
[----------] 1 test from EXPTEST
[ RUN      ] EXPTEST.EXPTEST_EXIT
[       OK ] EXPTEST.EXPTEST_EXIT (0 ms)
[----------] 1 test from EXPTEST (0 ms total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test suite ran. (0 ms total)
[  PASSED  ] 1 test.</code>

1.2.3.4.5.6.7.8.9.10.11.

ASSERT_DEATH只有在被测函数没有错误退出，或者以exit(0)退出的时候会出错。因为0号在操作系统中是进程退出的正常情况，非0才是错误信号。

<code class="language-plain has-numbering hljs" id="code_id_23">❯ g++ test.cpp -o test -lgtest && ./test
[==========] Running 1 test from 1 test suite.
[----------] Global test environment set-up.
[----------] 1 test from EXPTEST
[ RUN      ] EXPTEST.EXPTEST_EXIT
test.cpp:15: Failure
Death test: test_exit()
    Result: died but not with expected exit code:
            Exited with exit status 0
Actual msg:
[  DEATH   ] test exit
[  DEATH   ] 

[  FAILED  ] EXPTEST.EXPTEST_EXIT (0 ms)
[----------] 1 test from EXPTEST (0 ms total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test suite ran. (0 ms total)
[  PASSED  ] 0 tests.
[  FAILED  ] 1 test, listed below:
[  FAILED  ] EXPTEST.EXPTEST_EXIT

 1 FAILED TEST</code>

1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23.

注意，抛出异常并没有归结到DEATH和EXIT的判定范围内。

<code class="language-plain has-numbering hljs" id="code_id_24">void test_exit()
{
    std::cerr << "test exit happy
";
    // int ret = 10/0;
    throw std::runtime_error("123");
}

TEST(EXPTEST, EXPTEST_EXIT)
{
    ASSERT_DEATH(test_exit(),"happy");
}</code>

1.2.3.4.5.6.7.8.9.10.11. 

<code class="language-plain has-numbering hljs" id="code_id_25">❯ g++ test.cpp -o test -lgtest && ./test
[==========] Running 1 test from 1 test suite.
[----------] Global test environment set-up.
[----------] 1 test from EXPTEST
[ RUN      ] EXPTEST.EXPTEST_EXIT
test.cpp:16: Failure
Death test: test_exit()
    Result: threw an exception.
 Error msg:
[  DEATH   ] test exit happy
[  DEATH   ] 
[  DEATH   ] test.cpp:16:: Caught std::exception-derived exception escaping the death test statement. Exception message: 123
[  DEATH   ] 

[  FAILED  ] EXPTEST.EXPTEST_EXIT (0 ms)
[----------] 1 test from EXPTEST (0 ms total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test suite ran. (0 ms total)
[  PASSED  ] 0 tests.
[  FAILED  ] 1 test, listed below:
[  FAILED  ] EXPTEST.EXPTEST_EXIT

 1 FAILED TEST</code>

1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23.24.

4.3 ASSERT_DEBUG_DEATH

对于ASSERT_DEBUG_DEATH，官方文档是这么描述的：

In debug mode, behaves the same as EXPECT_DEATH. When not in debug mode (i.e. NDEBUG is defined), just executes statement.

这里补充一下NDEBUG宏的作用，在标准库里面，它会控制assert是否起效果。如果一个程序define了NDEBUG宏（注意必须在引用<assert.h>头文件之前定义），那么assert将什么都不做。

可以看assert.h的源代码，当定义了NDEBUG宏后，assert会调用__ASSERT_VOID_CAST (0)；在C++中这个cast是一个static_cast<void>，在C语言中是一个)void)的强转，反正都是啥都不干。

<code class="language-plain has-numbering hljs" id="code_id_26">#if defined __cplusplus && __GNUC_PREREQ (2,95)
# define __ASSERT_VOID_CAST static_cast<void>
#else
# define __ASSERT_VOID_CAST (void)
#endif

/* void assert (int expression);

   If NDEBUG is defined, do nothing.
   If not, and EXPRESSION is zero, print an error message and abort.  */

#ifdef	NDEBUG

# define assert(expr)		(__ASSERT_VOID_CAST (0))

/* void assert_perror (int errnum);

   If NDEBUG is defined, do nothing.  If not, and ERRNUM is not zero, print an
   error message with the error text for ERRNUM and abort.
   (This is a GNU extension.) */

# ifdef	__USE_GNU
#  define assert_perror(errnum)	(__ASSERT_VOID_CAST (0))
# endif

#else /* Not NDEBUG.  */</code>

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.

下面是一个简单的测试示例，当我们没有定义NDEBUG的时候，ASSERT_DEBUG_DEATH和ASSERT_DEATH做的是相同的操作。

<code class="language-plain has-numbering hljs" id="code_id_27">#include <gtest/gtest.h>
#include <iostream>
#include <unistd.h>


void test_exit()
{
    std::cerr << "test exit happy
";
    exit(1);
}

TEST(EXPTEST, EXPTEST_EXIT)
{
    ASSERT_DEBUG_DEATH(test_exit(),"happy");
}

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

1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21. 

<code class="language-plain has-numbering hljs" id="code_id_28">❯ g++ test.cpp -o test -lgtest && ./test
[==========] Running 1 test from 1 test suite.
[----------] Global test environment set-up.
[----------] 1 test from EXPTEST
[ RUN      ] EXPTEST.EXPTEST_EXIT
[       OK ] EXPTEST.EXPTEST_EXIT (0 ms)
[----------] 1 test from EXPTEST (0 ms total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test suite ran. (0 ms total)
[  PASSED  ] 1 test.</code>

1.2.3.4.5.6.7.8.9.10.11.

如果在文件开头定义了NDEBUG，那么ASSERT_DEBUG_DEATH则只会调用函数，并不会做错误信息的判断，如下所示，我们将函数中的exit删除，gtest也没有报告错误。

<code class="language-plain has-numbering hljs" id="code_id_29">#define NDEBUG 1 // 一定要在开头定义
#include <gtest/gtest.h>
#include <iostream>
#include <unistd.h>


void test_exit()
{
    std::cerr << "test exit happy
";
    // exit(1); // 没有错误退出
}

TEST(EXPTEST, EXPTEST_EXIT)
{
    ASSERT_DEBUG_DEATH(test_exit(),"happy");
}

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

1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.

可以看到，我们的函数并没有退出，但是由于定义了NDEBUG，ASSERT_DEBUG_DEATH宏没有报告错误。（去掉该宏，则会和ASSERT_DEATH一样提示出错）

<code class="language-plain has-numbering hljs" id="code_id_30">❯ g++ test.cpp -o test -lgtest && ./test
[==========] Running 1 test from 1 test suite.
[----------] Global test environment set-up.
[----------] 1 test from EXPTEST
[ RUN      ] EXPTEST.EXPTEST_EXIT
test exit happy
[       OK ] EXPTEST.EXPTEST_EXIT (0 ms)
[----------] 1 test from EXPTEST (0 ms total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test suite ran. (0 ms total)
[  PASSED  ] 1 test.</code>

1.2.3.4.5.6.7.8.9.10.11.12.

4.4 ASSERT_THROW

调用对象应该抛出异常，并判断异常类型是否为期待类型。

<code class="language-plain has-numbering hljs" id="code_id_31">#include <gtest/gtest.h>
#include <iostream>
#include <unistd.h>

void test_throw()
{
    throw std::runtime_error("test");
}

TEST(EXPTEST, EXPTEST_THROW)
{
    ASSERT_THROW(test_throw(),std::runtime_error);
}

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

1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19. 

<code class="language-plain has-numbering hljs" id="code_id_32">❯ g++ test.cpp -o test -lgtest && ./test
[==========] Running 1 test from 1 test suite.
[----------] Global test environment set-up.
[----------] 1 test from EXPTEST
[ RUN      ] EXPTEST.EXPTEST_THROW
[       OK ] EXPTEST.EXPTEST_THROW (0 ms)
[----------] 1 test from EXPTEST (0 ms total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test suite ran. (0 ms total)
[  PASSED  ] 1 test.</code>

1.2.3.4.5.6.7.8.9.10.11.

当抛出的异常类型不一致的时候会出错

<code class="language-plain has-numbering hljs" id="code_id_33">❯ g++ test.cpp -o test -lgtest && ./test
[==========] Running 1 test from 1 test suite.
[----------] Global test environment set-up.
[----------] 1 test from EXPTEST
[ RUN      ] EXPTEST.EXPTEST_THROW
test.cpp:12: Failure
Expected: test_throw() throws an exception of type std::runtime_error.
  Actual: it throws std::length_error with description "123".

[  FAILED  ] EXPTEST.EXPTEST_THROW (0 ms)
[----------] 1 test from EXPTEST (0 ms total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test suite ran. (0 ms total)
[  PASSED  ] 0 tests.
[  FAILED  ] 1 test, listed below:
[  FAILED  ] EXPTEST.EXPTEST_THROW

 1 FAILED TEST</code>

1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.

异常相关的还有两个

ASSERT_ANY_THROW不需要传入第二个参数，只关注目标函数应该抛出异常；ASSERT_NO_THROW也只有一个参数，目标函数不应该抛出异常；

因为它们很简单，这里就不做演示了。

4.5 ASSERT_EQ/NE

相等和不相等的比较。

<code class="language-plain has-numbering hljs" id="code_id_34">#include <gtest/gtest.h>
#include <iostream>
#include <unistd.h>


TEST(EXPTEST, EXPTEST_EQ)
{
    int ret = 10;
    ASSERT_EQ(ret,10);
    ASSERT_NE(ret,29);
}

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

1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17. 

<code class="language-plain has-numbering hljs" id="code_id_35">❯ g++ test.cpp -o test -lgtest && ./test
[==========] Running 1 test from 1 test suite.
[----------] Global test environment set-up.
[----------] 1 test from EXPTEST
[ RUN      ] EXPTEST.EXPTEST_EQ
[       OK ] EXPTEST.EXPTEST_EQ (0 ms)
[----------] 1 test from EXPTEST (0 ms total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test suite ran. (0 ms total)
[  PASSED  ] 1 test.</code>

1.2.3.4.5.6.7.8.9.10.11.

ASSERT_FLOAT_EQ和ASSERT_DOUBLE_EQ是在比较的基础上允许一定的浮点数精度误差值。如果你需要比较两个浮点数，请使用对应的浮点数类型比较宏，而不要直接使用ASSERT_EQ；

4.6 ASSERT_GE/LE

注意，大小写比较都是左和右直接按顺序比较的，比如GE是判断左边是否大于右边（不要搞反顺序了）

<code class="language-plain has-numbering hljs" id="code_id_36">TEST(EXPTEST, EXPTEST_GE)
{
    int ret = 10;
    ASSERT_GE(ret,5);
    ASSERT_LE(ret,29);
}</code>

1.2.3.4.5.6. 

<code class="language-plain has-numbering hljs" id="code_id_37">❯ g++ test.cpp -o test -lgtest && ./test
[==========] Running 1 test from 1 test suite.
[----------] Global test environment set-up.
[----------] 1 test from EXPTEST
[ RUN      ] EXPTEST.EXPTEST_EQ
[       OK ] EXPTEST.EXPTEST_EQ (0 ms)
[----------] 1 test from EXPTEST (0 ms total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test suite ran. (0 ms total)
[  PASSED  ] 1 test.</code>

1.2.3.4.5.6.7.8.9.10.11.

4.7 ASSERT_NEAR

该宏提供了第三个参数，在浮点数比较时允许一定的误差值。官网文档说明是保证val1和val2不超过abs_error的误差边界。

<code class="language-plain has-numbering hljs" id="code_id_38">EXPECT_NEAR(val1,val2,abs_error)
ASSERT_NEAR(val1,val2,abs_error)
// Verifies that the difference between val1 and val2 does not exceed the absolute error bound abs_error.</code>

1.2.3.

下面是一个示例

<code class="language-plain has-numbering hljs" id="code_id_39">#include <gtest/gtest.h>
#include <iostream>
#include <unistd.h>


TEST(EXPTEST, EXPTEST_NEAR)
{
    ASSERT_NEAR(3.14,3.15,0.01);
}

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

1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.

因为两个数字的差距的确在0.01的误差区间，所以可以通过测试。

<code class="language-plain has-numbering hljs" id="code_id_40">❯ g++ test.cpp -o test -lgtest && ./test
[==========] Running 1 test from 1 test suite.
[----------] Global test environment set-up.
[----------] 1 test from EXPTEST
[ RUN      ] EXPTEST.EXPTEST_NEAR
[       OK ] EXPTEST.EXPTEST_NEAR (0 ms)
[----------] 1 test from EXPTEST (0 ms total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test suite ran. (0 ms total)
[  PASSED  ] 1 test.</code>

1.2.3.4.5.6.7.8.9.10.11.

如果将第三个参数的误差改为0.001，则无法通过测试。

<code class="language-plain has-numbering hljs" id="code_id_41">❯ g++ test.cpp -o test -lgtest && ./test
[==========] Running 1 test from 1 test suite.
[----------] Global test environment set-up.
[----------] 1 test from EXPTEST
[ RUN      ] EXPTEST.EXPTEST_NEAR
test.cpp:8: Failure
The difference between 3.14 and 3.15 is 0.0099999999999997868, which exceeds 0.001, where
3.14 evaluates to 3.1400000000000001,
3.15 evaluates to 3.1499999999999999, and
0.001 evaluates to 0.001.

[  FAILED  ] EXPTEST.EXPTEST_NEAR (0 ms)
[----------] 1 test from EXPTEST (0 ms total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test suite ran. (0 ms total)
[  PASSED  ] 0 tests.
[  FAILED  ] 1 test, listed below:
[  FAILED  ] EXPTEST.EXPTEST_NEAR

 1 FAILED TEST</code>

1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.

4.8 ASSERT_STREQ/STRCASEEQ

字符串相等比较，一个不忽略大小写，一个忽略大小写;

注意，这两个宏的入参都是const char*，不能直接传入std::string进行比较。

<code class="language-plain has-numbering hljs" id="code_id_42">#include <gtest/gtest.h>
#include <iostream>
#include <unistd.h>
#include <string>

TEST(EXPTEST, EXPTEST_STR)
{
    std::string str1 = "hello";
    std::string str2 = "hello";
    std::string str3 = "Hello";
    ASSERT_STREQ(str1.c_str(),str2.c_str());
    ASSERT_STRCASEEQ(str1.c_str(),str3.c_str());
}

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

1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19. 

<code class="language-plain has-numbering hljs" id="code_id_43">❯ g++ test.cpp -o test -lgtest && ./test
[==========] Running 1 test from 1 test suite.
[----------] Global test environment set-up.
[----------] 1 test from EXPTEST
[ RUN      ] EXPTEST.EXPTEST_STR
[       OK ] EXPTEST.EXPTEST_STR (0 ms)
[----------] 1 test from EXPTEST (0 ms total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test suite ran. (0 ms total)
[  PASSED  ] 1 test.</code>

1.2.3.4.5.6.7.8.9.10.11.

4.9 ASSERT_TRUE/FALSE

bool值真假的判断。

<code class="language-plain has-numbering hljs" id="code_id_44">#include <gtest/gtest.h>
#include <iostream>
#include <unistd.h>
#include <string>

TEST(EXPTEST, EXPTEST_TRUE)
{
    int a, b;
    a = 1;
    b = 2;
    ASSERT_TRUE(a != b);
    ASSERT_FALSE(a == b);
}

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

1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19. 

<code class="language-plain has-numbering hljs" id="code_id_45">❯ g++ test.cpp -o test -lgtest && ./test
[==========] Running 1 test from 1 test suite.
[----------] Global test environment set-up.
[----------] 1 test from EXPTEST
[ RUN      ] EXPTEST.EXPTEST_TRUE
[       OK ] EXPTEST.EXPTEST_TRUE (0 ms)
[----------] 1 test from EXPTEST (0 ms total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test suite ran. (0 ms total)
[  PASSED  ] 1 test.</code>

1.2.3.4.5.6.7.8.9.10.11.

注意，这两个宏只接受bool值或者int类型，诸如nullptr这类值都是不能被直接接受的（除非你强转）。

如果你需要判断一个函数的结果是否为空指针nullptr，请使用ASSERT_EQ来判断；如果你的函数返回值用了int且用0来标识错误的情况，也建议用ASSERT_EQ来更可读的判断，而不要用ASSERT_TRUE/FALSE； 

<code class="language-plain has-numbering hljs" id="code_id_46">❯ g++ test.cpp -o test -lgtest && ./test
In file included from /usr/local/include/gtest/gtest-printers.h:122,
                 from /usr/local/include/gtest/gtest-matchers.h:49,
                 from /usr/local/include/gtest/internal/gtest-death-test-internal.h:47,
                 from /usr/local/include/gtest/gtest-death-test.h:43,
                 from /usr/local/include/gtest/gtest.h:65,
                 from test.cpp:1:
test.cpp: In member function 'virtual void EXPTEST_EXPTEST_TRUE_Test::TestBody()':
test.cpp:8:5: error: converting to 'bool' from 'std::nullptr_t' requires direct-initialization [-fpermissive]
    8 |     ASSERT_FALSE(nullptr);
      |     ^~~~~~~~~~~~</code>

1.2.3.4.5.6.7.8.9.10.11.

这里也能看出C++中nullptr和C语言中NULL的不同，使用ASSERT_FALSE来判断NULL是能通过编译的，因为它本质只是一个define的数字0，和bool值的本质是一样的。

<code class="language-plain has-numbering hljs" id="code_id_47">ASSERT_FALSE(NULL);</code>

1.

4.10 ADD_FAILURE

添加失败信息的效果示例

<code class="language-plain has-numbering hljs" id="code_id_48">#include <gtest/gtest.h>
#include <iostream>
#include <unistd.h>
#include <string>

TEST(EXPTEST, EXPTEST_TRUE)
{
    int a, b;
    a = 1;
    b = 2;
    if (a!=b)
    {
        ADD_FAILURE();
    }
    // 假设我知道被测函数的目标文件和行号
    ADD_FAILURE_AT("add.hpp",20); 
}

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

1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23.

如果你知道出错的被测函数的文件和所在行数，使用ADD_FAILURE_AT能更好的帮助定位问题。因为ADD_FAILURE只会显示出错单元测试的文件和位置。

<code class="language-plain has-numbering hljs" id="code_id_49">❯ g++ test.cpp -o test -lgtest && ./test
[==========] Running 1 test from 1 test suite.
[----------] Global test environment set-up.
[----------] 1 test from EXPTEST
[ RUN      ] EXPTEST.EXPTEST_TRUE
test.cpp:13: Failure
Failed

add.hpp:20: Failure
Failed

[  FAILED  ] EXPTEST.EXPTEST_TRUE (0 ms)
[----------] 1 test from EXPTEST (0 ms total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test suite ran. (0 ms total)
[  PASSED  ] 0 tests.
[  FAILED  ] 1 test, listed below:
[  FAILED  ] EXPTEST.EXPTEST_TRUE

 1 FAILED TEST</code>

1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.

这里也能看到，ADD_FAILURE后，单元测试会像EXPECT宏一样继续往后运行。

4.11 ASSERT_THAT

和ASSERT_THAT相关的matcher选项在gtest中提供了，注意需要引用gmock头文件

<code class="language-plain has-numbering hljs" id="code_id_50">#include <gmock/gmock.h>

using ::testing::AllOf;
using ::testing::Gt;
using ::testing::Lt;
using ::testing::MatchesRegex;
using ::testing::StartsWith;</code>

1.2.3.4.5.6.7.

更多matcher可以查看官方文档： Matchers

这里还有个小细节，你会发现gtest官网文档中的所有testing命名空间前面都带了一个::，这样不管你在什么自定义的命名空间里面编写gtest的代码，都可以通过::先回到全局命名空间，再访问testing命名空间。即不会和用户自定义空间中的冲突。

另外，如果你需要使用gtest框架，应该避免自己的命名空间和gtest的命名空间重名。

示例代码如下，我们的字符串的确是以he开头的，能通过检查。

<code class="language-plain has-numbering hljs" id="code_id_51">#include <gtest/gtest.h>
#include <gmock/gmock.h>
#include <iostream>
#include <unistd.h>
#include <string>

TEST(EXPTEST, EXPTEST_THAT)
{
    std::string str = "hello";
    ASSERT_THAT(str.c_str(),testing::StartsWith("he"));
}

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

1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17. 

<code class="language-plain has-numbering hljs" id="code_id_52">❯ g++ test.cpp -o test -lgtest && ./test
[==========] Running 1 test from 1 test suite.
[----------] Global test environment set-up.
[----------] 1 test from EXPTEST
[ RUN      ] EXPTEST.EXPTEST_THAT
[       OK ] EXPTEST.EXPTEST_THAT (0 ms)
[----------] 1 test from EXPTEST (0 ms total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test suite ran. (0 ms total)
[  PASSED  ] 1 test.</code>

1.2.3.4.5.6.7.8.9.10.11.

4.12 ASSERT_PRED

谓词测试宏一共有5个，分别接受一个自定义函数和该函数对应的参数，并判断返回值是否为bool值的true。数字就代表函数的参数个数，最多支持5个参数的自定义函数。

<code class="language-plain has-numbering hljs" id="code_id_53">ASSERT_PRED1(pred,val1)
ASSERT_PRED2(pred,val1,val2)
ASSERT_PRED3(pred,val1,val2,val3)
ASSERT_PRED4(pred,val1,val2,val3,val4)
ASSERT_PRED5(pred,val1,val2,val3,val4,val5)</code>

1.2.3.4.5.

我们定义一个测试函数，再把两个参数传入该函数，就能得到一个结果

<code class="language-plain has-numbering hljs" id="code_id_54">#include <gtest/gtest.h>
#include <gmock/gmock.h>
#include <iostream>
#include <unistd.h>
#include <string>

bool is_eq(int a, int b)
{
    return a == b;
}

TEST(EXPTEST, EXPTEST_PRED)
{
    ASSERT_PRED2(is_eq, 1, 2);
    // 等价于 ASSERT_TRUE(is_eq(1,2));
}

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

1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22. 

<code class="language-plain has-numbering hljs" id="code_id_55">❯ g++ test.cpp -o test -lgtest && ./test
[==========] Running 1 test from 1 test suite.
[----------] Global test environment set-up.
[----------] 1 test from EXPTEST
[ RUN      ] EXPTEST.EXPTEST_PRED
test.cpp:14: Failure
is_eq(1, 2) evaluates to false, where
1 evaluates to 1
2 evaluates to 2

[  FAILED  ] EXPTEST.EXPTEST_PRED (0 ms)
[----------] 1 test from EXPTEST (0 ms total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test suite ran. (0 ms total)
[  PASSED  ] 0 tests.
[  FAILED  ] 1 test, listed below:
[  FAILED  ] EXPTEST.EXPTEST_PRED

 1 FAILED TEST</code>

1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.

5.TEST_F

介绍完毕断言宏了，TEST的作用想必大家也明白了，下面对TEST_F给出一个简单的示例。

在上文介绍TEST_F中提到过编写的基本框架应该如下所示

<code class="language-plain has-numbering hljs" id="code_id_56">class MyClassTest : public testing::Test {
  ...
};

TEST_F(MyClassTest, HasPropertyA) { ... }
TEST_F(MyClassTest, HasPropertyB) { ... }</code>

1.2.3.4.5.6.

假设我们需要对MyClass类进行测试，那么MyClassTest类就是对MyClass进行初始化和销毁操作的，每一个TEST_F都是对MyClass中的某个成员变量进行测试。

下面是一个简单的对类的单元测试的示例，目的是确认AddX和AddY的情况符合我们的预期，能正常给成员变量添加值。

<code class="language-plain has-numbering hljs" id="code_id_57">#include <gtest/gtest.h>
#include <gmock/gmock.h>
#include <iostream>
#include <unistd.h>
#include <memory>
#include <string>

class MyClass
{
public:
    MyClass(int x = 0, int y = 0) : _x(x), _y(y) {}

    void AddX(int val)
    {
        _x += val;
    }

    void AddY(int val)
    {
        _y += val;
    }

    int GetX() { return _x; }
    int GetY() { return _y; }

private:
    int _x;
    int _y;
};

class MyClassTest : public testing::Test
{
protected:
    void SetUp()
    {
        std::cout << "set up for MyClass
";
        _mc = std::make_shared<MyClass>();
    }

    void TearDown()
    {
        std::cout << "tear down for MyClass
";
        _mc.reset();
    }

    std::shared_ptr<MyClass> _mc;
};

TEST_F(MyClassTest, MyClassTestAddX)
{
    _mc->AddX(10);
    EXPECT_EQ(_mc->GetX(), 10);
}

TEST_F(MyClassTest, MyClassTestAddY)
{
    _mc->AddY(20);
    EXPECT_EQ(_mc->GetY(), 20);
}

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

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.44.45.46.47.48.49.50.51.52.53.54.55.56.57.58.59.60.61.62.63.64.65.

在代码中，TEST_F体内可以访问MyClassTest的成员变量_mc，并调用它的成员函数。这样就避免了我们在每个单元测试中对一些公用的类进行多次初始化程序编写的操作。

编译运行这个代码，能看到SetUp和TearDown在每次TEST_F之前和之后都会被执行，并非只执行一次！

<code class="language-plain has-numbering hljs" id="code_id_58">❯ g++ test.cpp -o test -lgtest && ./test
[==========] Running 2 tests from 1 test suite.
[----------] Global test environment set-up.
[----------] 2 tests from MyClassTest
[ RUN      ] MyClassTest.MyClassTestAddX
set up for MyClass
tear down for MyClass
[       OK ] MyClassTest.MyClassTestAddX (0 ms)
[ RUN      ] MyClassTest.MyClassTestAddY
set up for MyClass
tear down for MyClass
[       OK ] MyClassTest.MyClassTestAddY (0 ms)
[----------] 2 tests from MyClassTest (0 ms total)

[----------] Global test environment tear-down
[==========] 2 tests from 1 test suite ran. (0 ms total)
[  PASSED  ] 2 tests.</code>

1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.

如果你需要测试一个类的私有成员，可以使用g++的编译命令-fno-access-control直接取消访问限定符

<code class="language-plain has-numbering hljs" id="code_id_59">g++ test.cpp -o test -fno-access-control -lgtest</code>

1.

此时在类外对私有成员和私有函数的直接访问不会出现编译报错。但需要注意的是，你只可以在单元测试中使用该编译命令，在生产环境中不应该这么做！

The end

对于Gtest的宏的介绍到这里就结束了。

google gtest框架中还包含了一个gmock模块，这个模块的主要作用是继承一个父类，重写虚函数，并可以在测试夹具中用EXPECT_CALL自定义重写后函数的返回值和调用次数。在我遇到的实际项目中，这个gmock模块用到的次数很少，因为它的适用范围实在是太窄了。

原创作者: musnow 转载于: https://blog.51cto.com/musnow/11882869

© 版权声明
文章版权归作者所有，未经允许请勿转载。

相关文章

Selenium Cucumber Java 项目教程
头像 油
40
Linux环境搭建
头像 夏末之后
34
发货以后买家申请仅退款，包邮的商品邮费白搭了吗？ – 淘宝天猫
头像 赵禹钧
148
【MC】【插件服】我的世界SMC服务器
头像 樊梵
27
CodeNeRF 使用教程
头像 原漫
52
ShaderGraph.js 使用教程
头像 初
33

暂无评论

您必须登录才能参与评论！
立即登录
暂无评论...

相关文章

Oracle 21c-PL/SQL连接远程数据库的方式
0
PLSQL中文显示乱码
0
openGauss 用于Oracle的外部数据包装器
0
oracle数据恢复—断电导致Oracle数据库出错的数据恢复案例
0
linux Oracle19c安装
0

随机网址

猜你喜欢

XieNiao 血鸟导航，集网址、资源、资讯于一体的定制化导航主题，简约优雅的设计风格，自定义网址的用户功能，自定义主页，欢迎您的体验

服务协议 法律声明 联系我们 版权投诉 友链申请 网站收录

扫码加QQ群血鸟导航

扫码加QQ群
Copyright © 2024 血鸟导航 赣ICP备19014419号  赣公网安备36020002000448号