C++ Academy · Lektion

Mocking mit GMock

Abhängigkeiten mocken

Mocking mit GMock ist eine kostenlose C++ Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C++ Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.

Warum Mocking?

GMock erstellt simulierte Objekte, die Aufrufe aufzeichnen und programmierte Ergebnisse zurückgeben. Mocking isoliert die zu testende Einheit von langsamen oder unvorhersehbaren Abhängigkeiten wie Datenbanken oder Netzwerken.

Mit einem Interface beginnen

Mockbare Abhängigkeiten sind normalerweise abstrakte Basisklassen mit virtuellen Methoden.

#include <string>

class Database {
public:
    virtual ~Database() = default;
    virtual std::string get(int id) = 0;
    virtual bool save(const std::string& v) = 0;
};

Eine Mock-Klasse definieren

Verwenden Sie MOCK_METHOD, um für jede virtuelle Methode einen Mock zu erzeugen. Geben Sie dabei Rückgabetyp, Namen, Argumente und Qualifizierer an.

#include <gmock/gmock.h>
#include <string>

class Database {
public:
    virtual ~Database() = default;
    virtual std::string get(int id) = 0;
};

class MockDatabase : public Database {
public:
    MOCK_METHOD(std::string, get, (int id), (override));
};

Erwartungen festlegen

EXPECT_CALL legt fest, wie eine Mock-Methode aufgerufen werden soll und was sie zurückgibt. WillOnce(Return(...)) programmiert das Ergebnis.

#include <gmock/gmock.h>
using ::testing::Return;

TEST(DbTest, ReturnsValue) {
    MockDatabase db;
    EXPECT_CALL(db, get(1)).WillOnce(Return("alice"));
    EXPECT_EQ(db.get(1), "alice");
}

Argument-Matcher

Erwartungen können Argumente mithilfe von Matchern wie _ (beliebig), Gt(5) oder HasSubstr("x") flexibel abgleichen.

#include <gmock/gmock.h>
using ::testing::_;
using ::testing::Return;

TEST(DbTest, AnyId) {
    MockDatabase db;
    EXPECT_CALL(db, get(_)).WillRepeatedly(Return("x"));
    EXPECT_EQ(db.get(99), "x");
}

Kardinalität

Mit Times geben Sie an, wie oft ein Aufruf erwartet wird.

Times(1) genau einmal
Times(AtLeast(2))
Times(0) darf nie aufgerufen werden

#include <gmock/gmock.h>
using ::testing::AtLeast;
using ::testing::Return;

TEST(DbTest, CalledTwice) {
    MockDatabase db;
    EXPECT_CALL(db, get(1)).Times(AtLeast(2)).WillRepeatedly(Return("v"));
    db.get(1);
    db.get(1);
}

Rückgabeaktionen

Aktionen legen das Verhalten fest.

Return(value)
ReturnRef(ref)
Throw(exception)
Invoke(callable), um eigenen Code auszuführen

Mock injizieren

Die zu testende Einheit muss die Abhängigkeit über einen Zeiger oder eine Referenz auf das Interface annehmen. Das ist Dependency Injection und ermöglicht überhaupt erst das Mocking.

#include <string>

class Database;

class UserService {
    Database& db;
public:
    UserService(Database& d) : db(d) {}
    std::string name(int id);
};

Interaktionen überprüfen

GMock überprüft alle EXPECT_CALL-Erwartungen, wenn der Mock zerstört wird. Nicht erfüllte Erwartungen (falsche Anzahl oder fehlende Aufrufe) lassen den Test automatisch fehlschlagen.

Nice-, Strict- und Naggy-Mocks

Steuern Sie, wie unerwartete Aufrufe behandelt werden.

NiceMock: uninteressante Aufrufe ignorieren
StrictMock: jeder unerwartete Aufruf lässt den Test fehlschlagen
Standardverhalten (naggy): warnt bei uninteressanten Aufrufen

Mocken Sie nur, was Ihnen gehört

Mocken Sie vorzugsweise Ihre eigenen Interfaces statt konkreter Klassen von Drittanbietern. Führen Sie dünne Wrapper-Interfaces um externe Bibliotheken ein, damit Tests stabil bleiben.

Schnelltest

Rufen Sie sich in Erinnerung, wann GMock Erwartungen überprüft.

Zusammenfassung

Sie haben GMock kennengelernt.

Mocken Sie virtuelle Interfaces mit MOCK_METHOD
EXPECT_CALL und Aktionen programmieren das Verhalten
Matcher und Times steuern Argumente und Kardinalität
Injizieren Sie Mocks; Erwartungen werden bei der Zerstörung überprüft

Häufig gestellte Fragen

Ist die Lektion „Mocking mit GMock“ kostenlos?

Ja — der vollständige Text von „Mocking mit GMock“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C++ Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Mocking mit GMock“?

Abhängigkeiten mocken Du übst C++ Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C++ Academy zu starten?

Keine Vorkenntnisse erforderlich. C++ Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Mocking mit GMock“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C++ Academy-Lektion Code schreiben und ausführen?

Ja. Jede C++ Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu C++ Academy