org.junit.runner
Class Request
public abstract class Request
extends java.lang.Object
A
Request
is an abstract description of tests to be run. Older versions of
JUnit did not need such a concept--tests to be run were described either by classes containing
tests or a tree of
Test
s. However, we want to support filtering and sorting,
so we need a more abstract specification than the tests themselves and a richer
specification than just the classes.
The flow when JUnit runs tests is that a
Request
specifies some tests to be run ->
a
Runner
is created for each class implied by the
Request
->
the
Runner
returns a detailed
Description
which is a tree structure of the tests to be run.
static Request | aClass(Class> clazz) - Create a
Request that, when processed, will run all the tests
in a class.
|
static Request | classWithoutSuiteMethod(Class> newTestClass)
|
static Request | classes(String collectionName, Class>... classes) - Create a
Request that, when processed, will run all the tests
in a set of classes.
|
static Request | errorReport(Class> klass, Throwable cause)
|
Request | filterWith(Description desiredDescription) - Returns a Request that only runs contains tests whose
Description
equals desiredDescription
|
Request | filterWith(Filter filter) - Returns a Request that only contains those tests that should run when
filter is applied
|
abstract Runner | getRunner() - Returns a
Runner for this Request
|
static Request | method(Class> clazz, String methodName) - Create a
Request that, when processed, will run a single test.
|
Request | sortWith(Comparator comparator) - Returns a Request whose Tests can be run in a certain order, defined by
comparator
For example, here is code to run a test suite in alphabetical order:
private static Comparator forward() {
return new Comparator() {
public int compare(Description o1, Description o2) {
return o1.getDisplayName().compareTo(o2.getDisplayName());
}
};
}
public static main() {
new JUnitCore().run(Request.aClass(AllTests.class).sortWith(forward()));
}
|
aClass
public static Request aClass(Class> clazz)
Create a Request
that, when processed, will run all the tests
in a class. The odd name is necessary because class
is a reserved word.
clazz
- the class containing the tests
- a
Request
that will cause all tests in the class to be run
classWithoutSuiteMethod
public static Request classWithoutSuiteMethod(Class> newTestClass)
classes
public static Request classes(String collectionName,
Class>... classes)
Create a Request
that, when processed, will run all the tests
in a set of classes.
collectionName
- a name to identify this suite of testsclasses
- the classes containing the tests
- a
Request
that will cause all tests in the classes to be run
errorReport
public static Request errorReport(Class> klass,
Throwable cause)
filterWith
public Request filterWith(Description desiredDescription)
Returns a Request that only runs contains tests whose
Description
equals
desiredDescription
desiredDescription
- Description
of those tests that should be run
filterWith
public Request filterWith(Filter filter)
Returns a Request that only contains those tests that should run when
filter
is applied
filter
- The Filter
to apply to this Request
getRunner
public abstract Runner getRunner()
Returns a
Runner
for this Request
- corresponding
Runner
for this Request
method
public static Request method(Class> clazz,
String methodName)
Create a Request
that, when processed, will run a single test.
This is done by filtering out all other tests. This method is used to support rerunning
single tests.
clazz
- the class of the testmethodName
- the name of the test
- a
Request
that will cause a single test be run
sortWith
public Request sortWith(Comparator comparator)
Returns a Request whose Tests can be run in a certain order, defined by
comparator
For example, here is code to run a test suite in alphabetical order:
private static Comparator forward() {
return new Comparator() {
public int compare(Description o1, Description o2) {
return o1.getDisplayName().compareTo(o2.getDisplayName());
}
};
}
public static main() {
new JUnitCore().run(Request.aClass(AllTests.class).sortWith(forward()));
}
comparator
- definition of the order of the tests in this Request
- a Request with ordered Tests