Menú

Tutorial JUnit per a principiants: què és la prova JUnit

  • Principal
  • Altres
  • Tutorial JUnit per a principiants: què és la prova JUnit

junit tutorial beginners what is junit testing

Proveu El Nostre Instrument Per Eliminar Problemes

Aquest tutorial de JUnit per a principiants explica què és la prova unitària, la cobertura de la prova i què és el marc de proves JUnit, juntament amb exemples de casos de prova JUnit:

Aquesta sèrie de JUnit s’ha preparat per centrar-se en el nostre públic que és principiant absolut, així com en aquells que tenen un bon coneixement de Java o JUnit amb un gran interès per aprendre JUnit.

La sèrie s'ha presentat en la seva totalitat de manera que podreu interpretar la diferència entre JUnit 4 i Junit 5.

Comencem ara a explorar JUnit !!

Tutorial JUnit

Què aprendreu:

preguntes d’entrevistes sobre sabó i descans

Llista de tutorials d'aquesta sèrie JUnit

Tutorial # 1: Tutorial JUnit per a principiants: què és la prova JUnit? (Aquest tutorial)
Tutorial # 2: Descarregueu, instal·leu i configureu JUnit a Eclipse
Tutorial # 3: Proves JUnit: Com escriure casos de prova JUnit amb exemples
Tutorial # 4: Què és un dispositiu de prova de JUnit: tutorial amb exemples de JUnit 4
Tutorial # 5: Múltiples maneres d'executar proves JUnit
Tutorial # 6: Llista d’anotacions de JUnit: JUnit 4 Vs JUnit 5
Tutorial # 7: JUnit Ignora el cas de prova: JUnit 4 @Ignore Vs JUnit 5 @Disabled
Tutorial # 8: JUnit Test Suite i filtratge de casos de prova: JUnit 4 contra JUnit 5
Tutorial # 9: Ordre d'execució de la prova JUnit: Ordre de proves JUnit 4 Vs JUnit 5
Tutorial # 10: Com s'utilitza JUnit 5 Annotation @RepeatedTest amb exemples
Tutorial # 11: JUnit 5 Classe imbricada: @ Tutorial imbricat amb exemples
Tutorial # 12: Nom visualitzat personalitzat de JUnit 5 i execució de la prova condicional
Tutorial # 13: JUnit Vs TestNG: quines diferències hi ha?

Tutorial JUnit

En un enfocament típic de desenvolupament basat en proves (TDD), els desenvolupadors se centren en provar unitats cada fragment del codi que desenvolupen. Com més bones siguin les proves d’un producte, millor serà la seva qualitat. Tots sabem que les proves haurien d’anar paral·lelament a cada fase que passa del cicle de vida del desenvolupament de programari.

Començant des dels requisits i anàlisis fins al disseny i desenvolupament fins al manteniment, cada fase hauria de tenir associada una fase de proves adequada. La prova d’unitat després del desenvolupament és el que és aconsellable per construir una aplicació robusta i tenir un codi optimitzat.

Què és la prova unitària?

La prova d’unitat consisteix a provar una petita lògica o un codi per verificar que la sortida del codi és l’esperada en l’entrada d’unes dades específiques i / o en el compliment de determinades condicions. Normalment, les proves unitàries se suposa que són independents de les altres proves.

Les proves unitàries no són factibles per provar interfícies complexes amb una altra aplicació o serveis externs o de tercers. Una prova unitària només s'orienta a una petita unitat de codi que pot ser només un mètode o una classe.

Ajuda al desenvolupador a descobrir problemes de la lògica actual i qualsevol fallada de regressió a causa del canvi actual. A més, també proporciona informació sobre com el codi actual pot afectar la implementació futura.

Proves unitàries

Cobertura de la prova

Es diu el percentatge de codi que es prova mitjançant proves unitàries cobertura de la prova .

L’objectiu és tenir una millor i més cobertura de proves del codi, que en el futur continua sumant-se al conjunt de proves de regressió i ajuda a augmentar l’execució i la verificació automatitzades de les proves, reduint així l’esforç manual implicat en les proves de regressió.

