Menu

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

  • Vigtigste
  • Andet
  • JUnit Test Suite & Filtering Test Cases: JUnit 4 Vs JUnit 5

junit test suite filtering test cases

Prøv Vores Instrument Til At Fjerne Problemer

bedste gratis computerrenser og -reparation

Denne vejledning diskuterer, hvad der er en JUnit Test Suite, hvordan man opretter en test-suite, og hvordan man filtrerer testtilfælde i JUnit 4 vs JUnit 5:

Vi lærte om, hvordan man springer over bestemte testsager under udførelse i vores tidligere tutorial. Vi lærte også om forskellige kommentarer, der blev brugt i JUnit 4 og JUnit 5 til at gøre det.

I denne vejledning lærer vi:

  • Hvad er en testpakke?
  • Hvordan opretter vi en testpakke ved at indkapsle flere testsager i en gruppe og udføre pakken ved hjælp af JUnitCore-klassen?

=> Besøg her for den eksklusive JUnit Training Tutorial Series.

JUnit Test suite & Filtering Testcase

Hvad du lærer:

JUnit Test Suite

JUnit 4: @RunWith, @SuiteClasses Annotations

Vejledningen Flere måder at udføre JUnit-test på illustreret hvordan man opretter en testpakke i JUnit 4.

Kommentarerne @RunWith og @SuiteClasses hjalp os med at oprette en testpakke ved at gruppere flere JUnit testklasser. Derefter påkaldte en løberfil med klasse JUnitCore.runclasses () udførelsen af ​​den oprettede testpakke.

Se det nævnte afsnit for alle detaljer om arbejdsgangen sammen med den faktiske kode for JUnit 4.

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

Oprettelse af en testpakke i JUnit 5 svarer til det, vi har i JUnit 4. Så hvor er forskellen så?

# 1) I JUnit 4 , vi har Suite.class, der sendes som parameter til @RunWith-kommentar for at understøtte oprettelsen af ​​en testpakke, mens JUnit 5 bruger den samme @RunWith-kommentar, men med inputparameteren som JUnitPlatform.class i stedet for Suite.klasse .

Så kodelinjen i JUnit 5 ser ud @RunWith (JUnitPlatform.class). Dette er den kommentar, der følger med din underprojekt JUnit Platform.

#to) I JUnit 4 , vi bruger @SuiteClasses at gruppere flere JUnit-klasser adskilt af et komma, mens de er i JUnit 5 vi har:

  • Annotationen @SelectClasses det svarer til @SuiteClasses i JUnit 4 for at gruppere flere JUnit-klasser.
  • @SelectPackages annotation bruges til at gruppere flere tests fra pakken / pakkerne. Du skal indtaste en strengarrayværdi, der repræsenterer den pakke, du vil medtage.

Således med andre ord

  1. Hvis du ønsker at gruppere testsager fra en enkelt pakke, giver JUnit 5 dig mulighed for at gøre det.
  2. Eller hvis du ønsker at gruppere testsager fra flere pakker, understøtter JUnit 5, at du også gør det. En bemærkning til at huske her er, at testene under alle underpakkerne til den nævnte pakke også inkluderes i testpakken som standard.

JUnit 5: Forskellige scenarier / eksempler

Oprettelse af en testpakke, der grupperer flere testklasser

Kodestykket vises nedenfor:

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

Oprettelse af en testpakke til enkeltpakke

Kodestykket vises nedenfor:

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

Bemærk :

  1. Sige demo.tests pakken har en underpakke demo.tests.subtests.
  2. Koden @SelectPackages ({“demo.tests“}) vil også inkludere alle testene under delpakken i testpakken; som standard.
  3. Hvis du havde sagt @SelectPackages ({“demo.tests.subtests“}) , testsagerne under delpakken demo.tests.subtests vil kun blive inkluderet i testpakken, mens testene fra dets overordnede pakke, dvs. demo.tests ville ikke være inkluderet.

Oprettelse af en testpakke til flere pakker

Kodestykket til oprettelse af en testpakke til flere pakker adskilt med komma i JUnit 5 - ser ud som vist nedenfor:

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

