java - que - ¿Cuál es la diferencia entre falla y error en JUnit?

errores de diseño en el software su origen e impacto

Question

Estoy ejecutando pruebas de JUnit en una gran base de código, y me he dado cuenta de que a veces obtengo "Errores" mientras que otras veces obtengo "Errores". ¿Cual es la diferencia?

Answer 1

La prueba siguiente explica la diferencia entre el error de prueba y el fracaso de la prueba .

He comentado la línea que arroja error de prueba y falla de prueba.

    @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"
        }

Por lo tanto, Junit muestra un error de prueba cada vez que recibe una excepción, y prueba un error cuando el valor de resultado esperado no coincide con su valor real

Answer 2

Clase fuente: 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;
                    }
                }
}

Como puede ver debajo de la línea en el método anterior

tr.getThrowable () instancia de AssertionError

el recuento de errores se incrementa cuando es instancia de AssertionError, de lo contrario (cualquier Throwable) se cuenta como fallas.

Answer 3

De "Pruebas unitarias pragmáticas en Java 8 con JUnit":

Las afirmaciones (o afirmaciones) en JUnit son llamadas a métodos estáticos que se incluyen en sus pruebas. Cada afirmación es una oportunidad para verificar que alguna condición sea verdadera. Si una condición afirmada no es verdadera, la prueba se detiene allí y JUnit informa una falla en la prueba.

(También es posible que cuando JUnit ejecute la prueba, se genere una excepción y no se capture. En este caso, JUnit informa un error de prueba).

Answer 4

Ok, acabo de notar un patrón y creo que lo he descubierto (corríjanme si me equivoco). Me parece que las fallas se producen cuando los casos de prueba fallan, es decir, sus afirmaciones son incorrectas. Los errores son errores inesperados que ocurren al intentar ejecutar realmente la prueba: excepciones, etc.

Answer 5

Si su prueba arroja una excepción que no se borra a través del marco de Assertion en Junit, se informa como un error. Por ejemplo, una excepción NullPointer o ClassNotFound informará un error:

String s = null;
s.trim();

o,

try {

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

Dicho esto, lo siguiente informará un error:

Assert.fail("Failure here");

o,

Assert.assertEquals(1, 2);

o incluso:

throw new AssertionException(e);

Depende de la versión de Junit que esté utilizando. Junit 4- hará la distinción entre una falla y un error, pero Junit 4 lo simplifica solo como fallas.

El siguiente enlace proporciona entradas más interesantes:

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