TestExecutionListener (Spring Framework 3.2.1.RELEASE API)
Date: 2013-01-24

org.springframework.test.context

## Interface TestExecutionListener

- All Known Implementing Classes:
    AbstractTestExecutionListener, DependencyInjectionTestExecutionListener, DirtiesContextTestExecutionListener, ServletTestExecutionListener, TransactionalTestExecutionListener

      public interface TestExecutionListener

  `TestExecutionListener` defines a listener API for reacting to test execution events published by the `TestContextManager` with which the listener is registered.

  Concrete implementations must provide a `public` no-args constructor, so that listeners can be instantiated transparently by tools and configuration mechanisms.

  Spring provides the following out-of-the-box implementations:

  - `DependencyInjectionTestExecutionListener`
  - `DirtiesContextTestExecutionListener`
  - `TransactionalTestExecutionListener`
  Since:
    2.5
  Author:
    Sam Brannen, Juergen Hoeller

- - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `afterTestClass(TestContext testContext)` Post-processes a test class after execution of all tests within the class.
    `void` | `afterTestMethod(TestContext testContext)` Post-processes a test after execution of the `test method` in the supplied `test context`, for example by tearing down test fixtures.
    `void` | `beforeTestClass(TestContext testContext)` Pre-processes a test class before execution of all tests within the class.
    `void` | `beforeTestMethod(TestContext testContext)` Pre-processes a test before execution of the `test method` in the supplied `test context`, for example by setting up test fixtures.
    `void` | `prepareTestInstance(TestContext testContext)` Prepares the `test instance` of the supplied `test context`, for example by injecting dependencies.

- - ### Method Detail

    - #### beforeTestClass

          void beforeTestClass(TestContext testContext)
                               throws Exception

      Pre-processes a test class before execution of all tests within the class.

      This method should be called immediately before framework-specific before class lifecycle callbacks.

      If a given testing framework (e.g., JUnit 3.8) does not support before class lifecycle callbacks, this method will not be called for that framework.

      Parameters:
        `testContext` - the test context for the test; never `null`
      Throws:
        `Exception` - allows any exception to propagate

    - #### prepareTestInstance

          void prepareTestInstance(TestContext testContext)
                                   throws Exception

      Prepares the `test instance` of the supplied `test context`, for example by injecting dependencies.

      This method should be called immediately after instantiation of the test instance but prior to any framework-specific lifecycle callbacks.

      Parameters:
        `testContext` - the test context for the test; never `null`
      Throws:
        `Exception` - allows any exception to propagate

    - #### beforeTestMethod

          void beforeTestMethod(TestContext testContext)
                                throws Exception

      Pre-processes a test before execution of the `test method` in the supplied `test context`, for example by setting up test fixtures.

      This method should be called immediately prior to framework-specific before lifecycle callbacks.

      Parameters:
        `testContext` - the test context in which the test method will be executed; never `null`
      Throws:
        `Exception` - allows any exception to propagate

    - #### afterTestMethod

          void afterTestMethod(TestContext testContext)
                               throws Exception

      Post-processes a test after execution of the `test method` in the supplied `test context`, for example by tearing down test fixtures.

      This method should be called immediately after framework-specific after lifecycle callbacks.

      Parameters:
        `testContext` - the test context in which the test method was executed; never `null`
      Throws:
        `Exception` - allows any exception to propagate

    - #### afterTestClass

          void afterTestClass(TestContext testContext)
                              throws Exception

      Post-processes a test class after execution of all tests within the class.

      This method should be called immediately after framework-specific after class lifecycle callbacks.

      If a given testing framework (e.g., JUnit 3.8) does not support after class lifecycle callbacks, this method will not be called for that framework.

      Parameters:
        `testContext` - the test context for the test; never `null`
      Throws:
        `Exception` - allows any exception to propagate