Risposte:
Ok, ho appena notato uno schema e penso di averlo capito (correggimi se sbaglio). Mi sembra che gli errori si verifichino quando i tuoi casi di test falliscono, ovvero le tue affermazioni non sono corrette. Gli errori sono errori imprevisti che si verificano durante il tentativo di eseguire effettivamente il test: eccezioni, ecc.
@Testcon expected = SomeException.class.
Se il test genera un'eccezione che non viene ribaltata tramite il framework di asserzioni in Junit, viene segnalata come errore. Ad esempio, un'eccezione NullPointer o ClassNotFound segnalerà un errore:
String s = null;
s.trim();o,
try {
// your code
} catch(Exception e) {
// log the exception
throw new MyException(e);
}Detto questo, verrà segnalato un guasto:
Assert.fail("Failure here");o,
Assert.assertEquals(1, 2);o anche:
throw new AssertionException(e);Dipende dalla versione di Junit che stai utilizzando. Junit 4- farà la distinzione tra un fallimento e un errore, ma Junit 4 lo semplifica solo come fallimenti.
Il seguente collegamento fornisce input più interessanti:
Da "Pragmatic Unit Testing in Java 8 con JUnit":
Le asserzioni (o asserzioni) in JUnit sono chiamate di metodi statici che inserisci nei tuoi test. Ogni affermazione è un'opportunità per verificare che alcune condizioni siano vere. Se una condizione asserita non è vera, il test si interrompe proprio lì e JUnit segnala un errore del test.
(È anche possibile che quando JUnit esegue il test, viene generata un'eccezione e non viene rilevata. In questo caso, JUnit riporta un errore di test.)
Ho commentato la riga che genera errore di test e fallimento del 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"
}Quindi Junit mostra un errore di test ogni volta che si ottiene un'eccezione e un errore di test quando il valore del risultato atteso non corrisponde al valore effettivo
Classe di origine: 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;
}
}
}Come puoi vedere sotto la riga nel metodo sopra
tr.getThrowable () instanceof AssertionError
il conteggio degli errori aumenta quando si tratta di un'istanza di AssertionError altrimenti (qualsiasi Throwable) viene conteggiato come errori.
Hai ragione che gli errori provengono dagli AssertionErrors lanciati dai metodi di asserzione JUnit, o lanciando un AssertionError, o generando un'eccezione che hai dichiarato nella tua @Testannotazione, e gli errori provengono da altre eccezioni impreviste. Ma c'è un'importante distinzione tra di loro:
Un errore significa che il test è stato eseguito correttamente e ha identificato un difetto nel codice.
Un errore potrebbe significare un bug nel tuo codice, ma che non stavi nemmeno testando. Potrebbe anche significare che il bug è nel test stesso.
In breve, un errore significa che è necessario riscrivere il codice che viene testato. Un errore significa che potrebbe essere lo unit test che devi riscrivere. Può significare questo anche se l'errore era nel tuo codice, ad esempio a NullPointerException, perché hai rilevato un difetto per il quale non stavi nemmeno testando, quindi potrebbe essere saggio testarlo.
Ironia della sorte, junit e altri framework relativi ai test (testng, hamcrest) forniscono operazioni di asserzione che verificano la condizione e, se fallisce, viene lanciato "sotto il cofano" un java.lang.AssertionError, che btw estende java.lang.Error.
Ma non è affatto in contraddizione con le risposte di cui sopra che sono ovviamente pienamente valide. Quindi, per contrassegnare un flusso di test specifico come errore, si può lanciare AssertionError, tuttavia non sono sicuro che sia realmente documentato nei manuali corrispondenti, perché è più appropriato utilizzare l'API fail () dedicata. Altri tipi di Throwable saranno considerati errori, non fallimenti.
Fondamentalmente, i fallimenti si riferiscono ad asserzioni non soddisfatte mentre gli errori sono dovuti a un'esecuzione anormale del test . e penso che ogni IDE abbia icone simboliche con colori diversi per test passati , falliti e con errori .
Per ulteriori informazioni, controlla questo .
java.lang.AssertionErrorviene lanciato qualcosa che si estende , verrà mostrato come un fallimento del test invece di un errore del test. Dovresti considerare di accettare la tua risposta perché è corretta.