JUnit - Guide rapide

Le test est le processus de vérification de la fonctionnalité d'une application pour s'assurer qu'elle s'exécute conformément aux exigences. Les tests unitaires interviennent au niveau des développeurs; c'est le test d'une seule entité (classe ou méthode). Les tests unitaires jouent un rôle essentiel pour aider une entreprise de logiciels à fournir des produits de qualité à ses clients.

Les tests unitaires peuvent être effectués de deux manières: les tests manuels et les tests automatisés.

Test manuel	Test automatisé
L'exécution manuelle d'un cas de test sans aucune prise en charge d'outil est appelée test manuel.	Prendre en charge les outils et exécuter les cas de test à l'aide d'un outil d'automatisation est appelé test d'automatisation.
Time-consuming and tedious - Les cas de test étant exécutés par des ressources humaines, c'est très lent et fastidieux.	Fast - L'automatisation exécute les cas de test beaucoup plus rapidement que les ressources humaines.
Huge investment in human resources - Les cas de test devant être exécutés manuellement, plus de testeurs sont nécessaires pour les tests manuels.	Less investment in human resources - Les cas de test sont exécutés à l'aide d'outils d'automatisation, de sorte que moins de testeurs sont nécessaires dans les tests d'automatisation.
Less reliable - Les tests manuels sont moins fiables, car ils doivent tenir compte des erreurs humaines.	More reliable - Les tests d'automatisation sont précis et fiables.
Non-programmable - Aucune programmation ne peut être effectuée pour écrire des tests sophistiqués pour récupérer des informations cachées.	Programmable - Les testeurs peuvent programmer des tests sophistiqués pour faire ressortir des informations cachées.

Qu'est-ce que JUnit?

JUnit est un framework de test unitaire pour le langage de programmation Java. Il joue un rôle crucial dans le développement piloté par les tests et est une famille de frameworks de tests unitaires collectivement connus sous le nom de xUnit.

JUnit promeut l'idée de "tester d'abord puis coder", qui met l'accent sur la configuration des données de test pour un morceau de code qui peut être testé en premier, puis implémenté. Cette approche est comme "tester un peu, coder un peu, tester un peu, coder un peu". Cela augmente la productivité du programmeur et la stabilité du code du programme, ce qui réduit le stress du programmeur et le temps consacré au débogage.

Caractéristiques de JUnit

• JUnit est un framework open source, utilisé pour écrire et exécuter des tests.

• Fournit des annotations pour identifier les méthodes de test.

• Fournit des affirmations pour tester les résultats attendus.

• Fournit des exécuteurs de test pour exécuter des tests.

• Les tests JUnit vous permettent d'écrire des codes plus rapidement, ce qui augmente la qualité.

• JUnit est d'une simplicité élégante. C'est moins complexe et prend moins de temps.

• Les tests JUnit peuvent être exécutés automatiquement et ils vérifient leurs propres résultats et fournissent une rétroaction immédiate. Il n'est pas nécessaire de parcourir manuellement un rapport des résultats de test.

• Les tests JUnit peuvent être organisés en suites de tests contenant des cas de test et même d'autres suites de tests.

• JUnit affiche la progression du test dans une barre qui est verte si le test se déroule correctement, et elle devient rouge lorsqu'un test échoue.

Qu'est-ce qu'un scénario de test unitaire?

Un cas de test unitaire est une partie du code, ce qui garantit qu'une autre partie du code (méthode) fonctionne comme prévu. Pour obtenir rapidement les résultats souhaités, un cadre de test est nécessaire. JUnit est un cadre de test unitaire parfait pour le langage de programmation Java.

Un cas de test unitaire écrit formel est caractérisé par une entrée connue et une sortie attendue, qui sont élaborées avant l'exécution du test. L'entrée connue doit tester une condition préalable et la sortie attendue doit tester une post-condition.

Il doit y avoir au moins deux cas de test unitaires pour chaque exigence - un test positif et un test négatif. Si une exigence a des sous-exigences, chaque sous-exigence doit avoir au moins deux cas de test positifs et négatifs.

Configuration de l'environnement local

JUnit est un framework pour Java, donc la toute première exigence est d'avoir JDK installé sur votre machine.

Exigence du système

JDK	1.5 ou supérieur.
Mémoire	Aucune exigence minimale.
Espace disque	Aucune exigence minimale.
Système opérateur	Aucune exigence minimale.

Étape 1: Vérifiez l'installation de Java sur votre machine

Tout d'abord, ouvrez la console et exécutez une commande java basée sur le système d'exploitation sur lequel vous travaillez.

OS	Tâche	Commander
les fenêtres	Ouvrez la console de commande	c: \> java -version
Linux	Ouvrir le terminal de commande	$ java -version
Mac	Terminal ouvert	machine: ~ joseph $ java -version

Vérifions la sortie pour tous les systèmes d'exploitation -

OS	Production
les fenêtres	version java "1.8.0_101" Environnement d'exécution Java (TM) SE (build 1.8.0_101)
Linux	version java "1.8.0_101" Environnement d'exécution Java (TM) SE (build 1.8.0_101)
Mac	version java "1.8.0_101" Environnement d'exécution Java (TM) SE (build 1.8.0_101)

Si Java n'est pas installé sur votre système, téléchargez le kit de développement logiciel Java (SDK) à partir du lien suivant https://www.oracle.com. Nous supposons que Java 1.8.0_101 est la version installée pour ce didacticiel.

Étape 2: définir l'environnement JAVA

Met le JAVA_HOMEvariable d'environnement pour pointer vers l'emplacement du répertoire de base où Java est installé sur votre machine. Par exemple.

OS	Production
les fenêtres	Définissez la variable d'environnement JAVA_HOME sur C: \ Program Files \ Java \ jdk1.8.0_101
Linux	export JAVA_HOME = / usr / local / java-current
Mac	export JAVA_HOME = / Bibliothèque / Java / Accueil

Ajoutez l'emplacement du compilateur Java au chemin système.

OS	Production
les fenêtres	Ajouter la chaîne C:\Program Files\Java\jdk1.8.0_101\bin à la fin de la variable système, Path.
Linux	export PATH = $PATH:$JAVA_HOME / bin /
Mac	non requis

Vérifiez l'installation de Java à l'aide de la commande java -version comme expliqué ci-dessus.

Étape 3: Téléchargez l'archive JUnit

Téléchargez la dernière version du fichier jar JUnit à partir de http://www.junit.org. Au moment de la rédaction de ce didacticiel, nous avons téléchargé Junit-4.12.jar et l'avons copié dans le dossier C: \> JUnit.

OS	Nom de l'archive
les fenêtres	junit4.12.jar
Linux	junit4.12.jar
Mac	junit4.12.jar

Étape 4: définir l'environnement JUnit

Met le JUNIT_HOMEvariable d'environnement pour pointer vers l'emplacement du répertoire de base où JUNIT jar est stocké sur votre machine. Supposons que nous ayons stocké junit4.12.jar dans le dossier JUNIT.

Sr.Non	OS et description
1	Windows Définissez la variable d'environnement JUNIT_HOME sur C: \ JUNIT
2	Linux export JUNIT_HOME = / usr / local / JUNIT
3	Mac export JUNIT_HOME = / Bibliothèque / JUNIT

Étape 5: Définissez la variable CLASSPATH

Met le CLASSPATH variable d'environnement pour pointer vers l'emplacement du fichier JUNIT.

Sr.Non	OS et description
1	Windows Définissez la variable d'environnement CLASSPATH sur% CLASSPATH%;% JUNIT_HOME% \ junit4.12.jar;.;
2	Linux export CLASSPATH = $CLASSPATH:$JUNIT_HOME / junit4.12.jar :.
3	Mac export CLASSPATH = $CLASSPATH:$JUNIT_HOME / junit4.12.jar :.

Étape 6: Tester la configuration de JUnit

Créer un nom de fichier de classe Java TestJunit dans C:\>JUNIT_WORKSPACE

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

public class TestJunit {
   @Test
	
   public void testAdd() {
      String str = "Junit is working fine";
      assertEquals("Junit is working fine",str);
   }
}

Créer un nom de fichier de classe Java TestRunner dans C:\>JUNIT_WORKSPACE pour exécuter des cas de test.

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

