Meny

JUnit Test Suite & Filtering Test Cases: JUnit 4 Vs JUnit 5

  • Huvud
  • Övrig
  • JUnit Test Suite & Filtering Test Cases: JUnit 4 Vs JUnit 5

junit test suite filtering test cases

Prova Vårt Instrument För Att Eliminera Problem

felreparationsverktyg för Windows 10

Denna handledning diskuterar vad som är en JUnit Test Suite, hur man skapar en testsvit och hur man filtrerar testfall i JUnit 4 vs JUnit 5:

Vi lärde oss hur man hoppar över vissa testfall under körningen i vår tidigare handledning. Vi lärde oss också om olika anteckningar som används i JUnit 4 och JUnit 5 för att göra det.

I den här handledningen lär vi oss:

  • Vad är en testsvit?
  • Hur skapar vi en testsvit genom att lägga in flera testfall i en grupp och genomföra sviten med JUnitCore-klassen?

=> Besök här för den exklusiva JUnit-utbildningsserien.

JUnit Test Suite & Filtering Testcase

Vad du kommer att lära dig:

JUnit Test Suite

JUnit 4: @RunWith, @SuiteClasses Annotations

Handledningen Flera sätt att utföra JUnit-tester illustrerade hur man skapar en testsvit i JUnit 4.

Anteckningarna @Spring med och @SuiteClasses hjälpte oss att skapa en testsvit genom att gruppera flera JUnit-testklasser. Därefter anropade en löparfil med klass JUnitCore.runclasses () körningen av den testsvit som skapats.

Se det nämnda avsnittet för alla detaljer om arbetsflödet tillsammans med den faktiska koden för JUnit 4.

JUnit 5: @RunWith, @SelectClasses, @SelectPackages Annotations

Skapandet av en testsvit i JUnit 5 är ganska lik vad vi har i JUnit 4. Så, var är skillnaden då?

# 1) I JUnit 4 , vi har Suite.class som skickas som en parameter till @RunWith-kommentar för att stödja skapandet av en testsvit medan JUnit 5 använder samma @ RunWith-kommentar men med inmatningsparametern som JUnitPlatform.class istället för Suite.klass .

Så kodraden i JUnit 5 ser ut @RunWith (JUnitPlatform.class). Detta är anteckningen som kommer med din underprojekt JUnit Platform.

#två) I JUnit 4 , vi använder @SuiteClasses att gruppera flera JUnit-klasser åtskilda av ett kommatecken i JUnit 5 vi har:

  • Anteckningen @SelectClasses det motsvarar @SuiteClasses i JUnit 4 för att gruppera flera JUnit-klasser.
  • @SelectPackages annotering används för att gruppera flera tester från paketet / paketen. Du måste ange ett strängmatrisvärde som representerar paketet du vill inkludera.

Således, med andra ord,

  1. Om du vill gruppera testfall från ett enda paket, kan JUnit 5 göra det.
  2. Eller om du vill gruppera testfall från flera paket, stöder JUnit 5 att du också gör det. En anmärkning att komma ihåg här är att testerna under alla underpaket för det nämnda paketet också ingår i testpaketet som standard.

JUnit 5: Olika scenarier / exempel

Skapa en testsvit som grupperar flera testklasser

Kodavsnittet visas nedan:

@RunWith(JUnitPlatform.class) @SelectClasses({JUnit5TestCase1.class, JUnit5TestCase2.class }) public class JUnitTestSuite { }

Skapa en testsvit för ett paket

Kodavsnittet visas nedan:

@RunWith(JUnitPlatform.class) @SelectPackages({“ demo.tests “}) public class JUnit5TestSuite { }

Notera :

  1. Säga demo.tester paketet har ett delpaket demo.tests.subtests.
  2. Koden @SelectPackages ({“demo.tests“}) kommer att inkludera alla tester under delpaketet också i testpaketet; som standard.
  3. Om du hade sagt @SelectPackages ({“demo.tests.subtests“}) , testfallet under delpaketet demo.tests.subtests kommer endast att inkluderas i testpaketet medan test från sitt överordnade paket, dvs. demo.tester skulle inte inkluderas.

Skapa en testsvit för flera paket

Kodavsnittet för att skapa en testsvit för flera paket separerad med ett kommatecken i JUnit 5 - ser ut som visas nedan:

@RunWith(JUnitPlatform.class) @SelectPackages({“demo.tests”, “demo1.tests”, “demo2.tests”}) public class JUnit5TestSuite { }

