JUnit Casos de prueba @Before @BeforeClass Anotación

JUnit es la unidad más popular Pruebas marco en Java. Se recomienda explícitamente para Examen de la unidad. JUnit No requiere un servidor para probar una aplicación web, lo que agiliza el proceso de prueba.

El JUnit framework también permite la generación rápida y sencilla de casos de prueba y datos de prueba. El org.junit El paquete consta de muchas interfaces y clases para JUnit pruebas, como Test, Assert, After y Before. El más amplio JUnit La familia se construye sobre estos mismos pilares fundamentales.

¿Qué es un dispositivo de prueba?

Antes de comprender qué es un dispositivo de prueba, estudiemos el siguiente código.

Este código está diseñado para ejecutar dos casos de prueba en un archivo simple.

public class OutputFileTest {
    private File output; 
    output = new File(...);
    output.delete(); 
public void testFile1(){
        //Code to verify Test Case 1
}
    output.delete();
    output = new File(...);
public void testFile2(){
        //Code to verify Test Case 2
}
 output.delete(); 
}

Algunos problemas aquí

• El código no es legible.
• El código no es fácil de mantener.
• Cuando el conjunto de pruebas es complejo, el código podría contener problemas lógicos.

Compara el mismo código usando JUnit.

public class OutputFileTest		
{
    private File output; 
    @Before public void createOutputFile() 
    { 
       output = new File(...);
    }
  
	@After public void deleteOutputFile() 
    {
        output.delete(); 
    } 
     
    @Test public void testFile1() 
    {
       // code for test case objective
    } 
	@Test public void testFile2() 
    {
       // code for test case objective
    }
}

El código es mucho más legible y mantenible. La estructura de código anterior es una dispositivo de prueba.

Un dispositivo de prueba es un contexto donde un JUnit Caso de prueba carreras. Normalmente, los accesorios de prueba incluyen:

• Objetos o recursos que están disponibles para cualquier caso de prueba.
• Actividades necesarias para que estos objetos y recursos estén disponibles.
• Estas actividades son
  1. asignaciónConfigure)
  2. desasignación (desmontaje).

Configuración y desmontaje

Los accesorios importan porque JUnit Estos ganchos se utilizan en cada prueba.

• Por lo general, hay algunas tareas repetidas que deben realizarse antes de cada caso de prueba. Ejemplo: crear una conexión de base de datos.
• Asimismo, al final de cada caso de prueba, puede haber algunas tareas repetidas. Ejemplo: para limpiar una vez finalizada la ejecución de la prueba.
• JUnit Proporciona anotaciones que facilitan la configuración y el desmontaje. Garantiza que se liberen los recursos y que el sistema de pruebas esté listo para el siguiente caso de prueba.

Estos JUnit Las anotaciones se analizan a continuación.

Configuración

@Antes anotación en JUnit se utiliza en un método que contiene Java código que se ejecuta antes de cada caso de prueba, es decir, se ejecuta antes de cada ejecución de prueba.

Desmontaje (independientemente del veredicto)

@Después La anotación se utiliza en un método que contiene Java Código que se ejecutará después de cada caso de prueba. Estos métodos se ejecutarán incluso si se produce alguna excepción en el caso de prueba o en caso de fallos en las aserciones.

Nota:

• Se permite tener cualquier número de anotaciones enumeradas anteriormente.
• Todos los métodos anotados con @Antes in JUnit se ejecutarán antes de cada caso de prueba, pero pueden ejecutarse en cualquier orden.
• Puedes heredar los métodos @Before y @After de una superclase. La ejecución es la siguiente, y es un proceso de ejecución estándar en JUnit.

1. Ejecute el JUnit @Before métodos en la superclase
2. Ejecute los métodos @Before en esta clase.
3. Ejecutar un método @Test en esta clase
4. Ejecute los métodos @After en esta clase
5. Ejecute los métodos @After en la superclase

JUnit Nota 5: estas anotaciones son JUnit 4 (org.junit). JUnit 5 los renombraron en org.junit.jupiter.api, y JUnit El código 4 que aparece a continuación todavía funciona con el motor antiguo.

Ejemplo: Creación de una clase con un archivo como conjunto de pruebas.

public class OutputFileTest		
{
    private File output; 
    @Before	public void createOutputFile() 
    { 
       output = new File(...);
    }
  
	@After public void deleteOutputFile() 
    {
        output.delete(); 
    } 
     
    @Test public void testFile1() 
    {
       // code for test case objective
    } 
	@Test public void testFile2() 
    {
       // code for test case objective
    }
}

En el ejemplo anterior, la cadena de ejecución será la siguiente. El diagrama traces un ciclo de creación-prueba-eliminación por método de prueba.

1. crear archivo de salida()
2. pruebaArchivo1()
3. eliminarArchivoSalida()
4. crear archivo de salida()
5. pruebaArchivo2()
6. eliminarArchivoSalida()

Suposición:

La función testFile1() se ejecuta antes que testFile2(), lo cual no está garantizado.

Configuración única

