Ausführen von JUnit-Tests parallel auf Suite-Ebene?

Ich habe eine Reihe von tests, die organisiert sind in JUnit-test-Suiten. Diese tests sind sehr Nutzung von selenium zum testen einer web-Anwendung. So, naturaly für Selen, die Laufzeit dieser tests ist ziemlich lang. Da die test-Klassen in den Suiten können nicht parallel laufen aufgrund einiger überschneidungen in der test-Datenbank, ich würde gerne die Suiten parallel.

JUnit ParallelComputer kann nur ausführen von tests auf Klassen-oder methodenebene parallel, gibt es irgendwelche standard-Möglichkeiten für JUnit zu tun, die mit suites?

Wenn ich nur pass suite Klassen des junit-runner und konfigurieren Sie den computer zu parallelisieren, auf Klasse Niveau, wählt er die test-Klassen selbst, nicht die Suiten.

br
Frank

InformationsquelleAutor Frank | 2011-04-15
  1. 11

    Hier ist etwas code, der für mich gearbeitet. Ich wollte nicht schreiben. Wenn Sie @RunWith(ConcurrentSuite.class) statt @RunWith(Suite.class) sollte es funktionieren. Es ist eine Anmerkung, die ist auch notwendig, die Sie unten finden.

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

}

    Und die Anmerkung ist wie folgt. 

    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;
}
    InformationsquelleAutor Reid Mac
  2. 2

    Seit Suite wird verwendet, um Anmerkungen zu einer Klasse, so führen Sie die Suite-annotierten Klasse JUnitCore.runClasses(ParallelComputer.classes(), cls) Weg. cls sind Suite-annotierten Klassen.

    @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})
    • Hallo, vielen Dank für die quik Antwort. Leider wird das nicht führen Sie den test in der Art habe ich gedacht. Wie schrieb ich am Ende meiner Frage, dieser führt die tests Klassen innerhalb der suite parallel, nicht die Suiten selbst.
    • Ihr Beispiel führen Sie die folgende Weise: Test1 und Test2 parallel laufen, genau das Verhalten, das ich verhindern müssen.
    • Herzlich willkommen! Wenn mein code kann dir nicht helfen, schreiben Sie die multi-thread zum ausführen Suites(wenn keine bessere Lösung).
    • Ich war über dieses denken, aber wenn ich das mache, habe ich zum aggregieren der junit Ergebnis mich selbst, weil ich brauche das für test-Bericht. Aber vielen Dank für deine schnelle Hilfe!
    InformationsquelleAutor 卢声远 Shengyuan Lu
Schreibe einen Kommentar