Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.junit.runners
Class BlockJUnit4ClassRunner

    java.lang.Object
      org.junit.runner.Runner
          org.junit.runners.ParentRunner<FrameworkMethod>
              org.junit.runners.BlockJUnit4ClassRunner

All Implemented Interfaces:
  Describable, Filterable, Sortable

Direct Known Subclasses:
  JUnit4, Theories

    public class BlockJUnit4ClassRunner

extends ParentRunner<FrameworkMethod>

Implements the JUnit 4 standard test case class model, as defined by the annotations in the org.junit package. Many users will never notice this class: it is now the default test class runner, but it should have exactly the same behavior as the old test class runner (`JUnit4ClassRunner`). BlockJUnit4ClassRunner has advantages for writers of custom JUnit runners that are slight changes to the default behavior, however:

- It has a much simpler implementation based on `Statement`s, allowing new operations to be inserted into the appropriate point in the execution flow.
- It is published, and extension and reuse are encouraged, whereas `JUnit4ClassRunner` was in an internal package, and is now deprecated.

Constructor Summary
`BlockJUnit4ClassRunner(Class<?> klass)` Creates a BlockJUnit4ClassRunner to run `klass`

Method Summary
`protected void` | `collectInitializationErrors(List<Throwable> errors)` Adds to `errors` a throwable for each problem noted with the test class (available from `ParentRunner.getTestClass()`).
`protected List<FrameworkMethod>` | `computeTestMethods()` Returns the methods that run tests.
`protected Object` | `createTest()` Returns a new fixture for running a test.
`protected Description` | `describeChild(FrameworkMethod method)` Returns a `Description` for `child`, which can be assumed to be an element of the list returned by `ParentRunner.getChildren()`
`protected List<FrameworkMethod>` | `getChildren()` Returns a list of objects that define the children of this Runner.
`protected List<TestRule>` | `getTestRules(Object target)`
`protected Statement` | `methodBlock(FrameworkMethod method)` Returns a Statement that, when executed, either returns normally if `method` passes, or throws an exception if `method` fails.
`protected Statement` | `methodInvoker(FrameworkMethod method, Object test)` Returns a `Statement` that invokes `method` on `test`
`protected Statement` | `possiblyExpectingExceptions(FrameworkMethod method, Object test, Statement next)` Deprecated. Will be private soon: use Rules instead
`protected List<MethodRule>` | `rules(Object target)` Deprecated. `MethodRule` is a deprecated interface. Port to `TestRule` and `getTestRules(Object)`
`protected void` | `runChild(FrameworkMethod method, RunNotifier notifier)` Runs the test corresponding to `child`, which can be assumed to be an element of the list returned by `ParentRunner.getChildren()`.
`protected String` | `testName(FrameworkMethod method)` Returns the name that describes `method` for `Description`s.
`protected void` | `validateConstructor(List<Throwable> errors)` Adds to `errors` if the test class has more than one constructor, or if the constructor takes parameters.
`protected void` | `validateInstanceMethods(List<Throwable> errors)` Deprecated. unused API, will go away in future version
`protected void` | `validateNoNonStaticInnerClass(List<Throwable> errors)`
`protected void` | `validateOnlyOneConstructor(List<Throwable> errors)` Adds to `errors` if the test class has more than one constructor (do not override)
`protected void` | `validateTestMethods(List<Throwable> errors)` Adds to `errors` for each method annotated with `@Test`that is not a public, void instance method with no arguments.
`protected void` | `validateZeroArgConstructor(List<Throwable> errors)` Adds to `errors` if the test class's single constructor takes parameters (do not override)
`protected Statement` | `withAfters(FrameworkMethod method, Object target, Statement statement)` Deprecated. Will be private soon: use Rules instead
`protected Statement` | `withBefores(FrameworkMethod method, Object target, Statement statement)` Deprecated. Will be private soon: use Rules instead
`protected Statement` | `withPotentialTimeout(FrameworkMethod method, Object test, Statement next)` Deprecated. Will be private soon: use Rules instead

Methods inherited from class org.junit.runners.ParentRunner
`childrenInvoker, classBlock, classRules, filter, getDescription, getName, getRunnerAnnotations, getTestClass, run, runLeaf, setScheduler, sort, validatePublicVoidNoArgMethods, withAfterClasses, withBeforeClasses`

Methods inherited from class org.junit.runner.Runner
`testCount`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### BlockJUnit4ClassRunner

    public BlockJUnit4ClassRunner(Class<?> klass)
                           throws InitializationError

  Creates a BlockJUnit4ClassRunner to run `klass`

  Throws:
    `InitializationError` - if the test class is malformed.

Method Detail

### runChild

    protected void runChild(FrameworkMethod method,
                            RunNotifier notifier)

  Description copied from class: `ParentRunner`
  Runs the test corresponding to `child`, which can be assumed to be an element of the list returned by `ParentRunner.getChildren()`. Subclasses are responsible for making sure that relevant test events are reported through `notifier`

  Specified by:
    `runChild` in class `ParentRunner<FrameworkMethod>`

### describeChild

    protected Description describeChild(FrameworkMethod method)

  Description copied from class: `ParentRunner`
  Returns a `Description` for `child`, which can be assumed to be an element of the list returned by `ParentRunner.getChildren()`

  Specified by:
    `describeChild` in class `ParentRunner<FrameworkMethod>`

### getChildren

    protected List<FrameworkMethod> getChildren()

  Description copied from class: `ParentRunner`
  Returns a list of objects that define the children of this Runner.

  Specified by:
    `getChildren` in class `ParentRunner<FrameworkMethod>`

