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 la aplicación web, lo que agiliza el proceso de prueba.

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 Prueba, Afirmar, Después, Antes, etc.

¿Qué es el dispositivo de prueba?

Antes de entender 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 fácil de mantener. La estructura del código anterior es una Accesorio 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 requeridas que hacen que estos objetos/recursos estén disponibles.
Estas actividades son
1. asignaciónConfigure)
2. desasignación (desmontaje).

Configuración y desmontaje

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 ayudan en la instalación y desmontaje. Garantiza que se liberen los recursos y que el sistema de prueba esté listo para el siguiente caso de prueba.

Estos JUnit Las anotaciones se analizan a continuación.

Preparar

@Antes anotación en JUnit se utiliza en un método que contiene Java código que se ejecutará 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 código Java para ejecutarse 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 el caso de errores de aserción.

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.
Puede heredar los métodos @Before y @After de una superclase. La ejecución es la siguiente: Es un proceso de ejecución estándar en JUnit.

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

Ejemplo: crear una clase con un archivo como dispositivo de prueba

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:

crear archivo de salida()
pruebaArchivo1()
eliminarArchivoSalida()
crear archivo de salida()
pruebaArchivo2()
eliminarArchivoSalida()

Suposició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 de una sola vez” es útil para iniciar servidores, abrir comunicaciones, etc. Cerrar y volver a abrir recursos para cada prueba lleva 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	
 }

Derribar una sola vez

Similar a la configuración de una sola vez, también está disponible un método de limpieza de una sola vez. Se ejecuta después de todos los métodos de casos de prueba y @Después Se han ejecutado las anotaciones.
Es útil para detener servidores, cerrar enlaces de comunicación, etc.
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

Si queremos ejecutar varias pruebas en un orden específico, podemos hacerlo combinando todas las pruebas en un solo lugar. Este lugar se denomina suite de pruebas. Más detalles sobre cómo ejecutar suites de pruebas y cómo se utilizan en JUnit será cubierto en este tutoriales.

Ejecutor de pruebas Junit

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

JUnitCore La clase se utiliza para ejecutar estas pruebas.
Un método llamado ejecutar clases proporcionada por org.junit.runner.JUnitCentro, 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. Vea 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 fallas y resultados exitosos de los casos de prueba que estamos ejecutando.

Nombre de pila JUnit programa

Conocimiento razonable de SDLC, programación Java y conceptos básicos de pruebas de software El proceso ayuda a comprender JUnit .

Entendamos las pruebas unitarias usando un ejemplo en vivo. 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 prueba. En el ejecutor de pruebas tenemos que agregar la clase de prueba como parámetro en JUnitMétodo runclasses() de Core. Devolverá el resultado de la prueba, en función de si la prueba se aprobó o no.

Para obtener más detalles sobre esto, 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());							
   }		
}

Salida

En el momento que todos los DARWINs coticen incluyendo los deslizamientos PruebaRunner.java ejecuta nuestros métodos de prueba y obtenemos un resultado como fallido o aprobado. Encuentre la siguiente explicación de salida:

En este ejemplo, después de ejecutar MiPruebaPrimeraClase.java , se pasa la prueba y el resultado está en verde.
Si hubiera fallado, debería haber mostrado el resultado en rojo y la falla se puede observar en el seguimiento de fallas. Vea abajo JUnit interfaz gráfica de usuario:

Resum

JUnit es un marco que admite varias anotaciones para identificar un método que contiene una prueba.
JUnit proporciona una anotación llamada @Prueba, que le dice al JUnit que el método public void en el que se utiliza pueda ejecutarse como un caso de prueba.
Un dispositivo de prueba es un contexto donde se ejecuta un caso de prueba.
Para ejecutar varias pruebas en un orden específico, se puede hacer combinando todas las pruebas en un solo lugar. Este lugar se llama salas de pruebas.
JUnit proporciona una herramienta para la ejecución de las pruebas donde podemos ejecutar nuestros casos de prueba denominados Test Runner.

Te podría gustar: