D Language
Désengagement

Syntaxe

• unittest {...} - un bloc qui n'est exécuté qu'en mode "unittesting"
• assert (<expression qui donne une valeur booléenne>, <message d'erreur facultatif>)

Blocs Unittest

Les tests sont un excellent moyen de garantir des applications stables et exemptes de bogues. Ils servent de documentation interactive et permettent de modifier le code sans crainte de casser la fonctionnalité. D fournit une syntaxe pratique et native pour les blocs les plus unittest dans le langage D. N'importe où dans un module D, les blocs les plus unittest utilisés peuvent être utilisés pour tester la fonctionnalité du code source.

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

Exécuter le plus souvent

Si l' -unittest flag est transmise au compilateur D, tous les blocs les plus communs seront exécutés. Il est souvent utile de laisser le compilateur générer une fonction main tronquée. En utilisant le wrapper de compilation et d'exécution rdmd , tester votre programme D devient aussi simple que:

rdmd -main -unittest yourcode.d

Bien sûr, vous pouvez également diviser ce processus en deux étapes si vous le souhaitez:

dmd -main -unittest yourcode.d
./yourcode

Pour les projets de dub , la compilation de tous les fichiers et l’exécution de leurs blocs les plus faciles à utiliser peuvent être

dub test

alias tdmd="rdmd -main -unittest"

puis testez vos fichiers avec:

tdmd yourcode.d

Annoté le plus souvent

Pour le code @nogc modèles, il est souvent utile de vérifier cela pour les attributs de fonction (par exemple, @nogc est déduit correctement. Pour garantir cela pour un test spécifique et donc pour taper tout le code unittest, il est possible de l'annoter)

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

Notez bien sûr que dans D chaque bloc peut être annoté avec des attributs et que les compilateurs, bien sûr, vérifient qu’ils sont corrects. Ainsi, par exemple, ce qui suit serait similaire à l'exemple ci-dessus:

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