¿Cómo pruebo las excepciones en una prueba parametrizada?

Question

En JUnit4 puede escribir pruebas de unidades parametrizadas proporcionando la recopilación de parámetros en un método, que se pasará al constructor de la prueba y la prueba en otro método. Si tengo un parámetro para el cual espero una excepción, ¿cómo especifico eso?

Answer 1

if (parameter == EXCEPTION_EXPECTED) { 
    try { 
     method(parameter); 
     fail("didn't throw an exception!"); 
    } catch (ExpectedException ee) { 
     // Test succeded! 
    } 
} 

Answer 2

Si utilizó catch-exception en lugar de las anotaciones y las reglas de junit4 correspondientes, a continuación, el código se vería así:

catchException(obj).method(parameter); 

if (parameter != EXCEPTION_EXPECTED) { 
    assert caughtException() instanceof ExpectedException; 
} 
// more assertions 

Answer 3

A diferencia de lo que otros sugieren, yo no introducir ningún tipo de lógica para las pruebas, ¡incluso simples ifs!

Lo que debe tener son dos métodos de prueba:

• primera tiene parámetros válidos (y espera que parte de la producción)
• segundas tomas parámetros no válidos (y espera excepciones)

No está seguro si JUnit con su prueba parametrizada basada en el constructor puede hacerlo. Probablemente tendrías que crear dos clases de prueba para esto. Vaya con JUnit Params o TestNG que ofrecen una solución mucho más conveniente.

Answer 4

Gabriel, mira la regla TestWatcher (desde JUnit 4.9). Aquí está el código de ejemplo citado de http://junit-team.github.io/junit/javadoc/4.11/org/junit/rules/TestWatcher.html:

public static class WatchmanTest { 
    private static String watchedLog; 

    @Rule 
    public TestWatcher watchman= new TestWatcher() { 
     @Override 
     protected void failed(Throwable e, Description description) { 
      watchedLog+= description + "\n"; 
     } 

     @Override 
     protected void succeeded(Description description) { 
      watchedLog+= description + " " + "success!\n"; 
     } 
    }; 


    @Test 
    public void fails() { 
     fail(); 
    } 

    @Test 
    public void succeeds() { 
    } 
} 

Otro enfoque sería utilizar ErrorCollector de JUnit 4.7: @Rule ExpectedException pública lanzada = ExpectedException.none();

@Test 
public void testCollectingErrors() { 
    thrown.handleAssertionErrors(); 
    thrown.expect(MultipleFailureException.class); // or #expectMessage()/#expectCause() 

    collector.checkThat("a", equalTo("b")); 
    //... 
} 

Answer 5

así es como yo uso la prueba junit parametrizada con excepciones esperados:

@RunWith(Parameterized.class) 
public class CalcDivTest { 

@Parameter(0) 
public int num1; 
@Parameter(1) 
public int num2; 

@Parameter(2) 
public int expectedResult; 

@Parameter(3) 
public Class<? extends Exception> expectedException; 
@Parameter(4) 
public String expectedExceptionMsg; 

@Rule 
public ExpectedException thrown = ExpectedException.none(); 

@Parameters 
public static Iterable<Object[]> data() { 
    return Arrays.asList(new Object[][] { 
     // calculation scenarios: 
     { 120, 10, 12, null, null }, // simple div 
     { 120, 0, -1, ArithmeticException.class, "/ by zero" }, // div by zero   
    }); 

} 

@Test 
public void testDiv() throws CCalculationException { 

    //setup expected exception 
    if (expectedException != null) { 
     thrown.expect(expectedException); 
     thrown.expectMessage(expectedExceptionMsg); 
    } 

    assertEquals("calculation result is not as", expectedResult, div(num1, num2)); 

} 

private int div(int a, int b) { 
    return a/b; 
} 
}