51Testing软件测试论坛

标题: GoogleTest框架总结之类Test Fixture的继承和差异化和接口测试 [打印本页]
作者: lsekfe    时间: 2021-11-2 15:21
标题: GoogleTest框架总结之类Test Fixture的继承和差异化和接口测试
一、Test Fixture的继承和差异化
　　之前介绍了Test Fixture，下面通过示例sample05说明下如何进行Test Fixture的继承。
　　对已有的Test Fixture进行继承，往往发生在如下两个场景 (1) 定义的Test Fixture可用于指定的一套单元测试用例集，当有多套测试用例时，如何处理？ (2)当不同的测试用例集对应的测试资源基本相同、但又存在少量差异，又如何处理？
　　被继承的Test Fixture在Google Test 中被称为 Super Fixture、继承者被称为sub fixture。Super Fixture /Test Fixture 本质就是一个类，类当然可以被继承啦。

　　sample05的测试对象
　　1. 测试对象是 sample01.h + sample01.cpp, sample03.h，文件结构如下图所示：
[attach]135054[/attach]
sample01.h 对Factorial( ), IsPrime( )函数进行了声明、sample01.cpp 对Factorial( ) 、IsPrime( )两个函数进行了具体实现：Factorial用于求一个整数的阶乘、IsPrime用于判定一个整数是否为素数
　　sample03.h 完整定义了类Queue（包含成员函数的具体实现）：类Queue实现了队列的基本功能，同时他包含了一个定制化的Map( )函数
　　上述源码文件在之前的文档中已经展示过，这里不再重复。

　　对应的单元测试用例
　　1. sample05UnitTest.cpp中定义了名为QuickTest的Test Fixture，用来判定用例的执行时间是否超过5秒：从SetUp( )调用时启动计时，从TearDown( )调用时结束计时，期间时间就是用例执行时间。
　　GoogleTest的每一条用例，正式启动前先调用SetUp( )，执行结束后调用TearDown( )。
  1. class QuickTest : public testing::Test   
  2.     {  
  3.     protected:  
  4.         time_t start_time_;  
  5.         void SetUp() override  
  6.          {   
  7.             start_time_ = time(nullptr);   
  8.         }  
  9.         void TearDown() override  
  10.         {   
  11.             const time_t end_time = time(nullptr);  
  12.             EXPECT_TRUE(end_time - start_time_ <= 5) << "The test took too long.";  
  13.         }  
  14. };
复制代码
2. Test Fixture的继承
　　IntegerFunctionTest继承自测试夹具QuickTest，该继承解决了上面提到的问题一：只定义了一个Test Fixture，但是需要编写多套测试用例？
  1. class IntegerFunctionTest : public QuickTest{ }；  
  2. TEST_F(IntegerFunctionTest, Factorial)  
  3. {  
  4.         EXPECT_EQ(1, Factorial(-5)); //每条用例都会判定是否超过5秒  
  5.         EXPECT_EQ(1, Factorial(-1));  
  6. }
复制代码
　QueueTest也继承自测试夹具QuickTest，他的目标是测试类Queue，因此进行了必要的差异化：在SetUp( )中为类Queue的实例化对象赋初值
　　该继承解决了上面提到的问题二：不同的测试用例集使用相同的测试资源、但又存在差异？
  1. class QueueTest : public QuickTest  
  2.     {  
  3.     protected:  
  4.          Queue<int> q0_; //差异化  
  5.         Queue<int> q1_;  
  6.         Queue<int> q2_;
  7.         void SetUp() override  
  8.         {  
  9.             QuickTest::SetUp();  
  10.             q1_.Enqueue(1);  
  11.             q2_.Enqueue(2);  
  12.             q2_.Enqueue(3);  
  13.         }            
  14.     };
复制代码
使用QueueTest的宏TEST_F，由于继承自QuickTest，同样会判定用例的执行是否超过5秒：
  1. TEST_F(QueueTest, DefaultConstructor)  
  2.     {  
  3.         EXPECT_EQ(0, q0_.Size());  
  4.     }
复制代码
QueueTest, IntegerFunctionTest 也可以被继承：可以进行Test Fixture继承的继承，此类继承没有层数限制。

　　3. 单元测试用例的完整源码
　　下面通过测试夹具QuickTest, QueueTest, IntegerFunctionTest完成sample01.h和 sample03.h的测试。
  1. #include "pch.h"  
  2. #include <limits.h>  
  3. #include <time.h>   
  4. #include "sample01.h"  
  5. #include "sample03.h"   
  6. namespace {  
  7.     class QuickTest : public testing::Test   //首先定义测试夹具QuickTest
  8.     {  
  9.     protected:   
  10.         time_t start_time_;   
  11.         void SetUp() override  
  12.         {   
  13.             start_time_ = time(nullptr);   
  14.         }  
  15.         void TearDown() override   
  16.         {  
  17.             const time_t end_time = time(nullptr);
  18.             EXPECT_TRUE(end_time - start_time_ <= 5) << "The test took too long.";  
  19.         }  
  20.     };  
  21.   
  22.     class IntegerFunctionTest : public QuickTest  
  23.     {  
  24.         // IntegerFunctionTest继承自QuickTest，由于不需要差异化，因此代码为空
  25.     };  
  26.   
  27.       //通过IntegerFunctionTest完成Factorial() 和 IsPrime()的单元测试

  29.       TEST_F(IntegerFunctionTest, Factorial)
  30.        {  
  31.         // Tests factorial of negative numbers.  
  32.         EXPECT_EQ(1, Factorial(-5));  
  33.         EXPECT_EQ(1, Factorial(-1));  
  34.         EXPECT_GT(Factorial(-10), 0);  
  35.   
  36.         // Tests factorial of 0.  
  37.         EXPECT_EQ(1, Factorial(0));  
  38.   
  39.         // Tests factorial of positive numbers.  
  40.         EXPECT_EQ(1, Factorial(1));  
  41.         EXPECT_EQ(2, Factorial(2));  
  42.         EXPECT_EQ(6, Factorial(3));  
  43.         EXPECT_EQ(40320, Factorial(8));  
  44.         }  
  45.   
  46.   
  47.     // Tests IsPrime()  
  48.     TEST_F(IntegerFunctionTest, IsPrime)  
  49.     {  
  50.         // Tests negative input.  
  51.         EXPECT_FALSE(IsPrime(-1));  
  52.         EXPECT_FALSE(IsPrime(-2));  
  53.         EXPECT_FALSE(IsPrime(INT_MIN)); //INT_MIN是边界值  
  54.   
  55.         // Tests some trivial cases.  
  56.         EXPECT_FALSE(IsPrime(0));  
  57.         EXPECT_FALSE(IsPrime(1));  
  58.         EXPECT_TRUE(IsPrime(2));  
  59.         EXPECT_TRUE(IsPrime(3));  
  60.   
  61.         // Tests positive input.  
  62.         EXPECT_FALSE(IsPrime(4));  
  63.         EXPECT_TRUE(IsPrime(5));  
  64.         EXPECT_FALSE(IsPrime(6));  
  65.         EXPECT_TRUE(IsPrime(23));  
  66.     }  
  67.   
  68.     class QueueTest : public QuickTest  
  69.     {  // QueueTest 也继承自QuickTest，由于是测试Queue，进行了部分差异化
  70.     protected:  
  71.         Queue<int> q0_;  
  72.         Queue<int> q1_;  
  73.         Queue<int> q2_;  
  74.         void SetUp() override  
  75.         {   
  76.             QuickTest::SetUp();  
  77.             q1_.Enqueue(1);  
  78.             q2_.Enqueue(2);  
  79.             q2_.Enqueue(3);  
  80.         }   
  81.     };  

  83. //通过 QueueTest完成类Queue的测试，进行代码测试并评估用例的执行时间是否超过5秒
  84.     TEST_F(QueueTest, DefaultConstructor)  
  85.     {  
  86.         EXPECT_EQ(0, q0_.Size());  
  87.     }  
  88.   
  89.     // Tests Dequeue().  
  90.     TEST_F(QueueTest, Dequeue)   
  91.     {  
  92.         int* n = q0_.Dequeue();  
  93.         EXPECT_TRUE(n == nullptr);  
  94.   
  95.         n = q1_.Dequeue();  
  96.         EXPECT_TRUE(n != nullptr);  
  97.         EXPECT_EQ(1, *n);  
  98.         EXPECT_EQ(0u, q1_.Size());  
  99.         delete n;  
  100.   
  101.         n = q2_.Dequeue();  
  102.         EXPECT_TRUE(n != nullptr);  
  103.         EXPECT_EQ(2, *n);  
  104.         EXPECT_EQ(1u, q2_.Size());  
  105.         delete n;  
  106.     }  
  107. }  // namespace
复制代码
4. 用例执行结果如下
　　从测试结果来看，所有用例的执行时间都在5秒内：










欢迎光临 51Testing软件测试论坛 (http://bbs.51testing.com/) Powered by Discuz! X3.2