1

我正在开发一个测试框架。有许多测试套件，每个测试套件都是一个类，每个测试套件都有一组成员函数。

我想找到一种方法来动态迭代一个类中的所有测试。

理想化的设置可能如下所示：

class A : public Test
{
public:
    A() {
        addTest(a);
        addTest(b);
        addTest(c);
    }

    void a() { cout << "A::a" << endl; }
    void b() { cout << "A::b" << endl; }
    void c() { cout << "A::c" << endl; }
};

addTest() 方法会将其参数添加到列表中；稍后会迭代此列表并运行每个方法。

有什么办法可以做到这一点？到目前为止，我们提出的最接近的是：

class Test
{
public:
    template <typename T>
    struct UnitTest
    {
        typedef void (T::*P)();
        P f;
        UnitTest(P p) : f(p) {}
    };
    // (this struct simplified: we also include a name and description)

    virtual void run(int testId) = 0;
};

class A : public Test
{
public:
    A() {
        mTests.push_back(UnitTest<A>(&A::a));
        mTests.push_back(UnitTest<A>(&A::b));
        mTests.push_back(UnitTest<A>(&A::c));
    }

    void a() { cout << "a" << endl; }
    void b() { cout << "b" << endl; }
    void c() { cout << "c" << endl; }

    // not ideal - this code has to be repeated in every test-suite
    void run(int testId)
    {
        (this->*(mTests[testId].f))();
    }
    vector<UnitTest<A>> mTests;
};

要在主运行循环的每次迭代中调用一个测试：

a->run(mTestId++);

这并不理想，因为每个测试套件（类）都必须重复 run() 代码并拥有自己的 mTests 成员。

有没有办法更接近理想？

4

1 回答 1

1

使每个测试成为仿函数或函数对象。创建一个指向测试的指针容器，然后遍历容器：

struct Test_Base_Class
{
  virtual bool Execute(void) = 0;
};

typedef std::vector<Test_Base_Class *> Container_Of_Tests;

struct Test_Engine
{
  Container_Of_Tests tests_to_run;

  void Add_Test(Test_Base_Class * p_new_test)
  {
    tests_to_run.push_back(p_new_test);
  }

  void Run_Tests(void)
  {
    Container_Of_Tests::iterator iter;
    for (iter = tests_to_run.begin();
         iter != tests_to_run.end();
         ++iter)
    {
       (*iter)->Execute(); // Invoke the Execute method on a test.
    }
    return;
  }
}

这是基础。我目前正在使用这种模式，但已经扩展到包括 Resume() 方法和状态报告。

于 2011-02-07T23:33:11.983 回答