Introduction to Google Test: An Open Source C/C++ Unit-Testing Framework

Integrate unit tests easily in your projects

Photo by Mitchell Luo on Unsplash

Unit tests are our first line of defense against regressive code changes.
It provides software developers fast feedback about their code at a fine-grained level.

In this article, I’ll demonstrate how easy it is to add unit tests to your C/C++ project with google test.

Simple Start

Let’s look at a simple example of calculating the mean value out of an array of integers.

calculate_meantakes as input an array of integers and its length; it returns as output the mean of the array (the sum of the array divided by its length) as a float number.

File Structure

+ Root
  + modules
    - calculations.c
    - calculations.h
    - CMakeLists.txt
  + tests
    - test_calculations.cpp
    - CMakeLists.txt
  - mainapp.c
  - CMakeLists.txt
  - conanfile.txt

Note: all the code for this demo can be found on my GitHub account.

modules/calculations.c

This is a module responsible for calculations:

modules/calculations.c

Very straightforward.

It has a function to calculate the sum of the numbers, and it is called on the calculate_mean function, then the division between the sum and the length is returned.

Now let’s consume this code in the mainapp:

mainapp.c

mainapp.c

And now we need two CMakeLists.txt files: one for the mainapp and one for the modules:

CMakeLists.txt

cmake_minimum_required(VERSION 3.10.2) 
project(MyProject)

add_subdirectory(modules)

add_executable(${PROJECT_NAME} mainapp.c)
target_link_libraries(${PROJECT_NAME} calculations)

modules/CMakeLists.txt

project(calculations) 
add_library(calculations calculations.c calculations.h)

In short, the modules CMakeLists generates a library called calculationsand the main CMakeLists consumes the library and links it to the main executable.

Now, let's compile and run.

Compile:

cmake --build ./build --config Debug --target MyProject -j 10 --

Run:

./build/MyProject

The output is:

Mean=5.78

Introducing Google Test

Google test, or gtest is an open source framework for unit testing C\C++ projects.

It easily integrates with CMake, has a great assertion engine, and produces XML reports to be for display so that it can be integrated with common CI\CD frameworks.

Step 1. install gtest from Conan

To learn more about Conan, read my article here.

Let's create the conanfile.txt in the root directory:

[requires]
gtest/cci.20210126
[generators]
cmake

run — conan install . -pr=myprofile

Step 2. add gtest to CMakeLists

Having gtest installed, let's add it as a dependency to the main CMakeLists file:

cmake_minimum_required(VERSION 3.10.2)
project(MyProject)
include(${CMAKE_SOURCE_DIR}/conanbuildinfo.cmake)
conan_basic_setup()
add_subdirectory(modules)
add_subdirectory(tests)
add_executable(${PROJECT_NAME} mainapp.c)
target_link_libraries(${PROJECT_NAME} calculations)

We’ve added four lines, one to include the configurations by Conan, two to run the Conan CMake set up, and one to add the tests directory.

Step 3. write the test suite

tests/test_calculations.cpp

This is the actual test case to be executed.

In total there are five test cases covering various possible scenarios.

Step 4. configure tests executable with CMake

tests/CMakeLists.txt

cmake_minimum_required(VERSION 3.10.2)
project(tests)
add_executable(${PROJECT_NAME} test_calculations.cpp)
set(CMAKE_CXX_STANDARD 11)
target_link_libraries(${PROJECT_NAME} PUBLIC
calculations
gtest
gtest_main
)

The instructions here are to create an executable called tests with three linked libraries, calculations (the module we want to test), gtest and gtest_main.

Step 5. Run your tests

Compile:

cmake --build ./build --config Debug --target tests -j 10 --

Run:

build\bin\tests.exe

Output:

[==========] Running 5 tests from 1 test suite.
[----------] Global test environment set-up.
[----------] 5 tests from test_calculations
[ RUN      ] test_calculations.simple_arr
[       OK ] test_calculations.simple_arr (0 ms)
[ RUN      ] test_calculations.empty_arr
[       OK ] test_calculations.empty_arr (0 ms)
[ RUN      ] test_calculations.all_negatives
[       OK ] test_calculations.all_negatives (0 ms)
[ RUN      ] test_calculations.mix_negative_positive
[       OK ] test_calculations.mix_negative_positive (0 ms)
[ RUN      ] test_calculations.with_zeros
[       OK ] test_calculations.with_zeros (0 ms)
[----------] 5 tests from test_calculations (70 ms total)
[----------] Global test environment tear-down
[==========] 5 tests from 1 test suite ran. (107 ms total)
[  PASSED  ] 5 tests.

Awesome! All five tests got executed and passed!

Now let’s run it again and export the results to output.xml:

build/bin/tests --gtest_output=xml:output.xml

The XML output looks like this:

<?xml version="1.0" encoding="UTF-8"?>
<testsuites tests="5" failures="0" disabled="0" errors="0" time="0.083" timestamp="2022-02-16T12:57:20.151" name="AllTests">
<testsuite name="test_calculations" tests="5" failures="0" disabled="0" skipped="0" errors="0" time="0.055" timestamp="2022-02-16T12:57:20.166">
<testcase name="simple_arr" status="run" result="completed" time="0" timestamp="2022-02-16T12:57:20.171" classname="test_calculations" />
<testcase name="empty_arr" status="run" result="completed" time="0" timestamp="2022-02-16T12:57:20.181" classname="test_calculations" />
<testcase name="all_negatives" status="run" result="completed" time="0" timestamp="2022-02-16T12:57:20.192" classname="test_calculations" />
<testcase name="mix_negative_positive" status="run" result="completed" time="0" timestamp="2022-02-16T12:57:20.204" classname="test_calculations" />
<testcase name="with_zeros" status="run" result="completed" time="0" timestamp="2022-02-16T12:57:20.216" classname="test_calculations" />
</testsuite>
</testsuites>

Let's load this into codebeautify’s xunit viewer:

xunit view

Beautiful!

This can be easily published as a test result on your ci/cd pipelines :).