what is junit test fixture
Ce didacticiel expliquera quand, pourquoi et comment utiliser JUnit Test Fixture avec des exemples simples de JUnit Test Fixture pour faciliter votre compréhension du concept:
Nous apprendrons -
- Quand et pourquoi avons-nous besoin d'utiliser Test Fixture?
- Quelle est l'approche pour l'utiliser dans notre code pour le test JUnit?
- Quelques exemples pour comprendre le terme «Test Fixture» en cascade avec une longueur d'avance sur les annotations de cycle de vie JUnit 4 telles que @Before, @After, @BeforeClass, @AfterClass et @Test.
=> Vérifiez TOUS les didacticiels JUnit ici.
Ce que vous apprendrez:
Appareil de test JUnit
Lorsqu'il y a plusieurs cas de test dans une classe JUnit, il peut y avoir un ou des objets communs utilisés par tous les cas de test. Dans ce cas, il pourrait y avoir des fonctions spécifiques qui pourraient être communes à tous les cas de test.
Cela ne signifie pas que les objets de test doivent être partagés par tous les cas de test. La modification apportée à l'objet dans un test n'a pas à être partagée entre tous les tests car ces tests sont indépendants et peuvent être exécutés dans un ordre différent selon leur ensemble de priorités.
qu'est-ce qu'un plan de test dans les tests logiciels
La compréhension holistique du terme «Dispositif d’essai» est un état fixe dans un code ou un ensemble d'étapes fixes dans un code qui est utilisé comme condition préalable et quelques autres ensembles d'étapes qui sont utilisés comme postcondition pour tous les tests.
Ainsi, en d'autres termes, nous identifions ces ensembles d'instructions qui se répéteront pour tous les tests et, par conséquent, essayons de définir un environnement fixe pour l'exécution de nos méthodes de test.
Le but l'utilisation de Test Fixture consiste à éliminer la duplication du code commun pour tous les cas de test.
commandes unix interview questions et réponses pdf
Essayons de comprendre la mise en œuvre pratique du dispositif de test dans un test JUnit.
méthode setUp ()
- Il existe des tests qui nécessitent l'initialisation de certains objets (chaîne, entier ou ArrayList ou tout autre objet d'ailleurs). Vous pouvez créer une méthode public void setUp () dans lequel vous pouvez déclarer les variables d'instance pour les objets communs. Placez cette méthode setUp () sous l'annotation @Avant que . Avec l'annotation @Before, le framework exécutera la méthode setUp () avant chaque exécution de scénario de test.
- La méthode setUp () peut également être utilisée dans le cas où vous souhaitez lancer un navigateur avec une URL spécifique comme première étape, vous exécutez un cas de test qui suit la connexion à l'application avec des informations d'identification prédéfinies.
méthode tearDown ()
- Si vous avez alloué des ressources externes dans un test, n'oubliez pas de libérer les ressources également. La méthode teardown () pourrait être ajoutée pour le nettoyage des objets une fois l'exécution du scénario de test terminée. De la même manière que la méthode setUp (), ajoutez une méthode démontage du vide public () sous @Après annotation. Le framework JUnit s'assure qu'après chaque cas de test, la méthode sous @After est sûrement exécutée. Les objets utilisés dans le test doivent être définis NULL dans la méthode teardown () afin que les déchets des tests soient collectés.
- Un autre bon candidat pour le nettoyage des objets est de tuer un navigateur en action une fois le scénario de test terminé et de libérer la mémoire en détruisant les objets utilisés.
- Les noms de méthode setUp () et tearDown () ne sont qu'un nom défini par l'utilisateur. Vous pouvez définir n'importe quel nom de méthode que vous souhaitez. Ce ne sont que les annotations utilisées avec la méthode qui déterminent la séquence d’exécution des tests.
Exemples de bancs d'essai JUnit
Dans cette section, nous allons passer en revue deux exemples du test JUnit 4 et essayer de comprendre comment utiliser l'approche de Test Fixtures dans notre code ainsi que la séquence des différentes annotations de cycle de vie @Before, @After, @BeforeClass, @AfterClass, et @Test.
Bien sûr, il y aura un didacticiel séparé sur les annotations qui clarifiera ce qu'elles sont et comment chacune des annotations fonctionne. À partir de maintenant, restons fidèles à la compréhension de l'utilisation du dispositif de test dans le code.
Test JUnit 4 - Exemple 1
Dans cet exemple, nous aurons les montages de test dans la classe avec trois cas de test. La méthode setUp () avec l'annotation @Before et la méthode tearDown () avec l'annotation @After.
Code:
package demo.tests; import static org.junit.Assert.*; import org.junit.After; import org.junit.Before; import org.junit.Test; public class JUnitProgram { @Before public void setUp() { System.out.println('_______________________________________________________
'); System.out.println('This is the setUp() method that runs before each testcase'); } @Test public void test_JUnit1() { System.out.println('This is the testcase test_JUnit1() in this class'); } @Test public void test_JUnit2() { System.out.println('This is the testcase test_JUnit2() in this class'); } @Test public void test_JUnit3() { System.out.println('This is the testcase test_JUnit3() in this class'); } @After public void tearDown() { System.out.println('This is the tearDown() method that runs after each testcase'); System.out.println('_______________________________________________________
'); } }La fenêtre de console résultante sera comme indiqué ci-dessous:
La fenêtre de la console montre clairement qu'avant chaque test, la méthode setUp () s'exécute, et après chaque test terminé, la méthode tearDown () s'exécute.
Ainsi, la séquence d'exécution par annotation pour chaque méthode de test est:
- @Avant que
- @Test
- @Après
Rappelez-vous que les tests, bien qu'ici, se sont exécutés dans un ordre séquentiel, c'est-à-dire test_JUnit1 (), test_JUnit2 (), test_JUnit3 (), il n'y a pas de séquence définie pour le test, ils peuvent donc s'exécuter dans n'importe quel ordre. Chaque test est isolé de l'autre test.
Test JUnit 4 - Exemple 2
Voyons ici rapidement comment nous pouvons avoir une méthode qui s'exécute une fois pour la toute première fois dans une classe et une autre méthode qui s'exécute une fois après que tous les tests ont été exécutés pour la classe.
Code:
package demo.tests; import static org.junit.Assert.*; import org.junit.After; import org.junit.Before; import org.junit.Test; public class JUnitProgram { @BeforeClass public static void preClass() { System.out.println('This is the preClass() method that runs one time before the class'); } @Before public void setUp() { System.out.println('_______________________________________________________
'); System.out.println('This is the setUp() method that runs before each testcase'); } @Test public void test_JUnit1() { System.out.println('This is the testcase test_JUnit1() in this class'); } @Test public void test_JUnit2() { System.out.println('This is the testcase test_JUnit2() in this class'); } @Test public void test_JUnit3() { System.out.println('This is the testcase test_JUnit3() in this class'); } @After public void tearDown() { System.out.println('This is the tearDown() method that runs after each testcase'); System.out.println('_______________________________________________________
'); } @AfterClass public static void postClass() { System.out.println('This is the postClass() method that runs one time after the class'); } } Nous avons ajouté la méthode preClass () sous l'annotation @BeforeClass. Cette méthode ne s'exécute qu'une seule fois pour une classe avant l'exécution du test. Il s'exécute avant même que la méthode sous @Before ne s'exécute.
La méthode postClass () sous l'annotation @AfterClass s'exécute une fois à la fin lorsque tous les tests, y compris le test sous @After, sont exécutés et terminés.
La séquence du test est la suivante:
- @Avant les cours
- @Avant que
- @Test
- @Après
- @Après les cours
Les méthodes sous @BeforeClass et @AfterClass sont généralement partagées par la classe, c'est pourquoi si les méthodes ne sont pas déclarées comme statique puis ça donne un erreur d'initialisation lors de l'exécution du test.
qu'est-ce qu'un fichier .bin?
Voir la capture d'écran ci-dessous, où nous n'avons pas défini la méthode preClass () sous l'annotation @BeforeClass comme statique et ainsi le test a fait une erreur lors de l'exécution.
Vous pouvez voir le résultat indiquant une erreur d'initialisation qui pourrait être éliminée en marquant la méthode comme statique. Il en va de même pour la méthode postClass () sous l'annotation @AfterClass.
Conclusion
Nous avons tenté de mettre en contexte les bonnes pratiques de programmation à suivre pour la mise en Appareil d'essai approche et une compréhension de base de l'utilisation et de la séquence d'exécution des annotations du cycle de vie.
Dans notre prochain tutoriel, nous en apprendrons davantage sur la différentes manières d'exécuter les tests JUnit dans Eclipse. Alors restez à l'écoute de la série au fur et à mesure que nous progressons avec des aspects plus intéressants de JUnit.
=> Vérifiez ici pour voir de A à Z des didacticiels de formation JUnit ici.
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
- Tutoriel Python DateTime avec des exemples
- Tutoriel sur la méthode Java String contains () avec des exemples
- Tutoriel sur l'utilisation de l'instruction C # et la méthode virtuelle C # avec des exemples
- Introduction au framework JUnit et à son utilisation dans Selenium Script - Tutoriel Selenium # 11
- Tutoriel de recherche d'élément par texte Selenium avec des exemples
- Tutoriel Java Array Length avec des exemples de code