public abstract class Request extends 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.
Constructor and Description |
---|
Request() |
Modifier and Type | Method and Description |
---|---|
static Request |
aClass(Class<?> clazz)
Create a
Request that, when processed, will run all the tests
in a class. |
static Request |
classes(Class<?>... classes)
Create a
Request that, when processed, will run all the tests
in a set of classes with the default Computer . |
static Request |
classes(Computer computer,
Class<?>... classes)
Create a
Request that, when processed, will run all the tests
in a set of classes. |
static Request |
classWithoutSuiteMethod(Class<?> clazz)
Create a
Request that, when processed, will run all the tests
in a class. |
static Request |
errorReport(Class<?> klass,
Throwable cause)
Deprecated.
|
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. |
static Request |
runner(Runner runner) |
Request |
sortWith(Comparator<Description> 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 |
public static Request method(Class<?> clazz, String methodName)
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 testRequest
that will cause a single test be runpublic static Request aClass(Class<?> clazz)
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 testsRequest
that will cause all tests in the class to be runpublic static Request classWithoutSuiteMethod(Class<?> clazz)
Request
that, when processed, will run all the tests
in a class. If the class has a suite() method, it will be ignored.clazz
- the class containing the testsRequest
that will cause all tests in the class to be runpublic static Request classes(Computer computer, Class<?>... classes)
Request
that, when processed, will run all the tests
in a set of classes.computer
- Helps construct Runners from classesclasses
- the classes containing the testsRequest
that will cause all tests in the classes to be runpublic static Request classes(Class<?>... classes)
Request
that, when processed, will run all the tests
in a set of classes with the default Computer
.classes
- the classes containing the testsRequest
that will cause all tests in the classes to be run@Deprecated public static Request errorReport(Class<?> klass, Throwable cause)
public static Request runner(Runner runner)
runner
- the runner to returnRequest
that will run the given runner when invokedpublic abstract Runner getRunner()
Runner
for this RequestRunner
for this Requestpublic Request filterWith(Filter filter)
filter
is appliedfilter
- The Filter
to apply to this Requestpublic Request filterWith(Description desiredDescription)
Description
equals desiredDescription
desiredDescription
- Description
of those tests that should be runpublic Request sortWith(Comparator<Description> comparator)
comparator
For example, here is code to run a test suite in alphabetical order:
private static Comparatorforward() { 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