How-to do unit-testing of methods involving file input output?

Question

Hello,

I'm using C++Test from Parasoft for unit testing C++ code. I came across the following problem. I have a function similar to the next one (pseudocode):

bool LoadFileToMem(const std::string& rStrFileName)
{
    if( openfile(rStrFileName) == successfull )
    {
         if( get_file_size() == successfull )
         {
            if( read_entire_file_to_buffer() == successfull )
            {
                return true;
            }
            return false;
         }
         return false;
    }
    return false;
}

My questions in this case are:

Should I use stubs for file system functions? Or should I include specific sample test files for running the unit tests?

In my case std::fstream class is used for file input.

Has anyone better suggestions? (Best if done in C++Test but not mandatory)

Thank you,

Iulian

Answer 1

I would go for short sample test files. They can be checked into source control along with the test code. The reason I would do it is that the intent of your function is to load a file, so this is what you should be testing.

Answer 2

My suggestion:

Create stubs for functions that will call this function.

Create a unit test for this specific function, with sample test files.

Create a integration test with no stubs to test the whole process.

Answer 3

It is generally a good idea in unit testing that you want to mimic the original functionality as close as possible while covering as much of the code you are testing (code coverage). Stubs aside, which I am not familiar with, an example would be that you want to make sure that, provided the wrong filename is given, etc line 3 in your file:

if( openfile(rStrFileName) == successfull )

then you will accurately handle this situation and return false. If this can be done by stubs then so be it. In my case I would use a sample test file and store that with my tests. This is a common practice.

Remember that the whole point is to test out the function as close to reality as you can. This will ensure a lot of strange cases that you can't anticipate will be caught automatically so you can fix it, which is the point of unit testing to begin with.

Answer 4

I think your looking for a technique called fault injection. I saw a project several years ago that would cause programs to go into rarely tested error conditions (file permission errors, malloc returning 0, etc.) .. I just can't remember the name of it. Hopefully the wikipedia link could get you started.

Answer 5

For unit-testing THIS function, you should use stubs for each of the called functions.

Each called function then has its own unit test suite, which exercises that function.

For read_entire_file_to_buffer(), you want at least one test file that overflows the buffer, massively, to verify that you do not crash and burn when they feed you the New York Stock Exchange histories instead of the 40-character config file you were expecting.

Answer 6

Honestly, I would split this function into two. One function would read from a std::istream, and one would open the file and return an ifstream (possibly a heap-allocated one by a smart pointer). Then, you can easily unit-test the first by supplying an istringstream instead of an ifstream, and the latter should be easy-to-test too.