Como o título diz, estou procurando uma maneira simples de executar os testes do JUnit 4.x várias vezes seguidas automaticamente usando o Eclipse.

Um exemplo seria executar o mesmo teste 10 vezes seguidas e reportar o resultado.

Já temos uma maneira complexa de fazer isso, mas estou procurando uma maneira simples de fazê-lo, para que eu possa ter certeza de que o teste superficial que estou tentando corrigir permanece fixo.

Uma solução ideal seria um plugin / configuração / recurso do Eclipse que eu desconheço.

A maneira mais fácil (como é necessária a quantidade mínima de código novo) para fazer isso é executar o teste como um teste parametrizado (anote com @RunWith(Parameterized.class)e adicione um método para fornecer 10 parâmetros vazios). Dessa forma, a estrutura executará o teste 10 vezes.

Esse teste precisaria ser o único na classe, ou melhor, todos os métodos de teste precisariam ser executados 10 vezes na classe.

Aqui está um exemplo:

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

Com o exposto, é possível fazê-lo com um construtor sem parâmetros, mas não tenho certeza se os autores da estrutura pretendiam isso ou se isso seria interrompido no futuro.

Se você estiver implementando seu próprio corredor, poderá fazer com que o corredor execute o teste 10 vezes. Se você estiver usando um corredor de terceiros, com o 4.7, poderá usar a nova @Ruleanotação e implementar a MethodRuleinterface para que ela pegue a instrução e a execute 10 vezes em um loop for. A desvantagem atual dessa abordagem é essa @Beforee @Afteré executada apenas uma vez. Provavelmente, isso mudará na próxima versão do JUnit (o que @Beforeserá executado após o @Rule), mas independentemente você estará agindo na mesma instância do objeto (algo que não é verdadeiro para o Parameterizedcorredor). Isso pressupõe que qualquer corredor com o qual você esteja executando a classe reconheça corretamente as @Ruleanotações. Esse é apenas o caso se estiver delegando para os corredores JUnit.

Se você estiver executando com um corredor personalizado que não reconheça a @Ruleanotação, ficará realmente com a necessidade de escrever seu próprio corredor, que delega adequadamente esse corredor e o executa 10 vezes.

Observe que existem outras maneiras de resolver isso potencialmente (como o corredor de teorias), mas todas elas exigem um corredor. Infelizmente, o JUnit atualmente não suporta camadas de corredores. Esse é um corredor que liga outros corredores.

Com o IntelliJ, você pode fazer isso na configuração de teste. Depois de abrir esta janela, você pode optar por executar o teste quantas vezes quiser.

Quando você executa o teste, o intellij executará todos os testes selecionados para o número de vezes que você especificou.

Exemplo executando 624 testes 10 vezes:

Descobri que a anotação repetida do Spring é útil para esse tipo de coisa:

@Repeat(value = 10)

Documento mais recente (API Spring Framework 4.3.11.RELEASE):

• org.springframework.test.annotation
• Teste de Unidade na Primavera

Inspirado nos seguintes recursos:

• publicação no blog
• esta solução
• versão comentada

Exemplo

Crie e use uma @Repeatanotação da seguinte maneira:

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

Para usar esta solução @RunWith(PowerMockRunner.class), é necessário atualizar para o Powermock 1.6.5 (que inclui um patch ).

Com o JUnit 5, consegui resolver isso usando a anotação @RepeatedTest :

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

Observe que a @Testanotação não deve ser usada junto com @RepeatedTest.

Algo errado com:

@Test
void itWorks() {
    // stuff
}

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

Ao contrário do caso em que você está testando cada uma de uma matriz de valores, não se importa particularmente com a falha na execução.

Não é necessário fazer na configuração ou anotação o que você pode fazer no código.

Isso funciona muito mais fácil para mim.

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

Há uma anotação intermitente na biblioteca tempus-fugit que funciona com o JUnit 4.7 @Rulepara repetir um teste várias vezes ou com@RunWith .

Por exemplo,

@RunWith(IntermittentTestRunner.class)
public class IntermittentTestRunnerTest {

   private static int testCounter = 0;

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

Após a execução do teste (com o IntermittentTestRunner no @RunWith), testCounterseria igual a 99.

Eu construo um módulo que permite fazer esse tipo de teste. Mas é focado não apenas na repetição. Mas, para garantir que algum trecho de código seja seguro para threads.

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

Dependência do Maven:

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

Exemplo 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 é um projeto de código aberto. Sinta-se livre para melhorar.

Você pode executar seu teste JUnit a partir de um método principal e repeti-lo quantas vezes precisar:

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 é essencialmente a resposta que Yishai forneceu acima, reescrita em 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() { }
}