public abstract class

Request

extends Object
java.lang.Object
   ↳ org.junit.runner.Request
Known Direct Subclasses

Class Overview

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.

Summary

Public Constructors
Request()
Public Methods
static Request aClass(Class<?> clazz)
Create a Request that, when processed, will run all the tests in a class.
static Request classWithoutSuiteMethod(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 errorReport(Class<?> klass, Throwable cause)
Not used within JUnit.
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 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()));
        }
[Expand]
Inherited Methods
From class java.lang.Object

Public Constructors

public Request ()

Public Methods

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

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

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

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

public static Request errorReport (Class<?> klass, Throwable cause)

Not used within JUnit. Clients should simply instantiate ErrorReportingRunner themselves

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

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

public abstract Runner getRunner ()

Returns a Runner for this Request

Returns
  • corresponding Runner for this Request

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

public static Request runner (Runner runner)

Parameters
runner the runner to return
Returns
  • a Request that will run the given runner when invoked

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