private static Runner parallelize(Runner runner) {
    int nThreads = Integer.getInteger(Constants.NTHREADS, Runtime.getRuntime().availableProcessors());
    LOGGER.info("Using " + nThreads + " threads.");
    if (runner instanceof ParentRunner) {
        ((ParentRunner<?>) runner).setScheduler(new RunnerScheduler() {
            private final ExecutorService fService = Executors.newFixedThreadPool(nThreads);

            @Override
            public void schedule(Runnable childStatement) {
                fService.submit(childStatement);
            }

            @Override
            public void finished() {
                try {
                    fService.shutdown();
                    fService.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
                } catch (InterruptedException e) {
                    e.printStackTrace(System.err);
                }
            }
        });
    }
    return runner;
}
 

public Parallelized(Class<?> klass) throws Throwable {
    super(klass);

    setScheduler(new RunnerScheduler() {
        private final ExecutorService service = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

        public void schedule(Runnable childStatement) {
            service.submit(childStatement);
        }

        public void finished() {
            try {
                service.shutdown();
                service.awaitTermination(5, TimeUnit.MINUTES);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    });
}
 

public ConcurrentJunitRunner(final Class<?> klass) throws InitializationError {
	super(klass);
	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();
			}
		}
	});
}
 

@Override
public void setScheduler(RunnerScheduler scheduler) {
  for (Runner child : getChildren()) {
    if (child instanceof ParentRunner<?>) {
      ((ParentRunner<?>) child).setScheduler(scheduler);
    }
  }
}
 

private void runChildren(final RunNotifier notifier) {
    final RunnerScheduler currentScheduler = scheduler;
    try {
        for (final FrameworkMethod each : getFilteredChildren()) {
            currentScheduler.schedule(new Runnable() {
                public void run() {
                    runChild(each, notifier);
                }
            });
        }
    } finally {
        currentScheduler.finished();
    }
}
 

private void runChildren(final RunNotifier notifier) {
    final RunnerScheduler currentScheduler = scheduler;

    try {
        for (final Runner each : getFilteredChildren()) {
            currentScheduler.schedule(new Runnable() {
                public void run() {
                    runChild(each, notifier);
                }
            });
        }
    } finally {
        currentScheduler.finished();
    }
}
 

@Override
public void setScheduler(RunnerScheduler scheduler) {
  super.setScheduler(scheduler);
  multiThreadingAssumed = true;
}
 

@Override
public void setScheduler(RunnerScheduler scheduler)
{
    cucumber.setScheduler(scheduler);
}
 

@Override
public void setScheduler(RunnerScheduler scheduler) {
	super.setScheduler(scheduler);
	this.scheduler = scheduler;
}
 

@Override
public void setScheduler(RunnerScheduler scheduler) {
	super.setScheduler(scheduler);
	this.scheduler = scheduler;
}