Flere måter å utføre JUnit-tester på

multiple ways execute junit tests

Denne veiledningen viser flere måter å utføre JUnit-tester på, for eksempel å kjøre som en JUnit-test, bruke hurtigtaster eller kjøre JUnit-test fra kommandolinjen, etc:

Vi så hvordan du skriver de grunnleggende JUnit-testtilfellene og har en testinnretningstilnærming som en av de gode programmeringsrutinene for JUnit i vår forrige opplæring.

I denne veiledningen, la oss se på de forskjellige måtene vi kan bruke til å utføre tester for JUnit. Du vil bli overrasket over å se på antall tilgjengelige alternativer for å kjøre disse testtilfellene.

=> Se opp The Simple JUnit Training Series her.

Hva du vil lære:

• Ulike måter å utføre JUnit-tester på
  • # 1) Kjør som JUnit Test
  • # 2) Kjør sist utførte JUnit-test via menyalternativet
  • # 3) Kjør ved hjelp av hurtigtaster
  • # 4) Kjør bare en testmetode i en klasse
  • # 5) Kjør JUnit-tester fra kommandolinjen
  • # 6) Kjør Test Suite ved hjelp av Testrunner Class
  • # 7) Kjør JUnit-testtilfeller ved bruk av Maven
• Konklusjon
• Anbefalt lesing

Ulike måter å utføre JUnit-tester på

For å utføre JUnit-tester er det visse måter du kan kjøre en enkelt klassefil med en eller flere testmetoder på gjennom følgende alternativer:

1. 'Kjør som JUnit-test'.
2. Kjør sist utførte JUnit-test gjennom menyalternativet.
3. Kjør ved hjelp av hurtigtaster.
4. Kjør bare en testmetode i en klasse.
5. Kjør gjennom kommandolinjen.
6. Kjør med Testrunner-klassefilen.
7. Kjør også gjennom Maven.

Merk: JUnit-testutførelsen gjennom Maven vil bli vurdert i en egen opplæring for JUnit Maven.

Gjentar poenget, i denne opplæringen vil vi lære hvordan flere tester kan grupperes sammen i en testpakke, og hvordan kan man kjøre suiten på forskjellige måter. Dessuten skal den detaljere relevant og relatert tilleggsinformasjon.

# 1) Kjør som JUnit Test

Den enkleste måten du kan utføre JUnit-testene på er:

Metode 1:

1. Høyreklikk på klassefilen i skriptvisningen
2. Å velge Kjør som -> JUnit Test
3. Klassefilen kjøres.

Metode 2:

1. På samme måte kan du velge klassefilen fra Package Explorer-visningen
2. Høyreklikk på filen
3. Å velge Kjør som -> JUnit Test
4. Klassefilen kjøres.

Merk: På denne måten kan du utføre en klassefil om gangen.

# 2) Kjør sist utførte JUnit-test via menyalternativet

Du kan kjøre en JUnit-klassefil ved å holde en klassefil åpen i redigeringsprogrammet. Gå til toppmenyen på Formørkelse => Velg Kjør => Kjør . Valget Løp -> Løp betyr i utgangspunktet kjøre testen som du kjørte sist.

La oss vurdere en JUnit-klasse med flere metoder / tester for bedre klarhet i hvordan Løp-> Løp virker:

• Scenario 1 : Hvis du hadde kjørt en enkelt metode med @ Test, og deretter når du klikker Løp-> Løp , den eneste metoden som kjørte sist, ville bare kjøre denne gangen og ikke hele JUnit-klassen.
• Scenario 2 :Mens du hadde kjørt hele klassen tidligere, Løp-> Løp vil kjøre hele klassefilen på nytt.

Nå som vi vet at Run-> Run kjører testen du kjørte sist, fører dette oss til en spørsmål hvis du kan endre innstillingen til alternativet Run-> Run?

Svaret på spørsmålet er Ja, preferansen til alternativet Kjør-> Kjør kan endres. Det er en viss konfigurasjon knyttet til Run-> Run.

