L'exécution de Test JUnit en parallèle sur la Suite?

J'ai un tas de tests qui sont organisés dans les suites de test JUnit. Ces tests sont grandement utilisant le sélénium pour tester une application web. Alors, bien sûr pour le sélénium, le moteur d'exécution de ces tests est assez longue. Depuis les classes de test dans les suites ne peuvent pas s'exécuter en parallèle en raison des chevauchements dans la base de données de test, je voudrais que les suites parallèles.

JUnit ParallelComputer ne peut exécuter des tests sur une classe ou une méthode de niveau en parallèle, il y a aucune façon standard pour JUnit pour le faire avec des suites?

Si je viens de passer à la suite de classes à la runner junit et configurer l'ordinateur pour paralléliser sur le niveau de la classe, il récupère les classes de test lui-même, pas les suites.

br
Frank

OriginalL'auteur Frank | 2011-04-15

  1. 10

    Voici un code qui a fonctionné pour moi. Je n'ai pas écrit cela. Si vous utilisez @RunWith(ConcurrentSuite.class) au lieu de @RunWith(Suite.class) il devrait fonctionner. Il y a une annotation qui est également nécessaire qui se trouve ci-dessous.

    package utilities.runners;
import org.junit.internal.builders.AllDefaultPossibilitiesBuilder;
import org.junit.runner.Runner;
import org.junit.runners.Suite;
import org.junit.runners.model.InitializationError;
import org.junit.runners.model.RunnerBuilder;
import org.junit.runners.model.RunnerScheduler;
import utilities.annotations.Concurrent;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author Mathieu Carbou ([email protected])
*/
public final class ConcurrentSuite extends Suite {
public ConcurrentSuite(final Class<?> klass) throws InitializationError {
super(klass, new AllDefaultPossibilitiesBuilder(true) {
@Override
public Runner runnerForClass(Class<?> testClass) throws Throwable {
List<RunnerBuilder> builders = Arrays.asList(
new RunnerBuilder() {
@Override
public Runner runnerForClass(Class<?> testClass) throws Throwable {
Concurrent annotation = testClass.getAnnotation(Concurrent.class);
if (annotation != null)
return new ConcurrentJunitRunner(testClass);
return null;
}
},
ignoredBuilder(),
annotatedBuilder(),
suiteMethodBuilder(),
junit3Builder(),
junit4Builder());
for (RunnerBuilder each : builders) {
Runner runner = each.safeRunnerForClass(testClass);
if (runner != null)
return runner;
}
return null;
}
});
setScheduler(new RunnerScheduler() {
ExecutorService executorService = Executors.newFixedThreadPool(
klass.isAnnotationPresent(Concurrent.class) ?
klass.getAnnotation(Concurrent.class).threads() :
(int) (Runtime.getRuntime().availableProcessors() * 1.5),
new NamedThreadFactory(klass.getSimpleName()));
CompletionService<Void> completionService = new ExecutorCompletionService<Void>(executorService);
Queue<Future<Void>> tasks = new LinkedList<Future<Void>>();
@Override
public void schedule(Runnable childStatement) {
tasks.offer(completionService.submit(childStatement, null));
}
@Override
public void finished() {
try {
while (!tasks.isEmpty())
tasks.remove(completionService.take());
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
while (!tasks.isEmpty())
tasks.poll().cancel(true);
executorService.shutdownNow();
}
}
});
}
static final class NamedThreadFactory implements ThreadFactory {
static final AtomicInteger poolNumber = new AtomicInteger(1);
final AtomicInteger threadNumber = new AtomicInteger(1);
final ThreadGroup group;
NamedThreadFactory(String poolName) {
group = new ThreadGroup(poolName + "-" + poolNumber.getAndIncrement());
}
@Override
public Thread newThread(Runnable r) {
return new Thread(group, r, group.getName() + "-thread-" + threadNumber.getAndIncrement(), 0);
}
}
}

    Et l'annotation est comme suit. 

    package utilities.annotations;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* @author Mathieu Carbou ([email protected])
*/
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.TYPE })
public @interface Concurrent {
int threads() default 5;
}
    Ressemble à une copie de ce code est disponible à cette adresse mycila.googlecode.com/svn/sandbox/src/main/java/com/mycila/...
    Oui, je devrais avoir inclus le lien. Merci.
    Cela a fonctionné après l'ajout d'un autre constructeur: public ConcurrentSuite(Classe<?> klass, RunnerBuilder builder) throws InitializationError { ce(klass); }
    Comme le lien est mort maintenant les pré-compilé jar et des sources sur Maven: mvnrepository.com/artifact/com.mycila/mycila-junit et un échantillon aléatoire

    OriginalL'auteur Reid Mac

  2. 1

    Puisque la Suite est utilisé pour annoter une Classe, afin d'exécuter la Suite annotées à la classe dans JUnitCore.runClasses(ParallelComputer.classes(), cls). cls sont Suite annotée classes.

    @RunWith(Suite.class)
@Suite.SuiteClasses({
Test1.class,
Test2.class})
public class Suite1 {
}
@RunWith(Suite.class)
@Suite.SuiteClasses({
Test3.class,
Test4.class})
public class Suite2 {
}
...
JUnitCore.runClasses(ParallelComputer.classes(), new Class[]{Suite1.class, Suite2.class})
    Salut, merci pour le quik réponse. Malheureusement, ce n'est pas exécuter le test dans la façon dont j'ai prévu. Comme je l'ai écrit à la fin de ma question, cela va les classes de tests à l'intérieur de la suite, en parallèle, de ne pas les suites.
    Votre exemple n'exécuter de la manière suivante: Test1 et Test2 parallèles, exactement le comportement que je doit éviter.
    Bienvenue! Si mon code ne peut pas vous aider, vous pouvez écrire multi thread à exécuter vos Suites(si pas de meilleure solution).
    Je pensais à ce sujet, mais si je fais cela, j'ai pour agréger les junit résultat moi-même, parce que j'en ai besoin pour le rapport de test. Mais merci pour votre aide rapide!

    OriginalL'auteur 卢声远 Shengyuan Lu