java.lang.Object
- org.junit.runner.Runner
- - org.junit.runners.ParentRunner<FrameworkMethod>
  - - org.junit.runners.BlockJUnit4ClassRunner
    - - org.springframework.test.context.junit4.SpringJUnit4ClassRunner

所有已实现的接口:
Describable, Filterable, Sortable
直接已知子类:
SpringRunner
```
public class SpringJUnit4ClassRunner
extends BlockJUnit4ClassRunner
```
SpringJUnit4ClassRunner is a custom extension of JUnit's BlockJUnit4ClassRunner which provides functionality of the Spring TestContext Framework to standard JUnit tests by means of the TestContextManager and associated support classes and annotations.
To use this class, simply annotate a JUnit 4 based test class with @RunWith(SpringJUnit4ClassRunner.class) or @RunWith(SpringRunner.class).
The following list constitutes all annotations currently supported directly or indirectly by SpringJUnit4ClassRunner. (Note that additional annotations may be supported by various TestExecutionListener or TestContextBootstrapper implementations.)
If you would like to use the Spring TestContext Framework with a runner other than this one, use SpringClassRule and SpringMethodRule.
NOTE: As of Spring Framework 4.3, this class requires JUnit 4.12 or higher.
从以下版本开始:
2.5
作者:
Sam Brannen, Juergen Hoeller
另请参阅:
SpringRunner, TestContextManager, AbstractJUnit4SpringContextTests, AbstractTransactionalJUnit4SpringContextTests, SpringClassRule, SpringMethodRule

构造器概要

构造器
构造器	说明
`SpringJUnit4ClassRunner(Class<?> clazz)`	Construct a new `SpringJUnit4ClassRunner` and initialize a `TestContextManager` to provide Spring testing functionality to standard JUnit tests.

方法概要

所有方法实例方法具体方法
修饰符和类型	方法	说明
`protected Object`	`createTest()`	Delegate to the parent implementation for creating the test instance and then allow the `TestContextManager` to prepare the test instance before returning it.
`protected TestContextManager`	`createTestContextManager(Class<?> clazz)`	Create a new `TestContextManager` for the supplied test class.
`Description`	`getDescription()`	Return a description suitable for an ignored test class if the test is disabled via `@IfProfileValue` at the class-level, and otherwise delegate to the parent implementation.
`protected Class<? extends Throwable>`	`getExpectedException(FrameworkMethod frameworkMethod)`	Get the `exception` that the supplied test method is expected to throw.
`protected long`	`getJUnitTimeout(FrameworkMethod frameworkMethod)`	Retrieve the configured JUnit `timeout` from the `@Test` annotation on the supplied test method.
`protected long`	`getSpringTimeout(FrameworkMethod frameworkMethod)`	Retrieve the configured Spring-specific `timeout` from the `@Timed` annotation on the supplied test method.
`protected TestContextManager`	`getTestContextManager()`	Get the `TestContextManager` associated with this runner.
`protected boolean`	`isTestMethodIgnored(FrameworkMethod frameworkMethod)`	Return `true` if `@Ignore` is present for the supplied test method or if the test method is disabled via `@IfProfileValue`.
`protected Statement`	`methodBlock(FrameworkMethod frameworkMethod)`	Augment the default JUnit behavior with potential repeats of the entire execution chain.
`protected Statement`	`possiblyExpectingExceptions(FrameworkMethod frameworkMethod, Object testInstance, Statement next)`	Perform the same logic as `BlockJUnit4ClassRunner.possiblyExpectingExceptions(FrameworkMethod, Object, Statement)` except that the expected exception is retrieved using `getExpectedException(FrameworkMethod)`.
`void`	`run(RunNotifier notifier)`	Check whether the test is enabled in the current execution environment.
`protected void`	`runChild(FrameworkMethod frameworkMethod, RunNotifier notifier)`	Perform the same logic as `BlockJUnit4ClassRunner.runChild(FrameworkMethod, RunNotifier)`, except that tests are determined to be ignored by `isTestMethodIgnored(FrameworkMethod)`.
`protected Statement`	`withAfterClasses(Statement statement)`	Wrap the `Statement` returned by the parent implementation with a `RunAfterTestClassCallbacks` statement, thus preserving the default JUnit functionality while adding support for the Spring TestContext Framework.
`protected Statement`	`withAfters(FrameworkMethod frameworkMethod, Object testInstance, Statement statement)`	Wrap the `Statement` returned by the parent implementation with a `RunAfterTestMethodCallbacks` statement, thus preserving the default functionality while adding support for the Spring TestContext Framework.
`protected Statement`	`withBeforeClasses(Statement statement)`	Wrap the `Statement` returned by the parent implementation with a `RunBeforeTestClassCallbacks` statement, thus preserving the default JUnit functionality while adding support for the Spring TestContext Framework.
`protected Statement`	`withBefores(FrameworkMethod frameworkMethod, Object testInstance, Statement statement)`	Wrap the `Statement` returned by the parent implementation with a `RunBeforeTestMethodCallbacks` statement, thus preserving the default functionality while adding support for the Spring TestContext Framework.
`protected Statement`	`withPotentialRepeat(FrameworkMethod frameworkMethod, Object testInstance, Statement next)`	Wrap the supplied `Statement` with a `SpringRepeat` statement.
`protected Statement`	`withPotentialTimeout(FrameworkMethod frameworkMethod, Object testInstance, Statement next)`	Perform the same logic as `BlockJUnit4ClassRunner.withPotentialTimeout(FrameworkMethod, Object, Statement)` but with additional support for Spring's `@Timed` annotation.

