C++ Academy · Les

Mocking met GMock

Mock afhankelijkheden

Les 4 van 413 stappen

Mocking met GMock is een gratis C++ Academy-les op CoddyKit. Dit is les 4 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject C++ Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus C++ Academy bevat in totaal 4 lessen.

Waarom nepobjecten gebruiken?

GMock maakt nepobjecten die aanroepen registreren en geprogrammeerde resultaten teruggeven. Nepobjecten isoleren de geteste eenheid van trage of onvoorspelbare afhankelijkheden, zoals databases of netwerken.

Begin met een koppelvlak

Afhankelijkheden waarvoor je nepobjecten kunt gebruiken, zijn meestal abstracte basisklassen met virtuele methoden.

#include <string>

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

Een nepklasse definiëren

Gebruik MOCK_METHOD om voor elke virtuele methode een nepimplementatie te genereren. Geef het retourtype, de naam, de argumenten en de kwalificaties op.

#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));
};

Verwachtingen instellen

EXPECT_CALL beschrijft hoe een nep-methode moet worden aangeroepen en wat deze teruggeeft. WillOnce(Return(...)) programmeert het resultaat.

#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");
}

Argumentmatchers

Verwachtingen kunnen argumenten losjes vergelijken met matchers zoals _ (willekeurig), Gt(5) of HasSubstr("x").

#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");
}

Kardinaliteit

Geef met Times aan hoe vaak een aanroep wordt verwacht.

Times(1) precies één keer
Times(AtLeast(2))
Times(0) mag nooit worden aangeroepen

#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);
}

Retouracties

Acties bepalen het gedrag.

Return(value)
ReturnRef(ref)
Throw(exception)
Invoke(callable) om aangepaste code uit te voeren

De mock injecteren

De te testen eenheid moet de afhankelijkheid accepteren via een pointer of referentie naar de interface. Dit is dependency injection en maakt mocken mogelijk.

#include <string>

class Database;

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

Interacties verifiëren

GMock verifieert alle verwachtingen van EXPECT_CALL wanneer de mock wordt vernietigd. Niet-ingeloste verwachtingen (verkeerd aantal of ontbrekende aanroepen) laten de test automatisch mislukken.

Nice-, Strict- en Naggy-mocks

Bepaal hoe onverwachte aanroepen worden behandeld.

NiceMock: negeert oninteressante aanroepen
StrictMock: elke onverwachte aanroep laat de test mislukken
Standaard (waarschuwend): geeft waarschuwingen bij oninteressante aanroepen

Mock alleen wat je zelf beheert

Mock bij voorkeur je eigen interfaces, niet concrete klassen van derden. Introduceer dunne wrapperinterfaces rond externe bibliotheken, zodat tests stabiel blijven.

Snelle controle

Haal terug wanneer GMock de verwachtingen controleert.

Beantwoord dit in de interactieve les

Samenvatting

Je hebt GMock geleerd.

Mock virtuele interfaces met MOCK_METHOD
EXPECT_CALL + acties programmeren het gedrag
Matchers en Times bepalen de argumenten en kardinaliteit
Injecteer mocks; verwachtingen worden bij vernietiging geverifieerd

Gratis beginnen

Leer C++ met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 51
Lessen: 203

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Mocking met GMock” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad C++ Academy, waaronder “Mocking met GMock”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus C++ Academy bevat in totaal 4 lessen.

Wat leer ik in “Mocking met GMock”?

Mock afhankelijkheden Je oefent met C++ Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met C++ Academy te beginnen?

Ervaring vooraf is niet nodig. C++ Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.

Hoe lang duurt de les “Mocking met GMock”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over C++ Academy?

Ja. Elke les over C++ Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar C++ Academy