multiple ways execute junit tests
Aquest tutorial mostra diverses maneres d'executar proves JUnit com ara executar-se com a prova JUnit, utilitzar tecles de drecera o executar la prova JUnit des de la línia d'ordres, etc.:
Vam veure com escriure els casos de prova bàsics de JUnit i tenir un enfocament de solucions de prova com una de les bones pràctiques de programació de JUnit al nostre tutorial anterior.
En aquest tutorial, fem una ullada a les diferents maneres que podem utilitzar per executar proves de JUnit. Us sorprendrà veure el nombre d’opcions disponibles per executar aquests casos de prova.
=> Mireu aquí les sèries de formació JUnit senzilles.
Què aprendreu:
- Diferents maneres d'executar proves JUnit
- # 1) Executeu com a prova JUnit
- # 2) Executeu la darrera prova executada de JUnit mitjançant l'opció de menú
- # 3) Executeu amb tecles de drecera
- # 4) Executeu només un mètode de prova en una classe
- # 5) Executeu les proves JUnit des de la línia d'ordres
- # 6) Executeu Test Suite amb la classe Testrunner
- # 7) Executeu JUnit Test Cases utilitzant Maven
- Conclusió
- Lectura recomanada
Diferents maneres d'executar proves JUnit
Per tal d'executar proves JUnit, hi ha algunes maneres en què podeu executar un fitxer de classe única amb un o diversos mètodes de prova mitjançant les opcions següents:
- Opció 'Executa com a prova JUnit'.
- Executeu l'última prova de JUnit executada mitjançant l'opció de menú.
- Executeu amb tecles de drecera.
- Executeu només un mètode de prova en una classe.
- Executeu la línia d'ordres.
- Executeu-lo amb el fitxer de classe Testrunner.
- Feu servir també a través de Maven.
Nota: L’execució de la prova JUnit a través de Maven es contemplarà en un tutorial separat per a JUnit Maven.
Reiterant el punt, en aquest tutorial, aprendrem com es poden agrupar diverses proves en una suite de proves i com es podria executar la suite de maneres diferents. A més, detallarà certa informació addicional rellevant i relacionada.
# 1) Executeu com a prova JUnit
La forma més senzilla d’executar les proves JUnit és:
Mètode 1:
- Feu clic amb el botó dret al fitxer de classe a la vista Script
- Seleccioneu Executa com a -> Prova JUnit
- El fitxer de classe s'executa.
Mètode 2:
- De la mateixa manera, podeu seleccionar el fitxer de classe a la vista Explorador de paquets
- Feu clic amb el botó dret al fitxer
- Seleccioneu Executa com a -> Prova JUnit
- El fitxer de classe s'executa.
Nota: D’aquesta manera podríeu executar un fitxer de classe a la vegada.
# 2) Executeu la darrera prova executada de JUnit mitjançant l'opció de menú
Podeu executar un fitxer de classe JUnit mantenint un fitxer de classe obert a l'editor. Aneu al menú superior del fitxer Eclipsi => Seleccioneu Executa => Executa . L’opció Executa -> Executa bàsicament significa tornar a executar la prova que heu fet l'últim.
Considerem una classe JUnit amb diversos mètodes / proves per a una millor claredat de com Executa-> Executa obres:
- Escenari 1 : Si haguessis executat un mètode únic amb @Test, després quan feu clic Executa-> Executa , l'únic mètode que s'ha executat darrerament només s'executaria aquesta vegada i no tota la classe JUnit.
- Escenari 2 :Mentre que havíeu executat el tota la classe prèviament, Executa-> Executa tornaria a executar tot el fitxer de classe.
Ara que ja sabem que Executa-> Executa executa la prova que heu fet l'últim, això ens portarà a pregunta si podeu canviar la preferència de l'opció Executa-> Executa?
La resposta a la pregunta és Sí, es pot canviar la preferència de l'opció Executa-> Executa. Hi ha una certa configuració adjunta a Executa-> Executa.
A continuació s’explica com podeu fer-ho:
a) La configuració d’execució d’Eclipse és bàsicament predeterminada executeu el recurs seleccionat o l'editor actiu si es pot llançar .
Llavors, què significa la configuració predeterminada - 'Executeu el recurs seleccionat o l'editor actiu si es pot executar'?
La resposta a això és que no executarà l'aplicació que vau llançar l'últim, sinó que seguirà la versió nova de l'última aplicació llançada per a l'editor actiu .
b) Llavors, com canvieu la preferència predeterminada?
La resposta a això és que podeu canviar la preferència predeterminada a Eclipse per executar la darrera aplicació que vau llançar independentment de l'editor actiu Tu tens.
A continuació s'explica com canvieu la preferència de l'opció Executar mitjançant Executa -> Executa:
- Aneu a Windows => Preferències => Executa / Depura => Inici
- 'Launch Operation' té un botó d'opció predeterminat: ' Inicieu l'aplicació llançada anteriorment ' seleccionat a la segona opció ' Inicieu el recurs seleccionat o l'editor actiu. Si no es pot llançar : '.
- És possible que hagueu de canviar aquesta preferència pel primer botó d’opció, és a dir, ' Inicieu sempre l'aplicació llançada anteriorment '.
# 3) Executeu amb tecles de drecera
Podeu seleccionar el fitxer de classe a la vista Script o a la vista Explorador de paquets i utilitzar les tecles de drecera següents per executar les proves JUnit:
- Premeu les tecles ALT + MAJ + X, T per tal d'executar el fitxer de classe JUnit.
- Una alternativa a això seria la premsa ALT + R i després CTRL + F11 per executar un fitxer de classe JUnit. ALT + R i després CTRL + F11 és l'opció de drecera per al menú Executa -> Executa
# 4) Executeu només un mètode de prova en una classe
De vegades, és possible que vulgueu executar un sol mètode de prova JUnit.
En el cas, hi ha més d’un mètode dins del fitxer de classe JUnit:
- Podeu seleccionar o col·locar el cursor al nom del mètode a la vista de seqüència.
- Utilitzeu les tecles de drecera esmentades anteriorment o les opcions proporcionades anteriorment per executar només el mètode que acabeu de seleccionar.
Nota: ALT + MAJÚS + X, T pot executar els mètodes seleccionats tal com s’esperava. Tanmateix, si voleu executar un mètode específic en una classe JUnit, ha de ser un testcase anotat amb @Test, sinó que mostra un error d'inicialització.
Dit d’una altra manera, si seleccioneu mètodes a @Before o @After (qualsevol anotació que no sigui @Test), s’executaria un mètode d’execució específic.
# 5) Executeu les proves JUnit des de la línia d'ordres
Igual que executeu qualsevol fitxer de classe Java mitjançant la línia d'ordres, també podeu compilar i executar fitxers de classe JUnit a través de la línia d'ordres.
Aquí tractarem els subtemes següents per entendre com podem executar les proves de JUnit a través de la línia d’ordres:
- Com es compila una prova de JUnit a la línia d'ordres?
- Com s'executa una prova de JUnit a la línia d'ordres?
- Informació addicional sobre l'execució de la línia d'ordres.
- Com es corregeix l'error d'ordres no reconegut de l'ordre javac?
- Avantatges d'executar proves mitjançant la línia d'ordres.
# 5.1) Com es compila una prova de JUnit a la línia d'ordres?
La condició prèvia per compilar i executar un fitxer de classe JUnit mitjançant un símbol del sistema és:
- Primer afegiu fitxers jar JUnit rellevants a la ruta de la classe.
- Establiu les variables d'entorn tal com es va esmentar al fitxer SetUp de JUnit tutorial.
- A continuació, compileu un fitxer de classe JUnit.
- La sintaxi per compilar un fitxer de classe JUnit a través de la línia d’ordres és:
javac -cp junit-4.0.0.jar;. JUnitProgram.java
Aquí, javac és el compilador Java que utilitza l’opció -cp.
L'ordre javac -cp busca els paràmetres següents:
- El fitxer jar JUnit va seguit d'un punt i coma.
- El camí del directori on existeix el fitxer font.
- El nom del fitxer de classe
A la sintaxi indicada anteriorment, què implica el punt (.)?
Hem esmentat un punt al lloc de tota la ruta del directori.
El punt implica que:
- El classpath ja inclou el directori actual dels fitxers font de Java.
- La JVM (màquina virtual de Java) assumeix automàticament que el directori actual és on es col·loquen els fitxers font.
- A continuació, JVM hi busca el nom de fitxer JUnit esmentat. El nom de fitxer és l'últim paràmetre indicat a l'ordre compile.
Podeu comprovar els paràmetres que entren a -cp mitjançant els passos següents:
- Obriu el símbol del sistema.
- Escriviu javac i premeu ENTRAR.
- Es mostren totes les opcions rellevants, inclòs -cp. Trobareu que -cp va com a paràmetre on el camí és el camí dels fitxers de classe que cerca JVM.
Captura de pantalla següent:
Com compilar diversos fitxers alhora?
Es poden compilar diversos fitxers de prova JUnit alhora separant els noms de fitxers amb espais.
A continuació es mostra un exemple d'on compileu fitxers java JUnitProgram i demoTest:
javac -cp junit-4.0.0.jar;. JUnitProgram.java demoTest.java
# 5.2) Com executar una prova JUnit des de la línia d'ordres?
De la mateixa manera, javac és el compilador Java utilitzat java -cp s'utilitza per executar els fitxers de classe Java, incloses les classes JUnit.
A continuació es mostra la sintaxi que podeu seguir:
java -cp junit-4.0.0.jar;. JUnitProgram demoTest
Aquesta ordre executa tant els fitxers JUnitProgram.java com demoTest.java un darrere l’altre.
# 5.3) Informació addicional sobre l'execució de la línia d'ordres.
preguntes i respostes per a l'entrevista d'assegurament de la qualitat pdf
Aquí hi ha informació addicional sobre com es corregeix un error amb l'ordre javac i per què utilitzar l'opció d'execució de línia d'ordres
# 5.3.1) Com es corregeix l'error d'ordres no reconegut de l'ordre javac?
La majoria de nosaltres ens trobaríem amb aquest problema mentre intentàvem executar el fitxer javac a través de la línia d'ordres. Això també m'ha passat; així que hem pensat a escriure-ho aquí.
a) Vam entrar al comandament javac i pressionat Entra a l'indicador d'ordres.
b) El missatge d'error - javac no es reconeix com una comanda interna o externa, un programa operatiu o un fitxer per lots es va mostrar a continuació:
Aquí és on comença la compilació dels fitxers de classe Java de la línia d’ordres. Per tant, l’error és un motiu de preocupació i no es pot ignorar.
Per solucionar el problema, seguiu els passos següents i Aquí està!!! veieu que l'error s'ha desaparegut:
- Fem una demostració d’aquest procés mitjançant un fitxer Java bàsic. El primer pas que podeu fer és crear una classe Java bàsica Per exemple. : 'Calculator.java'
- Localitzarem Calculate.java des de l’explorador de Windows i copiarem el camí.
- Canvieu el directori de l'indicador d'ordres pel camí que heu copiat (el camí del fitxer d'origen). Utilitzeu cd per canviar el directori.
- Ara configureu el PATH a la carpeta jdk bin mitjançant l'ordre.
SET PATH = i premeu ENTER.
- Aquí, el camí d'accés jdk és C: Program Files Java jdk1.8.0_181 bin. Per tant, hem establert el camí en conseqüència. El resultat no mostra res en prémer ENTER després de l'ordre.
- Ara, verifiqueu si la JVM reconeix l'ordre javac introduint l'ordre javac i prement ENTRAR.
-
- Si reconeix l'ordre, es mostrarà com a resultat un conjunt d'opcions vàlides per a javac.
- En cas contrari, es mostrarà de nou l’error.
A continuació es mostra una captura de pantalla que mostra que hem eliminat correctament l’error.
No intentem eludir una pregunta essencial aquí:
Per què la JVM va reconèixer l’ordre javac després d’haver definit el camí a la carpeta jdk bin?
Estem segurs que també tindreu aquesta pregunta a la vostra ment. A continuació es dóna la resposta.
- La carpeta jdk bin té totes les biblioteques per a l'ordre javac. Per tant, és per això que, quan configureu el camí en conseqüència, la JVM ara pot reconèixer l'ordre javac sense cap problema.
- Vegeu el carpeta javac sota la paperera jdk de la imatge següent.
- A continuació, podeu executar l'ordre 'Compilar i executar Java' mitjançant la línia d'ordres. A més, també recordeu establir la variable CLASSPATH adequadament. Variables JAVA_HOME i JUNIT_HOME per a fitxers Java i fitxers JUnit, respectivament.
# 5.3.2) Avantatge de realitzar proves mitjançant la línia d'ordres:
Analitzem ràpidament l’avantatge d’executar proves de Java / JUnit mitjançant la línia d’ordres.
Com ja sabeu, no hi ha una regla ràpida i dura sobre l'execució dels fitxers de classe a través de la línia d'ordres. És només una forma alternativa de com podeu gestionar la compilació i l'execució dels fitxers de classe.
Si us pregunteu si hi ha un avantatge especial a l’hora de tenir coneixements sobre l’execució de les proves de JUnit mitjançant la línia d’ordres, diríem ‘Certament, sí’.
A continuació es mostra el motiu del 'Sí':
- Totes aquestes sèries de passos que hem seguit més amunt; es podria afegir al bloc de notes i convertir-lo en un fitxer per lots.
- Ara, quan executeu aquest fitxer per lots amb un doble clic, es podria activar la compilació i l'execució de diversos fitxers de prova JUnit anomenats al fitxer per lots.
Quin avantatge té compilar i executar un fitxer per lots en la compilació i execució dels fitxers Java?
- Un fitxer batch / jar pot actuar com una utilitat fàcil d’utilitzar que podria permetre a qualsevol persona que desconeixi la lògica interna del codi i executar múltiples casos de prova molt fàcilment.
- Això pot eliminar la necessitat de tenir un desenvolupador o QA especialitzat per fer aquests treballs d'execució de proves. La tasca d'execució es pot delegar a qualsevol recurs sense preocupar-se de les limitacions d'habilitat.
A la següent opció alternativa, veurem una altra forma avantatjosa i encomiable d’executar els nostres casos de prova de JUnit.
# 6) Executeu Test Suite amb la classe Testrunner
En els escenaris en temps real, l’execució d’una prova a la vegada és l’opció menys preferida.
- Tenim casos en què hem d’executar un grup de casos de prova relacionats / no relacionats.
- Per exemple, és possible que haguem de crear i executar suites de proves de regressió o suites de proves de fum.
Ara coneixerem la implementació de diferents anotacions utilitzades per crear suites de prova i executar la suite.
El procés general d'execució del conjunt de proves mitjançant Test Runner és el següent:
- Creeu JUnit classe 1, JUnit classe 2,…. JUnitat classe n.
- Creeu un fitxer de classe de suite de proves que agrupi els casos de prova.
- Creeu un fitxer de classe Testrunner per invocar el conjunt de proves creat.
- Executeu la classe Testrunner.
A la imatge següent es mostra l'estructura dels programes a través dels quals farem una demostració de la creació del paquet de proves i l'execució del fitxer corredor:
Aquí tractarem els subtemes:
- Creació de classes JUnit
- Creació de suites de proves
- Creació d’un fitxer Testrunner i execució de les suites de prova amb ell.
- Informació addicional sobre el funcionament de l’anotació @RunWith.
# 6.1) Creació de classes JUnit
Comencem creant dos fitxers de classe JUnit senzills:
- JUnitTestCase1.java - Inclou el codi per verificar un valor numèric esperat: la variable Valor1 coincideix amb un valor real de la variable Valor2.
- JUnitTestCase2.java - Inclou el codi per verificar si la variable de cadena esperada strValue i variable de cadena real estrActual partits.
Es tracta bàsicament de dos casos de prova que intentarem introduir en una agrupació lògica anomenada suite de proves i fer que s’executi un darrere l’altre.
Codi per a JUnitTestCase1.java
package demo.tests; import static org.junit.Assert.*; import java.util.*; import java.lang.String; import static org.testng.Assert.assertTrue; import org.junit.Before; import org.junit.Test; import junit.framework.Assert; public class JUnitTestCase1 { public int Value1=6000; @Test public void junitMethod1(){ int Value2=9000; Assert.assertEquals(Value1, Value2); } }
Codi per a JUnitTestCase2.java
package demo.tests; import static org.junit.Assert.*; import java.util.*; import java.lang.String; import static org.testng.Assert.assertTrue; import org.junit.Before; import org.junit.Test; import junit.framework.Assert; public class JUnitTestCase2 { public String stringValue='JUnit'; @Test public void junitMethod2(){ String strActual='Junit1'; Assert.assertSame(stringValue, strActual); } }
# 6.2) Creació de la suite de proves:
Aquesta secció i la següent tenen un paper destacat en tot el procés de creació i execució d’un conjunt de proves. En aquesta secció, intentarem entendre-ho com agrupar diverses classes de proves de JUnit i unir-les a un conjunt de proves .
Segons la imatge estructural anterior, creem una suite de proves que agrupa JUnitTestCase1.java i JUnitTestCase2.java i anomenem la suite com JUnitTestSuite.java
Les dues anotacions que ens ajuden a crear una suite de proves són:
- @RunWith i
- @SuiteClasses
Paquets necessaris per a les anotacions:
- Haureu d’importar el paquet org.junit.runner.RunWith; per a la inclusió de @RunWith amb anotació.
- Necessitareu el paquet org.junit.runners.Suite.SuiteClasses perquè funcioni @SuiteClasses.
- A més, també haureu d’importar el paquet org.junit.runners.Suite per passar un paràmetre Suite.class a l’anotació @RunWith.
Vegem el codi per a una millor comprensió !!
Codi de JUnitTestSuite.java
package demo.tests; import static org.junit.Assert.*; import org.junit.After; import org.junit.AfterClass; import org.junit.BeforeClass; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.Suite; import org.junit.runners.Suite.SuiteClasses; @RunWith(Suite.class) @SuiteClasses({JUnitTestCase1.class, JUnitTestCase2.class }) public class JUnitTestSuite { @BeforeClass public static void printMe() { System.out.println('JUnitTestSuite is the test suite grouping testcase 1 and testcase 2'); } }
Comprensió del codi de JUnitTestSuite.java:
- @RunWith ajuda la JVM a entendre quin tipus de cursa hauria de córrer Per exemple. Suite.class o Cucumber.class
- Aquí, el paràmetre de @RunWith és Suite.class . Ajuda a JVM a reconèixer que el fitxer actual on s’utilitza @RunWith (Suite.class) té un paper a la suite de proves.
- Els noms de classes de prova de la JUnit que s’uneixen en una suite s’han de passar com una matriu de cadenes en forma de paràmetres per a @SuiteClasses separats cadascun per una coma.
- Això permet a JVM saber quines són totes les proves que cal agrupar a la suite.
- El nom de la suite serà el nom del fitxer de la classe JUnit que s’anota amb @RunWith i @SuiteClasses, que és JUnitTestSuite en aquest cas.
# 6.3) Creeu el fitxer Test Runner i executeu el conjunt de proves JUnit mitjançant Test Runner
L'últim pas ens ajudarà a executar el conjunt de proves que acabem de crear a la secció anterior mitjançant un fitxer Testrunner.
- Ara crearem un fitxer Java anomenat SuiteRunnerFile.
- Aquest SuiteRunnerFile.java no és una classe JUnit, sinó un fitxer Java habitual amb el mètode principal.
Vegem el codi i, a continuació, intentem entendre'l.
Codi de SuiteRunnerFile.java
package demo.tests; import org.junit.runner.JUnitCore; import org.junit.runner.Result; import org.junit.runner.notification.Failure; public class SuiteRunnerFile { public static void main(String args[]) { Result result=JUnitCore.runClasses(JUnitTestSuite.class); for (Failure failure : result.getFailures()) { System.out.println(failure.toString()); } } }
Paquets necessaris per a l’anotació
- Cal incloure el paquet org.junit.runner.JunitCore per incloure el paquet JUnitCore classe al codi.
- Cal importar el paquet org.junit.runner.notification.Failure i org.junit.runner. Resultat per incloure Failure i Result class al codi, respectivament.
Comprensió del codi per a SuiteRunnerFile.java
- Per tal de crear un fitxer runner per a l'execució del paquet de proves, el fitxer JUnitCore la classe té un paper important.
- El runClasses () mètode de JUnitCore class pren el nom de la classe del paquet de proves com a paràmetre d'entrada, de manera que tenim la sentència JUnitCore. runClasses (JUnitTestSuite. classe ).
- El tipus de retorn d'aquesta sentència és el Resultat objecte de classe que emmagatzema l'estat d'èxit i l'estat de fracàs resultants de cadascun dels fitxers del cas de prova; postexecució. Per això tenim un resultat com el Resultat objecte de classe al codi.
- A continuació, imprimim els errors dels casos de prova, si n'hi ha. Igual que el mètode getFailures (), també podeu obtenir el recompte d'errors i el recompte d'execució mitjançant el mètode getFailureCount () i getRunCount (), respectivament.
- Ara SuiteRunnerFile està a punt per executar-se,
- Seleccioneu el fitxer a l 'Explorador de paquets i
- Feu clic amb el botó dret i seleccioneu Executa com -> Java, el programa s'executa.
A continuació es mostra la captura de pantalla de la finestra de la consola.
Explicació dels resultats a la consola:
La consola anterior mostra que:
- El fitxer de la classe JUnitTestSuite s'ha executat a través de SuiteRunnerFile.
- El mètode printMe () sota anotació @BeforeClass s'ha executat primer i
- A continuació, els casos de prova del conjunt de proves es van executar un darrere l’altre. Així es pot crear i executar el paquet de proves.
# 6.4) Informació addicional: com funciona @RunWith?
- @RunWith és una API JUnit que bàsicament només pren un element com a paràmetre d'entrada que és un nom de fitxer de classe corredor.
- El marc JUnit invoca la classe especificada com a corredor de prova.
El fragment següent de RunWith.java us ajudarà a comprendre:
@Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) @Inherited public @interface RunWith { Class Extends Runner> value(); }
Descripció del codi d'interfície RunWith anterior:
- L'especificat valor L 'element ha de ser una classe derivada de Corredor classe . Aquí s’utilitza el concepte de reflexió.
- Un molt bon exemple d’aquesta classe de corredors ja està implementat al nostre codi, és a dir, @RunWith (Suite.class), on s’uneixen un grup de casos de proves per formar un conjunt de proves.
- De la mateixa manera, un altre bon exemple d’utilitzar una classe Runner amb @RunWith podria ser @RunWith (Cucumber.class), que és un marc de desenvolupament basat en el negoci (BDD) per a l’automatització de proves mitjançant Selenium a Java. Això ajuda el marc a executar els casos de prova basats en Cucumber.
Nota:
- Les anotacions i els paràmetres utilitzats per crear i executar el conjunt de proves JUnit d’aquest tutorial eren específics de JUnit 4.
- Hi ha una manera lleugerament diferent de com es crea un JUnit Test Suite i s’executa el fitxer corredor a JUnit 5.
Aviat tindrem una comprensió centrada en tots els aspectes de JUnit 4 vs JUnit 5 als nostres propers tutorials.
# 7) Executeu JUnit Test Cases utilitzant Maven
També podeu tenir un projecte Maven format per proves JUnit i executar-les mitjançant Maven, que es tractarà en un tutorial separat.
Conclusió
- Hem après totes les diferents opcions per executar les proves de JUnit: proves individuals i diverses agrupades en grups de proves.
- Tenim coneixement addicional sobre com actualitzar la preferència per a l'opció Executa, com corregir l'error javac i com ens pot ajudar l'execució de la línia de comandes.
- A més, també vam aprendre sobre com funciona l’anotació @RunWith.
Per tant, hi ha més coses a seguir en els propers tutorials. ‘Stand By’ fins llavors !!!
=> Visiteu aquí per aprendre JUnit From Scratch.
Lectura recomanada
- Proves JUnit: Com escriure casos de prova JUnit amb exemples
- Tutorial JUnit per a principiants: què és la prova JUnit
- Què és un dispositiu de prova de JUnit: tutorial amb exemples de JUnit 4
- Specflow Reporting: Com generar informes de proves i executar proves selectives
- Descarregueu, instal·leu i configureu JUnit a Eclipse
- Introducció a JUnit Framework i el seu ús a Selenium Script - Selenium Tutorial # 11
- Creeu proves Appium per a una aplicació d'Android
- Inseriu diversos documents a MongoDB mitjançant matrius