Menú

Llista d’anotacions de JUnit: JUnit 4 Vs JUnit 5

list junit annotations

Proveu El Nostre Instrument Per Eliminar Problemes

Aquest tutorial explica tot sobre les anotacions de JUnit juntament amb una comparació de les anotacions de JUnit 4 contra JUnit 5:

Hem après les diferents maneres d’executar casos de prova de JUnit i hem vist com crear i executar un conjunt de proves al nostre tutorial anterior.

En aquest tutorial, coneixerem l’aspecte destacat de JUnit que s’anomena Anotacions. A partir de JUnit 4, les anotacions estan al seu lloc i fan que JUnit sigui molt senzill, més beneficiós i molt més fàcil d'utilitzar.

Anotacions és una API Java que permet a JVM reconèixer el tipus de mètode definit a la classe de prova. Hi ha 'anotacions de trucada de cicles de vida' que s'utilitzen amb freqüència.

=> Visiteu aquí per aprendre JUnit From Scratch.

Anotacions JUnit

Què aprendreu:

Anotacions JUnit: JUnit 4 contra JUnit 5

Una execució de la prova passa per diferents etapes del cicle de vida tal com es mostra a continuació:

  • Abans de començar una prova, hi ha certes activitats a realitzar en la iniciació d’una classe.
  • Algunes altres activitats que s'han de realitzar abans que comenci l'execució d'una caixa de proves.
  • Algunes activitats que cal realitzar després de la realització de la prova i
  • Determinades activitats al final de l'execució de totes les proves d'una classe.

Per tal de comprovar que aquestes activitats es realitzen al llarg de cada etapa del cicle de vida de Java, cal que hi hagi determinats mètodes o funcions definits per l’usuari anomenats ' mètodes de devolució de trucades del cicle de vida .

El comportament d’aquests mètodes de devolució de trucades del cicle de vida ve determinat per la funció anotacions de devolució de trucada del cicle de vida ' utilitzat a JUnit.

Exemple: Intentem fer-ho encara més senzill relacionant aquests mètodes i anotacions de trucada de cicle de vida amb un exemple de provant una màquina expenedora de cafè.

  1. Un mètode màquina preparada () que comprova si hi ha aigua, llet i grans de cafè disponibles abans d’encendre la màquina.
  2. Un altre mètode startMachine () que engega la màquina i pot col·locar una tassa de paper nova a la màquina.
  3. Una prova que comprova el ‘ Aigua calenta () ’Opció.
  4. Una altra prova que comprova el ‘ Caputxí () ’Opció.
  5. Una altra prova que comprova el ‘ ExpressoCoffee () ’Opció.
  6. Un altre mètode ' throwCup () ”Que llença les tasses usades a la paperera.
  7. Un mètode a nivell de classe ' throwTrashandSwitchOff () ”Llença el líquid residual desbordant de la safata a la pica i apaga la màquina.

Per tant, a l’exemple anterior, aquí es mostra com segueix el cicle de vida de la prova:

  • startMachine () s'executarà abans de cada prova - Aigua calenta (), Caputxí () i ExpressoCoffee () carreres.
  • Cadascuna d'aquestes proves també segueix el mètode throwCup ().
  • Els mètodes màquina preparada () i throwTrashandSwitchOff () són un mètode de nivell de classe que només s'executa una vegada per a una classe. El mètode màquina preparada () s'executa una vegada mentre la classe inicia l'execució. El mètode throwTrashandSwitchOff () s'executa un cop finalitzada l'execució de tots els casos de prova.

Ara, sorgeix la pregunta que es tracta de simples mètodes Java, doncs:

configuració de l'eclipsi per a c ++
  1. Com insistirem en l'execució de JVM màquina preparada () només una vegada a nivell de classe i throwTrashandSwitchOff () al final de l'execució de la classe?
  2. Com farem que JVM ho sàpiga startMachine () i throwCup () s'ha d'executar abans d'executar cada prova i després de completar l'execució de cada prova, respectivament?
  3. Com podem fer que JVM identifiqui els mètodes Aigua calenta (), Caputxí () i ExpressoCoffee () s'han d'executar casos de prova?

Resposta: L'única resposta a les preguntes anteriors és que les anotacions de devolució de trucada del cicle de vida fan tota la màgia necessària.

(De moment, suposem que estem creant aquesta classe a JUnit 4)

Les anotacions del cicle de vida - @BeforeClass, @AfterClass, @Before, @After, i @Prova són les respostes reals a les tres preguntes anteriors. Estem força segurs que, després de llegir els consells següents, quedareu clar amb les anotacions de trucada de cicle de vida i el seu flux de treball.

  • Anoteu el mètode màquina preparada () amb @BeforeClass i JVM farà que s'executi una vegada durant l'inici de la classe.
  • Anoteu el mètode llençar Trash () amb @Després de classe i JVM farà que s'executi una vegada al final de la classe.
  • Anoteu el mètode startMachine () amb @Abans i JVM l'executarà abans que s'executi cada prova.
  • Anoteu el mètode throwCup () amb @Després i JVM l'executarà després de l'execució de cada cas de prova.
  • Anoteu cadascun d’aquests mètodes Aigua calenta (), Caputxí () i ExpressoCoffee () amb @Prova i JVM sap que aquests són els casos de prova bàsics per executar la classe JUnit.

