Flera sätt att utföra JUnit-tester

multiple ways execute junit tests

Denna handledning visar flera sätt att utföra JUnit-tester som att köra som ett JUnit-test, använda genvägstangenter eller köra JUnit-test från kommandoraden, etc:

Vi såg hur man skriver de grundläggande JUnit-testfallen och har en testinriktningsmetod som en av de goda programmeringsmetoderna för JUnit i vår tidigare handledning.

I den här handledningen ska vi titta på de olika sätten vi kan använda för att utföra tester för JUnit. Du kommer att bli förvånad över att titta på antalet tillgängliga alternativ för att köra dessa testfall.

=> Se upp den enkla JUnit-träningsserien här.

Vad du kommer att lära dig:

• Olika sätt att utföra JUnit-tester
  • # 1) Kör som JUnit-test
  • # 2) Kör det senast utförda JUnit-testet via menyalternativet
  • # 3) Kör med kortkommandon
  • # 4) Kör bara en testmetod i en klass
  • # 5) Kör JUnit-tester från kommandoraden
  • # 6) Kör Test Suite med Testrunner Class
  • # 7) Kör JUnit-testfall med Maven
• Slutsats
• Rekommenderad läsning

Olika sätt att utföra JUnit-tester

För att utföra JUnit-tester finns det vissa sätt att köra en enda klassfil med en eller flera testmetoder genom följande alternativ:

1. Kör som JUnit-test.
2. Kör det senaste körda JUnit-testet genom menyalternativet.
3. Kör med kortkommandon.
4. Kör bara en testmetod i en klass.
5. Kör igenom kommandoraden.
6. Kör med Testrunner klassfil.
7. Kör även genom Maven.

Notera: JUnit-testkörningen genom Maven kommer att övervägas i en separat handledning för JUnit Maven.

När vi upprepar poängen kommer vi att lära oss hur flera tester kan grupperas i en testsvit och hur man kan köra sviten på olika sätt. Dessutom ska den innehålla detaljerad information om relevant och relaterad ytterligare information.

# 1) Kör som JUnit-test

Det enklaste sättet att utföra JUnit-testerna är:

Metod 1:

1. Högerklicka på klassfilen i skriptvyn
2. Välj Kör som -> JUnit Test
3. Klassfilen körs.

Metod 2:

1. På samma sätt kan du välja klassfilen från paketutforskarens vy
2. Högerklicka på filen
3. Välj Kör som -> JUnit Test
4. Klassfilen körs.

Notera: På så sätt kan du köra en klassfil åt gången.

# 2) Kör det senast utförda JUnit-testet via menyalternativet

Du kan köra en JUnit-klassfil genom att hålla en klassfil öppen i redigeraren. Gå till toppmenyn i Förmörkelse => Välj Kör => Kör . Alternativet Kör -> Kör betyder i grunden kör om testet som du körde sist.

Låt oss överväga en JUnit-klass med flera metoder / tester för bättre klarhet i hur Kör-> Kör Arbetar:

• Scenario 1 : Om du hade kört en enda metod med @Test och sedan när du klickar Kör-> Kör , den enda metoden som sprang sist skulle bara köras den här gången och inte hela JUnit-klassen.
• Scenario 2 :Medan hade du drivit hela klassen tidigare, Kör-> Kör skulle köra om hela klassfilen.

Nu när vi vet att Run-> Run kör testet som du körde sist, kommer detta till oss fråga om du kan ändra inställningen för alternativet Kör-> Kör?

Svaret på frågan är Ja, preferensen för alternativet Kör-> Kör kan ändras. Det finns en viss konfiguration kopplad till Run-> Run.

Så här kan du göra det:

till) Eclipses körinställning är i princip som kör den valda resursen eller den aktiva redigeraren om den kan startas .

Så, vad gör standardinställningen - 'Kör den valda resursen eller aktiva redigeraren om den kan startas' gör det?

Svaret på detta är att det inte kommer att köra programmet som du startade senast, utan det kommer att följa omprogrammet för den senast lanserade applikationen för den aktiva redaktören .

b) Hur ändrar du sedan standardinställningen?

Svaret på detta är att du kan ändra standardinställningen i Eclipse för att köra den senaste applikationen du startade oavsett den aktiva redaktören du har.

Nedan följer hur du ändrar preferensen för alternativet Kör med Kör -> Kör:

• Navigera till Windows => Inställningar => Kör / felsöka => Startar
• 'Startoperation' har en standardknapp - '' Starta den tidigare lanserade applikationen ” vald under det andra alternativet ” Starta vald resurs eller aktiv redigerare. Om inte startbar : ’.
• Du kan behöva ändra denna inställning till den första alternativknappen, dvs. '' Starta alltid den tidigare lanserade applikationen ”.

# 3) Kör med kortkommandon

Du kan välja klassfilen från skriptvyn eller Package Explorer-vyn och använda nedanstående kortkommandon för att utföra JUnit-testerna:

1. Tryck på knapparna ALT + SKIFT + X, T för att köra JUnit-klassfilen.
2. Ett alternativ till detta skulle vara press ALT + R sedan CTRL + F11 för att köra en JUnit-klassfil. ALT + R sedan CTRL + F11 är genvägen för menyalternativet Kör -> Kör

# 4) Kör bara en testmetod i en klass

Ibland kanske du vill köra en enda JUnit-testmetod.

Om det finns mer än en metod inuti JUnit-klassfilen:

1. Du kan välja eller placera markören på metodens namn i manusvyn.
2. Använd antingen genvägar som nämns ovan eller alternativen ovan för att bara utföra den metod du just valt.

Notera: ALT + SKIFT + X, T kan köra valda metoder som förväntat. Men om du vill köra en specifik metod i en JUnit-klass, måste den vara en testcase kommenterad med @Test, annars visas initialiseringsfel.

Med andra ord, om du väljer metoder under @Before eller @After (någon annotering förutom @Test), skulle den specifika metodkörningen fel.

# 5) Kör JUnit-tester från kommandoraden

Precis som om du kör Java-klassfiler via kommandoraden kan du också kompilera och köra JUnit-klassfiler via kommandoraden.

Vi kommer att täcka nedanstående underämnen här för att få en förståelse för hur vi kan köra JUnit-tester genom kommandoraden:

1. Hur sammanställer jag ett JUnit-test på kommandoraden?
2. Hur kör jag ett JUnit-test på kommandoraden?
3. Ytterligare information om kommandoradsutförande.
   • Hur fixar jag okänt kommandofel för javac-kommando?
   • Fördelar med att köra tester med kommandoraden.

# 5.1) Hur sammanställer jag ett JUnit-test på kommandoraden?

Förutsättningen för att kompilera och köra en JUnit-klassfil via kommandotolken är:

1. Lägg först till relevanta JUnit jar-filer i klassvägen.
2. Ställ in miljövariablerna som de nämndes i Inställning av JUnit handledning.
3. Kompilera sedan en JUnit-klassfil.
4. Syntaxen för att kompilera en JUnit-klassfil via kommandoraden är:

Här är javac Java-kompilatorn som använder -cp-alternativet.

Kommandot javac -cp letar efter följande parametrar:

1. JUnit jar-filen följs av ett semikolon.
2. Sökvägen till katalogen där källfilen finns.
3. Klassens filnamn

I ovanstående syntax, vad innebär punkten (.)?

Vi har nämnt en punkt i stället för katalogens hela sökväg.

Pricken antyder att:

1. Klassvägen innehåller redan den aktuella katalogen för Java-källfilerna.
2. JVM (Java Virtual Machine) antar automatiskt att den aktuella katalogen är där källfilerna placeras.
3. JVM söker sedan efter det nämnda JUnit-filnamnet där. Filnamnet är den sista parametern som ges i kompileringskommandot.

Du kan kontrollera parametrarna som går in i -cp genom följande steg:

1. Öppna kommandotolken.
2. Skriv javac och tryck på ENTER.
3. Alla relevanta alternativ dyker upp inklusive -cp. Du kommer att upptäcka att -cp går med som en parameter där sökvägen är klassfilsökvägen som JVM söker efter.

Skärmdump nedan:

Hur kompilerar du flera filer samtidigt?

Flera JUnit-testfiler kan kompileras samtidigt genom att filnamnen separeras med mellanslag.

Nedan ges ett exempel på var du kompilerar java-filer JUnitProgram och demoTest:

# 5.2) Hur kör jag ett JUnit-test från kommandoraden?

Precis som javac används Java-kompilatorn på samma sätt java -cp används för att köra Java-klassfiler inklusive JUnit-klasserna.

Nedan är syntaxen som du kan följa:

Detta kommando kör både filerna JUnitProgram.java och demoTest.java efter varandra.

# 5.3) Ytterligare information om ”exekvering av kommandoraden”.

bästa YouTube-nedladdaren för pc

Här är ytterligare information om hur man åtgärdar ett fel med javac-kommandot och varför använda alternativet för kommandorads körning

# 5.3.1) Hur fixar jag det okända kommandofelet för javac-kommandot?

De flesta av oss skulle stöta på det här problemet när vi försökte köra javac kommando genom kommandoraden. Detta har hänt mig också; så vi tänkte på att penna det här.

till) Vi kom in i kommandot javac och tryckte på Stiga på på kommandotolken.

b) Felmeddelandet - javac känns inte igen som ett internt eller externt kommando, operativt program eller batchfil dök upp som nedan:

Det är här din kompilering av Java-klassfiler från kommandoraden börjar. Följaktligen är felet verkligen ett bekymmer och kan inte ignoreras.

Följ stegen nedan för att åtgärda problemet Här är!!! du ser att felet är borta:

• Låt oss demonstrera den här processen med en grundläggande Java-fil. Det första steget du kan göra är att skapa en grundläggande Java-klass T.ex. : “Calculator.java”
• Vi hittar Calculate.java från Windows Explorer och kopierar sökvägen.

• Ändra katalogen i kommandotolken till den sökväg du kopierade (källfilens sökväg). Använd cd för att ändra katalog.

• Ställ nu PATH till mappen jdk bin med kommandot.

SET PATH = och tryck på ENTER.

• Här är jdk-sökvägen C: Program Files Java jdk1.8.0_181 bin. Därför har vi satt vägen därefter. Resultatet visar ingenting när du trycker på ENTER efter kommandot.

• Kontrollera nu om JVM känner igen kommandot javac genom att ange kommandot javac och trycka på ENTER.

1. 1. Om den känner igen kommandot visas en uppsättning giltiga alternativ för javac som resultatet.
   2. Annars visas felet igen.

Nedan visas en skärmdump som visar att vi lyckades bli av med felet.

Låt oss inte försöka undgå en väsentlig fråga här:

Varför kände JVM igen javac-kommandot efter att ha ställt in sökvägen till mappen jdk bin?

Vi är säkra på att du också kommer att ha den här frågan. Nedan är svaret.

• Jdk bin-mappen har alla bibliotek för javac-kommandot. Därför är det därför som JVM nu kan känna igen javac-kommandot utan problem när du ställer in sökvägen därefter.
• Se javac-mapp under jdk-facket i bilden nedan.

• Du kan sedan köra kommandot ”Java compile and run” med kommandoraden. Kom också ihåg att ställa in CLASSPATH-variabeln på lämpligt sätt. JAVA_HOME- och JUNIT_HOME-variabler för Java-filer respektive JUnit-filer.

# 5.3.2) Fördelen med att köra tester med kommandoraden:

Låt oss snabbt diskutera fördelen över att köra Java / JUnit-testcases via kommandoraden.

Som du redan är medveten om finns det ingen hård och snabb regel om exekvering av klassfilerna via kommandoraden. Det är bara ett alternativt sätt på hur du kan hantera sammanställning och körning av klassfilerna.

Om du frågar om det finns en särskild fördel med att ha kunskap om genomförandet av JUnit-testerna via kommandoraden, skulle vi säga ”Visst, ja”.

Anledningen till ett ”ja” ges nedan:

1. Alla dessa steg som vi följde ovan; kan läggas till i anteckningar och konverteras till en batchfil.
2. När du nu kör den här batchfilen med ett dubbelklick kan den utlösa kompilering och körning av flera JUnit-testfiler med namnet i batchfilen.

Vad är fördelen med att ha en batchfil som kompilerar och utför Java-filer?

1. En batch / jar-fil kan fungera som ett användarvänligt verktyg som kan göra det möjligt för alla som inte är medvetna om den interna logiken i koden och utföra flera testfall mycket enkelt.
2. Detta kan eliminera behovet av att ha en specialutvecklare eller QA för att utföra dessa testkörningsjobb. Körningsuppgiften kan delegeras till vilken resurs som helst utan att bry sig om kompetensbegränsningar.

I nästa alternativalternativ ser vi ett annat fördelaktigt och prisvärt sätt att utföra våra JUnit-testfall.

