Home-theater-designers
Quan esteu escrivint una sèrie de proves unitàries, és possible que hi hagi activitats que no estiguin relacionades amb la prova que hàgiu de realitzar. Aquestes activitats poden tenir qualsevol forma. És possible que hàgiu de connectar-vos a una base de dades o reunir recursos abans de realitzar una prova. Després d'executar cada cas de prova, és possible que hàgiu d'alliberar alguns recursos.
MAKEUSEO VÍDEO DEL DIA
Realitzar qualsevol d'aquestes activitats no relacionades amb la prova fora de l'àmbit d'una classe de prova unitària pot ser tediós, si no impossible. L'execució correcta de la vostra classe de prova pot dependre d'aquestes activitats, de manera que JUnit proporciona dos parells d'anotacions per solucionar aquest problema.
L'anotació @BeforeAll
Una classe de prova JUnit pot tenir un o més mètodes de prova. L'anotació @BeforeAll indica que un mètode específic s'ha d'executar abans que tots els mètodes de prova d'una classe de prova. El mètode associat amb aquesta anotació només s'executa una vegada (a l'inici de la prova), independentment del nombre de mètodes de prova de la classe de prova.
Qualsevol mètode que utilitzi l'anotació @BeforeAll ha de seguir unes quantes estipulacions. Aquests mètodes han de tenir un tipus de retorn nul, han de ser públics i no han de ser privats. L'anotació @BeforeAll és ideal per establir un connexió a una base de dades o creant un fitxer nou. Aquest article utilitza una classe de prova de calculadora per mostrar com podeu utilitzar l'anotació @BeforeAll.
La classe de la calculadora
package com.app;
public class Calculator {
public static int add(int num1, int num2) {
return num1 + num2;
}
public static int subtract(int num1, int num2) {
return num1 - num2;
}
public static int multiply(int num1, int num2) {
return num1 * num2;
}
public static int divide(int num1, int num2) {
return num1 / num2;
}
}La classe CalculatorTest
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.DisplayName;
@DisplayName("Test class demonstrating how to use the before and after annotations.")
class CalculatorTest {
@BeforeAll
public static void powerOnCalculator() {
System.out.println("The calculator is on");
}
@Test
@DisplayName("Testing method that adds two integer values.")
public void testAdd() {
assertEquals(7, Calculator.add(3, 4));
}
@Test
@DisplayName("Testing method that subtracts one integer value from another.")
public void testSubtract() {
assertEquals(6, Calculator.subtract(9, 3));
}
@Test
@DisplayName("Testing method that multiplies two integer values")
public void testMultiply() {
assertEquals(10, Calculator.multiply(5, 2));
}
@Test
@DisplayName("Testing method that divides one integer value by another")
public void testDivide() {
assertEquals(2, Calculator.divide(4, 2));
}
}En aquesta classe, l'anotació @BeforeAll funciona amb el mètode powerOnCalculator(), que imprimeix 'La calculadora està engegada' abans de qualsevol execució de prova. L'execució correcta de la prova imprimeix el següent informe de prova:
Com podeu veure, el mètode associat a l'anotació @BeforeAll no apareix a l'informe de prova. Tanmateix, si hi ha un error en el mètode d'anotació @BeforeAll, els resultats de l'informe de prova ho indicaran amb un error.
L'anotació @BeforeEach
Igual que el mètode anotat @BeforeAll, el mètode anotat @BeforeEach no apareixerà a l'informe de prova. El mètode anotat @BeforeEach s'executa abans de cada mètode de prova en una classe de prova. Per tant, si una classe de prova conté dos mètodes de prova, l'anotació @BeforeEach s'executarà dues vegades.
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@DisplayName("Test class demonstrating how to use the before and after annotations.")
class CalculatorTest {
@BeforeAll
public static void powerOnCalculator() {
System.out.println("The calculator is on");
}
@BeforeEach
public void clearCalculator() {
System.out.println("The calculator is ready");
}
@Test
@DisplayName("Testing method that adds two integer values.")
public void testAdd() {
assertEquals(7, Calculator.add(3, 4));
}
@Test
@DisplayName("Testing method that subtracts one integer value from another.")
public void testSubtract() {
assertEquals(6, Calculator.subtract(9, 3));
}
@Test
@DisplayName("Testing method that multiplies two integer values")
public void testMultiply() {
assertEquals(10, Calculator.multiply(5, 2));
}
@Test
@DisplayName("Testing method that divides one integer value by another")
public void testDivide() {
assertEquals(2, Calculator.divide(4, 2));
}
}
Afegir l'anotació @BeforeEach a la classe CalculatorTest produeix la següent sortida:
El mètode associat a l'anotació @BeforeEach s'executa quatre vegades, una vegada abans de cada mètode de prova. Heu de tenir en compte que el mètode @BeforeEach no és estàtic, té un tipus de retorn nul i no és privat, ja que són estipulacions obligatòries. També és important tenir en compte que el mètode associat a l'anotació @BeforeEach s'executa després del mètode @BeforeAll.
L'anotació @AfterAll
Un mètode amb l'anotació @AfterAll s'executarà després que tots els mètodes de prova de la classe de prova finalitzin la seva execució. L'anotació @AfterAll és ideal per a operacions bàsiques dels fitxers , com ara tancar un fitxer o desconnectar-se d'una base de dades. L'anotació @AfterAll és la contrapartida de l'anotació @BeforeAll. Igual que l'anotació @BeforeAll, l'anotació @AfterAll ha de ser estàtica, ha de retornar void i no ser privada.
@AfterAll
public static void powerOffCalculator() {
System.out.println("The calculator is off");
}Si s'afegeix el mètode anotat @AfterAll a la classe CalculatorTest existent, s'imprimeix la següent sortida a la consola:
Tingueu en compte que el mètode powerOffCalculator(), que utilitza l'anotació @AfterAll, s'imprimeix al final de la classe de prova, després d'executar tots els mètodes de prova.
L'anotació @AfterEach
L'anotació @AfterEach és la contrapartida de l'anotació @BeforeEach. Tenen les mateixes estipulacions obligatòries, que són lleugerament diferents de les de les anotacions @BeforeAll i @AfterAll. El que distingeix l'anotació @AfterEach de l'anotació @BeforeEach (a part dels seus noms) és que el mètode @AfterEach s'executa després de cada mètode de prova.
@AfterEach
public void returnResults() {
System.out.println("The results are ready");
}En executar la classe CalculatorTest s'imprimeix la següent sortida a la consola:
La sortida mostra que el mètode associat a l'anotació @AfterEach (returnResults) s'imprimeix quatre vegades. Cada execució del mètode returnResults() només es produeix després de l'execució de cada prova unitària. Això és evident pel fet que la sortida del mètode returnResults() apareix després de cada sortida del mètode associat a l'anotació @BeforeEach.
com fer un lloc web PHP
Poliu els vostres conjunts de proves amb anotacions
JUnit us permet gestionar processos no relacionats amb proves utilitzant les anotacions de parell abans i després. Aquestes quatre anotacions pertanyen a una llista de diverses altres anotacions que afegeixen valor a les vostres proves. Una altra de les anotacions de JUnit és @DisplayName.
Els dos exemples de codi que mostren la classe CalculatorTest completa utilitzen l'anotació @DisplayName. L'anotació @DisplayName us ajuda a crear noms més significatius per a les vostres classes de prova i mètodes de prova.