Jak mówi tytuł, szukam prostego sposobu na automatyczne uruchamianie testów JUnit 4.x kilka razy z rzędu za pomocą Eclipse.

Przykładem może być uruchomienie tego samego testu 10 razy z rzędu i przedstawienie wyniku.

Mamy już złożony sposób, aby to zrobić, ale szukam prostego sposobu, aby to zrobić, aby mieć pewność, że niestabilny test, który próbowałem naprawić, pozostaje naprawiony.

Idealnym rozwiązaniem byłaby wtyczka / ustawienie / funkcja Eclipse, o której nie wiem.

Najłatwiejszym sposobem (ponieważ wymagana jest najmniejsza ilość nowego kodu) jest uruchomienie testu jako testu sparametryzowanego (opatrzenie adnotacją @RunWith(Parameterized.class)i dodanie metody zapewniającej 10 pustych parametrów). W ten sposób framework uruchomi test 10 razy.

Ten test musiałby być jedynym testem w klasie lub lepiej umieścić wszystkie metody testowe w klasie 10 razy.

Oto przykład:

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

Dzięki temu można to zrobić nawet za pomocą konstruktora bez parametrów, ale nie jestem pewien, czy autorzy frameworka to zamierzyli, czy też w przyszłości się to zepsuje.

Jeśli wdrażasz własnego biegacza, możesz poprosić biegacza o wykonanie testu 10 razy. Jeśli korzystasz z zewnętrznego narzędzia uruchamiającego , to w wersji 4.7 możesz użyć nowej @Ruleadnotacji i zaimplementować MethodRuleinterfejs tak, aby pobierał instrukcję i wykonywał ją 10 razy w pętli for. Obecną wadą tego podejścia jest to @Beforei @Afteruruchamianie tylko raz. Prawdopodobnie zmieni się to w następnej wersji JUnit ( @Beforeuruchomi się po @Rule), ale niezależnie od tego, będziesz działał na tej samej instancji obiektu (coś, co nie jest prawdą w przypadku Parameterizedrunnera). Zakłada się, że niezależnie od biegacza, z którym prowadzisz zajęcia, poprawnie rozpoznaje @Ruleadnotacje. Dzieje się tak tylko w przypadku delegowania do biegaczy JUnit.

Jeśli biegasz z niestandardowym biegaczem, który nie rozpoznaje @Ruleadnotacji, naprawdę utkniesz z koniecznością napisania własnego biegacza, który deleguje odpowiednio tego biegacza i uruchamia go 10 razy.

Zauważ, że istnieją inne sposoby, aby potencjalnie rozwiązać ten problem (np. Biegacz teorii), ale wszystkie wymagają biegacza. Niestety JUnit nie obsługuje obecnie warstw runnerów. To biegacz, który wiąże innych biegaczy.

Dzięki IntelliJ możesz to zrobić z konfiguracji testowej. Po otwarciu tego okna możesz uruchomić test dowolną liczbę razy.

po uruchomieniu testu intellij wykona wszystkie wybrane przez Ciebie testy tyle razy, ile podałeś.

Przykład uruchomienia 624 testów 10 razy:

Zauważyłem, że powtarzająca się adnotacja Springa jest przydatna w takich sytuacjach:

@Repeat(value = 10)

Najnowszy (Spring Framework 4.3.11.RELEASE API) dokument:

• org.springframework.test.annotation
• Testy jednostkowe wiosną

Zainspirowany następującymi zasobami:

• post na blogu
• to rozwiązanie
• skomentowana wersja

Przykład

Utwórz i użyj @Repeatadnotacji w następujący sposób:

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

Korzystanie z tego rozwiązania w programie @RunWith(PowerMockRunner.class)wymaga aktualizacji do Powermock 1.6.5 (która zawiera poprawkę ).

Dzięki JUnit 5 udało mi się rozwiązać ten problem za pomocą adnotacji @RepeatedTest :

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

Pamiętaj, że @Testadnotacji nie należy używać razem z @RepeatedTest.

Coś nie tak z:

@Test
void itWorks() {
    // stuff
}

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

W przeciwieństwie do przypadku, gdy testujesz każdą z tablicy wartości, nie obchodzi cię, który przebieg się nie powiódł.

Nie musisz robić w konfiguracji ani adnotacji tego, co możesz zrobić w kodzie.

U mnie to działa dużo łatwiej.

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

W bibliotece tempus-fugit znajduje się przerywana adnotacja, która współpracuje z JUnit 4.7, @Ruleaby powtórzyć test kilka razy lub z @RunWith.

Na przykład,

@RunWith(IntermittentTestRunner.class)
public class IntermittentTestRunnerTest {

   private static int testCounter = 0;

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

Po uruchomieniu testu (z IntermittentTestRunner w @RunWith), testCounterbędzie równe 99.

Buduję moduł umożliwiający wykonanie tego typu testów. Ale skupia się nie tylko na powtórzeniach. Ale gwarantujemy, że jakiś fragment kodu jest bezpieczny dla wątków.

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

Zależność Mavena:

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

Przykład użycia:

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

To jest projekt open source. Zapraszam do ulepszania.

Możesz uruchomić test JUnit z głównej metody i powtórzyć go tyle razy, ile potrzebujesz:

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

            }
        }

    }

}

Jest to w istocie odpowiedź, którą Yishai podał powyżej, przepisaną w Kotlinie:

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