GoogleTest and Memory Leaks

Question

I'm surprised that Google C++ Testing Framework does not explicitly support checking for memory leaks. There is, however, a workaround for Microsoft Visual C++, but what about Linux?

If memory management is crucial for me, is it better to use another C++ unit-testing framework?

Answer 1

If memory management is crucial for me, is it better to use another C++ unit-testing framework?

i don't know about c++ unit-testing, but i used Dr. memory, it works on linux windows and mac if you have the symbols it even tells you in what line the memory leak happened! really usefull :D
more info http://drmemory.org/

Answer 2

Even if this thread is very old. I was searching for this lately.

I now came up with a simple solution (inspired by https://stackoverflow.com/a/19315100/8633816)

Just write the following header:

#include "gtest/gtest.h"
#include <crtdbg.h>

class MemoryLeakDetector {
public:
    MemoryLeakDetector() {
        _CrtMemCheckpoint(&memState_);
    }

    ~MemoryLeakDetector() {
        _CrtMemState stateNow, stateDiff;
        _CrtMemCheckpoint(&stateNow);
        int diffResult = _CrtMemDifference(&stateDiff, &memState_, &stateNow);
        if (diffResult)
            reportFailure(stateDiff.lSizes[1]);
    }
private:
    void reportFailure(unsigned int unfreedBytes) {
        FAIL() << "Memory leak of " << unfreedBytes << " byte(s) detected.";
    }
    _CrtMemState memState_;
};

Then just add a local MemoryLeakDetector to your Test:

TEST(TestCase, Test) {
    // Do memory leak detection for this test
    MemoryLeakDetector leakDetector;

    //Your test code
}

Example:

A test like:

TEST(MEMORY, FORCE_LEAK) {
    MemoryLeakDetector leakDetector;

    int* dummy = new int;
}

Produces the output:

I am sure there are better tools out there, but this is a very easy and simple solution.

Answer 3

"I'm surprised that Google C++ Testing Framework does not explicitly support checking for memory leaks."

It's not (and never was) purposed to do so. You can actually do some certifying, e.g. using google mock and setting up expected calls (for e.g. destructors). But using a tool specialized upon this aspect, will certainly do better, than everything you're able to write yourself.

"is it better to use another C++ unit-testing framework?"

So why bothering looking for different unit testing frameworks (that won't support such feature either, at least there's none I know of).

There are tools like valgrind you can use, and run your UnitTester executable under their control to detect memory leaks.

Note:
The above advice to do this with the UnitTester executable, won't be able to catch all of the possible memory leaks from the final executable produced with your code, but just help to find bugs/flaws with the actually tested code.

Answer 4

Not sure whether this worked in 2015, but since 2018 or so we use GoogleTest with CLang's sanitizers, including LeakSanitizer, AddressSanitizer and UndefinedBehavior sanitizer.

Just build tests with sanitizers enabled, example for the CMake-based project:

  add_compile_options(-fsanitize=leak,address,undefined -fno-omit-frame-pointer -fno-common -O1)
  link_libraries(-fsanitize=leak,address,undefined)

Answer 5

Memory leaks are a result of incorrect use of system interfaces, The unit test should check if those interfaces are being used correctly in your unit under test, not what the implementation specific results of any of those interfaces is. It should check that the memory allocation and deallocation interfaces used directly by your unit are being used as designed. Testing the system specific results would be a part of component or integration testing. In the unit test, the memory management interfaces are external to the unit under test and thus should be stubbed out with a test implementation.