Étape 7: Vérifiez le résultat

Compilez les classes en utilisant javac compilateur comme suit -

C:\JUNIT_WORKSPACE>javac TestJunit.java TestRunner.java

Maintenant, exécutez le Test Runner pour voir le résultat comme suit -

C:\JUNIT_WORKSPACE>java TestRunner

Vérifiez la sortie.

true

JUnit est un Regression Testing Frameworkutilisé par les développeurs pour implémenter des tests unitaires en Java, accélérer la vitesse de programmation et augmenter la qualité du code. JUnit Framework peut être facilement intégré avec l'un des éléments suivants:

• Eclipse
• Ant
• Maven

Fonctionnalités de JUnit Test Framework

Le framework de test JUnit fournit les fonctionnalités importantes suivantes -

• Fixtures
• Suites de tests
• Coureurs d'essai
• Classes JUnit

Agencements

Fixturesest un état fixe d'un ensemble d'objets utilisé comme base de référence pour l'exécution de tests. Le but d'un montage de test est de s'assurer qu'il existe un environnement bien connu et fixe dans lequel les tests sont exécutés afin que les résultats soient reproductibles. Il comprend -

• setUp (), qui s'exécute avant chaque appel de test.
• tearDown (), qui s'exécute après chaque méthode de test.

Vérifions un exemple -

import junit.framework.*;

public class JavaTest extends TestCase {
   protected int value1, value2;
   
   // assigning the values
   protected void setUp(){
      value1 = 3;
      value2 = 3;
   }

   // test method to add two values
   public void testAdd(){
      double result = value1 + value2;
      assertTrue(result == 6);
   }
}

Suites de test

Une suite de tests regroupe quelques cas de test unitaires et les exécute ensemble. Dans JUnit, les annotations @RunWith et @Suite sont utilisées pour exécuter le test de la suite. Vous trouverez ci-dessous un exemple qui utilise les classes de test TestJunit1 et TestJunit2.

import org.junit.runner.RunWith;
import org.junit.runners.Suite;

//JUnit Suite Test
@RunWith(Suite.class)

@Suite.SuiteClasses({ 
   TestJunit1.class ,TestJunit2.class
})

public class JunitTestSuite {
}

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

public class TestJunit1 {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
   
   @Test
   public void testPrintMessage() {	
      System.out.println("Inside testPrintMessage()");    
      assertEquals(message, messageUtil.printMessage());     
   }
}

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

public class TestJunit2 {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
 
   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Robert";
      assertEquals(message,messageUtil.salutationMessage());
   }
}

Test Runners

Test Runner est utilisé pour exécuter les cas de test. Voici un exemple qui suppose la classe de testTestJunit existe déjà.

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

Classes JUnit

Les classes JUnit sont des classes importantes, utilisées pour écrire et tester des JUnits. Certaines des classes importantes sont -

• Assert - Contient un ensemble de méthodes d'assert.

• TestCase - Contient un cas de test qui définit l'appareil pour exécuter plusieurs tests.

• TestResult - Contient des méthodes pour collecter les résultats de l'exécution d'un scénario de test.

Prenons maintenant un exemple de base pour illustrer le processus étape par étape d'utilisation de JUnit.

Créer une classe

Créez une classe Java à tester, disons MessageUtil.java dans C:\>JUNIT_WORKSPACE

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
	
   public MessageUtil(String message){
      this.message = message;
   }
      
   // prints the message
   public String printMessage(){
      System.out.println(message);
      return message;
   }   
}

Créer une classe de cas de test

• Créez une classe de test java, par exemple TestJunit.java.
• Ajoutez une méthode de test testPrintMessage () à votre classe de test.
• Ajoutez un Annotaion @Test à la méthode testPrintMessage ().
• Implémentez la condition de test et vérifiez la condition à l'aide de l'API assertEquals de JUnit.

Créez un nom de fichier de classe Java TestJunit.java dans C:\>JUNIT_WORKSPACE.

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

public class TestJunit {
	
   String message = "Hello World";	
   MessageUtil messageUtil = new MessageUtil(message);

   @Test
   public void testPrintMessage() {
      assertEquals(message,messageUtil.printMessage());
   }
}

Créer une classe Test Runner

• Créez une classe java TestRunner.
• Utilisez la méthode runClasses de la classe JUnitCore de JUnit pour exécuter le scénario de test de la classe de test créée ci-dessus.
• Obtenez le résultat des cas de test exécutés dans l'objet du résultat.
• Obtenez les échecs en utilisant la méthode getFailures () de l'objet Result.
• Obtenez le résultat Success en utilisant la méthode wasSuccessful () de l'objet Result.

Créez un fichier de classe Java nommé TestRunner.java dans C:\>JUNIT_WORKSPACE pour exécuter des cas de test.

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

Compilez les classes MessageUtil, Test case et Test Runner à l'aide de javac.

C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java

Exécutez maintenant le Test Runner, qui exécutera le scénario de test défini dans la classe de scénario de test fournie.

C:\JUNIT_WORKSPACE>java TestRunner

Vérifiez la sortie.

Hello World
true

Maintenant, mettez à jour TestJunit dans C:\>JUNIT_WORKSPACEde sorte que le test échoue. Modifiez la chaîne du message.

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

public class TestJunit {
	
   String message = "Hello World";	
   MessageUtil messageUtil = new MessageUtil(message);

   @Test
   public void testPrintMessage() {
      message = "New Word";
      assertEquals(message,messageUtil.printMessage());
   }
}

Gardons le reste des classes tel quel et essayons d'exécuter le même Test Runner.

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

Exécutez maintenant le Test Runner, qui exécutera le scénario de test défini dans la classe de scénario de test fournie.

C:\JUNIT_WORKSPACE>java TestRunner

Vérifiez la sortie.

Hello World
testPrintMessage(TestJunit): expected:<[New Wor]d> but was:<[Hello Worl]d>
false

Le package le plus important de JUnit est junit.framework, qui contient toutes les classes principales. Certaines des classes importantes sont les suivantes -

Sr.No.	Nom du cours	Fonctionnalité
1	Affirmer	Un ensemble de méthodes d'assert.
2	Cas de test	Un cas de test définit l'appareil pour exécuter plusieurs tests.
3	Résultat du test	Un TestResult collecte les résultats de l'exécution d'un scénario de test.
4	Suite de tests	Un TestSuite est un composite de tests.

Assert Class

Voici la déclaration pour org.junit.Assert classe -

public class Assert extends java.lang.Object

Cette classe fournit un ensemble de méthodes d'assertion utiles pour écrire des tests. Seules les affirmations ayant échoué sont enregistrées. Certaines des méthodes importantes de la classe Assert sont les suivantes:

Sr.No.	Méthodes et description
1	void assertEquals(boolean expected, boolean actual) Vérifie que deux primitives / objets sont égaux.
2	void assertFalse(boolean condition) Vérifie qu'une condition est fausse.
3	void assertNotNull(Object object) Vérifie qu'un objet n'est pas nul.
4	void assertNull(Object object) Vérifie qu'un objet est nul.
5	void assertTrue(boolean condition) Vérifie qu'une condition est vraie.
6	void fail() Échoue un test sans message.

Utilisons certaines des méthodes mentionnées ci-dessus dans un exemple. Créez un fichier de classe Java nommé TestJunit1.java dansC:\>JUNIT_WORKSPACE.

import org.junit.Test;
import static org.junit.Assert.*;

public class TestJunit1 {
   @Test
   public void testAdd() {
      //test data
      int num = 5;
      String temp = null;
      String str = "Junit is working fine";

      //check for equality
      assertEquals("Junit is working fine", str);
      
      //check for false condition
      assertFalse(num > 6);

      //check for not null value
      assertNotNull(temp);
   }
}

Ensuite, créez un fichier de classe Java nommé TestRunner1.java dans C: \> JUNIT_WORKSPACE pour exécuter le ou les cas de test.

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

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

Compilez le scénario de test et les classes Test Runner à l'aide de javac.

C:\JUNIT_WORKSPACE>javac TestJunit1.java TestRunner1.java

Exécutez maintenant le Test Runner, qui exécutera le scénario de test défini dans la classe de scénario de test fournie.