Slik kan du gjøre det:

til) Eclipse's kjøreinnstilling er i utgangspunktet som standard kjør den valgte ressursen eller den aktive redigereren hvis den kan startes .

Så hva gjør standardinnstillingen - 'Kjør den valgte ressursen eller den aktive redigereren hvis den kan startes'?

Svaret på dette er at det ikke vil kjøre applikasjonen du lanserte sist, men snarere vil følge kjøringen av den sist lanserte applikasjonen for den aktive redaktøren .

b) Så hvordan endrer du standardinnstillingen?

Svaret på dette er at du kan endre standardinnstillingen i Eclipse for å kjøre det siste programmet du startet uavhengig av aktiv redaktør du har.

Nedenfor ser du hvordan du endrer innstillingen for Kjør-alternativet ved hjelp av Kjør -> Kjør:

• Navigere til Windows => Innstillinger => Kjør / feilsøking => Lansering
• 'Launch Operation' har en standard radioknapp - ' Start den tidligere lanserte applikasjonen ’ valgt under det andre alternativet ‘ Start den valgte ressursen eller den aktive redaktøren. Hvis ikke startbar : ’.
• Du må kanskje endre denne innstillingen til den første alternativknappen, dvs. ' Start alltid den tidligere lanserte applikasjonen ’.

# 3) Kjør ved hjelp av hurtigtaster

Du kan velge klassefilen fra skriptvisningen eller pakkeutforskeren, og bruke snarveitastene nedenfor til å utføre JUnit-testene:

1. Trykk på tastene ALT + SKIFT + X, T for å kjøre JUnit-klassefilen.
2. Et alternativ til dette ville være press ALT + R deretter CTRL + F11 for å utføre en JUnit-klassefil. ALT + R deretter CTRL + F11 er snarveien for menyalternativet Løp -> Løp

# 4) Kjør bare en testmetode i en klasse

Noen ganger kan det være lurt å kjøre en enkelt JUnit-testmetode.

I tilfelle det er mer enn én metode inne i JUnit-klassefilen:

1. Du kan velge eller plassere markøren på metodens navn i skriptvisningen.
2. Bruk enten hurtigtaster nevnt ovenfor eller alternativene som er gitt ovenfor for å utføre bare metoden du nettopp valgte.

Merk: ALT + SHIFT + X, T kan kjøre utvalgte metoder som forventet. Imidlertid, hvis du ønsker å kjøre en bestemt metode i en JUnit-klasse, må den være en testcase merket med @Test ellers viser den initialiseringsfeil.

Med andre ord, hvis du velger metoder under @Before eller @After (annen merknad enn @Test), vil den spesifikke metodeutførelsen feile.

# 5) Kjør JUnit-tester fra kommandolinjen

Som du kjører Java-klassefiler via kommandolinjen, kan du også kompilere og kjøre JUnit-klassefiler via kommandolinjen.

Vi vil dekke nedenstående underemner her for å få en forståelse av hvordan vi kan kjøre JUnit-tester gjennom kommandolinjen:

1. Hvordan lage en JUnit-test i kommandolinjen?
2. Hvordan kjøre en JUnit-test på kommandolinjen?
3. Tilleggsinformasjon om kommandolinjekjøring.
   • Hvordan fikser jeg ukjent kommandofeil for javac-kommando?
   • Fordeler med å kjøre tester ved hjelp av kommandolinjen.

# 5.1) Hvordan lage en JUnit-test på kommandolinjen?

Forutsetningen for å kompilere og kjøre en JUnit-klassefil via ledeteksten er:

1. Legg først til relevante JUnit jar-filer i klassestien.
2. Sett miljøvariablene slik det ble nevnt i Oppsett av JUnit opplæringen.
3. Så kompilerer du en JUnit-klassefil.
4. Syntaksen for å kompilere en JUnit-klassefil gjennom kommandolinjen er:

