Як говорить заголовок, я шукаю простий спосіб запустити тести 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 разів.

Зауважте, що існують й інші способи вирішити це (наприклад, теорія бігуна), але всі вони потребують бігуна. На жаль, 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
    }
}

Повторіть.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 є переривчаста примітка, яка працює з 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

Залежна залежність:

<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

            }
        }

    }

}

Це, по суті, відповідь, яку Yishai надав вище, переписаний у Котліні:

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