Filtering Test Suite - JUnit 4 vs JUnit 5

Nogle gange er vi nødt til at filtrere testsager ud og udføre et bestemt sæt tests i henhold til vores behov. For eksempel kunne der være et sæt tests identificeret til regressionstest, et separat sæt til enhedstest og et separat sæt testsager til røgtest.

Vi er nødt til at ekskludere eller inkludere testsager fra bestemte pakker eller klasser eller kategorier. Filtrering eller tagging af testene fra en enkelt pakke er den eneste mulighed med JUnit4.

Sammenlignet med JUnit 4 leveres JUnit 5 med et godt sæt funktioner til understøttelse af dette behov for filtrering af dine testcases fra den enkelte pakke eller flere pakker og underpakker i henhold til dine skiftende krav.

JUnit 4 - @Category, @IncludeCategory, @ExcludeCategory

Testcases i JUnit 4 kan kategoriseres i forskellige kategorier. Disse kategorier kan ekskluderes eller inkluderes, mens du kører din testpakke. Kommentarerne @Category, @IncludeCategory og @ExcludeCategory understøttes fra JUnit 4.12 og derover.

Trin på højt niveau for at oprette filtre baseret på kategorien eller kategorierne er som følger:

# 1) Opret et markørinterface, der spiller en rolle i kategorien.

#to) Kommenter testmetoderne for de klasser, der skal medtages i SuiteClasses med @Kategori og kategorienavnet.

# 3) Brug annotering i testpakkefilen @IncludeCategory med kategorienavnet for at inkludere de tests, der tilhører en bestemt kategori.

# 4) Brug annotering i testpakkefilen @ExcludeCategory med kategorienavnet til ekskludering af dem.

# 5) Kommentar @Category kan også bruges på testniveau eller klasseniveau. Hvis kommentaren anvendes på testniveau, bliver den specifikke test mærket med den givne kategori, mens hvis kommentaren er på klasseniveau, bliver alle testene i klassen tagget til den givne kategori.

Lad os se på nogle flere detaljer for at forstå den praktiske implementering af kategorisering af testene og filtrering af dem til udførelse:

Trin 1:

Vi starter med oprettelsen af ​​en markørgrænseflade der vil spille rollen som en kategori for testmetoder. Her opretter vi en kategori med navnet Enhedstest . Koden er meget enkel. Se koden nedenfor.

Kode for UnitTest.java

package demo.tests; public interface UnitTest {}

Trin 2:

Vi markerer kategorien på testmetodeniveau i klassen JUnitTestCase1.java . For at tilføje testcase junitMethod1 () i kategorien UnitTest skal vi kommentere testmetoden med @Kategori (UnitTest.class) .

Dette tilføjer testmetoden til kategorien UnitTest. De andre testmetoder (hvis nogen) er ikke mærket til kategorien, medmindre metoderne er kommenteret med en kategori.

For at have @Category-annotering i vores kode skal vi importere pakken org.junit.experimental.categories.Category

Kodestykket fra JUnitTestCase1.java:

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

Alternativt kan en testmetode også tilhøre flere kategorier For eksempel. : @Category (UnitTest.class, SmokeTest.class)

Trin 3:

Jeg vil nu markere kategorien på klasseniveau i klassen JUnitTestCase2.java . Den samme erklæring, der blev tilføjet på testmetodeniveau i det tidligere trin, tilføjes også i den aktuelle klassefil.

Bemærk, at her vil vi tilføje udsagnet på klasseniveau. Hvis du gør dette, vil alle testmetoder i filen tilhøre Enhedstest Kategori.

Kodestykket fra JUnitTestCase2.java:

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

Trin 4:

pl sql interview spørgsmål til 5 års erfaring

