package org.junit.runners.model;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.junit.internal.runners.ErrorReportingRunner;
import org.junit.runner.Runner;
/**
* A RunnerBuilder is a strategy for constructing runners for classes.
*
* Only writers of custom runners should use <code>RunnerBuilder</code>s. A custom runner class with a constructor taking
* a <code>RunnerBuilder</code> parameter will be passed the instance of <code>RunnerBuilder</code> used to build that runner itself.
* For example,
* imagine a custom runner that builds suites based on a list of classes in a text file:
*
* <pre>
* \@RunWith(TextFileSuite.class)
* \@SuiteSpecFile("mysuite.txt")
* class MySuite {}
* </pre>
*
* The implementation of TextFileSuite might include:
*
* <pre>
* public TextFileSuite(Class testClass, RunnerBuilder builder) {
* // ...
* for (String className : readClassNames())
* addRunner(builder.runnerForClass(Class.forName(className)));
* // ...
* }
* </pre>
*
* @see org.junit.runners.Suite
*/
public abstract class RunnerBuilder {
private final Set<Class<?>> parents= new HashSet<Class<?>>();
/**
* Override to calculate the correct runner for a test class at runtime.
*
* @param testClass class to be run
* @return a Runner
* @throws Throwable if a runner cannot be constructed
*/
public abstract Runner runnerForClass(Class<?> testClass) throws Throwable;
/**
* Always returns a runner, even if it is just one that prints an error instead of running tests.
* @param testClass class to be run
* @return a Runner
*/
public Runner safeRunnerForClass(Class<?> testClass) {
try {
return runnerForClass(testClass);
} catch (Throwable e) {
return new ErrorReportingRunner(testClass, e);
}
}
Class<?> addParent(Class<?> parent) throws InitializationError {
if (!parents.add(parent))
throw new InitializationError(String.format("class '%s' (possibly indirectly) contains itself as a SuiteClass", parent.getName()));
return parent;
}
void removeParent(Class<?> klass) {
parents.remove(klass);
}
/**
* Constructs and returns a list of Runners, one for each child class in
* {@code children}. Care is taken to avoid infinite recursion:
* this builder will throw an exception if it is requested for another
* runner for {@code parent} before this call completes.
*/
public List<Runner> runners(Class<?> parent, Class<?>[] children)
throws InitializationError {
addParent(parent);
try {
return runners(children);
} finally {
removeParent(parent);
}
}
public List<Runner> runners(Class<?> parent, List<Class<?>> children)
throws InitializationError {
return runners(parent, children.toArray(new Class<?>[0]));
}
private List<Runner> runners(Class<?>[] children) {
ArrayList<Runner> runners= new ArrayList<Runner>();
for (Class<?> each : children) {
Runner childRunner= safeRunnerForClass(each);
if (childRunner != null)
runners.add(childRunner);
}
return runners;
}
}
|