KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

Testen en assertions

Tests vergelijken het gedrag van een programma met verwachtingen; assertions leggen voorwaarden vast die moeten gelden. Leer property-based testing, idempotentie en een deterministische testverzameling kennen, en ontdek het verschil tussen assert, static_assert en controles die actief blijven wanneer NDEBUG is gedefinieerd.

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

Syntax

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

Testen controleert het gedrag van een programma met geselecteerde invoer. Een test op basis van voorbeelden vergelijkt een resultaat met een concrete verwachte waarde; property-based testing controleert een algemene regel voor veel invoerwaarden, die vaak automatisch worden gegenereerd. Dat tests slagen, bewijst op zichzelf niet dat het programma voor alle mogelijke invoer correct is.

Idempotentie betekent f(f(x)) == f(x): een bewerking opnieuw toepassen verandert het resultaat niet meer. De functie clamp_score begrenst een getal tot [0, 10]. Het voorbeeld controleert de verwachte waarden, het resultaatbereik en idempotentie. Idempotentie alleen is niet voldoende: ook een onjuiste functie die altijd 0 retourneert voldoet eraan.

Een deterministic test corpus is een vaste, geordende verzameling gevallen waarmee een testuitvoering herhaalbaar wordt. Deze bevat zeven invoerwaarden, waaronder grenzen en waarden buiten het bereik. Dit is een kleine eigenschapscontrole op een vaste verzameling, geen willekeurige generator en geen volledige dekking van het domein. Bewaar bij het genereren van invoer de seed, de generatorconfiguratie en de gevallen die mislukken; alleen de seed garandeert geen reproductie als de generator verandert.

assert(condition) uit <cassert> controleert een voorwaarde tijdens uitvoering; als een ingeschakelde assertion faalt, geeft die een diagnose en wordt het programma afgebroken. Als NDEBUG is gedefinieerd wanneer de header wordt ingesloten, wordt de voorwaarde niet geëvalueerd. Plaats er daarom geen noodzakelijke neveneffecten in. static_assert controleert tijdens het compileren een constante voorwaarde. Het voorbeeld gebruikt een expliciete if en return 1 zodat de runtimecontroles ook met NDEBUG actief blijven; assertions vervangen geen validatie van externe invoer.

Het voorbeeld gebruikt syntax die compatibel is met C++23. De bron eel.is is een voortdurend bijgewerkt werkdocument, geen vastgelegde C++23-publicatie. Een compileroptie in de repository toont niet aan dat het voorbeeld in de productieomgeving kan worden uitgevoerd. De getoonde broncode is ongewijzigd uitgevoerd in een geïsoleerde omgeving. De standaarduitvoer (stdout) kwam exact overeen met de uitvoer hieronder.

Voorbeelden

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

Resultaat

7 cases passed

De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.

Bronnen