All Classes and Interfaces

Class	Description
AbstractTestDescriptor	Abstract base implementation of TestDescriptor that may be used by custom TestEngines.
AbstractTestRuleAdapter
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.
AfterEachMethodAdapter	Functional interface for registering an @AfterEach method as a pseudo-extension.
AfterSuite	@AfterSuite is used to signal that the annotated method should be executed after all tests in the current test suite.
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.
AggregateWith	@AggregateWith is an annotation that allows one to specify an ArgumentsAggregator.
AnnotatedElementContext	AnnotatedElementContext encapsulates the context in which an AnnotatedElement is declared.
AnnotationBasedArgumentConverter<A>	AnnotationBasedArgumentConverter is an abstract base class for ArgumentConverter implementations that also need to consume an annotation in order to perform the conversion.
AnnotationBasedArgumentsProvider<A>	AnnotationBasedArgumentsProvider is an abstract base class for ArgumentsProvider implementations that also need to consume an annotation in order to provide the arguments.
AnnotationConsumer<A>	AnnotationConsumer is a functional interface for consuming annotations.
AnnotationConsumerInitializer	AnnotationConsumerInitializer is an internal helper class for initializing AnnotationConsumers.
AnnotationSupport	AnnotationSupport provides static utility methods for common tasks regarding annotations — for example, checking if a class, method, or field is annotated with a particular annotation; finding annotations on a given class, method, or field; finding fields or methods annotated with a particular annotation, etc.
AnnotationUtils	Collection of utilities for working with annotations.
ArgumentAccessException	ArgumentAccessException is an exception thrown by an ArgumentsAccessor if an error occurs while accessing or converting an argument.
ArgumentConversionException	ArgumentConversionException is an exception that can occur when an object is converted to another object by an implementation of an ArgumentConverter.
ArgumentConverter	ArgumentConverter is an abstraction that allows an input object to be converted to an instance of a different class.
ArgumentCountValidationMode	Enumeration of argument count validation modes for @ParameterizedTest.
Arguments	Arguments is an abstraction that provides access to an array of objects to be used for invoking a @ParameterizedTest method.
Arguments.ArgumentSet	Specialization of Arguments that associates a name with a set of arguments.
ArgumentsAccessor	ArgumentsAccessor defines the public API for accessing arguments provided by an ArgumentsProvider for a single invocation of a @ParameterizedTest method.
ArgumentsAggregationException	ArgumentsAggregationException is an exception thrown by an ArgumentsAggregator when an error occurs while aggregating arguments.
ArgumentsAggregator	ArgumentsAggregator is an abstraction for the aggregation of arguments provided by an ArgumentsProvider for a single invocation of a @ParameterizedTest method into a single object.
ArgumentsProvider	An ArgumentsProvider is responsible for providing a stream of arguments to be passed to a @ParameterizedTest method.
ArgumentsSource	@ArgumentsSource is a repeatable annotation that is used to register arguments providers for the annotated test method.
ArgumentsSources	@ArgumentsSources is a simple container for one or more ArgumentsSource annotations.
AssertionFailureBuilder	Builder for AssertionFailedErrors.
Assertions	Assertions is a collection of utility methods that support asserting conditions in tests.
Assertions.TimeoutFailureFactory<T>	Factory for timeout failures.
Assumptions	Assumptions is a collection of utility methods that support conditional test execution based on assumptions.
AutoClose	@AutoClose is used to indicate that an annotated field will be automatically closed after test execution.
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.
BeforeEachMethodAdapter	Functional interface for registering a @BeforeEach method as a pseudo-extension.
BeforeSuite	@BeforeSuite is used to signal that the annotated method should be executed before all tests in the current test suite.
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.
BlacklistedExceptions	Deprecated. Use UnrecoverableExceptions instead.
CachingJupiterConfiguration	Caching implementation of the JupiterConfiguration API.
ClassBasedTestDescriptor	TestDescriptor for tests based on Java classes.
ClassDescriptor	ClassDescriptor encapsulates functionality for a given Class.
ClassFilter	Class-related predicate used by reflection utilities.
ClassLoaderUtils	Collection of utilities for working with ClassLoader and associated tasks.
ClassNameFilter	DiscoveryFilter that is applied to the name of a Class.
ClassNamePatternFilterUtils	Collection of utilities for creating filters based on class names.
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.
ClasspathResourceSelector	A DiscoverySelector that selects the name of a classpath resource so that TestEngines can load resources from the classpath — for example, to load XML or JSON files from the classpath, potentially within JARs.
ClasspathResourceSelector.IdentifierParser	The DiscoverySelectorIdentifierParser for ClasspathResourceSelectors.
ClasspathResourceSource	Classpath resource based TestSource with an optional position.
ClasspathRootSelector	A DiscoverySelector that selects a classpath root so that TestEngines can search for class files or resources within the physical classpath — for example, to scan for test classes.
ClasspathRootSelector.IdentifierParser	The DiscoverySelectorIdentifierParser for ClasspathRootSelectors.
ClasspathScanningSupport	Deprecated. Please use EngineDiscoveryRequestResolver instead.
ClassSelector	A DiscoverySelector that selects a Class or class name so that TestEngines can discover tests or containers based on classes.
ClassSelector.IdentifierParser	The DiscoverySelectorIdentifierParser for ClassSelectors.
ClassSource	Class based TestSource with an optional file position.
ClassSupport	ClassSupport provides static utility methods for common tasks regarding classes — for example, generating a comma-separated list of fully qualified class names for a set of supplied classes.
ClassTestDescriptor	TestDescriptor for tests based on Java classes.
ClassUtils	Collection of utilities for working with classes.
CleanupMode	Enumeration of cleanup modes for @TempDir.
CollectionUtils	Collection of utilities for working with Collections.
CommandFacade	Internal facade to run a CLI command that exists to hide implementation details such as the used library.
CommandResult<T>
CompositeTestSource	A CompositeTestSource contains one or more TestSources.
ConditionEvaluationResult	The result of evaluating an ExecutionCondition.
ConditionEvaluator	ConditionEvaluator evaluates ExecutionCondition extensions.
ConfigurationParameter	@ConfigurationParameter is a repeatable annotation that specifies a configuration key and value pair to be added to the discovery request when running a test suite on the JUnit Platform.
ConfigurationParameters	Configuration parameters that TestEngines may use to influence test discovery and execution.
ConfigurationParameters	@ConfigurationParameters is a container for one or more @ConfigurationParameter declarations.
ConfigurationParametersResource	@ConfigurationParametersResource is a repeatable annotation that specifies a configuration file in Java's properties format on the classpath to be added to the discovery request when running a test suite on the JUnit Platform.
ConfigurationParametersResources	@ConfigurationParametersResources is a container for one or more @ConfigurationParametersResource declarations.
ConsoleLauncher	The ConsoleLauncher is a stand-alone application for launching the JUnit Platform from the console.
ConsoleLauncherToolProvider	Run the JUnit Platform Console Launcher as a service.
ConsoleTestExecutor
ConsoleTestExecutor.Factory
ConsoleUtils	Collection of utilities for working with java.io.Console and friends.
Constants	Collection of constants related to the JupiterTestEngine.
ConversionException	ConversionException is an exception that can occur when an object is converted to another object.
ConversionSupport	ConversionSupport provides static utility methods for converting a given object into an instance of a specified type.
ConvertWith	@ConvertWith is an annotation that allows one to specify an explicit ArgumentConverter.
CsvFileSource	@CsvFileSource is a repeatable ArgumentsSource which is used to load comma-separated value (CSV) files from one or more classpath CsvFileSource.resources() or CsvFileSource.files().
CsvFileSources	@CsvFileSources is a simple container for one or more CsvFileSource annotations.
CsvParsingException	Thrown if an error is encountered while parsing CSV input.
CsvSource	@CsvSource is a repeatable ArgumentsSource which reads comma-separated values (CSV) from one or more CSV records supplied via the CsvSource.value() attribute or CsvSource.textBlock() attribute.
CsvSources	@CsvSources is a simple container for one or more CsvSource annotations.
DefaultArgumentConverter	DefaultArgumentConverter is the default implementation of the ArgumentConverter API.
DefaultArgumentsAccessor	Default implementation of the ArgumentsAccessor API.
DefaultExecutableInvoker
DefaultJupiterConfiguration	Default implementation of the JupiterConfiguration API.
DefaultParallelExecutionConfigurationStrategy	Default implementations of configuration strategies for parallel test execution.
DefaultTestInstances
DescriptionUtils
Details
DirectorySelector	A DiscoverySelector that selects a directory so that TestEngines can discover tests or containers based on directories in the file system.
DirectorySelector.IdentifierParser	The DiscoverySelectorIdentifierParser for DirectorySelectors.
DirectorySource	Directory based TestSource.
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 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 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 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
DisableParentConfigurationParameters	Disable parent configuration parameters.
DiscoveryFilter<T>	A DiscoveryFilter is applied during test discovery to determine if a given container or test should be included in the test plan.
DiscoverySelector	A selector defines what a TestEngine can use to discover tests — for example, the name of a Java class, the path to a file or directory, etc.
DiscoverySelectorIdentifier	Identifier for a DiscoverySelector with a specific prefix.
DiscoverySelectorIdentifierParser	Parser for a DiscoverySelectorIdentifier with a specific prefix.
DiscoverySelectorIdentifierParser.Context	Context for parsing DiscoverySelectorIdentifiers.
DiscoverySelectorResolver	DiscoverySelectorResolver resolves TestDescriptors for containers and tests selected by DiscoverySelectors, with the help of an EngineDiscoveryRequestResolver.
DiscoverySelectors	Collection of static factory methods for creating DiscoverySelectors.
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.
DynamicDescendantFilter	Filter for dynamic descendants of TestDescriptors that implement Filterable.
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.
EmptySource	@EmptySource is an ArgumentsSource which provides a single empty argument to the annotated @ParameterizedTest method.
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 only enabled 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.
EnableJUnit4MigrationSupport	EnableJUnit4MigrationSupport is a class-level annotation that enables all JUnit 4 migration support within JUnit Jupiter.
EnableRuleMigrationSupport	This class-level annotation enables native JUnit 4 rule support within JUnit Jupiter.
EngineDescriptor	An EngineDescriptor is a TestDescriptor for a specific TestEngine.
EngineDiscoveryListener	EngineDiscoveryListener contains TestEngine access to the information necessary to discover tests and containers.
EngineDiscoveryOrchestrator	Orchestrates test discovery using the configured test engines.
EngineDiscoveryOrchestrator.Phase
EngineDiscoveryRequest	EngineDiscoveryRequest provides a TestEngine access to the information necessary to discover tests and containers.
EngineDiscoveryRequestResolver<T>	Configurable test discovery implementation based on SelectorResolver and TestDescriptor.Visitor that can be reused by different TestEngines.
EngineDiscoveryRequestResolver.Builder<T>	Builder for EngineDiscoveryRequestResolver.
EngineDiscoveryRequestResolver.InitializationContext<T>	The initialization context for creating resolvers and visitors that depend on the EngineDiscoveryRequest to be resolved or the engine descriptor that will be used to collect the results.
EngineDiscoveryResult	EngineDiscoveryResult encapsulates the result of test discovery by a TestEngine.
EngineDiscoveryResult.Status	Status of test discovery by a TestEngine.
EngineExecutionContext	Marker interface for an execution context used by a concrete implementation of HierarchicalTestEngine and its collaborators.
EngineExecutionListener	Listener to be notified of test execution events by test engines.
EngineExecutionOrchestrator	Orchestrates test execution using the configured test engines.
EngineExecutionResults	EngineExecutionResults provides a fluent API for processing the results of executing a test plan on the JUnit Platform for a given TestEngine.
EngineFilter	An EngineFilter is applied to all TestEngines before they are used.
EngineTestKit	EngineTestKit provides support for executing a test plan for a given TestEngine and then accessing the results via a fluent API to verify the expected results.
EngineTestKit.Builder	TestEngine execution builder.
EnumConfigurationParameterConverter<E>
EnumSource	@EnumSource is a repeatable ArgumentsSource for constants of an Enum.
EnumSource.Mode	Enumeration of modes for selecting enum constants by name.
EnumSources	@EnumSources is a simple container for one or more EnumSource annotations.
Event	Event represents a single event fired during execution of a test plan on the JUnit Platform.
EventConditions	Collection of AssertJ conditions for Event.
Events	Events is a facade that provides a fluent API for working with events.
EventStatistics	EventStatistics provides a fluent API for asserting statistics for events.
EventType	Enumeration of the different possible Event types.
ExceptionUtils	Collection of utilities for working with exceptions.
ExcludeClassNamePatterns	@ExcludeClassNamePatterns specifies regular expressions that are used to match against fully qualified class names when running a test suite on the JUnit Platform.
ExcludeEngines	@ExcludeEngines specifies the IDs of TestEngines to be excluded when running a test suite on the JUnit Platform.
ExcludePackages	@ExcludePackages specifies the packages to be excluded when running a test suite on the JUnit Platform.
ExcludeTags	@ExcludeTags specifies the tags or tag expressions to be excluded when running a test suite on the JUnit Platform.
ExclusiveResource	An exclusive resource identified by a key with a lock mode that is used to synchronize access to shared resources when executing nodes in parallel.
ExclusiveResource.LockMode	LockMode translates to the respective ReadWriteLock locks.
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.
Execution	Execution encapsulates metadata for the execution of a single TestDescriptor.
ExecutionCondition	ExecutionCondition defines the Extension API for programmatic, conditional test execution.
ExecutionMode	Supported execution modes for parallel test execution.
ExecutionRecorder	ExecutionRecorder is an EngineExecutionListener that records data from every event that occurs during the engine execution lifecycle and provides functionality for retrieving execution state via EngineExecutionResults.
ExecutionRequest	Provides a single TestEngine access to the information necessary to execute its tests.
Executions	Executions is a facade that provides a fluent API for working with executions.
ExpectedExceptionAdapter
ExpectedExceptionSupport	This Extension provides native support for the ExpectedException rule from JUnit 4.
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.
ExtensionContextInternal	ExtensionContextInternal extends the ExtensionContext with internal API.
ExtensionContextSupplier	Container of two instances of ExtensionContext to simplify the legacy for #3445.
ExtensionContextSupplier.ScopeBasedExtensionContextSupplier
ExtensionRegistrar	An ExtensionRegistrar is used to register extensions.
ExtensionRegistry	An ExtensionRegistry holds all registered extensions (i.e.
Extensions	@Extensions is a container for one or more @ExtendWith declarations.
ExternalResourceAdapter
ExternalResourceSupport	This Extension provides native support for subclasses of the ExternalResource rule from JUnit 4.
FieldSource	@FieldSource is a repeatable ArgumentsSource which provides access to values of fields of the class in which this annotation is declared or from static fields in external classes referenced by fully qualified field name.
FieldSources	@FieldSources is a simple container for one or more FieldSource annotations.
FilePosition	Position inside a file represented by line and column numbers.
FilePosition	Position inside a file represented by line and column numbers.
FileSelector	A DiscoverySelector that selects a file so that TestEngines can discover tests or containers based on files in the file system.
FileSelector.IdentifierParser	The DiscoverySelectorIdentifierParser for FileSelectors.
FileSource	File based TestSource with an optional position.
FileSystemSource	File system based TestSource.
Filter<T>	A Filter can be applied to determine if an object should be included or excluded in a result set.
Filterable	Filterable is implemented by TestDescriptors that may register dynamic tests during execution and support selective test execution.
FilterResult	The result of applying a Filter.
FlightRecordingDiscoveryListener	A LauncherDiscoveryListener that generates Java Flight Recorder events.
FlightRecordingExecutionListener	A TestExecutionListener that generates Java Flight Recorder events.
ForkJoinPoolHierarchicalTestExecutorService	A ForkJoinPool-based executor service that executes test tasks with the configured parallelism.
FunctionUtils	Collection of utilities for working with Functions, Predicates, etc.
GenericBeforeAndAfterAdvice
HierarchicalTestEngine<C>	Abstract base class for all TestEngine implementations that wish to organize test suites hierarchically based on the Node abstraction.
HierarchicalTestExecutorService	A closeable service that executes test tasks.
HierarchicalTestExecutorService.TestTask	An executable task that represents a single test or container.
HierarchyTraversalMode	Modes in which a hierarchy can be traversed — for example, when searching for methods or fields within a class hierarchy.
IgnoreCondition	ExecutionCondition that supports JUnit 4's @Ignore annotation.
IncludeClassNamePatterns	@IncludeClassNamePatterns specifies regular expressions that are used to match against fully qualified class names when running a test suite on the JUnit Platform.
IncludeEngines	@IncludeEngines specifies the IDs of TestEngines to be included when running a test suite on the JUnit Platform.
IncludePackages	@IncludePackages specifies the packages to be included when running a test suite on the JUnit Platform.
IncludeTags	@IncludeTags specifies the tags or tag expressions to be included when running a test suite on the JUnit Platform.
IndicativeSentencesGeneration	@IndicativeSentencesGeneration is used to register the DisplayNameGenerator.IndicativeSentences display name generator and configure it.
InterceptingExecutableInvoker	InterceptingExecutableInvoker encapsulates the invocation of a Executable (i.e., method or constructor), including support for dynamic resolution of method parameters via ParameterResolvers.
InterceptingExecutableInvoker.ReflectiveInterceptorCall<E,T>
InterceptingExecutableInvoker.ReflectiveInterceptorCall.VoidMethodInterceptorCall
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.
InvocationInterceptorChain
InvocationInterceptorChain.InterceptorCall<T>
InvocationInterceptorChain.VoidInterceptorCall
IsInnerClass	Test if a class is a non-private inner class (i.e., a non-static nested class).
IsNestedTestClass	Test if a class is a JUnit Jupiter @Nested test class.
Isolated	@Isolated is used to declare that the annotated test class should be executed in isolation from other test classes.
IsPotentialJUnit4TestClass
IsPotentialTestContainer	Test if a class is a potential top-level JUnit Jupiter test container, even if it does not contain tests.
IsTestClassWithTests	Test if a class is a JUnit Jupiter test class containing executable tests, test factories, test templates, or nested tests.
IsTestFactoryMethod	Test if a method is a JUnit Jupiter @TestFactory method.
IsTestMethod	Test if a method is a JUnit Jupiter @Test method.
IsTestTemplateMethod	Test if a method is a JUnit Jupiter @TestTemplate method.
IterationSelector	A DiscoverySelector that selects the iterations of a parent DiscoverySelector via their indices so that TestEngines can discover a subset of the iterations of tests or containers.
IterationSelector.IdentifierParser	The DiscoverySelectorIdentifierParser for IterationSelectors.
JavaTimeConversionPattern	@JavaTimeConversionPattern is an annotation that allows a date/time conversion pattern to be specified on a parameter of a @ParameterizedTest method.
JRE	Enumeration of Java Runtime Environment (JRE) versions.
JUnitContributor	Contributes a section containing JUnit-specific metadata for each test node to the open-test-reporting HTML report.
JUnitException	Base class for all RuntimeExceptions thrown by JUnit.
JUnitPlatform	Deprecated. since 1.8, in favor of the @Suite support provided by the junit-platform-suite-engine module; to be removed in JUnit Platform 2.0
JupiterConfiguration
JupiterEngineDescriptor
JupiterEngineExecutionContext
JupiterEngineExecutionContext.Builder
JupiterTestDescriptor
JupiterTestEngine	The JUnit Jupiter TestEngine.
JupiterThrowableCollectorFactory	Factory for creating ThrowableCollectors within the JUnit Jupiter test engine.
Launcher	The Launcher API is the main entry point for client code that wishes to discover and execute tests using one or more test engines.
LauncherConfig	LauncherConfig defines the configuration API for creating Launcher instances via the LauncherFactory.
LauncherConfig.Builder	Builder API for LauncherConfig.
LauncherConstants	Collection of constants related to Launcher.
LauncherDiscoveryListener	Register a concrete implementation of this interface with a LauncherDiscoveryRequestBuilder or Launcher to be notified of events that occur during test discovery.
LauncherDiscoveryListeners	Collection of static factory methods for creating LauncherDiscoveryListeners.
LauncherDiscoveryRequest	LauncherDiscoveryRequest extends the EngineDiscoveryRequest API with additional filters that are applied by the Launcher itself.
LauncherDiscoveryRequestBuilder	The LauncherDiscoveryRequestBuilder provides a light-weight DSL for generating a LauncherDiscoveryRequest.
LauncherDiscoveryResult	Represents the result of test discovery of the configured test engines.
LauncherFactory	Factory for creating Launcher instances by invoking LauncherFactory.create() or LauncherFactory.create(LauncherConfig).
LauncherInterceptor	Interceptor for test discovery and execution by a Launcher in the context of a LauncherSession.
LauncherInterceptor.Invocation<T>	An invocation that can be intercepted.
LauncherSession	The LauncherSession API is the main entry point for client code that wishes to repeatedly discover and execute tests using one or more test engines.
LauncherSessionListener	Register an implementation of this interface to be notified when a LauncherSession is opened and closed.
LauncherSessionListeners	Collection of static factory methods for creating LauncherSessionListeners.
LegacyReportingUtils	Deprecated. Use LegacyReportingUtils instead.
LegacyReportingUtils	Utility methods for dealing with legacy reporting infrastructure, such as reporting systems built on the Ant-based XML reporting format for JUnit 4.
LegacyXmlReportGeneratingListener	LegacyXmlReportGeneratingListener is a TestExecutionListener that generates a separate XML report for each root in the TestPlan.
LifecycleMethodExecutionExceptionHandler	LifecycleMethodExecutionExceptionHandler defines the API for Extensions that wish to handle exceptions thrown during the execution of @BeforeAll, @BeforeEach, @AfterEach, and @AfterAll lifecycle methods.
Logger	The Logger API serves as a simple logging facade for java.util.logging (JUL).
LoggerFactory	Factory for the Logger facade for JUL.
LoggingListener	Simple TestExecutionListener for logging informational messages for all events via a BiConsumer that consumes Throwable and Supplier<String>.
LogRecordListener	LogRecordListener is only intended for testing purposes within JUnit's own test suite.
LruCache<K,V>	A simple LRU cache with a maximum size.
MethodBasedTestDescriptor	Base class for TestDescriptors based on Java methods.
MethodDescriptor	MethodDescriptor encapsulates functionality for a given Method.
MethodFilter	PostDiscoveryFilter that is applied to the fully qualified Method name without parameters.
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.
MethodSelector	A DiscoverySelector that selects a Method or a combination of class name, method name, and parameter types so that TestEngines can discover tests or containers based on methods.
MethodSelector.IdentifierParser	The DiscoverySelectorIdentifierParser for MethodSelectors.
MethodSource	@MethodSource is a repeatable ArgumentsSource which provides access to values returned from factory methods of the class in which this annotation is declared or from static factory methods in external classes referenced by fully qualified method name.
MethodSource	Method based TestSource.
MethodSources	@MethodSources is a simple container for one or more MethodSource annotations.
ModifierSupport	ModifierSupport provides static utility methods for working with class and member modifiers — for example, to determine if a class or member is declared as public, private, abstract, static, etc.
ModuleSelector	A DiscoverySelector that selects a module name so that TestEngines can discover tests or containers based on modules.
ModuleSelector.IdentifierParser	The DiscoverySelectorIdentifierParser for ModuleSelectors.
ModuleUtils	Collection of utilities for working with java.lang.Module and friends.
MutableExtensionRegistry	Default, mutable implementation of ExtensionRegistry.
Named<T>	Named is a container that associates a name with a given payload.
NamedExecutable	NamedExecutable joins Executable and Named in a one self-typed functional interface.
NamespaceAwareStore
NamespacedHierarchicalStore<N>	NamespacedHierarchicalStore is a hierarchical, namespaced key-value store.
NamespacedHierarchicalStore.CloseAction<N>	Called for each successfully stored non-null value in the store when a NamespacedHierarchicalStore is closed.
NamespacedHierarchicalStoreException	Exception thrown by failed NamespacedHierarchicalStore operations.
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.
NestedClassSelector	A DiscoverySelector that selects a nested Class or class name enclosed in other classes so that TestEngines can discover tests or containers based on classes.
NestedClassSelector.IdentifierParser	The DiscoverySelectorIdentifierParser for NestedClassSelectors.
NestedClassTestDescriptor	TestDescriptor for tests based on nested (but not static) Java classes.
NestedMethodSelector	A DiscoverySelector that selects a nested Method or a combination of enclosing classes names, class name, method name, and parameter types so that TestEngines can discover tests or containers based on methods.
NestedMethodSelector.IdentifierParser	The DiscoverySelectorIdentifierParser for NestedMethodSelectors.
Node<C>	A node within the execution hierarchy.
Node.DynamicTestExecutor	Executor for additional, dynamic test descriptors discovered during execution of a Node.
Node.ExecutionMode	Supported execution modes for parallel execution.
Node.Invocation<C>	Represents an invocation that runs with the supplied context.
Node.SkipResult	The result of determining whether the execution of a given context should be skipped.
NullAndEmptySource	@NullAndEmptySource is a composed annotation that combines the functionality of @NullSource and @EmptySource.
NullEnum	Dummy enum class used as default value for optional attributes of annotations.
NullSource	@NullSource is an ArgumentsSource which provides a single null argument to the annotated @ParameterizedTest method.
OpenTest4JAwareThrowableCollector	Specialization of ThrowableCollector that treats instances of TestAbortedException as aborting.
OpenTestReportGeneratingListener	Open Test Reporting events XML generating test execution listener.
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.
OutputDir
PackageNameFilter	DiscoveryFilter that is applied to the name of a Package.
PackageSelector	A DiscoverySelector that selects a package name so that TestEngines can discover tests or containers based on packages.
PackageSelector.IdentifierParser	The DiscoverySelectorIdentifierParser for PackageSelectors.
PackageSource	Package based TestSource.
PackageUtils	Collection of utilities for working with packages.
ParallelExecutionConfiguration	Configuration to use for parallel test execution.
ParallelExecutionConfigurationStrategy	A strategy to use for configuring parallel test execution.
ParameterContext	ParameterContext encapsulates the context in which an Executable will be invoked for a given Parameter.
ParameterizedTest	@ParameterizedTest is used to signal that the annotated method is a parameterized test method.
ParameterResolutionException	Thrown if an error is encountered in the configuration or execution of a ParameterResolver.
ParameterResolutionUtils	ParameterResolutionUtils provides support for dynamic resolution of executable parameters via ParameterResolvers.
ParameterResolver	ParameterResolver defines the API for Extensions that wish to dynamically resolve arguments for parameters at runtime.
ParseResult	The result of attempting to parse a TagExpression.
PostDiscoveryFilter	A PostDiscoveryFilter is applied to TestDescriptors after test discovery.
Preconditions	Collection of utilities for asserting preconditions for method and constructor arguments.
PreconditionViolationException	Thrown if a precondition is violated.
PreconditionViolationException	Deprecated. Use PreconditionViolationException instead.
PrefixedConfigurationParameters	View of ConfigurationParameters that applies a supplied prefix to all queries.
PreInterruptCallback	PreInterruptCallback defines the API for Extensions that wish to be called prior to invocations of Thread.interrupt() by the Timeout extension.
PreInterruptContext	PreInterruptContext encapsulates the context in which an beforeThreadInterrupt method is called.
ReflectionSupport	ReflectionSupport provides static utility methods for common reflection tasks — for example, scanning for classes in the class-path or module-path, loading classes, finding methods, invoking methods, etc.
ReflectionUtils	Collection of utilities for working with the Java reflection APIs.
ReflectionUtils.HierarchyTraversalMode	Modes in which a hierarchy can be traversed — for example, when searching for methods or fields within a class hierarchy.
ReflectiveInvocationContext<T>	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.
ReportEntry	ReportEntry encapsulates a time-stamped map of String-based key-value pairs to be published to the reporting infrastructure.
Resource	Represents a resource on the classpath.
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.
ResourceLock	A lock for a one or more resources.
ResourceLocks	@ResourceLocks is a container for one or more @ResourceLock declarations.
ResourceLocksProvider	@ResourceLocksProvider is used to add shared resources to a test class and / or its test methods dynamically at runtime.
ResourceLocksProvider.Lock	ResourceLocksProvider.Lock represents a shared resource.
Resources	Common resource names for synchronizing test execution.
ResourceUtils	Collection of static utility methods for working with resources.
RunnerDecorator
RunnerExecutor
RunnerTestDescriptor
RuntimeUtils	Collection of utilities for working with Runtime, RuntimeMXBean, etc.
SameThreadHierarchicalTestExecutorService	A simple executor service that executes all test tasks in the caller's thread.
SearchOption	Search options for finding an annotation within a class hierarchy.
Select	@Select is a repeatable annotation that specifies which tests to select based on prefixed selector identifiers.
SelectClasses	@SelectClasses specifies the classes to select when running a test suite on the JUnit Platform.
SelectClasspathResource	@SelectClasspathResource is a repeatable annotation that specifies a classpath resource to select when running a test suite on the JUnit Platform.
SelectClasspathResources	@SelectClasspathResources is a container for one or more @SelectClasspathResource declarations.
SelectDirectories	@SelectDirectories specifies the directories to select when running a test suite on the JUnit Platform.
SelectFile	@SelectFile is a repeatable annotation that specifies a file to select when running a test suite on the JUnit Platform.
SelectFiles	@SelectFiles is a container for one or more @SelectFile declarations.
SelectMethod	@SelectMethod is a repeatable annotation that specifies a method to select when running a test suite on the JUnit Platform.
SelectMethods	@SelectMethods is a container for one or more @SelectMethod declarations.
SelectModules	@SelectModules specifies the modules to select when running a test suite on the JUnit Platform.
SelectorResolutionResult	SelectorResolutionResult encapsulates the result of resolving a DiscoverySelector by a TestEngine.
SelectorResolutionResult.Status	Status of resolving a DiscoverySelector.
SelectorResolver	A resolver that supports resolving one or multiple types of DiscoverySelectors.
SelectorResolver.Context	The context for resolving a DiscoverySelector and adding it to the test tree.
SelectorResolver.Match	An exact or partial match for resolving a DiscoverySelector into a TestDescriptor.
SelectorResolver.Resolution	The result of an attempt to resolve a DiscoverySelector.
SelectPackages	@SelectPackages specifies the names of packages to select when running a test suite on the JUnit Platform.
Selects	@Selects is a container for one or more @Select declarations.
SelectUris	@SelectUris specifies the URIs to select when running a test suite on the JUnit Platform.
ServiceLoaderTestEngineRegistry
SimpleArgumentConverter	SimpleArgumentConverter is an abstract base class for ArgumentConverter implementations that only need to know the target type and do not need access to the ParameterContext to perform the conversion.
SingleTestExecutor	Deprecated. Please use ThrowableCollector.execute(org.junit.platform.engine.support.hierarchical.ThrowableCollector.Executable) and ThrowableCollector.toTestExecutionResult() instead.
SingleTestExecutor.Executable	Functional interface for a single test to be executed by SingleTestExecutor.
StringUtils	Collection of utilities for working with Strings, CharSequences, etc.
StringUtils.TwoPartSplitResult	The result of splitting a string into up to two parts.
Suite	@Suite marks a class as a test suite on the JUnit Platform.
SuiteDisplayName	@SuiteDisplayName is used to declare a custom display name for the annotated test class that is executed as a test suite on the JUnit Platform.
SuiteLauncherDiscoveryRequestBuilder	The SuiteLauncherDiscoveryRequestBuilder provides a light-weight DSL for generating a LauncherDiscoveryRequest specifically tailored for suite execution.
SuiteTestEngine	The JUnit Platform Suite TestEngine.
SummaryGeneratingListener	Simple TestExecutionListener that generates a summary of the test execution.
Tag	@Tag is a repeatable annotation that is used to declare a tag for the annotated test class or test method.
TagExpression	A tag expression can be evaluated against a collection of tags to determine if they match the expression.
TagFilter	Factory methods for creating PostDiscoveryFilters based on included and excluded tags or tag expressions.
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 prefix.
TerminationInfo	TerminationInfo is a union type that allows propagation of terminated container/test state, supporting either the reason if the container/test was skipped or the TestExecutionResult if the container/test was executed.
Test	@Test is used to signal that the annotated method is a test method.
Testable	@Testable is used to signal to IDEs and tooling vendors that the annotated or meta-annotated element is testable.
TestClassOrder	@TestClassOrder is a type-level annotation that is used to configure a ClassOrderer for the @Nested test classes of the annotated test class.
TestConsoleOutputOptions
TestDescriptor	Mutable descriptor for a test or container that has been discovered by a TestEngine.
TestDescriptor.Type	Supported types for TestDescriptors.
TestDescriptor.Visitor	Visitor for the tree-like TestDescriptor structure.
TestDiscoveryOptions
TestEngine	A TestEngine facilitates discovery and execution of tests for a particular programming model.
TestExecutionExceptionHandler	TestExecutionExceptionHandler defines the API for Extensions that wish to handle exceptions thrown during test execution.
TestExecutionListener	Register a concrete implementation of this interface with a Launcher to be notified of events that occur during test execution.
TestExecutionResult	TestExecutionResult encapsulates the result of executing a single test or container.
TestExecutionResult.Status	Status of executing a single test or container.
TestExecutionResultConditions	Collection of AssertJ conditions for TestExecutionResult.
TestExecutionSummary	Summary of test plan execution.
TestExecutionSummary.Failure	Failure of a test or container.
TestFactory	@TestFactory is used to signal that the annotated method is a test factory method.
TestFactoryTestDescriptor	TestDescriptor for @TestFactory methods.
TestIdentifier	Immutable data transfer object that represents a test or container which is usually part of a TestPlan.
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.
TestInstanceLifecycleUtils	Collection of utilities for retrieving the test instance lifecycle mode.
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.
TestInstancesProvider
TestInstantiationAwareExtension	Interface for Extensions that are aware and can influence the instantiation of test instances.
TestInstantiationAwareExtension.ExtensionContextScope	ExtensionContextScope is used to define the scope of the ExtensionContext passed to an extension during the instantiation of test instances.
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.
TestMethodTestDescriptor	TestDescriptor for @Test methods.
TestPlan	TestPlan describes the tree of tests and containers as discovered by a Launcher.
TestPlan.Visitor	Visitor for TestIdentifiers in a TestPlan.
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.
TestRuleAnnotatedField
TestRuleAnnotatedMember
TestRuleAnnotatedMethod
TestSource	Representation of the source of a test or container used to navigate to its location by IDEs and build tools.
TestSourceProvider
TestTag	Immutable value object for a tag that is assigned to a test or container.
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.
TestTemplateInvocationTestDescriptor	TestDescriptor for a @TestTemplate invocation.
TestTemplateTestDescriptor	TestDescriptor for @TestTemplate methods.
TestWatcher	TestWatcher defines the API for Extensions that wish to process test results.
Theme
ThrowableCollector	Simple component that can be used to collect one or more instances of Throwable.
ThrowableCollector.Executable	Functional interface for an executable block of code that may throw a Throwable.
ThrowableCollector.Factory	Factory for ThrowableCollector instances.
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 used to define whether test code should be executed in the thread of the calling code or in a separate thread.
ToStringBuilder	Simple builder for generating strings in custom implementations of toString().
Try<V>	A container object which may either contain a nullable value in case of success or an exception in case of failure.
Try.Transformer<S,T>	A transformer for values of type S to type T.
TypeBasedParameterResolver<T>	ParameterResolver adapter which resolves a parameter based on its exact type.
TypedArgumentConverter<S,T>	TypedArgumentConverter is an abstract base class for ArgumentConverter implementations that always convert objects of a given source type into a given target type.
UniqueId	UniqueId encapsulates the creation, parsing, and display of unique IDs for TestDescriptors.
UniqueId.Segment	A segment of a UniqueId comprises a type and a value.
UniqueIdReader
UniqueIdSelector	A DiscoverySelector that selects a UniqueId so that TestEngines can discover tests or containers based on unique IDs.
UniqueIdSelector.IdentifierParser	The DiscoverySelectorIdentifierParser for UniqueIdSelectors.
UniqueIdStringifier
UniqueIdTrackingListener	UniqueIdTrackingListener is a TestExecutionListener that tracks the unique IDs of all tests that were executed during the execution of the TestPlan and generates a file containing the unique IDs once execution of the TestPlan has finished.
UnrecoverableExceptions	Internal utilities for working with unrecoverable exceptions.
UriSelector	A DiscoverySelector that selects a URI so that TestEngines can discover tests or containers based on URIs.
UriSelector.IdentifierParser	The DiscoverySelectorIdentifierParser for UriSelectors.
UriSource	A TestSource that can be represented as a URI.
UseTechnicalNames	Deprecated. since 1.8, in favor of the @Suite support provided by the junit-platform-suite-engine module; to be removed in JUnit Platform 2.0
ValueSource	@ValueSource is a repeatable ArgumentsSource which provides access to an array of literal values.
ValueSources	@ValueSources is a simple container for one or more ValueSource annotations.
VerifierAdapter
VerifierSupport	This Extension provides native support for subclasses of the Verifier rule from JUnit 4.
VintageDiscoverer
VintageEngineDescriptor
VintageTestDescriptor
VintageTestEngine	The JUnit Vintage TestEngine.