JUnit Cas de test @Before @BeforeClass Annotation

JUnit est l'unité la plus populaire Tests cadre dans Java. Il est explicitement recommandé pour Tests unitaires. JUnit Ne nécessite pas de serveur pour tester une application web, ce qui accélère le processus de test.

Le JUnit Le framework permet également la génération rapide et facile de cas de test et de données de test. Le org.junit Le package comprend de nombreuses interfaces et classes pour JUnit tests, tels que Test, Assert, After et Before. Plus large JUnit La famille se construit sur ces mêmes fondements.

Qu'est-ce qu'un banc d'essai ?

Avant de comprendre ce qu'est un environnement de test, étudions le code ci-dessous.

Ce code est conçu pour exécuter deux cas de test sur un simple fichier.

public class OutputFileTest {
    private File output; 
    output = new File(...);
    output.delete(); 
public void testFile1(){
        //Code to verify Test Case 1
}
    output.delete();
    output = new File(...);
public void testFile2(){
        //Code to verify Test Case 2
}
 output.delete(); 
}

Quelques problèmes ici

• Le code est illisible.
• Le code n'est pas facile à maintenir.
• Lorsque la suite de tests est complexe, le code peut contenir des problèmes logiques.

Comparez le même code en utilisant JUnit.

public class OutputFileTest		
{
    private File output; 
    @Before public void createOutputFile() 
    { 
       output = new File(...);
    }
  
	@After public void deleteOutputFile() 
    {
        output.delete(); 
    } 
     
    @Test public void testFile1() 
    {
       // code for test case objective
    } 
	@Test public void testFile2() 
    {
       // code for test case objective
    }
}

Le code est beaucoup plus lisible et maintenable. La structure de code ci-dessus est un Dispositif de test.

Un montage de test est un contexte dans lequel un JUnit Cas de test court. En règle générale, les montages de test comprennent :

• Objets ou ressources disponibles pour tout scénario de test.
• Activités nécessaires pour rendre ces objets et ressources disponibles.
• Ces activités sont
  1. allocation (installation)
  2. désallocation (teardown).

Installation et démontage

Les installations sont importantes parce que JUnit Ces hooks sont exécutés autour de chaque test.

• Habituellement, certaines tâches répétées doivent être effectuées avant chaque scénario de test. Exemple : créer une connexion à la base de données.
• De même, à la fin de chaque scénario de test, des tâches peuvent être répétées. Exemple : pour nettoyer une fois l’exécution du test terminée.
• JUnit Il fournit des annotations facilitant la configuration et la suppression des ressources. Il garantit la libération des ressources et la disponibilité du système de test pour le cas de test suivant.

Ces JUnit Les annotations sont abordées ci-dessous.

installation

@Avant que annotation dans JUnit est utilisé sur une méthode contenant Java code à exécuter avant chaque cas de test, c'est-à-dire qu'il s'exécute avant chaque exécution de test.

Démontage (quel que soit le verdict)

@Après L'annotation est utilisée sur une méthode contenant Java Code à exécuter après chaque test. Ces méthodes s'exécuteront même en cas d'exceptions levées lors du test ou d'échecs d'assertions.

Remarque:

• Il est permis d'avoir n'importe quel nombre d'annotations répertoriées ci-dessus.
• Toutes les méthodes annotées avec @Avant que in JUnit seront exécutés avant chaque scénario de test, mais ils peuvent s'exécuter dans n'importe quel ordre.
• Vous pouvez hériter des méthodes `@Before` et `@After` d'une superclasse. L'exécution se déroule comme suit ; il s'agit d'un processus d'exécution standard. JUnit.

1. Exécutez le JUnit Méthodes @Before dans la superclasse
2. Exécuter les méthodes @Before dans cette classe
3. Exécuter une méthode @Test dans cette classe
4. Exécutez les méthodes @After dans cette classe
5. Exécutez les méthodes @After dans la superclasse

JUnit Note de 5 : ces annotations sont JUnit 4 (org.junit). JUnit 5 les ont renommés dans org.junit.jupiter.apiainsi que, JUnit Le code 4 ci-dessous fonctionne toujours sous le moteur d'origine.

Exemple : Création d’une classe avec un fichier comme environnement de test.

public class OutputFileTest		
{
    private File output; 
    @Before	public void createOutputFile() 
    { 
       output = new File(...);
    }
  
	@After public void deleteOutputFile() 
    {
        output.delete(); 
    } 
     
    @Test public void testFile1() 
    {
       // code for test case objective
    } 
	@Test public void testFile2() 
    {
       // code for test case objective
    }
}

Dans l'exemple ci-dessus, la chaîne d'exécution sera la suivante. Le diagramme tracun cycle création-test-suppression par méthode de test.

1. createOutputFile()
2. fichiertest1()
3. supprimerOutputFile()
4. createOutputFile()
5. fichiertest2()
6. supprimerOutputFile()

Supposition:

La fonction testFile1() s'exécute avant testFile2(), ce qui n'est pas garanti.

Configuration unique

• Il est possible d'exécuter une méthode une seule fois pour toute la classe de test avant l'exécution de l'un des tests et avant tout @Avant que méthode(s).
• La configuration unique est utile pour démarrer des serveurs, établir des communications et effectuer des tâches similaires. Il est fastidieux de fermer et de rouvrir les ressources pour chaque test.
• Cela peut être fait en utilisant l'annotation @Avant les cours in JUnit.

@BeforeClass public static void Method_Name() {	
    // class setup code here	
 }	

La méthode doit être Vide public statique, Parce JUnit appelle cette fonction avant même qu'une instance de test n'existe.

Démolition unique

• À l'instar de la configuration unique, une méthode de nettoyage unique est également disponible. Elle s'exécute après toutes les méthodes de cas de test et @Après les annotations ont été exécutées.
• Il est utile pour s'arrêterping serveurs et fermeture des liaisons de communication.
• Cela peut être fait en utilisant le @Après les cours annotation.

 @AfterClass public static void Method_Name()	
 {	
    // class cleanup code here	
 }	

JUnit Suites de test

Une fois les paramètres définis, les classes de tests associées sont généralement regroupées et lancées ensemble.

Si l'on souhaite exécuter plusieurs tests dans un ordre précis, on peut les regrouper en un seul endroit. Cet endroit s'appelle une suite de tests. Plus de détails sur l'exécution et l'utilisation des suites de tests sont disponibles dans [référence manquante]. JUnit sont couverts dans ce tutoriel.

JUnit Testeur

JUnit fournit un outil pour l’exécution de vos cas de test.

• JUnitCore La classe est utilisée pour exécuter ces tests.
• Une méthode appelée classes d'exécution fourni par org.junit.runner.JUnitCore est utilisé pour exécuter une ou plusieurs classes de test.
• Le type de retour de cette méthode est le Résultat objet (org.junit.runner.Résultat), qui permet d'accéder aux informations relatives aux tests. Voir l'exemple de code suivant pour plus de clarté.

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

Dans le code ci-dessus, l'objet « result » est traité pour obtenir les échecs et les réussites des cas de test exécutés. Des fonctions d'assistance telles que affirmerÉgal mettre en lumière ces échecs, tout en @Ignorer rate un test.

JUnit Note de 5 : JUnitCore est le JUnit 4e coureur. JUnit 5 le remplace par le JUnit Plateforme complète lanceur API, normalement lancée par l'IDE, Gradle ou Maven Surefire.

Prénom JUnit Programme

Bonne connaissance du cycle de vie du développement logiciel (SDLC), Java la programmation et les bases de la test logiciel Ce processus permet de comprendre un JUnit programme, tout comme savoir comment tests unitaires différer des tests d'intégration.

Comprenons les tests unitaires à l'aide d'un exemple concret. Nous devons créer une classe de test avec une méthode de test annotée avec @Tester comme indiqué ci-dessous :

MaPremièreClasseTest.java

package guru99.JUnit;		

import static org.junit.Assert.*;				

import org.junit.Test;		

public class MyFirstClassTest {				

    @Test		
    public void myFirstMethod(){					
        String str= "JUnit is working fine";					
        assertEquals("JUnit is working fine",str);					
    }
}		

TestRunner.java

Pour exécuter notre méthode de test (ci-dessus), nous devons créer un lanceur de tests. Dans ce lanceur, nous devons ajouter la classe de test comme paramètre. JUnitLa méthode runClasses() de Core renvoie le résultat du test, selon qu'il a réussi ou échoué.

Pour plus de détails, consultez le code ci-dessous :

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(MyFirstClassTest.class);					
			for (Failure failure : result.getFailures()) {							
              System.out.println(failure.toString());					
      }		
      System.out.println("Result=="+result.wasSuccessful());							
   }		
}      	

Sortie

Une fois TestRunner.java L'exécution de nos méthodes de test nous renvoie un résultat indiquant si elles ont échoué ou réussi. Vous trouverez ci-dessous l'explication de ce résultat :

1. Dans cet exemple, après avoir exécuté MaPremièreClasseTest.javaLe test est réussi et le résultat est vert.
2. En cas d'échec, le résultat aurait été affiché en rouge, et l'échec est visible dans le résultat de l'échec. trace. Voir le JUnit Interface graphique ci-dessous :

FAQ