Home-theater-designers
Cuando está escribiendo un conjunto de pruebas unitarias, puede haber algunas actividades no relacionadas con las pruebas que deba realizar. Estas actividades pueden tomar cualquier forma. Es posible que deba conectarse a una base de datos o recopilar recursos antes de realizar una prueba. Después de que se ejecute cada caso de prueba, es posible que deba liberar algunos recursos.
MAKEUSEOF VÍDEO DEL DÍA
Realizar cualquiera de estas actividades no relacionadas con la prueba fuera del alcance de una clase de prueba unitaria puede ser tedioso, si no imposible. La ejecución exitosa de su clase de prueba puede depender de estas actividades, por lo que JUnit proporciona dos pares de anotaciones para abordar este problema.
La anotación @BeforeAll
Una clase de prueba JUnit puede tener uno o más métodos de prueba. La anotación @BeforeAll indica que un método específico debe ejecutarse antes que todos los métodos de prueba en una clase de prueba. El método asociado con esta anotación solo se ejecuta una vez (al comienzo de la prueba), independientemente de la cantidad de métodos de prueba en la clase de prueba.
Cualquier método que use la anotación @BeforeAll debe seguir algunas estipulaciones. Estos métodos deben tener un tipo de retorno nulo, deben ser públicos y no deben ser privados. La anotación @BeforeAll es ideal para establecer una conexión a una base de datos o creando un nuevo archivo. Este artículo usa una clase de prueba de calculadora para mostrar cómo puede usar la anotación @BeforeAll.
La clase de 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 clase 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 esta clase, la anotación @BeforeAll funciona con el método powerOnCalculator(), que imprime 'La calculadora está encendida' antes de ejecutar cualquier prueba. La ejecución exitosa de la prueba imprime el siguiente informe de prueba:
Como puede ver, el método asociado con la anotación @BeforeAll no aparece en el informe de prueba. Sin embargo, si hay un error en el método de anotación @BeforeAll, los resultados del informe de prueba lo indicarán como un error.
La anotación @BeforeEach
Al igual que el método anotado @BeforeAll, el método anotado @BeforeEach no aparecerá en el informe de prueba. El método anotado @BeforeEach se ejecuta antes de cada método de prueba en una clase de prueba. Entonces, si una clase de prueba contiene dos métodos de prueba, la anotación @BeforeEach se ejecutará dos veces.
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));
}
}
Agregar la anotación @BeforeEach a la clase CalculatorTest produce el siguiente resultado:
El método asociado con la anotación @BeforeEach se ejecuta cuatro veces, una vez antes de cada método de prueba. Debe tener en cuenta que el método @BeforeEach no es estático, tiene un tipo de retorno nulo y no es privado, ya que estas son estipulaciones obligatorias. También es importante tener en cuenta que el método asociado con la anotación @BeforeEach se ejecuta después del método @BeforeAll.
La anotación @AfterAll
Un método con la anotación @AfterAll se ejecutará después de que todos los métodos de prueba en la clase de prueba completen su ejecución. La anotación @AfterAll es ideal para operaciones basicas de archivos , como cerrar un archivo o desconectarse de una base de datos. La anotación @AfterAll es la contraparte de la anotación @BeforeAll. Al igual que la anotación @BeforeAll, la anotación @AfterAll debe ser estática, debe devolverse nula y no ser privada.
@AfterAll
public static void powerOffCalculator() {
System.out.println("The calculator is off");
}Agregar el método anotado @AfterAll a la clase CalculatorTest existente imprime el siguiente resultado en la consola:
alguien me bloqueó en facebook, ¿cómo puedo ver su perfil?
Tenga en cuenta que el método powerOffCalculator(), que usa la anotación @AfterAll, se imprime al final de la clase de prueba, después de que se ejecutan todos los métodos de prueba.
La anotación @AfterEach
La anotación @AfterEach es la contraparte de la anotación @BeforeEach. Tienen las mismas estipulaciones obligatorias, que son ligeramente diferentes a las de las anotaciones @BeforeAll y @AfterAll. Lo que distingue a la anotación @AfterEach de la anotación @BeforeEach (aparte de sus nombres) es que el método @AfterEach se ejecuta después de cada método de prueba.
@AfterEach
public void returnResults() {
System.out.println("The results are ready");
}Ejecutar la clase CalculatorTest imprime el siguiente resultado en la consola:
El resultado muestra que el método asociado con la anotación @AfterEach (returnResults) se imprime cuatro veces. Cada ejecución del método returnResults() solo ocurre después de la ejecución de cada prueba unitaria. Esto es evidente por el hecho de que la salida del método returnResults() aparece después de cada salida del método asociado con la anotación @BeforeEach.
Pula sus suites de prueba usando anotaciones
JUnit le permite manejar procesos no relacionados con pruebas utilizando las anotaciones de pares anteriores y posteriores. Estas cuatro anotaciones pertenecen a una lista de otras anotaciones que agregan valor a sus pruebas. Otra de las anotaciones de JUnit es @DisplayName.
Los dos ejemplos de código que muestran la clase CalculatorTest completa usan la anotación @DisplayName. La anotación @DisplayName lo ayuda a crear nombres más significativos para sus clases y métodos de prueba.