All Classes

Class	Description
AbortOnFailureLauncherDiscoveryListener
AbstractAnnotatedDescriptorWrapper<E extends java.lang.reflect.AnnotatedElement>	Abstract base class for wrappers for test descriptors based on annotated elements.
AbstractClassNameFilter	Abstract ClassNameFilter that servers as a superclass for filters including or excluding fully qualified class names based on pattern-matching.
AbstractExtensionContext<T extends TestDescriptor>
AbstractMethodFilter	Abstract MethodFilter that servers as a superclass for filters including or excluding fully qualified method names without parameters based on pattern-matching.
AbstractOrderingVisitor	Abstract base class for visitors that order children nodes.
AbstractOrderingVisitor.DescriptorWrapperOrderer<ORDERER,WRAPPER>
AbstractOrderingVisitor.MessageGenerator
AbstractParameterizedClassInvocationLifecycleMethodInvoker
AbstractTestDescriptor	Abstract base implementation of TestDescriptor that may be used by custom TestEngines.
AbstractTestRuleAdapter
AbstractTestRuleAnnotatedMember
AdditionalDiscoverySelectors
AfterEachMethodAdapter	Functional interface for registering an @AfterEach method as a pseudo-extension.
AfterParameterizedClassInvocation	@AfterParameterizedClassInvocation is used to signal that the annotated method should be executed before each invocation of the current @ParameterizedClass.
AfterParameterizedClassInvocationMethodInvoker
AfterSuite	@AfterSuite is used to signal that the annotated method should be executed after all tests in the current test suite.
AggregateWith	@AggregateWith is an annotation that allows one to specify an ArgumentsAggregator.
AnnotationBasedArgumentConverter<A extends java.lang.annotation.Annotation>	AnnotationBasedArgumentConverter is an abstract base class for ArgumentConverter implementations that also need to consume an annotation in order to perform the conversion.
AnnotationBasedArgumentsProvider<A extends java.lang.annotation.Annotation>	AnnotationBasedArgumentsProvider is an abstract base class for ArgumentsProvider implementations that also need to consume an annotation in order to provide the arguments.
AnnotationConsumer<A extends java.lang.annotation.Annotation>	AnnotationConsumer is a functional interface for consuming annotations.
AnnotationConsumerInitializer	AnnotationConsumerInitializer is an internal helper class for initializing AnnotationConsumers.
AnnotationConsumerInitializer.AnnotationConsumingMethodSignature
AnsiColorOptionMixin
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 @ParameterizedClass and @ParameterizedTest.
ArgumentCountValidator
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.
ArgumentSetLifecycleMethod
ArgumentSetLifecycleMethod.ParameterResolver
ArgumentsProvider	An ArgumentsProvider is responsible for providing a stream of arguments to be passed to a @ParameterizedClass or @ParameterizedTest.
ArgumentsSource	@ArgumentsSource is a repeatable annotation that is used to register arguments providers for the annotated class or method.
ArgumentsSources	@ArgumentsSources is a simple container for one or more ArgumentsSource annotations.
ArgumentsUtils	Collection of utilities for working with Arguments.
Assertions	Assertions is a collection of selected assertion utility methods from JUnit Jupiter for use within the JUnit Platform Test Kit.
Assertions.Executable
AutoCloseExtension	AutoCloseExtension is a JUnit Jupiter extension that closes resources if a field in a test class is annotated with @AutoClose.
BannerOptionMixin
BaseCommand<T>
BeforeClassTemplateInvocationFieldInjector
BeforeEachMethodAdapter	Functional interface for registering a @BeforeEach method as a pseudo-extension.
BeforeParameterizedClassInvocation	@BeforeParameterizedClassInvocation is used to signal that the annotated method should be executed before each invocation of the current @ParameterizedClass.
BeforeParameterizedClassInvocationMethodInvoker
BeforeSuite	@BeforeSuite is used to signal that the annotated method should be executed before all tests in the current test suite.
CachingJupiterConfiguration	Caching implementation of the JupiterConfiguration API.
CallbackSupport
CallbackSupport.CallbackInvoker<T extends org.junit.jupiter.api.extension.Extension>
ClassBasedTestDescriptor	TestDescriptor for tests based on Java classes.
ClassBasedTestDescriptor.ClassInfo
ClassBasedTestDescriptor.LifecycleMethods
ClassContainerSelectorResolver
ClassExtensionContext
ClassNameFilter	DiscoveryFilter that is applied to the name of a Class.
ClassOrderingVisitor
ClasspathAlignmentChecker
ClasspathAlignmentCheckingLauncherInterceptor
ClasspathEntriesConverter
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.
ClassSelectorResolver
ClassSelectorResolver
ClassSelectorResolver.DummyClassTemplateInvocationContext
ClassSource	Class based TestSource with an optional file position.
ClassTemplateConstructorParameterResolver
ClassTemplateInvocationExtensionContext
ClassTemplateInvocationTestDescriptor
ClassTemplateTestDescriptor
ClassTestDescriptor	TestDescriptor for tests based on Java classes.
ColorPalette
CommandFacade	Internal facade to run a CLI command that exists to hide implementation details such as the used library.
CommandResult<T>
CompositeEngineExecutionListener
CompositeFilter<T>	Combines a collection of Filters into a new filter that will include elements if and only if all of the filters in the specified collection include it.
CompositeLauncherDiscoveryListener
CompositeLauncherSessionListener
CompositeLock
CompositeTestDescriptorVisitor
CompositeTestExecutionListener
CompositeTestExecutionListener.EagerTestExecutionListener
CompositeTestSource	A CompositeTestSource contains one or more TestSources.
ConditionEvaluationException	Thrown if an error is encountered while 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.
ConsoleTestExecutor
ConsoleTestExecutor.Factory
ConsoleUtils	Collection of utilities for working with java.io.Console and friends.
Constants	Collection of constants related to the JupiterTestEngine.
Constants	Collection of constants related to the VintageTestEngine.
ConstructorInvocation<T>
ConvertWith	@ConvertWith is an annotation that allows one to specify an explicit ArgumentConverter.
CsvArgumentsProvider
CsvFileArgumentsProvider
CsvFileArgumentsProvider.CsvParserIterator
CsvFileArgumentsProvider.DefaultInputStreamProvider
CsvFileArgumentsProvider.InputStreamProvider
CsvFileArgumentsProvider.Source
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.
CsvParserFactory
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.
CustomClassLoaderCloseStrategy	Defines the strategy for closing custom class loaders created for test discovery and execution.
CustomContextClassLoaderExecutor
DeclaredMethodSelector	Jupiter-specific selector for methods, potentially in nested classes.
DefaultArgumentConverter	DefaultArgumentConverter is the default implementation of the ArgumentConverter API.
DefaultArgumentConverter.LocaleConversionFormat
DefaultArgumentsAccessor	Default implementation of the ArgumentsAccessor API.
DefaultClassDescriptor	Default implementation of ClassDescriptor, backed by a ClassBasedTestDescriptor.
DefaultClassOrdererContext	Default implementation of ClassOrdererContext.
DefaultDiscoveryIssue
DefaultDiscoveryIssue.Builder
DefaultDiscoveryRequest	DefaultDiscoveryRequest is the default implementation of the EngineDiscoveryRequest and LauncherDiscoveryRequest APIs.
DefaultDynamicTestInvocationContext	Default implementation of the DynamicTestInvocationContext API.
DefaultExecutableInvoker
DefaultJupiterConfiguration	Default implementation of the JupiterConfiguration API.
DefaultLauncher	Default implementation of the Launcher API.
DefaultLauncherConfig	Default implementation of the LauncherConfig API.
DefaultLauncherSession
DefaultLauncherSession.ClosedLauncher
DefaultMethodDescriptor	Default implementation of MethodDescriptor, backed by a MethodBasedTestDescriptor.
DefaultMethodOrdererContext	Default implementation of MethodOrdererContext.
DefaultParallelExecutionConfiguration
DefaultParallelExecutionConfigurationStrategy	Default implementations of configuration strategies for parallel test execution.
DefaultParameterContext
DefaultParameterInfo
DefaultPreInterruptContext
DefaultRepetitionInfo	Default implementation of RepetitionInfo.
DefaultTestInstanceFactoryContext	Default implementation of the TestInstanceFactoryContext API.
DefaultTestInstances
DefaultTestReporter
DefaultUriSource	Default implementation of UriSource.
DefensiveAllDefaultPossibilitiesBuilder	Customization of AllDefaultPossibilitiesBuilder from JUnit 4 to ignore certain classes that would otherwise be reported as errors or cause infinite recursion.
DefensiveAllDefaultPossibilitiesBuilder.DefensiveAnnotatedBuilder	Customization of AnnotatedBuilder that ignores classes annotated with @RunWith(JUnitPlatform.class) to avoid infinite recursion.
DefensiveAllDefaultPossibilitiesBuilder.DefensiveJUnit4Builder	Customization of JUnit4Builder that ignores classes that do not contain any test methods in order not to report errors for them.
DefensiveAllDefaultPossibilitiesBuilder.NullIgnoredBuilder	Customization of IgnoredBuilder that always returns null.
DelegatingEngineExecutionListener
DelegatingLauncher
DelegatingLauncherDiscoveryRequest
DequeStack<T>
DescriptionUtils
Details
DetailsPrintingListener
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.
DisabledCondition	ExecutionCondition that supports the @Disabled annotation.
DisableParentConfigurationParameters	Disable parent configuration parameters.
DiscoverTestsCommand
DiscoveryFilter<T>	A DiscoveryFilter is applied during test discovery to determine if a given container or test should be included in the test plan.
DiscoveryIssue	DiscoveryIssue represents an issue that was encountered during test discovery by a TestEngine.
DiscoveryIssue.Builder	Builder for creating a DiscoveryIssue.
DiscoveryIssue.Severity	The severity of a DiscoveryIssue.
DiscoveryIssueCollector
DiscoveryIssueException	DiscoveryIssueException is an exception that is thrown if an engine reports critical issues during test discovery.
DiscoveryIssueNotifier
DiscoveryIssueReporter	DiscoveryIssueReporter defines the API for reporting DiscoveryIssues.
DiscoveryIssueReporter.Condition<T>	A Condition is a union of Predicate and Consumer.
DiscoveryRequestCreator
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.
DiscoverySelectorIdentifierParsers	Utility class for parsing DiscoverySelectorIdentifiers.
DiscoverySelectorIdentifierParsers.Singleton
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.
DisplayNameUtils	Collection of utilities for working with display names.
DynamicContainerTestDescriptor	TestDescriptor for a DynamicContainer.
DynamicDescendantFilter	Filter for dynamic descendants of TestDescriptors that implement Filterable.
DynamicDescendantFilter.Mode
DynamicExtensionContext
DynamicNodeTestDescriptor	Base TestDescriptor for a DynamicNode.
DynamicTestTestDescriptor	TestDescriptor for a DynamicTest.
EmptyArgumentsProvider
EmptySource	@EmptySource is an ArgumentsSource which provides a single empty argument to the annotated @ParameterizedClass or @ParameterizedTest.
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 defines the API which enables a TestEngine to publish information about events that occur during test discovery.
EngineDiscoveryOrchestrator	Orchestrates test discovery using the configured test engines.
EngineDiscoveryRequest	EngineDiscoveryRequest provides a TestEngine access to the information necessary to discover tests and containers.
EngineDiscoveryRequestResolution
EngineDiscoveryRequestResolver<T extends TestDescriptor>	Configurable test discovery implementation based on SelectorResolver and TestDescriptor.Visitor that can be reused by different TestEngines.
EngineDiscoveryRequestResolver.Builder<T extends TestDescriptor>	Builder for EngineDiscoveryRequestResolver.
EngineDiscoveryRequestResolver.DefaultInitializationContext<T extends TestDescriptor>
EngineDiscoveryRequestResolver.InitializationContext<T extends TestDescriptor>	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.
EngineDiscoveryResults	EngineDiscoveryResults represents the results of test discovery by a TestEngine on the JUnit Platform and provides access to the TestDescriptor of the engine and any DiscoveryIssues that were encountered.
EngineDiscoveryResultValidator	Perform common validation checks on the result from the `discover()` method.
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.
EngineFilter.Type
EngineFilterer
EngineIdValidator
EngineTestKit	EngineTestKit provides support for discovering and executing tests for a given TestEngine and provides convenient access to the results.
EngineTestKit.Builder	TestEngine execution builder.
EngineTestKit.Builder.DisabledOutputDirectoryCreator
EnumArgumentsProvider
EnumConfigurationParameterConverter<E extends java.lang.Enum<E>>
EnumSource	@EnumSource is a repeatable ArgumentsSource for constants of an Enum.
EnumSource.Mode	Enumeration of modes for selecting enum constants by name.
EnumSource.Mode.Validator
EnumSources	@EnumSources is a simple container for one or more EnumSource annotations.
EvaluatedArgumentSet	Encapsulates the evaluation of an Arguments instance (so it happens only once) and access to the resulting argument values.
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.
EventType
ExcludeClassNameFilter	ClassNameFilter that matches fully qualified class names against patterns in the form of regular expressions.
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.
ExcludeMethodFilter	MethodFilter that matches fully qualified method names against patterns in the form of regular expressions.
ExcludePackageNameFilter	PackageNameFilter that matches fully qualified package names that are not prefixed by one of the package names provided to the filter.
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.
ExclusiveResourceCollector
ExclusiveResourceCollector.DefaultExclusiveResourceCollector
ExecuteTestsCommand
ExecuteTestsCommand.ReportingOptions
Execution	Execution encapsulates metadata for the execution of a single TestDescriptor.
ExecutionListenerAdapter	An ExecutionListenerAdapter adapts a TestPlan and a corresponding TestExecutionListener to the EngineExecutionListener API.
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.
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.
ExtensionUtils	Collection of utilities for working with extensions and the extension registry.
ExternalResourceAdapter
ExternalResourceSupport	This Extension provides native support for subclasses of the ExternalResource rule from JUnit 4.
FieldArgumentsProvider	ArgumentsProvider for @FieldSource.
FieldContext	FieldContext encapsulates the context in which an @Parameter-annotated Field is declared in a @ParameterizedClass.
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.
FileEntry	FileEntry encapsulates a file or directory to be published to the reporting infrastructure.
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.
FilterableIgnoringRunnerDecorator	Filterable IgnoringRunnerDecorator.
FilterResult	The result of applying a Filter.
FlatPrintingListener
ForkJoinPoolHierarchicalTestExecutorService	A ForkJoinPool-based executor service that executes test tasks with the configured parallelism.
ForkJoinPoolHierarchicalTestExecutorService.TaskEventListener
ForkJoinPoolHierarchicalTestExecutorService.ThreadLock
ForkJoinPoolHierarchicalTestExecutorService.ThreadLock.NestedResourceLock
ForkJoinPoolHierarchicalTestExecutorService.WorkerThread
ForkJoinPoolHierarchicalTestExecutorService.WorkerThreadFactory
GenericBeforeAndAfterAdvice
HierarchicalOutputDirectoryCreator	Hierarchical OutputDirectoryCreator that creates directories based on the unique ID segments of a TestDescriptor.
HierarchicalTestEngine<C extends EngineExecutionContext>	Abstract base class for all TestEngine implementations that wish to organize test suites hierarchically based on the Node abstraction.
HierarchicalTestExecutor<C extends EngineExecutionContext>	Implementation core of all TestEngines that wish to use the Node abstraction as the driving principle for structuring and executing test suites.
HierarchicalTestExecutorService	A closeable service that executes test tasks.
HierarchicalTestExecutorService.TestTask	An executable task that represents a single test or container.
IgnoreCondition	ExecutionCondition that supports JUnit 4's @Ignore annotation.
IgnoringRunnerDecorator	Decorator for Runners that will be ignored completely.
IncludeClassNameFilter	ClassNameFilter that matches fully qualified class names against patterns in the form of regular expressions.
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.
IncludeMethodFilter	MethodFilter that matches fully qualified method names against patterns in the form of regular expressions.
IncludePackageNameFilter	PackageNameFilter that matches fully qualified package names that are prefixed by one of the package names provided to the filter.
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.
InstancePostProcessingClassTemplateFieldInjector
InstantiatingConfigurationParameterConverter<T>
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 extends java.lang.reflect.Executable,T>
InterceptingExecutableInvoker.ReflectiveInterceptorCall.VoidMethodInterceptorCall
InterceptingLauncher
InternalTestPlan
InvocationInterceptorChain
InvocationInterceptorChain.InterceptedInvocation<T>
InvocationInterceptorChain.InterceptorCall<T>
InvocationInterceptorChain.ValidatingInvocation<T>
InvocationInterceptorChain.VoidInterceptorCall
IsPotentialJUnit4TestClass
IsPotentialJUnit4TestMethod
IsTestableMethod
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.
IterationOrder
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.
JavaTimeArgumentConverter
JavaTimeConversionPattern	@JavaTimeConversionPattern is an annotation that allows a date/time conversion pattern to be specified on a parameter of a @ParameterizedClass or @ParameterizedTest.
JUnit4VersionCheck
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
JUnitPlatformRunnerListener
JUnitPlatformTestTree
JupiterConfiguration
JupiterEngineDescriptor
JupiterEngineExecutionContext
JupiterEngineExecutionContext.Builder
JupiterEngineExecutionContext.State
JupiterEngineExtensionContext
JupiterTestDescriptor
JupiterTestDescriptor.ExceptionHandlerInvoker<E extends org.junit.jupiter.api.extension.Extension>
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.
LauncherConfigurationParameters
LauncherConfigurationParameters.Builder
LauncherConfigurationParameters.ParameterProvider
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.
LauncherDiscoveryListeners.LauncherDiscoveryListenerType
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.
LauncherDiscoveryResult.EngineResultInfo
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.
LauncherListenerRegistry
LauncherPhase	The phase the Launcher is in.
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.
LauncherStoreFacade
LegacyReportingUtils	Deprecated. Use org.junit.platform.reporting.legacy.LegacyReportingUtils instead.
LifecycleMethodUtils	Collection of utilities for working with test lifecycle methods.
ListenerRegistry<T>
ListTestEnginesCommand
LockManager
LoggingLauncherDiscoveryListener
LoggingListener	Simple TestExecutionListener for logging informational messages for all events via a BiConsumer that consumes Throwable and Supplier<String>.
MainCommand
ManifestVersionProvider
MethodArgumentsProvider
MethodBasedTestDescriptor	Base class for TestDescriptors based on Java methods.
MethodBasedTestDescriptor.MethodInfo
MethodExtensionContext
MethodFilter	PostDiscoveryFilter that is applied to the fully qualified Method name without parameters.
MethodInvocation<T>
MethodOrderingVisitor
MethodSegmentResolver
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.
MethodSelectorResolver
MethodSelectorResolver
MethodSelectorResolver.MethodType
MethodSelectorResolver.MethodType.TestDescriptorFactory
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.
MethodSourceSupport	Jupiter internal support for creating MethodSource from URI.
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.
MutableExtensionRegistry	Default, mutable implementation of ExtensionRegistry.
MutableExtensionRegistry.Entry
MutableExtensionRegistry.LateInitEntry
MutableExtensionRegistry.LateInitExtensions
MutableTestExecutionSummary	Mutable, internal implementation of the TestExecutionSummary API.
MutableTestExecutionSummary.DefaultFailure
Namespace	A Namespace is used to provide a scope for data saved by extensions within a NamespacedHierarchicalStore.
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.
NamespacedHierarchicalStore.CompositeKey<N>
NamespacedHierarchicalStore.EvaluatedValue<N>
NamespacedHierarchicalStore.MemoizingSupplier	Thread-safe Supplier that memoizes the result of calling its delegate and ensures it is called at most once.
NamespacedHierarchicalStore.MemoizingSupplier.Failure
NamespacedHierarchicalStore.StoredValue
NamespacedHierarchicalStoreException	Exception thrown by failed NamespacedHierarchicalStore operations.
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 class 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 extends EngineExecutionContext>	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 extends EngineExecutionContext>	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.
NodeExecutionAdvisor
NodeTestTask<C extends EngineExecutionContext>
NodeTestTask.DynamicTaskState
NodeTestTaskContext
NodeTreeWalker
NodeUtils
NopLock	No-op ResourceLock implementation.
NullAndEmptySource	@NullAndEmptySource is a composed annotation that combines the functionality of @NullSource and @EmptySource.
NullArgumentsProvider
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 @ParameterizedClass or @ParameterizedTest.
OpenTest4JAndJUnit4AwareThrowableCollector	Specialization of ThrowableCollector that treats instances of the OTA's TestAbortedException and JUnit 4's org.junit.AssumptionViolatedException as aborting.
OpenTest4JAwareThrowableCollector	Specialization of ThrowableCollector that treats instances of TestAbortedException as aborting.
Operator
Operator.Associativity
Operator.TagExpressionCreator
Operators
OrFilter
OutcomeDelayingEngineExecutionListener	Delays reporting of engine skipped/finished events so that exceptions thrown by engines can be reported to listeners.
OutcomeDelayingEngineExecutionListener.Outcome
OutputDir
OutputDirectoryCreator	Provider of output directories for test engines to write reports and other output files to.
OutputDirectoryProvider	Deprecated. Please implement OutputDirectoryCreator instead
OutputDirectoryProviderAdapter
OutputStreamConfig
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.
ParallelExecutionConfiguration	Configuration to use for parallel test execution.
ParallelExecutionConfigurationStrategy	A strategy to use for configuring parallel test execution.
Parameter	@Parameter is used to signal that a field in a @ParameterizedClass constitutes a parameter and marks it for field injection.
ParameterDeclaration	ParameterDeclaration encapsulates the declaration of an indexed @ParameterizedClass or @ParameterizedTest parameter.
ParameterDeclarations	ParameterDeclarations encapsulates the combined declarations of all indexed @ParameterizedClass or @ParameterizedTest parameters.
ParameterInfo	ParameterInfo is used to provide information about the current invocation of a parameterized class or test.
ParameterInfo	Deprecated. Please use ParameterInfo instead
ParameterizedClass	@ParameterizedClass is used to signal that the annotated class is a parameterized test class.
ParameterizedClassContext
ParameterizedClassContext.InjectionType
ParameterizedClassExtension
ParameterizedClassInvocationContext
ParameterizedDeclarationContext<C>
ParameterizedInvocationConstants	Constants for the use with the @ParameterizedClass and @ParameterizedTest annotations.
ParameterizedInvocationContext<T extends ParameterizedDeclarationContext<?>>
ParameterizedInvocationContext.CloseableArgument
ParameterizedInvocationContextProvider<T>
ParameterizedInvocationNameFormatter
ParameterizedInvocationNameFormatter.ArgumentsContext
ParameterizedInvocationNameFormatter.ArgumentSetNameFormatter
ParameterizedInvocationNameFormatter.CachingByArgumentsLengthPartialFormatter
ParameterizedInvocationNameFormatter.MessageFormatPartialFormatter
ParameterizedInvocationNameFormatter.PartialFormatter
ParameterizedInvocationNameFormatter.PartialFormatters
ParameterizedInvocationNameFormatter.PlaceholderPosition
ParameterizedInvocationParameterResolver
ParameterizedTest	@ParameterizedTest is used to signal that the annotated method is a parameterized test method.
ParameterizedTestContext	Encapsulates access to the parameters of a parameterized test method and caches the converters and aggregators used to resolve them.
ParameterizedTestExtension
ParameterizedTestInvocationContext
ParameterizedTestMethodParameterResolver
ParameterizedTestSpiInstantiator
ParameterResolutionUtils	ParameterResolutionUtils provides support for dynamic resolution of executable parameters via ParameterResolvers.
Parser
ParseResult	The result of attempting to parse a TagExpression.
ParseResults
ParseStatus
PostDiscoveryFilter	A PostDiscoveryFilter is applied to TestDescriptors after test discovery.
PrefixedConfigurationParameters	View of ConfigurationParameters that applies a supplied prefix to all queries.
PreInterruptCallbackInvocation
PreInterruptCallbackInvocationFactory
PreInterruptThreadDumpPrinter	The default implementation for PreInterruptCallback, which will print the stacks of all Threads to System.out.
RepeatedTestDisplayNameFormatter	Display name formatter for a @RepeatedTest.
RepeatedTestExtension	TestTemplateInvocationContextProvider that supports the @RepeatedTest annotation.
RepeatedTestInvocationContext	TestTemplateInvocationContext for a @RepeatedTest.
RepetitionExtension	RepetitionExtension implements the following extension APIs to support repetitions of a @RepeatedTest method.
ReportEntry	ReportEntry encapsulates a time-stamped map of String-based key-value pairs to be published to the reporting infrastructure.
ResolutionCache
ResolutionCache.Concurrent
ResolverFacade
ResolverFacade.Aggregator
ResolverFacade.Converter
ResolverFacade.DefaultArgumentSetLifecycleMethodParameterResolver
ResolverFacade.DefaultParameterDeclarations
ResolverFacade.ExecutableParameterDeclaration
ResolverFacade.FieldParameterDeclaration
ResolverFacade.RequiredParameterCount
ResolverFacade.ResolvableParameterDeclaration
ResolverFacade.Resolver
ResourceContainerSelectorResolver
ResourceLock	A lock for a one or more resources.
ResourceLockAware
ResourceUtils	Resource-related utilities to be used in conjunction with ReflectionSupport.
RunListenerAdapter
RunnerDecorator
RunnerExecutor
RunnerRequest
RunnerTestDescriptor
RunnerTestDescriptor.ExcludeDescriptionFilter
RunnerTestDescriptorPostProcessor
SameThreadHierarchicalTestExecutorService	A simple executor service that executes all test tasks in the caller's thread.
SameThreadTimeoutInvocation<T>
SameThreadTimeoutInvocation.InterruptTask
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.
SelectorConverter
SelectorConverter.Class
SelectorConverter.ClasspathResource
SelectorConverter.Directory
SelectorConverter.File
SelectorConverter.Identifier
SelectorConverter.Iteration
SelectorConverter.Method
SelectorConverter.Module
SelectorConverter.Package
SelectorConverter.UniqueId
SelectorConverter.Uri
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.Match.Type
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.
SeparateThreadTimeoutInvocation<T>
ServiceLoaderRegistry
ServiceLoaderTestEngineRegistry
SessionPerRequestLauncher
ShuntingYard	This is based on a modified version of the Shunting-yard algorithm.
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.
SimpleArgumentsAggregator	SimpleArgumentsAggregator is an abstract base class for ArgumentsAggregator implementations that do not need to distinguish between fields and method/constructor parameters.
SingleLock
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.
Stack<T>
StackTracePruningEngineExecutionListener	Prunes the stack trace in case of a failed event.
StandardStreamsHandler
StreamInterceptingTestExecutionListener
StreamInterceptor
StreamInterceptor.RewindableByteArrayOutputStream
Style
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.
SummaryGeneratingListener	Simple TestExecutionListener that generates a summary of the test execution.
TagExpression	A tag expression can be evaluated against a collection of tags to determine if they match the expression.
TagExpressions
TagFilter	Factory methods for creating PostDiscoveryFilters based on included and excluded tags or tag expressions.
TempDirectory	TempDirectory is a JUnit Jupiter extension that creates and cleans up temporary directories if a field in a test class or a parameter in a test class constructor, lifecycle method, or test method is annotated with @TempDir.
TempDirectory.CloseablePath
TempDirectory.FailureTracker
TempDirectory.FieldContext
TempDirectory.FileOperations
TempDirectory.Scope
TemplateExecutor<P extends org.junit.jupiter.api.extension.Extension,C>
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.
TestClassAware
TestClassPredicates	Predicates for determining whether a class is a JUnit Jupiter test class.
TestClassPredicates.NestedClassInvalidityReason
TestConsoleOutputOptions
TestConsoleOutputOptionsMixin
TestConsoleOutputOptionsMixin.ConsoleOutputOptions
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
TestDiscoveryOptionsMixin
TestDiscoveryOptionsMixin.FilterOptions
TestDiscoveryOptionsMixin.RuntimeConfigurationOptions
TestDiscoveryOptionsMixin.SelectorOptions
TestEngine	A TestEngine facilitates discovery and execution of tests for a particular programming model.
TestEngineFormatter
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.
TestFactoryTestDescriptor	TestDescriptor for @TestFactory methods.
TestFeedPrintingListener
TestIdentifier	Immutable data transfer object that represents a test or container which is usually part of a TestPlan.
TestIdentifier.SerializedForm	Represents the serialized output of TestIdentifier.
TestInfoParameterResolver	ParameterResolver that resolves the TestInfo for the currently executing test.
TestInfoParameterResolver.DefaultTestInfo
TestInstanceLifecycleUtils	Collection of utilities for retrieving the test instance lifecycle mode.
TestInstancesProvider
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.
TestReporterParameterResolver	ParameterResolver that injects a TestReporter.
TestRuleAnnotatedField
TestRuleAnnotatedMember
TestRuleAnnotatedMethod
TestRuleSupport
TestRuleSupport.AdviceInvoker
TestRun
TestRun.VintageDescriptors
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.
TestTemplateExtensionContext
TestTemplateInvocationTestDescriptor	TestDescriptor for a @TestTemplate invocation.
TestTemplateTestDescriptor	TestDescriptor for @TestTemplate methods.
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.
TimeoutConfiguration
TimeoutDuration
TimeoutDurationParser
TimeoutExceptionFactory
TimeoutExtension
TimeoutExtension.TimeoutProvider
TimeoutInvocationFactory
TimeoutInvocationFactory.ExecutorResource
TimeoutInvocationFactory.SingleThreadExecutorResource
TimeoutInvocationFactory.TimeoutInvocationParameters<T>
Token
Tokenizer
TokenWith<T>
TreeNode
TreePrinter
TreePrintingListener
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.
UniqueIdFilter
UniqueIdFormat	Used to UniqueIdFormat.parse(java.lang.String) a UniqueId from a string representation or to UniqueIdFormat.format(org.junit.platform.engine.UniqueId) a UniqueId into a string representation.
UniqueIdPrefixTransformer
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.
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
Validatable	Interface for descriptors that can be validated during discovery.
ValueArgumentsProvider
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.
VerboseTreePrintingListener
VerifierAdapter
VerifierSupport	This Extension provides native support for subclasses of the Verifier rule from JUnit 4.
VintageDiscoverer
VintageEngineDescriptor
VintageExecutor
VintageTestDescriptor
VintageTestEngine	The JUnit Vintage TestEngine.