Come dice il titolo, sto cercando un modo semplice per eseguire i test di JUnit 4.x più volte di seguito automaticamente utilizzando Eclipse.

Un esempio potrebbe essere eseguire lo stesso test 10 volte di seguito e riportare il risultato.

Abbiamo già un modo complesso per farlo, ma sto cercando un modo semplice per farlo in modo da essere certo che il test traballante che ho cercato di risolvere rimanga fisso.

Una soluzione ideale sarebbe un plug-in / impostazione / funzionalità Eclipse di cui non sono a conoscenza.

Il modo più semplice (come minimo quantità di nuovo codice richiesto) per farlo è eseguire il test come un test parametrizzato (annotare con un @RunWith(Parameterized.class) e aggiungere un metodo per fornire 10 parametri vuoti). In questo modo il framework eseguirà il test 10 volte.

Questo test dovrebbe essere l'unico test nella classe, o meglio mettere tutti i metodi di test dovrebbero essere eseguiti 10 volte nella classe.

Ecco un esempio:

@RunWith(Parameterized.class)
public class RunTenTimes {

    @Parameterized.Parameters
    public static Object[][] data() {
        return new Object[10][0];
    }

    public RunTenTimes() {
    }

    @Test
    public void runsTenTimes() {
        System.out.println("run");
    }
}

Con quanto sopra, è possibile farlo anche con un costruttore senza parametri, ma non sono sicuro se gli autori del framework lo intendessero o se ciò si interromperà in futuro.

Se stai implementando il tuo corridore, potresti fare in modo che il corridore esegua il test 10 volte. Se stai usando un runner di terze parti, allora con 4.7, puoi usare la nuova @Ruleannotazione e implementare l' MethodRuleinterfaccia in modo che prenda l'istruzione e la esegua 10 volte in un ciclo for. Lo svantaggio attuale di questo approccio è che @Beforee @Afterottenere eseguito solo una volta. Questo probabilmente cambierà nella prossima versione di JUnit ( @Beforeverrà eseguito dopo il @Rule), ma indipendentemente dal fatto che agirete sulla stessa istanza dell'oggetto (qualcosa che non è vero per il Parameterizedcorridore). Ciò presuppone che qualunque corridore con cui stai conducendo la classe riconosca correttamente le @Ruleannotazioni. Questo è solo il caso se sta delegando ai corridori JUnit.

Se stai correndo con un corridore personalizzato che non riconosce l' @Ruleannotazione, allora sei davvero bloccato nel dover scrivere il tuo corridore che delega in modo appropriato a quel corridore e lo esegue 10 volte.

Nota che ci sono altri modi per risolverlo potenzialmente (come il corridore di Theories) ma tutti richiedono un corridore. Sfortunatamente JUnit attualmente non supporta livelli di corridori. Questo è un corridore che incatena altri corridori.

Con IntelliJ, puoi farlo dalla configurazione di prova. Una volta aperta questa finestra, puoi scegliere di eseguire il test tutte le volte che vuoi.

quando si esegue il test, intellij eseguirà tutti i test selezionati per il numero di volte specificato.

Esempio che esegue 624 test 10 volte:

Ho scoperto che l'annotazione di ripetizione di Spring è utile per questo tipo di cose:

@Repeat(value = 10)

Documento più recente (Spring Framework 4.3.11.RELEASE API):

• org.springframework.test.annotation
• Unit test in primavera

Ispirato dalle seguenti risorse:

• post sul blog
• questa soluzione
• versione commentata

Esempio

Crea e utilizza @Repeatun'annotazione come segue:

public class MyTestClass {

    @Rule
    public RepeatRule repeatRule = new RepeatRule();

    @Test
    @Repeat(10)
    public void testMyCode() {
        //your test code goes here
    }
}

Repeat.java

import static java.lang.annotation.ElementType.ANNOTATION_TYPE;
import static java.lang.annotation.ElementType.METHOD;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention( RetentionPolicy.RUNTIME )
@Target({ METHOD, ANNOTATION_TYPE })
public @interface Repeat {
    int value() default 1;
}

RepeatRule.java

import org.junit.rules.TestRule;
import org.junit.runner.Description;
import org.junit.runners.model.Statement;

public class RepeatRule implements TestRule {

    private static class RepeatStatement extends Statement {
        private final Statement statement;
        private final int repeat;    

        public RepeatStatement(Statement statement, int repeat) {
            this.statement = statement;
            this.repeat = repeat;
        }

        @Override
        public void evaluate() throws Throwable {
            for (int i = 0; i < repeat; i++) {
                statement.evaluate();
            }
        }

    }