Vegem ràpidament el Anotacions de trucada de cicle de vida de JUnit per a JUnit 4 i JUnit 5

ANOTACIÓ DE JUNIT 4ANOTACIÓ DE JUNIT 5
@RepeatedTest1. La Unitat 5 admet l'execució repetida del mètode de prova un cert nombre de vegades mitjançant l'anotació @RepeatedTest
@Abans@BeforeEach
@Després@AfterEach
@BeforeClass@BeforeAll
@Després de classe@Després de tot
@Prova@Prova

Flux de treball seqüencial de les anotacions del cicle de vida

A continuació es mostra el flux de treball seqüencial de les anotacions del cicle de vida de JUnit 4:

flux de treball seqüencial de les anotacions del cicle de vida de JUnit 4

  1. El mètode anotat amb @BeforeClass s’executa una vegada a l’inici de la classe.
  2. El mètode anotat amb @Before s'executa abans que comenci el Testcase 1.
  3. El mètode Testcase1 anotat amb @Test és el testcase de la classe.
  4. El mètode anotat amb @After s'executa després que Testcase 1 finalitzi l'execució.
  5. El mètode anotat amb @Before s'executa abans que comenci Testcase 2.
  6. El mètode Testcase2 anotat amb @Test és el testcase de la classe.
  7. El mètode anotat amb @After s'executa després que Testcase 2 finalitzi l'execució.
  8. El mètode anotat amb @AfterClass s’executa una vegada al final de la classe després d’executar els dos casos de prova 1 i 2.

El flux de treball seqüencial de les anotacions del cicle de vida de JUnit 5 és el següent:

flux de treball seqüencial de les anotacions del cicle de vida de JUnit 5

  1. El mètode anotat amb @BeforeAll s'executa una vegada a l'inici de la classe.
  2. El mètode anotat amb @BeforeEach s'executa abans que comenci el Testcase 1.
  3. El mètode Testcase1 anotat amb @Test és el testcase de la classe.
  4. El mètode anotat amb @AfterEach s’executa després que Testcase 1 finalitzi l’execució.
  5. El mètode anotat amb @BeforeEach s'executa abans que comenci Testcase 2.
  6. El mètode Testcase2 anotat amb @Test és el testcase de la classe.
  7. El mètode anotat amb @AfterEach s’executa després que Testcase 2 finalitzi l’execució.
  8. El mètode anotat amb @AfterAll s’executa una vegada al final de la classe després d’executar els dos casos de prova 1 i 2.

Elaboració de cada anotació

En aquesta secció, busquem profundament i comprenem detalladament el que fa cadascun dels cicles de vida que fan una anotació de tornada:

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

  • El mètode anotat s'executa abans de l'execució de cada mètode de prova a la classe de prova.
  • Aquesta anotació es pot utilitzar quan voleu configurar els recursos o les dades de prova just abans de l'inici de cada prova.
  • Per exemple, si hi ha 5 casos de proves en una classe de prova de JUnit, el mètode anotat amb @ Before / @ BeforeEach s’executa 5 vegades abans de l’execució de cada cas de prova.

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

  • El mètode anotat s'executa després de cada mètode de prova de la classe de prova.
  • Aquesta anotació es pot utilitzar quan es vulgui haver d'alliberar recursos usats o dades de prova després d'executar cada cas de prova.
  • Per exemple, si hi ha cinc casos de prova en una classe de prova de JUnit, el mètode anotat amb @ After / @ AfterEach s’executa 5 vegades després de l’execució dels casos de prova.

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

  • El mètode anotat s'executa abans que s'executin tots els mètodes de prova d'una classe de prova.
  • Aquesta anotació es pot utilitzar quan voleu configurar recursos o provar dades a nivell de classe.
  • Com que aquest mètode s’anota amb @ BeforeClass / @ BeforeAll només s’executa una vegada per a una classe de prova i la còpia del mètode es comparteix a tota la classe i s’ha d’indicar el mètode. estàtic.
  • Per exemple, si hi ha 5 casos de proves en una classe de prova de JUnit, el mètode anotat amb @ BeforeClass / @ BeforeAll s'executa una vegada per classe de prova abans que s'iniciï qualsevol cas de prova.

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

  • El mètode anotat s'executa després que s'executin tots els mètodes de prova d'una classe de prova.
  • Aquesta anotació es pot utilitzar quan vulgueu alliberar els recursos usats o provar les dades a nivell de classe.
  • Com que aquest mètode s’anota amb @ AfterClass / @ AfterAll només s’executa una vegada per a una classe de prova i la còpia del mètode es comparteix a tota la classe, s’ha d’indicar el mètode estàtic.
  • Per exemple, si hi ha cinc casos de prova en una classe de prova de JUnit, el mètode anotat amb @ AfterClass / @ AfterAll s'executa una vegada per classe de prova després de completar l'execució de tots els casos de prova.

