## 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, Orderable, Sortable

Direct Known Subclasses:
  BlockJUnit4ClassRunnerWithParameters, 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.

In turn, in 2009 we introduced `Rule`s. In many cases where extending BlockJUnit4ClassRunner was necessary to add new behavior, `Rule`s can be used, which makes the extension more reusable and composable.

Since:
  4.5

Constructor Summary
`` `BlockJUnit4ClassRunner(Class<?> testClass)` Creates a BlockJUnit4ClassRunner to run `testClass`
`protected` `BlockJUnit4ClassRunner(TestClass testClass)` Creates a BlockJUnit4ClassRunner to run `testClass`.

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 Object` `createTest(FrameworkMethod method)` Returns a new fixture to run a particular test `method` against.
`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 boolean` `isIgnored(FrameworkMethod child)` Evaluates whether `FrameworkMethod`s are ignored based on the `Ignore` annotation.
`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)` Returns a `Statement`: if `method`'s `@Test` annotation has the `Test.expected()` attribute, return normally only if `next` throws an exception of the correct type, and throw an exception otherwise.
`protected List<MethodRule>` `rules(Object target)`
`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` `validateFields(List<Throwable> errors)`
`protected void` `validateInstanceMethods(List<Throwable> errors)` Deprecated.
`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)` 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`.
`protected Statement` `withBefores(FrameworkMethod method, Object target, Statement statement)` 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.
`protected Statement` `withPotentialTimeout(FrameworkMethod method, Object test, Statement next)` Deprecated.

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

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<?> testClass)
                           throws InitializationError

  Creates a BlockJUnit4ClassRunner to run `testClass`

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

### BlockJUnit4ClassRunner

    protected BlockJUnit4ClassRunner(TestClass testClass)
                              throws InitializationError

  Creates a BlockJUnit4ClassRunner to run `testClass`.

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

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

### isIgnored

    protected boolean isIgnored(FrameworkMethod child)

  Evaluates whether `FrameworkMethod`s are ignored based on the `Ignore` annotation.

  Overrides:
    `isIgnored` 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.

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

### validateFields

    protected void validateFields(List<Throwable> errors)

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

### createTest

    protected Object createTest(FrameworkMethod method)
                         throws Exception

  Returns a new fixture to run a particular test `method` against. Default implementation executes the no-argument `createTest()` method.

  Throws:
    `Exception`
  Since:
    4.13

### 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(org.junit.runners.model.FrameworkMethod)`, and throw any exceptions thrown by either operation.
  - HOWEVER, if `method`'s `@Test` annotation has the `Test.expected()` 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

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

  Returns a `Statement`: if `method`'s `@Test` annotation has the `Test.expected()` 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.

  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

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

  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

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

  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

    protected List<MethodRule> rules(Object target)

  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

Copyright © 2002–2020 JUnit. All rights reserved.