How to capture stdout/stderr with googletest?

Question

Is it possible to capture the stdout and stderr when using the googletest framework?

For example, I would like to call a function that writes errors to the console (stderr). Now, when calling the function in the tests, I want to assert that no output appears there.

Or, maybe I want to test the error behaviour and want to assert that a certain string gets printed when I (deliberately) produce an error.

Solution 1

I have used this snippet before to redirect cout calls to a stringstream when testing output. Hopefully it might spark some ideas. I've never used googletest before.

// This can be an ofstream as well or any other ostream
std::stringstream buffer;

// Save cout's buffer here
std::streambuf *sbuf = std::cout.rdbuf();

// Redirect cout to our stringstream buffer or any other ostream
std::cout.rdbuf(buffer.rdbuf());

// Use cout as usual
std::cout << "Hello World";

// When done redirect cout to its old self
std::cout.rdbuf(sbuf);

Before redirecting back to the original output use your google test to check the output in buffer.

Solution 2

Googletest offers functions for this:

testing::internal::CaptureStdout();
std::cout << "My test";
std::string output = testing::internal::GetCapturedStdout();

Solution 3

Avoiding having to do this is always a good design idea. If you really want to do it the following works:

#include <cstdio>
#include <cassert>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <iostream>

int main() {
   int fd = open("my_file.log", O_WRONLY|O_CREAT|O_TRUNC, 0660);
   assert(fd >= 0);
   int ret = dup2(fd, 1);
   assert(ret >= 0);
   printf("This is stdout now!\n");
   std::cout << "This is C++ iostream cout now!" << std::endl;
   close(fd);
}

To use stderr instead of stdout change the second argument to dup2 to be 2. For capturing without going via a file you could use a pipe pair instead.

Solution 4

Rather than do this, use dependency injection to remove the direct use of std::cout. In your test code use a mock object of class std:ostringstream as a mock object instead of the real std::cout.

So instead of this:

 void func() {
    ...
    std::cout << "message";
    ...
 }

 int main (int argc, char **argv) {
    ...
    func();
    ...
 }

have this:

 void func(std::ostream &out) {
    ...
    out << "message";
    ...
 }

 int main(int argc, char **argv) {
    ...
    func(std::cout);
    ...
 }

View more solutions

Comments

[Jan Tojnar]

probably the simplest possible solution

[davidA]

This is only available for stdout, not stderr? There are death tests that capture stderr, but in many cases you may not be testing for process termination.

[Heinzi]

testing::internal::CaptureStderr() also exists. Is used here for example: googletest.googlecode.com/svn/trunk/test/…

[hamster on wheels]

the message is still printed on screen? how to suppress that?

[Antoine Bolvy]

One should know that this is a private API and is therefore not supported. I'd advise against it

[Nir Friedman]

I found this to segfault if called more than once, even in different tests, and therefore worthless.

[zr.]

This solution won't work if the unit-under-test throws an exception.

[Florin T.]

This doesn't work for googletest since gtest uses printf which goes straight to stdout, circumventing your redirect. But it is a nice solution if you want to intercept the output of cout << .... I would create a helper class though to automatically restore the original streambuf in the destructor...

[Florin T.]

While this is a good idea in general, it won't work in his case because gtest is an external library (from his viewpoint) and he wants to capture the output of the framework without modifying the source code.

[John Jiang]

This doesn't work for me. I still get no printout on the screen or in the log.

[andreee]

@NirFriedman it seems that one has to call ::testing::internal::CaptureStdout() prior to each capture.

[Jim Daehn]

I've added a way one might use this with Google Test barring the scenario commented above.

[Keshav Sahu]

What if he/she has many functions that prints some error messages or logs? This won't work in that case as adding extra parameter just for capturing a stream is not a good idea. One thing he/she can do is to use global stream object and change/redirect it according to needs. std::cout, std::cerr and std::clog are such global objects. It's better to use std::cout and redirect it to another stream when needed.

[Raedwald]

@KeshacSabu if there are many such functions, there are many design faults in the code to be fixed. Fixing them is a good idea.