Chapter 141: Unit Testing in C++

Unit testing is a level in software testing that validates the behavior and correctness of units of code.

In C++, "units of code" often refer to either classes, functions, or groups of either. Unit testing is often performed using specialized "testing frameworks" or "testing libraries" that often use non-trivial syntax or usage patterns.

This topic will review di erent strategies and unit testing libraries or frameworks.

Section 141.1: Google Test

Google Test is a C++ testing framework maintained by Google. It requires building the gtest library and linking it to your testing framework when building a test case file.

Minimal Example

// main.cpp

#include <gtest/gtest.h> #include <iostream>

//Google Test test cases are created using a C++ preprocessor macro

//Here, a "test suite" name and a specific "test name" are provided. TEST(module_name, test_name) {

std::cout << "Hello world!" << std::endl;

// Google Test will also provide macros for assertions. ASSERT_EQ(1+1, 2);

}

//Google Test can be run manually from the main() function

//or, it can be linked to the gtest_main library for an already

//set-up main() function primed to accept Google Test test cases. int main(int argc, char** argv) {

::testing::InitGoogleTest(&argc, argv);

return RUN_ALL_TESTS();

}

// Build command: g++ main.cpp -lgtest

Section 141.2: Catch

Catch is a header only library that allows you to use both TDD and BDD unit test style.

The following snippet is from the Catch documentation page at this link:

SCENARIO( "vectors can be sized and resized", "[vector]" ) { GIVEN( "A vector with some items" ) {

std::vector v( 5 );

REQUIRE( v.size() == 5 );

REQUIRE( v.capacity() >= 5 );

WHEN( "the size is increased" ) { v.resize( 10 );

THEN( "the size and capacity change" ) {

REQUIRE( v.size() == 10 );

REQUIRE( v.capacity() >= 10 );

}

}

WHEN( "the size is reduced" ) { v.resize( 0 );

THEN( "the size changes but not capacity" ) { REQUIRE( v.size() == 0 );

REQUIRE( v.capacity() >= 5 );

}

}

WHEN( "more capacity is reserved" ) { v.reserve( 10 );

THEN( "the capacity changes but not the size" ) { REQUIRE( v.size() == 5 );

REQUIRE( v.capacity() >= 10 );

}

}

WHEN( "less capacity is reserved" ) { v.reserve( 0 );

THEN( "neither size nor capacity are changed" ) { REQUIRE( v.size() == 5 );

REQUIRE( v.capacity() >= 5 );

}

}

}

}

Conveniently, these tests will be reported as follows when run:

Scenario: vectors can be sized and resized Given: A vector with some items When: more capacity is reserved Then: the capacity changes but not the size

Use make_unique()

Use nullptr

Performance checks

Find unneeded copies

Find ine cient algorithm calls

The list might not be that large, as Clang already has a lot of compiler warnings, however it will bring you one step closer to a high quality code base.

Other tools

Other tools with similar purpose exist, like:

the visual studio static analyzer as external tool clazy, a Clang compiler plugin for checking Qt code

Conclusion

A lot static analysis tools exist for C++, both build-in in the compiler as external tools. Trying them out doesn't take that much time for easy setups and they will find bugs you might miss in code review.

Section 142.2: Segfault analysis with GDB

Lets use the same code as above for this example.

#include <iostream>

void fail() { int *p1;

int *p2(NULL); int *p3 = p1; if (p3) {

std::cout << *p2 << std::endl;

}

}

int main() { fail();

}

First lets compile it

g++ -g -o main main.cpp

Lets run it with gdb

gdb ./main

Now we will be in gdb shell. Type run.

(gdb) run

The program being debugged has been started already. Start it from the beginning? (y or n) y

Starting program: /home/opencog/code-snippets/stackoverflow/a.out

Program received signal SIGSEGV, Segmentation fault. 0x0000000000400850 in fail () at debugging_with_gdb.cc:11