Como dice el título, estoy buscando una forma simple de ejecutar las pruebas JUnit 4.x varias veces seguidas automáticamente usando Eclipse.

Un ejemplo sería ejecutar la misma prueba 10 veces seguidas e informar el resultado.

Ya tenemos una forma compleja de hacer esto, pero estoy buscando una manera simple de hacerlo para poder estar seguro de que la prueba escamosa que he estado tratando de arreglar se mantiene fija.

Una solución ideal sería un complemento / configuración / característica de Eclipse que desconozco.

La forma más fácil (como se requiere la menor cantidad de código nuevo) de hacer esto es ejecutar la prueba como una prueba parametrizada (anotar con @RunWith(Parameterized.class)y agregar un método para proporcionar 10 parámetros vacíos). De esa manera, el marco ejecutará la prueba 10 veces.

Esta prueba debería ser la única prueba en la clase, o mejor dicho, todos los métodos de prueba deberían ejecutarse 10 veces en la clase.

Aquí hay un ejemplo:

@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 lo anterior, es posible incluso hacerlo con un constructor sin parámetros, pero no estoy seguro de si los autores del marco lo pretendieron, o si eso se romperá en el futuro.

Si está implementando su propio corredor, puede hacer que el corredor ejecute la prueba 10 veces. Si está utilizando un corredor de terceros, entonces con 4.7, puede usar la nueva @Ruleanotación e implementar la MethodRuleinterfaz para que tome la declaración y la ejecute 10 veces en un ciclo for. El inconveniente actual de este enfoque es que @Beforey @Afterconseguir ejecutar sólo una vez. Es probable que esto cambie en la próxima versión de JUnit ( @Beforese ejecutará después de @Rule), pero independientemente de que va a actuar en la misma instancia del objeto (algo que no es cierto para el Parameterizedcorredor). Esto supone que cualquier corredor con el que esté ejecutando la clase reconoce correctamente las @Ruleanotaciones. Ese es solo el caso si está delegando a los corredores JUnit.

Si está ejecutando con un corredor personalizado que no reconoce la @Ruleanotación, entonces realmente tiene que escribir su propio corredor que delegue apropiadamente en ese corredor y lo ejecute 10 veces.

Tenga en cuenta que hay otras formas de resolver esto potencialmente (como el corredor de Teorías), pero todas requieren un corredor. Desafortunadamente, JUnit actualmente no admite capas de corredores. Ese es un corredor que encadena a otros corredores.

Con IntelliJ, puede hacer esto desde la configuración de prueba. Una vez que abra esta ventana, puede elegir ejecutar la prueba la cantidad de veces que desee.

cuando ejecute la prueba, intellij ejecutará todas las pruebas que haya seleccionado para la cantidad de veces que especificó.

Ejemplo ejecutando 624 pruebas 10 veces:

He descubierto que la anotación repetida de Spring es útil para ese tipo de cosas:

@Repeat(value = 10)

Último documento (Spring Framework 4.3.11.RELEASE API):

• org.springframework.test.annotation
• Pruebas Unitarias en Spring

Inspirado en los siguientes recursos:

• entrada en el blog
• esta solución
• versión comentada

Ejemplo

Cree y use una @Repeatanotación de la siguiente manera:

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

Usar esta solución con @RunWith(PowerMockRunner.class), requiere actualizar a Powermock 1.6.5 (que incluye un parche ).

Con JUnit 5 pude resolver esto usando la anotación @RepeatedTest :

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

Tenga en cuenta que la @Testanotación no debe usarse junto con @RepeatedTest.

Algo mal con:

@Test
void itWorks() {
    // stuff
}

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

A diferencia del caso en el que está probando cada una de una matriz de valores, no le importa particularmente qué ejecución falló.

No es necesario hacer en la configuración o anotación lo que puede hacer en el código.

Esto funciona mucho más fácil para mí.

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;
    }
}

Hay una anotación intermitente en la biblioteca tempus-fugit que funciona con JUnit 4.7 @Rulepara repetir una prueba varias veces o con @RunWith.

Por ejemplo,

@RunWith(IntermittentTestRunner.class)
public class IntermittentTestRunnerTest {

   private static int testCounter = 0;

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

Después de ejecutar la prueba (con IntermittentTestRunner en el @RunWith), testCountersería igual a 99.

Construyo un módulo que permite hacer este tipo de pruebas. Pero está enfocado no solo en repetición. Pero como garantía de que algún código es seguro para subprocesos.

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

Dependencia de Maven:

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

Ejemplo de uso:

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");
    }
}

Este es un proyecto de código abierto. Siéntase libre de mejorar.

Puede ejecutar su prueba JUnit desde un método principal y repetirla tantas veces como sea necesario:

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

            }
        }

    }

}

Esta es esencialmente la respuesta que Yishai proporcionó anteriormente, reescrita en 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() { }
}