All Classes

Class	Description
AfterAll	@AfterAll is used to signal that the annotated method should be executed after all tests in the current test class.
AfterAllCallback	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	@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	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	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	AnnotatedElementContext encapsulates the context in which an AnnotatedElement is declared.
AssertionFailureBuilder	Builder for AssertionFailedErrors.
Assertions	Assertions is a collection of utility methods that support asserting conditions in tests.
Assertions.TimeoutFailureFactory<T extends java.lang.Throwable>	Factory for timeout failures.
Assumptions	Assumptions is a collection of utility methods that support conditional test execution based on assumptions.
BeforeAll	@BeforeAll is used to signal that the annotated method should be executed before all tests in the current test class.
BeforeAllCallback	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	@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	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	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	ClassDescriptor encapsulates functionality for a given Class.
ClassOrderer	ClassOrderer defines the API for ordering top-level test classes and @Nested test classes.
ClassOrderer.ClassName	ClassOrderer that sorts classes alphanumerically based on their fully qualified names using String.compareTo(String).
ClassOrderer.DisplayName	ClassOrderer that sorts classes alphanumerically based on their display names using String.compareTo(String)
ClassOrderer.OrderAnnotation	ClassOrderer that sorts classes based on the @Order annotation.
ClassOrderer.Random	ClassOrderer that orders classes pseudo-randomly.
ClassOrdererContext	ClassOrdererContext encapsulates the context in which a ClassOrderer will be invoked.
CleanupMode	Enumeration of cleanup modes for @TempDir.
ConditionEvaluationResult	The result of evaluating an ExecutionCondition.
Disabled	@Disabled is used to signal that the annotated test class or test method is currently disabled and should not be executed.
DisabledForJreRange	@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	@DisabledIf is used to signal that the annotated test class or test method is disabled only if the provided condition evaluates to true.
DisabledIfEnvironmentVariable	@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	@DisabledIfEnvironmentVariables is a container for one or more @DisabledIfEnvironmentVariable declarations.
DisabledIfSystemProperties	@DisabledIfSystemProperties is a container for one or more @DisabledIfSystemProperty declarations.
DisabledIfSystemProperty	@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	@DisabledInNativeImage is used to signal that the annotated test class or test method is only disabled when executing within a GraalVM native image.
DisabledOnJre	@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	@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	@DisplayName is used to declare a custom display name for the annotated test class or test method.
DisplayNameGeneration	@DisplayNameGeneration is used to declare a custom display name generator for the annotated test class.
DisplayNameGenerator	DisplayNameGenerator defines the SPI for generating display names programmatically.
DisplayNameGenerator.IndicativeSentences	DisplayNameGenerator that generates complete sentences.
DisplayNameGenerator.ReplaceUnderscores	DisplayNameGenerator that replaces underscores with spaces.
DisplayNameGenerator.Simple	Simple DisplayNameGenerator that removes trailing parentheses for methods with no parameters.
DisplayNameGenerator.Standard	Standard DisplayNameGenerator.
DynamicContainer	A DynamicContainer is a container generated at runtime.
DynamicNode	DynamicNode serves as the abstract base class for a container or a test case generated at runtime.
DynamicTest	A DynamicTest is a test case generated at runtime.
DynamicTestInvocationContext	DynamicTestInvocationContext represents the context of a single invocation of a dynamic test.
EnabledForJreRange	@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	@EnabledIf is used to signal that the annotated test class or test method is enabled only if the provided condition evaluates to true.
EnabledIfEnvironmentVariable	@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	@EnabledIfEnvironmentVariables is a container for one or more @EnabledIfEnvironmentVariable declarations.
EnabledIfSystemProperties	@EnabledIfSystemProperties is a container for one or more @EnabledIfSystemProperty declarations.
EnabledIfSystemProperty	@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	@EnabledInNativeImage is used to signal that the annotated test class or test method is only enabled when executing within a GraalVM native image.
EnabledOnJre	@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	@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	Executable is a functional interface that can be used to implement any generic block of code that potentially throws a Throwable.
ExecutableInvoker	ExecutableInvoker allows invoking methods and constructors with support for dynamic resolution of parameters via ParameterResolvers.
Execution	@Execution is used to configure the parallel execution mode of a test class or test method.
ExecutionCondition	ExecutionCondition defines the Extension API for programmatic, conditional test execution.
ExecutionMode	Supported execution modes for parallel test execution.
ExtendWith	@ExtendWith is a repeatable annotation that is used to register extensions for the annotated test class, test interface, test method, parameter, or field.
Extension	Marker interface for all extensions.
ExtensionConfigurationException	Thrown if an error is encountered regarding the configuration of an extension.
ExtensionContext	ExtensionContext encapsulates the context in which the current test or container is being executed.
ExtensionContext.Namespace	A Namespace is used to provide a scope for data saved by extensions within a ExtensionContext.Store.
ExtensionContext.Store	Store provides methods for extensions to save and retrieve data.
ExtensionContext.Store.CloseableResource	Classes implementing this interface indicate that they want to ExtensionContext.Store.CloseableResource.close() some underlying resource or resources when the enclosing Store is closed.
ExtensionContextException	Thrown if an error is encountered regarding the use of an ExtensionContext or ExtensionContext.Store.
Extensions	@Extensions is a container for one or more @ExtendWith declarations.
IndicativeSentencesGeneration	@IndicativeSentencesGeneration is used to register the DisplayNameGenerator.IndicativeSentences display name generator and configure it.
InvocationInterceptor	InvocationInterceptor defines the API for Extensions that wish to intercept calls to test code.
InvocationInterceptor.Invocation<T>	An invocation that returns a result and may throw a Throwable.
Isolated	@Isolated is used to declare that the annotated test class should be executed in isolation from other test classes.
JRE	Enumeration of Java Runtime Environment (JRE) versions.
LifecycleMethodExecutionExceptionHandler	LifecycleMethodExecutionExceptionHandler defines the API for Extensions that wish to handle exceptions thrown during the execution of @BeforeAll, @BeforeEach, @AfterEach, and @AfterAll lifecycle methods.
MethodDescriptor	MethodDescriptor encapsulates functionality for a given Method.
MethodOrderer	MethodOrderer defines the API for ordering the test methods in a given test class.
MethodOrderer.Alphanumeric	Deprecated. as of JUnit Jupiter 5.7 in favor of MethodOrderer.MethodName; to be removed in 6.0
MethodOrderer.DisplayName	MethodOrderer that sorts methods alphanumerically based on their display names using String.compareTo(String)
MethodOrderer.MethodName	MethodOrderer that sorts methods alphanumerically based on their names using String.compareTo(String).
MethodOrderer.OrderAnnotation	MethodOrderer that sorts methods based on the @Order annotation.
MethodOrderer.Random	MethodOrderer that orders methods pseudo-randomly.
MethodOrdererContext	MethodOrdererContext encapsulates the context in which a MethodOrderer will be invoked.
Named<T>	Named is a container that associates a name with a given payload.
Nested	@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	@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.
OS	Enumeration of common operating systems used for testing Java applications.
ParameterContext	ParameterContext encapsulates the context in which an Executable will be invoked for a given Parameter.
ParameterResolutionException	Thrown if an error is encountered in the configuration or execution of a ParameterResolver.
ParameterResolver	ParameterResolver defines the API for Extensions that wish to dynamically resolve arguments for parameters at runtime.
ReflectiveInvocationContext<T extends java.lang.reflect.Executable>	ReflectiveInvocationContext encapsulates the context of a reflective invocation of an executable (method or constructor).
RegisterExtension	@RegisterExtension is used to register an Extension via a field in a test class.
RepeatedTest	@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	RepetitionInfo is used to inject information about the current repetition of a repeated test into @RepeatedTest, @BeforeEach, and @AfterEach methods.
ResourceAccessMode	The access mode required by a test class or method for a given resource.
ResourceLock	@ResourceLock is used to declare that the annotated test class or test method requires access to a shared resource identified by a key.
ResourceLocks	@ResourceLocks is a container for one or more @ResourceLock declarations.
Resources	Common resource names for synchronizing test execution.
Tag	@Tag is a repeatable annotation that is used to declare a tag for the annotated test class or test method.
Tags	@Tags is a container for one or more @Tag declarations.
TempDir	@TempDir can be used to annotate a field in a test class or a parameter in a lifecycle method or test method of type Path or File that should be resolved into a temporary directory.
TempDirFactory	TempDirFactory defines the SPI for creating temporary directories programmatically.
TempDirFactory.Standard	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	@Test is used to signal that the annotated method is a test method.
TestClassOrder	@TestClassOrder is a type-level annotation that is used to configure a ClassOrderer for the @Nested test classes of the annotated test class.
TestExecutionExceptionHandler	TestExecutionExceptionHandler defines the API for Extensions that wish to handle exceptions thrown during test execution.
TestFactory	@TestFactory is used to signal that the annotated method is a test factory method.
TestInfo	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	@TestInstance is a type-level annotation that is used to configure the lifecycle of test instances for the annotated test class or test interface.
TestInstance.Lifecycle	Enumeration of test instance lifecycle modes.
TestInstanceFactory	TestInstanceFactory defines the API for Extensions that wish to create test instances.
TestInstanceFactoryContext	TestInstanceFactoryContext encapsulates the context in which a test class is to be instantiated by a TestInstanceFactory.
TestInstancePostProcessor	TestInstancePostProcessor defines the API for Extensions that wish to post-process test instances.
TestInstancePreConstructCallback	TestInstancePreConstructCallback defines the API for Extensions that wish to be invoked prior to creation of test instances.
TestInstancePreDestroyCallback	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	TestInstances encapsulates the test instances of a test.
TestInstantiationException	Thrown if an error is encountered during the execution of a TestInstanceFactory.
TestMethodOrder	@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.
TestReporter	Parameters of type TestReporter can be injected into @BeforeEach and @AfterEach lifecycle methods as well as methods annotated with @Test, @RepeatedTest, @ParameterizedTest, @TestFactory, etc.
TestTemplate	@TestTemplate is used to signal that the annotated method is a test template method.
TestTemplateInvocationContext	TestTemplateInvocationContext represents the context of a single invocation of a test template.
TestTemplateInvocationContextProvider	TestTemplateInvocationContextProvider defines the API for Extensions that wish to provide one or multiple contexts for the invocation of a @TestTemplate method.
TestWatcher	TestWatcher defines the API for Extensions that wish to process test results.
ThrowingConsumer<T>	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<T>	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	@Timeout is used to define a timeout for a method or all testable methods within one class and its @Nested classes.
Timeout.ThreadMode	ThreadMode is use to define whether the test code should be executed in the thread of the calling code or in a separated thread.
TypeBasedParameterResolver<T>	ParameterResolver adapter which resolves a parameter based on its exact type.