JUnit Tutoriel d'annotations avec exemple : Qu'est-ce que @Test et @After

Qu'est-ce que le JUnit Annotation ?

JUnit annotations sont une forme particulière de métadonnées syntaxiques qui peuvent être ajoutées à Java Le code source est annoté pour une meilleure lisibilité et une structure améliorée. Les variables, les paramètres, les packages, les méthodes et les classes peuvent être annotés. Les annotations ont été introduites dans JUnit 4, ce qui fait Java un code plus lisible et plus simple. C'est la grande différence entre JUnit 3 et JUnit 4: JUnit 4 est basé sur des annotations.

Avec une connaissance pratique de ces annotations, on peut facilement apprendre et implémenter un JUnit test. Vous trouverez ci-dessous les informations importantes et fréquemment utilisées JUnit liste des annotations, avec la JUnit 5 (Jupiter) équivalent à côté de chacun :

JUnit Exemple d'annotations

Créons une classe couvrant les sujets importants JUnit annotations avec des instructions d'impression simples et exécutez-les avec une classe d'exécution de tests :

Étape 1) Considérez ce qui suit Java classe possédant diverses méthodes qui sont associées aux annotations listées ci-dessus :

Exemple d'annotations Junit.java

package guru99.junit;		

import static org.junit.Assert.assertEquals;				
import static org.junit.Assert.assertFalse;				

import java.util.ArrayList;		

import org.junit.After;		
import org.junit.AfterClass;		
import org.junit.Before;		
import org.junit.BeforeClass;		
import org.junit.Ignore;		
import org.junit.Test;		

public class JunitAnnotationsExample {				

    private ArrayList<String> list;					

    @BeforeClass		
    public static void m1() {							
        System.out.println("Using @BeforeClass , executed before all test cases ");					
    }		

    @Before		
    public void m2() {					
        list = new ArrayList<String>();					
        System.out.println("Using @Before annotations ,executed before each test cases ");					
    }		

    @AfterClass		
    public static void m3() {							
        System.out.println("Using @AfterClass ,executed after all test cases");					
    }		

    @After		
    public void m4() {					
        list.clear();			
        System.out.println("Using @After ,executed after each test cases");					
    }		

    @Test		
    public void m5() {					
        list.add("test");					
        assertFalse(list.isEmpty());			
        assertEquals(1, list.size());			
    }		

    @Ignore		
    public void m6() {					
        System.out.println("Using @Ignore , this execution is ignored");					
    }		

    @Test(timeout = 10)			
    public void m7() {					
        System.out.println("Using @Test(timeout),it can be used to enforce timeout in JUnit4 test case");					
    }		

    @Test(expected = NoSuchMethodException.class)					
    public void m8() {					
        System.out.println("Using @Test(expected) ,it will check for specified exception during its execution");					

    }		

}		

Étape 2) Créons une classe d'exécution de tests pour exécuter le test ci-dessus :

TestRunner.java

package guru99.junit;		

import org.junit.runner.JUnitCore;		
import org.junit.runner.Result;		
import org.junit.runner.notification.Failure;		

public class TestRunner {				
			public static void main(String[] args) {									
      Result result = JUnitCore.runClasses(JunitAnnotationsExample.class);					
			for (Failure failure : result.getFailures()) {							
         System.out.println(failure.toString());					
      }		
      System.out.println("Result=="+result.wasSuccessful());							
   }		
}      	

résultat attendu

• Tous les cas de test seront exécutés un par un, et tous les messages d'affichage seront visibles sur la console.
• Comme indiqué dans le tableau ci-dessus, @Before et @BeforeClass dans JUnit [ Les méthodes m2() et m1() ] seront exécutées respectivement avant chaque cas de test et avant tous les cas de test.
• De la même manière que @After et @AfterClass dans JUnit Les méthodes `m4()` et `m3()` seront exécutées respectivement après chaque cas de test et après tous les cas de test. L'annotation `@Ignore` (méthode `m6()`) sera interprétée comme si le test était ignoré.

Analysons les cas de test utilisés dans ce qui précède. Java Cours en détail :

1. Considérons la méthode m5() comme indiqué ci-dessous :

	@Test		
    public void m5() {					
        list.add("test");					
        assertFalse(list.isEmpty());			
        assertEquals(1, list.size());			
    }		

Dans la méthode ci-dessus, vous ajoutez une chaîne de caractères à la variable « liste » :

• liste.isEmpty() retournera faux.
• assertFalse(list.isEmpty()) doit retourner vrai.
• En conséquence, le scénario de test sera pass.