Filtering Test Suite - JUnit 4 vs JUnit 5

Ibland måste vi filtrera bort testfall och utföra en viss uppsättning test enligt våra behov. Till exempel kan det finnas en uppsättning tester som identifierats för regressionstest, en separat uppsättning för enhetstestning och en separat uppsättning testfall för rökprovning.

Vi måste utesluta eller inkludera testfall från vissa paket eller klasser eller kategorier. Filtrering eller taggning av tester från ett enda paket är det enda alternativet med JUnit4.

Jämfört med JUnit 4 kommer JUnit 5 med en bra uppsättning funktioner för att stödja detta behov av att filtrera dina testfall från enpaketet eller flera paket och delpaket enligt dina ändrade krav.

JUnit 4 - @Category, @IncludeCategory, @ExcludeCategory

Testfallet i JUnit 4 kan kategoriseras i olika kategorier. Dessa kategorier kan uteslutas eller inkluderas när du kör din testsvit. Anteckningarna @Category, @IncludeCategory och @ExcludeCategory stöds från JUnit 4.12 och senare.

Steg på hög nivå för att skapa filter baserat på kategorin eller kategorierna är följande:

# 1) Skapa ett markörgränssnitt som spelar en roll i kategorin.

#två) Anteckna testmetoderna för de klasser som ska ingå i SuiteClasses med @Kategori och kategorinamnet.

# 3) Använd anteckningen i testpaketfilen @IncludeCategory med kategorinamnet för att inkludera de test som tillhör en viss kategori.

# 4) Använd anteckningen i testpaketfilen @ExcludeCategory med kategorinamnet för att utesluta dem.

# 5) Kommentaren @Category kan också användas på testnivå eller klassnivå. Om anteckningen tillämpas på testnivå, märks det specifika testet med den givna kategorin, medan om anteckningen är på klassnivå märks alla tester inom klassen till den givna kategorin.

Låt oss titta på några fler detaljer för att förstå det praktiska genomförandet av att kategorisera testerna och filtrera bort dem för utförande:

Steg 1:

Vi börjar med skapandet av en markörgränssnitt som kommer att spela rollen som a kategori för testmetoder. Här skapar vi en kategori med namnet Enhetstest . Koden är väldigt enkel. Se koden nedan.

Kod för UnitTest.java

package demo.tests; public interface UnitTest {}

Steg 2:

Vi markerar kategorin vid testmetodnivå i klassen JUnitTestCase1.java . För att lägga till testfallet junitMethod1 () i kategorin UnitTest måste vi kommentera testmetoden med @Category (UnitTest.class) .

Detta lägger till testmetoden i kategorin UnitTest. De andra testmetoderna (om sådana finns) är inte märkta till kategorin om inte metoderna är antecknade med en kategori.

För att @Category-anteckningen ska fungera i vår kod måste vi importera paketet org.junit.experimental.categories.Category

Kodavsnittet från JUnitTestCase1.java:

@Category(UnitTest.class) @Test public void junitMethod1(){ int Value2=9000; Assert. assertEquals (Value1, Value2); }

Alternativt kan en testmetod också tillhöra flera kategorier T.ex. : @Category (UnitTest.class, SmokeTest.class)

Steg 3:

Jag skulle nu markera kategorin på klassnivå i klassen JUnitTestCase2.java . Samma uttalande som lades till på testmetodnivå i det tidigare steget kommer också att läggas till i den aktuella klassfilen.

Observera att här kommer vi att lägga till uttalandet på klassnivå. Genom att göra detta kommer alla testmetoder i filen att tillhöra Enhetstest Kategori.

Kodavsnittet från JUnitTestCase2.java:

@Category(UnitTest.class) @Test public class JUnitTestCase2 { public String stringValue='JUnit';

Steg 4:

dual wan trådlös router belastningsbalansering

Nu när våra erforderliga testfall har kategoriserats i kategorin UnitTest kommer vi nu att se hur man lägger till dem i testsviten genom att filtrera bort dem baserat på kategorin. Vi kommer att göra vissa kodändringar i JUnitTestSuite.class för att demonstrera detta.

