Tests en C++ : Tests Unitaires, d'Intégration et E2E avec exemples

Formateur Python en ligne pour débutants

Apprenez Python facilement sans surcharge théorique. Résolvez des tâches pratiques avec vérification automatique et écrivez du code directement dans le navigateur.

Start Course

Introduction : Pourquoi les tests sont essentiels pour les projets C++

Tester le code en C++ n'est pas une simple formalité, mais une pratique fondamentale qui garantit la stabilité, la sécurité et la maintenabilité des logiciels. Contrairement aux langages interprétés, où une erreur peut se manifester instantanément, en C++, les bogues restent souvent cachés jusqu'à la compilation ou l'exécution dans des conditions spécifiques. Une fuite de mémoire manquée, un comportement indéfini ou une gestion incorrecte des pointeurs peuvent entraîner des pannes fatales.

L'industrie moderne du développement distingue trois niveaux principaux de tests : Unit (tests unitaires), Integration (tests d'intégration) et E2E (tests de bout en bout). Chacun répond à un objectif spécifique et, ensemble, ils forment la "pyramide des tests", permettant de détecter jusqu'à 90% des bogues avant la mise en production.

Dans cet article, nous analyserons chaque type de test avec des exemples pratiques en C++, en utilisant les frameworks populaires Google Test et Catch2, et nous discuterons des meilleures pratiques pour leur mise en œuvre.

1. Tests Unitaires : Vérification des modules atomiques

Les tests unitaires constituent le niveau le plus bas et le plus rapide. Ils vérifient des fonctions, classes ou méthodes individuelles isolées du reste du système. L'objectif est de s'assurer que chaque "brique" de code fonctionne correctement.

Exemple de test unitaire avec Google Test

Considérons une fonction mathématique simple :

// math_utils.h#pragma once

namespace MathUtils {    int add(int a, int b);    int divide(int a, int b);}

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

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

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

Écrivons maintenant des tests unitaires avec Google Test :

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

TEST(MathUtilsTest, AddPositiveNumbers) {    EXPECT_EQ(MathUtils::add(2, 3), 5);    EXPECT_EQ(MathUtils::add(0, 0), 0);}

TEST(MathUtilsTest, AddNegativeNumbers) {    EXPECT_EQ(MathUtils::add(-1, -1), -2);    EXPECT_EQ(MathUtils::add(-5, 3), -2);}

TEST(MathUtilsTest, DivideNormal) {    EXPECT_EQ(MathUtils::divide(10, 2), 5);    EXPECT_EQ(MathUtils::divide(7, 3), 2); // Division entière}

TEST(MathUtilsTest, DivideByZeroThrows) {    EXPECT_THROW(MathUtils::divide(5, 0), std::invalid_argument);}

Utilisation d'objets Mock

Pour isoler un module, il est souvent nécessaire de simuler les dépendances. Google Mock (partie de Google Test) permet de créer des bouchons :

// database_interface.hclass DatabaseInterface {public:    virtual ~DatabaseInterface() = default;    virtual bool save(const std::string& data) = 0;};

// user_service.cppclass UserService {    DatabaseInterface& db;public:    explicit UserService(DatabaseInterface& db) : db(db) {}    bool registerUser(const std::string& name) {        return db.save("user:" + name);    }};

// test_user_service.cpp#include <gmock/gmock.h>

class MockDatabase : public DatabaseInterface {public:    MOCK_METHOD(bool, save, (const std::string&), (override));};

TEST(UserServiceTest, RegisterUserCallsDb) {    MockDatabase mockDb;    EXPECT_CALL(mockDb, save("user:Alice")).WillOnce(testing::Return(true));

    UserService service(mockDb);    EXPECT_TRUE(service.registerUser("Alice"));}

Avantages : Vitesse d'exécution (millisecondes), localisation précise des erreurs, possibilité de les exécuter sans dépendances externes.
Inconvénients : Ils ne vérifient pas les interactions entre les composants réels.