C++ Academy · Aula

Mocking com GMock

Simule dependências

Aula 4 de 413 etapas

Mocking com GMock é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C++ Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C++ Academy inclui 4 aulas no total.

Por que usar simulações?

O GMock cria objetos fictícios que registram chamadas e retornam resultados programados. A simulação isola a unidade sob teste de dependências lentas ou imprevisíveis, como bancos de dados ou redes.

Começando com uma interface

As dependências que podem ser simuladas geralmente são classes-base abstratas com métodos virtuais.

#include <string>

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

Definindo uma classe simulada

Use MOCK_METHOD para gerar uma simulação para cada método virtual, especificando o tipo de retorno, o nome, os argumentos e os qualificadores.

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

Definindo expectativas

EXPECT_CALL declara como um método simulado deve ser chamado e o que deve retornar. WillOnce(Return(...)) programa o resultado.

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

Correspondentes de argumentos

As expectativas podem corresponder livremente aos argumentos com correspondentes como _ (qualquer valor), Gt(5) ou 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");
}

Cardinalidade

Especifique quantas vezes uma chamada é esperada com Times.

Times(1) exatamente uma vez
Times(AtLeast(2))
Times(0) nunca deve ser chamada

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

Ações de retorno

As ações determinam o comportamento.

Return(value)
ReturnRef(ref)
Throw(exception)
Invoke(callable) para executar código personalizado

Injetando a simulação

A unidade em teste deve aceitar a dependência por meio de um ponteiro ou uma referência à interface. Isso é injeção de dependência e é o que torna possível usar simulações.

#include <string>

class Database;

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

Verificando interações

O GMock verifica todas as expectativas de EXPECT_CALL quando a simulação é destruída. Expectativas não atendidas (quantidade incorreta ou chamadas ausentes) fazem o teste falhar automaticamente.

Simulações Nice, Strict e Naggy

Controle como as chamadas inesperadas são tratadas.

NiceMock: ignora chamadas desinteressantes
StrictMock: qualquer chamada inesperada causa uma falha
Padrão (insistente): avisa sobre chamadas desinteressantes

Simule apenas o que você possui

Prefira simular suas próprias interfaces, não classes concretas de terceiros. Introduza interfaces finas de encapsulamento ao redor de bibliotecas externas para manter os testes estáveis.

Verificação rápida

Relembre quando o GMock verifica as expectativas.

Responda na aula interativa

Recapitulação

Você aprendeu sobre o GMock.

Simule interfaces virtuais com MOCK_METHOD
EXPECT_CALL + ações programam o comportamento
Correspondentes e Times controlam os argumentos e a cardinalidade
Injete simulações; as expectativas são verificadas durante a destruição

Grátis para começar

Aprenda C++ com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 51
Aulas: 203

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Mocking com GMock” é grátis?

Sim — o texto completo de “Mocking com GMock” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C++ Academy, atualize para CoddyKit PRO. O curso de C++ Academy inclui 4 aulas no total.

O que vou aprender em “Mocking com GMock”?

Simule dependências Você pratica C++ Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C++ Academy?

Nenhuma experiência prévia é necessária. C++ Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Mocking com GMock”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C++ Academy?

Sim. Cada aula de C++ Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para C++ Academy