Nu hvor vores krævede testsager er blevet kategoriseret i UnitTest-kategorien, vil vi nu se, hvordan vi tilføjer dem til testpakken ved at filtrere dem ud fra kategorien. Vi foretager visse kodeændringer i JUnitTestSuite.class for at demonstrere dette.

  • Kategorier. Klasse vil blive videregivet som en parameter til @RunWith-kommentaren.
  • @ Suite.SuiteClasses tager testklassens string array.
  • Annotationen @ Categories.IncludeCategory har brug for UnitTest.class som parameter.
  • Denne erklæring hjælper os med at filtrere hele pakken og kun køre de testsager fra pakken, der hører til kategorien.
  • Categories.class behovspakke org.junit.experimental.categories.Categories der skal importeres.

Kodestykket til JunitTestSuite.java

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

Annotationen @ Categories.IncludeCategory kan også skrives som @IncludeCategory. Du kan også oprette flere grænseflader (kategorier) og kommentere klasse / testmetoder med flere kategorier adskilt med et komma. Eksemplet nedenfor filtrerer de tests, der tilhører kategori - Kategori1 og Kategori2, ud.

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

Lignende regler følger med @ Categories.ExcludeCategory / @ExcludeCategory at udelukke testmetoderne under kategorien eller kategorierne under testkørslen.

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

JUnit 5 leveres pakket med flere tilgange til organisering og filtrering af testsagerne.

JUnit 5 - @IncludeTags, @ExcludeTags

# 1) Ligesom JUnit 4 har @IncludeCategory og @ExcludeCategory-kommentarer til understøttelse af filtrering af testsager til udførelse.

#to) JUnit 5 har @IncludeTags og @ExcludeTags-kommentarer for at opnå det samme formål.

# 3) JUnit 4 henviser til testsagerne, der skal organiseres i en bestemt kategori, mens JUnit 5 henviser til mærkning af testsagerne med et specifikt tag for at muliggøre filtrering af testsagerne til udførelse.

Trin på højt niveau for at oprette filtre baseret på tags er som følger:

  1. Kommenter testmetoderne for pakken / pakkerne, der skal medtages i @SelectPackages med @Tag og det brugerdefinerede tagnavn. En klasse kan have forskellige tags til forskellige testmetoder.
  2. Du kan også kommentere @Tag på klasseniveau, så alle testene i klassen er tagget.
  3. Brug annotering i testpakkefilen @IncludeTags med tagnavnet for at inkludere de tests, der tilhører et specifikt tag.
  4. Brug annotering i testpakkefilen @ExcludeTags med tagnavnet til ekskludering af dem fra testpakken.

Lad os nu have en detaljeret illustration af, hvordan man praktisk implementerer filtrering i JUnit 5.

Trin 1 : Vi mærker en testmetode i JUnit5TestCase1.java til Tagnavnet 'Regression'

Kodestykket fra JUnit5TestCase1.java:

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

Trin 2 : Vi mærker en testmetode i JUnit5TestCase2.java til tagnavnet “SmokeTest”.

Kodestykket fra JUnit5TestCase2.java:

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

Trin 3: Nu hvor testmetoderne er blevet mærket, opdaterer vi nu JUnit5TestSuite.java for at tilføje passende filtre efter tags til testene. Nedenstående kode inkluderer alle tests, der er mærket som 'Regression' og ekskluderer alle dem, der er tagget som 'SmokeTest'.

Kodestykket fra JUnit5TestSuite.java:

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

JUnit 5 - @IncludePackages, @ExcludePackages

Vi ved allerede, at når vi videregiver et pakkenavn i @SelectPackages kommentar, testene i delpakkerne til pakken føjes også til testpakken.

Der kan være visse underpakker, som vi vil medtage i vores testpakke, mens et par andre underpakker, som vi ikke ønsker eller måske ikke er relevante for at blive inkluderet i vores pakke.

Dette letter gennem annoteringerne @IncludePackages og @ExcludePackages i JUnit 5.

Lad os antage, at vi har en pakke 'demo.tests', som har tre underpakker, dvs. underpakke1, underpakke2 og underpakke 3 med dens testklasser i hver af nedenstående pakker.

pakke

Lad os se et kodestykke af JUnit5TestSuite.java for at visualisere, hvordan man inkluderer og ekskluderer en pakke.

Scenarie nr. 1: Anvend filter for kun at inkludere testcases fra underpakning1.