C:\JUNIT_WORKSPACE>java TestRunner1

Vérifiez la sortie.

true

Classe TestCase

Voici la déclaration pour org.junit.TestCase classe -

public abstract class TestCase extends Assert implements Test

Un cas de test définit l'appareil pour exécuter plusieurs tests. Certaines des méthodes importantes deTestCase les classes sont les suivantes -

Sr.No.	Méthodes et description
1	int countTestCases() Compte le nombre de cas de test exécutés par run (résultat TestResult).
2	TestResult createResult() Crée un objet TestResult par défaut.
3	String getName() Obtient le nom d'un TestCase.
4	TestResult run() Une méthode pratique pour exécuter ce test, en collectant les résultats avec un objet TestResult par défaut.
5	void run(TestResult result) Exécute le scénario de test et collecte les résultats dans TestResult.
6	void setName(String name) Définit le nom d'un TestCase.
sept	void setUp() Configurez l'appareil, par exemple, ouvrez une connexion réseau.
8	void tearDown() Démarre l'appareil, par exemple, ferme une connexion réseau.
9	String toString() Renvoie une représentation sous forme de chaîne du scénario de test.

Utilisons certaines des méthodes mentionnées ci-dessus dans un exemple. Créez un fichier de classe Java nomméTestJunit2.java dans C: \> JUNIT_WORKSPACE.

import junit.framework.TestCase;
import org.junit.Before;
import org.junit.Test;

public class TestJunit2 extends TestCase  {
   protected double fValue1;
   protected double fValue2;
   
   @Before 
   public void setUp() {
      fValue1 = 2.0;
      fValue2 = 3.0;
   }
	
   @Test
   public void testAdd() {
      //count the number of test cases
      System.out.println("No of Test Case = "+ this.countTestCases());
		
      //test getName 
      String name = this.getName();
      System.out.println("Test Case Name = "+ name);

      //test setName
      this.setName("testNewAdd");
      String newName = this.getName();
      System.out.println("Updated Test Case Name = "+ newName);
   }
	
   //tearDown used to close the connection or clean up activities
   public void tearDown(  ) {
   }
}

Ensuite, créez un fichier de classe Java nommé TestRunner2.java dans C: \> JUNIT_WORKSPACE pour exécuter le ou les cas de test.

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

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

Compilez le scénario de test et les classes Test Runner à l'aide de javac.

C:\JUNIT_WORKSPACE>javac TestJunit2.java TestRunner2.java

Exécutez maintenant le Test Runner, qui exécutera le scénario de test défini dans la classe de scénario de test fournie.

C:\JUNIT_WORKSPACE>java TestRunner2

Vérifiez la sortie.

No of Test Case = 1
Test Case Name = testAdd
Updated Test Case Name = testNewAdd
true

Classe TestResult

Voici la déclaration pour org.junit.TestResult classe -

public class TestResult extends Object

Un TestResult collecte les résultats de l'exécution d'un scénario de test. Il s'agit d'une instance du modèle Collecting Parameter. Le cadre de test fait la distinction entre les échecs et les erreurs. Un échec est anticipé et vérifié avec des affirmations. Les erreurs sont des problèmes imprévus comme une ArrayIndexOutOfBoundsException. Certaines des méthodes importantes deTestResult les classes sont les suivantes -

Sr.No.	Méthodes et description
1	void addError(Test test, Throwable t) Ajoute une erreur à la liste des erreurs.
2	void addFailure(Test test, AssertionFailedError t) Ajoute un échec à la liste des échecs.
3	void endTest(Test test) Informe le résultat qu'un test a été terminé.
4	int errorCount() Obtient le nombre d'erreurs détectées.
5	Enumeration<TestFailure> errors() Renvoie une énumération pour les erreurs.
6	int failureCount() Obtient le nombre d'échecs détectés.
sept	void run(TestCase test) Exécute un TestCase.
8	int runCount() Obtient le nombre de tests exécutés.
9	void startTest(Test test) Informe le résultat qu'un test sera lancé.
dix	void stop() Marque que le test doit s'arrêter.

Créez un fichier de classe Java nommé TestJunit3.java dans C: \> JUNIT_WORKSPACE.

import org.junit.Test;
import junit.framework.AssertionFailedError;
import junit.framework.TestResult;

public class TestJunit3 extends TestResult {
   // add the error
   public synchronized void addError(Test test, Throwable t) {
      super.addError((junit.framework.Test) test, t);
   }

   // add the failure
   public synchronized void addFailure(Test test, AssertionFailedError t) {
      super.addFailure((junit.framework.Test) test, t);
   }
	
   @Test
   public void testAdd() {
      // add any test
   }
   
   // Marks that the test run should stop.
   public synchronized void stop() {
      //stop the test here
   }
}

Ensuite, créez un fichier de classe Java nommé TestRunner3.java dans C: \> JUNIT_WORKSPACE pour exécuter le ou les cas de test.

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

public class TestRunner3 {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(TestJunit3.class);

      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Compilez le scénario de test et les classes Test Runner à l'aide de javac.

C:\JUNIT_WORKSPACE>javac TestJunit3.java TestRunner3.java

Exécutez maintenant le Test Runner, qui exécutera le scénario de test défini dans la classe de scénario de test fournie.

C:\JUNIT_WORKSPACE>java TestRunner3

Vérifiez la sortie.

true

Classe TestSuite

Voici la déclaration pour org.junit.TestSuite classe:

public class TestSuite extends Object implements Test

Un TestSuite est un Composite de tests. Il exécute une collection de cas de test. Certaines des méthodes importantes deTestSuite les classes sont les suivantes -

Sr.No.	Méthodes et description
1	void addTest(Test test) Ajoute un test à la suite.
2	void addTestSuite(Class<? extends TestCase> testClass) Ajoute les tests de la classe donnée à la suite.
3	int countTestCases() Compte le nombre de cas de test qui seront exécutés par ce test.
4	String getName() Renvoie le nom de la suite.
5	void run(TestResult result) Exécute les tests et collecte leur résultat dans un TestResult.
6	void setName(String name) Définit le nom de la suite.
sept	Test testAt(int index) Renvoie le test à l'index donné.
8	int testCount() Renvoie le nombre de tests dans cette suite.
9	static Test warning(String message) Renvoie un test qui échouera et consignera un message d'avertissement.

Créez un fichier de classe Java nommé JunitTestSuite.java dans C: \> JUNIT_WORKSPACE pour créer la suite de tests.

import junit.framework.*;

public class JunitTestSuite {
   public static void main(String[] a) {
      // add the test's in the suite
      TestSuite suite = new TestSuite(TestJunit1.class, TestJunit2.class, TestJunit3.class );
      TestResult result = new TestResult();
      suite.run(result);
      System.out.println("Number of test cases = " + result.runCount());
   }
}

Compilez les classes de la suite de tests à l'aide de javac.

C:\JUNIT_WORKSPACE>javac JunitTestSuite.java

Exécutez maintenant la suite de tests.

C:\JUNIT_WORKSPACE>java JunitTestSuite

Vérifiez la sortie.

No of Test Case = 1
Test Case Name = testAdd
Updated Test Case Name = testNewAdd
Number of test cases = 3

Ici, nous allons voir un exemple complet de test JUnit utilisant la classe POJO, la classe de logique métier et une classe de test, qui sera exécutée par le testeur.

Créer EmployeeDetails.java dans C: \> JUNIT_WORKSPACE, qui est une classe POJO.

public class EmployeeDetails {

   private String name;
   private double monthlySalary;
   private int age;
   
   /**
   * @return the name
   */
	
   public String getName() {
      return name;
   }
	
   /**
   * @param name the name to set
   */
	
   public void setName(String name) {
      this.name = name;
   }
	
   /**
   * @return the monthlySalary
   */
	
   public double getMonthlySalary() {
      return monthlySalary;
   }
	
   /**
   * @param monthlySalary the monthlySalary to set
   */
	
   public void setMonthlySalary(double monthlySalary) {
      this.monthlySalary = monthlySalary;
   }
	
   /**
   * @return the age
   */
   public int getAge() {
      return age;
   }
	
   /**
   * @param age the age to set
   */
   public void setAge(int age) {
      this.age = age;
   }
}

EmployeeDetails la classe est utilisée pour -

• obtenir / définir la valeur du nom de l'employé.
• obtenir / définir la valeur du salaire mensuel de l'employé.
• obtenir / définir la valeur de l'âge de l'employé.

Créez un fichier appelé EmpBusinessLogic.java dans C: \> JUNIT_WORKSPACE, qui contient la logique métier.

public class EmpBusinessLogic {
   // Calculate the yearly salary of employee
   public double calculateYearlySalary(EmployeeDetails employeeDetails) {
      double yearlySalary = 0;
      yearlySalary = employeeDetails.getMonthlySalary() * 12;
      return yearlySalary;
   }
	
   // Calculate the appraisal amount of employee
   public double calculateAppraisal(EmployeeDetails employeeDetails) {
      double appraisal = 0;
		
      if(employeeDetails.getMonthlySalary() < 10000){
         appraisal = 500;
      }else{
         appraisal = 1000;
      }
		
      return appraisal;
   }
}

EmpBusinessLogic la classe est utilisée pour calculer -

• le salaire annuel d'un employé.
• le montant de l'évaluation d'un employé.

Créez un fichier appelé TestEmployeeDetails.java dans C: \> JUNIT_WORKSPACE, qui contient les cas de test à tester.

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

public class TestEmployeeDetails {
   EmpBusinessLogic empBusinessLogic = new EmpBusinessLogic();
   EmployeeDetails employee = new EmployeeDetails();

   //test to check appraisal
   @Test
   public void testCalculateAppriasal() {
      employee.setName("Rajeev");
      employee.setAge(25);
      employee.setMonthlySalary(8000);
		
      double appraisal = empBusinessLogic.calculateAppraisal(employee);
      assertEquals(500, appraisal, 0.0);
   }

   // test to check yearly salary
   @Test
   public void testCalculateYearlySalary() {
      employee.setName("Rajeev");
      employee.setAge(25);
      employee.setMonthlySalary(8000);
		
      double salary = empBusinessLogic.calculateYearlySalary(employee);
      assertEquals(96000, salary, 0.0);
   }
}

TestEmployeeDetails class est utilisé pour tester les méthodes de EmpBusinessLogicclasse. Il

• teste le salaire annuel de l'employé.
• teste le montant de l'évaluation de l'employé.

Ensuite, créez une classe java nommée TestRunner.java dans C: \> JUNIT_WORKSPACE pour exécuter le ou les cas de test.

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

Compilez le scénario de test et les classes Test Runner à l'aide de javac.

C:\JUNIT_WORKSPACE>javac EmployeeDetails.java 
EmpBusinessLogic.java TestEmployeeDetails.java TestRunner.java

Exécutez maintenant le Test Runner, qui exécutera le scénario de test défini dans la classe de scénario de test fournie.

C:\JUNIT_WORKSPACE>java TestRunner

Vérifiez la sortie.

true

Affirmation

Toutes les assertions sont dans la classe Assert.

public class Assert extends java.lang.Object

Cette classe fournit un ensemble de méthodes d'assertion, utiles pour écrire des tests. Seules les affirmations ayant échoué sont enregistrées. Certaines des méthodes importantes de la classe Assert sont les suivantes:

Sr.No.	Méthodes et description
1	void assertEquals(boolean expected, boolean actual) Vérifie que deux primitives / objets sont égaux.
2	void assertTrue(boolean condition) Vérifie qu'une condition est vraie.
3	void assertFalse(boolean condition) Vérifie qu'une condition est fausse.
4	void assertNotNull(Object object) Vérifie qu'un objet n'est pas nul.
5	void assertNull(Object object) Vérifie qu'un objet est nul.
6	void assertSame(object1, object2) La méthode assertSame () teste si deux références d'objet pointent vers le même objet.
sept	void assertNotSame(object1, object2) La méthode assertNotSame () teste si deux références d'objet ne pointent pas vers le même objet.
8	void assertArrayEquals(expectedArray, resultArray); La méthode assertArrayEquals () testera si deux tableaux sont égaux l'un à l'autre.

Utilisons certaines des méthodes mentionnées ci-dessus dans un exemple. Créez un fichier de classe Java nomméTestAssertions.java dans C: \> JUNIT_WORKSPACE.

import org.junit.Test;
import static org.junit.Assert.*;

public class TestAssertions {

   @Test
   public void testAssertions() {
      //test data
      String str1 = new String ("abc");
      String str2 = new String ("abc");
      String str3 = null;
      String str4 = "abc";
      String str5 = "abc";
		
      int val1 = 5;
      int val2 = 6;

      String[] expectedArray = {"one", "two", "three"};
      String[] resultArray =  {"one", "two", "three"};

      //Check that two objects are equal
      assertEquals(str1, str2);

      //Check that a condition is true
      assertTrue (val1 < val2);

      //Check that a condition is false
      assertFalse(val1 > val2);

      //Check that an object isn't null
      assertNotNull(str1);

      //Check that an object is null
      assertNull(str3);

      //Check if two object references point to the same object
      assertSame(str4,str5);

      //Check if two object references not point to the same object
      assertNotSame(str1,str3);

      //Check whether two arrays are equal to each other.
      assertArrayEquals(expectedArray, resultArray);
   }
}

Ensuite, créez un fichier de classe Java nommé TestRunner.java dans C: \> JUNIT_WORKSPACE pour exécuter le ou les cas de test.

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

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

Compilez le scénario de test et les classes Test Runner à l'aide de javac.

C:\JUNIT_WORKSPACE>javac TestAssertions.java TestRunner.java

Exécutez maintenant le Test Runner, qui exécutera le scénario de test défini dans la classe de scénario de test fournie.

C:\JUNIT_WORKSPACE>java TestRunner

Vérifiez la sortie.

true

Annotation

Les annotations sont comme des méta-balises que vous pouvez ajouter à votre code et les appliquer à des méthodes ou en classe. Ces annotations dans JUnit fournissent les informations suivantes sur les méthodes de test -

• quelles méthodes vont être exécutées avant et après les méthodes de test.
• quelles méthodes s'exécutent avant et après toutes les méthodes, et.
• quelles méthodes ou classes seront ignorées lors de l'exécution.

Le tableau suivant fournit une liste d'annotations et leur signification dans JUnit -

Sr.No.	Annotation et description
1	@Test L'annotation Test indique à JUnit que la méthode publique void à laquelle elle est attachée peut être exécutée en tant que scénario de test.
2	@Before Plusieurs tests nécessitent des objets similaires créés avant de pouvoir s'exécuter. L'annotation d'une méthode void publique avec @Before entraîne l'exécution de cette méthode avant chaque méthode Test.
3	@After Si vous allouez des ressources externes dans une méthode Before, vous devez les libérer après l'exécution du test. L'annotation d'une méthode void publique avec @After entraîne l'exécution de cette méthode après la méthode Test.
4	@BeforeClass L'annotation d'une méthode void statique publique avec @BeforeClass entraîne son exécution une fois avant l'une des méthodes de test de la classe.
5	@AfterClass Cela exécutera la méthode une fois tous les tests terminés. Cela peut être utilisé pour effectuer des activités de nettoyage.
6	@Ignore L'annotation Ignorer est utilisée pour ignorer le test et ce test ne sera pas exécuté.

Créez un fichier de classe Java nommé JunitAnnotation.java dans C: \> JUNIT_WORKSPACE pour tester l'annotation.

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 JunitAnnotation {
	
   //execute before class
   @BeforeClass
   public static void beforeClass() {
      System.out.println("in before class");
   }

   //execute after class
   @AfterClass
   public static void  afterClass() {
      System.out.println("in after class");
   }

   //execute before test
   @Before
   public void before() {
      System.out.println("in before");
   }
	
   //execute after test
   @After
   public void after() {
      System.out.println("in after");
   }
	
   //test case
   @Test
   public void test() {
      System.out.println("in test");
   }
	
   //test case ignore and will not execute
   @Ignore
   public void ignoreTest() {
      System.out.println("in ignore test");
   }
}

Ensuite, créez un fichier de classe Java nommé TestRunner.java dans C: \> JUNIT_WORKSPACE pour exécuter des annotations.

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

Compilez le scénario de test et les classes Test Runner à l'aide de javac.

C:\JUNIT_WORKSPACE>javac JunitAnnotation.java TestRunner.java

Exécutez maintenant le Test Runner, qui exécutera le scénario de test défini dans la classe de scénario de test fournie.

C:\JUNIT_WORKSPACE>java TestRunner

Vérifiez la sortie.

in before class
in before
in test
in after
in after class
true

Ce chapitre explique la procédure d'exécution des méthodes dans JUnit, qui définit l'ordre des méthodes appelées. La procédure d'exécution des méthodes de l'API de test JUnit avec un exemple est abordée ci-dessous.

Créez un fichier de classe Java nommé ExecutionProcedureJunit.java dans C: \> JUNIT_WORKSPACE pour tester l'annotation.

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 ExecutionProcedureJunit {
	
   //execute only once, in the starting 
   @BeforeClass
   public static void beforeClass() {
      System.out.println("in before class");
   }

   //execute only once, in the end
   @AfterClass
   public static void  afterClass() {
      System.out.println("in after class");
   }

   //execute for each test, before executing test
   @Before
   public void before() {
      System.out.println("in before");
   }
	
   //execute for each test, after executing test
   @After
   public void after() {
      System.out.println("in after");
   }
	
   //test case 1
   @Test
   public void testCase1() {
      System.out.println("in test case 1");
   }

   //test case 2
   @Test
   public void testCase2() {
      System.out.println("in test case 2");
   }
}

Ensuite, créez un fichier de classe Java nommé TestRunner.java dans C: \> JUNIT_WORKSPACE pour exécuter des annotations.

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(ExecutionProcedureJunit.class);

      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Compilez le scénario de test et les classes Test Runner à l'aide de javac.

C:\JUNIT_WORKSPACE>javac ExecutionProcedureJunit.java TestRunner.java

Exécutez maintenant le Test Runner, qui exécutera le scénario de test défini dans la classe de scénario de test fournie.

C:\JUNIT_WORKSPACE>java TestRunner

Vérifiez la sortie.

in before class
in before
in test case 1
in after
in before
in test case 2
in after
in after class

Voir la sortie ci-dessus. La procédure d'exécution est la suivante -

• Tout d'abord, la méthode beforeClass () ne s'exécute qu'une seule fois.
• La méthode afterClass () ne s'exécute qu'une seule fois.
• La méthode before () s'exécute pour chaque cas de test, mais avant d'exécuter le cas de test.
• La méthode after () s'exécute pour chaque cas de test, mais après l'exécution du cas de test.
• Entre avant () et après (), chaque scénario de test s'exécute.

Les cas de test sont exécutés en utilisant JUnitCoreclasse. JUnitCore est une façade pour exécuter des tests. Il prend en charge l'exécution des tests JUnit 4, des tests JUnit 3.8.x et des mélanges. Pour exécuter des tests à partir de la ligne de commande, exécutez java org.junit.runner.JUnitCore <TestClass>. Pour les exécutions de test ponctuelles, utilisez la méthode statique runClasses (Class []).

Voici la déclaration pour org.junit.runner.JUnitCore classe:

public class JUnitCore extends java.lang.Object

Nous verrons ici comment exécuter les tests à l'aide de JUnitCore.

Créer une classe

Créez une classe java à tester, disons, MessageUtil.java, dans C: \> JUNIT_WORKSPACE.

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message){
      this.message = message;
   }
      
   // prints the message
   public String printMessage(){
      System.out.println(message);
      return message;
   }   
	
}

Créer une classe de cas de test

• Créez une classe de test java, par exemple TestJunit.java.

• Ajoutez une méthode de test testPrintMessage () à votre classe de test.

• Ajoutez un Annotaion @Test à la méthode testPrintMessage ().

• Implémentez la condition de test et vérifiez la condition à l'aide de l'API assertEquals de JUnit.

Créez un fichier de classe Java nommé TestJunit.java dans C: \> JUNIT_WORKSPACE.

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

public class TestJunit {
	
   String message = "Hello World";	
   MessageUtil messageUtil = new MessageUtil(message);

   @Test
   public void testPrintMessage() {
      assertEquals(message,messageUtil.printMessage());
   }
}

Créer une classe Test Runner

Créez maintenant un fichier de classe Java nommé TestRunner.javadans C: \> JUNIT_WORKSPACE pour exécuter le ou les cas de test. Il importe la classe JUnitCore et utilise la méthode runClasses () qui prend le nom de la classe de test comme paramètre.

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

Compilez le scénario de test et les classes Test Runner à l'aide de javac.

C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java

Exécutez maintenant le Test Runner, qui exécutera le scénario de test défini dans la classe de scénario de test fournie.

C:\JUNIT_WORKSPACE>java TestRunner

Vérifiez la sortie.

Hello World
true

Test suiteest utilisé pour regrouper quelques cas de test unitaires et les exécuter ensemble. Dans JUnit, les deux@RunWith et @Suiteles annotations sont utilisées pour exécuter les tests de la suite. Ce chapitre prend un exemple ayant deux classes de test,TestJunit1 & TestJunit2, qui fonctionnent ensemble à l'aide de Test Suite.

Créer une classe

Créez une classe java à tester, disons, MessageUtil.java dans C: \> JUNIT_WORKSPACE.

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message){
      this.message = message; 
   }

   // prints the message
   public String printMessage(){
      System.out.println(message);
      return message;
   }   

   // add "Hi!" to the message
   public String salutationMessage(){
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }   
}

Créer des classes de cas de test

Créez un fichier de classe Java nommé TestJunit1.java dans C: \> JUNIT_WORKSPACE.

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

public class TestJunit1 {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
   
   @Test
   public void testPrintMessage() {	
      System.out.println("Inside testPrintMessage()");    
      assertEquals(message, messageUtil.printMessage());     
   }
}

Créez un fichier de classe Java nommé TestJunit2.java dans C: \> JUNIT_WORKSPACE.

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

public class TestJunit2 {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
 
   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Robert";
      assertEquals(message,messageUtil.salutationMessage());
   }
}

Créer une classe de suite de tests

• Créez une classe java.
• Attachez l'annotation @RunWith (Suite.class) à la classe.
• Ajoutez une référence aux classes de test JUnit à l'aide de l'annotation @ Suite.SuiteClasses.

Créez un fichier de classe Java nommé TestSuite.java dans C: \> JUNIT_WORKSPACE pour exécuter le ou les cas de test.

import org.junit.runner.RunWith;
import org.junit.runners.Suite;

@RunWith(Suite.class)

@Suite.SuiteClasses({
   TestJunit1.class,
   TestJunit2.class
})

public class JunitTestSuite {   
}

Créer une classe Test Runner

Créez un fichier de classe Java nommé TestRunner.java dans C: \> JUNIT_WORKSPACE pour exécuter le ou les cas de test.

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(JunitTestSuite.class);

      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Compilez toutes les classes java en utilisant javac.

C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit1.java 
TestJunit2.java JunitTestSuite.java TestRunner.java

Exécutez maintenant le Test Runner, qui exécutera le scénario de test défini dans la classe de scénario de test fournie.

C:\JUNIT_WORKSPACE>java TestRunner

Vérifiez la sortie.

Inside testPrintMessage()
Robert
Inside testSalutationMessage()
Hi Robert
true

Parfois, il arrive que notre code ne soit pas complètement prêt lors de l'exécution d'un cas de test. En conséquence, le scénario de test échoue. le@Ignore l'annotation aide dans ce scénario.

• Une méthode de test annotée avec @Ignore ne sera pas exécutée.

• Si une classe de test est annotée avec @Ignore, aucune de ses méthodes de test ne sera exécutée.

Voyons maintenant @Ignore en action.

Créer une classe

Créez une classe java à tester, disons, MessageUtil.java dans C: \> JUNIT_WORKSPACE.

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message){
      this.message = message; 
   }

   // prints the message
   public String printMessage(){
      System.out.println(message);
      return message;
   }   

   // add "Hi!" to the message
   public String salutationMessage(){
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }   
	
}

Créer une classe de cas de test

• Créez une classe de test java, par exemple TestJunit.java.

• Ajoutez une méthode de test testPrintMessage () ou testSalutationMessage () à votre classe de test.

• Ajoutez un Annotaion @Ignore à la méthode testPrintMessage ().

Créez un fichier de classe Java nommé TestJunit.java dans C: \ JUNIT_WORKSPACE.

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

public class TestJunit {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
   
   @Ignore
   @Test
   public void testPrintMessage() {
      System.out.println("Inside testPrintMessage()");
      message = "Robert";
      assertEquals(message,messageUtil.printMessage());
   }

   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Robert";
      assertEquals(message,messageUtil.salutationMessage());
   }
	
}

Créer une classe Test Runner

Créez un fichier de classe Java nommé TestRunner.java dans C: \> JUNIT_WORKSPACE pour exécuter le ou les cas de test.

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(TestJunit.class);

      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Compilez les classes MessageUtil, Test case et Test Runner à l'aide de javac.

C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java

Exécutez maintenant le Test Runner, qui n'exécutera pas le scénario de test testPrintMessage () défini dans la classe de scénario de test fournie.

C:\JUNIT_WORKSPACE>java TestRunner

Vérifiez la sortie. Le cas de test testPrintMessage () n'est pas testé.

Inside testSalutationMessage()
Hi!Robert
true

Maintenant, mettez à jour TestJunit dans C: \> JUNIT_WORKSPACE pour ignorer tous les cas de test. Ajoutez @Ignore au niveau de la classe.

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

@Ignore
public class TestJunit {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
     
   @Test
   public void testPrintMessage() {
      System.out.println("Inside testPrintMessage()");
      message = "Robert";
      assertEquals(message,messageUtil.printMessage());
   }

   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Robert";
      assertEquals(message,messageUtil.salutationMessage());
   }
	
}

Compilez le scénario de test à l'aide de javac.

C:\JUNIT_WORKSPACE>javac TestJunit.java

Gardez votre Test Runner inchangé comme suit -

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

Exécutez maintenant le Test Runner, qui n'exécutera aucun cas de test défini dans la classe de scénario de test fournie.

C:\JUNIT_WORKSPACE>java TestRunner

Vérifiez la sortie. Aucun cas de test n'est testé.

true

JUnit fournit une option pratique de Timeout. Si un scénario de test prend plus de temps que le nombre de millisecondes spécifié, JUnit le marquera automatiquement comme ayant échoué. letimeoutLe paramètre est utilisé avec l'annotation @Test. Voyons le @Test (timeout) en action.

Créer une classe

Créez une classe java à tester, disons, MessageUtil.java dans C: \> JUNIT_WORKSPACE.

Ajoutez une boucle while infinie à l'intérieur de la méthode printMessage ().

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message){
      this.message = message; 
   }

   // prints the message
   public void printMessage(){
      System.out.println(message);
      while(true);
   }   

   // add "Hi!" to the message
   public String salutationMessage(){
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }   
}

Créer une classe de cas de test

Créez une classe de test java, par exemple, TestJunit.java. Ajoutez un délai d'expiration de 1000 au scénario de test testPrintMessage ().

Créez un fichier de classe Java nommé TestJunit.java dans C: \> JUNIT_WORKSPACE.

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

public class TestJunit {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
   
   @Test(timeout = 1000)
   public void testPrintMessage() {	
      System.out.println("Inside testPrintMessage()");     
      messageUtil.printMessage();     
   }

   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Robert";
      assertEquals(message,messageUtil.salutationMessage());
   }
}

Créer une classe Test Runner

Créez un fichier de classe Java nommé TestRunner.java dans C: \> JUNIT_WORKSPACE pour exécuter le ou les cas de test.

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

Compilez les classes MessageUtil, Test case et Test Runner à l'aide de javac.

C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java

Exécutez maintenant le Test Runner, qui exécutera les cas de test définis dans la classe de cas de test fournie.

C:\JUNIT_WORKSPACE>java TestRunner

Vérifiez la sortie. Le cas de test testPrintMessage () marquera l'échec du test unitaire.

Inside testPrintMessage()
Robert
Inside testSalutationMessage()
Hi!Robert
testPrintMessage(TestJunit): test timed out after 1000 milliseconds
false

JUnit fournit une option de suivi de la gestion des exceptions du code. Vous pouvez tester si le code lève une exception souhaitée ou non. leexpectedLe paramètre est utilisé avec l'annotation @Test. Voyons @Test (attendu) en action.

Créer une classe

Créez une classe java à tester, disons, MessageUtil.java dans C: \> JUNIT_WORKSPACE.

Ajoutez une condition d'erreur dans la méthode printMessage ().

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message){
      this.message = message; 
   }

   // prints the message
   public void printMessage(){
      System.out.println(message);
      int a = 0;
      int b = 1/a;
   }   

   // add "Hi!" to the message
   public String salutationMessage(){
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }   
}

Créer une classe de cas de test

Créez une classe de test java appelée TestJunit.java. Ajoutez une exception ArithmeticException attendue au scénario de test testPrintMessage ().

Créez un fichier de classe Java nommé TestJunit.java dans C: \> JUNIT_WORKSPACE.

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

public class TestJunit {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
   
   @Test(expected = ArithmeticException.class)
   public void testPrintMessage() {	
      System.out.println("Inside testPrintMessage()");     
      messageUtil.printMessage();     
   }

   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Robert";
      assertEquals(message,messageUtil.salutationMessage());
   }
}

Créer une classe Test Runner

Créez un fichier de classe Java nommé TestRunner.java dans C: \> JUNIT_WORKSPACE pour exécuter le ou les cas de test.

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

Compilez les classes MessageUtil, Test case et Test Runner à l'aide de javac.

C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java

Exécutez maintenant le Test Runner, qui exécutera les cas de test définis dans la classe de cas de test fournie.

C:\JUNIT_WORKSPACE>java TestRunner

Vérifiez la sortie. Le cas de test testPrintMessage () sera passé.

Inside testPrintMessage()
Robert
Inside testSalutationMessage()
Hi!Robert
true

JUnit 4 a introduit une nouvelle fonctionnalité appelée parameterized tests. Les tests paramétrés permettent à un développeur d'exécuter le même test encore et encore en utilisant des valeurs différentes. Vous devez suivre cinq étapes pour créer un test paramétré.

• Annoter la classe de test avec @RunWith (Parameterized.class).

• Créez une méthode statique publique annotée avec @Parameters qui renvoie une collection d'objets (sous forme de tableau) en tant qu'ensemble de données de test.

• Créez un constructeur public qui prend ce qui équivaut à une «ligne» de données de test.

• Créez une variable d'instance pour chaque "colonne" de données de test.

• Créez votre ou vos cas de test en utilisant les variables d'instance comme source des données de test.

Le scénario de test sera appelé une fois pour chaque ligne de données. Voyons les tests paramétrés en action.

Créer une classe

Créez une classe java à tester, disons, PrimeNumberChecker.java dans C: \> JUNIT_WORKSPACE.

public class PrimeNumberChecker {
   public Boolean validate(final Integer primeNumber) {
      for (int i = 2; i < (primeNumber / 2); i++) {
         if (primeNumber % i == 0) {
            return false;
         }
      }
      return true;
   }
}

Créer une classe de cas de test paramétrée

Créez une classe de test java, par exemple, PrimeNumberCheckerTest.java. Créez un fichier de classe Java nomméPrimeNumberCheckerTest.java dans C: \> JUNIT_WORKSPACE.

import java.util.Arrays;
import java.util.Collection;
 
import org.junit.Test;
import org.junit.Before;

import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
import org.junit.runner.RunWith;
import static org.junit.Assert.assertEquals;

@RunWith(Parameterized.class)
public class PrimeNumberCheckerTest {
   private Integer inputNumber;
   private Boolean expectedResult;
   private PrimeNumberChecker primeNumberChecker;

   @Before
   public void initialize() {
      primeNumberChecker = new PrimeNumberChecker();
   }

   // Each parameter should be placed as an argument here
   // Every time runner triggers, it will pass the arguments
   // from parameters we defined in primeNumbers() method
	
   public PrimeNumberCheckerTest(Integer inputNumber, Boolean expectedResult) {
      this.inputNumber = inputNumber;
      this.expectedResult = expectedResult;
   }

   @Parameterized.Parameters
   public static Collection primeNumbers() {
      return Arrays.asList(new Object[][] {
         { 2, true },
         { 6, false },
         { 19, true },
         { 22, false },
         { 23, true }
      });
   }

   // This test will run 4 times since we have 5 parameters defined
   @Test
   public void testPrimeNumberChecker() {
      System.out.println("Parameterized Number is : " + inputNumber);
      assertEquals(expectedResult, 
      primeNumberChecker.validate(inputNumber));
   }
}

Créer une classe Test Runner

Créez un fichier de classe Java nommé TestRunner.java dans C: \> JUNIT_WORKSPACE pour exécuter le ou les cas de test.

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(PrimeNumberCheckerTest.class);

      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Compilez les classes PrimeNumberChecker, PrimeNumberCheckerTest et Test Runner à l'aide de javac.

C:\JUNIT_WORKSPACE>javac PrimeNumberChecker.java PrimeNumberCheckerTest.java
TestRunner.java

Exécutez maintenant le Test Runner, qui exécutera les cas de test définis dans la classe de cas de test fournie.

C:\JUNIT_WORKSPACE>java TestRunner

Vérifiez la sortie.

Parameterized Number is : 2
Parameterized Number is : 6
Parameterized Number is : 19
Parameterized Number is : 22
Parameterized Number is : 23
true

Nous aurons un exemple pour montrer comment exécuter JUnit en utilisant ANT. Suivez les étapes ci-dessous.

Étape 1: Téléchargez Apache Ant

Téléchargez Apache Ant en fonction du système d'exploitation sur lequel vous travaillez.

OS	Nom de l'archive
les fenêtres	apache-ant-1.8.4-bin.zip
Linux	apache-ant-1.8.4-bin.tar.gz
Mac	apache-ant-1.8.4-bin.tar.gz

Étape 2: définir l'environnement Ant

Met le ANT_HOMEvariable d'environnement pour pointer vers l'emplacement du répertoire de base, où les bibliothèques ANT sont stockées sur votre machine. Supposons que les bibliothèques Ant soient stockées dans le dossier apache-ant-1.8.4.

Sr.No.	OS et description
1	Windows Définissez la variable d'environnement ANT_HOME sur C: \ Program Files \ Apache Software Foundation \ apache-ant-1.8.4
2	Linux export ANT_HOME = /usr/local/apache-ant-1.8.4
3	Mac export ANT_HOME = /Library/apache-ant-1.8.4

Ajoutez l'emplacement du compilateur Ant au chemin système comme suit -

OS	Production
les fenêtres	Ajouter la chaîne %ANT_HOME\bin à la fin de la variable système, Path.
Linux	export PATH = $PATH:$ANT_HOME / bin /
Mac	non requis

Étape 3: Téléchargez l'archive JUnit

Téléchargez une archive JUnit adaptée à votre système d'exploitation.

OS	Nom de l'archive
les fenêtres	junit4.10.jar
Linux	junit4.10.jar
Mac	junit4.10.jar

Étape 4: Créer une structure de projet

• Créer un dossier TestJunitWithAnt dans C: \> JUNIT_WORKSPACE.

• Créer un dossier src dans C: \> JUNIT_WORKSPACE> TestJunitWithAnt.

• Créer un dossier test dans C: \> JUNIT_WORKSPACE> TestJunitWithAnt.

• Créer un dossier lib dans C: \> JUNIT_WORKSPACE> TestJunitWithAnt.

• Créer MessageUtil classe dans C: \> JUNIT_WORKSPACE> TestJunitWithAnt> srcfolder.

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message){
      this.message = message; 
   }

   // prints the message
   public String printMessage(){
      System.out.println(message);
      return message;
   }   

   // add "Hi!" to the message
   public String salutationMessage(){
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }   
}

Créer TestMessageUtil class dans le dossier C: \> JUNIT_WORKSPACE> TestJunitWithAnt> src.

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

public class TestMessageUtil {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
   
   @Test
   public void testPrintMessage() {	
      System.out.println("Inside testPrintMessage()");     
      assertEquals(message,messageUtil.printMessage());
   }

   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Robert";
      assertEquals(message,messageUtil.salutationMessage());
   }
}

Copiez junit-4.10.jar dans le dossier C: \> JUNIT_WORKSPACE> TestJunitWithAnt> lib.

Créer ANT Build.xml

Nous utiliserons <junit> tâche dans Ant pour exécuter nos cas de test JUnit.

<project name = "JunitTest" default = "test" basedir = ".">
   <property name = "testdir" location = "test" />
   <property name = "srcdir" location = "src" />
   <property name = "full-compile" value = "true" />
	
   <path id = "classpath.base"/>
	
   <path id = "classpath.test">
      <pathelement location = "lib/junit-4.10.jar" />
      <pathelement location = "${testdir}" /> <pathelement location = "${srcdir}" />
      <path refid = "classpath.base" />
   </path>
	
   <target name = "clean" >
      <delete verbose = "${full-compile}"> <fileset dir = "${testdir}" includes = "**/*.class" />
      </delete>
   </target>
	
   <target name = "compile" depends = "clean">
      <javac srcdir = "${srcdir}" destdir = "${testdir}" 
         verbose = "${full-compile}">
         <classpath refid = "classpath.test"/>
      </javac>
   </target>
	
   <target name = "test" depends = "compile">
      <junit>
         <classpath refid = "classpath.test" />
         <formatter type = "brief" usefile = "false" />
         <test name = "TestMessageUtil" />
      </junit>
   </target>
	
</project>

Exécutez la commande Ant suivante.

C:\JUNIT_WORKSPACE\TestJunitWithAnt>ant

Vérifiez la sortie.

Buildfile: C:\JUNIT_WORKSPACE\TestJunitWithAnt\build.xml

clean:  

compile:  
   [javac] Compiling 2 source files to C:\JUNIT_WORKSPACE\TestJunitWithAnt\test
   [javac] [parsing started C:\JUNIT_WORKSPACE\TestJunitWithAnt\src\
      MessageUtil.java]
   [javac] [parsing completed 18ms]
   [javac] [parsing started C:\JUNIT_WORKSPACE\TestJunitWithAnt\src\
      TestMessageUtil.java]
   [javac] [parsing completed 2ms]
   [javac] [search path for source files: C:\JUNIT_WORKSPACE\
      TestJunitWithAnt\src]    
   [javac] [loading java\lang\Object.class(java\lang:Object.class)]
   [javac] [loading java\lang\String.class(java\lang:String.class)]
   [javac] [loading org\junit\Test.class(org\junit:Test.class)]
   [javac] [loading org\junit\Ignore.class(org\junit:Ignore.class)]
   [javac] [loading org\junit\Assert.class(org\junit:Assert.class)]
   [javac] [loading java\lang\annotation\Retention.class
      (java\lang\annotation:Retention.class)]
   [javac] [loading java\lang\annotation\RetentionPolicy.class
      (java\lang\annotation:RetentionPolicy.class)]
   [javac] [loading java\lang\annotation\Target.class
      (java\lang\annotation:Target.class)]
   [javac] [loading java\lang\annotation\ElementType.class
      (java\lang\annotation:ElementType.class)]
   [javac] [loading java\lang\annotation\Annotation.class
      (java\lang\annotation:Annotation.class)]
   [javac] [checking MessageUtil]
   [javac] [loading java\lang\System.class(java\lang:System.class)]
   [javac] [loading java\io\PrintStream.class(java\io:PrintStream.class)]
   [javac] [loading java\io\FilterOutputStream.class
      (java\io:FilterOutputStream.class)]
   [javac] [loading java\io\OutputStream.class(java\io:OutputStream.class)]
   [javac] [loading java\lang\StringBuilder.class
      (java\lang:StringBuilder.class)]
   [javac] [loading java\lang\AbstractStringBuilder.class
      (java\lang:AbstractStringBuilder.class)]
   [javac] [loading java\lang\CharSequence.class(java\lang:CharSequence.class)]
   [javac] [loading java\io\Serializable.class(java\io:Serializable.class)]
   [javac] [loading java\lang\Comparable.class(java\lang:Comparable.class)]
   [javac] [loading java\lang\StringBuffer.class(java\lang:StringBuffer.class)]
   [javac] [wrote C:\JUNIT_WORKSPACE\TestJunitWithAnt\test\MessageUtil.class]
   [javac] [checking TestMessageUtil]
   [javac] [wrote C:\JUNIT_WORKSPACE\TestJunitWithAnt\test\TestMessageUtil.class]
   [javac] [total 281ms]