Executar proves automàticament ajuda a identificar problemes de regressió del programari introduïts pels canvis en el codi actual. Tenir una cobertura elevada de proves del vostre codi us permet continuar desenvolupant funcions sense haver de realitzar moltes proves manuals.

Molts vénen amb una pregunta sobre quina cobertura de prova és essencial . La resposta a aquesta pregunta és que no hi ha una regla dura i ràpida quant a la cobertura de les proves és essencial; tot és criteri. El judici millora amb l'experiència en el flux de treball de l'aplicació i el coneixement històric dels defectes trobats fins ara.

Les proves eficients no necessàriament han de significar tenir un 100% de cobertura de proves o incorporar proves d'automatització i / o proves unitàries per a cada cobertura de ramal o camí.

No cal incloure a la suite de regressió certes verificacions trivials, com ara un missatge d'error de validació per a un camp obligatori que es deixa en blanc i que no presenta defectes des de fa anys.

Proves manuals contra proves automàtiques

La prova unitària es pot fer mitjançant dos enfocaments:

com obrir un objecte flash d’ona de xoc
  1. Proves manuals
  2. Proves automatitzades

Enfocaments de proves de JUnit

En ambdós enfocaments, el flux de treball continua sent comú:

  1. Creació d’un cas de prova
  2. Revisant-ho
  3. Torneu a treballar si calen correccions
  4. Executeu el cas de prova
  5. Analitzeu els resultats de les proves

Les proves automàtiques es prefereixen a les proves manuals pels motius següents:

Proves manualsProves automatitzades
Quan una caixa de proves s’executa manualment sense la intervenció d’una eina, s’anomena prova manual.Quan s’executa una caixa de proves amb l’ajut d’una eina sense molta intervenció manual, s’anomena prova automatitzada.
S'inclouen esforços manuals repetitius.Es poden evitar esforços manuals repetitius.
Els esforços humans en proves manuals poden ser errònies i requereixen molt de temps.Les proves d'automatització són més ràpides i exemptes d'errors en comparació amb els esforços manuals.
Els recursos de prova necessaris són més per executar totes les proves de manera manual, cosa que augmenta la inversió en recursos.Es necessiten menys provadors per executar proves automatitzades mitjançant les eines automatitzades designades, de manera que hi ha menys inversió en provar recursos, cosa que augmenta la rendibilitat.
Les proves manuals s'han de limitar a una petita cobertura de proves tenint en compte les restriccions de la cronologia. Per tant, hi ha el risc de saltar-se molts escenaris de prova, donant lloc a risc de fugides de defectes també.Es poden automatitzar molts escenaris de proves diferents i es poden executar diverses vegades fins i tot amb crisi de temps i recursos, de manera que es pot obtenir una millor cobertura de proves i una millor qualitat del lliurament.

Marc de proves unitàries

Podríem tenir la següent pregunta sobre com és un cas típic de prova d’unitat d’automatització i el marc que segueix. Els desenvolupadors utilitzen el fitxer Marc de proves unitàries per a la creació de casos de proves unitaris automatitzats.

  1. Per tal de verificar si el codi funciona lògicament com s'esperava, es crea un testcase amb un punt de control específic o un criteri de verificació.
  2. Quan s’executa la prova, el criteri / condició passa o falla.
  3. Es genera un registre segons el flux de treball de la prova.
  4. El marc informarà d’un resultat resumit sobre els casos de prova superats i els fallits.
  5. Segons la gravetat de l’error, és possible que la prova no continuï més i pugui aturar l’execució posterior.
  6. Pot haver-hi certs errors greus baixos que s’informin al registre, tot i que no mostra una parada dura, però continua sense bloquejar els passos de prova posteriors.

Què és JUnit?

JUnit és un marc de codi obert que s’utilitza per escriure i executar proves d’unitat en llenguatge de programació Java. És un dels marcs de proves unitàries més coneguts.

La imatge següent mostra les diferents eines de prova d’unitats d’automatització conegudes.

