D Language
Testen van een eenheid

Syntaxis

• unittest {...} - een blok dat alleen in de modus "unittesting" wordt uitgevoerd
• assert (<expressie die resulteert in een boolean>, <optioneel foutbericht>)

Unittest blokken

Tests zijn een uitstekende manier om stabiele, bug-vrije applicaties te garanderen. Ze dienen als een interactieve documentatie en laten toe om code te wijzigen zonder angst om functionaliteit te breken. D biedt een handige en native syntaxis voor unittest blok als onderdeel van de D-taal. Overal in een D-module kunnen unittest blokken worden gebruikt om de functionaliteit van de broncode te testen.

/**
Yields the sign of a number.
Params:
    n = number which should be used to check the sign
Returns:
    1 for positive n, -1 for negative and 0 for 0.
*/
T sgn(T)(T n)
{
    if (n == 0)
        return 0;
    return (n > 0) ? 1 : -1;
}

// this block will only be executed with -unittest
// it will be removed from the executable otherwise
unittest
{
    // go ahead and make assumptions about your function
    assert(sgn(10)  ==  1);
    assert(sgn(1)   ==  1);
    assert(sgn(-1)  == -1);
    assert(sgn(-10) == -1);
}

Unittest uitvoeren

Als de vlag -unittest wordt doorgegeven aan de D-compiler, worden alle unittest-blokken uitgevoerd. Vaak is het handig om de compiler een main te laten genereren. Met het compileren en uitvoeren van wrapper rdmd wordt het testen van uw D-programma net zo eenvoudig als:

rdmd -main -unittest yourcode.d

Je kunt dit proces natuurlijk ook in twee stappen splitsen als je wilt:

dmd -main -unittest yourcode.d
./yourcode

Voor dub projecten kan het compileren van alle bestanden en het uitvoeren van hun meest ongeschikte blokken gemakkelijk worden gedaan met

dub test

alias tdmd="rdmd -main -unittest"

en test vervolgens uw bestanden met:

tdmd yourcode.d

Geannoteerd niet

Voor sjablooncode is het vaak handig om te controleren of voor functie-attributen (bijv. @nogc correct worden afgeleid. Om dit voor een specifieke test te verzekeren en dus te typen kan de hele unittest worden geannoteerd

@safe @nogc pure nothrow unittest
{
    import std.math;
    assert(exp(0)  ==  1);
    assert(log(1)  ==  0);
}

Merk op dat natuurlijk in D elk blok kan worden geannoteerd met attributen en de compilers, natuurlijk, controleert of ze correct zijn. Dus het volgende zou bijvoorbeeld vergelijkbaar zijn met het bovenstaande voorbeeld:

unittest
{
    import std.math;
    @safe {
        assert(exp(0)  ==  1);
        assert(log(1)  ==  0);
    }
}