从类继承的方法 org.junit.runners.BlockJUnit4ClassRunner
collectInitializationErrors, computeTestMethods, describeChild, getChildren, getTestRules, isIgnored, methodInvoker, rules, testName, validateConstructor, validateFields, validateInstanceMethods, validateNoNonStaticInnerClass, validateOnlyOneConstructor, validateTestMethods, validateZeroArgConstructor

从类继承的方法 org.junit.runners.ParentRunner
childrenInvoker, classBlock, classRules, createTestClass, filter, getName, getRunnerAnnotations, getTestClass, runLeaf, setScheduler, sort, validatePublicVoidNoArgMethods

从类继承的方法 org.junit.runner.Runner
testCount

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 构造器详细资料
  - SpringJUnit4ClassRunner
```
public SpringJUnit4ClassRunner(Class<?> clazz)
                        throws InitializationError
```
    Construct a new SpringJUnit4ClassRunner and initialize a TestContextManager to provide Spring testing functionality to standard JUnit tests.
    参数:
    clazz - the test class to be run
    抛出:
    InitializationError
    另请参阅:
    createTestContextManager(Class)
- 方法详细资料
  - createTestContextManager
```
protected TestContextManager createTestContextManager(Class<?> clazz)
```
    Create a new TestContextManager for the supplied test class.
    Can be overridden by subclasses.
    参数:
    clazz - the test class to be managed
  - getTestContextManager
```
protected final TestContextManager getTestContextManager()
```
    Get the TestContextManager associated with this runner.
  - getDescription
```
public Description getDescription()
```
    Return a description suitable for an ignored test class if the test is disabled via @IfProfileValue at the class-level, and otherwise delegate to the parent implementation.
    指定者:
    getDescription 在接口中 Describable
    覆盖:
    getDescription 在类中 ParentRunner<FrameworkMethod>
    另请参阅:
    ProfileValueUtils.isTestEnabledInThisEnvironment(Class)
  - run
```
public void run(RunNotifier notifier)
```
    Check whether the test is enabled in the current execution environment.
    This prevents classes with a non-matching @IfProfileValue annotation from running altogether, even skipping the execution of prepareTestInstance() methods in TestExecutionListeners.
    覆盖:
    run 在类中 ParentRunner<FrameworkMethod>
    另请参阅:
    ProfileValueUtils.isTestEnabledInThisEnvironment(Class), IfProfileValue, TestExecutionListener
  - withBeforeClasses
```
protected Statement withBeforeClasses(Statement statement)
```
    Wrap the Statement returned by the parent implementation with a RunBeforeTestClassCallbacks statement, thus preserving the default JUnit functionality while adding support for the Spring TestContext Framework.
    覆盖:
    withBeforeClasses 在类中 ParentRunner<FrameworkMethod>
    另请参阅:
    RunBeforeTestClassCallbacks
  - withAfterClasses
```
protected Statement withAfterClasses(Statement statement)
```
    Wrap the Statement returned by the parent implementation with a RunAfterTestClassCallbacks statement, thus preserving the default JUnit functionality while adding support for the Spring TestContext Framework.
    覆盖:
    withAfterClasses 在类中 ParentRunner<FrameworkMethod>
    另请参阅:
    RunAfterTestClassCallbacks
  - createTest
```
protected Object createTest()
                     throws Exception
```
    Delegate to the parent implementation for creating the test instance and then allow the TestContextManager to prepare the test instance before returning it.
    覆盖:
    createTest 在类中 BlockJUnit4ClassRunner
    抛出:
    Exception
    另请参阅:
    TestContextManager.prepareTestInstance(java.lang.Object)
  - runChild
```
protected void runChild(FrameworkMethod frameworkMethod,
                        RunNotifier notifier)
```
    Perform the same logic as BlockJUnit4ClassRunner.runChild(FrameworkMethod, RunNotifier), except that tests are determined to be ignored by isTestMethodIgnored(FrameworkMethod).
    覆盖:
    runChild 在类中 BlockJUnit4ClassRunner
  - methodBlock
