JUnit Prueba de excepción esperada: @Test (esperada)

JUnit proporciona la facilidad para tracy la excepción y también para comprobar si el código está generando la excepción esperada o no.

JUnit 4 proporciona una forma sencilla y legible de realizar pruebas de excepciones. Puede utilizar:

• El parámetro opcional (esperado) del Anotación @Test, y
• A tracy la información, se puede utilizar “fail()”.

Aunque las pruebas una excepción, debe asegurarse de que la clase de excepción que está proporcionando en ese parámetro opcional de la Anotación @Test es la misma que realmente lanza el método. Esto se debe a que esperas una excepción del método que estás examen de la unidad; de lo contrario nuestro JUnit la prueba fallaría.

Ejemplo: @Test(expected = IllegalArgumentException.class)

Al usar el parámetro “expected”, puede especificar el nombre de la excepción que nuestra prueba puede generar. En el ejemplo anterior, está usando “Argumento de excepción ilegal", que será lanzada por la prueba si un desarrollador utiliza un argumento que no está permitido.

Ejemplo usando @Test(expected)

Entendamos las pruebas de excepciones creando una Java clase con un método que lanza una excepción excepción. Lo manejarás y lo probarás en una clase de prueba. Considera JUnitEl archivo Message.java contiene un método que realiza una operación matemática. La división en la línea 14 divide por cero, por lo que el método siempre lanza una excepción "ArithmeticException". Véase a continuación:

package guru99.junit;

public class JUnitMessage{

	private String message;

	public JUnitMessage(String message) {
		this.message = message;
	}

public void printMessage(){

	System.out.println(message); 
	int divide=1/0;

}

public String printHiMessage(){ 

	message="Hi!" + message;
	
	System.out.println(message);

	return message;
}

}

Code Explicación:

• Code Línea 7: Creando un constructor parametrizado con inicialización de campo.
• Code Línea 11-14: Crear un método para la operación matemática.
• Code Línea 18: Creando otro método para imprimir un mensaje.
• Code Línea 20: Creando una nueva cadena para imprimir un mensaje.
• Code Línea 22: Imprimiendo el nuevo mensaje creado en la línea 20.

Vamos a crear una clase de prueba para lo anterior. Java clase para verificar la excepción.

A continuación se muestra la clase de prueba que realiza pruebas unitarias de la excepción (ArithmeticException en este caso) lanzada desde lo anterior. Java clase:

AirthematicTest.java

La captura de pantalla que aparece a continuación muestra la misma prueba en el editor, donde el archivo se guarda como AirthematicTest1, con el parámetro esperado resaltado en la línea 13:

package guru99.junit;

import static org.junit.Assert.assertEquals;

import org.junit.Test;

public class AirthematicTest {

	public String message = "Saurabh";
	
	JUnitMessage junitMessage = new JUnitMessage(message);
	
	@Test(expected = ArithmeticException.class)
	public void testJUnitMessage(){

		System.out.println("Junit Message is printing ");
		junitMessage.printMessage();

	}

	@Test
	public void testJUnitHiMessage(){ 
		message="Hi!" + message;
		System.out.println("Junit Message is printing ");
		assertEquals(message, junitMessage.printHiMessage());
	
	}
}

Code Explicación:

• Code Línea 13: Utilizamos la anotación @Test para crear nuestra prueba. Al ejecutar el método de la clase anterior, se invocará una operación matemática. En este caso, se espera una excepción ArithmeticException, por lo que la incluimos como parámetro en @Test.
• Code Línea 17: Invocando printMessage() desde JUnitMensaje.java.
• Code Línea 21-22: Creando otro método de prueba para verificar el mensaje "Hola", esta vez sin un parámetro esperado.

La clase contiene dos métodos de prueba, por lo que una sola ejecución ejecuta ambos: el que espera una ArithmeticException y el que realiza una comprobación sobre la cadena devuelta.

Nota: Este ejemplo aparece con tres nombres diferentes en el material original: en la lista se llama a la clase AirthematicTest, en la captura de pantalla del editor se muestra AirthematicTest1 y en la vista de resultados se indica JunitTestExample. El código es idéntico en todos los casos; solo difiere el nombre del archivo.

Vamos a ejecutarlo y verificar el resultado. El JUnit Ver a continuación informa sobre la carrera de Ejemplo de prueba Junit.java.

Salida:

Aquí está el resultado, que muestra una prueba exitosa sin fallos. trace como se indica a continuación:

Ambos métodos son verdes. El primero pasa porque la ArithmeticException que declaró sí llegó, y el segundo pasa porque la cadena devuelta coincidió. Si la división nunca se hubiera lanzado, JUnit El primer método habría fallado con el mensaje “Excepción esperada: java.lang.ArithmeticException”.

Tres maneras de probar una excepción en JUnit 4

El parámetro esperado es el más corto de los tres. JUnit 4 modismos, pero no siempre es el correcto. La tabla los compara en función de las dos preguntas que deciden la elección: ¿puedes afirmar sobre el mensaje? y ¿sabes qué línea lanzó?

La función fail() que se menciona en la introducción tiene este aspecto. Si la llamada no genera una excepción, fail() se ejecuta y la prueba informa del mensaje que escribiste:

@Test
public void testDivideByZero() {
    try {
        junitMessage.printMessage();
        fail("Expected an ArithmeticException");
    } catch (ArithmeticException e) {
        assertEquals("/ by zero", e.getMessage());
    }
}

La regla ExpectedException se sitúa entre las dos. Fue descontinuada en JUnit 4.13 a favor del método assertThrows que se describe a continuación, por lo que es nuevo JUnit 4 pruebas no deberían adoptarlo.

Cómo probar excepciones en JUnit 5 con assertThrows()

JUnit 5 elimina por completo el parámetro esperado de @Test. Jupiter proporciona asertThrows (), que recibe la clase de excepción y una función lambda que contiene el código que se está probando. Devuelve la excepción que capturó, de modo que el mensaje, la causa y cualquier campo personalizado se pueden verificar posteriormente.

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import org.junit.jupiter.api.Test;

public class AirthematicJupiterTest {

    JUnitMessage junitMessage = new JUnitMessage("Saurabh");

    @Test
    public void testJUnitMessage() {
        ArithmeticException thrown = assertThrows(
                ArithmeticException.class,
                () -> junitMessage.printMessage());
        assertEquals("/ by zero", thrown.getMessage());
    }
}

Tres relacionados afirmaciones Completar la familia:

• assertThrows acepta el tipo de excepción o cualquier subclase del mismo.
• assertThrowsExactamente Rechaza una subclase, por lo que solo pasa el tipo nombrado.
• assertDoesNotThrow Se afirma la expectativa opuesta, que el bloque se complete sin problemas.

El JUnit 4 códigos en esta página todavía se ejecutan en el JUnit La plataforma funciona mediante el motor clásico, por lo que no es necesario reescribir nada de lo anterior para que siga funcionando mientras un proyecto migra.

Errores comunes al probar excepciones en JUnit

Las pruebas de excepciones fallan de maneras fácilmente reconocibles. Cada fila indica el síntoma, la causa y la solución.

La última fila es la que suele confundir a la mayoría de la gente durante la migración, porque ambas anotaciones se llaman @Test y solo la importación las distingue. Keeping uno JUnit versión por caso de prueba Esta clase evita todo el problema.

Preguntas Frecuentes