JUnit Cas de test @Before @BeforeClass Annotation

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

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, Après, Avant, etc.

Qu'est-ce que le dispositif de test

Avant de comprendre ce qu'est un appareil 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 n'est pas lisible
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 beaucoup plus lisible et maintenable. La structure de code ci-dessus est un Appareil d'essai.

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 requises qui rendent ces objets/ressources disponibles.
Ces activités sont
1. allocation (installation)
2. désallocation (teardown).

Installation et démontage

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 fournit des annotations qui facilitent la configuration et le démontage. Cela garantit que les ressources sont libérées et que le système de test est prêt pour le prochain scénario de test.

Ces JUnit les annotations sont discutées ci-dessous-

installation

@Avant que annotation dans JUnit est utilisé sur une méthode contenant Java code à exécuter avant chaque scénario 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 du code Java à exécuter après chaque scénario de test. Ces méthodes s'exécuteront même si des exceptions sont levées dans le scénario de test ou en cas d'échec d'assertion.

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 super classe. L'exécution est la suivante : Il s'agit d'un processus d'exécution standard dans JUnit.

Exécutez le JUnit Méthodes @Before dans la superclasse
Exécuter les méthodes @Before dans cette classe
Exécuter une méthode @Test dans cette classe
Exécutez les méthodes @After dans cette classe
Exécutez les méthodes @After dans la superclasse

Exemple : Création d'une classe avec un fichier comme appareil 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 :

createOutputFile()
fichiertest1()
supprimerOutputFile()
createOutputFile()
fichiertest2()
supprimerOutputFile()

Supposition:

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).
Les « installations uniques » sont utiles pour démarrer les serveurs, ouvrir les communications, etc. La fermeture et la réouverture des ressources pour chaque test prennent beaucoup de temps.
Cela peut être fait en utilisant l'annotation @Avant les cours in JUnit.

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

Démolition unique

Semblable à la configuration unique, une méthode de nettoyage unique est également disponible. Il 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 arrêter les serveurs, fermer les liens de communication, etc.
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

Si nous voulons exécuter plusieurs tests dans un ordre spécifique, cela peut être fait en combinant tous les tests en un seul endroit. Cet endroit est appelé suites de tests. Plus de détails sur la façon d'exécuter des suites de tests et sur la façon dont elles sont utilisées dans JUnit sera couvert dans ce tutoriel.

Exécuteur de tests Junit

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.JUnitCœur, est utilisé pour exécuter une ou plusieurs classes de test.
Le type de retour de cette méthode est le Résultats objet (org.junit.runner.Résultat), qui permet d'accéder aux informations sur les 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 « résultat » est traité pour obtenir les échecs et les résultats positifs des cas de test que nous exécutons.

Prénom JUnit Programme

Bonne connaissance de SDLC, de la programmation Java et des bases de test logiciel le processus aide à comprendre JUnit .

Comprenons les tests unitaires à l'aide d'un exemple réel. 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 test. Dans le programme d'exécution de tests, nous devons ajouter une classe de test en tant que paramètre dans JUnitMéthode runclasses() de Core. Il renverra le résultat du test, selon que le test a réussi ou échoué.

Pour plus de détails à ce sujet, 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 exécute nos méthodes de test, nous obtenons un résultat comme ayant échoué ou réussi. Veuillez trouver ci-dessous l'explication de la sortie :

Dans cet exemple, après avoir exécuté MaPremièreClasseTest.java , le test est réussi et le résultat est en vert.
S'il avait échoué, il aurait dû afficher le résultat en rouge et l'échec peut être observé dans la trace d'échec. Voir ci-dessous JUnit interface graphique :

Résumé

JUnit est un framework qui prend en charge plusieurs annotations pour identifier une méthode contenant un test.
JUnit fournit une annotation appelée @Test, qui raconte le JUnit que la méthode public void dans laquelle elle est utilisée peut s'exécuter comme scénario de test.
Un appareil de test est un contexte dans lequel un scénario de test s'exécute
Pour exécuter plusieurs tests dans un ordre spécifié, cela peut être fait en combinant tous les tests en un seul endroit. Cet endroit est appelé les suites de tests.
JUnit fournit un outil pour l'exécution des tests où nous pouvons exécuter nos cas de test appelés Test Runner.