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 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.

Method Summary

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()));
}
 

Method Details

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.
Parameters:
clazz - the class containing the tests
Returns:
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.
Parameters:
collectionName - a name to identify this suite of tests
classes - the classes containing the tests
Returns:
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
Parameters:
desiredDescription - Description of those tests that should be run
Returns:
the filtered Request

filterWith

public Request filterWith(Filter filter)
Returns a Request that only contains those tests that should run when filter is applied
Parameters:
filter - The Filter to apply to this Request
Returns:
the filtered Request

getRunner

public abstract Runner getRunner()
Returns a Runner for this Request
Returns:
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.
Parameters:
clazz - the class of the test
methodName - the name of the test
Returns:
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()));
}
 
Parameters:
comparator - definition of the order of the tests in this Request
Returns:
a Request with ordered Tests