Wie der Titel schon sagt, suche ich nach einer einfachen Möglichkeit, JUnit 4.x-Tests mehrmals hintereinander automatisch mit Eclipse auszuführen.

Ein Beispiel wäre, denselben Test zehnmal hintereinander auszuführen und das Ergebnis zurückzumelden.

Wir haben bereits eine komplexe Methode, aber ich suche nach einer einfachen Methode, damit ich sicher sein kann, dass der schuppige Test, den ich zu beheben versucht habe, behoben bleibt.

Eine ideale Lösung wäre ein Eclipse-Plugin / -Einstellung / -Funktion, das mir nicht bekannt ist.

Der einfachste Weg (da nur die geringste Menge an neuem Code erforderlich ist) besteht darin, den Test als parametrisierten Test auszuführen (mit einem zu kommentieren @RunWith(Parameterized.class)und eine Methode hinzuzufügen, um 10 leere Parameter bereitzustellen). Auf diese Weise führt das Framework den Test zehnmal aus.

Dieser Test muss der einzige Test in der Klasse sein, oder besser gesagt, alle Testmethoden müssen zehnmal in der Klasse ausgeführt werden.

Hier ist ein Beispiel:

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

Mit dem oben Gesagten ist es sogar möglich, dies mit einem parameterlosen Konstruktor zu tun, aber ich bin mir nicht sicher, ob die Framework-Autoren dies beabsichtigt haben oder ob dies in Zukunft nicht mehr funktioniert.

Wenn Sie Ihren eigenen Läufer implementieren, kann der Läufer den Test zehnmal ausführen. Wenn Sie einen Runner eines Drittanbieters verwenden, können Sie mit 4.7 die neue @RuleAnnotation verwenden und die MethodRuleSchnittstelle so implementieren , dass sie die Anweisung aufnimmt und sie zehnmal in einer for-Schleife ausführt. Der aktuelle Nachteil dieses Ansatzes ist , dass @Beforeund @Aftererhält nur einmal ausgeführt. Dies wird sich wahrscheinlich in der nächsten Version von JUnit ändern (die @Beforewird nach der ausgeführt @Rule), aber unabhängig davon, ob Sie auf dieselbe Instanz des Objekts reagieren (etwas, das für den ParameterizedLäufer nicht zutrifft ). Dies setzt voraus, dass jeder Läufer, mit dem Sie die Klasse ausführen, die @RuleAnmerkungen korrekt erkennt . Dies ist nur dann der Fall, wenn es an die JUnit-Läufer delegiert.

Wenn Sie mit einem benutzerdefinierten Runner arbeiten, der die @RuleAnmerkung nicht erkennt , müssen Sie wirklich Ihren eigenen Runner schreiben, der entsprechend an diesen Runner delegiert und ihn zehnmal ausführt.

Beachten Sie, dass es andere Möglichkeiten gibt, dies möglicherweise zu lösen (z. B. den Theories-Läufer), für die jedoch alle ein Läufer erforderlich ist. Leider unterstützt JUnit derzeit keine Schichten von Läufern. Das ist ein Läufer, der andere Läufer kettet.

Mit IntelliJ können Sie dies über die Testkonfiguration tun. Sobald Sie dieses Fenster geöffnet haben, können Sie den Test beliebig oft ausführen.

Wenn Sie den Test ausführen, führt Intellij alle von Ihnen ausgewählten Tests so oft aus, wie Sie es angegeben haben.

Beispiel für 10-maliges Ausführen von 624 Tests:

Ich habe festgestellt, dass die wiederholte Anmerkung von Spring für solche Dinge nützlich ist:

@Repeat(value = 10)

Neuestes Dokument (Spring Framework 4.3.11.RELEASE API):

• org.springframework.test.annotation
• Unit Testing im Frühjahr

Inspiriert von folgenden Ressourcen:

• Blogeintrag
• diese Lösung
• kommentierte Version

Beispiel

Erstellen und verwenden Sie eine @RepeatAnmerkung wie folgt:

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

Die Verwendung dieser Lösung mit @RunWith(PowerMockRunner.class)erfordert ein Update auf Powermock 1.6.5 (das einen Patch enthält ).

Mit JUnit 5 konnte ich dies mithilfe der Annotation @RepeatedTest lösen :

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

Beachten Sie, dass @TestAnmerkungen nicht zusammen mit verwendet werden sollten @RepeatedTest.

Irgendwas falsch mit:

@Test
void itWorks() {
    // stuff
}

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

Im Gegensatz zu dem Fall, in dem Sie jedes einzelne Array von Werten testen, ist es Ihnen egal, welcher Lauf fehlgeschlagen ist.

Sie müssen in der Konfiguration oder in den Anmerkungen nicht tun, was Sie im Code tun können.

Das funktioniert für mich viel einfacher.

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

Es gibt eine intermittierende Anmerkung in der Tempus-Fugit- Bibliothek, die mit JUnit 4.7 zusammenarbeitet @Rule, um einen Test mehrmals oder mit zu wiederholen @RunWith.

Beispielsweise,

@RunWith(IntermittentTestRunner.class)
public class IntermittentTestRunnerTest {

   private static int testCounter = 0;

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

Nach dem Ausführen des Tests (mit dem IntermittentTestRunner im @RunWith) testCounterwäre gleich 99.

Ich baue ein Modul, das diese Art von Tests ermöglicht. Es wird aber nicht nur wiederholt fokussiert. Aber in der Garantie, dass ein Teil des Codes Thread-sicher ist.

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

Maven-Abhängigkeit:

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

Anwendungsbeispiel:

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

Dies ist ein Open Source-Projekt. Fühlen Sie sich frei zu verbessern.

Sie können Ihren JUnit-Test mit einer Hauptmethode ausführen und ihn so oft wiederholen, bis Sie Folgendes benötigen:

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

            }
        }

    }

}

Dies ist im Wesentlichen die Antwort, die Yishai oben in Kotlin neu geschrieben hat:

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