list junit annotations
Este tutorial explica todo sobre las anotaciones de JUnit junto con una comparación de anotaciones en JUnit 4 frente a JUnit 5:
Aprendimos las diferentes formas de ejecutar casos de prueba JUnit y vimos cómo crear y ejecutar un conjunto de pruebas en nuestro tutorial anterior.
En este tutorial, conoceremos el aspecto destacado de JUnit que se llama Anotaciones. A partir de JUnit 4, las anotaciones están en su lugar y hacen que JUnit sea muy simple, más beneficioso y mucho más fácil de usar.
Anotaciones es una API de Java que permite a JVM reconocer el tipo de método definido en la clase de prueba. Hay 'anotaciones de llamada de ciclo de vida' que se utilizan con frecuencia.
=> Visite aquí para aprender JUnit desde cero.
Lo que vas a aprender:
Anotaciones de JUnit - JUnit 4 vs JUnit 5
Una ejecución de prueba pasa por diferentes etapas del ciclo de vida como se indica a continuación:
- Antes de comenzar una prueba, hay ciertas actividades que se deben realizar al inicio de una clase.
- Algunas otras actividades que se realizarán antes de que comience la ejecución de un caso de prueba.
- Ciertas actividades que deben realizarse después de la ejecución de la prueba y
- Ciertas actividades al final de la ejecución de todas las pruebas en una clase.
Para asegurarse de que estas actividades se realizan a lo largo de cada etapa del ciclo de vida de Java, es necesario que existan ciertos métodos o funciones definidos por el usuario, denominados ' métodos de devolución de llamada del ciclo de vida .
El comportamiento de estos métodos de devolución de llamada del ciclo de vida está determinada por la función ' anotaciones de devolución de llamada del ciclo de vida ’ utilizado en JUnit.
Ejemplo: Intentemos hacerlo aún más simple relacionando estos métodos de devolución de llamada y anotaciones del ciclo de vida con un ejemplo de probando una máquina expendedora de café.
- Un método machineReady () que comprueba si hay agua, leche y granos de café disponibles antes de encender la máquina, podría ser necesario.
- Otro método startMachine () que enciende la máquina, es posible que se necesite un vaso de papel nuevo en la máquina.
- Un caso de prueba que comprueba el ' Agua Caliente ()' opción.
- Otro caso de prueba que comprueba el ' Capuchino ()' opción.
- Otro caso de prueba que comprueba el ' ExpressoCoffee ()' opción.
- Otro método ' throwCup () ”Que tira los vasos usados a la papelera.
- Un método a nivel de clase ' throwTrashandSwitchOff () ”Arroja el líquido residual de la bandeja al lavabo y apaga la máquina.
Entonces, en el ejemplo anterior, así es como sigue el ciclo de vida de la prueba:
- startMachine () se ejecutará antes de cada caso de prueba - Agua Caliente (), Capuchino () y ExpressoCoffee () carreras.
- Cada uno de estos casos de prueba también sigue el método throwCup ().
- Los métodos machineReady () y throwTrashandSwitchOff () son métodos de nivel de clase que se ejecutan solo una vez para una clase. El método machineReady () se ejecuta una vez mientras la clase inicia la ejecución. El método throwTrashandSwitchOff () se ejecuta una vez después de completar la ejecución de todos los casos de prueba.
Ahora, surge la pregunta de que estos son meros métodos de Java, entonces:
mejor sistema de punto de venta para ipad
- ¿Cómo insistiremos en que se ejecute JVM? machineReady () solo una vez a nivel de clase y throwTrashandSwitchOff () al final de la ejecución de la clase?
- ¿Cómo haremos que JVM sepa que startMachine () y throwCup () debe ejecutarse antes de ejecutar cada caso de prueba y después de completar la ejecución de cada caso de prueba, respectivamente?
- ¿Cómo podemos hacer que JVM identifique que los métodos Agua Caliente (), Capuchino () y ExpressoCoffee () ¿se ejecutarán los casos de prueba?
Respuesta: La única respuesta a las preguntas anteriores es que las anotaciones de devolución de llamada del ciclo de vida hacen toda la magia necesaria.
(Por ahora, supongamos que estamos creando esta clase en JUnit 4)
Las anotaciones del ciclo de vida: @BeforeClass, @AfterClass, @Before, @After, y @Prueba son las respuestas reales a las tres preguntas anteriores. Estamos bastante seguros de que después de leer los siguientes consejos, se aclarará con las anotaciones de devolución de llamada del ciclo de vida y su flujo de trabajo.
- Anotar el método machineReady () con @Antes de clase y JVM hará que se ejecute una vez durante el inicio de la clase.
- Anotar el método tirar basura () con @Después de clases y JVM hará que se ejecute una vez al final de la clase.
- Anotar el método startMachine () con @Antes y JVM lo ejecutará antes de que se ejecute cada caso de prueba.
- Anotar el método throwCup () con @Después y JVM lo ejecutará después de la ejecución de cada caso de prueba.
- Anote cada uno de estos métodos Agua Caliente (), Capuchino () y ExpressoCoffee () con @Prueba y JVM sabe que estos son los casos de prueba centrales para que se ejecute la clase JUnit.
Echemos un vistazo rápido a la Anotaciones de devolución de llamada del ciclo de vida de JUnit para JUnit 4 vs JUnit 5
ANOTACIÓN JUNIT 4 | ANOTACIÓN JUNIT 5 | |
---|---|---|
@RepetidoPrueba | 1.JUnit 5 admite la ejecución repetida del método de prueba durante un cierto número de veces utilizando la anotación @RepeatedTest | |
@Antes | @BeforeEach | |
@Después | @Después de cada | |
@Antes de clase | @Antes de todo | |
@Después de clases | @Después de todo | |
@Prueba | @Prueba |
Flujo de trabajo secuencial de las anotaciones del ciclo de vida
A continuación se muestra el flujo de trabajo secuencial de las anotaciones del ciclo de vida para JUnit 4:
- El método anotado con @BeforeClass se ejecuta una vez al comienzo de la clase.
- El método anotado con @Before se ejecuta antes de que comience el caso de prueba 1.
- El método Testcase1 anotado con @Test es el caso de prueba en la clase.
- El método anotado con @After se ejecuta después de que Testcase 1 completa la ejecución.
- El método anotado con @Before se ejecuta antes de que comience Testcase 2.
- El método Testcase2 anotado con @Test es el caso de prueba en la clase.
- El método anotado con @After se ejecuta después de que Testcase 2 completa la ejecución.
- El método anotado con @AfterClass se ejecuta una vez al final de la clase después de que se ejecuten los casos de prueba 1 y 2.
El flujo de trabajo secuencial de las anotaciones del ciclo de vida para JUnit 5 es el siguiente:
- El método anotado con @BeforeAll se ejecuta una vez al comienzo de la clase.
- El método anotado con @BeforeEach se ejecuta antes de que comience Testcase 1.
- El método Testcase1 anotado con @Test es el caso de prueba en la clase.
- El método anotado con @AfterEach se ejecuta después de que Testcase 1 completa la ejecución.
- El método anotado con @BeforeEach se ejecuta antes de que comience Testcase 2.
- El método Testcase2 anotado con @Test es el caso de prueba en la clase.
- El método anotado con @AfterEach se ejecuta después de que Testcase 2 completa la ejecución.
- El método anotado con @AfterAll se ejecuta una vez al final de la clase después de que se ejecuten los casos de prueba 1 y 2.
Elaboración de cada anotación
En esta sección, profundicemos y comprendamos en detalle lo que hace cada una de las anotaciones de devolución de llamada de los ciclos de vida:
@Before (JUnit 4) / @ BeforeEach (JUnit 5):
- El método anotado se ejecuta antes de la ejecución de cada método de prueba en la clase de prueba.
- Esta anotación se puede utilizar cuando desee tener los recursos o los datos de prueba configurados justo antes del inicio de cada prueba.
- Por ejemplo, si hay 5 casos de prueba en una clase de prueba JUnit, el método anotado con @ Before / @ BeforeEach se ejecuta 5 veces antes de la ejecución de cada caso de prueba.
@Después (JUnit 4) / @ AfterEach (JUnit 5):
- El método anotado se ejecuta después de que se ejecuta cada método de prueba en la clase de prueba.
- Esta anotación se puede utilizar cuando desee tener que liberar recursos usados o datos de prueba después de que se ejecute cada caso de prueba.
- Por ejemplo, si hay 5 casos de prueba en una clase de prueba JUnit, el método anotado con @ After / @ AfterEach se ejecuta 5 veces después de la ejecución de los casos de prueba.
@BeforeClass (JUnit 4) / @ BeforeAll (JUnit 5):
- El método anotado se ejecuta antes de que se ejecuten todos los métodos de prueba en una clase de prueba.
- Esta anotación se puede utilizar cuando desee configurar recursos o probar datos a nivel de clase.
- Como este método está anotado con @ BeforeClass / @ BeforeAll se ejecuta solo una vez para una clase de prueba y la copia del método se comparte en la clase, y el método debe indicarse estático.
- Por ejemplo, si hay 5 casos de prueba en una clase de prueba JUnit, el método anotado con @ BeforeClass / @ BeforeAll se ejecuta una vez por clase de prueba antes de que se inicie cualquier caso de prueba.
@AfterClass (JUnit 4) / @ AfterAll (JUnit 5):
- El método anotado se ejecuta después de que se ejecutan todos los métodos de prueba en una clase de prueba.
- Esta anotación se puede utilizar cuando desee liberar los recursos utilizados o los datos de prueba a nivel de clase.
- Como este método está anotado con @ AfterClass / @ AfterAll se ejecuta solo una vez para una clase de prueba y la copia del método se comparte en toda la clase, se debe indicar el método estático.
- Por ejemplo, si hay 5 casos de prueba en una clase de prueba JUnit, el método anotado con @ AfterClass / @ AfterAll se ejecuta una vez por clase de prueba después de que todos los casos de prueba completen la ejecución.
@Test (JUnit 4 y JUnit 5):
- La anotación @Test es común para JUnit 4 y JUnit 5. Los métodos anotados representan los casos de prueba en la clase.
- Podría haber varios métodos, cada uno anotado con @Test en una clase JUnit. Esto implica que una clase puede tener varios casos de prueba.
- Hay diferentes atributos o parámetros para probar cuál podría pasarse. Puede agregar un tiempo de espera forzado para un caso de prueba o agregar una excepción. Esto se cubrirá en detalle en un tutorial separado.
- El método anotado no puede ser privado o estático y no puede devolver ningún valor.
- El método @Test debe declararse como público en JUnit 4, mientras que Junit 5 permite un caso de prueba definido sin el modificador de acceso 'público', ya que considera 'sin modificador de acceso' como 'público' de forma predeterminada.
Ejemplo de prueba básica de JUNIT
Un basico JUNIT 4 El ejemplo de las anotaciones @BeforeClass, @Before, @Test, @After y @AfterClass se mostró a través del código con su explicación en nuestro tutorial anterior sobre 'Test Fixtures'.
Veamos lo básico JUnit 5 Programa para demostrar el funcionamiento de las anotaciones de devolución de llamada del ciclo de vida @BeforeAll, @BeforeEach, @Test, @AfterEach y @AfterAll.
Código para JUnit5Program.java:
|_+_|Al ejecutar el archivo de clase, el siguiente resultado se muestra en la ventana de la consola.
Anotaciones adicionales - JUnit 4 vs JUnit 5
Hay muchas anotaciones adicionales que se utilizan para fines específicos. Veremos brevemente la lista de anotaciones para JUnit 4 vs JUnit 5 y el propósito que sirve.
Habrá un tutorial detallado sobre cada una de estas anotaciones en nuestros próximos tutoriales.
ANOTACIÓN JUNIT 4 | ANOTACIÓN JUNIT 5 | Descripción breve |
---|---|---|
@FixMethodOrder | @TestMethodOrder y @Order | 1. Estas anotaciones permiten al usuario elegir el orden de ejecución de los métodos dentro de una clase de prueba. |
@Rule y @ClassRule | @ExtendWith | 1. @Rule: la anotación se extiende desde la clase TestRule que ayuda a aplicar ciertas reglas en los casos de prueba. 2. Por ejemplo: la creación de una carpeta temporal antes de la ejecución del caso de prueba y la eliminación de la carpeta después de la ejecución se pueden configurar mediante una regla. 3. @Rule está disponible solo en JUnit 4, que se puede usar en JUnit 5 Vintage, sin embargo, @ExtendWith proporciona una función más cercana para JUnit 5 4. De manera similar, se puede establecer un tiempo de espera global usando @Rule. |
N / A | @TestFactory | 1. Esta anotación solo es compatible con JUnit 5 y ayuda a la creación de pruebas dinámicas o en tiempo de ejecución. 2. Devuelve un flujo de datos como recopilación y no puede usar anotaciones de devolución de llamada del ciclo de vida. |
N / A | @Anidado | 1.Esta anotación solo es compatible con JUnit Jupiter 2. Nos ayuda a crear casos de prueba anidados. 3. Por ejemplo, la Clase 1 con el caso de prueba 1 podría tener una Clase 2 @ anidada con el caso de prueba 2. Esto hace que el caso de prueba 2 sea un caso de prueba anidado para el caso de prueba 1. Por lo tanto, el caso de prueba 1 se ejecuta, luego el caso de prueba 2 se ejecuta. 4.Si no se usa la anotación @Nested, la clase anidada no se ejecutará. |
@Categoría | @Etiqueta | 1.Esta anotación ayuda a etiquetar y filtrar las pruebas 2. Puede incluir pruebas para su ejecución o excluirlas mediante el filtrado según las categorías en las que se encuentran. |
@RunWith (clase parametrizada) @ Parameterized.Parameters | @ParameterizedTest y @ValueSource | 1. Esta anotación se utiliza para ejecutar un método con variaciones de datos de prueba varias veces. 2.JUnit 4 admite @RunWith y @Parameters mientras que JUnit 5 Jupiter admite @ParameterizedTest con @ValueSource |
@DisplayName | 1. Se puede dar un nombre definido por el usuario a un método o clase de prueba con fines de visualización. | |
@TestInstance (LifeCycle.PER_CLASS) y @TestInstance (LifeCycle.PER_METHOD) | 1. JUnit 5 admite la configuración del ciclo de vida de las pruebas. 2. Tanto JUnit 4 como 5 siguen la devolución de llamada predeterminada por ciclo de vida del método, mientras que también se puede realizar la configuración por clase. |
Referencias => JUnit 4 , JUnit 5
Conclusión
- Aprendimos sobre las anotaciones de devolución de llamada del ciclo de vida y el flujo de trabajo secuencial en el que se ejecutan los métodos de prueba en función de sus anotaciones.
- Aprendimos las anotaciones utilizadas para JUnit 4 y las anotaciones para JUnit 5.
- También aprendimos sobre las anotaciones adicionales que admite JUnit 4 y aquellas que solo admiten JUnit 5.
=> Mire aquí la serie de entrenamiento simple JUnit.
Lectura recomendada
- ¿Qué es un dispositivo de prueba JUnit? Tutorial con ejemplos de JUnit 4
- Pruebas JUnit: Cómo escribir casos de prueba JUnit con ejemplos
- Tutorial de JUnit para principiantes: ¿Qué son las pruebas de JUnit?
- Descargar, instalar y configurar JUnit en Eclipse
- Múltiples formas de ejecutar pruebas JUnit
- Introducción a JUnit Framework y su uso en Selenium Script - Tutorial de Selenium n. ° 11
- Lista encubierta para matriz y otras colecciones en Java
- Métodos de lista de Java: ordenar lista, contener, agregar lista, eliminar lista