单元测试2

在阅读某单元测试框架时，发现其中宏定义的用法很“飘逸”，给人一种耳目一新的感觉。
下面我就将这个单元测试框架精简化，便于理解。
精简后的单元测试框架主要用3个宏“TEST_CASE”，“DECLARE_TEST_SUITE”，“TEST_SUITE”来实现。
宏TEST_CASE，DECLARE_TEST_SUITE实际上“实现”了2个类，这2个类分别继承于“TestCase”和“TestSuite”，祖先是“Test”。
当我们添加“用例”和“测试套”，就是套用宏实现，生成新的类，实现runImpl和construct方法。（这样做即简洁，扩展性又强）
新添加的类（用例）被存放（addTest）在Test类型数组testList中;在执行时，遍历每一个testList成员，调用run，动态映射到具体用例的执行。

添加用例时：
TEST_CASE(myTestCase)
{
  cout<<"Hello, myTestCase"<<endl;
}
实际就是实现了类TestmyTestCase中的runImpl()
就是这么简单！

下面是精简后的代码。

#include <iostream>
using namespace std;

//最大测试用例数
#define TEST_CASE_MAX 100
//测试接口类
class Test 
{
  public:
  virtual void run() = 0;  
};
//“测试用例”类
class TestCase:public Test 
{
public:
  TestCase()
  {
  }
  ~TestCase()
  {
  }
  void run()
  {
	runImpl();
  }
  virtual void runImpl() {}
};
//“测试套”类
class TestSuite:public Test 
{
  public:
  TestSuite()
  {
  }
  ~TestSuite()
  {
  }
  void run()
  {
    Test * currTest_p;
    for(int i = 0; i<testIndex; i++)
    {
      currTest_p = testList[i];
	  currTest_p->run();
    }
  }
  void addTest(Test &test)
  {
    if(testIndex<TEST_CASE_MAX)
    {
      testList[testIndex] = &test;
	  testIndex++;
    }
  }
  private:	
  //测试用例数组
  Test* testList[TEST_CASE_MAX];
  int  testIndex;
};

//（可扩展）宏定义测试用例类
#define TEST_CASE(Name)                                               \
  class Test##Name : public TestCase                                  \
  {                                                                   \
    public:                                                           \
      Test##Name()                                                    \
      {                                                               \
      }                                                               \
      virtual ~Test##Name()                                           \
      {                                                               \
      }                                                               \
      void runImpl();                                                 \
  } Name;                                                             \
  void Test##Name::runImpl()

//（可扩展）测试套声明类
#define DECLARE_TEST_SUITE(Name)                                      \
  class Test##Name: public TestSuite                                  \
  {                                                                   \
    public:                                                           \
      Test##Name()                                                    \
      {                                                               \
      }                                                               \
      virtual ~Test##Name()                                           \
      {                                                               \
      }                                                               \
      void construct();                                               \
  };                                                                  \
  extern Test##Name Name  
  
//（可扩展）测试套实现类
#define TEST_SUITE(Name)       \
  Test##Name Name;             \
  void Test##Name::construct() 
     
	 
//测试用例，实际就是实现了类TestmyTestCase的runImpl()
TEST_CASE(myTestCase)
{
  cout<<"Hello, myTestCase"<<endl;
}
//（添加）测试用例2
TEST_CASE(myTestCase2)
{
  cout<<"Hello, myTestCase2"<<endl;
}
//（添加）测试用例3
TEST_CASE(myTestCase3)
{
  cout<<"Hello, myTestCase3"<<endl;
}
//（添加）测试用例4
TEST_CASE(myTestCase4)
{
  cout<<"Hello, myTestCase4"<<endl;
}
//（添加）测试用例 ......


//测试套，实际就是实现了类TestmyTestSuite的construct()
DECLARE_TEST_SUITE(myTestSuite);
TEST_SUITE(myTestSuite)
{
  addTest(myTestCase);
  addTest(myTestCase3);
}
//(添加)测试套2
DECLARE_TEST_SUITE(myTestSuite2);
TEST_SUITE(myTestSuite2)
{
  addTest(myTestCase2);
  addTest(myTestCase4);
}
//（添加）测试套 ......


//合并测试套
DECLARE_TEST_SUITE(tests);
TEST_SUITE(tests)
{
  myTestSuite.construct();
  addTest(myTestSuite);
  
  myTestSuite2.construct();
  addTest(myTestSuite2);
}

//统一执行
int main()
{
  tests.construct();
  tests.run();
  return 1;
}