Meny

Lista över JUnit-kommentarer: JUnit 4 Vs JUnit 5

  • Huvud
  • Övrig
  • Lista över JUnit-kommentarer: JUnit 4 Vs JUnit 5

list junit annotations

Prova Vårt Instrument För Att Eliminera Problem

Denna handledning förklarar allt om JUnit-kommentarer tillsammans med en jämförelse av kommentarer i JUnit 4 vs JUnit 5:

Vi lärde oss de olika sätten att utföra JUnit-testfall och såg hur man skapar och kör en testsvit i vår tidigare handledning.

I denna handledning kommer vi att lära känna den framträdande aspekten av JUnit som kallas Kommentarer. Från och med JUnit 4 är anteckningar på plats och gör JUnit väldigt enkelt, mer fördelaktigt och mycket mer användarvänligt att använda.

Kommentarer är ett Java API som gör det möjligt för JVM att känna igen typen av metod som definierats i testklassen. Det finns ”livscykler som återkallar kommentarer” som ofta används.

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

JUnit-kommentarer

Vad du kommer att lära dig:

JUnit-kommentarer - JUnit 4 vs JUnit 5

Ett testutförande går igenom olika stadier av livscykeln enligt nedan:

  • Innan du påbörjar ett test, finns det vissa aktiviteter som ska utföras vid inledningen av en klass.
  • Vissa andra aktiviteter som ska utföras innan en testcase påbörjas.
  • Vissa aktiviteter som måste utföras efter genomförandet av testet och
  • Vissa aktiviteter i slutet av genomförandet av alla tester i en klass.

För att säkerställa att dessa aktiviteter utförs under varje steg i Java-livscykeln måste det finnas vissa användardefinierade metoder eller funktioner på plats som kallas ' återkallningsmetoder för livscykeln .

Dessa beteenden återkallningsmetoder för livscykeln bestäms av den inbyggda livscykel-återkommande kommentarer '' används i JUnit.

Exempel: Låt oss försöka göra det ännu enklare genom att relatera dessa återkallningsmetoder och kommentarer till livscykeln till ett exempel på testa en kaffeautomat.

  1. En metod machineReady () som kontrollerar om det finns vatten, mjölk och kaffebönor innan maskinen sätts på.
  2. En annan metod startMachine () som slår på maskinen och placerar en ny ny papperskopp i maskinen kan behövas.
  3. En testcase som kontrollerar Varmt vatten () ’Alternativ.
  4. En annan testkassa som kontrollerar Cappuccino () ’Alternativ.
  5. En annan testkassa som kontrollerar ExpressoCoffee () ’Alternativ.
  6. En annan metod “ throwCup () ”Som kastar de använda kopparna i soptunnan.
  7. En klassnivåmetod “ throwTrashandSwitchOff () ”Kastar överflödig spillvätska från brickan i handfatet och stänger av maskinen.

Så i exemplet ovan är här hur testets livscykel följer:

  • startMachine () körs före varje testcase - Varmt vatten (), Cappuccino () och ExpressoCoffee () körs.
  • Var och en av denna testcase följer också metoden throwCup ().
  • Metoderna machineReady () och throwTrashandSwitchOff () är klassnivåmetod som bara körs en gång för en klass. Metoden machineReady () körs en gång medan klassen initierar körning. Metoden throwTrashandSwitchOff () körs en gång efter att alla testfall har slutförts.

Nu uppstår frågan att dessa bara är Java-metoder, då:

DVD-kopieringsprogramvara för Windows 10
  1. Hur kommer vi att insistera på att JVM ska köra machineReady () bara en gång på klassnivå och throwTrashandSwitchOff () i slutet av klassens utförande?
  2. Hur ska vi få JVM att veta det startMachine () och throwCup () måste köras innan varje testcase körs och efter att varje testcase utförs, respektive?
  3. Hur kan vi få JVM att identifiera att metoderna Varmt vatten (), Cappuccino () och ExpressoCoffee () ska testfall köras?

Svar: Det enda svaret på ovanstående frågor är att återkommande anteckningar för livscykeln gör all nödvändig magi.

(Låt oss för närvarande anta att vi skapar den här klassen i JUnit 4)

Kommentarer om livscykeln - @BeforeClass, @AfterClass, @Before, @After, och @Testa är de verkliga svaren på ovanstående tre frågor. Vi är ganska säkra på att efter att ha läst nedanstående pekare blir du tydlig med livscykelens återkommande kommentarer och dess arbetsflöde.

  • Kommentera metoden machineReady () med @Innan lektionen och JVM kommer att få det att köras en gång under lekstart.
  • Kommentera metoden kasta sopor () med @Efter lektionen och JVM kommer att få det att springa en gång i slutet av klassen.
  • Kommentera metoden startMachine () med @Innan och JVM kommer att köra det innan varje testcase körs.
  • Kommentera metoden throwCup () med @Efter och JVM kommer att köra det efter genomförandet av varje testfall.
  • Kommentera var och en av dessa metoder Varmt vatten (), Cappuccino () och ExpressoCoffee () med @Testa och JVM vet att dessa är de viktigaste testfallet för att JUnit-klassen ska köras.

Låt oss snabbt ta en titt på JUnit livscykel återkallande kommentarer för JUnit 4 vs JUnit 5

ANMÄRKNING JUNIT 4ANMÄRKNING JUNIT 5
@RepeatedTest1.JUnit 5 stöder upprepad körning av testmetoden under ett visst antal gånger med @RepeatedTest-kommentar
@Innan@BeforeEach
@Efter@AfterEach
@Innan lektionen@BeforeAll
@Efter lektionen@Trots allt
@Testa@Testa

Sekventiellt arbetsflöde för livscykelanteckningarna

Nedan följer det sekventiella arbetsflödet för livscykelanteckningarna för JUnit 4:

sekventiellt arbetsflöde för livscykelanteckningarna för JUnit 4

  1. Metoden som antecknats med @BeforeClass körs en gång i början av klassen.
  2. Metoden som kommenteras med @Before körs innan Testcase 1 börjar.
  3. Metoden Testcase1 kommenterad med @Test är testcase i klassen.
  4. Metoden som kommenteras med @After körs efter att testcase 1 slutfört körningen.
  5. Metoden kommenterad med @Before körs innan Testcase 2 börjar.
  6. Metoden Testcase2 kommenterad med @Test är testcase i klassen.
  7. Metoden som antecknats med @After körs efter att Testcase 2 har slutfört körningen.
  8. Metoden som antecknats med @AfterClass körs en gång i slutet av klassen efter att både testkassa 1 och 2 har körts.

Det sekventiella arbetsflödet för livscykelanteckningarna för JUnit 5 är som följer:

sekventiellt arbetsflöde för livscykelanteckningarna för JUnit 5

  1. Metoden som antecknats med @BeforeAll körs en gång i början av klassen.
  2. Metoden kommenterad med @BeforeEach körs innan Testcase 1 börjar.
  3. Metoden Testcase1 kommenterad med @Test är testcase i klassen.
  4. Metoden som kommenteras med @AfterEach körs efter att testcase 1 slutfört körningen.
  5. Metoden kommenterad med @BeforeEach körs innan Testcase 2 börjar.
  6. Metoden Testcase2 kommenterad med @Test är testcase i klassen.
  7. Metoden som kommenteras med @AfterEach körs efter att Testcase 2 har slutfört körningen.
  8. Metoden som antecknats med @AfterAll körs en gång i slutet av klassen efter att både testcase 1 och 2 har körts.

Utarbetning av varje kommentar

I det här avsnittet, låt oss djupt dyka och ha en detaljerad förståelse för vad var och en av livscyklerna kallar tillbaka anteckningar gör:

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

  • Den antecknade metoden körs före körningen av varje testmetod i testklassen.
  • Denna kommentar kan användas när du vill att resurser eller testdata ska ställas in precis innan varje test startas.
  • Till exempel, om det finns 5 testcases i en JUnit-testklass så körs metoden med @ Before / @ BeforeEach 5 gånger före varje utförande av testfallet.

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

  • Den kommenterade metoden körs efter varje testmetod i testklassen körs.
  • Denna kommentar kan användas när du vill släppa använda resurser eller testdata efter varje testfall.
  • Till exempel, om det finns 5 testcases i en JUnit-testklass så kör metoden med @ After / @ AfterEach 5 gånger efter testfallets utförande.

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

  • Den antecknade metoden körs innan alla testmetoder i en testklass körs.
  • Denna kommentar kan användas när du vill ställa in resurser eller testdata på klassnivå.
  • Eftersom den här metoden antecknas med @ BeforeClass / @ BeforeAll körs endast en gång för en testklass och kopian av metoden delas över klassen, och metoden måste anges statisk.
  • Till exempel, om det finns 5 testcases i en JUnit-testklass så antecknas metoden med @ BeforeClass / @ BeforeAll en gång per testklass innan någon testcase initieras.

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

  • Den kommenterade metoden körs efter alla testmetoderna i en testklass körs.
  • Denna kommentar kan användas när du vill släppa de använda resurserna eller testdata på klassnivå.
  • Eftersom den här metoden antecknas med @ AfterClass / @ AfterAll körs endast en gång för en testklass och kopian av metoden delas över klassen, måste metoden anges statisk.
  • Till exempel, om det finns 5 testcases i en JUnit-testklass så förklaras metoden med @ AfterClass / @ AfterAll en gång per testklass efter att alla testfall har genomförts.

@Test (JUnit 4 & JUnit 5):

  • @Test-anteckningen är vanlig för JUnit 4 såväl som JUnit 5. De antecknade metoderna representerar testfall i klassen.
  • Det kan finnas flera metoder som antecknas med @Test i en JUnit-klass. Detta innebär att en klass kan ha flera testfall.
  • Det finns olika attribut eller parametrar för att testa vilka som kan skickas. Du kan lägga till en tvingad timeout för ett testfall eller lägga till ett undantag. Detta kommer att behandlas i detalj i en separat handledning.
  • Den antecknade metoden kan inte vara privat eller statisk och kan inte returnera något värde.
  • Metoden @Test måste deklareras som offentlig i JUnit 4 medan Junit 5 tillåter en testcase definierad utan åtkomstmodifieraren 'public' eftersom den som standard anser att 'no access modifier' är 'public'.

Grundläggande JUNIT-testexempel

En grundläggande JUNIT 4 exempel för anteckningar @BeforeClass, @Before, @Test, @After och @AfterClass visades genom koden med dess förklaring i vår tidigare handledning om 'Test Fixtures'.

Låt oss titta på det grundläggande JUnit 5 Program för att visa hur Lifecycle-återuppringningsanteckningarna fungerar @BeforeAll, @BeforeEach, @Test, @AfterEach och @AfterAll.

Kod för 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'); } }

Vid körning av klassfilen visas nedanstående resultat i konsolfönstret.

Konsolfönster

Ytterligare kommentarer - JUnit 4 vs JUnit 5

Det finns många ytterligare kommentarer som används för specifika ändamål. Vi kommer att se listan med anteckningar för JUnit 4 vs JUnit 5 och syftet med det kortfattat.

Det kommer att finnas en detaljerad handledning om var och en av dessa anteckningar i våra kommande handledning.

ANMÄRKNING JUNIT 4ANMÄRKNING JUNIT 5Beskrivning i korthet
@FixMethodOrder@TestMethodOrder & @Order1. Dessa anteckningar gör det möjligt för användaren att välja ordning på exekvering av metoderna inom en testklass
@Rule & @ClassRule@ExtendWith1. @Rule - Anteckningen utökas från klassen TestRule som hjälper till att tillämpa vissa regler i testfallet.
2. Till exempel: att skapa en tillfällig mapp innan testfallet utförs och ta bort mappen efter körning kan ställas in genom en regel.
3. @Rule är endast tillgängligt i JUnit 4 som kan användas i JUnit 5 Vintage, men @ExtendWith ger en närmare funktion för JUnit 5
4. På samma sätt kan en global timeout ställas in med @Rule.
NA@TestFactory1. Denna kommentar stöds endast av JUnit 5 och hjälper till att skapa dynamiska eller runtime-tester.
2. Den returnerar en dataflöde som insamling och kan inte använda återanmälningsannoteringar under livscykeln
NA@Nested1. Denna kommentar stöds endast av JUnit Jupiter
2.Det hjälper oss att skapa kapslade testfall.
3. Exempelvis kan klass 1 med testkassa 1 ha en @ nestad klass 2 med testkassa 2. Detta gör testkassa 2 till en kapslad testkassa till testkassett 1. Testkassa 1 körs och testkassa 2 körs.
4. Om @Nested-anteckningen inte används kommer den kapslade klassen inte att köras.
@Kategori@Märka1. Denna kommentar hjälper till att märka och filtrera testerna
2.Du kan inkludera test för körning eller utesluta dem genom att filtrera baserat på de kategorier de faller i.
@RunWith (Parameterized.class)
@ Parameterized.Parameters		@ParameterizedTest och @ValueSource1. Denna kommentar används för att köra en metod med testdatavariationer flera gånger.
2.JUnit 4 stöder @RunWith och @Parameters medan JUnit 5 Jupiter stöder @ParameterizedTest med @ValueSource
@DisplayName1. Ett användardefinierat namn kan ges till en testmetod eller klass för visningsändamål.
@TestInstance (LifeCycle.PER_CLASS) och @TestInstance (LifeCycle.PER_METHOD)1. JUnit 5 stöder konfigurationen av testcykelns livscykel.
2. Både JUnit 4 och 5 följer återuppringningsinställningen per metod livscykel medan konfiguration per klass också kan göras.

Referenser => JUnit 4 , JUnit 5

Slutsats

  1. Vi lärde oss om återkallningsannoteringar om livscykeln och det sekventiella arbetsflöde där testmetoderna körs baserat på deras anteckningar.
  2. Vi lärde oss anteckningarna som används för JUnit 4 och anteckningarna för JUnit 5.
  3. Vi lärde oss också om ytterligare kommentarer som JUnit 4 stöder och de som endast stöder JUnit 5.

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

Rekommenderad läsning

^