Menu

Liste over JUnit-kommentarer: JUnit 4 Vs JUnit 5

list junit annotations

Prøv Vores Instrument Til At Fjerne Problemer

Denne vejledning forklarer alt om JUnit-kommentarer sammen med en sammenligning af kommentarer i JUnit 4 vs JUnit 5:

Vi lærte de forskellige måder at udføre JUnit-testsager på og så, hvordan man opretter og udfører en testpakke i vores tidligere tutorial.

I denne vejledning lærer vi det fremtrædende aspekt af JUnit, der kaldes, at kende Kommentarer. Fra og med JUnit 4 er annoteringer på plads og gør JUnit meget enkel, mere gavnlig og meget mere brugervenlig at bruge.

Kommentarer er en Java API, der gør det muligt for JVM at genkende typen af ​​den metode, der er defineret i testklassen. Der er 'livscyklusser, der tilbagekalder annoteringer', der ofte bruges.

=> Besøg her for at lære JUnit fra bunden.

JUnit-kommentarer

Hvad du vil lære:

JUnit-kommentarer - JUnit 4 vs JUnit 5

En testudførelse gennemgår forskellige faser af livscyklussen som angivet nedenfor:

  • Før du starter en test, er der visse aktiviteter, der skal udføres ved indledningen af ​​en klasse.
  • Visse andre aktiviteter, der skal udføres, før en testcase begynder udførelsen.
  • Visse aktiviteter, der skal udføres efter udførelse af testen og
  • Visse aktiviteter i slutningen af ​​udførelsen af ​​alle testene i en klasse.

For at sikre sig, at disse aktiviteter udføres gennem hvert trin i Java-livscyklussen, skal der være visse brugerdefinerede metoder eller funktioner på stedet kaldet ' livscyklus tilbagekaldsmetoder .

Disse adfærd livscyklus tilbagekaldsmetoder bestemmes af den indbyggede ' livscyklus tilbagekaldningsanmærkninger '' bruges i JUnit.

Eksempel: Lad os prøve at gøre det endnu enklere ved at relatere disse livscyklus-tilbagekaldsmetoder og kommentarer til et eksempel på teste en kaffeautomat.

  1. En metode maskine klar () der kontrollerer om vand, mælk og kaffebønner er tilgængelige, før maskinen tændes.
  2. En anden metode startMaskine () der tænder maskinen og placerer en ny, ny papirkop i maskinen.
  3. En testcase, der kontrollerer Varmt vand ()' mulighed.
  4. En anden testcase, der kontrollerer Cappuccino ()' mulighed.
  5. En anden testcase, der kontrollerer ExpressoCoffee ()' mulighed.
  6. En anden metode “ throwCup () ”, Der smider de brugte kopper i skraldespanden.
  7. En klassemetode “ throwTrashandSwitchOff () ”Smider overfyldt affaldsvæske fra bakken i kummen og slukker for maskinen.

Så i ovenstående eksempel er her, hvordan testens livscyklus følger:

  • startMaskine () kører før hver testcase - Varmt vand (), Cappuccino () og ExpressoCoffee () kører.
  • Hver af denne testcase følger også metoden throwCup ().
  • Metoderne maskine klar () og throwTrashandSwitchOff () er klasseniveau-metode, der kun kører en gang for en klasse. Metoden maskine klar () kører en gang, mens klassen starter udførelse. Metoden throwTrashandSwitchOff () kører en gang, når alle testsagerne er fuldført.

Nu opstår spørgsmålet, det er kun Java-metoder, så:

bedste teksteditor til python windows
  1. Hvordan vil vi insistere på, at JVM kører maskine klar () kun en gang på klasseniveau og throwTrashandSwitchOff () i slutningen af ​​klassekørsel?
  2. Hvordan får vi JVM til at vide det startMaskine () og throwCup () skal køres inden henholdsvis kørsel af hver testcase og efter afslutning af hver testcase-udførelse?
  3. Hvordan kan vi få JVM til at identificere, at metoderne Varmt vand (), Cappuccino () og ExpressoCoffee () skal testcases køres?

