Java 类org.junit.runners.model.RunnerScheduler 实例源码

项目：marathonv5 文件：ParallelComputer.java

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

项目：aaf-junit 文件：ConcurrentDependsOnRunner.java

private void runChildren(@SuppressWarnings("hiding") final RunNotifier notifier) {
    RunnerScheduler currentScheduler = scheduler;
    try {
        List<FrameworkMethod> roots = graph.getRoots().stream().map(r -> nameToMethod.get(r)).collect(Collectors.toList());
        for (FrameworkMethod each : roots) {
            currentScheduler.schedule(new Runnable() {
                @Override
                public void run() {
                    ConcurrentDependsOnRunner.this.runChild(each, notifier);
                }
            });
        }
    } finally {
        currentScheduler.finished();
    }
}

项目：aaf-junit 文件：ConcurrentDependsOnClasspathSuite.java

private void runChildren(@SuppressWarnings("hiding") final RunNotifier notifier) {
    RunnerScheduler currentScheduler = scheduler;
    try {
        List<Runner> roots = graph.getRoots().stream().map(r -> nameToRunner.get(r)).collect(Collectors.toList());
        for (Runner each : roots) {
            currentScheduler.schedule(new Runnable() {
                @Override
                public void run() {
                    ConcurrentDependsOnClasspathSuite.this.runChild(each, notifier);
                }
            });
        }
    } finally {
        currentScheduler.finished();
    }
}

项目：typometer 文件：Parallelized.java

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

项目：pf-java-client 文件：ParallelSuite.java

public ParallelSuite(Class<?> klass, RunnerBuilder builder) throws InitializationError {

        super(klass, builder);

        setScheduler(new RunnerScheduler() {

            private final ExecutorService service = Executors.newCachedThreadPool();

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

            public void finished() {
                try {
                    service.shutdown();
                    service.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
                } catch (InterruptedException e) {
                    e.printStackTrace(System.err);
                }
            }
        });
    }

项目：sosiefier 文件：ParallelComputer.java

private static Runner parallelize(Runner runner) {
    if (runner instanceof ParentRunner) {
        ((ParentRunner<?>) runner).setScheduler(new RunnerScheduler() {
            private final ExecutorService fService = Executors.newCachedThreadPool();

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

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

项目：sosiefier 文件：ParentRunnerTest.java

@Test
public void useChildHarvester() throws InitializationError {
    log = "";
    ParentRunner<?> runner = new BlockJUnit4ClassRunner(FruitTest.class);
    runner.setScheduler(new RunnerScheduler() {
        public void schedule(Runnable childStatement) {
            log += "before ";
            childStatement.run();
            log += "after ";
        }

        public void finished() {
            log += "afterAll ";
        }
    });

    runner.run(new RunNotifier());
    assertEquals("before apple after before banana after afterAll ", log);
}

项目：pal 文件：ParallelParameterized.java

public ParallelParameterized(Class<?> arg0) throws Throwable {

        super(arg0);

        setScheduler(new RunnerScheduler() {

            private final ExecutorService service = Executors.newFixedThreadPool(8);

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

            public void finished() {
                try {
                    service.shutdown();
                    service.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
                } catch (InterruptedException e) {
                    e.printStackTrace(System.err);
                }
            }
        });
    }

项目：lcm 文件：ParallelComputer.java

private static Runner parallelize(Runner runner) {
    if (runner instanceof ParentRunner) {
        ((ParentRunner<?>) runner).setScheduler(new RunnerScheduler() {
            private final ExecutorService fService = Executors.newCachedThreadPool();

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

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

项目：junit 文件：ParallelComputer.java

private static Runner parallelize(Runner runner) {
    if (runner instanceof ParentRunner) {
        ((ParentRunner<?>) runner).setScheduler(new RunnerScheduler() {
            private final ExecutorService fService = Executors.newCachedThreadPool();

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

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

项目：junit 文件：ParentRunnerTest.java

@Test
public void useChildHarvester() throws InitializationError {
    log = "";
    ParentRunner<?> runner = new BlockJUnit4ClassRunner(FruitTest.class);
    runner.setScheduler(new RunnerScheduler() {
        public void schedule(Runnable childStatement) {
            log += "before ";
            childStatement.run();
            log += "after ";
        }

        public void finished() {
            log += "afterAll ";
        }
    });

    runner.run(new RunNotifier());
    assertEquals("before apple after before banana after afterAll ", log);
}

项目：org.openntf.domino 文件：ParallelComputer.java

private static Runner parallelize(Runner runner) {
    if (runner instanceof ParentRunner) {
        ((ParentRunner<?>) runner).setScheduler(new RunnerScheduler() {
            private final ExecutorService fService = Executors.newCachedThreadPool();

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

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

项目：health-and-care-developer-network 文件：ParentRunnerTest.java

@Test
public void useChildHarvester() throws InitializationError {
    log = "";
    ParentRunner<?> runner = new BlockJUnit4ClassRunner(FruitTest.class);
    runner.setScheduler(new RunnerScheduler() {
        public void schedule(Runnable childStatement) {
            log += "before ";
            childStatement.run();
            log += "after ";
        }

        public void finished() {
            log += "afterAll ";
        }
    });

    runner.run(new RunNotifier());
    assertEquals("before apple after before banana after afterAll ", log);
}

项目：shabdiz 文件：ParallelParameterized.java

/** Coppied from super constructor: Only called reflectively. Do not use problematically. */
public ParallelParameterized(final Class<?> test_class) throws Throwable {

    super(test_class);
    final String index_as_string = System.getProperty(TEST_PARAM_INDEX);
    next_host_index = new AtomicInteger();
    parameter_index = index_as_string != null ? Integer.valueOf(index_as_string) : null;
    configuration = getParallelizationAnnotation();
    process_builder = new AgentBasedJavaProcessBuilder();
    configure(configuration);
    setScheduler(new RunnerScheduler() {

        @Override
        public void schedule(final Runnable childStatement) {

            executor_service.execute(childStatement);
        }

        @Override
        public void finished() {

            executor_service.shutdown();
            try {
                executor_service.awaitTermination(10, TimeUnit.MINUTES);
            }
            catch (InterruptedException exc) {
                throw new RuntimeException(exc);
            }
        }
    });
}

项目：offheap-store 文件：ParallelParameterized.java

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

项目：commons-test 文件：ConcurrentJunitRunner.java

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<>(executorService);
        Queue<Future<Void>> tasks = new LinkedList<>();

        @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 (@SuppressWarnings("unused") InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                while (!tasks.isEmpty())
                    tasks.poll().cancel(true);
                executorService.shutdownNow();
            }
        }
    });
}

项目：sosiefier 文件：ParentRunner.java

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

项目：pinpoint 文件：PinpointPluginTestRunner.java

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

项目：pinpoint 文件：PinpointPluginTestSuite.java

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

项目：xtext-core 文件：AbstractParallelScenarioRunner.java

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

项目：commons-test 文件：ConcurrentSuite.java

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<?> testClass2) throws Throwable {
                            Concurrent annotation = testClass2.getAnnotation(Concurrent.class);
                            if (annotation != null)
                                return new ConcurrentJunitRunner(testClass2);
                            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<>(executorService);
        Queue<Future<Void>> tasks = new LinkedList<>();

        @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 (@SuppressWarnings("unused") InterruptedException e) {
                Thread.currentThread().interrupt();
            } finally {
                while (!tasks.isEmpty())
                    tasks.poll().cancel(true);
                executorService.shutdownNow();
            }
        }
    });
}

项目：j2objc 文件：ParentRunner.java

/**
 * Sets a scheduler that determines the order and parallelization
 * of children.  Highly experimental feature that may change.
 */
public void setScheduler(RunnerScheduler scheduler) {
    this.fScheduler = scheduler;
}

项目：sosiefier 文件：ParentRunner.java

/**
 * Sets a scheduler that determines the order and parallelization
 * of children.  Highly experimental feature that may change.
 */
public void setScheduler(RunnerScheduler scheduler) {
    this.fScheduler = scheduler;
}

项目：lcm 文件：ParentRunner.java

/**
 * Sets a scheduler that determines the order and parallelization
 * of children.  Highly experimental feature that may change.
 */
public void setScheduler(RunnerScheduler scheduler) {
    this.fScheduler = scheduler;
}

项目：orwell 文件：Corollaries.java

/**
 * Sets a scheduler that determines the order and parallelization
 * of children.  Highly experimental feature that may change.
 */
public void setScheduler(RunnerScheduler scheduler) {
    this.fScheduler = scheduler;
}

项目：junit 文件：ParentRunner.java

/**
 * Sets a scheduler that determines the order and parallelization
 * of children.  Highly experimental feature that may change.
 */
public void setScheduler(RunnerScheduler scheduler) {
    this.fScheduler = scheduler;
}

项目：org.openntf.domino 文件：ParentRunner.java

/**
 * Sets a scheduler that determines the order and parallelization
 * of children.  Highly experimental feature that may change.
 */
public void setScheduler(RunnerScheduler scheduler) {
    this.fScheduler = scheduler;
}