JUnit test unitaire commun et base Remarque: Questions et réponses InterInterview, des exemples, des notes et des explications


Nous avons besoin d'écrire/créer la méthode de test avec Test dans JUnit pour créer des tests unitaires.

Quelles méthodes test JUnit?

méthodes d'essai de JUnit sont les méthodes qui sont créés pour les tests unitaires dans JUnit.




Test Avant Après BeforeClass AfterClass Ignorer Test (timeout = 10) Test (attendu = Exception.class)

Quelle est l'utilisation DiTEST?

Le annotazioneTest identifie une méthode comme une méthode de preuve. Pour créer une méthode d'essai, nous devons utiliser cette première définition de la méthode.

Dans une classe de test, il ya 100 cas de test. Vous ne voulez pas courir deux cas de test. Comment faites-vous cela?

Nous devons usareIgnore annotations avant les cas de test que nous ne voulons pas courir.

Quelle est la différence traBefore eBeforeClass

Avant de cas de test se déroule avant chaque course, mais essai caseBeforeClass ne est effectuée avant le début de la classe de test.

Dans un environnement, nous avons 10 cas de test. Mais chaque fois que nous avons besoin pour créer l'objet. Nous devons créer l'objet explicitement chaque fois les cas de test?

Non, nous ne avons pas besoin de créer l'objet pour chaque test. Nous pouvons usareBefore dossier afin qu'il puisse créer l'objet chaque fois qu'il a besoin de l'objet.

Dans un environnement de production, nous devons vérifier si une méthode d'exécution, à moins 100milliseconds, Comment testez-vous cela?

Nous pouvons utiliser le temps libre et de définir la valeur de délai d'attente. Donc, nous pourrions facilement voir si la méthode est exécutée acceptés dans le délai fixé ou non.

Pourquoi est-il bon d'utiliser sauf en cas de test?

annotation Exception si le test échoue uniquement lorsque la méthode ne génère pas l'exception du nom. Ainsi, nous pouvons facilement contrôler la méthode.

Avant de créer des cas de test, nous avons besoin de voir la façon dont nous aimerions tester. Supposons que nous ayons une classe qui a CalculationMethodods.java certaines méthodes telles que l'addition, soustraction, multiplication, etc. définition de la structure et les modalités du projet sont les suivants:

CalculationMethods {public class public int add (String x1, x2 String) { int a1 = Integer.parseInt (x1); int = a2 Integer.parseInt (x2); int result = 0; résultat = A1 + A2; return result; } public int soustraction (String x1, x2 String) { int a1 = Integer.parseInt (x1); int = a2 Integer.parseInt (x2); int result = 0; résultat = A1 - A2; return result; } public int multiplication (String x1, x2 String) { int a1 = Integer.parseInt (x1); int = a2 Integer.parseInt (x2); int result = 0; * Result = A1 A2; return result; } Division public int (String x1, x2 String) { flotter a1 = Float.parseFloat (x1); flotter = a2 Float.parseFloat (x2); int result = 0; résultat = (int) (A1/A2); return result; } }

Maintenant, nous allons écrire quelques banc en mesure d'essayer toutes les méthodes de blocs de code ci-dessus de test. Les cas de test sont les suivantes:

