Unit testing a functions whose purposes is side effects

Question

How would you unit test do_int_to_string_conversion?

#include <string>
#include <iostream>

void do_int_to_string_conversion(int i, std::string& s) {
    switch(i) {
    case 1:
        s="1";
        break;
    case 2:
        s="2";
        break;
    default:
        s ="Nix";
    }
}

int main(int argc, char** argv){
    std::string little_s;

    do_int_to_string_conversion(1, little_s);
    do_int_to_string_conversion(2, little_s);
    do_int_to_string_conversion(3, little_s);

}

Answer 1

You can use something like Expect to pass it some input and verify that its output is what it should be.

Answer 2

I assume this is just an example. Why can't you assert on the value of little_s after each call?

do_int_to_string_conversion(1, little_s);
assert_are_equal("1", little_s);

Answer 3

If you really need to ensure that the output has been written, you need to break your dependency on std::cout and use another std::ostream during tests.

This might be as simple as a global variable:

#if PRODUCTION
std::ostream my_output = std::cout;
#else
std::ostream my_output = std::ostringstream;
#endif

void setup()
{
    my_output = std::ostringstream;
}

void print_hello()
{
    my_output << "hello";
}

void test_hello_was_printed()
{
    print_hello();
    ASSERT("hello" == my_output.str());
}

Or something similar to that effect.

Answer 4

I'd change do_int_to_string_conversion so that it does just one thing (convert the in to a string).

void do_int_to_string_conversion(int i, std::string& s) {
    switch(i) { ... }
}

This has no side effects, so you can write a simple unit test that verifies the output (s).

If I needed a function that printed the result of the conversion, I'd put that in a separate function, and I'd parameterize the output stream.

void output_int(int i, ostream &stream) {
    std::string s;
    do_int_to_string_conversion(i, s);
    stream << s;
}

To unit test that, I'd pass in a std::stringstream object and check the result.

Answer 5

Instead of worrying about how to test the function as it stands, I'd redesign the function to work a bit more sensibly, and test the re-designed version instead.

Right now, the function seems to have three separate (and only slightly related) responsibilities: do a conversion, modify an externally supplied string, and write some data to a stream. The stream to which it writes (std::cout) is also hard-coded -- a problem waiting to happen (e.g., conversion to a GUI environment is likely to be non-trivial).

I'd start by 1) splitting it up into logical functions, and 2) supplying the stream as a parameter.

std::string convert_int(int val) {
    switch (val) { 
       case 1: return "1";
       case 2: return "2";
       default: return "Nix";
   }
}

std::ostream &write_string(std::ostream &os, std::string const &s) { 
    return os << s;
}

I haven't included anything to (specifically) modify an externally supplied string -- obviously you can assign the return value from convert_int as you see fit, and the value of the string that was passed in wasn't being used anyway.

Truthfully, write_string is a good candidate to be eliminated entirely, but since you had that basic kind of capability, we'll retain it for the moment. Testing these is relatively simple -- for convert_int, we look at the string it returns, and compare to what we expect. For write_string, we can pass a stringstream instead of a normal ostream -- then we can use .str() to get that result as a string, and (again) compare to what we expect.