Qual é a diferença entre falha e erro no JUnit?

Estou executando testes JUnit em uma grande base de código e tenho percebido que às vezes recebo "Erros", enquanto outras vezes recebo "Falhas". Qual é a diferença?

Ok, acabei de notar um padrão e acho que descobri (corrija-me se estiver errado). Parece-me que as falhas ocorrem quando seus casos de teste falham - ou seja, suas afirmações estão incorretas. Os erros são erros inesperados que ocorrem ao tentar realmente executar o teste - exceções, etc.

Se o seu teste lançar uma exceção que não surge através da estrutura de asserção no Junit, ele é relatado como um erro. Por exemplo, um NullPointer ou uma exceção ClassNotFound relatará um erro:

String s = null;
s.trim();

ou,

try {

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

Dito isso, o seguinte relatará uma falha:

Assert.fail("Failure here");

ou,

Assert.assertEquals(1, 2);

ou mesmo:

throw new AssertionException(e);

Depende da versão do Junit que você está usando. A Junit 4 fará a distinção entre uma falha e um erro, mas a Junit 4 a simplifica apenas como falhas.

O link a seguir fornece informações mais interessantes:

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

De "Pragmatic Unit Testing in Java 8 with JUnit":

Assertions (ou asserts) em JUnit são chamadas de método estático que você coloca em seus testes. Cada afirmação é uma oportunidade de verificar se alguma condição é verdadeira. Se uma condição declarada não for verdadeira, o teste para ali mesmo e o JUnit relata uma falha de teste.

(Também é possível que, quando JUnit executa seu teste, uma exceção seja lançada e não detectada. Nesse caso, JUnit relata um erro de teste.)

O teste abaixo explica a diferença entre o erro do teste e a falha do teste .

Eu comentei a linha que gera erro de teste e falha de teste.

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

Portanto, o Junit mostra o erro de teste sempre que você obtém uma exceção e falha no teste quando o valor do resultado esperado não corresponde ao seu valor real

Classe de origem: 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 você pode ver a linha abaixo no método acima

tr.getThrowable () instanceof AssertionError

a contagem de erros é aumentada quando é uma instância de AssertionError, caso contrário (qualquer Throwable) é contado como falhas.

Você está certo de que as falhas vêm dos AssertionErrors lançados pelos métodos de asserção JUnit, ou lançando um AssertionError, ou lançando uma exceção que você declarou em sua @Testanotação, e os erros vêm de outras exceções inesperadas. Mas há uma distinção importante entre eles:

Uma falha significa que seu teste foi executado corretamente e identificou um defeito em seu código.

Um erro pode significar um bug em seu código, mas que você nem estava testando. Também pode significar que o bug está no próprio teste.

Resumindo, uma falha significa que você precisa reescrever o código que está sendo testado. Um erro significa que pode ser o teste de unidade que você precisa reescrever. Pode significar isso mesmo se a falha estiver em seu código, como um NullPointerException, porque você detectou uma falha que nem estava testando, então pode ser sábio testar isso.

Ironicamente, junit e outras estruturas relacionadas a testes (testng, hamcrest) fornecem operações de declaração que verificam a condição e, se ela falhar , "por baixo do capô" um java.lang.AssertionError está sendo lançado, o qual estende java.lang.Error.

Mas de forma alguma contradiz as respostas acima, as quais são totalmente válidas, é claro. Portanto, para marcar o fluxo de teste específico como falha, pode-se lançar AssertionError, no entanto, não tenho certeza se ele está realmente documentado nos manuais correspondentes, porque é mais apropriado usar a API fail () dedicada. Outros tipos de Throwable serão considerados erros, não falhas.

Basicamente, as falhas referem-se a afirmações não cumpridas, enquanto os erros são devidos à execução anormal do teste . e acho que cada IDE tem ícones simbólicos com cores diferentes para aprovado , reprovado e com testes de erro .

Para mais informações, verifique isto .