web-dev-qa-db-fra.com

Quelle est la différence entre l'échec et l'erreur dans JUnit?

J'exécute des tests JUnit sur une grande base de code, et je me rends compte que parfois j'obtiens des "erreurs" tandis que d'autres fois j'obtiens des "échecs". Quelle est la différence?

javatestingjunit
84
froadie

Ok, je viens de remarquer un motif et je pense l'avoir compris (corrigez-moi si je me trompe). Il me semble que les échecs se produisent lorsque vos cas de test échouent - c'est-à-dire que vos affirmations sont incorrectes. Les erreurs sont des erreurs inattendues qui se produisent lors de la tentative d'exécution du test - exceptions, etc.

111
froadie

Si votre test lève une exception qui ne se propage pas via le framework d'assertion dans Junit, il est signalé comme une erreur. Par exemple, un NullPointer ou une exception ClassNotFound signalera une erreur:

String s = null;
s.trim();

ou,

try {

    // your code
} catch(Exception e) {
    // log the exception
    throw new MyException(e);
}

Cela dit, ce qui suit signalera un échec:

Assert.fail("Failure here");

ou,

Assert.assertEquals(1, 2);

ou même:

throw new AssertionException(e);

Cela dépend de la version Junit que vous utilisez. Le Junit 4 fera la distinction entre un échec et une erreur, mais le Junit 4 le simplifie uniquement en tant qu'échecs.

Le lien suivant fournit des entrées plus intéressantes:

http://www.devx.com/Java/Article/31983/1763/page/2

13
Neel

Extrait de "Pragmatic Unit Testing in Java 8 with JUnit":

Les assertions (ou assertions) dans JUnit sont des appels de méthode statiques que vous déposez dans vos tests. Chaque assertion est l'occasion de vérifier qu'une condition est vérifiée. Si une condition affirmée ne se vérifie pas, le test s'arrête là, et JUnit signale un échec de test.

(Il est également possible que lorsque JUnit exécute votre test, une exception soit levée et non interceptée. Dans ce cas, JUnit signale une erreur de test.)

5
Matias Elorriaga

Le test ci-dessous explique la différence entre Erreur de test vs Échec du test.

J'ai commenté la ligne qui renvoie une erreur de test et un échec de test.

    @Test
    public void testErrorVsTestFailure() {

        final String sampleString = null;

        assertEquals('j', sampleString.charAt(0) );
        //above line throws test error as you are trying to access charAt() method on null reference

        assertEquals(sampleString, "jacob");
        //above line throws Test failure as the actual value-a null , is not equal to expected value-string "jacob"
        }

Junit affiche donc une erreur de test chaque fois que vous obtenez une exception et un échec de test lorsque votre valeur de résultat attendue ne correspond pas à votre valeur réelle

4
Deen John

Classe source: JUnitReportReporter.Java

public void generateReport(List<XmlSuite> xmlSuites, List<ISuite> suites, String defaultOutputDirectory) {
//......

            for (ITestResult tr : (Set) entry.getValue()) {
                TestTag testTag = new TestTag();

                boolean isSuccess = tr.getStatus() == 1;
                if (!(isSuccess)) {
                    if (tr.getThrowable() instanceof AssertionError)
                        ++errors;
                    else {
                        ++failures;
                    }
                }
}

Comme vous pouvez le voir ci-dessous dans la méthode ci-dessus

tr.getThrowable () instanceof AssertionError

le nombre d'erreurs est augmenté lorsqu'il s'agit d'une instance de AssertionError sinon (tout Throwable) est compté comme un échec.

2
Roushan

Vous avez raison de dire que les échecs proviennent des AssertionErrors lancées par les méthodes d'assertion JUnit, ou en lançant une AssertionError, ou en lançant une exception que vous avez déclarée dans votre annotation @Test, et les erreurs proviennent d'autres exceptions inattendues. Mais il y a une distinction importante entre eux:

Un échec signifie que votre test s'est déroulé correctement et a identifié un défaut dans votre code.

Une erreur pourrait signifier un bogue dans votre code, mais que vous n'étiez même pas en train de tester. Cela pourrait également signifier que le bogue est dans le test lui-même.

En bref, un échec signifie que vous devez réécrire le code testé. Une erreur signifie que c'est peut-être le test unitaire que vous devez réécrire. Cela peut signifier cela même si l'échec était dans votre code, comme une NullPointerException, car vous avez détecté une faille que vous n'étiez même pas en train de tester, il pourrait donc être judicieux de la tester.

0
MiguelMunoz