### computeTestMethods

    protected List<FrameworkMethod> computeTestMethods()

  Returns the methods that run tests. Default implementation returns all methods annotated with `@Test` on this class and superclasses that are not overridden.

### collectInitializationErrors

    protected void collectInitializationErrors(List<Throwable> errors)

  Description copied from class: `ParentRunner`
  Adds to `errors` a throwable for each problem noted with the test class (available from `ParentRunner.getTestClass()`). Default implementation adds an error for each method annotated with `@BeforeClass` or `@AfterClass` that is not `public static void` with no arguments.

  Overrides:
    `collectInitializationErrors` in class `ParentRunner<FrameworkMethod>`

### validateNoNonStaticInnerClass

    protected void validateNoNonStaticInnerClass(List<Throwable> errors)

### validateConstructor

    protected void validateConstructor(List<Throwable> errors)

  Adds to `errors` if the test class has more than one constructor, or if the constructor takes parameters. Override if a subclass requires different validation rules.

### validateOnlyOneConstructor

    protected void validateOnlyOneConstructor(List<Throwable> errors)

  Adds to `errors` if the test class has more than one constructor (do not override)

### validateZeroArgConstructor

    protected void validateZeroArgConstructor(List<Throwable> errors)

  Adds to `errors` if the test class's single constructor takes parameters (do not override)

### validateInstanceMethods

    @Deprecated
    protected void validateInstanceMethods(List<Throwable> errors)

  Deprecated. unused API, will go away in future version

  Adds to `errors` for each method annotated with `@Test`, `@Before`, or `@After` that is not a public, void instance method with no arguments.

### validateTestMethods

    protected void validateTestMethods(List<Throwable> errors)

  Adds to `errors` for each method annotated with `@Test`that is not a public, void instance method with no arguments.

### createTest

    protected Object createTest()
                         throws Exception

  Returns a new fixture for running a test. Default implementation executes the test class's no-argument constructor (validation should have ensured one exists).

  Throws:
    `Exception`

### testName

    protected String testName(FrameworkMethod method)

  Returns the name that describes `method` for `Description`s. Default implementation is the method's name

### methodBlock

    protected Statement methodBlock(FrameworkMethod method)

  Returns a Statement that, when executed, either returns normally if `method` passes, or throws an exception if `method` fails. Here is an outline of the default implementation:
  - Invoke `method` on the result of `createTest()`, and throw any exceptions thrown by either operation.
  - HOWEVER, if `method`'s `@Test` annotation has the `expecting` attribute, return normally only if the previous step threw an exception of the correct type, and throw an exception otherwise.
  - HOWEVER, if `method`'s `@Test` annotation has the `timeout` attribute, throw an exception if the previous step takes more than the specified number of milliseconds.
  - ALWAYS run all non-overridden `@Before` methods on this class and superclasses before any of the previous steps; if any throws an Exception, stop execution and pass the exception on.
  - ALWAYS run all non-overridden `@After` methods on this class and superclasses after any of the previous steps; all After methods are always executed: exceptions thrown by previous steps are combined, if necessary, with exceptions from After methods into a `MultipleFailureException`.
  - ALWAYS allow `@Rule` fields to modify the execution of the above steps. A `Rule` may prevent all execution of the above steps, or add additional behavior before and after, or modify thrown exceptions. For more information, see `TestRule`
  This can be overridden in subclasses, either by overriding this method, or the implementations creating each sub-statement.

### methodInvoker

    protected Statement methodInvoker(FrameworkMethod method,
                                      Object test)

  Returns a `Statement` that invokes `method` on `test`

### possiblyExpectingExceptions

    @Deprecated
    protected Statement possiblyExpectingExceptions(FrameworkMethod method,
                                                               Object test,
                                                               Statement next)

  Deprecated. Will be private soon: use Rules instead

  Returns a `Statement`: if `method`'s `@Test` annotation has the `expecting` attribute, return normally only if `next` throws an exception of the correct type, and throw an exception otherwise.

### withPotentialTimeout

    @Deprecated
    protected Statement withPotentialTimeout(FrameworkMethod method,
                                                        Object test,
                                                        Statement next)

  Deprecated. Will be private soon: use Rules instead

  Returns a `Statement`: if `method`'s `@Test` annotation has the `timeout` attribute, throw an exception if `next` takes more than the specified number of milliseconds.

### withBefores

    @Deprecated
    protected Statement withBefores(FrameworkMethod method,
                                               Object target,
                                               Statement statement)

  Deprecated. Will be private soon: use Rules instead

  Returns a `Statement`: run all non-overridden `@Before` methods on this class and superclasses before running `next`; if any throws an Exception, stop execution and pass the exception on.

### withAfters

    @Deprecated
    protected Statement withAfters(FrameworkMethod method,
                                              Object target,
                                              Statement statement)

  Deprecated. Will be private soon: use Rules instead

  Returns a `Statement`: run all non-overridden `@After` methods on this class and superclasses before running `next`; all After methods are always executed: exceptions thrown by previous steps are combined, if necessary, with exceptions from After methods into a `MultipleFailureException`.

### rules

    @Deprecated
    protected List<MethodRule> rules(Object target)

  Deprecated. `MethodRule` is a deprecated interface. Port to `TestRule` and `getTestRules(Object)`

  Parameters:
    `target` - the test case instance
  Returns:
    a list of MethodRules that should be applied when executing this test

### getTestRules

    protected List<TestRule> getTestRules(Object target)

  Parameters:
    `target` - the test case instance
  Returns:
    a list of TestRules that should be applied when executing this test

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD