|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||
java.lang.Objectorg.junit.runner.Request
public abstract class Request
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 Tests. 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 Summary | |
|---|---|
Request()
|
|
| Method Summary | |
|---|---|
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)
Creates a Request that, when processed, will report an error for the given
test class with the given cause. |
Request |
filterWith(Description desiredDescription)
Returns a Request that only runs tests whose Description
matches the given description. |
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 |
orderWith(Ordering ordering)
Returns a Request whose Tests can be run in a certain order, defined by ordering |
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 |
| Methods inherited from class java.lang.Object |
|---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Constructor Detail |
|---|
public Request()
| Method Detail |
|---|
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 test
Request 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 tests
Request 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 tests
Request that will cause all tests in the class to be run
public 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 tests
Request 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 tests
Request that will cause all tests in the classes to be run
public static Request errorReport(Class<?> klass,
Throwable cause)
Request that, when processed, will report an error for the given
test class with the given cause.
public static Request runner(Runner runner)
runner - the runner to return
Request that will run the given runner when invokedpublic abstract Runner getRunner()
Runner for this Request
Runner for this Requestpublic Request filterWith(Filter filter)
filter is applied
filter - The Filter to apply to this Request
public Request filterWith(Description desiredDescription)
Description
matches the given description.
Returns an empty Request if desiredDescription is not a single test and filters all but the single
test if desiredDescription is a single test.
desiredDescription - Description of those tests that should be run
public Request sortWith(Comparator<Description> comparator)
comparator
For example, here is code to run a test suite in alphabetical order:
private static Comparator<Description> forward() {
return new Comparator<Description>() {
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
public Request orderWith(Ordering ordering)
ordering
For example, here is code to run a test suite in reverse order:
private static Ordering reverse() {
return new Ordering() {
public List<Description> orderItems(Collection<Description> descriptions) {
List<Description> ordered = new ArrayList<>(descriptions);
Collections.reverse(ordered);
return ordered;
}
}
}
public static main() {
new JUnitCore().run(Request.aClass(AllTests.class).orderWith(reverse()));
}
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||