java - tipos - test junit netbeans

Excepciones de prueba JUnit

Question

Esta pregunta ya tiene una respuesta aquí:

• ¿Cómo se afirma que se produce una cierta excepción en las pruebas JUnit 4? 30 respuestas

Soy realmente nuevo en Java.

Estoy ejecutando algunas pruebas JUnit en un constructor. El constructor es tal que si se le da una cadena vacía o nula para uno de sus parámetros, se supone que arroja una excepción.

Cuando pruebo este constructor en JUnit con un parámetro de cadena nulo o vacío, obtengo una barra roja, aunque estoy casi 100% seguro de que el método de constructor arroja una excepción cuando se le pasan dichos parámetros.

¿No debería haber una barra verde en JUnit si el método arroja una excepción de la forma en que se supone? ¿O es eso cuando se supone que debes obtener una barra roja cuando el lanzamiento de la excepción funciona de la manera que se supone?

Answer 1

¿Estás seguro de haberle dicho que espere la excepción?

para junit más nuevo (> = 4.7), puedes usar algo como (desde here )

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

@Test
public void testRodneCisloRok(){
    exception.expect(IllegalArgumentException.class);
    exception.expectMessage("error1");
    new RodneCislo("891415",dopocitej("891415"));
}

y para junit más viejo, esto:

@Test(expected = ArithmeticException.class)  
public void divisionWithException() {  
  int i = 1/0;
}

Answer 2

Aunque @Test(expected = MyException.class) y la regla ExpectedException son opciones muy buenas, hay algunos casos en los que la captura de excepciones al estilo JUnit3 sigue siendo la mejor opción:

@Test public void yourTest() {
  try {
    systemUnderTest.doStuff();
    fail("MyException expected.");
  } catch (MyException expected) {

    // Though the ExpectedException rule lets you write matchers about
    // exceptions, it is sometimes useful to inspect the object directly.

    assertEquals(1301, expected.getMyErrorCode());
  }

  // In both @Test(expected=...) and ExpectedException code, the
  // exception-throwing line will be the last executed line, because Java will
  // still traverse the call stack until it reaches a try block--which will be
  // inside the JUnit framework in those cases. The only way to prevent this
  // behavior is to use your own try block.

  // This is especially useful to test the state of the system after the
  // exception is caught.

  assertTrue(systemUnderTest.isInErrorState());
}

Otra biblioteca que dice ayudar aquí es catch-exception ; sin embargo, a partir de mayo de 2014, el proyecto parece estar en modo de mantenimiento (obsoleto por Java 8) y, al igual que Mockito catch-exception, solo puede manipular métodos no final .

Answer 3

Si tu constructor es similar a este:

public Example(String example) {
    if (example == null) {
        throw new NullPointerException();
    }
    //do fun things with valid example here
}

Luego, cuando ejecutes esta prueba JUnit obtendrás una barra verde:

@Test(expected = NullPointerException.class)
public void constructorShouldThrowNullPointerException() {
    Example example = new Example(null);
}

Answer 4

Una ventaja del uso de ExpectedException Rule (versión 4.7) es que puede probar el mensaje de excepción y no solo la excepción esperada.

Y usando Matchers, puedes probar la parte del mensaje que te interesa:

exception.expectMessage(containsString("income: -1000.0"));

Answer 5

@Test(expected = Exception.class)  

Le dice a Junit que la excepción es el resultado esperado, de modo que la prueba se aprobará (marcada como verde) cuando se lanza una excepción.

por

@Test

Junit considerará la prueba como fallida si se lanza una excepción.
Este link puede ayudar.