单元测试时操作迭代器

Question

我依赖于一个使用以下结构的c 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和loadFileItinatorWithTwoItems的函数。

有人能提出一个更好的方法来测试上面的函数b吗？

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

Answer 1

在我看来，你实际上并没有充分利用嘲讽的潜力。为了在这种情况下测试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), "");
}

在我看来，这是使用模拟的最优雅的方法。发生的事情很清楚，你不需要依赖任何其他代码来设置行为。这只测试b函数的else子句。