Junit

A continuació es detallen els atributs amb els quals JUnit està empaquetat:

  • Hi ha una enorme llista d'anotacions per identificar, executar i donar suport a moltes funcions dels mètodes de prova.
  • Hi ha afirmacions per verificar els resultats esperats.
  • Proporciona Test Runner per executar les proves.
  • JUnit proporciona una plantilla incorporada bàsica perquè pugueu escriure casos de prova petits i senzills en poc temps.
  • Les proves de JUnit us ajuden a escriure mòduls independents, millorant així la cobertura de la prova i la qualitat de l’aplicació.
  • No només permet crear i executar fàcilment proves, sinó que també presenta al desenvolupador un informe clar i clar que elimina la necessitat que el desenvolupador cerqui la ruta dels informes i els resultats de les proves.
  • Fins que l'execució de la prova no es mogui, podeu relaxar-vos veient a la barra de progrés de la prova de color verd que es mostra mentre s'està executant mentre que us avisa en 'vermell' tan aviat com la prova falla en un punt de verificació de verificació.
  • Es poden crear suites de proves per reunir una seqüència o un conjunt de casos relacionats.

Exemples de JUnit Testcase

A continuació es detallen els dos exemples d’un programa Hello World molt bàsic per obtenir una comprensió de l’aspecte d’una classe de prova JUnit o de la seva diferència en comparació amb un fitxer de classe Java habitual.

Exemple 1:

Aquí hi ha una prova de JUnit HelloWorldJUnit.java que verifica que la cadena 'Hello world' coincideixi amb la cadena 'hello world' que falla en l'execució, ja que la coincidència distingeix entre majúscules i minúscules. Per tant, les dues cordes no coincideixen i la prova falla .

El codi de HelloWorldJUnit.java

package demo.tests; import static org.junit.Assert.*; import org.junit.Test; public class HelloWorldJUnit { @Test public void test() { assertEquals('Hello world','hello world'); } }

Exemple 2:

Aquí, veurem com és habitual Java fitxer de classe interactua amb una JUnit caixa de proves. Creem un Java fitxer de classe HelloWorld_Java.java amb un constructor que ens permet passar un valor de cadena i un mètode getText () per obtenir el valor de la cadena.

JUnit Prova de classe HelloWorldJUnit.java es crea de manera que es crea l'objecte de classe per HelloWorld_Java i el valor de cadena real es passa a l'objecte. L'assertEquals () de JUnit verifica si coincideixen els valors de cadena esperats i reals.

El codi de HelloWorld_Java.java

package demo.tests; import static org.junit.Assert.*; import org.junit.Test; public class HelloWorldJUnit { @Test public void test() { assertEquals('Hello world','hello world'); } }

El codi de HelloWorldJUnit.java

package demo.tests; public class HelloWorldJUnit{ private String s; public HelloWorld_Java(String s) { @Test public void test() { HelloWorld_Java hw=new HelloWorld_Java('Hello World'); assertEquals(hw.getText(),'Hello World'); } }

El resultat es veu com a sota on veiem les dues cordes coincidents. Per tant, la prova de JUnit és passat.

Exemple bàsic2

Conclusió

A l’hora de proporcionar-vos una visió general ràpida de què és i què fa JUnit, JUnit és un marc bellament elaborat que us permet crear i executar proves unitàries de manera automatitzada.

És una eina de codi obert però tan senzilla. Ja sigui la creació de casos de prova o l'execució d'una caixa de proves o l'informe després de l'execució o el manteniment de les proves, JUnit és elegant en tots els aspectes. Sí, també pot fallar elegantment; i veurem com passa això al nostre proper tutorial a mesura que avancem.

Sobre l'autor: Aquest tutorial ha estat escrit perShobhaD. Treballa com a cap de projecte i compta amb més de 9 anys d’experiència en proves manuals, d’automatització i API.

jugar a wow de servidor privat gratuït

Continuem il·luminant més profundament tots els aspectes de JUNIT aquí.

NEXT Tutorial

Lectura recomanada

^