Tests en C++ : Unit, Intégration et E2E. Guide complet

Introduction : Pourquoi les tests en C++ ne sont pas un luxe, mais une nécessité

Le développement en C++ est toujours un équilibre entre performance et fiabilité. Les erreurs de gestion de la mémoire, les comportements indéfinis (UB) et les dépendances complexes entre modules font du C++ l'un des langages les plus exigeants en matière de qualité de code. Sans une approche systématique des tests, un projet se transforme rapidement en « boîte noire », où la correction d'un bug en génère deux nouveaux.

Dans cet article, nous allons détailler trois niveaux clés de tests en C++ : les tests unitaires, les tests d'intégration et les tests e2e (de bout en bout). Vous découvrirez quels outils utiliser, comment écrire des tests efficaces et comment construire une pyramide de tests pour un projet C++.

1. Tests unitaires : Vérifier chaque brique

Les tests unitaires sont la base de la pyramide de tests. Ils vérifient de manière isolée une unité logique de code : une fonction, une méthode de classe ou une petite structure. En C++, les tests unitaires doivent s'exécuter rapidement (<1 seconde pour des centaines de tests) et ne pas dépendre de ressources externes (système de fichiers, réseau, bases de données).

Outils pour les tests unitaires en C++

• Google Test (gtest) — le framework le plus populaire de Google. Il prend en charge les macros d'assertion, les fixtures et les tests paramétrés.
• Catch2 — une alternative moderne avec une syntaxe concise et le support du style BDD.
• Boost.Test — fait partie de la bibliothèque Boost, un outil mature avec de nombreuses fonctionnalités.

Exemple de test unitaire avec Google Test

Supposons que nous ayons une fonction de calcul de factorielle :

// math_utils.h#pragma onceunsigned long long factorial(unsigned int n);

// math_utils.cpp#include "math_utils.h"

unsigned long long factorial(unsigned int n) {    if (n == 0) return 1;    unsigned long long result = 1;    for (unsigned int i = 1; i <= n; ++i) {        result *= i;    }    return result;}

Nous écrivons le test unitaire :

// test_math_utils.cpp#include <gtest/gtest.h>#include "math_utils.h"

TEST(FactorialTest, HandlesZero) {    EXPECT_EQ(factorial(0), 1);}

TEST(FactorialTest, HandlesPositiveNumbers) {    EXPECT_EQ(factorial(1), 1);    EXPECT_EQ(factorial(5), 120);    EXPECT_EQ(factorial(10), 3628800);}

TEST(FactorialTest, HandlesLargeInput) {    // 20! tient dans un unsigned long long    EXPECT_EQ(factorial(20), 2432902008176640000ULL);}

Bonnes pratiques pour les tests unitaires en C++ :

• Un test — une vérification. Utilisez EXPECT_EQ pour les vérifications souples et ASSERT_EQ pour les vérifications critiques.
• Isolez les dépendances via des objets mock (Google Mock).
• Testez les cas limites : valeurs nulles, dépassement de capacité, conteneurs vides.
• Utilisez TEST_F pour une initialisation répétée (fixtures).

2. Tests d'intégration : Comment les modules fonctionnent ensemble

Les tests d'intégration vérifient l'interaction entre plusieurs modules ou composants. En C++, c'est particulièrement important car les erreurs surviennent souvent aux interfaces : mauvaise gestion de la mémoire lors du passage d'objets, inadéquation des interfaces ou problèmes de multithreading.

Contrairement aux tests unitaires, les tests d'intégration peuvent fonctionner avec de vraies bases de données, des fichiers ou des sockets réseau, mais généralement dans un environnement de test (par exemple, fichiers temporaires ou conteneurs Docker).

Exemple de test d'intégration

Supposons que nous ayons un module Logger et un module FileManager. Nous voulons vérifier que les logs sont correctement écrits dans un fichier.

// file_logger.h#pragma once#include <string>

class FileLogger {public:    FileLogger(const std::string& filename);    vo