Meniu

Lista adnotărilor JUnit: JUnit 4 Vs JUnit 5

list junit annotations

Încercați Instrumentul Nostru Pentru Eliminarea Problemelor

Acest tutorial explică totul despre adnotările JUnit împreună cu o comparație a adnotărilor în JUnit 4 vs JUnit 5:

Am învățat diferitele moduri de a executa cazuri de testare JUnit și am văzut cum să creăm și să executăm o suită de testare în tutorialul nostru anterior.

În acest tutorial, vom cunoaște aspectul proeminent al JUnit, care se numește Adnotări. Începând de la JUnit 4, adnotările sunt la locul lor și fac JUnit foarte simplu, mai benefic și mult mai ușor de utilizat.

Adnotări este un API Java care permite JVM să recunoască tipul metodei definite în clasa de testare. Există „adnotări de apel înapoi pe cicluri de viață” care sunt utilizate frecvent.

=> Vizitați aici pentru a afla JUnit From Scratch.

Adnotări JUnit

Ce veți învăța:

Adnotări JUnit - JUnit 4 vs JUnit 5

O execuție a testului trece prin diferite etape ale ciclului de viață, după cum se arată mai jos:

  • Înainte de a începe un test, există anumite activități care trebuie efectuate la inițierea unei clase.
  • Anumite alte activități care trebuie efectuate înainte ca o probă să înceapă execuția.
  • Anumite activități care trebuie efectuate după executarea testului și
  • Anumite activități la sfârșitul executării tuturor testelor dintr-o clasă.

Pentru a se asigura că aceste activități sunt efectuate pe parcursul fiecărei etape a ciclului de viață Java, trebuie să existe anumite metode sau funcții definite de utilizator, denumite „ metode de apelare a ciclului de viață .

Comportamentul acestora metode de apelare a ciclului de viață este determinat de adnotări de revenire la ciclul de viață ' folosit în JUnit.

Exemplu: Să încercăm să o simplificăm și mai mult, raportând aceste metode de apelare și adnotări ale ciclului de viață la un exemplu de testarea unui automat de cafea.

  1. O metodă mașinăGata () care verifică dacă apa, laptele și boabele de cafea sunt disponibile înainte de pornirea mașinii ar putea fi necesare.
  2. O altă metodă startMachine () care pornește mașina, ar putea fi nevoie de o nouă ceașcă de hârtie nouă în mașină.
  3. O probă care verifică „ Apa fierbinte ()' opțiune.
  4. O altă probă care verifică „ Cappuccino ()' opțiune.
  5. O altă probă care verifică „ ExpressoCoffee ()' opțiune.
  6. O altă metodă „ arunca Cupa () ”Care aruncă cupele folosite în coș.
  7. O metodă la nivel de clasă „ throwTrashandSwitchOff () ”Aruncă lichid rezidual debordant din tavă în lighean și oprește mașina.

Deci, în exemplul de mai sus, iată cum urmează ciclul de viață al testului:

  • startMachine () va rula înainte de fiecare probă - Apa fierbinte (), Cappuccino () și ExpressoCoffee () aleargă.
  • Fiecare dintre aceste teste urmează, de asemenea, metoda arunca Cupa ().
  • Metodele mașinăGata () și throwTrashandSwitchOff () sunt metode la nivel de clasă care rulează o singură dată pentru o clasă. Metoda mașinăGata () rulează o dată în timp ce clasa inițiază execuția. Metoda throwTrashandSwitchOff () rulează o dată după executarea completă a tuturor cazurilor de testare.

Acum, se pune întrebarea, acestea sunt doar metode Java, apoi:

java 8 întrebări și răspunsuri la interviu
  1. Cum vom insista să ruleze JVM mașinăGata () o singură dată la nivelul clasei și throwTrashandSwitchOff () la sfârșitul execuției clasei?
  2. Cum îl vom face pe JVM să știe asta startMachine () și arunca Cupa () trebuie rulat înainte de a rula fiecare testcase și, după finalizarea fiecărei execuții testcase, respectiv?
  3. Cum putem face ca JVM să identifice că metodele Apa fierbinte (), Cappuccino () și ExpressoCoffee () trebuie testate cazurile de testare?

Răspuns: Singurul răspuns la întrebările de mai sus este că adnotările de callback ale ciclului de viață fac toată magia necesară.

(Deocamdată, să presupunem că creăm această clasă în JUnit 4)

Adnotările ciclului de viață - @BeforeClass, @AfterClass, @Before, @After, și @Test sunt răspunsurile reale la cele trei întrebări de mai sus. Suntem destul de siguri că, după citirea indicatoarelor de mai jos, veți fi clar cu adnotările de apel înapoi la ciclul de viață și cu fluxul de lucru al acestuia.

  • Adnotați metoda mașinăGata () cu @Înainte de curs iar JVM îl va face să ruleze o singură dată la începutul clasei.
  • Adnotați metoda arunca gunoi () cu @După clasa iar JVM îl va face să ruleze o dată la sfârșitul cursului.
  • Adnotați metoda startMachine () cu @Inainte de iar JVM îl va rula înainte ca fiecare testcase să ruleze.
  • Adnotați metoda arunca Cupa () cu @După iar JVM îl va executa după executarea fiecărui caz de testare.
  • Adnotați fiecare dintre aceste metode Apa fierbinte (), Cappuccino () și ExpressoCoffee () cu @Test iar JVM știe că acestea sunt cazurile de testare de bază pentru clasa JUnit de executat.

Să ne uităm rapid la Adnotări de apel înapoi în ciclul de viață JUnit pentru JUnit 4 și JUnit 5

ANOTAȚIE JUNIT 4ANOTAȚIE JUNIT 5
@RepeatedTest1. JUnit 5 acceptă executarea repetată a metodei de testare de un anumit număr de ori folosind adnotarea @RepeatedTest
@Inainte de@BeforeEach
@După@După fiecare
@Înainte de curs@BeforeAll
@După clasa@Dupa toate acestea
@Test@Test

Fluxul de lucru secvențial al adnotărilor ciclului de viață

Dat mai jos este fluxul de lucru secvențial al adnotărilor ciclului de viață pentru JUnit 4:

fluxul de lucru secvențial al adnotărilor ciclului de viață pentru JUnit 4

  1. Metoda adnotată cu @BeforeClass este executată o dată la începutul clasei.
  2. Metoda adnotată cu @Before se execută înainte ca Testcase 1 să înceapă.
  3. Metoda Testcase1 adnotată cu @Test este testcase din clasă.
  4. Metoda adnotată cu @After rulează după ce Testcase 1 finalizează execuția.
  5. Metoda adnotată cu @Before se execută înainte ca Testcase 2 să înceapă.
  6. Metoda Testcase2 adnotată cu @Test este testcase din clasă.
  7. Metoda adnotată cu @After rulează după ce Testcase 2 finalizează execuția.
  8. Metoda adnotată cu @AfterClass este executată o dată la sfârșitul clasei după ce ambele teste 1 și 2 sunt executate.

Fluxul de lucru secvențial al adnotărilor ciclului de viață pentru JUnit 5 este după cum urmează:

fluxul de lucru secvențial al adnotărilor ciclului de viață pentru JUnit 5

  1. Metoda adnotată cu @BeforeAll este executată o dată la începutul clasei.
  2. Metoda adnotată cu @BeforeEach se execută înainte de începerea Testcase 1.
  3. Metoda Testcase1 adnotată cu @Test este testcase din clasă.
  4. Metoda adnotată cu @AfterEach rulează după ce Testcase 1 finalizează execuția.
  5. Metoda adnotată cu @BeforeEach se execută înainte de începerea Testcase 2.
  6. Metoda Testcase2 adnotată cu @Test este testcase din clasă.
  7. Metoda adnotată cu @AfterEach rulează după ce Testcase 2 finalizează execuția.
  8. Metoda adnotată cu @AfterAll este executată o dată la sfârșitul clasei după ce ambele teste 1 și 2 sunt executate.

