La classe JUnit Assertions contient une collection de méthodes statiques qui vous permettent d'effectuer des tests unitaires. Les assertions sont l'une des principales fonctionnalités de JUnit. Cette classe a plus de cinquante méthodes diverses. Certains tests de classe Assertions échoueront si une condition est vraie, tandis que d'autres échoueront si une condition est fausse.
La classe Assertions possède également de nombreuses méthodes surchargées. Chaque méthode d'assertion a au moins deux méthodes surchargées. Découvrez certaines des méthodes de classe Assertions les plus populaires et découvrez comment les utiliser pour effectuer des tests unitaires.
La méthode assertEquals
La méthode JUnit 5 assertEquals a plus de dix variantes. Cette méthode est l'une des méthodes de classe Assertions les plus populaires. Une variante de la méthode assertEquals prend une valeur attendue et la fonction que vous souhaitez évaluer (valeur réelle). Une deuxième variante majeure prend un troisième argument supplémentaire. Il s'agit d'un message d'erreur qui s'affichera si le
Test unitaire JUnit échoue.La surcharge de la méthode assertEquals se produit avec différents types de données. Certaines méthodes de surcharge assertEquals prennent un quatrième argument appelé delta. D'autres versions remplacent la chaîne d'échec par une interface fonctionnelle Fournisseur, sous la forme d'un expression lambda.
Classe Java AssertionsMethods
forfait com.programme ;
PubliqueclasserAssertionsMethods{
Publiquestatiqueentiercarré(entier nombre){
revenir nombre * nombre ;
}
}
La classe Java AssertionsMethods ci-dessus a une seule méthode appelée square. La méthode square prend une valeur entière et renvoie son carré. Pour tester la méthode carrée et toute future méthode de la classe AssertionsMethods, vous devrez créer un cas de test JUnit.
Cas de test JUnit AssertionsMethodsTest
forfait com.programme ;importerstatiqueorg.junit.Affirmer.assertEquals;
importerstatiqueorg.junit.Jupiter.api.Assertions.*;importerorg.junit.Jupiter.api.Test;
classerAssertionsMéthodesTest{
@Test
annulertestCarré(){
assertEquals(25, Méthodes d'assertion.carré(5));
assertEquals (36, AssertionMethods.square (6), "Vos valeurs au carré ne correspondent pas.");
assertEquals (49, AssertionMethods.square (7), () ->"Vos valeurs au carré ne correspondent pas.");
}
}
La méthode testSquare() utilise trois variantes de assertEquals() pour tester la méthode square(). Chaque assertEquals() est un succès, car toutes les valeurs attendues correspondent aux valeurs réelles renvoyées par la méthode square().
La méthode assertNull
La classe JUnit Assertions a exactement trois méthodes assertNull. Chacune de ces méthodes prend un ou plusieurs arguments et affirme si l'objet donné est nul. Si un objet donné n'est pas nul, le test échouera.
@Test
PubliqueannulertestStringValue(){
Chaîne de caractères chaîneValeur = nul;
assertNull (stringValue);
assertNull (chaîneValeur, "Votre valeur de chaîne n'est pas nulle");
assertNull (stringValue, () ->"Votre valeur de chaîne n'est pas nulle");
}
La première méthode assertNull() prend un objet chaîne et vérifie s'il est nul. La deuxième méthode assertNull() prend un objet chaîne et un message chaîne à afficher si le test échoue. La troisième et dernière méthode assertNull() prend l'objet que vous souhaitez évaluer et une interface fonctionnelle Supplier.
Dans le cas de test ci-dessus, l'interface fournisseur agit comme une cible d'affectation pour une expression lambda. L'expression lambda génère un message d'erreur si le test échoue.
La méthode assertTrue
La méthode assertTrue() a six variantes. Chaque méthode affirme si une condition donnée est vraie. Si une condition assertTrue() est fausse, le test échouera.
@Test
annulertestEvenNumbers(){
entier num1 = 10;
entier num2 = 16;
entier num3 = 26;
assertTrue (num1 < num2);
assertTrue (num3 > num2, "Votre état n'est pas vrai.");
assertTrue (num1 < num3, () ->" Votre état n'est pas vrai.");
assertTrue(() -> nombre1%2 == 0);
assertTrue(() -> nombre2%2 == 0, "Votre valeur n'est pas un nombre pair.");
assertTrue(() -> nombre3%2 == 0, () ->"Votre valeur n'est pas un nombre pair.");
}
La méthode testEvenNumbers() montre comment utiliser les six méthodes assertTrue(). Toutes les méthodes ci-dessus sont vraies, par conséquent, ce test unitaire s'exécute sans échec ni erreur.
- assertTrue (condition booléenne): cette méthode prend une condition booléenne et affirme si elle est vraie. L'exemple de cette méthode dans le code ci-dessus affirme si la première valeur entière est inférieure à la seconde.
- assertTrue (condition booléenne, message String): cette méthode prend une condition booléenne à tester et une chaîne à afficher si elle est fausse.
- assertTrue (condition booléenne, fournisseur
messageSupplier): cette méthode prend une interface fonctionnelle booléenne et fournisseur, comme expression lambda. Le fournisseur de message contient une chaîne à afficher si la condition booléenne est fausse. - assertTrue (BooleanSupplier booleanSupplier): cette méthode prend une interface fonctionnelle BooleanSupplier, sous la forme d'une expression lambda qui prend la valeur true ou false. L'exemple de cette méthode dans le code utilise une expression lambda. Il teste le reste du premier entier divisé par deux pour déterminer s'il est pair ou impair.
- assertTrue (BooleanSupplier booleanSupplier, String message): cette méthode prend une interface fonctionnelle BooleanSupplier sous la forme d'une expression lambda. Il faut également un message de chaîne à imprimer si le BooleanSupier n'est pas vrai.
- assertTrue (BooleanSupplier booleanSupplier, Fournisseur
messageSupplier): cette méthode utilise une interface fonctionnelle BooleanSupplier pour affirmer. Il prend également une interface fonctionnelle fournisseur, qui est une expression lambda qui imprimera une valeur de chaîne si le test échoue.
La méthode assertFalse
La méthode assertFalse() est l'opposé de la méthode assertTrue(). Cette méthode évalue une condition donnée pour voir si elle est fausse. Si une condition donnée est vraie, alors le test assertFalse() échouera. La méthode assertFalse() a également six variantes qui acceptent les mêmes arguments que leurs homologues assertTrue().
@Test
annulertestNotEvenNumbers(){
entier num1 = 11;
entier num2 = 17;
entier num3 = 27;
assertFalse (num2 < num1);
assertFalse (num2 > num3, " Votre condition n'est pas fausse.");
assertFalse (num3 < nombre1, () ->" Votre condition n'est pas fausse.");
assertFalse(() -> nombre1%2 == 0);
assertFalse(() -> nombre2%2 == 0, "Votre valeur est un nombre pair.");
assertFalse(() -> nombre3%2 == 0, () ->"Votre valeur est un nombre pair.");
}
Les six méthodes assertFalse() de la méthode testNotEvenNumbers() aboutissent toutes à false, ce qui signifie que les tests assertFalse() sont réussis.
Les avantages des tests unitaires
Les tests unitaires font partie intégrante du processus de développement logiciel. Les grands projets logiciels échouent pour diverses raisons, allant des équipes qui y travaillent aux approches de développement.
Le but des tests unitaires est d'éliminer les défaillances logicielles en fournissant une détection précoce des erreurs. Cela nécessite que les équipes développent des spécifications claires, améliorent la conception des logiciels grâce à la documentation des erreurs et fournissent une assistance pour la maintenance des logiciels.
Les tests unitaires ne sont pas la seule approche de test logiciel que vous devriez utiliser dans votre cycle de vie de développement, c'est juste un très bon point de départ.
