9

我有一个简单的几乎类似价值的类，比如 Person：

class Person
{
public:
    Person(ThirdPartyClass *object);
    virtual ~Person(void);

    virtual std::string GetFullName() const;
    virtual int GetAge() const;
    virtual int GetNumberOfDaysTillBirthday() const;
};

我正在使用第三方库，并且ThirdPartyClass需要调用一个名为Destroy（第三方库的一部分）的全局/静态函数来销毁它。该Destroy函数在 Person 析构函数中调用。

现在我正在尝试对我的 Person 类进行单元测试，我需要一种方法来模拟/存根该Destroy方法。我想我可以围绕静态Destroy函数编写一个包装器类，然后使用依赖注入将这个包装器注入到 Person 类中，但这样做似乎有点过头了，只是在这个简单的类上调用这个函数。有什么简单直接的方法可以做到这一点？或者依赖注入真的是最好的方法吗？

更新

最终，我决定创建一个包含所有 3rd 方库的全局函数的类，然后使用依赖注入将这个类传递给我的 person 类的构造函数。这样我就可以去掉 Destroy 方法。虽然 person 类只使用一个函数，但库的其他函数在我的代码中的其他点被调用，当我需要测试这些函数时，我将面临同样的问题。

我在我的主应用程序代码中创建了这个包装类的一个实例，并在需要的地方注入它。我选择走这条路线，因为我认为它更清晰。我喜欢 Billy ONeal 的解决方案，我认为它回答了我的问题，但我意识到如果我将代码保留几个月然后回来，与依赖注入相比，我需要更长的时间才能弄清楚发生了什么。我想起了 Python 格言中的禅宗“显式胜于隐式”。而且我觉得依赖注入使正在发生的事情更加明确。

4

4 回答 4

10

创建一个链接接缝。将你的destroy声明放在一个头文件中，然后有两个实现文件：

// Destroy.cpp
void Destroy()
{
    //Code that really does destruction
}

并用于测试：

// DestroyFake.cpp
void Destroy()
{
    //Code that does fake destruction
}

然后将第一个文件链接到您的主二进制文件，将第二个文件链接到您的测试二进制文件。

除此之外，你所要求的都是不可能的。链接器将对全局函数和静态方法的调用烘焙到直接跳转到被调用者代码中——没有查找或决策过程可以挂钩来创建任何类型的重载，比如你正在寻找的重载（除了Destroy调用更容易的东西嘲笑）。

于 2011-06-30T23:58:25.913 回答
5

简单，使用Typemock Isolator++（免责声明 - 我在那里工作）

在您的测试中添加 1 行来伪造/模拟Destroy

全球使用：

FAKE_GLOBAL(Destroy);

公共静态使用：

WHEN_CALLED(Third_Party::Destroy()).Ignore();

私有静态使用： 

PRIVATE_WHEN_CALLED(Third_Party::Destroy).Ignore();

不需要额外的代码/没有条件代码/没有不同的链接。

于 2015-03-25T09:45:28.540 回答
0

我只是在这里玩，但一种可能对你有用的方法是提供你自己的destroy函数并通过在 Third_Party_Lib 指针周围添加一个包装类来消除调用的歧义......

#include <iostream>

namespace Third_Party_Lib
{
    struct X { };
    void destroy(X*) { std::cout << "Third_Party_Lib::destroy()\n"; }
}

template <typename T>
struct Wrap
{
    Wrap(const T& t) : t_(t) { }
    operator T&() { return t_; }
    operator const T&() const { return t_; }
    T t_;
};

namespace Mine
{

#if TEST_MODE
    // this destroy will be called because it's a better match
    // not needing Wrap::operator T&...
    void destroy(Wrap<Third_Party_Lib::X*>) { std::cout << "Mine::destroy()\n"; }
#endif

    struct Q
    {
        Q(Third_Party_Lib::X* p) : p_(p) { }
        ~Q() { destroy(Wrap<Third_Party_Lib::X*>(p_)); }
        Third_Party_Lib::X* p_;
    };
}

#if TEST_MODE    
int main()
{
    Mine::Q q(new Third_Party_Lib::X);
}
#endif
于 2011-07-01T01:30:21.430 回答
0

函数指针将创建一种替代另一个实现的方法。此外，它对调用者是透明的（除非他们正在做一些非常愚蠢的事情，比如 call sizeof(funcname)）。

于 2011-07-01T01:33:51.823 回答