C++-Testing

C++-Testing (Agenten-Skill)

Agentenfokussierter Test-Workflow für modernes C++ (C++17/20) mit GoogleTest/GoogleMock und CMake/CTest.

Wann verwenden

• Neue C++-Tests schreiben oder bestehende Tests reparieren
• Unit-/Integrationstest-Abdeckung für C++-Komponenten entwerfen
• Testabdeckung, CI-Gates oder Regression Protection hinzufügen
• CMake/CTest-Workflows für konsistente Ausführung konfigurieren
• Testfehler oder flaky Verhalten untersuchen
• Sanitizer für Speicher-/Race-Diagnose aktivieren

Wann NICHT verwenden

• Neue Produktfunktionen ohne Teständerungen implementieren
• Großflächige Refactorings ohne Bezug zu Testabdeckung oder -fehlern
• Performance-Tuning ohne Testregressionen zur Validierung
• Nicht-C++-Projekte oder Nicht-Test-Aufgaben

Kernkonzepte

• TDD-Zyklus: Rot → Grün → Refactoring (zuerst Tests, minimaler Fix, dann Bereinigung).
• Isolation: Bevorzuge Dependency Injection und Fakes gegenüber globalem Zustand.
• Test-Layout: tests/unit, tests/integration, tests/testdata.
• Mocks vs. Fakes: Mock für Interaktionen, Fake für zustandsbehaftetes Verhalten.
• CTest-Erkennung: Verwende gtest_discover_tests() für stabile Testerkennung.
• CI-Signal: Zuerst Teilmenge ausführen, dann vollständige Suite mit --output-on-failure.

TDD-Workflow

Folge dem ROT → GRÜN → REFACTOR-Zyklus:

1. ROT: Schreibe einen fehlschlagenden Test, der das neue Verhalten erfasst.
2. GRÜN: Implementiere die kleinste Änderung, um den Test zu bestehen.
3. REFACTOR: Bereinige den Code, während die Tests grün bleiben.

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

int Add(int a, int b); // Wird vom Produktionscode bereitgestellt.

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

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

// REFACTOR: vereinfachen/umbenennen, sobald Tests bestehen

Codebeispiele

Basistest (gtest)

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

int Add(int a, int b); // Wird vom Produktionscode bereitgestellt.

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

Fixture (gtest)

// tests/user_store_test.cpp
// Pseudocode-Stub: Ersetze UserStore/User durch Projekttypen.
#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");
}

CMake/CTest Schnellstart

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

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

include(FetchContent)
# Bevorzuge projektgebundene Versionen. Wenn ein Tag verwendet wird, verwende eine festgelegte Version gemäß Projektrichtlinie.
set(GTEST_VERSION v1.17.0) # An Projektrichtlinie anpassen.
FetchContent_Declare(
  googletest
  # Google Test Framework (offizielles Repository)
  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

Tests ausführen

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

Fehlerdiagnose

1. Führe den einzelnen fehlschlagenden Test mit gtest-Filter erneut aus.
2. Füge eingegrenztes Logging um die fehlschlagende Assertion hinzu.
3. Führe mit aktivierten Sanitizern erneut aus.
4. Erweitere auf die vollständige Suite, sobald die Ursache behoben ist.

Code Coverage

Bevorzuge zielspezifische Einstellungen anstelle globaler Flags.

option(ENABLE_COVERAGE "Coverage-Flags aktivieren" 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

Sanitizer

option(ENABLE_ASAN "AddressSanitizer aktivieren" OFF)
option(ENABLE_UBSAN "UndefinedBehaviorSanitizer aktivieren" OFF)
option(ENABLE_TSAN "ThreadSanitizer aktivieren" 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()

Flaky-Test-Schutzmaßnahmen

• Verwende niemals sleep zur Synchronisation; verwende Condition Variables oder Latches.
• Erstelle eindeutige temporäre Verzeichnisse pro Test und räume sie immer auf.
• Vermeide Echtzeit, Netzwerk oder Dateisystemabhängigkeiten in Unit-Tests.
• Verwende deterministische Seeds für zufällige Eingaben.

Best Practices

TUN

• Halte Tests deterministisch und isoliert
• Bevorzuge Dependency Injection gegenüber globalen Variablen
• Verwende ASSERT_* für Vorbedingungen, EXPECT_* für mehrere Prüfungen
• Trenne Unit- und Integrationstests in CTest-Labels oder Verzeichnissen
• Führe Sanitizer in CI zur Speicher- und Race-Erkennung aus

NICHT TUN

• Verlasse dich nicht auf Echtzeit oder Netzwerk in Unit-Tests
• Verwende keine Sleeps als Synchronisation, wenn eine Condition Variable verwendet werden kann
• Mocke einfache Wertobjekte nicht übermäßig
• Verwende keine fragilen String-Vergleiche für nicht-kritische Logs

Häufige Fallstricke

• Feste temporäre Pfade verwenden → Generiere eindeutige temporäre Verzeichnisse pro Test und räume sie auf.
• Auf Echtzeit verlassen → Injiziere eine Uhr oder verwende Fake-Zeitquellen.
• Flaky Concurrency-Tests → Verwende Condition Variables/Latches und begrenzte Wartezeiten.
• Versteckter globaler Zustand → Setze globalen Zustand in Fixtures zurück oder entferne globale Variablen.
• Übermäßiges Mocking → Bevorzuge Fakes für zustandsbehaftetes Verhalten und mocke nur Interaktionen.
• Fehlende Sanitizer-Läufe → Füge ASan/UBSan/TSan-Builds in CI hinzu.
• Coverage nur für Debug-Builds → Stelle sicher, dass Coverage-Ziele konsistente Flags verwenden.

Optionaler Anhang: Fuzzing / Property Testing

Nur verwenden, wenn das Projekt bereits LLVM/libFuzzer oder eine Property-Testing-Bibliothek unterstützt.

• libFuzzer: am besten für reine Funktionen mit minimaler I/O.
• RapidCheck: eigenschaftsbasierte Tests zur Validierung von Invarianten.

Minimaler libFuzzer-Harness (Pseudocode: Ersetze 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); // Projektfunktion
    return 0;
}

Alternativen zu Google Test

• Catch2: Header-Only, ausdrucksstarke Matcher
• doctest: leichtgewichtig, minimaler Compile-Overhead