Her er javac Java-kompilatoren som bruker -cp-alternativet.

Kommandoen javac -cp ser etter følgende parametere:

1. JUnit jar-filen etterfølges av semikolon.
2. Banen til katalogen der kildefilen finnes.
3. Klassens filnavn

I den ovennevnte syntaksen, hva innebærer prikken (.)?

Vi har nevnt en prikk i stedet for hele banen til katalogen.

Prikken antyder at:

1. Klassestien inkluderer allerede den nåværende katalogen for Java-kildefilene.
2. JVM (Java Virtual Machine) antar automatisk at den aktuelle katalogen er der kildefilene er plassert.
3. JVM søker deretter etter det nevnte JUnit-filnavnet der. Filnavnet er den siste parameteren som er gitt i kompileringskommandoen.

Du kan sjekke parametrene som går inn i -cp gjennom følgende trinn:

1. Åpne ledeteksten.
2. Skriv javac og trykk ENTER.
3. Alle relevante alternativer dukker opp inkludert -cp. Du vil finne at -cp går med som en parameter der banen er klassefilen banen som JVM søker etter.

Skjermbilde nedenfor:

Hvordan kompilere flere filer samtidig?

Flere JUnit-testfiler kan kompileres samtidig ved å skille filnavnene med mellomrom.

Nedenfor er et eksempel på hvor du kompilerer Java-filer JUnitProgram og demoTest:

# 5.2) Hvordan kjøre en JUnit-test fra kommandolinjen?

Akkurat som javac brukes Java-kompilatoren på samme måte java -cp brukes til å kjøre Java-klassefiler inkludert JUnit-klassene.

Nedenfor er syntaksen du kan følge:

Denne kommandoen kjører både filene JUnitProgram.java og demoTest.java etter hverandre.

# 5.3) Tilleggsinformasjon om 'kommandolinjekjøring'.

den beste gratis youtube til mp3-omformeren

Her er litt tilleggsinformasjon om hvordan du løser en feil med javac-kommandoen og hvorfor bruke alternativet kommandolinjekjøring

# 5.3.1) Hvordan løser jeg den ukjente kommandofeilen for javac-kommandoen?

De fleste av oss vil møte dette problemet mens vi prøver å utføre javac kommando gjennom kommandolinjen. Dette har skjedd med meg også; så vi tenkte å pinne den her.

til) Vi kom inn i kommandoen javac og presset Tast inn på ledeteksten.

b) Feilmeldingen - javac gjenkjennes ikke som en intern eller ekstern kommando, et operativt program eller en batchfil dukket opp som nedenfor:

Dette er hvor kompilering av Java-klassefilene fra kommandolinjen begynner. Derfor er feilen faktisk bekymringsfull og kan ikke ignoreres.

Følg trinnene nedenfor for å løse problemet Her er!!! du ser feilen er borte:

• La oss demonstrere denne prosessen ved hjelp av en grunnleggende Java-fil. Det første trinnet du kan gjøre er å lage en grunnleggende Java-klasse F.eks. : “Kalkulator.java”
• Vi skal finne Calculate.java fra Windows Utforsker og kopiere banen.

• Endre katalogen i ledeteksten til banen du kopierte (kildefilbanen). Bruk cd for å endre katalogen.

• Still nå PATH til jdk bin-mappen ved hjelp av kommandoen.

SET PATH = og trykk ENTER.

• Her er jdk-banen C: Program Files Java jdk1.8.0_181 bin. Derfor har vi satt veien tilsvarende. Resultatet viser ingenting ved å trykke ENTER etter kommandoen.

• Kontroller nå om JVM gjenkjenner kommandoen javac ved å skrive inn kommandoen javac og trykke ENTER.

1. 1. Hvis den kjenner igjen kommandoen, vises et sett med gyldige alternativer for javac som resultat.
   2. Ellers vises feilen igjen.

Nedenfor er et skjermbilde som viser at vi med hell ble kvitt feilen.

La oss ikke prøve å unngå et essensielt spørsmål her:

Hvorfor gjenkjente JVM javac-kommandoen etter å ha satt banen til jdk bin-mappen?

Vi er sikre på at du også vil ha dette spørsmålet. Nedenfor er svaret.

• Jdk bin-mappen har alle biblioteker for javac-kommandoen. Derfor er JVM nå når du angir banen tilsvarende, i stand til å gjenkjenne javac-kommandoen uten problemer.
• Se javac-mappen under jdk-søpla i bildet nedenfor.

• Deretter kan du kjøre kommandoen 'Java compile and run' ved hjelp av kommandolinjen. Husk dessuten å stille inn CLASSPATH-variabelen riktig. JAVA_HOME og JUNIT_HOME-variabler for henholdsvis Java-filer og JUnit-filer.

# 5.3.2) Fordelen ved å kjøre tester ved hjelp av kommandolinjen:

La oss raskt diskutere fordelen over å kjøre Java / JUnit-testkasser via kommandolinjen.

Som du allerede er klar over, er det ingen hard og rask regel om at kjøringen av klassefilene skal være gjennom kommandolinjen. Det er bare en alternativ måte, hvordan du kan administrere kompilering og utføring av klassefilene.

Hvis du spør om det er en spesiell fordel med å ha kunnskap om utførelsen av JUnit-testene via kommandolinjen, vil vi si 'Sikkert, Ja'.

Årsaken til et 'ja' er gitt nedenfor:

1. Alle disse trinnene vi fulgte ovenfor; kan legges til notisblokk og konverteres til en batchfil.
2. Nå, når du kjører denne batchfilen med et dobbeltklikk, kan den utløse kompilering og kjøring av flere JUnit-testfiler med navn i batchfilen.

Hva er fordelen med å ha en batchfil som kompilerer og utfører Java-filene?

1. En batch / jar-fil kan fungere som et brukervennlig verktøy som kan gjøre det mulig for alle som ikke er klar over den interne logikken i koden, og utfører flere testtilfeller veldig enkelt.
2. Dette kan eliminere behovet for å ha en spesialutvikler eller kvalitetssikring for å utføre disse testutførelsesjobbene. Utførelsesoppgaven kan delegeres til hvilken som helst ressurs uten å bry seg om ferdighetsbegrensninger.

I det neste alternative alternativet vil vi se en annen fordelaktig og prisverdig måte å utføre JUnit-testsakene på.

# 6) Kjør Test Suite ved hjelp av Testrunner Class

I sanntidsscenarier er det minst foretrukne alternativet å utføre en testcase om gangen.

• Vi har tilfeller der vi trenger å kjøre en gruppe relaterte / ikke-relaterte testsaker.
• For eksempel kan det hende vi trenger å opprette og utføre regresjonstestesuiter eller røykforsyningssuiter.

Vi vil nå lære om implementeringen av forskjellige merknader som brukes til å lage testsuiter og utføre suiten.

Den samlede prosessen med å utføre testpakken ved hjelp av Test Runner er i henhold til arbeidsflyten nedenfor:

1. Opprett JUnit klasse 1, JUnit klasse 2,…. JUnit klasse n.
2. Opprett en testfilklassefil som grupperer testtilfellene.
3. Opprett en Testrunner-klassefil for å påkalle Test Suite som er opprettet.
4. Utfør Testrunner-klassen.

Strukturen til programmene som vi skal demonstrere etableringen av testpakke og utførelse av løpefilen, vises i bildet nedenfor:

Her vil vi dekke underemnene:

1. Opprette JUnit-klasser
2. Opprette testsuiter
3. Opprette en Testrunner-fil og utføre testpakker ved hjelp av den.
4. Tilleggsinformasjon om hvordan @RunWith-merknaden fungerer.

# 6.1) Opprette JUnit-klasser

La oss starte med å lage to enkle JUnit-klassefiler:

1. JUnitTestCase1.java - Den inkluderer koden for å verifisere en forventet numerisk verdi - variabelen Verdi1 samsvarer med en faktisk verdi av variabelen Verdi2.
2. JUnitTestCase2.java - Inkluderer koden for å verifisere om den forventede strengvariabelen strValue og faktisk strengvariabel strActual fyrstikker.

Dette er i utgangspunktet to testtilfeller som vi vil prøve å komme inn i en logisk gruppering kalt testpakke og få den til å kjøre den ene etter den andre.

Kode for JUnitTestCase1.java

Kode for JUnitTestCase2.java

# 6.2) Opprette Test Suite:

Denne delen og neste seksjon spiller en fremtredende rolle i hele prosessen med å lage og kjøre en testpakke. I denne delen vil vi prøve å forstå hvordan du kan gruppere flere JUnit-testklasser og binde dem til en testpakke .

I henhold til det strukturelle bildet ovenfor, la oss lage en testpakke som grupperer JUnitTestCase1.java og JUnitTestCase2.java og kaller suiten som JUnitTestSuite.java

De to kommentarene som hjelper oss med å opprette en testpakke er:

1. @RunWith og
2. @SuiteClasses

Pakker som trengs for merknadene:

1. Du må importere pakken org.junit.runner.RunWith; for inkludering av @RunWith-kommentar.
2. Du trenger pakken org.junit.runners.Suite.SuiteClasses for at @SuiteClasses skal fungere.
3. Dessuten må du også importere pakken org.junit.runners.Suite for å sende en parameter Suite.class til merknaden @RunWith.

La oss se på koden for bedre forståelse !!

Kode for JUnitTestSuite.java

Forståelse av koden for JUnitTestSuite.java:

1. @RunWith hjelper JVM til å forstå hva slags løpeklasse den skal kjøre F.eks. Suite.klasse eller Agurk.klasse
2. Her er parameteren til @RunWith Suite.klasse . Det hjelper JVM å gjenkjenne at den nåværende filen der @RunWith (Suite.class) brukes, spiller en rolle i Test Suite.
3. JUnit-testklassenavnene som skal bindes sammen i en suite, må sendes som en strengmatrise i form av parametere for @SuiteClasses hver skilt med komma.
4. Dette gjør det mulig for JVM å vite hvilke testcases som må grupperes under suiten.
5. Suitenavnet vil være JUnit-klassens filnavn som er merket med @RunWith og @SuiteClasses som i dette tilfellet er JUnitTestSuite.

# 6.3) Opprett Test Runner-fil og kjør JUnit Test-pakke ved hjelp av Test Runner

Det siste trinnet vil hjelpe oss å kjøre testpakken som vi nettopp opprettet i avsnittet ovenfor ved hjelp av en Testrunner-fil.

1. Vi oppretter nå en Java-fil som heter SuiteRunnerFile.
2. Denne SuiteRunnerFile.java er ikke en JUnit-klasse, men en vanlig Java-fil med hovedmetoden i den.

La oss se på koden og deretter prøve å forstå den.

Kode for SuiteRunnerFile.java

Pakker som trengs for merknaden

1. Du må importere pakken org.junit.runner.JunitCore for å inkludere JUnitCore klasse i koden.
2. Du må importere pakken org.junit.runner.notification.Failure og org.junit.runner. Resultat for å inkludere henholdsvis feil og resultatklasse i koden.

Forståelse av koden for SuiteRunnerFile.java

1. For å lage en løpefil for utførelsen av testpakken, JUnitCore klasse spiller en viktig rolle.
2. De runClasses () Metode av JUnitCore klasse tar test suite klassens navn som inndataparameter, derfor har vi utsagnet JUnitCore. runClasses (JUnitTestSuite. klasse ).
3. Returtypen for denne uttalelsen er Resultat klasseobjekt som lagrer den resulterende suksessstatusen og feilstatusen til hver av testsaksdokumentene; etter gjennomføring. Dette er grunnen til at vi har en resultat som Resultat klasseobjekt i koden.
4. Deretter skriver vi ut feilene i testtilfellene, hvis noen. I likhet med getFailures () -metoden, kan du også få feilantall og Run count ved å bruke henholdsvis metoden getFailureCount () og getRunCount ().
5. Nå er SuiteRunnerFile klar til å kjøres,
   1. Velg filen fra Package Explorer og
   2. Høyreklikk og velg Kjør som -> Java, programmet kjøres.

Nedenfor er skjermbildet av konsollvinduet.

Forklaring av resultatene på konsollen:

Konsollen ovenfor viser at:

1. Klassefilen JUnitTestSuite har blitt kjørt gjennom SuiteRunnerFile.
2. PrintMe () -metoden under kommentar @BeforeClass ble utført først og
3. Deretter ble testsakene i testsuiten utført etter hverandre. Slik kan testpakken opprettes og kjøres som en pakke.

# 6.4) Tilleggsinformasjon - Hvordan fungerer @RunWith?

• @RunWith er et JUnit API som i utgangspunktet bare tar ett element som inndataparameter som er et filnavn for løpeklasse.
• JUnit framework påkaller den angitte klassen som testløper.

Utdraget nedenfor fra RunWith.java vil hjelpe deg med å få tak i:

Forstå ovennevnte RunWith-grensesnittkode:

1. Det angitte verdi elementet må være en avledet klasse av Løper klasse . Begrepet refleksjon brukes her.
2. Et veldig godt eksempel på en slik løperklasse er allerede implementert i koden vår, dvs. @ RunWith (Suite.class) hvor en gruppe testkasser er bundet sammen for å lage en testpakke.
3. Tilsvarende kan et annet godt eksempel på å bruke en Runner-klasse med @RunWith være @RunWith (Cucumber.class) som er et forretningsdrevet utviklingsrammeverk (BDD) for testautomatisering ved bruk av Selenium i Java. Dette hjelper rammeverket med å kjøre agurkbaserte testsaker.

Merk:

• Kommentarene og parametrene som ble brukt til å opprette og kjøre JUnit-testserien i denne opplæringen, var spesifikke for JUnit 4.
• Det er en litt annen måte å lage en JUnit Test Suite på og kjøre løpefilen i JUnit 5.

Vi vil ha en fokusert forståelse av alle aspektene av JUnit 4 vs JUnit 5 snart i våre kommende opplæringsprogrammer.

# 7) Kjør JUnit-testtilfeller ved bruk av Maven

Du kan også ha et Maven-prosjekt bestående av JUnit-tester på plass og kjøre testene gjennom Maven som vil bli dekket i en egen opplæring.

Konklusjon

1. Vi lærte alle de forskjellige alternativene for å kjøre JUnit-testene - enkelt tester så vel som flere som er gruppert i testserier.
2. Vi fikk ytterligere kunnskap om hvordan du oppdaterer innstillingen for alternativet Kjør, hvordan du løser javac-feil, og hvordan kan kommandolinjekjøring hjelpe oss.
3. Dessuten lærte vi også om hvordan @RunWith-kommentaren fungerer.

Derfor er det mer å følge i de kommende opplæringene. ‘Stand By’ til da !!!

=> Besøk her for å lære JUnit From Scratch.

Anbefalt lesing

• JUnit-tester: Hvordan skrive JUnit-testtilfeller med eksempler
• JUnit Tutorial for nybegynnere - Hva er JUnit-testing
• Hva er en JUnit-testarmatur: Veiledning med JUnit 4-eksempler
• Specflow Reporting: Slik genererer du testrapporter og utfører selektive tester
• Last ned, installer og konfigurer JUnit i formørkelse
• Introduksjon til JUnit Framework and Its Usage in Selenium Script - Selenium Tutorial # 11
• Lag appiumtester for en Android-app
• Sett inn flere dokumenter i MongoDB ved hjelp av arrays