1

我依赖于使用以下结构的 ac api（函数名称只是一个示例）：

getRoot(FolderHandle* out)
getFirstChildFolder(FolderHandle in, FolderHandle* out)
getNextFolder(FolderH in, FolderHandle* out)
getChildFolder(FolderH in, FolderHandle* out)
getProperties(FolderH in, PropertiesH* out)
getChildFolder(FolderH in, FolderH* out)
getName(PropertiesH in, char** out)
getFile(FolderH in, FileH* out)
getNextFile(FileH in, FileH* out)
getProperties(FileH in, PropertiesH* out)

所以我首先调用 getRoot 来获取根的文件夹句柄。为了获得根文件夹中第一个文件的句柄，我调用 getFile() 并传入文件夹句柄。要获取此级别的第二个和后续文件，我调用 getNextFile，传入前一个文件句柄。

我以一组 C++ 接口的形式包装了它，如下所示：

class IEntry
{
public:
    ...
    virtual IFolder* root() = 0;    
};

class IFolder
{
public:
    ...
    typedef Iterator<IFile, FolderH, FileH> FileIterator;
    virtual FileIterator filesBegin() const = 0;
    virtual FileIterator filesEnd() const = 0;
};

class File
{
public:
    ...    
    virtual IProperties* properties() = 0;
};

class Properties
{
public:
    ...
    virtual std::string name() = 0;
};

在单元测试中，我需要做的就是使用 IEntry、IFolder、IFile 等的 Google Mock 实现，这非常方便。此外，接口以更易于理解和使用的方式组织来自 c api 的功能。特定接口的实现包装了相关的句柄。

我使用迭代器将 getFile 和 getNextFile 之类的函数调用联系在一起，在这种情况下，它们会遍历文件夹中的文件。api中有很多这样的函数对，所以我使用一个名为Iterator的模板类来创建我的C++风格的迭代器。

我实际上使用的是 std::shared_ptrs，而不是普通的指针。

所以这里是一个单元测试的例子：

std::string a(IEntry& e) 
{
    std::shared_ptr<IFolder> f = e.root();
    return f->properties()->name();
}

TEST (FooTest, a) 
{
    MockEntry e;
    std::shared_ptr<MockFolder> f(new MockFolder());
    std::shared_ptr<MockProperties> p(new MockProperties());

    EXPECT_CALL(e, root()).WillOnce(testing::Return(f));
    EXPECT_CALL(*f, properties()).WillOnce(testing::Return(p));
    EXPECT_CALL(*p, name()).WillOnce(testing::Return("Root"));

    EXPECT_EQ(a(e), "Root");
}

然而，当涉及到迭代器的使用时，事情变得更加棘手。这是我在这种情况下使用的方法：

std::string b(IEntry& e)
{
    std::shared_ptr<IFolder> folder = e.root();
    IFile::FileIterator i = folder->filesBegin();
    if(i!=f->filesEnd())
    {
        return i->properties()->name();
    }
    else
    {
        return "";
    }
}

TEST (FooTest, b) 
{
    MockEntry e;
    std::shared_ptr<MockFolder> f(new MockFolder());
    loadFileIteratorWithZeroItems(f);
    loadFileIteratorEnd(f);
    std::shared_ptr<MockProperties> p(new MockProperties());

    EXPECT_CALL(e, root()).WillOnce(testing::Return(f));
    EXPECT_EQ(b(e), "");
}

该测试正在测试 else 子句。我还有另外两个测试测试其余代码（一个文件和多个文件）。

函数 loadFileIteratorWithZeroItems 正在操作迭代器的内部结构，以便迭代零个项目。loadFileIteratorEnd 设置 filesEnd() 的返回值。这是 loadFileIteratorWithZeroItems：

void loadFileIteratorWithZeroItems (std::shared_ptr<MockFolder> folder)
{
    std::shared_ptr<MockFile> file(new MockFile());
    std::shared_ptr<MockFileFactory> factory(new MockFileFactory());
    std::shared_ptr<MockFileIterator> internalIterator(new MockFileIterator());
    FolderH dummyHandle = {1};

    EXPECT_CALL(*internalIterator, getFirst(testing::_,testing::_)).WillOnce(testing::Return(false));
    MockFolder::FileIterator iterator = MockFolder::FileIterator(factory,internalIterator,dummyHandle);

    EXPECT_CALL(*folder, filesBegin()).WillOnce(testing::Return(iterator));
}

工厂用于创建迭代器指向的项目。在单元测试的情况下，这是一个模拟版本。内部迭代器是函数 getFile() 和 getNextFile() 以及所有此类对的包装器，带有接口 getFirst() 和 getNext()。

我还有名为 loadFileIteratorWithOneItem 和 loadFileIteratorWithTwoItems 的函数。

任何人都可以建议一种更好的方法来测试上面的函数 b 吗？

我的设计从根本上被剥削了吗？迭代器实现有问题吗？

4

1 回答 1

2

在我看来，您实际上并没有充分发挥模拟的潜力。要b在这种情况下进行测试，我只需使用以下测试用例：

TEST (FooTest, b) 
{
    MockEntry e;
    MockFolder f;
    IFile::FileIterator it; // I don't know how you construct one,
                            // just make sure that it == it

    ON_CALL(e, root()).WillByDefault(Return(&f));
    ON_CALL(f, filesBegin()).WillByDefault(Return(it));
    ON_CALL(f, filesEnd()).WillByDefault(Return(it));

    EXPECT_CALL(e, root()).Times(1);
    EXPECT_CALL(f, filesBegin()).Times(1);
    EXPECT_CALL(f, filesEnd()).Times(1);

    EXPECT_EQ(b(e), "");
}

在我看来，这是使用模拟的最优雅的方法。很清楚正在发生什么，并且您不依赖任何其他代码来设置行为。这仅测试函数的 else 子句b。

于 2013-01-14T12:24:30.523 回答