org.junit.runner
Class Request

java.lang.Object
  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

     

Request

public 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

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

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

orderWith

public Request orderWith(Ordering ordering)

Returns a Request whose Tests can be run in a certain order, defined by 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()));
 }
 

Returns:

a Request with ordered Tests

Since:

4.13

Copyright © 2002–2021 JUnit. All rights reserved.