@Test (JUnit 4 i JUnit 5):

  • L'anotació @Test és comuna per a JUnit 4 i JUnit 5. Els mètodes anotats representen els casos de prova de la classe.
  • Hi pot haver diversos mètodes anotats cadascun amb @Test en una classe JUnit. Això implica que una classe pot tenir diversos casos de prova.
  • Hi ha diferents atributs o paràmetres per provar quin es podria passar. Podeu afegir un temps d'espera forçat per a un cas de prova o afegir una excepció. Això es tractarà detalladament en un tutorial separat.
  • El mètode anotat no pot ser privat ni estàtic i no pot retornar cap valor.
  • El mètode @Test s’ha de declarar públic a JUnit 4, mentre que Junit 5 permet definir una caixa de proves sense el modificador d’accés ‘públic’, ja que considera que ‘no hi ha modificador d’accés’ com a ‘públic’ per defecte.

Exemple bàsic de prova de JUNIT

Un bàsic 4 DE JUNY per exemple, per a les anotacions @BeforeClass, @Before, @Test, @After i @AfterClass es va mostrar a través del codi amb la seva explicació al nostre tutorial anterior sobre 'Fixtures de prova'.

Vegem allò bàsic JUnitat 5 Programa per demostrar el funcionament de les anotacions de devolució de trucada del cicle de vida @BeforeAll, @BeforeEach, @Test, @AfterEach i @AfterAll.

Codi de 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'); } }

Quan s’executa el fitxer de classe, el resultat següent apareix a la finestra de la consola.

Finestra de la consola

Anotacions addicionals: JUnit 4 contra JUnit 5

Hi ha moltes anotacions addicionals que s’utilitzen amb finalitats específiques. Veurem la llista d’anotacions de JUnit 4 contra JUnit 5 i la finalitat que serveix en breu.

Hi haurà un tutorial detallat sobre cadascuna d’aquestes anotacions als nostres propers tutorials.

ANOTACIÓ DE JUNIT 4ANOTACIÓ DE JUNIT 5Descripció breu
@FixMethodOrder@TestMethodOrder i @Order1. Aquestes anotacions permeten a l'usuari triar l'ordre d'execució dels mètodes dins d'una classe de prova
@Rule i @ClassRule@ExtendWith1. @Rule: l'anotació s'amplia des de la classe TestRule que ajuda a aplicar certes regles als casos de prova.
2. Per exemple: crear una carpeta temporal abans de provar l'execució de casos i suprimir la carpeta després de l'execució es pot establir mitjançant una regla.
3. @Rule només està disponible a JUnit 4 que es pot utilitzar a JUnit 5 Vintage, però, @ExtendWith proporciona una funció més propera per a JUnit 5
4. De la mateixa manera, es pot establir un temps d'espera global mitjançant @Rule.
NA@TestFactory1. Aquesta anotació només és compatible amb JUnit 5 i ajuda a la creació de proves dinàmiques o d'execució.
2. Retorna un flux de dades com a recopilació i no pot fer servir anotacions de devolució de trucada del cicle de vida
NA@Anidat1. Aquesta anotació només és compatible amb JUnit Jupiter
2. Ens ajuda a crear casos de proves imbricats.
3. Per exemple, la classe 1 amb la prova 1 pot tenir un @ Nested Class 2 amb la prova 2. Això fa que la prova 2 sigui una prova anidada a la prova 1. Per tant, la prova 1 s’executa i la prova 2 s’executa.
4. Si no s’utilitza l’anotació @Nested, la classe imbricada no s’executarà.
@Categoria@Etiqueta1. Aquesta anotació ajuda a etiquetar i filtrar les proves
2. Podeu incloure proves d’execució o excloure-les filtrant-les en funció de les categories en què es trobin.
@RunWith (Parameterized.class)
@ Parameterized.Parameters		@ParameterizedTest i @ValueSource1. Aquesta anotació s'utilitza per executar un mètode amb variacions de dades de prova diverses vegades.
2. JUnit 4 admet @RunWith i @Parameters mentre que JUnit 5 Jupiter admet @ParameterizedTest amb @ValueSource
@DisplayName1. Es pot donar un nom definit per l'usuari a un mètode o classe de prova amb finalitats de visualització.
@TestInstance (LifeCycle.PER_CLASS) i @TestInstance (LifeCycle.PER_METHOD)1. La JUnit 5 admet la configuració del cicle de vida de les proves.
2. Tant la JUnit 4 com la 5 segueixen la trucada per defecte per mètode de cicle de vida, mentre que també es pot configurar per classe.

Referències => JUnitat 4 , JUnitat 5

Conclusió

  1. Vam conèixer les anotacions de devolució de trucades del cicle de vida i el flux de treball seqüencial en què s’executen els mètodes de prova en funció de les seves anotacions.
  2. Vam aprendre les anotacions utilitzades per a JUnit 4 i les anotacions per a JUnit 5.
  3. També vam aprendre sobre anotacions addicionals que JUnit 4 admet i aquelles que només admeten JUnit 5.

=> Mireu aquí les sèries de formació JUnit senzilles.

Lectura recomanada

^