Svar: Det eneste svar på de ovennævnte spørgsmål er, at tilbagekaldelsesanmærkningerne i livscyklussen gør al den krævede magi.

(Lad os nu antage, at vi opretter denne klasse i JUnit 4)

Livscykluskommentarer - @BeforeClass, @AfterClass, @Before, @After, og @Prøve er de virkelige svar på ovenstående tre spørgsmål. Vi er temmelig sikre på, at efter at have læst nedenstående henvisninger, bliver du klar med livscyklus-tilbagekaldningsanmærkninger og dens arbejdsgang.

  • Kommenter metoden maskine klar () med @BeforeClass og JVM får det til at køre en gang i løbet af klassen.
  • Kommenter metoden throwTrash () med @Efter skole og JVM får det til at køre en gang i slutningen af ​​klassen.
  • Kommenter metoden startMaskine () med @Før og JVM kører det, før hver testcase kører.
  • Kommenter metoden throwCup () med @Efter og JVM kører det efter udførelsen af ​​hver testsag.
  • Kommenter hver af disse metoder Varmt vand (), Cappuccino () og ExpressoCoffee () med @Prøve og JVM ved, at dette er kernetestsagerne for JUnit-klassen, der skal udføres.

Lad os hurtigt se på JUnit-livscyklus tilbagekaldte kommentarer til JUnit 4 vs JUnit 5

BEMÆRKNING JUNIT 4BEMÆRKNING JUNIT 5
@RepeatedTest1.JUnit 5 understøtter gentagen udførelse af testmetoden et bestemt antal gange ved hjælp af @RepeatedTest-kommentar
@Før@BeforeEach
@Efter@AfterEach
@BeforeClass@BeforeAll
@Efter skole@Trods alt
@Prøve@Prøve

Sekventiel arbejdsgang i livscyklusanmærkningerne

Nedenfor er den sekventielle arbejdsgang i livscyklusanmærkningerne for JUnit 4:

sekventiel arbejdsgang for livscyklusanmærkningerne til JUnit 4

  1. Metoden, der er kommenteret med @BeforeClass, udføres en gang i starten af ​​klassen.
  2. Metoden, der er kommenteret med @Before, udføres, før Testcase 1 begynder.
  3. Metoden Testcase1 kommenteret med @Test er testcase i klassen.
  4. Metoden, der er kommenteret med @After, kører efter testcase 1 fuldfører udførelsen.
  5. Metoden, der er kommenteret med @Before, udføres, før Testcase 2 begynder.
  6. Metoden Testcase2 kommenteret med @Test er testcase i klassen.
  7. Metoden, der er kommenteret med @After, køres efter testcase 2 fuldfører udførelsen.
  8. Metoden, der er kommenteret med @AfterClass, udføres en gang i slutningen af ​​klassen, efter at både testcase 1 og 2 er udført.

Den sekventielle arbejdsgang i livscyklusanmærkningerne for JUnit 5 er som følger:

sekventiel arbejdsgang for livscyklusanmærkningerne for JUnit 5

  1. Metoden, der er kommenteret med @BeforeAll, udføres en gang i starten af ​​klassen.
  2. Metoden, der er kommenteret med @BeforeEach, udføres, før Testcase 1 begynder.
  3. Metoden Testcase1 kommenteret med @Test er testcase i klassen.
  4. Metoden, der er kommenteret med @AfterEach, kører efter testcase 1 fuldfører udførelsen.
  5. Metoden, der er kommenteret med @BeforeEach, udføres, før Testcase 2 begynder.
  6. Metoden Testcase2 kommenteret med @Test er testcase i klassen.
  7. Metoden, der er kommenteret med @AfterEach, kører, når Testcase 2 fuldfører udførelsen.
  8. Metoden, der er kommenteret med @AfterAll, udføres en gang i slutningen af ​​klassen, efter at både testcase 1 og 2 er udført.

Uddybning af hver kommentar

I dette afsnit, lad os dybt dykke og have en detaljeret forståelse af, hvad hver af livscyklusser kalder tilbagemelding på:

@Before (JUnit 4) / @ BeforeEach (JUnit 5):

  • Den annoterede metode udføres før udførelsen af ​​hver testmetode i testklassen.
  • Denne kommentar kan bruges, når du ønsker at have ressourcerne eller testdataene opsat lige inden starten af ​​hver test.
  • For eksempel, hvis der er 5 testcases i en JUnit-testklasse, udføres metoden, der er kommenteret med @ Before / @ BeforeEach, 5 gange inden hver eksekvering af testsagen.

@After (JUnit 4) / @ AfterEach (JUnit 5):

  • Den kommenterede metode udføres efter hver testmetode i testklassen udføres.
  • Denne kommentar kan bruges, når du ønsker at frigive brugte ressourcer eller testdata, efter at hver testsag er kørt.
  • For eksempel, hvis der er 5 testcases i en JUnit-testklasse, udføres metoden, der er kommenteret med @ After / @ AfterEach 5 gange efter testcases udførelse.

@BeforeClass (JUnit 4) / @ BeforeAll (JUnit 5):

  • Den kommenterede metode udføres, før alle testmetoderne i en testklasse udføres.
  • Denne kommentar kan bruges, når du ønsker at oprette ressourcer eller teste data på klasseniveau.
  • Da denne metode er kommenteret med @ BeforeClass / @ BeforeAll udføres kun én gang for en testklasse, og kopien af ​​metoden deles på tværs af klassen, og metoden skal angives statisk.
  • For eksempel, hvis der er 5 testkasser i en JUnit-testklasse, udføres metoden, der er kommenteret med @ BeforeClass / @ BeforeAll, en gang pr. testklasse, inden testcase startes.

@AfterClass (JUnit 4) / @ AfterAll (JUnit 5):

  • Den annoterede metode udføres efter alle testmetoderne i en testklasse udføres.
  • Denne kommentar kan bruges, når du ønsker at frigive de anvendte ressourcer eller testdata på klasseniveau.
  • Da denne metode er kommenteret med @ AfterClass / @ AfterAll kun udføres en gang for en testklasse, og kopien af ​​metoden deles på tværs af klassen, skal metoden angives statisk.
  • For eksempel, hvis der er 5 testkasser i en JUnit-testklasse, udføres metoden, der er kommenteret med @ AfterClass / @ AfterAll, en gang pr. testklasse, efter at alle testcases er fuldført.

@Test (JUnit 4 & JUnit 5):

  • @Test-kommentaren er almindelig for JUnit 4 såvel som JUnit 5. De annoterede metoder repræsenterer testsagerne i klassen.
  • Der kan være flere metoder, som hver er kommenteret med @Test i en JUnit-klasse. Dette indebærer, at en klasse kan have flere testsager.
  • Der er forskellige attributter eller parametre, der kan testes, hvilken der kan sendes. Du kan tilføje en tvunget timeout til en testsag eller tilføje en undtagelse. Dette vil blive beskrevet i detaljer i en separat vejledning.
  • Den annoterede metode kan ikke være privat eller statisk og kan ikke returnere nogen værdi.
  • Metoden @Test skal erklæres som offentlig i JUnit 4, mens Junit 5 tillader en testcase defineret uden adgangsmodifikatoren 'offentlig', da den som standard betragter 'ingen adgangsmodifikator' som 'offentlig'.

Grundlæggende JUNIT-testeksempel

En grundlæggende JUNIT 4 eksempel til annoteringer @BeforeClass, @Before, @Test, @After og @AfterClass blev vist gennem koden med sin forklaring i vores tidligere tutorial om 'Test Fixtures'.

Lad os se på det grundlæggende JUnit 5 Program til at demonstrere, hvordan Lifecycle-tilbagekaldningsanmærkninger fungerer @BeforeAll, @BeforeEach, @Test, @AfterEach og @AfterAll.

Kode til JUnit5Program.java:

public class JUnit5Program { @BeforeAll public static void preClass() { System.out.println('@BeforeAll – the annotated method runs once before all other methods execute'); } @BeforeEach public void setUp() { System.out.println('_______________________________________________________ '); System.out.println('@BeforeEach – the annotated method executes before each test '); } @Test public void test_JUnit1() { System.out.println('@Test – this is test case 1'); } @Test public void test_JUnit2() { System.out.println('@Test – this is test case 2'); } @Test public void test_JUnit3() { System.out.println('@Test – this is test case 3'); } @AfterEach public void tearDown() { System.out.println('@AfterEach – the annotated method executes after each test executes'); System.out.println('_______________________________________________________ '); } @AfterAll public static void postClass() { System.out.println('@AfterAll – the annotated method runs once after all other methods execute'); } }

Ved udførelse af klassefilen vises nedenstående resultat i konsolvinduet.

Konsolvindue

Yderligere kommentarer - JUnit 4 vs JUnit 5

Der er mange yderligere kommentarer, der bruges til bestemte formål. Vi vil se listen over kommentarer til JUnit 4 vs JUnit 5 og det formål, den tjener i korte træk.

Der vil være en detaljeret vejledning om hver af disse kommentarer i vores kommende tutorials.

BEMÆRKNING JUNIT 4BEMÆRKNING JUNIT 5Kort beskrivelse
@FixMethodOrder@TestMethodOrder & @Order1. Disse kommentarer giver brugeren mulighed for at vælge rækkefølgen for udførelse af metoderne inden for en testklasse
@Rule & @ClassRule@ExtendWith1. @Rule - Annoteringen udvides fra klassen TestRule, der hjælper med at anvende bestemte regler i testsagerne.
2. For eksempel: Oprettelse af en midlertidig mappe før eksekvering af testtilfælde og sletning af mappen efter eksekvering kan indstilles gennem en regel.
3. @Rule er kun tilgængelig i JUnit 4, som kan bruges i JUnit 5 Vintage, men @ExtendWith giver en nærmere funktion til JUnit 5
4. Tilsvarende kan en global timeout indstilles ved hjælp af @Rule.
NA@TestFabrik1. Denne kommentar understøttes kun af JUnit 5 og hjælper med at oprette dynamiske eller runtime-tests.
2. Den returnerer en datastrøm som indsamling og kan ikke bruge tilbagekaldelseskommentarer i livscyklus
NA@ Nestet1. Denne kommentar understøttes kun af JUnit Jupiter
2.Det hjælper os med at oprette indlejrede testsager.
3. For eksempel kan klasse 1 med testcase 1 have en @ nestet klasse 2 med testcase 2. Dette gør testcase 2 til en indlejret testcase til testcase 1. Derfor udføres testcase 1 og derefter testcase 2 udføres.
4.Hvis @Nested-kommentaren ikke bruges, udføres den indlejrede klasse ikke.
@Kategori@Tag1. Denne kommentar hjælper med at tagge og filtrere testene
2.Du kan inkludere test til udførelse eller ekskludere dem ved at filtrere baseret på de kategorier, de falder i.
@RunWith (Parameterized.class)
@ Parameterized.Parameters		@ParameterizedTest og @ValueSource1. Denne kommentar bruges til at køre en metode med testdatavariationer flere gange.
2.JUnit 4 understøtter @RunWith og @Parameters, mens JUnit 5 Jupiter understøtter @ParameterizedTest med @ValueSource
@DisplayName1. Et brugerdefineret navn kan gives til en testmetode eller klasse til visningsformål.
@TestInstance (LifeCycle.PER_CLASS) og @TestInstance (LifeCycle.PER_METHOD)1. JUnit 5 understøtter konfigurationen af ​​testens livscyklus.
2. Både JUnit 4 og 5 følger standardopkaldet pr. Metode til livscyklus, mens konfiguration pr. Klasse også kan udføres.

Referencer => JUnit 4 , JUnit 5

Konklusion

  1. Vi lærte om livscyklusens tilbagekaldsanmærkninger og den sekventielle arbejdsgang, hvor testmetoderne udføres baseret på deres kommentarer.
  2. Vi lærte kommentarerne, der blev brugt til JUnit 4, og kommentarerne til JUnit 5.
  3. Vi lærte også om yderligere kommentarer, som JUnit 4 understøtter, og dem, der kun understøtter JUnit 5.

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

Anbefalet læsning

^