Elaborare la fiecare adnotare

În această secțiune, să ne scufundăm profund și să înțelegem detaliat ceea ce face fiecare dintre ciclurile de viață care fac apel la adnotare:

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

  • Metoda adnotată se execută înainte de executarea fiecărei metode de testare din clasa de testare.
  • Această adnotare poate fi utilizată atunci când doriți să configurați resursele sau datele de testare chiar înainte de inițierea fiecărui test.
  • De exemplu, dacă există 5 cazuri de testare într-o clasă de testare JUnit, atunci metoda adnotată cu @ Before / @ BeforeEach se execută de 5 ori înainte de fiecare execuție a cazului de testare.

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

  • Metoda adnotată se execută după fiecare metodă de testare din clasa de testare.
  • Această adnotare poate fi utilizată atunci când doriți să eliberați resursele folosite sau datele de testare după fiecare caz de testare.
  • De exemplu, dacă există 5 cazuri de testare într-o clasă de testare JUnit, atunci metoda adnotată cu @ After / @ AfterEach se execută de 5 ori după executarea cazurilor de testare.

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

  • Metoda adnotată se execută înainte de executarea tuturor metodelor de testare dintr-o clasă de testare.
  • Această adnotare poate fi utilizată atunci când doriți să configurați resurse sau să testați date la nivel de clasă.
  • Deoarece această metodă este adnotată cu @ BeforeClass / @ BeforeAll este executată o singură dată pentru o clasă de testare și copia metodei este partajată în întreaga clasă, iar metoda trebuie menționată static.
  • De exemplu, dacă există 5 cazuri de testare într-o clasă de test JUnit, atunci metoda adnotată cu @ BeforeClass / @ BeforeAll se execută o dată pe fiecare clasă de test înainte de inițierea oricărei teste.

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

  • Metoda adnotată se execută după executarea tuturor metodelor de testare dintr-o clasă de testare.
  • Această adnotare poate fi utilizată atunci când doriți să eliberați resursele utilizate sau să testați datele la nivel de clasă.
  • Deoarece această metodă este adnotată cu @ AfterClass / @ AfterAll este executată o singură dată pentru o clasă de testare și copia metodei este partajată în întreaga clasă, trebuie menționată metoda static.
  • De exemplu, dacă există 5 cazuri de testare într-o clasă de testare JUnit, atunci metoda adnotată cu @ AfterClass / @ AfterAll se execută o dată pe fiecare clasă de test, după executarea completă a tuturor cazurilor de testare.

@Test (JUnit 4 și JUnit 5):

  • Adnotarea @Test este obișnuită atât pentru JUnit 4, cât și pentru JUnit 5. Metodele adnotate reprezintă cazurile de testare din clasă.
  • Ar putea exista mai multe metode fiecare adnotate cu @Test într-o clasă JUnit. Aceasta implică faptul că o clasă poate avea mai multe cazuri de testare.
  • Există diferite atribute sau parametri de testat care dintre aceștia ar putea fi trecuți. Puteți adăuga o expirare forțată pentru un caz de testare sau puteți adăuga o excepție. Acest lucru va fi acoperit în detaliu într-un tutorial separat.
  • Metoda adnotată nu poate fi privată sau statică și nu poate returna nicio valoare.
  • Metoda @Test trebuie să fie declarată publică în JUnit 4, în timp ce Junit 5 permite o probă definită fără modificatorul de acces „public”, deoarece consideră „fără modificator de acces” ca „public” în mod implicit.

Exemplu de test de bază JUNIT

Un element de bază 4 IUNIE exemplu pentru adnotări @BeforeClass, @Before, @Test, @After și @AfterClass a fost afișat prin intermediul codului cu explicația sa în tutorialul nostru anterior despre „Test Fixtures”.

