## 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 `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 `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 tests whose `Description` matches the given description.
`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` `orderWith(Ordering ordering)` Returns a Request whose Tests can be run in a certain order, defined by `ordering`
`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 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–2020 JUnit. All rights reserved.