org.junit.Test importation; importation org.junit.Assert statique. *; public class CalculationMethodsTest { Test additionMethodTest50Add50 public void () { Méthode CalculationMethods CalculationMethods = new (); assertEquals («Somme des 50 et 50 est de 100", 100, method.addition ("50", "50")); } Test public void multiplicationMethodTest10Multiply20 () { Méthode CalculationMethods CalculationMethods = new (); assertEquals ("Multiplication des 10 et 20 ne est pas 200", 200, method.multiplication ("10", "20")); } Test subtractionMethodTestForValues50Subtact20 public void () { Méthode CalculationMethods CalculationMethods = new (); assertEquals ("Soustraction 50-20 est de 30", 30, method.subtraction ("50", "20")); } Test subtractionMethodTestForValues10DivideBy5 public void () { Méthode CalculationMethods CalculationMethods = new (); assertEquals ("Diviser 10 5 ne est pas 2", 2, method.division ("10", "5")); } }

Nous courons le programme JUnit et vous voyez la sortie suivante:

Voir les cas de test ci-dessus, nous définissons le même objet plusieurs fois. Ce est une tâche répétitive. La figure suivante verra la répétition de ces création d'objets.

Notre objectif est d'éliminer les répétitions. Et nous pouvons faire utilizzandoBefore annotation. En se écoulant nous enlevons codes répétitives et créons une nouvelle annotation bloc utilizzandoBefore.

org.junit.Before importation; org.junit.Test importation; importation org.junit.Assert statique. *; public class CalculationMethodsTest { CalculationMethods méthode privée; Avant public void setup () { Méthode CalculationMethods = new (); System.out.println ("Premier essai"); } Test additionMethodTest50Add50 public void () { assertEquals («Somme des 50 et 50 est de 100", 100, method.addition ("50", "50")); } Test public void multiplicationMethodTest10Multiply20 () { assertEquals ("Multiplication des 10 et 20 ne est pas 200", 200, method.multiplication ("10", "20")); } Test subtractionMethodTestForValues50Subtact20 public void () { assertEquals ("Soustraction 50-20 est de 30", 30, method.subtraction ("50", "20")); } Test subtractionMethodTestForValues10DivideBy5 public void () { assertEquals ("Diviser 10 5 ne est pas 2", 2, method.division ("10", "5")); } } org.junit.After importation; org.junit.Before importation; org.junit.Test importation; importation org.junit.Assert statique. *; public class CalculationMethodsTest { CalculationMethods méthode privée; Avant public void setup () { Méthode CalculationMethods = new (); System.out.println ("Premier essai"); } Après terminer public void () { System.out.println ("Après cas de test"); } Test additionMethodTest50Add50 public void () { assertEquals («Somme des 50 et 50 est de 100", 100, method.addition ("50", "50")); } Test public void multiplicationMethodTest10Multiply20 () { assertEquals ("Multiplication des 10 et 20 ne est pas 200", 200, method.multiplication ("10", "20")); } Test subtractionMethodTestForValues50Subtact20 public void () { assertEquals ("Soustraction 50-20 est de 30", 30, method.subtraction ("50", "20")); } Test subtractionMethodTestForValues10DivideBy5 public void () { assertEquals ("Diviser 10 5 ne est pas 2", 2, method.division ("10", "5")); } }

tests JUnit en utilisant BeforeClass Et AferClass

org.junit.After importation; org.junit.AfterClass importation; org.junit.Before importation; org.junit.BeforeClass importation; org.junit.Test importation; importation org.junit.Assert statique. *; public class CalculationMethodsTest { CalculationMethods méthode privée; Avant public void setup () { Méthode CalculationMethods = new (); System.out.println ("First"); } Après terminer public void () { System.out.println ("Après"); } BeforeClass public static void beforeClassDemo () { System.out.println ("première classe"); } AfterClass public static void afterClassDemo () { System.out.println ("Après la classe"); } Test additionMethodTest50Add50 public void () { assertEquals («Somme des 50 et 50 est de 100", 100, method.addition ("50", "50")); } Test public void multiplicationMethodTest10Multiply20 () { assertEquals ("Multiplication des 10 et 20 ne est pas 200", 200, method.multiplication ("10", "20")); } Test subtractionMethodTestForValues50Subtact20 public void () { assertEquals ("Soustraction 50-20 est de 30", 30, method.subtraction ("50", "20")); } Test subtractionMethodTestForValues10DivideBy5 public void () { assertEquals ("Diviser 10 5 ne est pas 2", 2, method.division ("10", "5")); } } Test

JUnit: Utilisation Timeout

Dans cet exemple, nous allons utiliser temps libre pour voir si le cas de test est terminée avec succès avec une valeur de temps. Pour ce faire, nous avons créé une méthode de contre CalculationMethods classe et ajouter un dépôt valeurFinale. Donc, nous devons ajouter la ligne de code suivante dans les CalculationMethods de classe.

à long valeurFinale privé = 0; long comptoir publique (longueur x) { valeurFinale valeurFinale + = x; valeurFinale revenir; }

Notre but est de vérifier si le procédé peut effectuer une tâche répétitive d'une période de temps définie. Donc, nous allons ajouter une méthode de badTest, qui va essayer d'appeler la méthode à plusieurs reprises contre. Il vérifiera si cela peut être achevé dans les 100 millisecondes le code de cette fonction est:

Test (timeout = 10) public void badTest () { for (int i = 0; i <50000000; i ++) { method.counter (i); } }

Maintenant, essayez d'exécuter le test. Lorsque le test coureur de JUnit se termine, nous verrons que le test a échoué. sortie de JUnit peut ressembler à ce qui suit:

Les codes complets de la présente sont les suivantes:

code complet de CalculationMethods.java

CalculationMethods {public class à long valeurFinale privé = 0; public int add (String x1, x2 String) { int a1 = Integer.parseInt (x1); int = a2 Integer.parseInt (x2); int result = 0; résultat = A1 + A2; return result; } public int soustraction (String x1, x2 String) { int a1 = Integer.parseInt (x1); int = a2 Integer.parseInt (x2); int result = 0; résultat = A1 - A2; return result; } public int multiplication (String x1, x2 String) { int a1 = Integer.parseInt (x1); int = a2 Integer.parseInt (x2); int result = 0; * Result = A1 A2; return result; } Division public int (String x1, x2 String) { flotter a1 = Float.parseFloat (x1); flotter = a2 Float.parseFloat (x2); int result = 0; résultat = (int) (A1/A2); return result; } long comptoir publique (longueur x) { valeurFinale valeurFinale + = x; valeurFinale revenir; } }

code complet de CalculationMethodsTest.java

org.junit.After importation; org.junit.AfterClass importation; org.junit.Before importation; org.junit.BeforeClass importation; org.junit.Test importation; importation org.junit.Assert statique. *; public class CalculationMethodsTest { CalculationMethods méthode privée; Avant public void setup () { Méthode CalculationMethods = new (); System.out.println ("First"); } Après terminer public void () { System.out.println ("Après"); } BeforeClass public static void beforeClassDemo () { System.out.println ("première classe"); } AfterClass public static void afterClassDemo () { System.out.println ("Après la classe"); } Test additionMethodTest50Add50 public void () { assertEquals («Somme des 50 et 50 est de 100", 100, method.addition ("50", "50")); } Test public void multiplicationMethodTest10Multiply20 () { assertEquals ("Multiplication des 10 et 20 ne est pas 200", 200, method.multiplication ("10", "20")); } Test subtractionMethodTestForValues50Subtact20 public void () { assertEquals ("Soustraction 50-20 est de 30", 30, method.subtraction ("50", "20")); } Test subtractionMethodTestForValues10DivideBy5 public void () { assertEquals ("Diviser 10 5 ne est pas 2", 2, method.division ("10", "5")); } Test (timeout = 10) public void badTest () { for (int i = 0; i <50000000; i ++) { method.counter (i); } } }

tests JUnit en utilisant Ignorer

Parfois, nous pouvons être amenés à ignorer certaines cas de test pendant le test. Mais nous ne avons pas besoin de supprimer le cas de test. Nous pouvons utiliser Ignorer pour ce faire.

Test (timeout = 10) Ignorer public void badTest () { for (int i = 0; i <50000000; i ++) { method.counter (i); System.out.println ("valeur de la" + i); } goalValue private int = 0; public int settingGoalValue (int passedValue) throws InvalidCounterException { goalValue + = passedValue; if (goalValue> 50) { throw new InvalidCounterException (); } goalValue revenir; } InvalidCounterException public class extends Exception { statique à long serialVersionUID finale privée = 1L; } Test (attendu = InvalidCounterException.class) public void whenGoalValueIsGereaterThan50ExceptionIsThrown () jette InvalidCounterException { method.settingGoalValue (200); }

Synthèse de tous les codes

Dans ce tutoriel, nous écrivons des cas de test et des cas de test test. Nous utilisons test en utilisant Avant, Après avoir utilisé, avec l'aide BeforeClass AfterClass utilisant Timing, en utilisant Ignorer et utilisant Exception de test. Tous ces cas de test sont très utiles pour tester le code Java. Le code complet de ce tutoriel et la structure de ce tutoriel sont:

Projets la structure

Projets structure de [plus de détails]

code complet de CalculationMethods.java

CalculationMethods {public class à long valeurFinale privé = 0; goalValue private int = 0; public int add (String x1, x2 String) { int a1 = Integer.parseInt (x1); int = a2 Integer.parseInt (x2); int result = 0; résultat = A1 + A2; return result; } public int soustraction (String x1, x2 String) { int a1 = Integer.parseInt (x1); int = a2 Integer.parseInt (x2); int result = 0; résultat = A1 - A2; return result; } public int multiplication (String x1, x2 String) { int a1 = Integer.parseInt (x1); int = a2 Integer.parseInt (x2); int result = 0; * Result = A1 A2; return result; } Division public int (String x1, x2 String) { flotter a1 = Float.parseFloat (x1); flotter = a2 Float.parseFloat (x2); int result = 0; résultat = (int) (A1/A2); return result; } long comptoir publique (longueur x) { valeurFinale valeurFinale + = x; valeurFinale revenir; } public int settingGoalValue (int passedValue) throws InvalidCounterException { goalValue + = passedValue; if (goalValue> 50) { throw new InvalidCounterException (); } goalValue revenir; } }

code complet de CalculationMethodsTest.java

org.junit.After importation; org.junit.AfterClass importation; org.junit.Before importation; org.junit.BeforeClass importation; org.junit.Ignore importation; org.junit.Test importation; importation org.junit.Assert statique. *; public class CalculationMethodsTest { CalculationMethods méthode privée; Avant public void setup () { Méthode CalculationMethods = new (); System.out.println ("First"); } Après terminer public void () { System.out.println ("Après"); } BeforeClass public static void beforeClassDemo () { System.out.println ("première classe"); } AfterClass public static void afterClassDemo () { System.out.println ("Après la classe"); } Test additionMethodTest50Add50 public void () { assertEquals («Somme des 50 et 50 est de 100", 100, method.addition ("50", "50")); } Test public void multiplicationMethodTest10Multiply20 () { assertEquals ("Multiplication des 10 et 20 ne est pas 200", 200, method.multiplication ("10", "20")); } Test subtractionMethodTestForValues50Subtact20 public void () { assertEquals ("Soustraction 50-20 est de 30", 30, method.subtraction ("50", "20")); } Test subtractionMethodTestForValues10DivideBy5 public void () { assertEquals ("Diviser 10 5 ne est pas 2", 2, method.division ("10", "5")); } Test (timeout = 10) Ignorer public void badTest () { for (int i = 0; i <50000000; i ++) { method.counter (i); System.out.println ("valeur de la" + i); } } Test (attendu = InvalidCounterException.class) public void whenGoalValueIsGereaterThan50ExceptionIsThrown () jette InvalidCounterException { method.settingGoalValue (200); } }

Résumé de l'intervention

(Cliquez sur l'en-tête de colonne pour trier les résultats) Annotation Description MethodName test public void () {} identifie un procédé en tant que procédé de test Test (attendu = Exception.class) nomMéthode public void () {} échoue, si le procédé ne génère pas l'exception du nom Test (timeout = 10) nomMéthode public void () {} échoue, si le procédé nécessite plus de 10 millisecondes Ignorer MethodName public void () {} ne tient pas compte de la méthode d'essai. Ce est utile lorsque le code sous-jacent a été changé et le test ne est pas encore suffisante. Or, si le temps d'exécution de ce test est trop long pour être inclus. Avant MethodName public void () {} méthode est exécutée avant chaque essai. Est utilisé pour être en mesure de préparer l'environnement de test (par exemple, pour lire les données d'entrée, initialiser la classe) Après MethodName public void () {} éthode est effectué après chaque test. Il est utilisé pour le nettoyage de l'environnement de test (par exemple, supprimer les données temporaires, restaurer les paramètres par défaut). Vous pouvez également enregistrer les structures de mémoire de nettoyage de la mémoire chère BeforeClass MethodName public void () {} méthode est exécutée une seule fois, avant le début de tous les tests. Est utilisé pour mener des activités intensives de temps, par exemple pour se connecter à une base de données. Méthodes annotés avec cette annotation doivent être définis comme statique de travailler avec JUnit AfterClass MethodName public void () {} méthode est exécutée une fois, après que tous les tests ont été terminés. Est utilisé pour mener des activités de nettoyage, par exemple pour vous déconnecter d'une base de données. Méthodes annotés avec cette annotation doivent être définis comme statique de travailler avec JUnit

(0)
(0)

Commentaires - 0

Sans commentaires

Ajouter un commentaire

smile smile smile smile smile smile smile smile
smile smile smile smile smile smile smile smile
smile smile smile smile smile smile smile smile
smile smile smile smile
Caractères restants: 3000
captcha