D Language
unit testing

Sintassi

• unittest {...} - un blocco che viene eseguito solo in modalità "unittesting"
• assert (<espressione che valuta un valore booleano>, <messaggio di errore opzionale>)

Blocchi Unittest

I test sono un modo eccellente per garantire applicazioni stabili e prive di bug. Servono come documentazione interattiva e consentono di modificare il codice senza timore di interrompere la funzionalità. D fornisce una sintassi conveniente e nativa per il blocco di unittest come parte del linguaggio D. Ovunque in un modulo D è possibile utilizzare blocchi di unittest per testare la funzionalità del codice sorgente.

/**
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);
}

Esecuzione di unittest

Se il flag -unittest viene passato al compilatore D, verrà eseguito tutti i blocchi di unittest. Spesso è utile lasciare che il compilatore generi una funzione main stubbed. Usando il rdmd & run wrapper rdmd , testare il tuo programma D diventa facile come:

rdmd -main -unittest yourcode.d

Ovviamente puoi anche dividere questo processo in due passaggi se lo desideri:

dmd -main -unittest yourcode.d
./yourcode

Per i progetti dub compilare tutti i file ed eseguire i blocchi di unittest può essere fatto comodamente con

dub test

alias tdmd="rdmd -main -unittest"

e quindi prova i tuoi file con:

tdmd yourcode.d

Annotated unittest

Per il codice @nogc modelli è spesso utile verificare che per gli attributi di funzione (ad es. @nogc siano dedotti correttamente. Per garantire questo per un test specifico e quindi digitare l'intero unittest può essere annotato

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

Si noti che, naturalmente, in D ogni blocco può essere annotato con attributi e, ovviamente, i compilatori verificano che siano corretti. Quindi, ad esempio, quanto segue sarebbe simile all'esempio sopra:

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