org.junit.runner
Class Request

java.lang.Object
  extended by org.junit.runner.Request

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

Since:
4.0

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 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
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Constructor Detail

Request

public Request()
Method Detail

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

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<?> clazz)
Create a Request that, when processed, will run all the tests in a class. If the class has a suite() method, it will be ignored.

Parameters:
clazz - the class containing the tests
Returns:
a Request that will cause all tests in the class to be run

classes

public static Request classes(Computer computer,
                              Class<?>... classes)
Create a Request that, when processed, will run all the tests in a set of classes.

Parameters:
computer - Helps construct Runners from classes
classes - the classes containing the tests
Returns:
a Request that will cause all tests in the classes to be run

classes

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

Parameters:
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)
Creates a Request that, when processed, will report an error for the given test class with the given cause.


runner

public static Request runner(Runner runner)
Parameters:
runner - the runner to return
Returns:
a Request that will run the given runner when invoked

getRunner

public abstract Runner getRunner()
Returns a Runner for this Request

Returns:
corresponding Runner for this 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

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

sortWith

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

Parameters:
comparator - definition of the order of the tests in this Request
Returns:
a Request with ordered Tests


Copyright © 2002–2018 JUnit. All rights reserved.