Nedenstående kode inkluderer alle testene fra alle JUnit-klasser i pakken demo.tests.subpackage1, dog ekskluderer alle tests direkte under pakken demo.test og dem under pakken subpackage2 og subpackage3.

Kodestykket fra JUnit5TestSuite.java:

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

Scenarie nr. 2: Anvend filter for kun at udelukke testtilfælde fra pakkeunderpakning3.

Nedenstående kode ekskluderer alle test fra JUnit-klasser i pakken - demo.tests.subpackage3, men pakken indeholder alle testene direkte under pakken demo.test og dem under pakken underpakning1 og underpakning2.

Kodestykket fra JUnit5TestSuite.java:

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

JUnit 5 - @IncludeClassNamePatterns, @ExcludeClassNamePatterns

Når du vil medtage eller ekskludere bestemte klasser, der matcher et specifikt regulært udtryk fra pakken, er kommentarerne @ IncludeClassNamePatterns og @ ExcludeClassnamePatterns kan bruges i testpakke klassefilen.

Lad os nu se illustrationen gennem kodeopdateringen i JUnit5TestSuite.java

Scenarie nr. 1:

Koden nedenfor inkluderer klasser, der slutter med 'Ctests' fra pakken demo.tests

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

Scenarie nr. 2:

Vi skal nu udelukke de klasser, der igangsætte med 'STest' fra pakken demo.tests

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

Scenarie # 3:

Flere regulære udtryk kan også sendes som filterkriterier. Nedenstående kode angiver to forskellige regulære udtryk adskilt med ' ELLER ”Operatør. Spaltebjælken | er OR-operatør her.

sql plsql interview spørgsmål og svar

Koden filtrerer klasser ud indlede med Prøve ( Prøve.*) eller Slutning med Tests (*. Tests?) og inkluderer disse klasser i testpakken, da der bruges kommentar @IncludeClassNamePatterns.

Bemærk: Hvis det fuldt kvalificerede klassenavn matcher mindst et mønster, hentes klassen pr. @IncludeClassNamePatterns eller @ExcludeClassNamePatterns-kommentaren.

@RunWith (JUnitPlatform.class)

@SelectPackages ({“demo.tests“})

@IncludeClassNamePatterns (. * Tests?) $ ”)

Ofte stillede spørgsmål om JUnit-filtreringstestsager

Her er et spørgsmål, der måske har dvælet hos dig i nogen tid nu.

Q # 1) Hvad er forskellen mellem at deaktivere / ignorere en test og filtrere en test ud? Kan ingen af ​​funktionerne hjælpe med at tjene det samme formål med at springe testsager over under udførelse?

Svar: Spørgsmålet er virkelig et ægte spørgsmål og det er værd at besvare.

  1. Med filtrering af testfunktionen kan du ekskludere såvel som omfatte test afhængigt af den taggede kategori. Mens du deaktiverer, kan du kun beslutte at ekskludere og ikke inkludere test til udførelse.
  2. Filtrering af testsagerne er en slags tilfælde, der springer betinget over, mens det i tilfælde af ignorerede tests springes over uden betingelser.
  3. En anden væsentlig forskel mellem de to er, at når du kører testcases med tests, der er kommenteret med @Ignore eller @Deaktiveret - vises de ignorerede tests i testresultaterne under HENTES OVER tælle
  4. Når du kører de filtrerede test, vises de slet ikke i testresultatet.

Konklusion

I denne vejledning lærte vi, hvordan man filtrerer test ud ved at tilføje en kategori / tag til testene.

Vi lærte i JUnit 4, at vi har @Category, @IncludeCategory og @ExcludeCategory til filtrering af testsagerne, mens JUnit 5 har @IncludeTags og @ExcludeTags til at gøre det samme.

Derudover har JUnit 5 yderligere filtreringsmuligheder ved hjælp af annoteringer @IncludePackages, @ExcludePackages og også annoteringer for at inkludere eller ekskludere klasser ved hjælp af klassens navnemønstre. Jo mere vi udforsker; vi indser, at der er meget mere endnu at udforske.

=> Hold øje med den enkle JUnit-træningsserie her.

Anbefalet læsning

^