Testes em C++ (Habilidade de Agente)

Fluxo de trabalho de testes focado no agente para C++ moderno (C++17/20) usando GoogleTest/GoogleMock com CMake/CTest.

Quando Usar

• Escrevendo novos testes em C++ ou corrigindo testes existentes
• Projetando cobertura de testes unitários/de integração para componentes C++
• Adicionando cobertura de testes, bloqueio de CI (Continuous Integration) ou proteção contra regressão
• Configurando fluxos de trabalho CMake/CTest para execução consistente
• Investigando falhas de testes ou comportamento instável
• Habilitando sanitizers para diagnósticos de memória/corrida (race conditions)

Quando NÃO Usar

• Implementando novas funcionalidades de produto sem alterações nos testes
• Refatorações em larga escala não relacionadas à cobertura de testes ou falhas
• Otimização de desempenho sem regressões de teste para validar
• Projetos que não são C++ ou tarefas que não são de teste

Conceitos Principais

• Loop TDD: vermelho → verde → refatorar (testes primeiro, correção mínima, depois limpezas).
• Isolamento: prefira injeção de dependência e fakes em vez de estado global.
• Layout de testes: tests/unit, tests/integration, tests/testdata.
• Mocks vs. fakes: mock para interações, fake para comportamento com estado.
• Descoberta de CTest: use gtest_discover_tests() para descoberta de testes estável.
• Sinal de CI: execute um subconjunto primeiro, depois a suíte completa com --output-on-failure.

Fluxo de Trabalho TDD

Siga o loop VERMELHO → VERDE → REFACTOR:

1. VERMELHO: escreva um teste que falha e capture o novo comportamento
2. VERDE: implemente a menor alteração para passar
3. REFACTOR: limpe enquanto os testes permanecem verdes

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

int Add(int a, int b); // Provided by production code.

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

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

// REFACTOR: simplify/rename once tests pass

Exemplos de Código

Teste Unitário Básico (gtest)

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

int Add(int a, int b); // Provided by production code.

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

Fixture (gtest)

// tests/user_store_test.cpp
// Pseudocode stub: replace UserStore/User with project types.
#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");
}

Início Rápido CMake/CTest

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

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

include(FetchContent)
# Prefer project-locked versions. If using a tag, use a pinned version per project policy.
set(GTEST_VERSION v1.17.0) # Adjust to project policy.
FetchContent_Declare(
  googletest
  # Google Test framework (official 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

…