JUnit Test Exceptions

Question

Je suis vraiment nouveau à java.

Je suis de l'exécution de certains tests JUnit sur un constructeur. Le constructeur est telle que si elle est donnée une valeur null ou une chaîne vide pour l'un de ses paramètres, il est censé générer une exception.

Quand je test ce constructeur dans JUnit avec une valeur null ou une chaîne vide paramètre, je reçois une barre rouge, même si je suis presque sûr à 100% que la méthode de constructeur en effet de lancer une exception lorsque ces paramètres sont passés à elle.

Ne devrait-il pas être une barre verte dans JUnit si la méthode lève une exception de la façon dont il est censé faire? Ou est-ce que lorsque vous êtes censé pour obtenir une barre rouge lorsque l'exception de jeter fonctionne de la façon dont il est censé faire?

Merci!

Answer 1

@Test(expected = Exception.class)  

Raconte Junit que l'exception est le résultat attendu de sorte de test sera passé (marqué en vert) lorsque l'exception est levée.

Pour

@Test

Junit va considérer le test comme un échec si une exception est levée.
Ce lien pourrait vous aider.

Answer 2

êtes-vous sûr que vous lui avez dit d'attendre l'exception?

pour les nouveaux junit (>= 4.7), vous pouvez utiliser quelque chose comme (à partir d' 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 plus junit, ceci:

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

Answer 3

Un parti d'utilisation ExpectedException Règle (version 4.7), c'est que vous pouvez tester le message de l'exception et pas seulement les attendus d'exception.

Et à l'aide de Rapprochement, vous pouvez tester la partie du message qui vous intéresse:

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

Answer 4

Si votre constructeur est similaire à ceci:

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

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

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

Answer 5

Si @Test(expected = MyException.class) et le ExpectedException règle sont de très bon choix, il y a certains cas où l'JUnit3 de style exception de rattrapage est encore la meilleure façon de le faire:

@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 voici catch-exception; toutefois, à compter de Mai 2014, le projet semble être en mode maintenance (obsolète Java 8), et à l'instar d'Mockito catch-exception ne peut manipuler les non-final méthodes.