web-dev-qa-db-fra.com

JUnit Test Exceptions

Je suis vraiment nouveau sur Java.

J'exécute des tests JUnit sur un constructeur. Le constructeur est tel que s'il se voit attribuer une chaîne nulle ou vide pour l'un de ses paramètres, il est supposé lever une exception.

Lorsque je teste ce constructeur dans JUnit avec un paramètre de chaîne vide ou vide, une barre rouge s'affiche, même si je suis presque à 100% sûr que la méthode du constructeur lève effectivement une exception lorsque de tels paramètres lui sont transmis.

Ne devrait-il pas y avoir une barre verte dans JUnit si la méthode lève une exception comme elle est supposée le faire? Ou est-ce le cas lorsque vous êtes censé obtenir une barre rouge lorsque le lancement d'exception fonctionne comme prévu?

javajunit
81
papercuts
@Test(expected = Exception.class)

Indique à Junit que l'exception est le résultat attendu. Le test sera donc passé (marqué en vert) quand une exception sera levée.

For

@Test

Junit considérera le test comme un échec si une exception est levée , à condition qu'il s'agisse d'une exception non contrôlée . Si l'exception est cochée, elle ne sera pas compilée et vous devrez utiliser d'autres méthodes. Ceci lien pourrait aider.

126
xyz

êtes-vous sûr de lui avoir dit d'attendre l'exception?

pour les nouveaux junits (> = 4.7), vous pouvez utiliser quelque chose comme (de ici )

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

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

et pour les junits plus âgés, ceci:

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

Une règle d’exception ExpectedException (version 4.7) permet de tester le message d’exception et pas uniquement l’exception attendue.

Et en utilisant Matchers, vous pouvez tester la partie du message qui vous intéresse:

exception.expectMessage(containsString("income: -1000.0"));
6
Manuel Fernández Bertoa

Si votre constructeur est similaire à celui-ci:

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

Ensuite, lorsque vous exécuterez ce test JUnit, vous obtiendrez une barre verte:

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

Bien que @Test(expected = MyException.class) et le règle ExpectedException soient de très bons choix, il existe des cas où la capture des exceptions de style JUnit3 reste la meilleure solution:

@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());
}

Une autre bibliothèque qui prétend aider ici est catch-exception ; toutefois, à compter de mai 2014, le projet semble être en mode maintenance (obsolète par Java 8), et un peu comme Mockito catch-exception ne peut manipuler que des méthodes non -final.

5
Jeff Bowman