All Classes and Interfaces
Class
Description
@AfterAll is used to signal that the annotated method should be
executed after all tests in the current test class.AfterAllCallback defines the API for Extensions
that wish to provide additional behavior to test containers once
after all tests in the container have been executed.@AfterEach is used to signal that the annotated method should be
executed after each @Test,
@RepeatedTest, @ParameterizedTest, @TestFactory,
and @TestTemplate method in the current test class.AfterEachCallback defines the API for Extensions
that wish to provide additional behavior to tests after an individual test
and any user-defined teardown methods (e.g.,
@AfterEach methods) for that test
have been executed.AfterTestExecutionCallback defines the API for Extensions that wish to provide additional behavior to tests
immediately after an individual test has been executed but
before any user-defined teardown methods (e.g.,
@AfterEach methods) have been executed
for that test.AnnotatedElementContext encapsulates the context in which an
AnnotatedElement is declared.Builder for
AssertionFailedErrors.Assertions is a collection of utility methods that support asserting
conditions in tests.Factory for timeout failures.
Assumptions is a collection of utility methods that support
conditional test execution based on assumptions.@BeforeAll is used to signal that the annotated method should be
executed before all tests in the current test class.BeforeAllCallback defines the API for Extensions
that wish to provide additional behavior to test containers once
before all tests in the container have been executed.@BeforeEach is used to signal that the annotated method should be
executed before each @Test,
@RepeatedTest, @ParameterizedTest, @TestFactory,
and @TestTemplate method in the current test class.BeforeEachCallback defines the API for Extensions
that wish to provide additional behavior to tests before an individual test
and any user-defined setup methods (e.g.,
@BeforeEach methods) for that test
have been executed.BeforeTestExecutionCallback defines the API for Extensions that wish to provide additional behavior to tests
immediately before an individual test is executed but after
any user-defined setup methods (e.g.,
@BeforeEach methods) have been
executed for that test.ClassDescriptor encapsulates functionality for a given Class.ClassOrderer defines the API for ordering top-level test classes and
@Nested test classes.ClassOrderer that sorts classes alphanumerically based on their
fully qualified names using String.compareTo(String).ClassOrderer that sorts classes alphanumerically based on their
display names using String.compareTo(String)ClassOrderer that sorts classes based on the @Order
annotation.ClassOrderer that orders classes pseudo-randomly.ClassOrdererContext encapsulates the context in which
a ClassOrderer will be invoked.Enumeration of cleanup modes for
@TempDir.The result of evaluating an
ExecutionCondition.@Disabled is used to signal that the annotated test class or
test method is currently disabled and should not be executed.@DisabledForJreRange is used to signal that the annotated test class or
test method is only disabled for a specific range of Java Runtime
Environment (JRE) versions from DisabledForJreRange.min() to DisabledForJreRange.max().@DisabledIf is used to signal that the annotated test class or test
method is disabled only if the provided
condition evaluates to true.@DisabledIfEnvironmentVariable is used to signal that the annotated test
class or test method is disabled if the value of the specified
environment variable matches the specified
regular expression.@DisabledIfEnvironmentVariables is a container for one or more
@DisabledIfEnvironmentVariable declarations.@DisabledIfSystemProperties is a container for one or more
@DisabledIfSystemProperty declarations.@DisabledIfSystemProperty is used to signal that the annotated test
class or test method is disabled if the value of the specified
system property matches the specified
regular expression.@DisabledInNativeImage is used to signal that the annotated test class
or test method is only disabled when executing within a GraalVM native
image.@DisabledOnJre is used to signal that the annotated test class or
test method is disabled on one or more specified Java
Runtime Environment (JRE) versions.@DisabledOnOs is used to signal that the annotated test class or
test method is disabled on one or more specified
operating systems or on one or more specified
architectures@DisplayName is used to declare a custom display
name for the annotated test class or test method.@DisplayNameGeneration is used to declare a custom display name
generator for the annotated test class.DisplayNameGenerator defines the SPI for generating display names
programmatically.DisplayNameGenerator that generates complete sentences.DisplayNameGenerator that replaces underscores with spaces.Simple
DisplayNameGenerator that removes trailing parentheses
for methods with no parameters.Standard
DisplayNameGenerator.A
DynamicContainer is a container generated at runtime.DynamicNode serves as the abstract base class for a container or a
test case generated at runtime.A
DynamicTest is a test case generated at runtime.DynamicTestInvocationContext represents the context of a
single invocation of a dynamic test.@EnabledForJreRange is used to signal that the annotated test class or
test method is only enabled for a specific range of Java Runtime
Environment (JRE) versions from EnabledForJreRange.min() to EnabledForJreRange.max().@EnabledIf is used to signal that the annotated test class or test
method is enabled only if the provided
condition evaluates to true.@EnabledIfEnvironmentVariable is used to signal that the annotated test
class or test method is only enabled if the value of the specified
environment variable matches the specified
regular expression.@EnabledIfEnvironmentVariables is a container for one or more
@EnabledIfEnvironmentVariable declarations.@EnabledIfSystemProperties is a container for one or more
@EnabledIfSystemProperty declarations.@EnabledIfSystemProperty is used to signal that the annotated test
class or test method is only enabled if the value of the specified
system property matches the specified
regular expression.@EnabledInNativeImage is used to signal that the annotated test class
or test method is only enabled when executing within a GraalVM native
image.@EnabledOnJre is used to signal that the annotated test class or
test method is only enabled on one or more specified Java
Runtime Environment (JRE) versions.@EnabledOnOs is used to signal that the annotated test class or
test method is only enabled on one or more specified
operating systems or one or more specified
architectures.Executable is a functional interface that can be used to
implement any generic block of code that potentially throws a
Throwable.ExecutableInvoker allows invoking methods and constructors
with support for dynamic resolution of parameters via
ParameterResolvers.@Execution is used to configure the parallel execution
mode of a test class or test method.ExecutionCondition defines the Extension API for
programmatic, conditional test execution.Supported execution modes for parallel test execution.
@ExtendWith is a repeatable annotation
that is used to register extensions for the annotated
test class, test interface, test method, parameter, or field.Marker interface for all extensions.
Thrown if an error is encountered regarding the configuration of an
extension.
ExtensionContext encapsulates the context in which the
current test or container is being executed.A
Namespace is used to provide a scope for data saved by
extensions within a ExtensionContext.Store.Store provides methods for extensions to save and retrieve data.Classes implementing this interface indicate that they want to
ExtensionContext.Store.CloseableResource.close()
some underlying resource or resources when the enclosing Store
is closed.Thrown if an error is encountered regarding the use of an
ExtensionContext or ExtensionContext.Store.@Extensions is a container for one or more @ExtendWith
declarations.@IndicativeSentencesGeneration is used to register the
DisplayNameGenerator.IndicativeSentences display name generator and configure it.InvocationInterceptor defines the API for Extensions that wish to intercept calls to test code.An invocation that returns a result and may throw a
Throwable.@Isolated is used to declare that the annotated test class should be
executed in isolation from other test classes.Enumeration of Java Runtime Environment (JRE) versions.
LifecycleMethodExecutionExceptionHandler defines the API for
Extensions that wish to handle exceptions thrown during
the execution of @BeforeAll, @BeforeEach, @AfterEach,
and @AfterAll lifecycle methods.MethodDescriptor encapsulates functionality for a given Method.MethodOrderer defines the API for ordering the test methods
in a given test class.Deprecated.
MethodOrderer that sorts methods alphanumerically based on their
display names using String.compareTo(String)MethodOrderer that sorts methods alphanumerically based on their
names using String.compareTo(String).MethodOrderer that sorts methods based on the @Order
annotation.MethodOrderer that orders methods pseudo-randomly.MethodOrdererContext encapsulates the context in which
a MethodOrderer will be invoked.Named is a container that associates a name with a given payload.@Nested is used to signal that the annotated class is a nested,
non-static test class (i.e., an inner class) that can share
setup and state with an instance of its enclosing class.@Order is an annotation that is used to configure the
order in which the annotated element (i.e., field,
method, or class) should be evaluated or executed relative to other elements
of the same category.Enumeration of common operating systems used for testing Java applications.
ParameterContext encapsulates the context in which an
Executable will be invoked for a given
Parameter.Thrown if an error is encountered in the configuration or execution of a
ParameterResolver.ParameterResolver defines the API for Extensions
that wish to dynamically resolve arguments for parameters
at runtime.ReflectiveInvocationContext encapsulates the context of
a reflective invocation of an executable (method or constructor).@RegisterExtension is used to register an Extension via a
field in a test class.@RepeatedTest is used to signal that the annotated method is a
test template method that should be repeated a specified number of times with a configurable display
name and an optional failure threshold.RepetitionInfo is used to inject information about the current
repetition of a repeated test into @RepeatedTest, @BeforeEach,
and @AfterEach methods.The access mode required by a test class or method for a given resource.
@ResourceLock is used to declare that the annotated test class or test
method requires access to a shared resource identified by a key.@ResourceLocks is a container for one or more
@ResourceLock declarations.Common resource names for synchronizing test execution.
@Tag is a repeatable annotation that is
used to declare a tag for the annotated test class or test method.@Tags is a container for one or more @Tag declarations.TempDirFactory defines the SPI for creating temporary directories
programmatically.Standard
TempDirFactory implementation which delegates to
Files.createTempDirectory(java.nio.file.Path, java.lang.String, java.nio.file.attribute.FileAttribute<?>...) using "junit" as the prefix.@Test is used to signal that the annotated method is a
test method.@TestClassOrder is a type-level annotation that is used to configure
a ClassOrderer for the @Nested test classes of
the annotated test class.TestExecutionExceptionHandler defines the API for Extensions that wish to handle exceptions thrown during test execution.@TestFactory is used to signal that the annotated method is a
test factory method.TestInfo is used to inject information about the current test or
container into to @Test, @RepeatedTest,
@ParameterizedTest, @TestFactory, @BeforeEach,
@AfterEach, @BeforeAll, and @AfterAll methods.@TestInstance is a type-level annotation that is used to configure
the lifecycle of test instances for the annotated
test class or test interface.Enumeration of test instance lifecycle modes.
TestInstanceFactoryContext encapsulates the context in which
a test class is to be instantiated by a
TestInstanceFactory.TestInstancePostProcessor defines the API for Extensions that wish to post-process test instances.TestInstancePreConstructCallback defines the API for Extensions that wish to be invoked prior to creation of test instances.TestInstancePreDestroyCallback defines the API for Extensions that wish to process test instances after they have been
used in tests but before they are destroyed.TestInstances encapsulates the test instances of a test.Thrown if an error is encountered during the execution of
a
TestInstanceFactory.@TestMethodOrder is a type-level annotation that is used to configure
a MethodOrderer for the test methods of the annotated
test class or test interface.Parameters of type
,
TestReporter can be injected into
@BeforeEach and @AfterEach lifecycle
methods as well as methods annotated with @Test,
@RepeatedTest,
invalid reference
@ParameterizedTest@TestFactory, etc.@TestTemplate is used to signal that the annotated method is a
test template method.TestTemplateInvocationContext represents the context of a
single invocation of a test
template.TestTemplateInvocationContextProvider defines the API for
Extensions that wish to provide one or multiple contexts
for the invocation of a
@TestTemplate method.TestWatcher defines the API for Extensions that
wish to process test results.ThrowingConsumer is a functional interface that can be used to
implement any generic block of code that consumes an argument and
potentially throws a Throwable.ThrowingSupplier is a functional interface that can be used to
implement any generic block of code that returns an object and
potentially throws a Throwable.@Timeout is used to define a timeout for a method or all testable
methods within one class and its @Nested classes.ThreadMode is use to define whether the test code should be executed in the thread
of the calling code or in a separated thread.ParameterResolver adapter which resolves a parameter based on its exact type.
MethodOrderer.MethodName; to be removed in 6.0