```
protected Statement methodBlock(FrameworkMethod frameworkMethod)
```
    Augment the default JUnit behavior with potential repeats of the entire execution chain.
    Furthermore, support for timeouts has been moved down the execution chain in order to include execution of @Before and @After methods within the timed execution. Note that this differs from the default JUnit behavior of executing @Before and @After methods in the main thread while executing the actual test method in a separate thread. Thus, the net effect is that @Before and @After methods will be executed in the same thread as the test method. As a consequence, JUnit-specified timeouts will work fine in combination with Spring transactions. However, JUnit-specific timeouts still differ from Spring-specific timeouts in that the former execute in a separate thread while the latter simply execute in the main thread (like regular tests).
    覆盖:
    methodBlock 在类中 BlockJUnit4ClassRunner
    另请参阅:
    possiblyExpectingExceptions(FrameworkMethod, Object, Statement), withBefores(FrameworkMethod, Object, Statement), withAfters(FrameworkMethod, Object, Statement), withRulesReflectively(FrameworkMethod, Object, Statement), withPotentialRepeat(FrameworkMethod, Object, Statement), withPotentialTimeout(FrameworkMethod, Object, Statement)
  - isTestMethodIgnored
```
protected boolean isTestMethodIgnored(FrameworkMethod frameworkMethod)
```
    Return true if @Ignore is present for the supplied test method or if the test method is disabled via @IfProfileValue.
    另请参阅:
    ProfileValueUtils.isTestEnabledInThisEnvironment(Method, Class)
  - possiblyExpectingExceptions
```
protected Statement possiblyExpectingExceptions(FrameworkMethod frameworkMethod,
                                                Object testInstance,
                                                Statement next)
```
    Perform the same logic as BlockJUnit4ClassRunner.possiblyExpectingExceptions(FrameworkMethod, Object, Statement) except that the expected exception is retrieved using getExpectedException(FrameworkMethod).
    覆盖:
    possiblyExpectingExceptions 在类中 BlockJUnit4ClassRunner
  - getExpectedException
```
protected Class<? extends Throwable> getExpectedException(FrameworkMethod frameworkMethod)
```
    Get the exception that the supplied test method is expected to throw.
    Supports JUnit's @Test(expected=...) annotation.
    Can be overridden by subclasses.
    返回:
    the expected exception, or null if none was specified
  - withPotentialTimeout
```
protected Statement withPotentialTimeout(FrameworkMethod frameworkMethod,
                                         Object testInstance,
                                         Statement next)
```
    Perform the same logic as BlockJUnit4ClassRunner.withPotentialTimeout(FrameworkMethod, Object, Statement) but with additional support for Spring's @Timed annotation.
    Supports both Spring's @Timed and JUnit's @Test(timeout=...) annotations, but not both simultaneously.
    覆盖:
    withPotentialTimeout 在类中 BlockJUnit4ClassRunner
    返回:
    either a SpringFailOnTimeout, a FailOnTimeout, or the supplied Statement as appropriate
    另请参阅:
    getSpringTimeout(FrameworkMethod), getJUnitTimeout(FrameworkMethod)
  - getJUnitTimeout
```
protected long getJUnitTimeout(FrameworkMethod frameworkMethod)
```
    Retrieve the configured JUnit timeout from the @Test annotation on the supplied test method.
    返回:
    the timeout, or 0 if none was specified
  - getSpringTimeout
```
protected long getSpringTimeout(FrameworkMethod frameworkMethod)
```
    Retrieve the configured Spring-specific timeout from the @Timed annotation on the supplied test method.
    返回:
    the timeout, or 0 if none was specified
    另请参阅:
    TestAnnotationUtils.getTimeout(Method)
  - withBefores
```
protected Statement withBefores(FrameworkMethod frameworkMethod,
                                Object testInstance,
                                Statement statement)
```
    Wrap the Statement returned by the parent implementation with a RunBeforeTestMethodCallbacks statement, thus preserving the default functionality while adding support for the Spring TestContext Framework.
    覆盖:
    withBefores 在类中 BlockJUnit4ClassRunner
    另请参阅:
    RunBeforeTestMethodCallbacks
  - withAfters
```
protected Statement withAfters(FrameworkMethod frameworkMethod,
                               Object testInstance,
                               Statement statement)
```
    Wrap the Statement returned by the parent implementation with a RunAfterTestMethodCallbacks statement, thus preserving the default functionality while adding support for the Spring TestContext Framework.
    覆盖:
    withAfters 在类中 BlockJUnit4ClassRunner
    另请参阅:
    RunAfterTestMethodCallbacks
  - withPotentialRepeat
```
protected Statement withPotentialRepeat(FrameworkMethod frameworkMethod,
                                        Object testInstance,
                                        Statement next)
```
    Wrap the supplied Statement with a SpringRepeat statement.
    Supports Spring's @Repeat annotation.
    另请参阅:
    TestAnnotationUtils.getRepeatCount(Method), SpringRepeat

类 SpringJUnit4ClassRunner

构造器概要

方法概要

从类继承的方法 org.junit.runners.BlockJUnit4ClassRunner

从类继承的方法 org.junit.runners.ParentRunner

从类继承的方法 org.junit.runner.Runner

从类继承的方法 java.lang.Object

构造器详细资料

SpringJUnit4ClassRunner

方法详细资料

createTestContextManager

getTestContextManager

getDescription

run

withBeforeClasses

withAfterClasses

createTest

runChild

methodBlock

isTestMethodIgnored

possiblyExpectingExceptions

getExpectedException

withPotentialTimeout

getJUnitTimeout

getSpringTimeout

withBefores

withAfters

withPotentialRepeat