| java.lang.Object
 org.junit.runner.Request
All known Subclasses: org.junit.internal.requests.FilterRequest, org.junit.internal.requests.ErrorReportingRequest, org.junit.internal.requests.SortingRequest, org.junit.internal.requests.ClassRequest, org.junit.internal.requests.ClassesRequest,
| Request | | abstract public class Request (Code) | | 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
org.junit.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
org.junit.runner.Runner is created for each class implied by the Request ->
the
org.junit.runner.Runner returns a detailed
org.junit.runner.Description
which is a tree structure of the tests to be run.
|
| aClass | | public static Request aClass(Class clazz)(Code) | | 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.
Parameters:
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)(Code) | | |
| classes | | public static Request classes(String collectionName, Class... classes)(Code) | | Create a Request that, when processed, will run all the tests
in a set of classes.
Parameters:
collectionName - a name to identify this suite of tests
Parameters:
classes - the classes containing the tests a Request that will cause all tests in the classes to be run |
| filterWith | | public Request filterWith(Filter filter)(Code) | | Returns a Request that only contains those tests that should run when
filter is applied
Parameters:
filter - The Filter to apply to this Request the filtered Request |
| filterWith | | public Request filterWith(Description desiredDescription)(Code) | | Returns a Request that only runs contains tests whose
Description equals desiredDescription
Parameters:
desiredDescription - Description of those tests that should be run the filtered Request |
| getRunner | | abstract public Runner getRunner()(Code) | | Returns a
Runner for this Request
corresponding Runner for this Request |
| method | | public static Request method(Class clazz, String methodName)(Code) | | 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.
Parameters:
clazz - the class of the test
Parameters:
methodName - the name of the test a Request that will cause a single test be run |
| sortWith | | public Request sortWith(Comparator<Description> comparator)(Code) | | 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()));
}
Parameters:
comparator - definition of the order of the tests in this Request a Request with ordered Tests |
|
|