googleTest 源码主线框架性分析—

TDD，测试驱动开发，英文全称Test-Driven Development，简称TDD，是一种不同于传统软件开发流程的新型的开发方法。它要求在编写某个功能的代码之前先编写测试代码，然后只编写使测试通过的功能代码，通过测试来推动整个开发的进行。这有助于编写简洁可用和高质量的代码，并加速开发过程。

简言之TDD是通过设计 Test 来完成软件设计的一种高效可行的软件开发模式。

为何更丰富地达成测试的目的，googletes是绕不过去的，本文备忘主要关注 googletest 主体的分析过程和结论，即，googleTest框架中是如何通过相关的测试宏的，实现测试的目的。

TEST TEST_F TEST_P 等等

1，googleTest 环境与简单示例

1.1 下载 googletest 并编译

下载：

$ git clone https://github.com/google/googletest.git
$ git checkout release-1.10.0

编译：

$ mkdir build
$ cd build/
$ export CXXFLAGS="-Wno-error=maybe-uninitialized"
$ cmake ..
$ make -j
$ ls lib/

默认为 release，若debug版本则须：

$ cmake .. -DCMAKE_BUILD_TYPE=Debug

成果：

1.2 示例1 验证函数 add

源码

#include <iostream>
#include "gtest/gtest.h"

int add_int_int(int a, int b){
	return a+b;
}

TEST(SumFuncTest, twoNumbers){
	EXPECT_EQ(add_int_int(3,4),7);
	EXPECT_EQ(27, add_int_int(9, 18));
}

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

运行：

1.3 示例 2

#include <gtest/gtest.h>

int Foo(int a, int b)
{
    if (a == 0 || b == 0)
    {
        throw "don't do that";
    }

    int c = a % b;

    if (c == 0)
        return b;

    return Foo(b, c);
}


TEST(FooTest, HandleNoneZeroInput)
{
    EXPECT_EQ(2, Foo(4, 10));
    EXPECT_EQ(6, Foo(30, 18));
}

g++ foo.cpp -I ../../googletest/googletest/include -L ../../googletest/build_dbg/lib -lgtest -lgtest_main

编译运行：

1.4 示例3

源码：

#include <iostream>
#include "gtest/gtest.h"


// add_util.cc

float add_from_left(float a, float b, float c, float d,	float e)
{
	float sum = 0.0;
	sum += c;
	sum += a;
	sum += b;
	//sum += c;
	sum += d;
	sum += e;
/*
	sum += a;
	sum += b;
	sum += c;
	sum += d;
	sum += e;
*/
	printf("add_from_left: sum = %f\n", sum);
	return sum;
}


float add_from_right(float a, float b, float c,	float d, float e)
{
	float sum = 0.0;

	sum += e;
	sum += d;
	sum += c;
	sum += b;
	sum += a;

	printf("add_from_right: sum = %f\n", sum);
	return sum;
}

int sum(int a, int b){
	return a+b;
}




TEST(AddFuncTest, floatVSfloat) {
	printf("AddFuncTest: float  sum = %f\n", 1.238f + 3.7f + 0.000353265f + 7898.3f + 12.23209f);
	printf("AddFuncTest: double sum = %f\n", 12.23209 + 7898.3 + 0.000353265 + 3.7 + 1.238);
	EXPECT_EQ(1.238f + 3.7f + 0.000353265f + 7898.3f + 12.23209f, add_from_left(1.238, 3.7, 0.000353265, 7898.3, 12.23209));
	EXPECT_EQ(1.238f + 3.7f + 0.000353265f + 7898.3f + 12.23209f, add_from_right(1.238, 3.7, 0.000353265, 7898.3, 12.23209));
//
}

TEST(AddFuncTest, doubleVSfloat) {
	printf("AddFuncTest: float  sum = %f\n", 1.238f + 3.7f + 0.000353265f + 7898.3f + 12.23209f);
	printf("AddFuncTest: double sum = %f\n", 12.23209 + 7898.3 + 0.000353265 + 3.7 + 1.238);
	EXPECT_EQ(1.238f + 3.7f + 0.000353265f + 7898.3f + 12.23209f, add_from_left(1.238, 3.7, 0.000353265, 7898.3, 12.23209));
	EXPECT_EQ(1.238 + 3.7 + 0.000353265 + 7898.3 + 12.23209, add_from_right(1.238, 3.7, 0.000353265, 7898.3, 12.23209));
//
}

TEST(SumFuncTest, twoNumbers){
	EXPECT_EQ(sum(3,4),7);
	EXPECT_EQ(27, sum(9, 18));
}

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

Makefile

EXE := hello_gtest_ex hello_gtest_add_int_int
all: $(EXE)

%: %.cpp
	g++ -O0 -fno-toplevel-reorder $< -o $@ $(INC) $(LD_FLAGS)

INC := -I../googletest/googletest/include/
LD_FLAGS := -L../googletest/build/lib/ -lgtest -lgtest_main


.PHONY: clean
clean:
	-rm -rf $(EXE)

2，示例与源码分析

使用最简单的测试示例，聚焦googletest本身的代码逻辑

观察点，main 函数如何调用到 TEST(...){...} 这种结构中的代码

两种方式互相印证：

方式1，通过编译器的预编译指令 g++ -E ... 生成展开代码;

方式2，通过跟踪源代码，来份些TEST等的展开结果

2.1 TEST

示例代码如上：

simple_gtest.cpp


#include "gtest/gtest.h"

int add_int_int(int a, int b){
	return a+b;
}

TEST(SumFuncTest, twoNumbers){
	EXPECT_EQ(add_int_int(3,4),7);
}

方式1:

g++ -E simple_gtest.cpp -o simple_gtest.i

展开后，simple_gtest.i文件有8W多行，但是其中对我们理解有意义的也就最尾巴上的几行：


int add_int_int(int a, int b){
 return a+b;
}

static_assert(sizeof("SumFuncTest") > 1, "test_suite_name must not be empty"); 
static_assert(sizeof("twoNumbers") > 1, "test_name must not be empty"); 

class SumFuncTest_twoNumbers_Test : public ::testing::Test { 
public: 
        SumFuncTest_twoNumbers_Test() {} 
private:
        virtual void TestBody(); 
        static ::testing::TestInfo* const test_info_ __attribute__ ((unused)); 
        SumFuncTest_twoNumbers_Test(SumFuncTest_twoNumbers_Test const &) = delete; void operator=(SumFuncTest_twoNumbers_Test const &) = delete; 
}; 

::testing::TestInfo* const SumFuncTest_twoNumbers_Test::test_info_ = 
                ::testing::internal::MakeAndRegisterTestInfo( "SumFuncTest", "twoNumbers", nullptr, nullptr, ::testing::internal::CodeLocation("simple_gtest.cpp", 8), (::testing::internal::GetTestTypeId()), ::testing::internal::SuiteApiResolver< ::testing::Test>::GetSetUpCaseOrSuite("simple_gtest.cpp", 8), ::testing::internal::SuiteApiResolver< ::testing::Test>::GetTearDownCaseOrSuite("simple_gtest.cpp", 8), new ::testing::internal::TestFactoryImpl<SumFuncTest_twoNumbers_Test>); 

void SumFuncTest_twoNumbers_Test::TestBody()
{
        switch (0) 
          case 0: 
          default: 
              if (const ::testing::AssertionResult gtest_ar = (::testing::internal::EqHelper::Compare("add_int_int(3,4)", "7", add_int_int(3,4), 7))) 
                  ; 
              else 
                  ::testing::internal::AssertHelper(::testing::TestPartResult::kNonFatalFailure, "simple_gtest.cpp", 9, gtest_ar.failure_message()) = ::testing::Message();
}

分析这段代码会发现，

TEST被展开成为了一个 class SumFuncTest_twoNumbers_Test

它有一个成员函数 TestBody(){....}

观察上述代码中最后一个函数体：void SumFuncTest_twoNumbers_Test::TestBody()

其中出现了被测试的函数等。

