我有一个执行测试用例的 C++ 应用程序。某些测试用例可能会依赖于其他测试用例的输出。

所有测试用例都实现一个基本接口(interface):

/// base class for all test cases
class ITest
{
public:
    virtual void Execute() = 0;
};

产生一些可能对其他测试用例有用的对象的测试用例实现这个接口(interface):

/// implemented by test cases that provide data to other test cases
template< class Obj >
class IDependency
{
public:
    virtual Obj Get() = 0;
};

需要来自其他测试用例的数据的测试用例实现此接口(interface):

/// implemented by test cases that require data from other test cases
template< class Obj >
class IDependent
{
public:

    void SetDependency( IDependency< Obj >* dependency )
    {
        dependency_ = dependency;
    };

protected:
    Obj GetDependency() const
    {
        return dependency_->Get();
    };

private:
    IDependency< Obj >* dependency_;
};

两个示例测试用例。一个需要一个 const wchar_t 对象；一个产生那个对象:

/// A test case that provides a "const wchar_t*" object to other test cases
class Foo : public ITest, 
            public IDependency< const wchar_t* >
{
public:
    const wchar_t* Get() 
    { 
        if( object_.length() == 0 )
            Execute();
        return object_.c_str();
    };

    virtual void Execute()
    {
        printf( "Execute Foo\n" );
        object_ = L"Object produced by Foo";
    };

private:
    std::wstring object_;
};

/// A test case that first requires a "const wchar_t*" object
class Bar : public ITest,
            public IDependent< const wchar_t* >
{
public:

    virtual void Execute()
    {
        const wchar_t* needed_object = GetDependency();

        printf( "Execute Bar with %S\n", needed_object );
    };
};

测试用例存储在列表中。案例通过注册过程添加到列表中:

/// List of test cases to execute
std::vector< ITest* > list_;

/// Register a test case to execute with the system
void Register( ITest* test_case )
{
    list_.push_back( test_case );
}

这是我的问题。我想实现也接受依赖项的“Register()”函数的重载。但是，因为依赖项可以是任何类型(不仅仅是本示例中的“const wchar_t*”)，所以我不确定如何管理它。下面是我正在寻找的或多或少的示例，但我不确定如何让它工作。

/// Register a test case with dependencies with the system
void Register( ITest* test_case, ITest* dependency, ... )
{
    IDependent< ??? >* dependent = dynamic_cast< IDependent< ??? >* >( test_case );
    IDependency< ??? >* dep = dynamic_cast< IDependency< ??? >* >( dependency );

    va_list dep_list;
    for( va_start( dep_list, dependency ); 
         NULL != dep; 
         dep = dynamic_cast< IDependency< ??? >* >( va_arg( dep_list, ITest* ) ) )
    {
        dependent->SetDependency( dep );
    }
    va_end( dep_list );

    Register( test_case );
}

用法示例:

int _tmain( int argc, _TCHAR* argv[] )
{
    /// Test case Foo
    Foo foo;

    /// Test case bar (depends on Foo)
    Bar bar;

    /// Register test case Bar with a dependency on Foo
    Register( &bar, &foo );

    /// Execute Bar. Because it depends on Foo, that will be executed first
    list_->begin()->Execute();
    return 0;
}

预期输出:

Execute Foo
Execute Bar with Object produced by Foo

有人对我如何成功实现此架构有任何建议吗？ (或者实际有效的更好架构？)

谢谢， 保罗H

最佳答案

我看到了两种可能的解决方案。

静态

使 Register() 方法成为模板。 简单的解决方案是将依赖项的数量限制在某个合理的最大值。

template <class T, class D1>
void Register(T* test_case, IDependency<D1>* d1)
{
    BOOST_STATIC_ASSERT(boost::is_base_and_derived<IDependent<D1>, T>::value);
    // since we now know that T is a IDependent<D1>, a dynamic_cast would only be necessary
    // to allow virtual inheritance.
    static_cast<IDependent<D1>*>(test_case)->SetDependency(d1);
    Register(test_case);
}

template <class T, class D1, class D2>
void Register(T* test_case, IDependency<D1>* d1, IDependency<D2>* d2)
{
    BOOST_STATIC_ASSERT(boost::is_base_and_derived<IDependent<D1>, T>::value);
    static_cast<IDependent<D1>*>(test_case)->SetDependency(d1);
    Register(test_case, d2);
}

template <class T, class D1, class D2, class D3>
void Register(T* test_case, IDependency<D1>* d1, IDependency<D2>* d2, IDependency<D3>* d3)
{
    BOOST_STATIC_ASSERT(boost::is_base_and_derived<IDependent<D1>, T>::value);
    static_cast<IDependent<D1>*>(test_case)->SetDependency(d1);
    Register(test_case, d2, d3);
}

// ...

对于支持可变参数模板的编译器，这可能只用一个函数模板编写，以获得无限数量的依赖项。

或者你可以让 Register() 返回一个代理类，这样你就可以这样写:

Register(test_case)(dep1)(dep2)(dep3) /* ... */ (depN);

代理类将存储指向容器和测试用例的指针，并定义一个函数调用运算符，它看起来就像上面示例中的 Register(T* test_case, IDependency* d1) 函数，只是没有“test_case”参数和对 Register(test_case) 的最终调用(可以在代理类的 dtor 中执行)。

动态

如果我理解您正在尝试正确执行的操作，则每个“依赖项”只能产生一种类型的结果。 在这种情况下，您可以像这样修改 IDependency 接口(interface):

class IDependencyBase
{
public:
    virtual void ApplyTo(ITest* target) = 0;
};

template <class T>
class IDependency : public IDependencyBase
{
public:
    virtual void ApplyTo(ITest* target)
    {
        // cast to reference gives us an std::bad_cast if the types are not compatible,
        // which I think is a good thing here
        dynamic_cast<IDependancy<T>&>(*target).SetDependancy(this); 
    }

    virtual T Get() = 0;
};

template <class InputIterator>
void Register(ITest* test_case, InputIterator begin, InputIterator end)
{
    for (; begin != end; ++begin)
    {
        IDependancyBase* dep = *begin;
        dep->ApplyTo(test_case);
    }
    Register(test_case);
}

template <class Container>
void Register(ITest* test_case, Container deps)
{
    Register(test_case, deps.begin(), deps.end());
}

现在您似乎很想再次实现您的可变参数解决方案，就像这样(从第二个示例继续):

void Register(ITest* test_case, ...)
{
    va_list dep_list;
    va_start(dep_list, test_case);
    while(IDependencyBase* dep = va_arg(dep_list, ITest*))
        dep->ApplyTo(test_case);

    va_end(dep_list);

    Register( test_case );
}

// and use it like

int _tmain( int argc, _TCHAR* argv[] )
{
    Foo foo;
    Bar bar;

    Register(&foo);
    Register(&bar, &foo, 0);

    list_->begin()->Execute();
    return 0;
}

然而，这并不能保证有效。在上面的代码中，一个 Foo* 被存储为一个 varagrs 参数，并作为一个 IDependencyBase* 读回。这不能保证有效，因为 Foo 和 IDependencyBase 都不是 POD(IIRC 它们都必须是 POD 才能保证有效——也许即使那样也不能保证，我必须在标准中查找它) .这不是什么牵强附会的“不受标准保证但可以在任何地方工作”的事情。引入多重和/或虚拟继承，这几乎肯定会失败。

所以使用 C++ 时的一般建议:除非没有其他方法，否则不要使用可变参数函数。而且总有另一种方式。

关于c++ - dynamic_cast<> 将变量参数传递给模板，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/3764912/