Tests en C++ : frameworks et outils pour vérifier le code

Tests en C++ : aperçu des frameworks et outils

Le test est une partie essentielle du développement professionnel en C++. Contrairement aux langages à typage dynamique, le C++ nécessite une attention particulière à la gestion de la mémoire, au RAII et aux métaprogrammes basés sur les templates. Sans tests de qualité, même une petite refactorisation peut entraîner des erreurs difficiles à détecter. Dans cet article, nous examinerons les principaux frameworks de tests unitaires en C++, leurs caractéristiques et des exemples d'utilisation.

Pourquoi tester le code C++ ?

Les principales raisons d'adopter les tests :

• Sécurité de la refactorisation — les tests figent le comportement correct avant les modifications.
• Documentation — les tests montrent comment utiliser l'API.
• Détection des régressions — vérification automatique après chaque commit.
• Validation des cas limites — gestion de nullptr, conteneurs vides, débordements.

Frameworks populaires pour C++

1. Google Test (gtest)

Le framework le plus répandu, développé par Google. Il prend en charge l'enregistrement automatique des tests, les macros ASSERT_* et EXPECT_*, les tests paramétrés, et les mocks via Google Mock.

#include <gtest/gtest.h>

int add(int a, int b) { return a + b; }

TEST(AdditionTest, PositiveNumbers) {    EXPECT_EQ(add(2, 3), 5);    EXPECT_EQ(add(0, 0), 0);}

TEST(AdditionTest, NegativeNumbers) {    EXPECT_EQ(add(-1, -2), -3);}

int main(int argc, char **argv) {    ::testing::InitGoogleTest(&argc, argv);    return RUN_ALL_TESTS();}

Caractéristiques :

• Prise en charge des tests de défaillance (death tests) pour vérifier les assert.
• Fabrique de mocks (gmock) pour isoler les dépendances.
• Intégration avec CMake (find_package(GTest)).

2. Catch2

Framework moderne avec une syntaxe expressive. Il ne nécessite pas d'enregistrement séparé des tests — la macro TEST_CASE suffit. Il prend en charge le style BDD (Given-When-Then).

#include <catch2/catch_test_macros.hpp>

int factorial(int n) {    return n <= 1 ? 1 : n * factorial(n - 1);}

TEST_CASE("Factorials are computed", "[math]") {    REQUIRE(factorial(0) == 1);    REQUIRE(factorial(1) == 1);    REQUIRE(factorial(5) == 120);}

TEST_CASE("Negative input", "[math][edge]") {    REQUIRE_THROWS_AS(factorial(-1), std::domain_error);}

Caractéristiques :

• Génération de données de test (GENERATE).
• Division des tests en sections (SECTION).
• Sélection automatique de main() (si CATCH_CONFIG_MAIN est défini).

3. doctest

Framework léger et rapide, avec un temps de compilation minimal. Idéal pour les projets où la vitesse de construction est importante. La syntaxe ressemble à celle de Catch2.

#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN#include <doctest/doctest.h>

int divide(int a, int b) {    if (b == 0) throw std::invalid_argument("division by zero");    return a / b;}

TEST_CASE("Division") {    CHECK(divide(10, 2) == 5);    CHECK_THROWS_AS(divide(5, 0), std::invalid_argument);}

Caractéristiques :

• Compilation très rapide (fichier d'en-tête d'environ 5 Ko).
• Prise en charge des macros CHECK, REQUIRE, WARN.
• Reporteur intégré en XML/JSON.

4. Boost.Test

Partie des bibliothèques Boost. Il offre de nombreuses fonctionnalités, mais nécessite plus de code boilerplate. Il prend en charge l'enregistrement automatique et manuel des tests.

#define BOOST_TEST_MODULE MyTest#include <boost/test/included/unit_test.hpp>

BOOST_AUTO_TEST_SUITE(MathTests)

BOOST_AUTO_TEST_CASE(TestSum) {    BOOST_CHECK_EQUAL(2 + 2, 4);    BOOST_CHECK_CLOSE(3.14159, 3.14, 0.1); // précision 0.1%}

BOOST_AUTO_TEST_CASE(TestFail) {    BOOST_REQUIRE_MESSAGE(false, "This test always fails");}

BOOST_AUTO_TEST_SU