Arresto suite di JUnit se particolare test fallisce

Question

Ho una suite di test JUnit nella forma:

@RunWith(Suite.class) 
@Suite.SuiteClasses({ xx.class, yy.cass }) 

public class AllTests { 

public static Test suite() { 
    TestSuite suite = new TestSuite(AllTests.class.getName()); 
    //$JUnit-BEGIN$ 

    //$JUnit-END$ 
    return suite; 
} 
} 

Questo quindi chiama test di vaniglia come questo:

public class xxx { 

@Test 
public void test() throws { 
    ... 

Ho una situazione in cui mi piacerebbe piace fermare il resto della suite di test in esecuzione se c'è un errore o un errore nel primo test. Ma gli errori/errori negli altri sono ok e la suite dovrebbe completare il maggior numero di test possibile. Fondamentalmente, il primo test fallito indica che non è sicuro eseguire il resto.

È possibile?

Answer 1

Cosa c'è di sbagliato nel chiamare System.exit()?

Answer 2

Stai facendo test utilizzando formica?

È possibile scrivere un listener di test personalizzato. Puoi impostarlo nel form http://ant.apache.org/manual/Tasks/junit.html (enableTestListenerEvents).

Answer 3

Se è il primo test, prendere in considerazione la possibilità di spostare la convalida su @BeforeClass e generare un'eccezione se non riesce. Quindi solo il metodo @AfterClass verrebbe eseguito in caso di questa eccezione.

Naturalmente, in questo modo ti mancano tutti gli artefatti di fixture creati nei metodi di configurazione di prova.

Answer 4

Sulla base della risposta di Hiro2k (grazie!) Ho utilizzato la seguente soluzione. È un po 'un trucco, ma funziona.

Il test che può impedire l'esecuzione di altri test si trova nella parte superiore dell'elenco @ Suite.SuiteClasses. Questo test ha quindi la seguente:

private static boolean shouldStopRestOfSuite = false; 

    @Test 
    public void test() throws Throwable { 
    try { 
      ... run some test code... 
    } 
    catch (Throwable e) { 
     shouldStopRestOfSuite = true; 
     throw e; 
    } 
} 

Nota È possibile che questo ha bisogno di prendere Throwable (non fa eccezione) in modo che cattura errori di asserzione. Inoltre, restituisce l'errore, quindi viene registrato da JUnit per l'analisi.

Poi c'è un altro metodo di prova:

@Test 
public void testKillIfNeeded() throws Exception { 
    if (!shouldStopRestOfSuite) { 
     return; 
    } 

    System.out.println ("Test suite killed due to dangerous error/failure"); 
    System.exit(1); 
} 

È possibile che questo è gestito secondo e ucciderà il processo di JUnit.

Utilizzando questo metodo, il test JUnit non si interromperà in caso di errore/errore in caso di problemi, ma l'errore/errore viene registrato per l'analisi da parte di JUnit e non verranno eseguiti ulteriori test.

Non troppo bella, ma non il lavoro :)

Answer 5

Come la tua risposta, ma utilizzando @Before in un test di integrazione, ho fatto qualcosa di simile:

public class FooTest { 

    private static boolean bar; 

    @BeforeClass 
    public static void setUpBeforeClass() throws Exception { 
     bar = false; 
    } 

    @Before 
    public void setUp() throws Exception { 
     assertTrue(bar); 
    } 

    @Test 
    public void test() { 
     System.out.println("something"); 
     assertTrue(true); 
    } 

    @Test 
    public void test1() { 
     System.out.println("Something2"); 
     assertTrue(true); 
    } 
} 

saluti!

Answer 6

Prima di tutto bisogna RunListener JUnit:

import org.junit.runner.notification.Failure; 
import org.junit.runner.notification.RunListener; 
import org.junit.runner.notification.RunNotifier; 

public class FailureListener extends RunListener { 

    private RunNotifier runNotifier; 

    public FailureListener(RunNotifier runNotifier) { 
     super(); 
     this.runNotifier=runNotifier; 
    } 

    @Override 
    public void testFailure(Failure failure) throws Exception { 
     super.testFailure(failure); 
     this.runNotifier.pleaseStop(); 
    } 
} 

quindi preparare una suite:

public class StopOnFailureSuite extends Suite { 

    public StopOnFailureSuite(Class<?> klass, Class<?>[] suiteClasses) throws InitializationError { 
     super(klass, suiteClasses); 
    } 

    public StopOnFailureSuite(Class<?> klass) throws InitializationError { 
     super(klass, klass.getAnnotation(SuiteClasses.class).value()); 
    } 

    @Override 
    public void run(RunNotifier runNotifier) { 
     runNotifier.addListener(new FailureListener(runNotifier)); 
     super.run(runNotifier); 
    } 
} 

ed eseguire la vostra suite:

@RunWith(StopOnFailureSuite.class) 
@Suite.SuiteClasses({ 
    FirstTestClass.class, 
    SecondTestClass.class, 
    ... 
}) 

Answer 7

In primo luogo si dovrebbe prendere un errore e controllare la lo stesso prima di eseguire il secondo test.

@Rule 
public ErrorCollector collector = new ErrorCollector(); 

1. Aggiungi errore.

collector.addError(new Throwable("first thing went wrong")); 

2. Verificare prima della corsa dipendente.

collector.checkThat(getResult(), not(containsString("ERROR!"))); 

Riferimento - ErrorCollector