Module org.junit.jupiter.api
Package org.junit.jupiter.api

Annotation Type AfterAll

  • @Target({ANNOTATION_TYPE,METHOD})
@Retention(RUNTIME)
@Documented
@API(status=STABLE,
     since="5.0")
public @interface AfterAll
    @AfterAll is used to signal that the annotated method should be executed after all tests in the current test class.

    In contrast to @AfterEach methods, @AfterAll methods are only executed once for a given test class.

    Method Signatures

    @AfterAll methods must have a void return type, must not be private, and must be static by default. Consequently, @AfterAll methods are not supported in @Nested test classes or as interface default methods unless the test class is annotated with @TestInstance(Lifecycle.PER_CLASS). @AfterAll methods may optionally declare parameters to be resolved by ParameterResolvers.

    Inheritance and Execution Order

    @AfterAll methods are inherited from superclasses as long as they are not hidden or overridden. Furthermore, @AfterAll methods from superclasses will be executed after @AfterAll methods in subclasses.

    Similarly, @AfterAll methods declared in an interface are inherited as long as they are not hidden or overridden, and @AfterAll methods from an interface will be executed after @AfterAll methods in the class that implements the interface.

    JUnit Jupiter does not guarantee the execution order of multiple @AfterAll methods that are declared within a single test class or test interface. While it may at times appear that these methods are invoked in alphabetical order, they are in fact sorted using an algorithm that is deterministic but intentionally non-obvious.

    In addition, @AfterAll methods are in no way linked to @BeforeAll methods. Consequently, there are no guarantees with regard to their wrapping behavior. For example, given two @BeforeAll methods createA() and createB() as well as two @AfterAll methods destroyA() and destroyB(), the order in which the @BeforeAll methods are executed (e.g. createA() before createB()) does not imply any order for the seemingly corresponding @AfterAll methods. In other words, destroyA() might be called before or after destroyB(). The JUnit Team therefore recommends that developers declare at most one @BeforeAll method and at most one @AfterAll method per test class or test interface unless there are no dependencies between the @BeforeAll methods or between the @AfterAll methods.

    Composition

    @AfterAll may be used as a meta-annotation in order to create a custom composed annotation that inherits the semantics of @AfterAll.

    Since:
    5.0
    See Also:
    BeforeAll, BeforeEach, AfterEach, Test, TestFactory, TestInstance