Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

Tests et assertions

Les tests comparent le comportement d’un programme aux attentes, tandis que les assertions expriment des conditions qui devraient être satisfaites. Découvrez les tests fondés sur les propriétés, l’idempotence et un corpus de test déterministe, ainsi que la différence entre assert, static_assert et les vérifications qui restent actives lorsque NDEBUG est défini.

Version : C++23; repository compiler flag, production runtime not attested

Syntaxe

assert(condition); static_assert(constant_condition, "message");

Les tests vérifient le comportement d’un programme avec des entrées choisies. Un test fondé sur des exemples compare un résultat à une valeur attendue précise ; le property-based testing vérifie une règle générale sur de nombreuses entrées, souvent générées automatiquement. La réussite des tests ne prouve pas à elle seule la correction pour toutes les entrées possibles.

L’idempotence signifie f(f(x)) == f(x) : appliquer une opération une nouvelle fois ne modifie plus son résultat. La fonction clamp_score limite un nombre à [0, 10]. L’exemple vérifie les valeurs attendues, la plage du résultat et l’idempotence. L’idempotence seule ne suffit pas : une fonction incorrecte qui renvoie toujours 0 la respecte également.

Un deterministic test corpus est un ensemble fixe et ordonné de cas qui rend l’exécution des tests reproductible. Ici, il contient sept entrées, notamment des limites et des valeurs hors plage. Il s’agit d’une petite vérification de propriété sur un corpus fixe, et non d’un générateur aléatoire ni d’une couverture exhaustive du domaine. Lors de la génération d’entrées, conservez la graine, la configuration du générateur et les cas qui échouent ; la graine seule ne garantit pas la reproduction après une modification du générateur.

assert(condition) de <cassert> vérifie une condition à l’exécution ; l’échec d’une assertion active produit un diagnostic et interrompt le programme. Si NDEBUG est défini lors de l’inclusion de l’en-tête, la condition n’est pas évaluée : n’y placez donc jamais d’effets de bord nécessaires. static_assert vérifie une condition constante à la compilation. L’exemple utilise un if explicite et return 1 pour que les vérifications à l’exécution restent actives même avec NDEBUG ; les assertions ne remplacent pas la validation des entrées externes.

L’exemple utilise une syntaxe compatible avec C++23. La source eel.is est un projet de travail en évolution, et non une publication C++23 figée. Une option du compilateur dans le dépôt ne suffit pas à établir que l’exemple peut s’exécuter dans l’environnement de production. Le code source présenté a été exécuté sans modification dans un environnement isolé, et sa sortie standard (stdout) correspondait exactement à la sortie ci-dessous.

Exemples

#include <array>
#include <iostream>

constexpr int clamp_score(int x) {
    return x < 0 ? 0 : (x > 10 ? 10 : x);
}

static_assert(clamp_score(-1) == 0, "lower boundary");
static_assert(clamp_score(11) == 10, "upper boundary");

struct Case {
    int input;
    int expected;
};

int main() {
    constexpr std::array<Case, 7> corpus{{
        {-3, 0}, {-1, 0}, {0, 0}, {1, 1},
        {9, 9}, {10, 10}, {11, 10}
    }};

    for (const auto& test : corpus) {
        const int y = clamp_score(test.input);
        if (y != test.expected || y < 0 || y > 10 ||
            clamp_score(y) != y) {
            std::cerr << "FAIL input=" << test.input << '\n';
            return 1;
        }
    }

    std::cout << corpus.size() << " cases passed\n";
    return 0;
}

Résultat

7 cases passed

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources