Question

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

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

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

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成员。

有没有办法更接近理想？

Answer 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（）方法和状态报告。

调用派生类中的方法列表

1 个答案: