Plusieurs façons d'exécuter des tests JUnit

multiple ways execute junit tests

Ce didacticiel montre plusieurs façons d'exécuter des tests JUnit tels que l'exécution en tant que test JUnit, l'utilisation de touches de raccourci ou l'exécution d'un test JUnit à partir de la ligne de commande, etc.

Nous avons vu comment écrire les cas de test de base de JUnit et avoir une approche de montage de test comme l'une des bonnes pratiques de programmation pour JUnit dans notre précédent tutoriel.

Dans ce didacticiel, examinons les différentes méthodes que nous pouvons utiliser pour exécuter des tests pour JUnit. Vous serez surpris de voir le nombre d'options disponibles pour exécuter ces cas de test.

=> Regardez la série de formation Simple JUnit ici.

Ce que vous apprendrez:

• Différentes façons d'exécuter des tests JUnit
  • # 1) Exécuter en tant que test JUnit
  • # 2) Exécuter le dernier test JUnit exécuté via l'option de menu
  • # 3) Exécuter à l'aide des touches de raccourci
  • # 4) Exécutez une seule méthode de test dans une classe
  • # 5) Exécutez les tests JUnit à partir de la ligne de commande
  • # 6) Exécutez la suite de tests à l'aide de la classe Testrunner
  • # 7) Exécuter des cas de test JUnit à l'aide de Maven
• Conclusion
• lecture recommandée

Différentes façons d'exécuter des tests JUnit

Afin d'exécuter des tests JUnit, il existe certaines façons d'exécuter un fichier de classe unique avec une ou plusieurs méthodes de test via les options suivantes:

1. Option «Exécuter en tant que test JUnit».
2. Exécutez le dernier test JUnit exécuté via l'option de menu.
3. Exécutez à l'aide des touches de raccourci.
4. Exécutez une seule méthode de test dans une classe.
5. Exécutez la ligne de commande.
6. Exécutez en utilisant le fichier de classe Testrunner.
7. Exécutez également via Maven.

Remarque: L'exécution du test JUnit via Maven sera envisagée dans un didacticiel distinct pour JUnit Maven.

Répétant ce point, dans ce didacticiel, nous allons apprendre comment plusieurs tests peuvent être regroupés dans une suite de tests et comment exécuter la suite de différentes manières. En outre, il détaillera certaines informations supplémentaires pertinentes et connexes.

# 1) Exécuter en tant que test JUnit

La manière la plus simple d'exécuter les tests JUnit est:

Méthode 1:

1. Cliquez avec le bouton droit sur le fichier de classe dans la vue Script
2. Sélectionner Exécuter en tant que -> Test JUnit
3. Le fichier de classe s'exécute.

Méthode 2:

1. De même, vous pouvez sélectionner le fichier de classe dans la vue Explorateur de packages
2. Cliquez avec le bouton droit sur le fichier
3. Sélectionner Exécuter en tant que -> Test JUnit
4. Le fichier de classe s'exécute.

Remarque: De cette façon, vous pouvez exécuter un fichier de classe à la fois.

# 2) Exécuter le dernier test JUnit exécuté via l'option de menu

Vous pouvez exécuter un fichier de classe JUnit en gardant un fichier de classe ouvert dans l'éditeur. Allez dans le menu supérieur du Éclipse => Sélectionnez Exécuter => Exécuter . L'option Exécuter -> Exécuter signifie essentiellement réexécuter le test que vous avez exécuté en dernier.

Considérons une classe JUnit avec plusieurs méthodes / tests pour plus de clarté sur la façon Exécuter-> Exécuter travaux:

• Scénario 1 : Si vous aviez exécuté un méthode unique avec @Test, puis quand vous cliquez Exécuter-> Exécuter , la méthode unique qui a été exécutée en dernier ne s'exécuterait que cette fois et non la classe JUnit entière.
• Scénario 2 :Alors que si vous aviez exécuté le classe entière précédemment, Exécuter-> Exécuter réexécuterait le fichier de classe entier.

Maintenant que nous savons que Run-> Run exécute le test que vous avez exécuté en dernier, cela nous amène à un question si vous pouvez modifier la préférence de l'option Exécuter-> Exécuter?

La réponse à la question est Oui, la préférence de l'option Exécuter-> Exécuter peut être modifiée. Il y a une certaine configuration attachée à Exécuter-> Exécuter.

Voici comment vous pouvez faire cela:

à) Le paramètre d'exécution d'Eclipse est fondamentalement par défaut exécuter la ressource sélectionnée ou l'éditeur actif s'il est lancable .

Alors, qu'est-ce que le paramètre par défaut - «Exécuter la ressource sélectionnée ou l’éditeur actif si son lancement est possible?

La réponse à cela est qu'il n'exécutera pas l'application que vous avez lancée en dernier, mais suivra la réexécution de la dernière application lancée pour l'éditeur actif .

b) Alors comment changer la préférence par défaut?

La réponse à cela est que vous pouvez modifier la préférence par défaut dans Eclipse pour exécuter la dernière application que vous avez lancée quel que soit l'éditeur actif vous avez.

Voici comment changer la préférence de l'option Exécuter en utilisant Exécuter -> Exécuter:

• Aller vers Windows => Préférences => Exécuter / Déboguer => Lancement
• «Lancer l’opération» a un bouton radio par défaut - ' Lancez l'application précédemment lancée » sélectionné sous la deuxième option » Lancez la ressource sélectionnée ou l'éditeur actif. Sinon lancable : ».
• Vous devrez peut-être modifier cette préférence pour le premier bouton radio, c'est-à-dire ' Lancez toujours l'application précédemment lancée ».

# 3) Exécuter à l'aide des touches de raccourci

Vous pouvez sélectionner le fichier de classe dans la vue Script ou dans la vue Explorateur de packages et utiliser les touches de raccourci ci-dessous pour exécuter les tests JUnit:

1. Appuyez sur les touches ALT + MAJ + X, T afin d'exécuter le fichier de classe JUnit.
2. Une alternative à cela serait la presse ALT + R puis CTRL + F11 pour exécuter un fichier de classe JUnit. ALT + R puis CTRL + F11 est le raccourci pour l'option de menu Exécuter -> Exécuter

# 4) Exécutez une seule méthode de test dans une classe

Parfois, vous souhaiterez peut-être exécuter une seule méthode de test JUnit.

Dans le cas, il y a plus d'une méthode dans le fichier de classe JUnit:

1. Vous pouvez sélectionner ou placer votre curseur sur le nom de la méthode dans la vue de script.
2. Utilisez les touches de raccourci mentionnées ci-dessus ou les options fournies ci-dessus pour exécuter uniquement la méthode que vous venez de sélectionner.

Remarque: ALT + SHIFT + X, T peut exécuter les méthodes sélectionnées comme prévu. Cependant, si vous souhaitez exécuter une méthode spécifique dans une classe JUnit, il doit s'agir d'un cas de test annoté avec @Test sinon il affiche une erreur d'initialisation.

En d'autres termes, si vous sélectionnez des méthodes sous @Before ou @After (toute annotation autre que @Test), l'exécution de la méthode spécifique entraînerait une erreur.

# 5) Exécutez les tests JUnit à partir de la ligne de commande

Comme vous exécutez n'importe quel fichier de classe Java via la ligne de commande, vous pouvez également compiler et exécuter des fichiers de classe JUnit via la ligne de commande.

Nous couvrirons ici les sous-sujets ci-dessous pour comprendre comment exécuter des tests JUnit via la ligne de commande:

1. Comment compiler un test JUnit en ligne de commande?
2. Comment exécuter un test JUnit en ligne de commande?
3. Informations supplémentaires sur l'exécution de la ligne de commande.
   • Comment réparer une erreur de commande non reconnue pour la commande javac?
   • Avantages de l'exécution de tests à l'aide de la ligne de commande.

# 5.1) Comment compiler un test JUnit en ligne de commande?

La condition préalable à la compilation et à l'exécution d'un fichier de classe JUnit via l'invite de commande est:

1. Ajoutez d'abord les fichiers jar JUnit pertinents dans le chemin de classe.
2. Définissez les variables d'environnement comme indiqué dans le Configuration de JUnit Didacticiel.
3. Puis compilez un fichier de classe JUnit.
4. La syntaxe pour compiler un fichier de classe JUnit via la ligne de commande est:

Ici, javac est le compilateur Java qui utilise l'option -cp.

La commande javac -cp recherche les paramètres suivants:

1. Le fichier jar JUnit est suivi d'un point-virgule.
2. Le chemin du répertoire dans lequel se trouve le fichier source.
3. Le nom du fichier de classe

Dans la syntaxe donnée ci-dessus, qu'implique le point (.)?

Nous avons mentionné un point à la place du chemin complet du répertoire.

Le point implique que:

1. Le chemin d'accès aux classes inclut déjà le répertoire en cours des fichiers source Java.
2. La JVM (Java Virtual Machine) suppose automatiquement que le répertoire courant est celui où les fichiers source sont placés.
3. JVM y recherche ensuite le nom de fichier JUnit mentionné. Le nom de fichier est le dernier paramètre donné dans la commande de compilation.

Vous pouvez vérifier les paramètres qui entrent dans -cp en suivant les étapes suivantes:

1. Ouvrez l'invite de commande.
2. Tapez javac et appuyez sur ENTRÉE.
3. Toutes les options pertinentes s'affichent, y compris -cp. Vous constaterez que -cp va avec comme paramètre où le chemin est le chemin des fichiers de classe recherchés par JVM.

Capture d'écran ci-dessous:

Comment compiler plusieurs fichiers à la fois?

Plusieurs fichiers de test JUnit peuvent être compilés à la fois en séparant les noms de fichiers par des espaces.

Vous trouverez ci-dessous un exemple où vous compilez les fichiers java JUnitProgram et demoTest:

# 5.2) Comment exécuter un test JUnit à partir de la ligne de commande?

Tout comme javac est le compilateur Java utilisé, de la même manière java -cp est utilisé pour exécuter les fichiers de classe Java, y compris les classes JUnit.

Voici la syntaxe que vous pouvez suivre:

Cette commande exécute les fichiers JUnitProgram.java et demoTest.java l'un après l'autre.

# 5.3) Informations supplémentaires sur «l'exécution en ligne de commande».

tester les outils de gestion des données open source

Voici quelques informations supplémentaires sur comment corriger une erreur avec la commande javac et pourquoi utiliser l'option d'exécution de ligne de commande

# 5.3.1) Comment corriger l'erreur de commande non reconnue pour la commande javac?

La plupart d'entre nous rencontreraient ce problème en essayant d'exécuter le Javac commande via la ligne de commande. Cela est arrivé à moi aussi; nous avons donc pensé à l'écrire ici.

à) Nous sommes entrés dans la commande Javac et pressé Entrer sur l'invite de commande.

b) Le message d'erreur - javac n'est pas reconnu comme une commande interne ou externe, un programme utilisable ou un fichier de commandes présenté comme ci-dessous:

C'est ici que commence votre compilation des fichiers de classe Java à partir de la ligne de commande. L’erreur est donc effectivement un sujet de préoccupation et ne peut être ignorée.

Afin de résoudre le problème, suivez les étapes ci-dessous et Voila!!! vous voyez que l'erreur a disparu:

• Démonstrons ce processus à l'aide d'un fichier Java de base. La première étape que vous pouvez faire est de créer une classe Java de base Par exemple. : 'Calculator.java'
• Nous allons localiser le Calculate.java à partir de l'explorateur Windows et copier le chemin.

• Remplacez le répertoire de l'invite de commande par le chemin que vous avez copié (le chemin du fichier source). Utilisez cd pour changer de répertoire.

• Maintenant, définissez le PATH sur le dossier jdk bin à l'aide de la commande.

SET PATH = et appuyez sur ENTER.

• Ici, le chemin jdk est C: Program Files Java jdk1.8.0_181 bin. Par conséquent, nous avons tracé le chemin en conséquence. Le résultat ne montre rien en appuyant sur ENTRÉE après la commande.

• Maintenant, vérifiez si la JVM reconnaît la commande Javac en entrant la commande javac et en appuyant sur ENTRÉE.

1. 1. S'il reconnaît la commande, un ensemble d'options valides pour javac s'affiche comme résultat.
   2. Sinon, l'erreur réapparaîtra.

Ci-dessous, une capture d'écran montrant que nous avons réussi à nous débarrasser de l'erreur.

N'essayons pas d'éluder une question essentielle ici:

Pourquoi la JVM a-t-elle reconnu la commande javac après avoir défini le chemin d'accès au dossier jdk bin?

Nous sommes sûrs que vous aurez également cette question en tête. La réponse est donnée ci-dessous.

• Le dossier jdk bin contient toutes les bibliothèques pour la commande javac. C'est pourquoi, lorsque vous définissez le chemin en conséquence, la JVM est maintenant capable de reconnaître la commande javac sans aucun problème.
• Voir le dossier javac sous le bac jdk dans l'image ci-dessous.

• Vous pouvez ensuite exécuter la commande 'Java compile and run' en utilisant la ligne de commande. En outre, n'oubliez pas de définir la variable CLASSPATH de manière appropriée. Variable JAVA_HOME et JUNIT_HOME pour les fichiers Java et JUnit, respectivement.

# 5.3.2) Avantage d'exécuter des tests en utilisant la ligne de commande:

Voyons rapidement l’avantage par rapport à l’exécution de cas de test Java / JUnit via la ligne de commande.

Comme vous le savez déjà, il n'y a pas de règle absolue sur l'exécution des fichiers de classe via la ligne de commande. C'est juste une manière alternative, sur la façon dont vous pouvez gérer la compilation et l'exécution des fichiers de classe.

Si vous demandez s'il y a un avantage particulier à avoir un savoir-faire sur l'exécution des tests JUnit via la ligne de commande, alors, nous vous répondrons «Certainement, oui».

La raison d'un «oui» est donnée ci-dessous:

1. Toutes ces séries d'étapes que nous avons suivies ci-dessus; pourrait être ajouté dans le bloc-notes et converti en fichier batch.
2. Désormais, lorsque vous exécutez ce fichier de commandes avec un double clic, cela peut déclencher la compilation et l'exécution de plusieurs fichiers de test JUnit nommés dans le fichier de commandes.

Quel est l'avantage d'avoir un fichier batch pour la compilation et l'exécution des fichiers Java?

1. Un fichier batch / jar peut agir comme un utilitaire convivial qui pourrait permettre à quiconque ignorant la logique interne du code et exécuter plusieurs cas de test très facilement.
2. Cela peut éliminer la nécessité d'avoir un développeur spécialisé ou un contrôle qualité pour effectuer ces tâches d'exécution de test. La tâche d'exécution peut être déléguée à n'importe quelle ressource sans se soucier des contraintes de compétences.

Dans la prochaine option alternative, nous verrons une autre manière avantageuse et louable d'exécuter nos cas de test JUnit.

# 6) Exécutez la suite de tests à l'aide de la classe Testrunner

Dans les scénarios en temps réel, l'exécution d'un scénario de test à la fois est l'option la moins préférée.

• Nous avons des cas où nous devons exécuter un groupe de cas de test liés / non liés.
• Par exemple, nous pourrions avoir besoin de créer et d'exécuter des suites de tests de régression ou des suites de tests de fumée.

Nous allons maintenant découvrir l'implémentation des différentes annotations utilisées pour créer des suites de tests et exécuter la suite.

Le processus global d'exécution de la suite de tests à l'aide de Test Runner est conforme au flux de travail ci-dessous:

1. Créez JUnit classe 1, JUnit classe 2,…. Classe JUnit n.
2. Créez un fichier de classe de la suite de tests regroupant les cas de test.
3. Créez un fichier de classe Testrunner pour appeler la suite de tests créée.
4. Exécutez la classe Testrunner.

La structure des programmes à travers lesquels nous allons faire une démonstration de la création de la suite de tests et de l'exécution du fichier runner est illustrée dans l'image ci-dessous:

Ici, nous allons couvrir les sous-thèmes:

1. Création de classes JUnit
2. Création de suites de tests
3. Création d'un fichier Testrunner et exécution des suites de tests en l'utilisant.
4. Informations supplémentaires sur le fonctionnement de l'annotation @RunWith.

N ° 6.1) Création de classes JUnit

Commençons par créer deux fichiers de classe JUnit simples:

1. JUnitTestCase1.java - Il comprend le code pour vérifier une valeur numérique attendue - la variable Valeur1 correspond à une valeur réelle de la variable Valeur2.
2. JUnitTestCase2.java - Inclut le code pour vérifier si la variable de chaîne attendue strValue et variable de chaîne réelle strActuel allumettes.

Ce sont essentiellement deux cas de test que nous allons essayer d'entrer dans un groupement logique appelé suite de tests et de le faire fonctionner l'un après l'autre.

Code pour JUnitTestCase1.java

Code pour JUnitTestCase2.java

N ° 6.2) Création de la suite de tests:

Cette section et la section suivante jouent un rôle de premier plan dans l'ensemble du processus de création et d'exécution d'une suite de tests. Dans cette section, nous essaierons de comprendre comment regrouper plusieurs classes de test JUnit et les lier dans une suite de tests .

Conformément à l'image structurelle ci-dessus, créons une suite de tests regroupant JUnitTestCase1.java et JUnitTestCase2.java et nommons la suite JUnitTestSuite.java

Les deux annotations qui nous aident à réaliser la création d'une suite de tests sont:

1. @RunWith et
2. @SuiteClasses

Packages nécessaires pour les annotations:

1. Vous devrez importer le package org.junit.runner.RunWith; pour l'inclusion de l'annotation @RunWith.
2. Vous aurez besoin du package org.junit.runners.Suite.SuiteClasses pour que @SuiteClasses fonctionne.
3. En outre, vous devrez également importer le package org.junit.runners.Suite pour passer un paramètre Suite.class dans l'annotation @RunWith.

Regardons le code pour une meilleure compréhension !!

Code pour JUnitTestSuite.java

Compréhension du code pour JUnitTestSuite.java:

1. @RunWith aide la JVM à comprendre quel type de classe Runner doit-elle exécuter Par exemple. Suite.class ou Cucumber.class
2. Ici, le paramètre de @RunWith est Suite.class . Cela aide JVM à reconnaître que le fichier actuel dans lequel @RunWith (Suite.class) est utilisé joue un rôle dans la suite de tests.
3. Les noms de classe de test JUnit à lier ensemble dans une suite doivent être passés sous forme de tableau de chaînes sous la forme de paramètres pour @SuiteClasses, séparés par une virgule.
4. Cela permet à JVM de savoir quels sont tous les cas de test qui doivent être regroupés sous la suite.
5. Le nom de la suite sera le nom du fichier de classe JUnit qui est annoté avec @RunWith et @SuiteClasses qui est JUnitTestSuite dans ce cas.

N ° 6.3) Créer un fichier Test Runner et exécuter la suite de tests JUnit à l'aide de Test Runner

La dernière étape nous aidera à exécuter la suite de tests que nous venons de créer dans la section ci-dessus en utilisant un fichier Testrunner.

1. Nous allons maintenant créer un fichier Java nommé SuiteRunnerFile.
2. Ce SuiteRunnerFile.java n'est pas une classe JUnit mais un fichier Java habituel contenant la méthode principale.

Examinons le code, puis essayons de le comprendre.

Code pour SuiteRunnerFile.java

Packages nécessaires pour l'annotation

1. Vous devez importer le package org.junit.runner.JunitCore afin d'inclure le JUnitCore classe dans le code.
2. Vous devez importer le package org.junit.runner.notification.Failure et org.junit.runner. Result pour inclure respectivement les classes Failure et Result dans le code.

Compréhension du code pour SuiteRunnerFile.java

1. Afin de créer un fichier runner pour l'exécution de la suite de tests, le JUnitCore la classe joue un rôle important.
2. Le runClasses () méthode de JUnitCore class prend le nom de classe de la suite de tests comme paramètre d'entrée, nous avons donc l'instruction JUnitCore. runClasses (JUnitTestSuite. classer ).
3. Le type de retour de cette instruction est le Résultat objet de classe qui stocke l'état de réussite et l'état d'échec résultants de chacun des fichiers de cas de test; post-exécution. C'est pourquoi nous avons un résultat comme le Résultat objet de classe dans le code.
4. Ensuite, nous imprimons les échecs des cas de test le cas échéant. Comme la méthode getFailures (), vous pouvez également obtenir le nombre d'échecs et le nombre d'exécutions en utilisant respectivement les méthodes getFailureCount () et getRunCount ().
5. Maintenant SuiteRunnerFile est prêt à être exécuté,
   1. Sélectionnez le fichier dans l'Explorateur de packages et
   2. Cliquez avec le bouton droit et sélectionnez Exécuter en tant que -> Java, le programme s'exécute.

Ci-dessous, la capture d'écran de la fenêtre de la console.

Explication des résultats sur la console:

La console ci-dessus montre que:

1. Le fichier de classe JUnitTestSuite a été exécuté via SuiteRunnerFile.
2. La méthode printMe () sous l'annotation @BeforeClass est exécutée en premier et
3. Ensuite, les cas de test de la suite de tests se sont exécutés les uns après les autres. C'est ainsi que la suite de tests peut être créée et exécutée en tant que package.

N ° 6.4) Informations supplémentaires - Comment fonctionne @RunWith?

• @RunWith est une API JUnit qui prend essentiellement un seul élément comme paramètre d'entrée qui est un nom de fichier de classe runner.
• Le framework JUnit appelle la classe spécifiée en tant que testeur.

L'extrait ci-dessous de RunWith.java vous aidera à comprendre:

Comprendre le code d'interface RunWith ci-dessus:

1. Le spécifié évaluer L'élément doit être une classe dérivée du Coureur classer . Le concept de réflexion est utilisé ici.
2. Un très bon exemple d'une telle classe de coureur est déjà implémenté dans notre code, à savoir @RunWith (Suite.class) où un groupe de cas de test est lié pour créer une suite de tests.
3. De même, un autre bon exemple d'utilisation d'une classe Runner avec @RunWith pourrait être @RunWith (Cucumber.class) qui est un framework de développement orienté métier (BDD) pour l'automatisation des tests à l'aide de Selenium en Java. Cela aide le framework à exécuter les cas de test basés sur Cucumber.

Remarque:

• Les annotations et paramètres utilisés pour créer et exécuter la suite de tests JUnit dans ce didacticiel étaient spécifiques à JUnit 4.
• Il existe une manière légèrement différente de créer une suite de tests JUnit et d'exécuter le fichier runner dans JUnit 5.

Nous aurons bientôt une compréhension ciblée de tous les aspects de JUnit 4 vs JUnit 5 dans nos prochains tutoriels.

# 7) Exécuter des cas de test JUnit à l'aide de Maven

Vous pouvez également mettre en place un projet Maven composé de tests JUnit et exécuter les tests via Maven qui seront traités dans un didacticiel séparé.

Conclusion

1. Nous avons appris toutes les différentes options pour exécuter les tests JUnit - des tests uniques ainsi que des tests multiples regroupés dans des suites de tests.
2. Nous avons obtenu des connaissances supplémentaires sur la façon de mettre à jour la préférence pour l'option Exécuter, comment corriger l'erreur javac et comment l'exécution de la ligne de commande pourrait nous aider.
3. En outre, nous avons également appris comment fonctionne l'annotation @RunWith.

Par conséquent, il y a plus à suivre dans les prochains tutoriels. «Stand By» jusque-là !!!

=> Visitez ici pour apprendre JUnit From Scratch.

lecture recommandée

• Tests JUnit: Comment écrire des cas de test JUnit avec des exemples
• Tutoriel JUnit pour les débutants - Qu'est-ce que le test JUnit
• Qu'est-ce qu'un montage de test JUnit: Tutoriel avec des exemples JUnit 4
• Rapports Specflow: Comment générer des rapports de test et exécuter des tests sélectifs
• Téléchargez, installez et configurez JUnit dans Eclipse
• Introduction à JUnit Framework et à son utilisation dans Selenium Script - Tutoriel Selenium # 11
• Créer des tests Appium pour une application Android
• Insérer plusieurs documents dans MongoDB à l'aide de tableaux