gtest概念应用及原理

概念

gtest是单元测试库可以测试一个函数，也可以测试一个类。

应用和原理

//被测试类
class MyClass{
    FRIEND_TEST(MyClassTest, private); //test private //为了gtest新增加的一行代码
    void init(string);
    void process(void*,void*);
    void release();
}

#define FRIEND_TEST(test_case_name, test_name) \
    friend class test_case_name##_##test_name##_Test
展开之后： friend class MyClassTest_private_test

##############################################
gtest测试代码：

class MyClassTest : public ::testing::Test
{
protected:
    MyClass *_myclass;
    virtual void SetUp()
    {
        cout << __FUNCTION__ << " Enter";
        _myclass = new MyClass("a", "b");
    }
    virtual void TearDown()
    {
        cout << __FUNCTION__ << " Enter";
        delete _myclass;
    }
};
TEST_F(MyClassTest, private)
{
    //_myclass初始化之后，执行3次，销毁
    _myclass->init(R"(...)");
    for (int i = 0; i < 3; i++)
    {
        _myclass->process(NULL, NULL);
    }
    _myclass->release();
}

原理分析：

#define TEST_F(test_fixture, test_name) \
    GTEST_TEST_(test_fixture, test_name, test_fixture, ::testing::internal::GetTypeId())


#define GTEST_TEST_CLASS_NAME_(test_suite_name, test_name) \
    test_suite_name##_##test_name##_Test


#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)                      \
        () {}                                                                   \
                                                                                \
    private:                                                                    \
        virtual void TestBody();                                                \
        static ::testing::TestInfo *const test_info_ GTEST_ATTRIBUTE_UNUSED_;   \
        GTEST_DISALLOW_COPY_AND_ASSIGN_(GTEST_TEST_CLASS_NAME_(test_suite_name, \
                                                               test_name));     \
    };
#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type) \
    type(type const &) = delete;              \
    GTEST_DISALLOW_ASSIGN_(type)
#define GTEST_DISALLOW_ASSIGN_(type) \
    void operator=(type const &) = delete
展开之后：
static_assert(sizeof("MyClassTest")) > 1,                
                "MyClassTest must not be empty");                         
static_assert(sizeof("private")) > 1,                              
                "private must not be empty");    


class MyClassTest_private_test
    : public MyClassTest
{                                                                                 
public:
    MyClassTest_private_test() {}                                       


private:
    virtual void TestBody();
    static ::testing::TestInfo *const test_info_ __attribute__((unused));
    MyClassTest_private_test(MyClassTest_private_test const &) = delete;
    void operator=(type const &) = delete;
};

结论

1.通过上面展开分析FRIEND_TEST(MyClassTest, private);和TEST_F(MyClassTest, private)
两对名字相同友缘类才能真正生效。

2.单元测试gtest内置一个main函数，需要搭建main需要的开发环境

3.gtest测试一个类，原理是使用了friend class，这样可以访问private

4.如果没有gtest，被测试类增加一个新建一个类并增加friend class权限，主流程可以执行到这个类，依然可以达到gtest的效果。

5.不知道其中的原理，只是按固定流程走，就是计算机迷信，迷信1和迷信2没有区别。