这说明，这个函数体中的代码才是是被测试内容，而其外围都是框架。

框架部分只需要把这中类的一个实例添加到某个链表中，然后依次迭代执行每个类的 TestBody成员函数，既可以完成测试任务。

本例中的 class 如下：

通过方法2.来验证一下展开的结果：

第一部分，class 宏

关联TEST宏，我们可以找到如下内容：


#define TEST(test_suite_name, test_name) GTEST_TEST(test_suite_name, test_name)


#define GTEST_TEST(test_suite_name, test_name)             \
  GTEST_TEST_(test_suite_name, test_name, ::testing::Test, \
              ::testing::internal::GetTestTypeId())




// Expands to the name of the class that implements the given test.
#define GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) \
  test_suite_name##_##test_name##_Test

// Helper macro for defining tests.
#define GTEST_TEST_(test_suite_name, test_name, parent_class, parent_id)       \
  static_assert(sizeof(GTEST_STRINGIFY_(test_suite_name)) > 1,                 \
                "test_suite_name must not be empty");                          \
  static_assert(sizeof(GTEST_STRINGIFY_(test_name)) > 1,                       \
                "test_name must not be empty");                                \
  class GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)                     \
      : public parent_class {                                                  \
   public:                                                                     \
    GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() = default;            \
    ~GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)() override = default;  \
    GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)                         \
    (const GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) &) = delete;     \
    GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) & operator=(            \
        const GTEST_TEST_CLASS_NAME_(test_suite_name,                          \
                                     test_name) &) = delete; /* NOLINT */      \
    GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)                         \
    (GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) &&) noexcept = delete; \
    GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) & operator=(            \
        GTEST_TEST_CLASS_NAME_(test_suite_name,                                \
                               test_name) &&) noexcept = delete; /* NOLINT */  \
                                                                               \
   private:                                                                    \
    void TestBody() override;                                                  \
    static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_;      \
  };                                                                           \
                                                                               \
  ::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_suite_name,           \
                                                    test_name)::test_info_ =   \
      ::testing::internal::MakeAndRegisterTestInfo(                            \
          #test_suite_name, #test_name, nullptr, nullptr,                      \
          ::testing::internal::CodeLocation(__FILE__, __LINE__), (parent_id),  \
          ::testing::internal::SuiteApiResolver<                               \
              parent_class>::GetSetUpCaseOrSuite(__FILE__, __LINE__),          \
          ::testing::internal::SuiteApiResolver<                               \
              parent_class>::GetTearDownCaseOrSuite(__FILE__, __LINE__),       \
          new ::testing::internal::TestFactoryImpl<GTEST_TEST_CLASS_NAME_(     \
              test_suite_name, test_name)>);                                   \
  void GTEST_TEST_CLASS_NAME_(test_suite_name, test_name)::TestBody()

其中的如下两行：

class GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) \

: public parent_class { \

TEST 的宏充分展开后，会根据TEST(X,Y) 括号中的X、Y字串定义一个完整的类，并且包含成员函数:
TestBody()

但是展开的内容中，没有这个函数的函数体。

这个函数体正好就是TEST(X,Y){Z} 中，{Z}的这个部分，即，

TestBody(){Z}

只需要在整个测试系统中，讲上面展开生成的class的一个实例，insert进一个链表中，并依次迭代执行链表的每一对象的成员函数 TestBody(){Z}，即可达到测试目的。

第二部分，函数体中的宏

关于 EXPECT_EQ，我们会发现如下定义：

#define EXPECT_EQ(val1, val2) \
  EXPECT_PRED_FORMAT2(::testing::internal::EqHelper::Compare, val1, val2)

而其中的 EXPECT_PRED_FORMAT2 又被展开为如下：

// Binary predicate assertion macros.
#define EXPECT_PRED_FORMAT2(pred_format, v1, v2) \
  GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_NONFATAL_FAILURE_)

又 GTEST_PRED_FORMAT2_ 被定义为：

