Un moyen facile d'exécuter le même test Junit à plusieurs reprises?

Question

Comme le dit le titre, je suis à la recherche pour certains moyen simple d'exécuter JUnit 4.x les tests plusieurs fois dans une rangée automatiquement à l'aide d'Eclipse.

Un exemple serait courir le même test 10 fois de suite, et de faire rapport sur le résultat.

Nous avons déjà un complexe de le faire, mais je suis à la recherche d'un moyen simple de faire en sorte que je peux être sorta assurer que l'feuilletée essai, j'ai essayé de corriger reste fixe.

Une solution idéale serait d'avoir un plugin Eclipse/réglage/fonction que je ne suis pas au courant de.

Answer 1

La méthode la plus simple (comme dans moins d'un nouveau code nécessaire) façon de le faire est d'exécuter le test un paramétrées test (annoter avec une annotation @RunWith(Parameterized.class) et ajouter une méthode à 10 paramètres vides). De cette façon, le cadre de l'exécution du test 10 fois.

Ce test devrait être le seul test dans la classe, ou mieux de mettre toutes les méthodes d'essai doit être exécuté 10 fois dans la classe.

Voici un exemple:

@RunWith(Parameterized.class)
public class RunTenTimes {
    @Parameterized.Parameters
    public static List<Object[]> data() {
        return Arrays.asList(new Object[10][0]);
    }

    public RunTenTimes() {
    }

    @Test
    public void runsTenTimes() {
        System.out.println("run");
    }
}

EDIT: Avec ce qui précède, il est possible de le faire avec un constructeur sans paramètre, mais je ne suis pas sûr si le cadre auteurs ont prévu que, ou si cela va se rompre dans l'avenir.

MODIFIER (en réponse à un commentaire): Si vous êtes à la mise en œuvre de votre propre coureur, vous pourriez avoir le coureur de l'exécution du test 10 fois. Si vous utilisez un tiers coureur, puis, avec plus de 4,7, vous pouvez utiliser le nouveau @Règle d'annotation et de mettre en œuvre les MethodRule interface afin qu'il prenne l'instruction et l'exécute 10 fois dans une boucle for. Le désavantage de cette approche est qu' @Before et @Après avoir exécuté qu'une seule fois. Ce sera probablement changer dans la prochaine version de JUnit (le @Avant sera exécuté après le @de la Règle), mais peu importe, vous serez en agissant sur la même instance de l'objet (quelque chose qui n'est pas vrai de la Paramétrée runner). Cela suppose que ce que coureur vous êtes l'exécution de la classe avec reconnaît correctement les @Règle des annotations. C'est seulement le cas si elle est de déléguer à la JUnit coureurs.

Si vous êtes en cours d'exécution avec un coureur qui ne reconnaît pas le @Règle d'annotation, alors vous êtes vraiment coincé avec le devoir écrire votre propre coureur qui délègue de façon appropriée pour que le Coureur et l'exécute 10 fois.

Notez qu'il existe d'autres moyens pour éventuellement résoudre ce (tels que les Théories runner), mais ils nécessitent tous un coureur. Malheureusement, JUnit ne prend pas actuellement en charge les calques de coureurs. C'est un coureur que les chaînes d'autres coureurs.

Answer 2

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

@Répéter (valeur = 10)

http://static.springsource.org/spring/docs/2.5.6/reference/testing.html http://static.springsource.org/spring/docs/2.5.x/api/org/springframework/test/annotation /Repeat.html

Answer 3

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 des valeurs d'un tableau, vous ne vous souciez pas de savoir si l'exécution a échoué.

Pas besoin de faire dans la configuration ou l'annotation ce que vous pouvez faire dans le code.

Answer 4

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

Answer 5

Une annotation intermittente dans la bibliothèque tempus-fugit fonctionne avec @Rule de JUnit 4.7 pour 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 @RunWith), testCounter serait égal à 99.