Assertions Java

L'instruction Assert En Java est utilisée pour tester certaines hypothèses sur l'état d'un programme pendant l'exécution. Cela permet de détecter facilement les erreurs et de déboguer le programme. Une instruction d'assertion en Java est écrite à l'aide du mot-clé Java assert suivi d'une expression booléenne. Si l’expression est vraie, l’assertion passe silencieusement et le programme fait son travail. Si l'évaluation est fausse, l'assertion échoue et une AssertionError est levée. Prenons un exemple de programme avec des assertions Java.

//Assertion in Java example
public class AssertDemo1 {
   public static void main(String[] args) {
       int x = 5;
       assert x == 5 : "x should be 5";
       System.out.println(x);
   }
}

Ici, l'expression est vraie, donc le programme continue son travail. Le résultat est exactement comme prévu :

Exemple d'erreur d'assertion

En Java, une AssertionError est une sous-classe de la classe Error et elle est levée lorsqu'une assertion échoue. Les assertions en Java sont généralement utilisées pour vérifier que les préconditions, les postconditions ou les invariants sont vrais. Comme nous l'avons dit ci-dessous, une AssertionError est levée lorsqu'une instruction d'assertion ne parvient pas à être évaluée comme vraie. Réécrivons maintenant notre programme pour que l'expression booléenne soit fausse.

//AssertionError example
public class AssertDemo1 {
   public static void main(String[] args) {
       int x = 5;
       assert x == 7 : "x should be 7";
       //here should be AssertionError
       System.out.println(x);
   }
}

Eh bien, nous l'exécutons et le résultat est… Quelque chose s’est définitivement mal passé dans notre exemple ! Nous devrions avoir une AssertionError ici parce que notre x est 5 et l'assertion s'attend à ce qu'il soit 7. Qu'est-ce qui ne va pas ici ? Il est important de noter que les assertions Java peuvent être simplement désactivées dans la JVM, elles ne doivent donc pas être utilisées comme seul moyen de vérification des erreurs dans un programme. Ils sont utiles pour le débogage et les tests, mais ne doivent pas être utilisés pour le code de production. Donc, pour utiliser des assertions, vous devez les activer à l'aide de l'option vm -ea (ou -enableassertions). Si vous travaillez en ligne de commande, vous pouvez utiliser la commande suivante pour votre programme AssertDemo1 : si vous activez les assertions et réexécutez le même programme, vous obtiendrez le suivant : C'est le but.

Comment activer les exceptions dans IntelliJ IDEA

1. Allez dans le menu Exécuter → Modifier les configurations....
2. Entrez le paramètre -ea dans la ligne options VM

Les assertions sont désormais activées et vous pouvez les utiliser.

Assertions pour les tests unitaires en Java

En Java, les tests unitaires sont une technique qui consiste à tester des modules de code individuels pour s'assurer qu'ils fonctionnent correctement. Les assertions sont couramment utilisées dans les tests unitaires en Java pour vérifier que le code testé fonctionne comme prévu. Dans les tests unitaires, une unité de code, par exemple une méthode particulière, est testée isolément pour garantir qu'elle fonctionne correctement dans différentes conditions et entrées. Prenons un exemple. Nous avons ici une calculatrice simple pour l'addition, la soustraction, la multiplication et la division 2 d'entiers.

public class MyMath {

   public static int add (int a, int b) {
       return a + b;
   }

   public static int sub (int a, int b) {
       return a - b;
   }

   public static int mult (int a, int b) {
       return a*b;
   }

   public static double div (int a, int b) {
       return a/b;
   }
}

Bien sûr, il y a beaucoup de questions sur cette implémentation (par exemple, que se passe-t-il si nous ajoutons le plus grand int à un autre nombre), mais pour l'instant nous laisserons cette implémentation telle quelle. Écrivons maintenant une classe dans laquelle nous testerons les méthodes de la classe myMath à l'aide de tests unitaires. C'est vrai, seulement deux d'entre eux. En fait, vous pouvez écrire des tests qui vérifient la validité des arguments, si une méthode gère des cas particuliers, etc. Mais ici, nous nous limiterons à quelques tests à des fins de démonstration.

import org.junit.Test;

import static org.junit.Assert.assertEquals;

public class MyMathTesting {
   @Test
   public void testAdd() {
       MyMath calculator = new MyMath();
       int sum = calculator.add(2, 3);
       assertEquals(5, sum);
   }

   @Test
   public void testSub() {
       MyMath calculator = new MyMath();
       int sub = calculator.sub(5, 2);
       assertEquals(3, sub);
   }

}

La méthode assertEquals est une assertion qui vérifie si deux valeurs sont égales. Si les valeurs ne sont pas égales, une AssertionError sera levée, indiquant que le test a échoué. L'utilisation d'assertions dans les tests unitaires peut vous aider à détecter les bogues et à garantir que votre code fonctionne correctement dans différentes conditions et entrées. Essayez d'ajouter vous-même de tels tests de division et de multiplication. Ce n'est pas difficile.