¿Qué es mejor, o ExpectedException @test (esperado =

Question

tengo código donde puedo comprobar las excepciones en jUnit. Quiero saber cuál de las siguientes es una buena práctica jUnit?

Primera

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

@Test 
public void checkNullObject() throws CustomException { 
    exception.expect(CustomException.class); 
    MyClass myClass= null; 
    MyCustomClass.get(null); 
} 

Segunda

@Test(expected=CustomException.class) 
public void checkNullObject() throws CustomException { 
    MyClass myClass= null; 
    MyCustomClass.get(null);  
} 

EDIT: Tenga en cuenta que CustomException es una excepción personalizada sin marcar. (Aunque no tendrá ningún impacto en esta pregunta).

Answer 1

Depende de lo que quiera verificar en la excepción. Si todo lo que está haciendo es comprobar que la excepción se produce, a continuación, utilizando @Test(expected=...) es probablemente la manera más fácil:

@Test(expected=CustomException.class) 
public void checkNullObject() throws CustomException { 
    MyClass myClass= null; 
    MyCustomClass.get(null); 
} 

Sin embargo, el @Rule ExpectedException tiene muchas más opciones, incluido el control del mensaje, desde el javadoc :

// These tests all pass. 
public static class HasExpectedException { 
    @Rule 
    public ExpectedException thrown= ExpectedException.none(); 

    @Test 
    public void throwsNothing() { 
     // no exception expected, none thrown: passes. 
    } 

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

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

    @Test 
    public void throwsIllegalArgumentExceptionWithMessageAndCause() { 
     NullPointerException expectedCause = new NullPointerException(); 
     thrown.expect(IllegalArgumentException.class); 
     thrown.expectMessage("What"); 
     thrown.expectCause(is(expectedCause)); 
     throw new IllegalArgumentException("What happened?", cause); 
    } 
} 

Para que pueda verificar el mensaje, la causa original de la excepción. Para verificar el mensaje, puede usar los contadores, por lo que puede marcar startsWith() y similar.

Una razón para usar el estilo antiguo (Junit 3) throw/catch es si usted tiene requisitos específicos. No hay muchos de estos, pero puede suceder:

@Test 
public void testMe() { 
    try { 
     Integer.parseInt("foobar"); 
     fail("expected Exception here"); 
    } catch (Exception e) { 
     // OK 
    } 
} 

Answer 2

La segunda versión es definitivamente la manera estándar de hacerlo. La forma de la vieja escuela para hacerlo, antes de Junit 4 parecía:

try { 
    codeThatShouldThrowException(); 
    fail("should throw exception"); 
} catch (ExpectedException expected) { 
    //Expected 
} 

A veces es posible que desee volver a examinar esta manera, por ejemplo, si desea hacer valer algo sobre el mensaje en la excepción.