^-^
后端技术_测试框架gtest以及内存泄漏检测
最近更新：2024-09-23   |   字数总计：1.8k   |   阅读估时：9分钟   |   阅读量：次
  1. unittest框架搭建
  2. google test测试层次关系
    1. EXPECT_* 与 ASSERT_*的区别
    2. 使用
    3. 函数测试
    4. 类对象测试
    5. 需要测试的数据类型
    6. 测试夹具
    7. 通过事件进行埋点
      1. 检测内存泄漏
    8. google mock

unittest框架搭建

  • 以下框架也是google test的基本原理
    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
    // unittest.h
    ##pragma once
    ##include "testcase.h"
    ##include <vector>
    ##include <iostream>

    class UnitTest // 单例实现，保证全局都可以进行唯一测试
    {
    public:
        // 获取单例
        static UnitTest* GetInstance(); 

        // 注册测试案例
        TestCase* RegisterTestCase(TestCase* testcase);
        // addChild()
        
        // 执行单元测试
        int Run();

        TestCase* GetCurrentTestCase() { return CurrentTestCase;}

    protected:
        std::vector<TestCase*> testcases_; // 案例集合

    private:
        TestCase* CurrentTestCase; // 记录当前执行的测试案例
        int nTestResult; // 总的执行结果
        int nPassed; // 通过案例数
        int nFailed; // 失败案例数
    };

    ##define TESTCASE_NAME(testcase_name) \
        testcase_name##_TEST

    ##define ZVOICE_TEST_(testcase_name) \
    class TESTCASE_NAME(testcase_name) : public TestCase \
    { \
    public: \
        TESTCASE_NAME(testcase_name)(const char* case_name) : TestCase(case_name){}; \
        virtual void Run(); \
    private: \
        static TestCase* const testcase_; \
    }; \
    \
    TestCase* const TESTCASE_NAME(testcase_name) \
        ::testcase_ = UnitTest::GetInstance()->RegisterTestCase( \
            new TESTCASE_NAME(testcase_name)(#testcase_name)); \
    void TESTCASE_NAME(testcase_name)::Run()

    ##define ZVTEST(testcase_name) \
        ZVOICE_TEST_(testcase_name)

    ##define RUN_ALL_TESTS() \
        UnitTest::GetInstance()->Run();

    ##define EXPECT_EQ(m, n) \
        if (m != n) \
        { \
            UnitTest::GetInstance()->GetCurrentTestCase()->nTestResult = 0; \
            std::cout << "Failed" << std::endl; \
            std::cout << "Expect:" << m << std::endl; \
            std::cout << "Actual:" << n << std::endl; \
        }

    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
    // unittest.cpp
    ##include "unittest.h"
    ##include <iostream>

    UnitTest* UnitTest::GetInstance()
    {
        static UnitTest instance;
        return &instance;
    }

    TestCase* UnitTest::RegisterTestCase(TestCase* testcase)
    {
        testcases_.push_back(testcase);
        return testcase;
    }

    int UnitTest::Run()
    {
        nTestResult = 1;
        for (std::vector<TestCase*>::iterator it = testcases_.begin();
            it != testcases_.end(); ++it)
        {
            TestCase* testcase = *it;
            CurrentTestCase = testcase;
            std::cout << "======================================" << std::endl;
            std::cout << "Run TestCase:" << testcase->testcase_name << std::endl;
            testcase->Run();
            std::cout << "End TestCase:" << testcase->testcase_name << std::endl;
            if (testcase->nTestResult)
            {
                nPassed++;
            }
            else
            {
                nFailed++;
                nTestResult = 0;
            }
        }

        std::cout << "======================================" << std::endl;
        std::cout << "Total TestCase : " << nPassed + nFailed << std::endl;
        std::cout << "Passed : " << nPassed << std::endl;
        std::cout << "Failed : " << nFailed << std::endl;
        return nTestResult;
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    // testcase.cpp
    ##include "unittest.h"

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

    ZVTEST(FooTest_PassDemo) // 会生成一个继承自TestCase的新的类
    {
        EXPECT_EQ(3, Foo(1, 2)); // 加入测试案例中
        EXPECT_EQ(2, Foo(1, 1));
    }

    ZVTEST(FooTest_FailDemo)
    {
        EXPECT_EQ(4, Foo(1, 2));
        EXPECT_EQ(2, Foo(1, 2));
    }

    int main(int argc, const char* argv[])
    {
        return RUN_ALL_TESTS();
    }

google test测试层次关系

  • 单元测试
    • 测试套件
      • 测试案例
        • 断言

EXPECT_* 与 ASSERT_*的区别

  1. EXPECT_*测试失败后后续语句正常执行，ASSERT_*失败后后续语句不执行，直接跳到下一个案例；
  2. 死亡测试：EXPECT_DEATH，经常用于在测试案例中提醒使用接口的用户，该位置该参数会造成崩溃，注意：死亡测试无论写到哪个位置，总是会提到测试案例最开始的位置执行；

使用

  1. 测试含有main函数的文件
    1
    g++ sample.cc -o sample -lgtest -lpthread
  2. 测试不含main函数的文件
    1
    g++ sample.cc -o sample -lgtest -lgtest_main -lpthread

函数测试

1
2
3
4
5
6
7
8
// sample1.h
##ifndef GOOGLETEST_SAMPLES_SAMPLE1_H_
##define GOOGLETEST_SAMPLES_SAMPLE1_H_

int Factorial(int n);
bool IsPrime(int n);

##endif  // GOOGLETEST_SAMPLES_SAMPLE1_H
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
// sample1_unittest.cc
// 不含main函数，需要手动-lgtest_main
##include "sample1.h"
##include <limits.h>
##include "gtest/gtest.h"

namespace {
    // Tests Factorial().

    // 测试套件：阶乘，测试案例：负数
    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));
    }

    // Tests IsPrime()

    // 测试套件：质数，测试案例：负数
    TEST(IsPrimeTest, Negative) {
    EXPECT_FALSE(IsPrime(-1));
    EXPECT_FALSE(IsPrime(-2));
    EXPECT_FALSE(IsPrime(INT_MIN));
    }

    // 测试套件：质数，测试案例：随机
    TEST(IsPrimeTest, Trivial) {
    EXPECT_FALSE(IsPrime(0));
    EXPECT_FALSE(IsPrime(1));
    EXPECT_TRUE(IsPrime(2));
    EXPECT_TRUE(IsPrime(3));
    }

    // 测试套件：质数，测试案例：整数
    TEST(IsPrimeTest, Positive) {
    EXPECT_FALSE(IsPrime(4));
    EXPECT_TRUE(IsPrime(5));
    EXPECT_FALSE(IsPrime(6));
    EXPECT_TRUE(IsPrime(23));
    }
}

类对象测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// sample2.h
##ifndef GOOGLETEST_SAMPLES_SAMPLE2_H_
##define GOOGLETEST_SAMPLES_SAMPLE2_H_
##include <string.h>
class MyString {
 private:
  const char* c_string_;
  const MyString& operator=(const MyString& rhs);

 public:
  static const char* CloneCString(const char* a_c_string);
  MyString() : c_string_(nullptr) {}
  explicit MyString(const char* a_c_string) : c_string_(nullptr) {
    Set(a_c_string);
  }
  MyString(const MyString& string) : c_string_(nullptr) {
    Set(string.c_string_);
  }
  ~MyString() { delete[] c_string_; }
  const char* c_string() const { return c_string_; }
  size_t Length() const { return c_string_ == nullptr ? 0 : strlen(c_string_); }
  void Set(const char* c_string);
};
##endif  // GOOGLETEST_SAMPLES_SAMPLE2_H_
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
// sample2_unittest.cc
##include "sample2.h"
##include "gtest/gtest.h"
namespace {

TEST(MyString, DefaultConstructor) {
  const MyString s;
  EXPECT_STREQ(nullptr, s.c_string());
  EXPECT_EQ(0u, s.Length());
}

const char kHelloString[] = "Hello, world!";

TEST(MyString, ConstructorFromCString) {
  const MyString s(kHelloString);
  EXPECT_EQ(0, strcmp(s.c_string(), kHelloString));
  EXPECT_EQ(sizeof(kHelloString) / sizeof(kHelloString[0]) - 1, s.Length());
}

TEST(MyString, CopyConstructor) {
  const MyString s1(kHelloString);
  const MyString s2 = s1;
  EXPECT_EQ(0, strcmp(s2.c_string(), kHelloString));
}

TEST(MyString, Set) {
  MyString s;

  s.Set(kHelloString);
  EXPECT_EQ(0, strcmp(s.c_string(), kHelloString));
  s.Set(s.c_string());
  EXPECT_EQ(0, strcmp(s.c_string(), kHelloString));
  s.Set(nullptr);
  EXPECT_STREQ(nullptr, s.c_string());
}
}  // namespace

需要测试的数据类型

  1. 业务需求功能测试
  2. 边界值测试
  3. 异常值测试

测试夹具

  • 当多个函数/类需要共享某些数据时使用
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    // 定义类型，继承自 testing::Test
    class TestFixtureSmpl : public testing::Test {
    protected:
        void SetUp() {} // 测试夹具测试前调用的函数 -- 做初始化的工作
        void TearDown() {} // 测试夹具测试后调用的函数 -- 做清理的工作
    };
    // 需要在 TEST_F 中书写测试用例
    ##define TEST_F(test_fixture, test_name)
    // 如果需要复用测试夹具，只需要继承自 TestFixtureSmpl
    class TestFixtureSmpl_v2 : public TestFixtureSmpl {
    };
    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
    // sample5_unittest.cc
    ##include <limits.h>
    ##include <time.h>

    ##include "sample1.h"
    ##include "gtest/gtest.h"
    namespace {
    class QuickTest : public testing::Test {
    protected:
        void SetUp() override { 
            // 共享数据的初始化
            start_time_ = time(nullptr); 
        }   
        void TearDown() override {
            const time_t end_time = time(nullptr);
            EXPECT_TRUE(end_time - start_time_ <= 5) << "The test took too long.";
        }
        // 要共享的数据
        time_t start_time_;
    };

    class IntegerFunctionTest : public QuickTest {
      // We don't need any more logic than already in the QuickTest fixture.
      // Therefore the body is empty.
    };

    // Tests Factorial()
    TEST_F(IntegerFunctionTest, Factorial) {
      EXPECT_EQ(1, Factorial(-5));
      EXPECT_EQ(1, Factorial(-1));
      EXPECT_GT(Factorial(-10), 0);

      EXPECT_EQ(1, Factorial(0));

      EXPECT_EQ(1, Factorial(1));
      EXPECT_EQ(2, Factorial(2));
      EXPECT_EQ(6, Factorial(3));
      EXPECT_EQ(40320, Factorial(8));
    }

    // Tests IsPrime()
    TEST_F(IntegerFunctionTest, IsPrime) {
      EXPECT_FALSE(IsPrime(-1));
      EXPECT_FALSE(IsPrime(-2));
      EXPECT_FALSE(IsPrime(INT_MIN));

      EXPECT_FALSE(IsPrime(0));
      EXPECT_FALSE(IsPrime(1));
      EXPECT_TRUE(IsPrime(2));
      EXPECT_TRUE(IsPrime(3));

      EXPECT_FALSE(IsPrime(4));
      EXPECT_TRUE(IsPrime(5));
      EXPECT_FALSE(IsPrime(6));
      EXPECT_TRUE(IsPrime(23));
    }
    }

通过事件进行埋点

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
// The interface for tracing execution of tests. The methods are organized
in
// the order the corresponding events are fired.
class TestEventListener {
public:
    virtual ~TestEventListener() {}
    // Fired before any test activity starts.
    virtual void OnTestProgramStart(const UnitTest& unit_test) = 0;
    // Fired before each iteration of tests starts. There may be more than
    // one iteration if GTEST_FLAG(repeat) is set. iteration is the iteration
    // index, starting from 0.
    virtual void OnTestIterationStart(const UnitTest& unit_test,
    int iteration) = 0;
    // Fired before environment set-up for each iteration of tests starts.
    virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test) = 0;
    // Fired after environment set-up for each iteration of tests ends.
    virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test) = 0;
    // Fired before the test suite starts.
    virtual void OnTestSuiteStart(const TestSuite& /*test_suite*/) {}
    // Legacy API is deprecated but still available
    #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
    virtual void OnTestCaseStart(const TestCase& /*test_case*/) {}
    #endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
    // Fired before the test starts.
    virtual void OnTestStart(const TestInfo& test_info) = 0;
    // Fired after a failed assertion or a SUCCEED() invocation.
    // If you want to throw an exception from this function to skip to the next
    // TEST, it must be AssertionException defined above, or inherited from it.
    virtual void OnTestPartResult(const TestPartResult& test_part_result) = 0;
    // Fired after the test ends.
    virtual void OnTestEnd(const TestInfo& test_info) = 0;
    // Fired after the test suite ends.
    virtual void OnTestSuiteEnd(const TestSuite& /*test_suite*/) {}
    // Legacy API is deprecated but still available
    #ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
    virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {}
    #endif // GTEST_REMOVE_LEGACY_TEST_CASEAPI_
    virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test) = 0;
    // Fired after environment tear-down for each iteration of tests ends.
    virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test) = 0;
    // Fired after each iteration of tests finishes.
    virtual void OnTestIterationEnd(const UnitTest& unit_test,
    int iteration) = 0;
    // Fired after all test activities have ended.
    virtual void OnTestProgramEnd(const UnitTest& unit_test) = 0;
};

检测内存泄漏

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 重载操作符 new 和 delete，接着用类的静态成员来统计调用 new 和 delete的次数
class CLeakMem {
public:
    // ...
    void* operator new(size_t allocation_size) {
        allocated_++;
        return malloc(allocation_size);
    } 
    void operator delete(void* block, size_t /* allocation_size */) {
        allocated_--;
        free(block);
    }
private:
    static int allocated_;
};
int CLeakMem::allocated_ = 0;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class LeakChecker : public EmptyTestEventListener {
private:
    // Called before a test starts.
    void OnTestStart(const TestInfo& /* test_info */) override {
        initially_allocated_ = CLeakMem::allocated();
    } 
    // Called after a test ends.
    void OnTestEnd(const TestInfo& /* test_info */) override {
        int difference = CLeakMem::allocated() - initially_allocated_;
        // You can generate a failure in any event handler except
        // OnTestPartResult. Just use an appropriate Google Test assertion to do
        // it.
        EXPECT_LE(difference, 0) << "Leaked " << difference << " unit(s) of class!";
    } 
    int initially_allocated_;
};

google mock

  • 工作中很少使用
2024-03-14 该篇文章被 Cleofwine 归为分类: 服务端

上一篇：后端技术_性能工具与性能分析 下一篇：后端技术_Skynet设计原理
© 2023-2026 Cleofwine / Email / GitHub / 浙ICP备2024136127号
🌙赠我弯弯一枚月，也赠予我晚星⭐ 本站由Hexo驱动｜使用Hexo-theme-A4主题