#define GTEST_PRED_FORMAT2_(pred_format, v1, v2, on_failure) \
  GTEST_ASSERT_(pred_format(#v1, #v2, v1, v2), on_failure)

而且其中的 GTEST_ASSERT_ 被展开为：

#define GTEST_ASSERT_(expression, on_failure)                   \
  GTEST_AMBIGUOUS_ELSE_BLOCKER_                                 \
  if (const ::testing::AssertionResult gtest_ar = (expression)) \
    ;                                                           \
  else                                                          \
    on_failure(gtest_ar.failure_message())

其中 GTEST_AMBIGUOUS_ELSE_BLOCKER_ 展开为：

#define GTEST_AMBIGUOUS_ELSE_BLOCKER_ \
  switch (0)                          \
  case 0:                             \
  default:  // NOLINT

于是得到函数体为：

总之，只需要调用这个 TestBody() 函数，即可完成测试任务。

2.2 TEST_F

2.2.1 小示例编译与运行

保持关于 TEST 宏分析的记忆，我们以一个简单的示例来分析 TEST_F 宏，

#include <gtest/gtest.h>

class SampleTestWithFixture : public ::testing::Test {
protected:
  void SetUp() override {
    a_ = 1;
    b_ = 2;
  }
  int a_;
  int b_;
};

TEST_F(SampleTestWithFixture, Case2) {
  a_ = 3;
  EXPECT_EQ(a_ + b_, 5);
}

Makefile:

EXE := hello_gtest_f
all: $(EXE)

%: %.cpp
	g++ -g -fno-toplevel-reorder $< -o $@ $(INC) $(LD_FLAGS)


# g++ -E hello_gtest_f.cpp  -I ../googletest/googletest/include/ -o hello_gtest_f.i
#g++ -g -fno-toplevel-reorder $< -o $@ $(INC) $(LD_FLAGS)

INC := -I../../googletest/googletest/include/
LD_FLAGS := -L../../googletest/build_dbg/lib/ -lgtest -lgtest_main


.PHONY: clean
clean:
	-rm -rf $(EXE)

编译，确保能够正确运行：

$ make

$ ./hello_gtest_f

2.2.2 TEST_F 宏展开分析

$ g++ -E hello_gtest_f.cpp  -I ../googletest/googletest/include/ -o hello_gtest_f.i

生成的预处理后的文件 hello_gtest_f.i 主要内容还是在文件的尾巴上，摘录调整格式如下：

class SampleTestWithFixture : public ::testing::Test {
protected:
  void SetUp() override {
    a_ = 1;
    b_ = 2;
  }
  int a_;
  int b_;
};

static_assert(sizeof("SampleTestWithFixture") > 1, "test_suite_name must not be empty");
static_assert(sizeof("Case2") > 1, "test_name must not be empty");

class SampleTestWithFixture_Case2_Test : public SampleTestWithFixture{
public:
  SampleTestWithFixture_Case2_Test() = default;
  ~SampleTestWithFixture_Case2_Test() override = default;
  SampleTestWithFixture_Case2_Test(const SampleTestWithFixture_Case2_Test&) = delete;
  SampleTestWithFixture_Case2_Test& operator=( const SampleTestWithFixture_Case2_Test&) = delete;
  SampleTestWithFixture_Case2_Test(SampleTestWithFixture_Case2_Test &&) noexcept = delete;
  SampleTestWithFixture_Case2_Test& operator=(SampleTestWithFixture_Case2_Test &&) noexcept = delete;

  private: void TestBody() override;
  static ::testing::TestInfo* const test_info_ __attribute__((unused));
};

::testing::TestInfo* const SampleTestWithFixture_Case2_Test::test_info_
    =::testing::internal::MakeAndRegisterTestInfo("SampleTestWithFixture",
                                                  "Case2",
                                                  nullptr,
                                                  nullptr,
                                                  ::testing::internal::CodeLocation("hello_gtest_f.cpp", 27),
                                                  (::testing::internal::GetTypeId<SampleTestWithFixture>()),
                                                  ::testing::internal::SuiteApiResolver< SampleTestWithFixture>::GetSetUpCaseOrSuite("hello_gtest_f.cpp", 27),
                                                  ::testing::internal::SuiteApiResolver< SampleTestWithFixture>::GetTearDownCaseOrSuite("hello_gtest_f.cpp", 27),
                                                  new ::testing::internal::TestFactoryImpl<SampleTestWithFixture_Case2_Test>);

void SampleTestWithFixture_Case2_Test::TestBody()
{
  a_ = 3;
  switch (0)
    case 0:
    default:
      if (const ::testing::AssertionResult gtest_ar = (::testing::internal::EqHelper::Compare( "a_ + b_" ,  "5" ,  a_ + b_ ,  5 )))
        ;
      else
        ::testing::internal::AssertHelper(::testing::TestPartResult::kNonFatalFailure, "hello_gtest_f.cpp", 29, gtest_ar.failure_message())
            = ::testing::Message();
}

跟 TEST 宏的展开类似，组合 TEST_F(X,Y) 的两个参数，构成一个新的类

class X_Y_Test :public SampleTestWithFixture{

...

... TestBody()

}

宏展开的新类中也有一个成员函数 TestBody()；

其中 SampleTestWithFixture 是自己定义的类，会被 X_Y_Test 类共有继承走。

而 TEST_F(...){body} 的类似函数体的部分 {body}，也同样被安排成为了 TestBody函数的函数体。

接下来，gtest框架会通过成员 X_Y_Test::test_info_ 的静态赋值过程，将本测试用例挂进系统的代运行链表，届时依次迭代调用 X_Y_Test::TestBody(); 实现测试感兴趣代码的目的。

2.2.3 总结 TEST_F

TEST_F的意图：

TEST_F的目的是为了把关系密切的测试问题汇总到一个class中来进行测试，可以共用同一个类的对象的上下文成员数据。

TEST_F 中，成员函数的执行顺序：

那么，成员函数 Setup( ) 在什么时候执行呢？

先说答案：

1 X_Y_Test() 构造函数；//c++ 语法

2 Setup(); //数据预备，资源申请

3 TestBody(); //测试部分

4 TearDown(); //资源释放

5 X_Y_Test() 析构函数；//c++ 语法

改造刚才的示例：

#include <gtest/gtest.h>

class SampleTestWithFixture : public ::testing::Test {
public:
SampleTestWithFixture(){std::cout<<"construct_STWF"<<std::endl;}
~SampleTestWithFixture(){std::cout<<"destruct_STWF"<<std::endl;}
protected:
  void SetUp() override {
    std::cout <<"Hello setupupup()000"<<std::endl;
    a_ = 1;
    b_ = 2;
    std::cout <<"Hello setupupup()111"<<std::endl;
  }
  void TearDown() override {
    std::cout <<"Hello teardownnn()000"<<std::endl;
    a_ = 4;
    b_ = 5;
    std::cout <<"Hello teardownnn()111"<<std::endl;
  }
  int a_;
  int b_;
};

TEST_F(SampleTestWithFixture, Case2) {
  std::cout <<"test_f Casess222"<<std::endl;
  a_ = 3;
  EXPECT_EQ(a_ + b_, 5);
}

编译运行：

TEST_F函数体中的部分的一些宏，跟TEST中的一样，展开成为一些比较语句。

2.3 TEST_P

2.3.1 可运行示例

#include "gtest/gtest.h"

namespace TTT
{
namespace testing
{
int g_env_switch = 0;

class BasicTestFixture : public ::testing::TestWithParam<int>
{
public:
    BasicTestFixture() {}
    void SetUp()
    {
        g_env_switch = GetParam();
        std::cout<<"BTF_SetUp() ges="<<g_env_switch<<std::endl;
    }

    void TearDown(){}
};


#define OK 0
#define FAIL 1

int envCheckFunc(void)
{
    if(g_env_switch > 0) {
        return OK;
    }else {
        return FAIL;
    }
}

TEST_P(BasicTestFixture, BasicTest)
{
    ASSERT_EQ(envCheckFunc(), OK);
}

INSTANTIATE_TEST_SUITE_P(configSwitch, BasicTestFixture, ::testing::Values(1, 0));
//INSTANTIATE_TEST_SUITE_P(failSwitch, BasicTestFixture, ::testing::Values(2, 3));

}
}

Makefile：

EXE := hello_gtest_p

all: $(EXE)

%: %.cpp
	g++ -g -fno-toplevel-reorder $< -o $@ $(INC) $(LD_FLAGS)


# g++ -E hello_gtest_p.cpp  -I ../googletest/googletest/include/ -o hello_gtest_p.i
#g++ -g -fno-toplevel-reorder $< -o $@ $(INC) $(LD_FLAGS)

INC := -I../../googletest/googletest/include/
LD_FLAGS := -L../../googletest/build_dbg/lib/ -lgtest -lgtest_main


.PHONY: clean
clean:
	-rm -rf $(EXE)

编译执行：

因为故意藏了一个逻辑错误，所以第二个参数时，会测试失败：

2.3.2 无实例化宏的预编译

注释掉程序中的所有 INSTANTIATE_TEST_SUITE_P 的行，不厌其烦地再贴一次：

#include "gtest/gtest.h"

namespace TTT
{
namespace testing
{
int g_env_switch = 0;

class BasicTestFixture : public ::testing::TestWithParam<int>
{
public:
    BasicTestFixture() {}
    void SetUp()
    {
        g_env_switch = GetParam();
        std::cout<<"BTF_SetUp() ges="<<g_env_switch<<std::endl;
    }

    void TearDown(){}
};


#define OK 0
#define FAIL 1

int envCheckFunc(void)
{
    if(g_env_switch > 0) {
        return OK;
    }else {
        return FAIL;
    }
}

TEST_P(BasicTestFixture, BasicTest)
{
    ASSERT_EQ(envCheckFunc(), OK);
}

//INSTANTIATE_TEST_SUITE_P(configSwitch, BasicTestFixture, ::testing::Values(1, 0));
//INSTANTIATE_TEST_SUITE_P(failSwitch, BasicTestFixture, ::testing::Values(2, 3));

}
}

g++ -E hello_gtest_p.cpp -I ../googletest/googletest/include/ -o hello_gtest_p.i

这时候预编译后生成的代码如下：

namespace TTT
{
namespace testing
{
int g_env_switch = 0;

class BasicTestFixture : public ::testing::TestWithParam<int>
{
public:
    BasicTestFixture() {}
    void SetUp()
    {
        g_env_switch = GetParam();
        std::cout<<"BTF_SetUp() ges="<<g_env_switch<<std::endl;
    }

    void TearDown(){}
};


int envCheckFunc(void)
{
    if(g_env_switch > 0) {
        return 0;
    }else {
        return 1;
    }
}


class BasicTestFixture_BasicTest_Test : public BasicTestFixture, private ::testing::internal::GTestNonCopyable {
public:
  BasicTestFixture_BasicTest_Test() {}
  void TestBody() override;
private:
  static int AddToRegistry()
  {
    ::testing::UnitTest::GetInstance()
        ->parameterized_test_registry()
            .GetTestSuitePatternHolder<BasicTestFixture>( "BasicTestFixture", ::testing::internal::CodeLocation("hello_gtest_p.cpp", 35))
                ->AddTestPattern( "BasicTestFixture",
                                  "BasicTest",
                                  new ::testing::internal::TestMetaFactory<BasicTestFixture_BasicTest_Test>(),
                                  ::testing::internal::CodeLocation("hello_gtest_p.cpp", 35));
    return 0;
  }

  static int gtest_registering_dummy_ __attribute__((unused));
};

int BasicTestFixture_BasicTest_Test::gtest_registering_dummy_ = BasicTestFixture_BasicTest_Test::AddToRegistry();

void BasicTestFixture_BasicTest_Test::TestBody()
{

   switch (0)
    case 0:
    default:
      if (const ::testing::AssertionResult gtest_ar = (::testing::internal::EqHelper::Compare("envCheckFunc()", "0", envCheckFunc(), 0)))
        ;
      else
        return ::testing::internal::AssertHelper(::testing::TestPartResult::kFatalFailure, "hello_gtest_p.cpp", 37, gtest_ar.failure_message()) = ::testing::Message();
}

没有实例化宏的代码，展开到被测试类的 TestBody()函数后就停止了，如上代码中最后一个函数的定义。

2.3.3 有实例化宏的预编译

多了这两句：

INSTANTIATE_TEST_SUITE_P(configSwitch, BasicTestFixture, ::testing::Values(1, 0));

INSTANTIATE_TEST_SUITE_P(failSwitch, BasicTestFixture, ::testing::Values(2, 3));


namespace TTT
{
namespace testing
{
int g_env_switch = 0;

class BasicTestFixture : public ::testing::TestWithParam<int>
{
public:
    BasicTestFixture() {}
    void SetUp()
    {
        g_env_switch = GetParam();
        std::cout<<"BTF_SetUp() ges="<<g_env_switch<<std::endl;
    }

    void TearDown(){}
};



int envCheckFunc(void)
{
    if(g_env_switch > 0) {
        return 0;
    }else {
        return 1;
    }
}


class BasicTestFixture_BasicTest_Test : public BasicTestFixture, private ::testing::internal::GTestNonCopyable {
public:
  BasicTestFixture_BasicTest_Test() {}
  void TestBody() override;

private:
  static int AddToRegistry()
  {
    ::testing::UnitTest::GetInstance()
      ->parameterized_test_registry()
        .GetTestSuitePatternHolder<BasicTestFixture>( "BasicTestFixture", ::testing::internal::CodeLocation("hello_gtest_p.cpp", 35))
          ->AddTestPattern( "BasicTestFixture",
                            "BasicTest",
                            new ::testing::internal::TestMetaFactory<BasicTestFixture_BasicTest_Test>(),
                            ::testing::internal::CodeLocation("hello_gtest_p.cpp",
                            35));
    return 0;
  }

  static int gtest_registering_dummy_ __attribute__((unused));
};

int BasicTestFixture_BasicTest_Test::gtest_registering_dummy_ = BasicTestFixture_BasicTest_Test::AddToRegistry();
void BasicTestFixture_BasicTest_Test::TestBody()
{
  switch (0)
    case 0:
    default:
      if (const ::testing::AssertionResult gtest_ar = (::testing::internal::EqHelper::Compare( "envCheckFunc()", "0", envCheckFunc(), 0)))
        ;
      else
        return ::testing::internal::AssertHelper(::testing::TestPartResult::kFatalFailure, "hello_gtest_p.cpp", 37, gtest_ar.failure_message()) = ::testing::Message();
}
//TEST_P(X, Y, ...){}
// 跟 TEST_F的展开比较接近，同样是将 TEST_P(){...} 的{...} 部分，作为TestBody的函数体；
// 但，一个重要不懂的地方在于，TEST_P 展开为被测试模式或模版，真正注册近被执行队列，是INSTANTIATE_TEST_SUITE_P的工作。

//INSTANTIATE_TEST_SUITE_P(X, Y, ...)的展开位三个函数
//参数容器函数：gtest_XY_EvaluGenerator_    测试参数值；
//被测试类函数：gtest_XY_EvalGenerateName_  测试参数类型；
//测试类压栈函数：gtest_XY_dummy_           将测试类实例化后 push进带测试队列中，通过调用 AddTestSuiteInstantiation


//展开，INSTANTIATE_TEST_SUITE_P(configSwitch, BasicTestFixture, ::testing::Values(1, 0));

static ::testing::internal::ParamGenerator<BasicTestFixture::ParamType> gtest_configSwitchBasicTestFixture_EvalGenerator_()
{
  return::testing::Values(1, 0);
}

static ::std::string gtest_configSwitchBasicTestFixture_EvalGenerateName_( const ::testing::TestParamInfo<BasicTestFixture::ParamType>& info)
{
  if (::testing::internal::AlwaysFalse()) {
    ::testing::internal::TestNotEmpty(::testing::internal::DefaultParamName<BasicTestFixture::ParamType>);
    auto t = std::make_tuple(::testing::Values(1, 0));
    static_assert(std::tuple_size<decltype(t)>::value <= 2, "Too Many Args!");
  }

  return ((::testing::internal::DefaultParamName<BasicTestFixture::ParamType>))(info);
}

static int gtest_configSwitchBasicTestFixture_dummy_ __attribute__((unused))
  = ::testing::UnitTest::GetInstance()
    ->parameterized_test_registry()
      .GetTestSuitePatternHolder<BasicTestFixture>("BasicTestFixture", ::testing::internal::CodeLocation("hello_gtest_p.cpp", 40))
        ->AddTestSuiteInstantiation("configSwitch",
                                    &gtest_configSwitchBasicTestFixture_EvalGenerator_,
                                    &gtest_configSwitchBasicTestFixture_EvalGenerateName_,
                                    "hello_gtest_p.cpp",
                                    40);




//展开，INSTANTIATE_TEST_SUITE_P(failSwitch, BasicTestFixture, ::testing::Values(2, 3));

static ::testing::internal::ParamGenerator<BasicTestFixture::ParamType> gtest_failSwitchBasicTestFixture_EvalGenerator_()
{
  return::testing::Values(2, 3);
}

static ::std::string gtest_failSwitchBasicTestFixture_EvalGenerateName_( const ::testing::TestParamInfo<BasicTestFixture::ParamType>& info)
{
  if (::testing::internal::AlwaysFalse()) {
    ::testing::internal::TestNotEmpty(::testing::internal::DefaultParamName<BasicTestFixture::ParamType>);
    auto t = std::make_tuple(::testing::Values(2, 3));
    static_assert(std::tuple_size<decltype(t)>::value <= 2, "Too Many Args!");
  }

  return ((::testing::internal::DefaultParamName<BasicTestFixture::ParamType>))(info);
}

static int gtest_failSwitchBasicTestFixture_dummy_ __attribute__((unused))
  = ::testing::UnitTest::GetInstance()
    ->parameterized_test_registry()
      .GetTestSuitePatternHolder<BasicTestFixture>("BasicTestFixture", ::testing::internal::CodeLocation("hello_gtest_p.cpp", 41))
        ->AddTestSuiteInstantiation("failSwitch",
                                    &gtest_failSwitchBasicTestFixture_EvalGenerator_,
                                    &gtest_failSwitchBasicTestFixture_EvalGenerateName_,
                                    "hello_gtest_p.cpp",
                                    41);

}
}

2.3.4 分析 TEST_P 和

TEST_P(X, Y, ...){...}的展开跟 TEST_F的展开比较接近，继承用户自定义类后，定义一个新类，含有成员函数 TestBody，同样是将 TEST_P(){...} 的{...} 部分，作为TestBody的函数体；

但，一个重要不同的地方在于，TEST_P 展开为被测试模式或模版，真正注册近被执行队列，是INSTANTIATE_TEST_SUITE_P的工作。

INSTANTIATE_TEST_SUITE_P(X, Y, ...)的展开位三个函数

1，参数容器函数：gtest_XY_EvaluGenerator_ 测试参数值；

2，被测试类函数：gtest_XY_EvalGenerateName_ 测试参数类型；

3，测试类压栈函数：gtest_XY_dummy_ 将测试类实例化后 push进带测试队列中，通过调用 AddTestSuiteInstantiation，压栈入队，等待main函数依次迭代调用各个类实例的 TestBody()成员函数，完成测试任务。

而其中的SetUp(), TearDown()等成员函数的调用，跟TEST_F的调用时机相同。

3. 总结

掌握 googletest的使用，
首先需要理解，TESTXXX(){...}结构中，{...}会被展开为一个类的成员函数 TestBody(){...} 的函数体。
其次，掌握Setup,TearDown的调用时机；
然后，对各种判别宏有一定掌握，比如 EXPECT_EQ；
最后，掌握 TEST_P de 参数的各种形式的使用方式