Să ne uităm la elementele de bază JUnitatea 5 Program pentru a demonstra funcționarea adnotărilor de apel invers ale ciclului de viață @BeforeAll, @BeforeEach, @Test, @AfterEach și @AfterAll.

Cod pentru 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'); } }

La executarea fișierului de clasă, rezultatul de mai jos apare în fereastra Consolei.

Fereastra consolei

Adnotări suplimentare - JUnit 4 vs JUnit 5

Există multe adnotări suplimentare care sunt utilizate în scopuri specifice. Vom vedea lista de adnotări pentru JUnit 4 vs JUnit 5 și scopul pe care îl servește pe scurt.

Vor exista un tutorial detaliat despre fiecare dintre aceste adnotări în tutorialele noastre viitoare.

ANOTAȚIE JUNIT 4ANOTAȚIE JUNIT 5Descriere pe scurt
@FixMethodOrder@TestMethodOrder & @Order1. Aceste adnotări permit utilizatorului să aleagă ordinea de execuție a metodelor în cadrul unei clase de testare
@Rule & @ClassRule@ExtendWith1. @Rule - Adnotarea este extinsă din clasa TestRule care ajută la aplicarea anumitor reguli în cazurile de testare.
2. De exemplu: crearea unui folder temporar înainte de testarea executării cazului și ștergerea folderului post-execuție poate fi setată printr-o regulă.
3. @Rule este disponibil numai în JUnit 4, care poate fi utilizat în JUnit 5 Vintage, cu toate acestea, @ExtendWith oferă o caracteristică mai apropiată pentru JUnit 5
4. În mod similar, un timeout global poate fi setat folosind @Rule.
N / A@TestFactory1. Această adnotare acceptată doar de JUnit 5 și ajută la crearea de teste dinamice sau de execuție.
2. Returnează un flux de date ca colecție și nu poate utiliza adnotări de apel de ciclu de viață
N / A@Cuibărit1. Această adnotare este acceptată doar de JUnit Jupiter
2. Ne ajută să creăm cazuri de test imbricate.
3. De exemplu, Clasa 1 cu testcase 1 ar putea avea un @Nested Class 2 cu testcase 2. Acest lucru face din testcase 2 o testă imbricată în testcase 1. Prin urmare, testcase 1 se execută, apoi testcase 2 se execută.
4. Dacă nu este utilizată adnotarea @Nested, clasa imbricată nu se va executa.
@Categorie@Etichetă1. Această adnotare ajută la etichetarea și filtrarea testelor
2. Puteți include teste de execuție sau le puteți exclude prin filtrare pe baza categoriilor în care se încadrează.
@RunWith (Parameterized.class)
@ Parametriți.Parametri		@ParameterizedTest și @ValueSource1. Această adnotare este utilizată pentru a rula o metodă cu variații ale datelor de test de mai multe ori.
2. JUnit 4 acceptă @RunWith și @Parameters în timp ce JUnit 5 Jupiter acceptă @ParameterizedTest cu @ValueSource
@Numele afisat1. Un nume definit de utilizator poate fi dat unei metode de testare sau unei clase în scopul afișării.
@TestInstance (LifeCycle.PER_CLASS) și @TestInstance (LifeCycle.PER_METHOD)1. JUnit 5 acceptă configurarea ciclului de viață al testelor.
2. Atât JUnit 4, cât și 5 urmează apelul implicit pe ciclu de viață al metodei, în timp ce se poate face și configurarea pe clasă.

Referințe => JUnitatea 4 , JUnitatea 5

Concluzie

  1. Am aflat despre adnotările de revenire la ciclul de viață și despre fluxul de lucru secvențial în care se execută metodele de testare pe baza adnotărilor lor.
  2. Am aflat adnotările folosite pentru JUnit 4 și adnotările pentru JUnit 5.
  3. De asemenea, am aflat despre adnotările suplimentare pe care JUnit 4 le acceptă și cele care acceptă numai JUnit 5.

=> Fii atent la seria de antrenament JUnit simplă aici.

Lectură recomandată

^