Comme le titre l'indique, je cherche un moyen simple d'exécuter des tests JUnit 4.x plusieurs fois de suite automatiquement en utilisant Eclipse.

Un exemple serait d'exécuter le même test 10 fois de suite et de rendre compte du résultat.

Nous avons déjà une façon complexe de faire cela, mais je cherche une façon simple de le faire afin que je puisse être certain que le test irrégulier que j'ai essayé de corriger reste fixe.

Une solution idéale serait un plugin / paramètre / fonctionnalité Eclipse que je ne connais pas.

Le moyen le plus simple (avec le moins de nouveau code requis) pour ce faire est d'exécuter le test en tant que test paramétré (annoter avec @RunWith(Parameterized.class)et ajouter une méthode pour fournir 10 paramètres vides). De cette façon, le framework exécutera le test 10 fois.

Ce test devrait être le seul test de la classe, ou mieux, toutes les méthodes de test devraient être exécutées 10 fois dans la classe.

Voici un exemple:

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

Avec ce qui précède, il est même possible de le faire avec un constructeur sans paramètre, mais je ne suis pas sûr si les auteurs du framework l'ont voulu, ou si cela se cassera à l'avenir.

Si vous implémentez votre propre coureur, vous pouvez demander au coureur d'exécuter le test 10 fois. Si vous utilisez un runner tiers, avec 4.7, vous pouvez utiliser la nouvelle @Ruleannotation et implémenter l' MethodRuleinterface afin qu'elle prenne l'instruction et l'exécute 10 fois dans une boucle for. L'inconvénient actuel de cette approche est que @Beforeet @Afters'exécuter qu'une seule fois. Cela changera probablement dans la prochaine version de JUnit (le @Beforefonctionnera après le @Rule), mais quoi qu'il en soit, vous agirez sur la même instance de l'objet (ce qui n'est pas vrai pour le Parameterizedcoureur). Cela suppose que le coureur avec lequel vous exécutez la classe reconnaît correctement les @Ruleannotations. Ce n'est le cas que s'il délègue aux coureurs JUnit.

Si vous exécutez avec un coureur personnalisé qui ne reconnaît pas l' @Ruleannotation, vous êtes vraiment obligé d'écrire votre propre coureur qui délègue de manière appropriée à ce coureur et l'exécute 10 fois.

Notez qu'il existe d'autres moyens de résoudre ce problème (comme le runner Theories), mais ils nécessitent tous un runner. Malheureusement, JUnit ne prend actuellement pas en charge les couches de coureurs. C'est un coureur qui enchaîne d'autres coureurs.

Avec IntelliJ, vous pouvez le faire à partir de la configuration de test. Une fois que vous ouvrez cette fenêtre, vous pouvez choisir d'exécuter le test autant de fois que vous le souhaitez.

lorsque vous exécutez le test, intellij exécutera tous les tests que vous avez sélectionnés pour le nombre de fois que vous avez spécifié.

Exemple exécutant 624 tests 10 fois:

J'ai trouvé que l'annotation de répétition de Spring est utile pour ce genre de chose:

@Repeat(value = 10)

Dernier document (API Spring Framework 4.3.11.RELEASE):

• org.springframework.test.annotation
• Tests unitaires au printemps

Inspiré des ressources suivantes:

• article de blog
• cette solution
• version commentée

Exemple

Créez et utilisez une @Repeatannotation comme suit:

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

L'utilisation de cette solution avec @RunWith(PowerMockRunner.class), nécessite une mise à jour vers Powermock 1.6.5 (qui inclut un correctif ).

Avec JUnit 5, j'ai pu résoudre ce problème en utilisant l' annotation @RepeatedTest :

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

Notez que l' @Testannotation ne doit pas être utilisée avec @RepeatedTest.

Quelque chose ne va pas avec:

@Test
void itWorks() {
    // stuff
}

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

Contrairement au cas où vous testez chacune d'un tableau de valeurs, vous ne vous souciez pas particulièrement de l'échec de l'exécution.

Pas besoin de faire en configuration ou en annotation ce que vous pouvez faire dans le code.

Cela fonctionne beaucoup plus facilement pour moi.

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

Il y a une annotation intermittente dans la bibliothèque tempus-fugit qui fonctionne avec JUnit 4.7 @Rulepour répéter un test plusieurs fois ou avec @RunWith.

Par exemple,

@RunWith(IntermittentTestRunner.class)
public class IntermittentTestRunnerTest {

   private static int testCounter = 0;

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

Une fois le test exécuté (avec IntermittentTestRunner dans le @RunWith), testCounterserait égal à 99.

Je construis un module qui permet de faire ce genre de tests. Mais il ne se concentre pas uniquement sur la répétition. Mais pour garantir que certains morceaux de code sont sécurisés pour les threads.

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

Dépendance Maven:

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

Exemple d'utilisation:

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

C'est un projet open source. N'hésitez pas à vous améliorer.

Vous pouvez exécuter votre test JUnit à partir d'une méthode principale et le répéter autant de fois que vous en avez besoin:

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

            }
        }

    }

}

C'est essentiellement la réponse que Yishai a fournie ci-dessus, réécrite en 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() { }
}