EnglishCommencer

Les assertions xUnit

La famille d'assertions des cadres xUnit : égalité, vérité, nullité, identité, tableaux, flottants avec tolérance, exception attendue, message d'échec, et la différence entre un échec et une erreur.

  • 20 cartes
  • 3 thèmes
  • Gratuit
Réviser ce deck

Le programme, thème par thème

Le poids de chaque thème suit celui que lui donne l'examen.

  1. Notions
  2. Questions
  3. Ranger et relier

Quelques cartes du deck

  • Assertion : de quoi s'agit-il ?

    Voir la réponse

    Instruction d'un test qui compare un résultat à ce qui est attendu et fait échouer le test quand ils diffèrent.

    C'est la seule partie du test qui peut le faire échouer pour une raison de fond : sans elle, le test ne prouve rien.

  • Que contient le message d'échec de JUnit pour ce test ?

    ```java
    @Test
    void somme() {
    assertEquals(5, Maths.somme(2, 2));
    }
    `

    • expected: <5> but was: <4>
    • expected: <4> but was: <5>
    • expected: <2> but was: <4>
    • expected: <true> but was: <false>
    Voir la réponse

    expected: <5> but was: <4>

    Le premier argument est la valeur attendue (5), le second la valeur obtenue (4). Inverser l'ordre dans l'écriture du test inverse les deux nombres du message et brouille le diagnostic.

  • Pour vérifier qu'une méthode lève une exception, JUnit 5 fournit l'assertion ….

    Voir la réponse

    Pour vérifier qu'une méthode lève une exception, JUnit 5 fournit l'assertion assertThrows.

    On lui passe la classe d'exception attendue et le code à exécuter sous forme de lambda : assertThrows(IllegalArgumentException.class, () -> f(-1)).

  • Échec d'un test (failure) : de quoi s'agit-il ?

    Voir la réponse

    Verdict d'un test dont une assertion n'est pas vérifiée : le code a tourné, mais le résultat n'est pas celui qu'on attendait.

    En JUnit, c'est une AssertionFailedError. Elle pointe vers un défaut de comportement du code testé.

  • Pourquoi ce test échoue-t-il alors que le code est correct ?

    ```java
    @Test
    void somme() {
    assertEquals(0.3, 0.1 + 0.2);
    }
    `

    • assertEquals ne sait pas comparer des nombres à virgule flottante
    • 0.1 + 0.2 vaut 0.30000000000000004 : il manque une tolérance
    • Les arguments sont dans le mauvais ordre : la somme doit venir en premier
    • Les deux nombres deviennent des objets Double distincts, dont assertEquals compare les références
    Voir la réponse

    0.1 + 0.2 vaut 0.30000000000000004 : il manque une tolérance

    JUnit affiche expected: <0.3> but was: <0.30000000000000004>. Les nombres binaires ne représentent pas exactement 0,1 ni 0,2. Java appelle ici la version assertEquals(double, double), qui compare des valeurs et non des références. La version avec tolérance, assertEquals(0.3, 0.1 + 0.2, 0.0001), réussit.

Réviser ce deck