Как говорится в названии, я ищу простой способ запускать тесты JUnit 4.x несколько раз подряд автоматически с помощью Eclipse.

Например, один и тот же тест будет выполняться 10 раз подряд и сообщать результат.

У нас уже есть сложный способ сделать это, но я ищу простой способ сделать это, чтобы быть уверенным, что нестабильный тест, который я пытался исправить, остается исправленным.

Идеальным решением будет плагин / настройка / функция Eclipse, о которых я не знаю.

Самый простой (как минимум необходимый объем нового кода) способ сделать это - запустить тест как параметризованный (пометить @RunWith(Parameterized.class)и добавить метод для предоставления 10 пустых параметров). Таким образом, фреймворк выполнит тест 10 раз.

Этот тест должен быть единственным тестом в классе, или, лучше сказать, все методы тестирования должны выполняться в классе 10 раз.

Вот пример:

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

С вышесказанным можно даже сделать это с помощью конструктора без параметров, но я не уверен, предполагали ли это авторы фреймворка или это сломается в будущем.

Если вы реализуете свой собственный бегун, то вы можете запустить тест 10 раз. Если вы используете сторонний бегун, то с 4.7 вы можете использовать новую @Ruleаннотацию и реализовать MethodRuleинтерфейс так, чтобы он принимал оператор и выполнял его 10 раз в цикле for. Текущий недостаток такого подхода в том, что @Beforeи @Afterзапускается только один раз. Скорее всего, это изменится в следующей версии JUnit ( @Beforeбудет запускаться после @Rule), но независимо от того, что вы будете действовать с одним и тем же экземпляром объекта (что не относится к Parameterizedбегуну). Это предполагает, что любой бегун, с которым вы запускаете класс, правильно распознает @Ruleаннотации. Это только в том случае, если он делегируется исполнителям JUnit.

Если вы работаете с настраиваемым бегуном, который не распознает @Ruleаннотацию, то вам действительно приходится писать собственный бегун, который надлежащим образом делегирует этому бегуну и запускает его 10 раз.

Обратите внимание, что есть и другие способы решения этой проблемы (например, бегун Theories), но все они требуют бегуна. К сожалению, JUnit в настоящее время не поддерживает уровни бегунов. Это бегун, который сковывает других бегунов.

С IntelliJ вы можете сделать это из тестовой конфигурации. Открыв это окно, вы можете запускать тест любое количество раз.

когда вы запустите тест, intellij выполнит все выбранные вами тесты указанное вами количество раз.

Пример выполнения 624 тестов 10 раз:

Я обнаружил, что аннотация повторения Spring полезна для таких вещей:

@Repeat(value = 10)

Последний документ (Spring Framework 4.3.11.RELEASE API):

• org.springframework.test.annotation
• Модульное тестирование весной

На основе следующих ресурсов:

• Сообщение блога
• это решение
• прокомментированная версия

пример

Создайте и используйте @Repeatаннотацию следующим образом:

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

Использование этого решения с @RunWith(PowerMockRunner.class)требует обновления до Powermock 1.6.5 (который включает патч ).

С JUnit 5 я смог решить эту проблему с помощью аннотации @RepeatedTest :

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

Обратите внимание, что @Testаннотацию не следует использовать вместе с @RepeatedTest.

Что-то не так с:

@Test
void itWorks() {
    // stuff
}

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

В отличие от случая, когда вы тестируете каждый из массивов значений, вам не особенно важно, какой прогон завершился неудачно.

Не нужно делать в конфигурации или аннотации то, что можно делать в коде.

Для меня это работает намного проще.

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

В библиотеке tempus-fugit есть аннотация Intermittent, которая работает с JUnit 4.7, @Ruleчтобы повторить тест несколько раз или с @RunWith.

Например,

@RunWith(IntermittentTestRunner.class)
public class IntermittentTestRunnerTest {

   private static int testCounter = 0;

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

После запуска теста (с IntermittentTestRunner в @RunWith) testCounterбудет равно 99.

Я создаю модуль, позволяющий проводить такие тесты. Но не только в повторении. Но чтобы гарантировать, что какой-то фрагмент кода является потокобезопасным.

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

Зависимость от Maven:

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

Пример использования:

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

Это проект с открытым исходным кодом. Не стесняйтесь совершенствоваться.

Вы можете запустить тест JUnit из основного метода и повторять его столько раз, сколько вам нужно:

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

            }
        }

    }

}

По сути, это ответ, который Ишай дал выше, переписанный на Котлине:

@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() { }
}