test:
    [junit] Testsuite: TestMessageUtil
    [junit] Tests run: 2, Failures: 0, Errors: 0, Time elapsed: 0.008 sec
    [junit]
    [junit] ------------- Standard Output ---------------
    [junit] Inside testPrintMessage()
    [junit] Robert
    [junit] Inside testSalutationMessage()
    [junit] Hi!Robert
    [junit] ------------- ---------------- ---------------

BUILD SUCCESSFUL
Total time: 0 seconds

Pour configurer JUnit avec eclipse, suivez les étapes ci-dessous.

Étape 1: Téléchargez l'archive JUnit

Téléchargez un fichier JUnit basé sur le système d'exploitation que vous avez sur votre système.

OS	Nom de l'archive
les fenêtres	junit4.10.jar
Linux	junit4.10.jar
Mac	junit4.10.jar

Supposons que vous ayez copié le fichier JAR ci-dessus dans le dossier C: \> JUnit.

Étape 2: définir l'environnement Eclipse

Ouvrez eclipse → faites un clic droit sur le projet et cliquez sur propriété> Build Path> Configure Build Path et ajoutez le junit-4.10.jar dans les bibliothèques en utilisant le bouton Add External Jar.

Nous supposons que votre Eclipse a un plugin JUnit intégré. S'il n'est pas disponible dans le répertoire C: \> eclipse \ plugins, vous pouvez le télécharger depuisJUnit Plugin. Décompressez le fichier zip téléchargé dans le dossier plugin de l'Eclipse. Enfin, redémarrez Eclipse.

Votre Eclipse est maintenant prêt pour le développement de cas de test JUnit.

Étape 3: Vérifiez l'installation de JUnit dans Eclipse

Créer un projet TestJunitdans Eclipse à n'importe quel endroit. Puis créez une classeMessageUtil à tester dans le projet.

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message){
      this.message = message;
   }
      
   // prints the message
   public String printMessage(){
      System.out.println(message);
      return message;
   }   
}

Créer une classe de test TestJunit dans le projet.

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

public class TestJunit {
	
   String message = "Hello World";	
   MessageUtil messageUtil = new MessageUtil(message);

   @Test
   public void testPrintMessage() {	  
      assertEquals(message,messageUtil.printMessage());
   }
}

Voici la structure du projet -

Enfin, cliquez avec le bouton droit sur le programme et exécutez en tant que JUnit pour vérifier la sortie du programme.

Vérifiez le résultat.

Voici les extensions JUnit -

• Cactus
• JWebUnit
• XMLUnit
• MockObject

Cactus

Cactus est un framework de test simple pour les tests unitaires de code Java côté serveur (servlets, EJB, librairies de balises, filtres). L'intention de Cactus est de réduire le coût d'écriture des tests pour le code côté serveur. Il utilise JUnit et l'étend. Cactus implémente une stratégie dans le conteneur qui exécute les tests à l'intérieur d'un conteneur.

L'écosystème de cactus est composé de plusieurs composants -

• Cactus Frameworkest le cœur de Cactus. C'est le moteur qui fournit l'API pour écrire les tests Cactus.

• Cactus Integration Modules sont des interfaces et des frameworks qui fournissent des moyens simples d'utiliser le Framework Cactus (scripts Ant, plugin Eclipse et plugin Maven).

Le code suivant montre comment Cactus peut être utilisé.

import org.apache.cactus.*;
import junit.framework.*;

public class TestSampleServlet extends ServletTestCase {
   @Test
   public void testServlet() {
      // Initialize class to test
      SampleServlet servlet = new SampleServlet();

      // Set a variable in session as the doSomething()
      // method that we are testing 
      session.setAttribute("name", "value");

      // Call the method to test, passing an 
      // HttpServletRequest object (for example)
      String result = servlet.doSomething(request);

      // Perform verification that test was successful
      assertEquals("something", result);
      assertEquals("otherValue", session.getAttribute("otherName"));
   }
}

JWebUnit

JWebUnit est un framework de test basé sur Java pour les applications Web. Il enveloppe les cadres de test existants tels que HtmlUnit et Selenium avec une interface de test unifiée et simple pour tester l'exactitude de vos applications Web.

JWebUnit fournit une API Java de haut niveau pour naviguer dans une application Web combinée à un ensemble d'assertions pour vérifier l'exactitude de l'application. Cela comprend la navigation via des liens, la saisie et la soumission de formulaires, la validation du contenu de la table et d'autres fonctionnalités d'applications Web d'entreprise typiques.

Les méthodes de navigation simples et les assertions prêtes à l'emploi permettent une création de test plus rapide que d'utiliser uniquement JUnit ou HtmlUnit. Et si vous souhaitez passer de HtmlUnit à d'autres plugins tels que Selenium (bientôt disponible), il n'est pas nécessaire de réécrire vos tests.

Voici un exemple de code.

import junit.framework.TestCase;
import net.sourceforge.jwebunit.WebTester;

public class ExampleWebTestCase extends TestCase {
   private WebTester tester;
   
   public ExampleWebTestCase(String name) {
      super(name);
      tester = new WebTester();
   }
	
   //set base url
   public void setUp() throws Exception {
      getTestContext().setBaseUrl("http://myserver:8080/myapp");
   }
	
   // test base info
   @Test
   public void testInfoPage() {
      beginAt("/info.html");
   }
}

XMLUnit

XMLUnit fournit une seule classe d'extension JUnit, XMLTestCase, et un ensemble de classes de prise en charge qui permettent de faire des assertions sur -

• Les différences entre deux morceaux de XML (via les classes Diff et DetailedDiff).

• La validité d'un morceau de XML (via la classe Validator).

• Le résultat de la transformation d'un morceau de XML à l'aide de XSLT (via la classe Transform).

• L'évaluation d'une expression XPath sur un morceau de XML (via des classes implémentant l'interface XpathEngine).

• Nœuds individuels dans un morceau de XML qui sont exposés par DOM Traversal (via la classe NodeTest).

Supposons que nous ayons deux morceaux de XML que nous souhaitons comparer et affirmons qu'ils sont égaux. Nous pourrions écrire une classe de test simple comme celle-ci -

import org.custommonkey.xmlunit.XMLTestCase;

public class MyXMLTestCase extends XMLTestCase {

   // this test method compare two pieces of the XML
   @Test
   public void testForXMLEquality() throws Exception {
      String myControlXML = "<msg><uuid>0x00435A8C</uuid></msg>";
      String myTestXML = "<msg><localId>2376</localId></msg>";
      assertXMLEqual("Comparing test xml to control xml", myControlXML, myTestXML);
   }
}

MockObject

Dans un test unitaire, les objets fictifs peuvent simuler le comportement d'objets complexes et réels (non simulés) et sont donc utiles lorsqu'un objet réel est peu pratique ou impossible à incorporer dans un test unitaire.

Le style de codage courant pour tester avec des objets fictifs est de -

• Créez des instances d'objets fictifs.
• Définissez l'état et les attentes dans les objets fictifs.
• Appelez le code de domaine avec des objets fictifs comme paramètres.
• Vérifiez la cohérence des objets fictifs.

Ci-dessous, un exemple de MockObject utilisant Jmock.

import org.jmock.Mockery;
import org.jmock.Expectations;

class PubTest extends TestCase {
   Mockery context = new Mockery();
   public void testSubReceivesMessage() {
      // set up
      final Sub sub = context.mock(Sub.class);

      Pub pub = new Pub();
      pub.add(sub);
    
      final String message = "message";
      
      // expectations
      context.checking(new Expectations() {
         oneOf (sub).receive(message);
      });

      // execute
      pub.publish(message);
      
      // verify
      context.assertIsSatisfied();
   }
}