# 6) Kör Test Suite med Testrunner Class

I realtidsscenarier är det minst föredragna alternativet att köra en testcase i taget.

• Vi har fall där vi måste köra en grupp relaterade / orelaterade testfall.
• Vi kan till exempel behöva skapa och köra regressionstestsviter eller röktestsviter.

Vi kommer nu att lära oss om implementeringen av olika anteckningar som används för att skapa testsviter och exekvera sviten.

Den övergripande processen för att köra testpaketet med Test Runner är enligt arbetsflödet nedan:

1. Skapa JUnit klass 1, JUnit klass 2,…. JUnit klass n.
2. Skapa klassfil för testpaket som grupperar testfallet.
3. Skapa en Testrunner-klassfil för att åberopa den testsvit som skapats.
4. Utför Testrunner-klassen.

Strukturen för de program genom vilka vi ska demonstrera skapandet av testpaket och körning av löparfilen visas i bilden nedan:

Här kommer vi att täcka underområdena:

1. Skapa JUnit-klasser
2. Skapa testsviter
3. Skapa en Testrunner-fil och köra testsviterna med den.
4. Ytterligare information om hur @RunWith-anteckningen fungerar.

# 6.1) Skapa JUnit-klasser

Låt oss börja med att skapa två enkla JUnit-klassfiler:

1. JUnitTestCase1.java - Den innehåller koden för att verifiera ett förväntat numeriskt värde - variabeln Värde1 matchar ett verkligt värde på variabeln Värde2.
2. JUnitTestCase2.java - Inkluderar koden för att verifiera om den förväntade strängvariabeln strValue och faktisk strängvariabel strActual tändstickor.

Dessa är i princip två testfall som vi försöker komma in i en logisk gruppering som kallas testsvit och få den att köras efter varandra.

Kod för JUnitTestCase1.java

Kod för JUnitTestCase2.java

# 6.2) Skapa Test Suite:

Detta avsnitt och nästa avsnitt spelar en framträdande roll i hela processen att skapa och köra en testsvit. I detta avsnitt kommer vi att försöka förstå hur man grupperar flera JUnit-testklasser och binder dem till en testsvit .

Enligt strukturbilden ovan, låt oss skapa en testsvit som grupperar JUnitTestCase1.java och JUnitTestCase2.java och namnge sviten som JUnitTestSuite.java

De två anteckningarna som hjälper oss att skapa en testsvit är:

1. @RunWith och
2. @SuiteClasses

Paket som behövs för anteckningarna:

1. Du måste importera paketet org.junit.runner.RunWith; för att inkludera @RunWith-anteckningen.
2. Du behöver paketet org.junit.runners.Suite.SuiteClasses för att @SuiteClasses ska fungera.
3. Dessutom måste du importera paketet org.junit.runners.Suite för att skicka en parameter Suite.class till kommentaren @RunWith.

Låt oss granska koden för bättre förståelse !!

Kod för JUnitTestSuite.java

Förståelse av koden för JUnitTestSuite.java:

1. @RunWith hjälper JVM att förstå vilken typ av löparklass som ska köras T.ex. Suite.class eller Gurka.class
2. Här är parametern för @RunWith Suite.klass . Det hjälper JVM att känna igen att den aktuella filen där @RunWith (Suite.class) används spelar en roll i Test Suite.
3. JUnit-testklassnamnen som ska bindas samman i en svit måste skickas som en strängmatris i form av parametrar för @SuiteClasses åtskilda av ett kommatecken.
4. Detta gör det möjligt för JVM att veta vilka testcases som behöver grupperas under sviten.
5. Svitenamnet kommer att vara JUnit-klassens filnamn som antecknas med @RunWith och @SuiteClasses vilket i detta fall är JUnitTestSuite.

# 6.3) Skapa Test Runner-fil och kör JUnit Test-sviten med Test Runner

Det sista steget hjälper oss att köra testsviten som vi just skapade i avsnittet ovan med hjälp av en Testrunner-fil.

1. Vi skapar nu en Java-fil med namnet SuiteRunnerFile.
2. Denna SuiteRunnerFile.java är inte en JUnit-klass utan en vanlig Java-fil med huvudmetoden i den.

Låt oss titta på koden och sedan försöka förstå den.

Kod för SuiteRunnerFile.java

Paket som behövs för anteckningen

1. Du måste importera paketet org.junit.runner.JunitCore för att inkludera JUnitCore klass i koden.
2. Du måste importera paketet org.junit.runner.notification.Failure och org.junit.runner. Resultat för att inkludera fel och resultatklass i koden.

Förståelse av koden för SuiteRunnerFile.java

1. För att skapa en löparfil för körning av testpaket, JUnitCore klass spelar en viktig roll.
2. De runClasses () metod av JUnitCore klass tar testets klassnamn som inmatningsparameter, därför har vi uttalandet JUnitCore. runClasses (JUnitTestSuite. klass ).
3. Returtypen för detta uttalande är Resultat klassobjekt som lagrar den resulterande framgångsstatusen och felstatusen för vart och ett av testfallet; efter utförande. Det är därför vi har en resultat som den Resultat klassobjekt i koden.
4. Sedan skriver vi ut eventuella misslyckanden i testfallet. Liksom getFailures () -metoden kan du också få felantalet och Run count med metoden getFailureCount () respektive getRunCount ().
5. Nu är SuiteRunnerFile redo att köras,
   1. Välj filen från Package Explorer och
   2. Högerklicka och välj Kör som -> Java, programmet körs.

Nedan visas skärmdumpen av konsolfönstret.

Förklaring av resultaten på konsolen:

Konsolen ovan visar att:

1. Klassfilen JUnitTestSuite har körts via SuiteRunnerFile.
2. Metoden printMe () under kommentar @BeforeClass körs först och
3. Sedan utfördes testfallet i testpaketet efter varandra. Så här kan testsviten skapas och köras som ett paket.

# 6.4) Ytterligare information - Hur fungerar @RunWith?

• @RunWith är ett JUnit API som i princip bara tar ett element som inmatningsparameter som är ett löparklassfilnamn.
• JUnit-ramverket åberopar den angivna klassen som testlöpare.

Nedanstående utdrag från RunWith.java hjälper dig att få en förståelse:

Förstå ovanstående RunWith-gränssnittskod:

1. Det angivna värde måste vara en härledd klass av Löpare klass . Begreppet reflektion används här.
2. Ett mycket bra exempel på en sådan löparklass är redan implementerad i vår kod, dvs @ RunWith (Suite.class) där en grupp testcases är bundna ihop för att göra en testsvit.
3. På liknande sätt kan ett annat bra exempel på att använda en Runner-klass med @RunWith vara @RunWith (Cucumber.class) som är en affärsdriven utvecklingsram (BDD) för testautomatisering med Selenium i Java. Detta hjälper ramverket att köra gurkabaserade testfall.

Notera:

• Kommentarerna och parametrarna som användes för att skapa och köra JUnit-testsviten i den här självstudien var specifika för JUnit 4.
• Det finns ett lite annorlunda sätt att skapa en JUnit Test Suite och köra löparfilen i JUnit 5.

Vi kommer att ha en fokuserad förståelse för alla aspekter av JUnit 4 vs JUnit 5 snart i våra kommande handledning.

# 7) Kör JUnit-testfall med Maven

Du kan också ha ett Maven-projekt bestående av JUnit-tester på plats och köra testerna genom Maven som kommer att behandlas i en separat handledning.

Slutsats

1. Vi lärde oss alla olika alternativ för att köra JUnit-testerna - såväl enstaka tester som flera som är grupperade i testsviter.
2. Vi fick ytterligare kunskap om hur man uppdaterar inställningen för alternativet Kör, hur man åtgärdar javac-fel och hur kan kommandoradsutförande hjälpa oss.
3. Dessutom lärde vi oss också hur @RunWith-anteckningen fungerar.

Därför finns det mer att följa i de kommande handledningarna. 'Stand By' tills dess !!!

=> Besök här för att lära dig JUnit From Scratch.

Rekommenderad läsning

• JUnit-tester: Hur man skriver JUnit-testfall med exempel
• JUnit-handledning för nybörjare - Vad är JUnit-testning?
• Vad är en JUnit Test Fixture: Handledning med JUnit 4-exempel
• Specflow Reporting: Hur man genererar testrapporter och utför selektiva tester
• Ladda ner, installera och konfigurera JUnit i Eclipse
• Introduktion till JUnit Framework and Its Use in Selenium Script - Selenium Tutorial # 11
• Skapa appiumtest för en Android-app
• Infoga flera dokument i MongoDB med hjälp av arrays