Comme vous n'avez ajouté qu'une seule chaîne de caractères à la liste, sa taille est de un.

• liste.size() doit renvoyer la valeur entière « 1 ».
• So assertEquals(1, list.size()) doit retourner vrai.
• En conséquence, le scénario de test sera pass.

2. Considérons la méthode m7() comme indiqué ci-dessous :

@Test(timeout = 10)		
    public void m7() {					
        System.out.println("Using @Test(timeout),it can be used to enforce timeout in JUnit4 test case");					
    }		

Comme discuté ci-dessus, @Test (délai d'attente = 10) Cette fonction permet de définir un délai d'attente dans le cas de test. La valeur étant exprimée en millisecondes, la fonction m7() doit s'exécuter en moins de 10 ms.

3. Considérons la méthode m8() comme indiqué ci-dessous :

@Test(expected = NoSuchMethodException.class)				
    public void m8() {					
        System.out.println("Using @Test(expected) ,it will check for specified exception during its execution");					
    
    }		

Comme discuté ci-dessus, @Test (attendu) La méthode vérifiera l'exception spécifiée lors de son exécution ; par conséquent, la méthode m8() lèvera une exception « Méthode inexistante ». En conséquence, le test sera exécuté avec une exception.

Note sur l'exactitude : La fonction m8() n'imprime qu'une ligne, donc l'exception déclarée n'est jamais réellement levée et JUnit 4 indique que le test a échoué. Alignez le type attendu avec le comportement de la méthode. JUnit 5 écrit ceci avec assertThrows.

Comme tous les cas de test sont réussis, cela entraîne une exécution réussie du test.

Résultat actuel

L'exemple ci-dessus comportant trois cas de test, ceux-ci seront exécutés un par un. Voir la capture d'écran de la console ci-dessous :

Voir ci-dessous les déclarations d'impression visibles sur la console :

Utilisation de @BeforeClass , exécuté avant tous les cas de test

Utilisation des annotations @Before, exécutées avant chaque cas de test

Utilisation de @After, exécuté après chaque cas de test

Utilisation des annotations @Before, exécutées avant chaque cas de test

En utilisant @Test(timeout), il peut être utilisé pour appliquer un délai d'attente dans JUnit4 cas de tests

Utilisation de @After, exécuté après chaque cas de test

Utilisation des annotations @Before, exécutées avant chaque cas de test

En utilisant @Test (attendu), il vérifiera l'exception spécifiée lors de son exécution

Utilisation de @After, exécuté après chaque cas de test

Utilisation de @AfterClass, exécuté après tous les cas de test

JUnit Classe d'affirmation

Les annotations déterminent quand une méthode s'exécute ; les méthodes d'assertion déterminent si elle réussit.

Cette classe fournit plusieurs méthodes d'assertion utiles pour écrire un cas de test. Si toutes les assertions sont réussies, le test est considéré comme concluant. Si une seule assertion échoue, le test est considéré comme ayant échoué. JUnit affirmer Ce tutoriel aborde chaque méthode en détail.

Comme vous l'avez vu précédemment, le tableau ci-dessous décrit les principales méthodes d'assertion et leur description :

JUnit Classe de cas de test

Pour exécuter plusieurs tests, la classe TestCase est disponible dans le junit.framework package. L'annotation @Test indique JUnit que cette méthode publique void (un cas de test ici) à laquelle elle est attachée puisse être exécutée comme un cas de test.

Note de version : Cas de test, Résultat du test et Suite de tests appartenir à l'héritage junit.framework paquet de JUnit 3. Ils sont toujours inclus dans l'artefact JUnit 4.x, mais les tests basés sur des annotations n'étendent pas TestCase.

Le tableau ci-dessous présente quelques méthodes importantes disponibles dans le junit.framework.TestCase classe:

JUnit Classe TestResult

Lorsqu'un test est exécuté, il renvoie un résultat (sous la forme d'un Résultat du test Cet objet TestResult permet d'analyser l'objet résultant. Le résultat du test peut être un échec ou une réussite.

Consultez le tableau ci-dessous pour connaître les principales méthodes utilisées dans la classe junit.framework.TestResult :

JUnit Classe de suite de tests

Si vous souhaitez exécuter plusieurs tests dans un ordre précis, vous pouvez les regrouper en un seul endroit. Cet endroit s'appelle une suite de tests. JUnit suite de tests Le tutoriel présente un exemple complet.

Consultez le tableau ci-dessous pour connaître les principales méthodes utilisées dans le junit.framework.TestSuite classe:

FAQ