    @Override
    public Statement apply(Statement statement, Description description) {
        Statement result = statement;
        Repeat repeat = description.getAnnotation(Repeat.class);
        if (repeat != null) {
            int times = repeat.value();
            result = new RepeatStatement(statement, times);
        }
        return result;
    }
}

PowerMock

L'utilizzo di questa soluzione con @RunWith(PowerMockRunner.class)richiede l'aggiornamento a Powermock 1.6.5 (che include una patch ).

Con JUnit 5 sono stato in grado di risolvere questo problema utilizzando l' annotazione @RepeatedTest :

@RepeatedTest(10)
public void testMyCode() {
    //your test code goes here
}

Nota che l' @Testannotazione non dovrebbe essere usata insieme a @RepeatedTest.

Qualcosa di sbagliato in:

@Test
void itWorks() {
    // stuff
}

@Test
void itWorksRepeatably() {
    for (int i = 0; i < 10; i++) {
        itWorks();
    }
}

A differenza del caso in cui stai testando ciascuno di un array di valori, non ti interessa particolarmente quale esecuzione non è riuscita.

Non c'è bisogno di fare nella configurazione o nell'annotazione ciò che puoi fare nel codice.

Questo funziona molto più facilmente per me.

public class RepeatTests extends TestCase {

    public static Test suite() {
        TestSuite suite = new TestSuite(RepeatTests.class.getName());

        for (int i = 0; i < 10; i++) {              
        suite.addTestSuite(YourTest.class);             
        }

        return suite;
    }
}

C'è un'annotazione intermittente nella libreria tempus-fugit che funziona con JUnit 4.7 @Ruleper ripetere un test più volte o con@RunWith .

Per esempio,

@RunWith(IntermittentTestRunner.class)
public class IntermittentTestRunnerTest {

   private static int testCounter = 0;

   @Test
   @Intermittent(repition = 99)
   public void annotatedTest() {
      testCounter++;
   }
}

Dopo che il test è stato eseguito (con IntermittentTestRunner in @RunWith), testCountersarebbe uguale a 99.

Realizzo un modulo che permette di fare questo tipo di test. Ma è focalizzato non solo a ripetizione. Ma a garanzia che alcune parti di codice siano thread-safe.

https://github.com/anderson-marques/concurrent-testing

Dipendenza da Maven:

<dependency>
    <groupId>org.lite</groupId>
    <artifactId>concurrent-testing</artifactId>
    <version>1.0.0</version>
</dependency>

Esempio di utilizzo:

package org.lite.concurrent.testing;

import org.junit.Assert;
import org.junit.Rule;
import org.junit.Test;
import ConcurrentTest;
import ConcurrentTestsRule;

/**
 * Concurrent tests examples
 */
public class ExampleTest {

    /**
     * Create a new TestRule that will be applied to all tests
     */
    @Rule
    public ConcurrentTestsRule ct = ConcurrentTestsRule.silentTests();

    /**
     * Tests using 10 threads and make 20 requests. This means until 10 simultaneous requests.
     */
    @Test
    @ConcurrentTest(requests = 20, threads = 10)
    public void testConcurrentExecutionSuccess(){
        Assert.assertTrue(true);
    }

    /**
     * Tests using 10 threads and make 20 requests. This means until 10 simultaneous requests.
     */
    @Test
    @ConcurrentTest(requests = 200, threads = 10, timeoutMillis = 100)
    public void testConcurrentExecutionSuccessWaitOnly100Millissecond(){
    }

    @Test(expected = RuntimeException.class)
    @ConcurrentTest(requests = 3)
    public void testConcurrentExecutionFail(){
        throw new RuntimeException("Fail");
    }
}

Questo è un progetto open source. Sentiti libero di migliorare.

Puoi eseguire il tuo test JUnit da un metodo principale e ripeterlo tante volte di cui hai bisogno:

package tests;

import static org.junit.Assert.*;

import org.junit.Test;
import org.junit.runner.Result;

public class RepeatedTest {

    @Test
    public void test() {
        fail("Not yet implemented");
    }

    public static void main(String args[]) {

        boolean runForever = true;

        while (runForever) {
            Result result = org.junit.runner.JUnitCore.runClasses(RepeatedTest.class);

            if (result.getFailureCount() > 0) {
                runForever = false;
               //Do something with the result object

            }
        }

    }

}

Questa è essenzialmente la risposta che Yishai ha fornito sopra, riscritta in Kotlin:

@RunWith(Parameterized::class)
class MyTest {

    companion object {

        private const val numberOfTests = 200

        @JvmStatic
        @Parameterized.Parameters
        fun data(): Array<Array<Any?>> = Array(numberOfTests) { arrayOfNulls<Any?>(0) }
    }

    @Test
    fun testSomething() { }
}