  • Kategorier. Klass kommer att skickas som en parameter till @RunWith-anteckningen.
  • @ Suite.SuiteClasses tar testklassens strängmatris.
  • Anteckningen @ Categories.IncludeCategory kommer att behöva UnitTest.class som parameter.
  • Detta uttalande hjälper oss att filtrera hela sviten och bara köra de testfall från sviten som tillhör kategorin.
  • Kategorier.klass behöver paket org.junit.experimental.categories.Categories som ska importeras.

Kodavsnittet för JunitTestSuite.java

@RunWith(Categories.class) @Categories.IncludeCategory(UnitTest.class) @Suite.SuiteClasses({JUnitTestCase1.class, JUnitTestCase2.class}) public class JUnitTestSuite {

Anteckningen @ Categories.IncludeCategory kan också skrivas som @IncludeCategory. Du kan också skapa flera gränssnitt (kategorier) och kommentera klass / testmetoder med flera kategorier åtskilda av ett kommatecken. Nedanstående exempel filtrerar bort de test som tillhör kategori - Kategori1 och Kategori2.

Exempel: @IncludeCategory ({Category1.class, Category2.class})

Liknande regler går med @ Categories.ExcludeCategory / @ExcludeCategory för att utesluta testmetoderna under kategorin eller kategorierna under testkörningen.

JUnit 5 - @IncludeTags, @ExcludeTags, @IncludePackages, @ExcludePackages, @IncludeClassNamePatterns, @ExcludeClassNamePatterns

JUnit 5 kommer förpackat med flera metoder för att organisera och filtrera bort testfall.

JUnit 5 - @IncludeTags, @ExcludeTags

# 1) Liksom JUnit 4 har @IncludeCategory och @ExcludeCategory-kommentarer för att stödja filtrering av testfall för körning.

#två) JUnit 5 har @IncludeTags och @ExcludeTags-anteckningar för att uppnå samma syfte.

# 3) JUnit 4 hänvisar till testfall som ska organiseras i en specifik kategori medan JUnit 5 hänvisar till taggning av testfall med en specifik tagg för att möjliggöra filtrering av testfall för körning.

Steg på hög nivå för att skapa filter baserat på taggarna är följande:

  1. Kommentera testmetoderna för paketet / paketen som ska ingå i @SelectPackages med @Märka och det användardefinierade taggnamnet. En klass kan ha olika taggar för olika testmetoder.
  2. Du kan också kommentera @Tag på klassnivå så att alla tester i klassen är taggade.
  3. Använd anteckningen i testpaketfilen @IncludeTags med taggnamnet för att inkludera de test som tillhör en specifik tagg.
  4. Använd anteckningen i testpaketfilen @ExcludeTags med taggnamnet för att utesluta dem från testsviten.

Låt oss nu få en detaljerad illustration om hur man praktiskt implementerar filtrering i JUnit 5.

Steg 1 : Vi taggar en testmetod i JUnit5TestCase1.java till taggnamnet 'Regression'

Kodavsnittet från JUnit5TestCase1.java:

@Tag(“Regression”) @Test public void junitMethod1(){

Steg 2 : Vi taggar en testmetod i JUnit5TestCase2.java till Taggnamnet “SmokeTest”.

Kodavsnittet från JUnit5TestCase2.java:

@Tag(“SmokeTest”) @Test public void junitMethod2(){

Steg 3: Nu när testmetoderna har taggats kommer vi nu att uppdatera JUnit5TestSuite.java för att lägga till lämpliga filter efter taggar för testerna. Koden nedan innehåller alla tester som är märkta som ”Regression” och utesluter alla de som är märkta som “SmokeTest”.

Kodavsnittet från JUnit5TestSuite.java:

@RunWith(JUnitPlatform.class) @SelectPackages({“demo.tests“}) @IncludeTags(“Regression”) @ExcludeTags(“SmokeTest”) public class JUnit5TestSuite { }

JUnit 5 - @IncludePackages, @ExcludePackages

Vi vet redan att när vi skickar ett paketnamn i @SelectPackages kommentar, testerna i delpaketen i paketet läggs också till i testpaketet.

Det kan finnas vissa delpaket som vi vill inkludera i vår testsvit medan några andra delpaket som vi inte vill eller kanske inte är relevanta att inkluderas i vår svit.

Detta underlättas genom anteckningarna @IncludePackages och @ExcludePackages i JUnit 5.

Låt oss anta att vi har ett paket ”demo.tests” som har tre delpaket, dvs. delpaket1, delpaket2 och delpaket 3 med dess testklasser i vart och ett av paketen nedan.

paketet

Låt oss se ett kodavsnitt av JUnit5TestSuite.java för att visualisera hur du inkluderar och utesluter ett paket.

Scenario 1: Använd filter för att endast inkludera testfall från underpaket1.

Koden nedan innehåller alla tester från alla JUnit-klasser i paketet demo.tests.subpackage1, men exkluderar dock alla tester direkt under paketet demo.test och de under paketet subpackage2 och subpackage3.

Kodavsnittet från JUnit5TestSuite.java:

@RunWith(JUnitPlatform.class) @SelectPackages({“demo.tests“}) @IncludePackages(“demo.tests.subpackage1”) public class JUnit5TestSuite { }

Scenario # 2: Använd filter för att utesluta testfall endast från paketets delpaket3.

Koden nedan exkluderar alla tester från JUnit-klasserna i paketet - demo.tests.subpackage3 men sviten innehåller alla tester direkt under paketet demo.test och de under paketet subpackage1 och subpackage2.

Kodavsnittet från JUnit5TestSuite.java:

@RunWith(JUnitPlatform.class) @SelectPackages({“demo.tests“}) @ExcludePackages(“demo.tests.subpackage3”) public class JUnit5TestSuite { }

JUnit 5 - @IncludeClassNamePatterns, @ExcludeClassNamePatterns

När du vill inkludera eller utesluta vissa klasser som matchar ett visst reguljärt uttryck från paketet, anteckningarna @ IncludeClassNamePatterns och @ ExcludeClassnamePatterns kan användas i testfilen klassfil.

Låt oss nu se illustrationen genom koduppdateringen i JUnit5TestSuite.java

Scenario 1:

Koden nedan innehåller klasser som slutar med 'Ctests' från paketet demo.tests

@RunWith(JUnitPlatform.class) @SelectPackages({“demo.tests“}) @IncludeClassNamePatterns({'^.*CTests?$'})

Scenario # 2:

Vi ska nu utesluta de klasserna som inleda med 'STest' från paketet demo.tests

@RunWith(JUnitPlatform.class) @SelectPackages({“demo.tests“}) @ExcludeClassNamePatterns({'^STest.*$'})

Scenario # 3:

Flera reguljära uttryck kan också skickas som filterkriterier. Nedanstående kod anger två olika reguljära uttryck åtskilda med ' ELLER ”Operatör. Spaltstången | är OR-operatören här.

hur öppnar jag en torrent

Koden filtrerar bort klasser initierande med Testa ( Testa.*) eller slut med Tester (*. Tester?) och inkluderar de här klasserna i testsviten eftersom annotering @IncludeClassNamePatterns används.

Notera: Om det fullständigt kvalificerade klassnamnet matchar minst ett mönster, hämtas klassen enligt @IncludeClassNamePatterns eller @ExcludeClassNamePatterns-anteckningen.

@RunWith (JUnitPlatform.class)

@SelectPackages ({“demo.tests“})

@IncludeClassNamePatterns (. * Tester?) $ ”)

Vanliga frågor om JUnit Filtering Testfall

Här är en fråga som kan ha legat kvar hos dig under en längre tid nu.

F # 1) Vad är skillnaden mellan att inaktivera / ignorera ett test och att filtrera bort ett test? Kan inte någon av funktionerna hjälpa till med samma syfte att hoppa över testfall under körning?

Svar: Frågan är verkligen en äkta och är värt att besvara.

  1. Med filtrering av testfunktionen kan du utesluta såväl som omfatta test beroende på märkt kategori. Medan du inaktiverar kan du bara välja att utesluta och inte inkludera test för utförande.
  2. Filtrering av testfallet är ett slags testvillkor som övergår villkorligt, medan det i fallet med ignorerade tester hoppas över utan några villkor.
  3. En annan signifikant skillnad mellan de två är att när du kör testfallet med tester som antecknats med @Ignore eller @Disabled - visas de ignorerade testerna i testresultaten under HOPPAT ÖVER räkna
  4. När du kör de bortfiltrerade testerna visas de inte alls i testresultatet.

Slutsats

I denna handledning lärde vi oss att filtrera bort tester genom att lägga till en kategori / tagg i testerna.

Vi lärde oss i JUnit 4 att vi har @Category, @IncludeCategory och @ExcludeCategory för att filtrera testfallet medan JUnit 5 har @IncludeTags och @ExcludeTags för att göra detsamma.

Dessutom har JUnit 5 ytterligare filtreringsalternativ som använder annoteringar @IncludePackages, @ExcludePackages, och även anteckningar för att inkludera eller utesluta klasser med klassnamnmönster. Ju mer vi utforskar; vi inser att det finns mycket mer att utforska ännu.

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

Rekommenderad läsning

^