java - tutorial - pruebas unitarias

Prueba de múltiples excepciones con anotaciones JUnit 4

Question

¿Es posible probar múltiples excepciones en una sola prueba de unidad JUnit? Sé que por una sola excepción se puede usar, por ejemplo

    @Test(expected=IllegalStateException.class)

Ahora, si quiero probar otra excepción (por ejemplo, NullPointerException), ¿se puede hacer esto en la misma anotación, una anotación diferente o necesito escribir otra prueba de unidad completamente?

Answer 1

¿Cómo esperas que las "esperadas" funcionen? Un método solo puede lanzar una excepción.

Tendría que escribir una prueba de unidad diferente para cada forma en que el método puede fallar. Entonces, si el método arroja legítimamente dos excepciones, entonces necesita configurar dos pruebas para forzar el método de lanzar cada excepción.

Answer 2

Aunque esto no es posible con JUnit 4, es posible si cambia a TestNG, que le permite escribir

@Test(expectedExceptions = {IllegalArgumentException.class, NullPointerException.class})

Answer 3

Esto no es posible con la anotación.

Con JUnit 4.7 puedes usar la nueva regla ExpectedException

public static class HasExpectedException {
    @Interceptor
    public ExpectedException thrown= new ExpectedException();

    @Test
    public void throwsNothing() {
    }

    @Test
    public void throwsNullPointerException() {
         thrown.expect(NullPointerException.class);
         throw new NullPointerException();
    }

    @Test
    public void throwsNullPointerExceptionWithMessage() {
        thrown.expect(NullPointerException.class);
        thrown.expectMessage("happened?");
        throw new NullPointerException("What happened?");
    }
}

Más ver

• JUnit 4.7: Interceptores: excepciones esperadas
• Reglas en JUnit 4.7

Si no es posible actualizar a JUnit 4.7, tiene que escribir una prueba de unidad desnuda del formulario

public test() {
    try {
        methodCall(); // should throw Exception
        fail();
    }
    catch (Exception ex) {
        assert((ex instanceof A) || (ex instanceof B) || ...etc...);
        ...
    }

}

Answer 4

Mantenga las pruebas lo más simples y cortas posible. La intención de una prueba JUnit es probar solo una funcionalidad simple o una sola forma de falla.

De hecho, para estar seguro, debe crear al menos una prueba para cada forma de ejecución posible.

Normalmente, esto no siempre es posible porque si tiene un método que analiza una cadena, hay tantas combinaciones de cadenas posibles que no puede cubrir todo.

Manténlo corto y simple.

Puede tener 30-40 métodos de prueba para un solo método fácilmente ... ¿realmente importa?

Saludos

Answer 5

Realmente quieres que la prueba haga una cosa, y que haga una prueba para eso. Si no está seguro de qué excepción se va a lanzar, no me parece una buena prueba.

por ejemplo (en pseudocódigo)

try {
   badOperation();
   /// looks like we succeeded. Not good! Fail the test
   fail();
}
catch (ExpectedException e) {
   // that''s fine
}
catch (UnexpectedException e) {
   // that''s NOT fine. Fail the test
}

por lo tanto, si desea probar que su método arroja 2 excepciones diferentes (para 2 conjuntos de entradas), entonces necesitará 2 pruebas.

Answer 6

Utilice catch-exception :

// test 
public void testDo() {

   // obj.do(1) must throw either A or B
   catchException(obj).do(1);
   assert caughtException() instanceof A
       || caughtException() instanceof B;

   // obj.do(2) must throw A but not SubclassOfA
   catchException(obj).do(2);
   assert caughtException() instanceof A
       && !(caughtException() instanceof SubclassOfA);

}

Answer 7

@Test(expected=Exception.class)

Esto arrojará todas las excepciones posibles.