0Pricing
C++ Academy · Leçon

Assertions et correspondants

Écrire des vérifications expressives

Assertions et correspondants est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C++ Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C++ Academy comprend 4 leçons au total.

Les assertions expriment des attentes

Les assertions de GTest vérifient des conditions dans un test. Elles ont deux niveaux de gravité.

  • EXPECT_* : l’échec est enregistré et le test continue
  • ASSERT_* : l’échec arrête immédiatement le test en cours

EXPECT contre ASSERT

Utilisez ASSERT_* lorsque continuer provoquerait un plantage, par exemple après la vérification d’un pointeur nul, et EXPECT_* dans les autres cas afin de voir tous les échecs en une seule fois.

#include <gtest/gtest.h>

TEST(Demo, MixedChecks) {
    int* p = new int(5);
    ASSERT_NE(p, nullptr);
    EXPECT_EQ(*p, 5);
    delete p;
}

Assertions de comparaison

Les principales macros de comparaison :

  • EXPECT_EQ, EXPECT_NE
  • EXPECT_LT, EXPECT_LE
  • EXPECT_GT, EXPECT_GE
#include <gtest/gtest.h>

TEST(Compare, Numbers) {
    EXPECT_LT(2, 3);
    EXPECT_GE(5, 5);
}

Assertions booléennes

EXPECT_TRUE et EXPECT_FALSE vérifient directement des conditions booléennes.

#include <gtest/gtest.h>

bool is_even(int n) { return n % 2 == 0; }

TEST(Bool, Even) {
    EXPECT_TRUE(is_even(4));
    EXPECT_FALSE(is_even(3));
}

Comparaisons en virgule flottante

N’utilisez jamais EXPECT_EQ avec des nombres flottants. Utilisez EXPECT_FLOAT_EQ, EXPECT_DOUBLE_EQ ou EXPECT_NEAR avec une tolérance.

#include <gtest/gtest.h>

TEST(Floats, Approx) {
    EXPECT_DOUBLE_EQ(0.1 + 0.2, 0.3);
    EXPECT_NEAR(3.14159, 3.14, 0.01);
}

Assertions sur les chaînes

Pour les chaînes C, utilisez EXPECT_STREQ / EXPECT_STRNE. Pour std::string, EXPECT_EQ convient, car la comparaison porte sur la valeur.

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

TEST(Strings, Compare) {
    EXPECT_STREQ("hi", "hi");
    EXPECT_EQ(std::string("ok"), "ok");
}

Assertions d’exception

Vérifiez que le code lève l’exception attendue.

#include <gtest/gtest.h>
#include <stdexcept>

void check(int n) {
    if (n < 0) throw std::runtime_error("neg");
}

TEST(Throws, Negative) {
    EXPECT_THROW(check(-1), std::runtime_error);
    EXPECT_NO_THROW(check(1));
}

Messages d’échec personnalisés

Ajoutez du contexte à une assertion avec << afin de faciliter le diagnostic des échecs.

#include <gtest/gtest.h>

TEST(Message, WithContext) {
    int x = 7;
    EXPECT_EQ(x, 7) << "x had unexpected value " << x;
}

Matchers GMock avec EXPECT_THAT

EXPECT_THAT associe une valeur à un matcher pour effectuer des vérifications expressives, par exemple EXPECT_THAT(v, ElementsAre(1, 2, 3)).

#include <gtest/gtest.h>
#include <gmock/gmock.h>
#include <vector>
using ::testing::ElementsAre;

TEST(Matchers, Vector) {
    std::vector<int> v{1, 2, 3};
    EXPECT_THAT(v, ElementsAre(1, 2, 3));
}

Matchers utiles

Parmi les matchers courants :

  • Eq, Ne, Gt, Lt
  • Contains, ElementsAre, UnorderedElementsAre
  • HasSubstr, StartsWith, EndsWith

Choisir la bonne assertion

Privilégiez l’assertion la plus précise : elle produit des messages d’échec plus clairs qu’un EXPECT_TRUE générique. EXPECT_EQ(a, b) affiche les deux valeurs ; EXPECT_TRUE(a == b) ne le fait pas.

Vérification rapide

Rappelez-vous la différence entre EXPECT et ASSERT.

Récapitulatif

Vous avez appris les assertions de GTest.

  • EXPECT_* poursuit l’exécution ; ASSERT_* interrompt le test
  • Macros de comparaison, booléennes, flottantes, de chaînes et d’exception
  • Ajoutez du contexte avec <<
  • EXPECT_THAT et les matchers pour des vérifications expressives

Questions Fréquemment Posées

La leçon « Assertions et correspondants » est-elle gratuite ?

Oui — le texte complet de « Assertions et correspondants » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C++ Academy, passe à CoddyKit PRO. Le cours C++ Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Assertions et correspondants » ?

Écrire des vérifications expressives Tu pratiques C++ Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C++ Academy ?

Aucune expérience préalable n'est requise. C++ Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Assertions et correspondants » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C++ Academy ?

Oui. Chaque leçon C++ Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Configurer GTest
  2. Assertions et correspondants
  3. Fixtures et configuration
  4. Simulations avec GMock
← Retour à C++ Academy