Test C++

Test C++ (Compétence Agent)

Workflow de test orienté agent pour le C++ moderne (C++17/20) utilisant GoogleTest/GoogleMock avec CMake/CTest.

Quand l'utiliser

• Écrire de nouveaux tests C++ ou corriger des tests existants
• Concevoir la couverture de tests unitaires/d'intégration pour des composants C++
• Ajouter de la couverture de test, un blocage CI ou une protection contre les régressions
• Configurer des workflows CMake/CTest pour une exécution cohérente
• Enquêter sur des échecs de test ou un comportement instable
• Activer les sanitizers pour les diagnostics mémoire/race

Quand NE PAS l'utiliser

• Implémenter de nouvelles fonctionnalités sans modifications de test
• Refontes à grande échelle non liées à la couverture de test ou aux échecs
• Réglage des performances sans régressions de test à valider
• Projets non C++ ou tâches non liées aux tests

Concepts clés

• Boucle TDD : rouge → vert → refactor (tests d'abord, correction minimale, puis nettoyage).
• Isolation : privilégier l'injection de dépendances et les fakes plutôt que l'état global.
• Disposition des tests : tests/unit, tests/integration, tests/testdata.
• Mocks vs fakes : mock pour les interactions, fake pour le comportement avec état.
• Découverte CTest : utiliser gtest_discover_tests() pour une découverte stable des tests.
• Signal CI : exécuter d'abord un sous-ensemble, puis la suite complète avec --output-on-failure.

Workflow TDD

Suivez la boucle ROUGE → VERT → REFACTOR :

1. ROUGE : écrire un test qui échoue et capture le nouveau comportement
2. VERT : implémenter le plus petit changement pour réussir
3. REFACTOR : nettoyer pendant que les tests restent verts

// tests/add_test.cpp
#include <gtest/gtest.h>

int Add(int a, int b); // Fourni par le code de production.

TEST(AddTest, AddsTwoNumbers) { // ROUGE
  EXPECT_EQ(Add(2, 3), 5);
}

// src/add.cpp
int Add(int a, int b) { // VERT
  return a + b;
}

// REFACTOR : simplifier/renommer une fois les tests passés

Exemples de code

Test unitaire de base (gtest)

// tests/calculator_test.cpp
#include <gtest/gtest.h>

int Add(int a, int b); // Fourni par le code de production.

TEST(CalculatorTest, AddsTwoNumbers) {
    EXPECT_EQ(Add(2, 3), 5);
}

Fixture (gtest)

// tests/user_store_test.cpp
// Stub pseudo-code : remplacer UserStore/User par les types du projet.
#include <gtest/gtest.h>
#include <memory>
#include <optional>
#include <string>

struct User { std::string name; };
class UserStore {
public:
    explicit UserStore(std::string /*path*/) {}
    void Seed(std::initializer_list<User> /*users*/) {}
    std::optional<User> Find(const std::string &/*name*/) { return User{"alice"}; }
};

class UserStoreTest : public ::testing::Test {
protected:
    void SetUp() override {
        store = std::make_unique<UserStore>(":memory:");
        store->Seed({{"alice"}, {"bob"}});
    }

    std::unique_ptr<UserStore> store;
};

TEST_F(UserStoreTest, FindsExistingUser) {
    auto user = store->Find("alice");
    ASSERT_TRUE(user.has_value());
    EXPECT_EQ(user->name, "alice");
}

Mock (gmock)

// tests/notifier_test.cpp
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <string>

class Notifier {
public:
    virtual ~Notifier() = default;
    virtual void Send(const std::string &message) = 0;
};

class MockNotifier : public Notifier {
public:
    MOCK_METHOD(void, Send, (const std::string &message), (override));
};

class Service {
public:
    explicit Service(Notifier &notifier) : notifier_(notifier) {}
    void Publish(const std::string &message) { notifier_.Send(message); }

private:
    Notifier &notifier_;
};

TEST(ServiceTest, SendsNotifications) {
    MockNotifier notifier;
    Service service(notifier);

    EXPECT_CALL(notifier, Send("hello")).Times(1);
    service.Publish("hello");
}

Démarrage rapide CMake/CTest

# CMakeLists.txt (extrait)
cmake_minimum_required(VERSION 3.20)
project(example LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

include(FetchContent)
# Privilégier les versions verrouillées par projet. Si vous utilisez un tag, utilisez une version épinglée selon la politique du projet.
set(GTEST_VERSION v1.17.0) # Ajuster à la politique du projet.
FetchContent_Declare(
  googletest
  # Google Test framework (dépôt officiel)
  URL https://github.com/google/googletest/archive/refs/tags/${GTEST_VERSION}.zip
)
FetchContent_MakeAvailable(googletest)

add_executable(example_tests
  tests/calculator_test.cpp
  src/calculator.cpp
)
target_link_libraries(example_tests GTest::gtest GTest::gmock GTest::gtest_main)

enable_testing()
include(GoogleTest)
gtest_discover_tests(example_tests)

cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug
cmake --build build -j
ctest --test-dir build --output-on-failure

Exécution des tests

ctest --test-dir build --output-on-failure
ctest --test-dir build -R ClampTest
ctest --test-dir build -R "UserStoreTest.*" --output-on-failure

./build/example_tests --gtest_filter=ClampTest.*
./build/example_tests --gtest_filter=UserStoreTest.FindsExistingUser

Débogage des échecs

1. Réexécuter le seul test qui échoue avec un filtre gtest.
2. Ajouter une journalisation ciblée autour de l'assertion qui échoue.
3. Réexécuter avec les sanitizers activés.
4. Étendre à la suite complète une fois la cause racine corrigée.

Couverture

Privilégier les paramètres au niveau de la cible plutôt que des flags globaux.

option(ENABLE_COVERAGE "Activer les flags de couverture" OFF)

if(ENABLE_COVERAGE)
  if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
    target_compile_options(example_tests PRIVATE --coverage)
    target_link_options(example_tests PRIVATE --coverage)
  elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
    target_compile_options(example_tests PRIVATE -fprofile-instr-generate -fcoverage-mapping)
    target_link_options(example_tests PRIVATE -fprofile-instr-generate)
  endif()
endif()

GCC + gcov + lcov :

cmake -S . -B build-cov -DENABLE_COVERAGE=ON
cmake --build build-cov -j
ctest --test-dir build-cov
lcov --capture --directory build-cov --output-file coverage.info
lcov --remove coverage.info '/usr/*' --output-file coverage.info
genhtml coverage.info --output-directory coverage

Clang + llvm-cov :

cmake -S . -B build-llvm -DENABLE_COVERAGE=ON -DCMAKE_CXX_COMPILER=clang++
cmake --build build-llvm -j
LLVM_PROFILE_FILE="build-llvm/default.profraw" ctest --test-dir build-llvm
llvm-profdata merge -sparse build-llvm/default.profraw -o build-llvm/default.profdata
llvm-cov report build-llvm/example_tests -instr-profile=build-llvm/default.profdata

Sanitizers

option(ENABLE_ASAN "Activer AddressSanitizer" OFF)
option(ENABLE_UBSAN "Activer UndefinedBehaviorSanitizer" OFF)
option(ENABLE_TSAN "Activer ThreadSanitizer" OFF)

if(ENABLE_ASAN)
  add_compile_options(-fsanitize=address -fno-omit-frame-pointer)
  add_link_options(-fsanitize=address)
endif()
if(ENABLE_UBSAN)
  add_compile_options(-fsanitize=undefined -fno-omit-frame-pointer)
  add_link_options(-fsanitize=undefined)
endif()
if(ENABLE_TSAN)
  add_compile_options(-fsanitize=thread)
  add_link_options(-fsanitize=thread)
endif()

Garde-fous pour les tests instables

• Ne jamais utiliser sleep pour la synchronisation ; utiliser des variables de condition ou des barrières.
• Rendre les répertoires temporaires uniques par test et toujours les nettoyer.
• Éviter le temps réel, le réseau ou les dépendances système de fichiers dans les tests unitaires.
• Utiliser des graines déterministes pour les entrées aléatoires.

Bonnes pratiques

À FAIRE

• Garder les tests déterministes et isolés
• Privilégier l'injection de dépendances plutôt que les globales
• Utiliser ASSERT_* pour les préconditions, EXPECT_* pour les vérifications multiples
• Séparer les tests unitaires et d'intégration dans les labels ou répertoires CTest
• Exécuter les sanitizers dans la CI pour la détection mémoire et de race

À NE PAS FAIRE

• Ne pas dépendre du temps réel ou du réseau dans les tests unitaires
• Ne pas utiliser de sleep comme synchronisation quand une variable de condition peut être utilisée
• Ne pas sur-mocker les objets de valeur simples
• Ne pas utiliser de correspondance de chaîne fragile pour les logs non critiques

Pièges courants

• Utiliser des chemins temporaires fixes → Générer des répertoires temporaires uniques par test et les nettoyer.
• Se fier au temps horloge → Injecter une horloge ou utiliser des sources de temps factices.
• Tests de concurrence instables → Utiliser des variables de condition/barrières et des attentes bornées.
• État global caché → Réinitialiser l'état global dans les fixtures ou supprimer les globales.
• Sur-mockage → Privilégier les fakes pour le comportement avec état et ne mocker que les interactions.
• Exécutions de sanitizers manquantes → Ajouter des builds ASan/UBSan/TSan dans la CI.
• Couverture sur des builds debug uniquement → S'assurer que les cibles de couverture utilisent des flags cohérents.

Annexe optionnelle : Fuzzing / Test de propriétés

À utiliser uniquement si le projet prend déjà en charge LLVM/libFuzzer ou une bibliothèque de test de propriétés.

• libFuzzer : meilleur pour les fonctions pures avec un minimum d'E/S.
• RapidCheck : tests basés sur les propriétés pour valider des invariants.

Harnais minimal libFuzzer (pseudo-code : remplacer ParseConfig) :

#include <cstddef>
#include <cstdint>
#include <string>

extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
    std::string input(reinterpret_cast<const char *>(data), size);
    // ParseConfig(input); // fonction du projet
    return 0;
}

Alternatives à GoogleTest

• Catch2 : header-only, matchers expressifs
• doctest : léger, overhead de compilation minimal