Saltar al contenido

Diferencia entre @Before, @BeforeClass, @BeforeEach y @BeforeAll

Sé libre de divulgar nuestros tutoriales y códigos en tus redes, ayúdanos a hacer crecer nuestra comunidad.

Solución:

El código marcado @Before se ejecuta antes de cada prueba, mientras que @BeforeClass se ejecuta una vez antes de todo el dispositivo de prueba. Si su clase de prueba tiene diez pruebas, @Before el código se ejecutará diez veces, pero @BeforeClass se ejecutará una sola vez.

En general, usas @BeforeClass cuando varias pruebas necesitan compartir el mismo código de configuración computacionalmente costoso. El establecimiento de una conexión de base de datos entra en esta categoría. Puede mover el código de @BeforeClass dentro @Before, pero la ejecución de la prueba puede tardar más. Tenga en cuenta que el código marcado @BeforeClass se ejecuta como static initializer, por lo tanto, se ejecutará antes de que se cree la instancia de clase de su accesorio de prueba.

En JUnit 5, las etiquetas @BeforeEach y @BeforeAll son los equivalentes de @Before y @BeforeClass en JUnit 4. Sus nombres son un poco más indicativos de cuándo se ejecutan, interpretados libremente: ‘antes de cada prueba’ y ‘una vez antes de todas las pruebas’.

Las diferencias entre cada anotación son:

+-------------------------------------------------------------------------------------------------------+
¦                                       Feature                            ¦   Junit 4    ¦   Junit 5   ¦
¦--------------------------------------------------------------------------+--------------+-------------¦
¦ Execute before all test methods of the class are executed.               ¦ @BeforeClass ¦ @BeforeAll  ¦
¦ Used with static method.                                                 ¦              ¦             ¦
¦ For example, This method could contain some initialization code          ¦              ¦             ¦
¦-------------------------------------------------------------------------------------------------------¦
¦ Execute after all test methods in the current class.                     ¦ @AfterClass  ¦ @AfterAll   ¦
¦ Used with static method.                                                 ¦              ¦             ¦
¦ For example, This method could contain some cleanup code.                ¦              ¦             ¦
¦-------------------------------------------------------------------------------------------------------¦
¦ Execute before each test method.                                         ¦ @Before      ¦ @BeforeEach ¦
¦ Used with non-static method.                                             ¦              ¦             ¦
¦ For example, to reinitialize some class attributes used by the methods.  ¦              ¦             ¦
¦-------------------------------------------------------------------------------------------------------¦
¦ Execute after each test method.                                          ¦ @After       ¦ @AfterEach  ¦
¦ Used with non-static method.                                             ¦              ¦             ¦
¦ For example, to roll back database modifications.                        ¦              ¦             ¦
+-------------------------------------------------------------------------------------------------------+

La mayoría de las anotaciones en ambas versiones son iguales, pero pocas difieren.

Referencia

Orden de ejecución.

Cuadro punteado -> anotación opcional.

ingrese la descripción de la imagen aquí

Before y BeforeClass en JUnit

La función @Before La anotación se ejecutará antes de cada función de prueba en la clase que tenga @Test anotación pero la función con @BeforeClass se ejecutará solo una vez antes de todas las funciones de prueba en la clase.

Del mismo modo funciona con @After La anotación se ejecutará después de cada función de prueba en la clase que tenga @Test anotación pero la función con @AfterClass se ejecutará solo una vez después de todas las funciones de prueba en la clase.

MuestraClase

public class SampleClass 
    public String initializeData()
        return "Initialize";
    

    public String processDate()
        return "Process";
    
 

Prueba de muestra

public class SampleTest 

    private SampleClass sampleClass;

    @BeforeClass
    public static void beforeClassFunction()
        System.out.println("Before Class");
    

    @Before
    public void beforeFunction()
        sampleClass=new SampleClass();
        System.out.println("Before Function");
    

    @After
    public void afterFunction()
        System.out.println("After Function");
    

    @AfterClass
    public static void afterClassFunction()
        System.out.println("After Class");
    

    @Test
    public void initializeTest()
        Assert.assertEquals("Initailization check", "Initialize", sampleClass.initializeData() );
    

    @Test
    public void processTest()
        Assert.assertEquals("Process check", "Process", sampleClass.processDate() );
    


Producción

Before Class
Before Function
After Function
Before Function
After Function
After Class

En junio 5

@Before = @BeforeEach
@BeforeClass = @BeforeAll
@After = @AfterEach
@AfterClass = @AfterAll

Nos puedes añadir valor a nuestra información aportando tu veteranía en las explicaciones.

¡Haz clic para puntuar esta entrada!
(Votos: 0 Promedio: 0)



Utiliza Nuestro Buscador

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *