what is junit test fixture
Aquest tutorial explicarà quan, per què i com s'utilitza el dispositiu de prova JUnit amb exemples senzills de dispositiu de prova JUnit per entendre fàcilment el concepte:
Aprendrem -
- Quan i per què hem de fer servir Test Fixture?
- Quin és l'enfocament per utilitzar-lo al nostre codi per a la prova JUnit?
- Un parell d’exemples per entendre el terme ‘Dispositiu de prova’ van paral·lelament a la cascada amb un avantatge a les anotacions del cicle de vida de JUnit 4 com @Before, @After, @BeforeClass, @AfterClass i @Test.
=> Consulteu TOTS els tutorials de JUnit aquí.
Què aprendreu:
Dispositiu de prova JUnit
Quan hi ha diversos casos de prova en una classe JUnit, hi pot haver un objecte o objectes comuns que facin servir tots els casos de prova. En aquest cas, podria haver-hi funcions específiques que podrien ser comunes en tots els casos de prova.
Això no vol dir que tots els casos de prova hagin de compartir els objectes de prova. El canvi de l’objecte realitzat en una prova no s’ha de compartir entre totes les proves, ja que aquestes proves són independents i es poden executar en un ordre diferent segons el seu conjunt de prioritats.
com escriure un correu electrònic a una mostra de reclutador
La comprensió holística del terme 'Dispositiu de prova' és un estat fix en un codi o un conjunt de passos fixos en un codi que s'utilitza com a condició prèvia i alguns altres conjunts de passos que s'utilitzen com a postcondició per a totes les proves.
Així, en altres paraules, estem identificant aquells conjunts d’instruccions que es repetiran per a totes les proves i, per tant, provem d’establir un entorn fix perquè els nostres mètodes de prova s’executin.
El propòsit utilitzar Test Fixture consisteix a eliminar la duplicació del codi comú per a totes les proves.
què és com obrir un fitxer json
Intentem comprendre la implementació pràctica del dispositiu de prova en una prova de JUnit.
mètode setUp ()
- Hi ha proves que necessiten la inicialització de certs objectes (cadena, enter o ArrayList o qualsevol objecte per al cas). Podeu crear un mètode public void setUp () en què podríeu declarar les variables d’instància dels objectes comuns. Col·loqueu aquest mètode setUp () a sota de l’anotació @Abans . Amb l’anotació @Before, el framework executarà el mètode setUp () abans de l’execució de cada cas de prova.
- El mètode setUp () també es podria utilitzar per si voleu iniciar un navegador amb una URL específica, ja que el primer pas és executar un cas de prova que segueix l'inici de sessió a l'aplicació amb credencials predefinides.
mètode tearDown ()
- Si heu assignat recursos externs en una prova, també heu de recordar alliberar-los. Es podria afegir el mètode teardown () per a la neteja dels objectes un cop finalitzada l'execució del cas de prova. Afegiu un mètode de manera similar al mètode setUp () demolició del buit públic () sota @Després anotació. El framework JUnit assegura que després d'executar cada cas de prova, el mètode sota @After s'executa segurament. Els objectes usats a la prova s'han d'establir NULL en el mètode teardown () perquè es reculli la brossa de les proves.
- Un altre bon candidat per a la neteja dels objectes és matar un navegador en acció després de completar el cas de prova i alliberar la memòria destruint els objectes usats.
- Els noms dels mètodes setUp () i tearDown () són només un nom definit per l'usuari. Podeu establir el nom del mètode que vulgueu. Només són les anotacions que s’utilitzen amb el mètode les que decideixen la seqüència de l’execució de les proves.
Exemples d'aparells de prova JUnit
En aquesta secció, revisarem dos exemples de la prova JUnit 4 i intentarem entendre com utilitzar l'enfocament dels accessoris de prova al nostre codi juntament amb la seqüència de diferents anotacions del cicle de vida @Before, @After, @BeforeClass, @AfterClass, i @Test.
Per descomptat, hi haurà un tutorial separat sobre les anotacions que aclarirà què són i com funcionen cadascuna de les anotacions. A partir d’ara, continuem amb la comprensió de l’ús del dispositiu de prova al codi.
Prova de la Unitat 4: exemple 1
En aquest exemple, tindrem els accessoris de prova a la classe amb tres casos de prova. El mètode setUp () amb @Before annotation i tearDown () amb el mètode @After annotation.
Codi:
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 finestra de la consola resultant serà la següent:
La finestra de la consola fa evident que abans de cada execució de la prova, s’executa el mètode setUp () i, un cop finalitzada la prova, s’executa el mètode tearDown ().
Per tant, la seqüència d'execució de l'anotació per a cada mètode de prova és:
- @Abans
- @Prova
- @Després
Recordeu que les proves, tot i que aquí, s’han executat en ordre seqüencial, és a dir, test_JUnit1 (), test_JUnit2 (), test_JUnit3 (), no hi ha cap seqüència definida a la prova, per tant, es poden executar en qualsevol ordre. Cada prova està aïllada de l’altra prova.
Prova de la Unitat 4: exemple 2
Aquí, vegem ràpidament com podem tenir un mètode que s’executa una vegada per primera vegada en una classe i un altre que s’executa una vegada després d’executar totes les proves de la classe.
Codi:
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'); } } Hem afegit el mètode preClass () a l’anotació @BeforeClass. Aquest mètode només s'executa una vegada per a una classe abans de l'execució de la prova. S’executa fins i tot abans que s’executi el mètode de @Before.
El mètode postClass () sota l’anotació @AfterClass s’executa una vegada al final quan s’executen i es completen totes les proves, inclosa la prova sota @After.
La seqüència de la prova és la següent:
- @BeforeClass
- @Abans
- @Prova
- @Després
- @Després de classe
Els mètodes de @BeforeClass i @AfterClass solen ser compartits per la classe, motiu pel qual si els mètodes no es declaren com estàtic llavors dóna un error d'inicialització en l'execució de la prova.
com implementar una llista doblement enllaçada a Java
Vegeu la captura de pantalla següent, on no hem definit el mètode preClass () a l’anotació @BeforeClass com a estàtic i, per tant, la prova ha errat en executar-se.
És possible que vegeu el resultat que mostra un error d’inicialització que es podria eliminar en marcar el mètode com a estàtic. El mateix passa amb el mètode postClass () a l’anotació @AfterClass.
Conclusió
Hem intentat establir un context sobre les bones pràctiques de programació que cal seguir implementant el programa Dispositiu de prova enfocament i una comprensió bàsica de l’ús i la seqüència d’execució de les anotacions del cicle de vida.
Al nostre següent tutorial, coneixerem el diferents maneres d’executar proves JUnit a Eclipsi. Així que estigueu atents a la sèrie a mesura que avancem amb aspectes més interessants de JUnit.
=> Consulteu aquí per veure els tutorials de formació A-Z de JUnit aquí.
Lectura recomanada
- Proves JUnit: Com escriure casos de prova JUnit amb exemples
- Tutorial JUnit per a principiants: què és la prova JUnit
- Tutorial de Python DateTime amb exemples
- Java String conté () Tutorial de mètode amb exemples
- C # Ús de declaracions i C # Tutorial de mètode virtual amb exemples
- Introducció a JUnit Framework i el seu ús a Selenium Script - Selenium Tutorial # 11
- Tutorial Selenium Find Element By Text amb exemples
- Tutorial de longitud de matriu de Java amb exemples de codi