• Es posible ejecutar un método sólo una vez para toda la clase de prueba antes de ejecutar cualquiera de las pruebas y antes de cualquier @Antes métodos).
• La configuración inicial es útil para arrancar servidores, abrir comunicaciones y tareas similares. Cerrar y volver a abrir los recursos para cada prueba consume mucho tiempo.
• Esto se puede hacer usando la anotación. @Antes de clase in JUnit.

@BeforeClass public static void Method_Name() {	
    // class setup code here	
 }	

El método debe ser vacío estático público, porque JUnit La llama antes de que exista cualquier instancia de prueba.

Derribar una sola vez

• De forma similar a la configuración única, también está disponible un método de limpieza única. Se ejecuta después de todos los métodos de casos de prueba y @Después Se han ejecutado las anotaciones.
• Es útil para detenerping servidores y cierre de enlaces de comunicación.
• Esto se puede hacer usando el @Después de clases anotación.

 @AfterClass public static void Method_Name()	
 {	
    // class cleanup code here	
 }	

JUnit Suites de prueba

Una vez establecidos los equipos, las clases de prueba relacionadas suelen agruparse y lanzarse juntas.

Si queremos ejecutar varias pruebas en un orden específico, podemos hacerlo combinando todas las pruebas en un solo lugar. Este lugar se llama conjunto de pruebas. Más detalles sobre cómo ejecutar conjuntos de pruebas y cómo se utilizan en JUnit están cubiertos en este tutoriales.

JUnit Ejecutor de pruebas

JUnit proporciona una herramienta para la ejecución de sus casos de prueba.

• JUnitNuestras La clase se utiliza para ejecutar estas pruebas.
• Un método llamado ejecutar clases proporcionada por org.junit.runner.JUnitNuestras se utiliza para ejecutar una o varias clases de prueba.
• El tipo de retorno de este método es el Resultado objetoorg.junit.runner.Result), que se utiliza para acceder a información sobre las pruebas. Consulte el siguiente ejemplo de código para mayor claridad.

public class Test {				
			public static void main(String[] args) {									
       		Result result = JUnitCore.runClasses(CreateAndSetName.class);					
			for (Failure failure : result.getFailures()) {							
         		System.out.println(failure.toString());					
      }		
      System.out.println(result.wasSuccessful());					
   }		
}      

En el código anterior, el objeto “resultado” se procesa para obtener los resultados de fallos y éxitos de los casos de prueba que estamos ejecutando. Ayudantes como asertEquals plantear esos fracasos, mientras @Ignorar Se salta una prueba.

JUnit Nota 5: JUnitNuestras son los JUnit 4 corredores. JUnit 5 lo reemplaza con el JUnit Plataforma lanzador API, normalmente iniciada por el IDE, Gradle o Maven Surefire.

Nombre JUnit Programa

Conocimientos aceptables del ciclo de vida del desarrollo de software (SDLC). Java programación y los fundamentos de la pruebas de software El proceso ayuda a comprender un JUnit programa, al igual que saber cómo pruebas unitarias difieren de las pruebas de integración.

Vamos a entender las pruebas unitarias usando un ejemplo práctico. Necesitamos crear una clase de prueba con un método de prueba anotado con @Prueba como se indica a continuación:

MiPruebaPrimeraClase.java

package guru99.JUnit;		

import static org.junit.Assert.*;				

import org.junit.Test;		

public class MyFirstClassTest {				

    @Test		
    public void myFirstMethod(){					
        String str= "JUnit is working fine";					
        assertEquals("JUnit is working fine",str);					
    }
}		

PruebaRunner.java

Para ejecutar nuestro método de prueba (arriba), necesitamos crear un ejecutor de pruebas. En el ejecutor de pruebas tenemos que agregar la clase de prueba como un parámetro en JUnitMétodo runClasses() de Core. Devuelve el resultado de la prueba, según si la prueba se supera o no.

Para obtener más detalles al respecto, consulte el código a continuación:

package guru99.JUnit;		

import org.junit.runner.JUnitCore;		
import org.junit.runner.Result;		
import org.junit.runner.notification.Failure;		

public class TestRunner {				
			public static void main(String[] args) {									
            Result result = JUnitCore.runClasses(MyFirstClassTest.class);					
			for (Failure failure : result.getFailures()) {							
              System.out.println(failure.toString());					
      }		
      System.out.println("Result=="+result.wasSuccessful());							
   }		
}      	

Resultado

En el momento que todos los DARWINs coticen incluyendo los deslizamientos PruebaRunner.java Al ejecutar nuestros métodos de prueba, obtenemos como resultado un fallo o un éxito. A continuación, encontrará la explicación del resultado:

1. En este ejemplo, después de ejecutar MiPruebaPrimeraClase.javaLa prueba se ha superado y el resultado está en verde.
2. Si hubiera fallado, habría mostrado el resultado en rojo, y el fallo se puede observar en el fallo. trace. Ver el JUnit Interfaz gráfica de usuario a continuación:

Preguntas Frecuentes