All Classes Interface Summary Class Summary Enum Summary Exception Summary Annotation Types Summary
| Class |
Description |
| AbstractAnnotatedDescriptorWrapper<E extends java.lang.reflect.AnnotatedElement> |
Abstract base class for wrappers for test descriptors based on annotated
elements.
|
| AbstractExtensionContext<T extends org.junit.platform.engine.TestDescriptor> |
|
| AbstractOrderingVisitor |
Abstract base class for visitors that
order children nodes.
|
| AbstractOrderingVisitor.DescriptorWrapperOrderer<ORDERER,WRAPPER> |
|
| AbstractOrderingVisitor.MessageGenerator |
|
| AbstractParameterizedClassInvocationLifecycleMethodInvoker |
|
| 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 |
|
| 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 |
|
| ArgumentCountValidator |
|
| Arguments |
Arguments is an abstraction that provides access to an array of
objects to be used for invoking a @ParameterizedTest method.
|
| Arguments.ArgumentSet |
|
| ArgumentsAccessor |
|
| 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 |
|
| 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 |
|
| CallbackSupport |
|
| CallbackSupport.CallbackInvoker<T extends org.junit.jupiter.api.extension.Extension> |
|
| ClassBasedTestDescriptor |
TestDescriptor for tests based on Java classes.
|
| ClassBasedTestDescriptor.ClassInfo |
|
| ClassBasedTestDescriptor.LifecycleMethods |
|
| ClassExtensionContext |
|
| ClassOrderingVisitor |
|
| ClasspathEntriesConverter |
|
| ClassSelectorResolver |
|
| ClassSelectorResolver |
|
| ClassSelectorResolver |
|
| ClassSelectorResolver.DummyClassTemplateInvocationContext |
|
| 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> |
|
| 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 |
|
| 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 |
|
| 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 |
|
| Constants |
|
| 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 |
|
| 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 |
|
| 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.LocaleConversionFormat |
|
| DefaultArgumentsAccessor |
|
| DefaultClassDescriptor |
|
| DefaultClassOrdererContext |
Default implementation of ClassOrdererContext.
|
| DefaultDynamicTestInvocationContext |
Default implementation of the DynamicTestInvocationContext API.
|
| DefaultExecutableInvoker |
|
| DefaultJupiterConfiguration |
|
| DefaultMethodDescriptor |
|
| DefaultMethodOrdererContext |
Default implementation of MethodOrdererContext.
|
| DefaultParameterContext |
|
| DefaultParameterInfo |
|
| DefaultPreInterruptContext |
|
| DefaultRepetitionInfo |
Default implementation of RepetitionInfo.
|
| DefaultTestInstanceFactoryContext |
Default implementation of the TestInstanceFactoryContext API.
|
| DefaultTestInstances |
|
| DefaultTestReporter |
|
| 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.
|
| DescriptionUtils |
|
| Details |
|
| DetailsPrintingListener |
|
| DisabledCondition |
ExecutionCondition that supports the @Disabled annotation.
|
| DisableParentConfigurationParameters |
Disable parent configuration parameters.
|
| DiscoverTestsCommand |
|
| DiscoveryRequestCreator |
|
| DiscoverySelectorResolver |
DiscoverySelectorResolver resolves TestDescriptors
for containers and tests selected by DiscoverySelectors, with the help of an EngineDiscoveryRequestResolver.
|
| DiscoverySelectorResolver |
|
| 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.
|
| 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.
|
| EngineExecutionResults |
EngineExecutionResults provides a fluent API for processing the
results of executing a test plan on the JUnit Platform for a given
TestEngine.
|
| 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.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 |
|
| 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 |
|
| ExclusiveResourceCollector |
|
| ExclusiveResourceCollector.DefaultExclusiveResourceCollector |
|
| ExecuteTestsCommand |
|
| ExecuteTestsCommand.ReportingOptions |
|
| Execution |
Execution encapsulates metadata for the execution of a single
TestDescriptor.
|
| 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. |
| 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 |
|
| FieldContext |
|
| 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. |
| Filterable |
Filterable is implemented by
TestDescriptors that may
register dynamic tests during execution and support selective test execution.
|
| FilterableIgnoringRunnerDecorator |
|
| FlatPrintingListener |
|
| GenericBeforeAndAfterAdvice |
|
| IgnoreCondition |
ExecutionCondition that supports JUnit 4's @Ignore
annotation.
|
| IgnoringRunnerDecorator |
Decorator for Runners that will be ignored completely.
|
| 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 |
|
| 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 |
|
| InvocationInterceptorChain |
|
| InvocationInterceptorChain.InterceptedInvocation<T> |
|
| InvocationInterceptorChain.InterceptorCall<T> |
|
| InvocationInterceptorChain.ValidatingInvocation<T> |
|
| InvocationInterceptorChain.VoidInterceptorCall |
|
| IsPotentialJUnit4TestClass |
|
| IsPotentialJUnit4TestMethod |
|
| IsSuiteClass |
|
| 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.
|
| JavaTimeArgumentConverter |
|
| JavaTimeConversionPattern |
|
| JUnit4VersionCheck |
|
| JUnitPlatform |
Deprecated.
|
| 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.
|
| LauncherStoreFacade |
|
| LifecycleMethodUtils |
Collection of utilities for working with test lifecycle methods.
|
| LifecycleMethodUtils |
Collection of utilities for working with test lifecycle methods.
|
| ListTestEnginesCommand |
|
| MainCommand |
|
| ManifestVersionProvider |
|
| MethodArgumentsProvider |
|
| MethodBasedTestDescriptor |
Base class for TestDescriptors based on Java methods.
|
| MethodBasedTestDescriptor.MethodInfo |
|
| MethodExtensionContext |
|
| MethodInvocation<T> |
|
| MethodOrderingVisitor |
|
| MethodSegmentResolver |
|
| 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. |
| MethodSources |
@MethodSources is a simple container for one or more
MethodSource annotations. |
| MethodSourceSupport |
Jupiter internal support for creating MethodSource from URI.
|
| MutableExtensionRegistry |
|
| MutableExtensionRegistry.Entry |
|
| MutableExtensionRegistry.LateInitEntry |
|
| MutableExtensionRegistry.LateInitExtensions |
|
| NamespaceAwareStore |
|
| NestedClassTestDescriptor |
TestDescriptor for tests based on nested (but not static) Java classes.
|
| NoTestsDiscoveredException |
|
| NullAndEmptySource |
|
| 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.
|
| OrFilter |
|
| OutputStreamConfig |
|
| 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.
|
| ParameterizedClass |
@ParameterizedClass is used to signal that the annotated class is
a parameterized test class.
|
| ParameterizedClassContext |
|
| ParameterizedClassContext.InjectionType |
|
| ParameterizedClassExtension |
|
| ParameterizedClassInvocationContext |
|
| ParameterizedDeclarationContext<C> |
|
| ParameterizedInvocationConstants |
|
| 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.
|
| 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.
|
| ResolutionCache |
|
| ResolutionCache.Concurrent |
|
| ResolverFacade |
|
| ResolverFacade.Aggregator |
|
| ResolverFacade.Converter |
|
| ResolverFacade.DefaultArgumentSetLifecycleMethodParameterResolver |
|
| ResolverFacade.DefaultParameterDeclarations |
|
| ResolverFacade.ExecutableParameterDeclaration |
|
| ResolverFacade.FieldParameterDeclaration |
|
| ResolverFacade.RequiredParameterCount |
|
| ResolverFacade.ResolvableParameterDeclaration |
|
| ResolverFacade.Resolver |
|
| ResourceLockAware |
|
| RunListenerAdapter |
|
| RunnerDecorator |
|
| RunnerExecutor |
|
| RunnerRequest |
|
| RunnerTestDescriptor |
|
| RunnerTestDescriptor.ExcludeDescriptionFilter |
|
| RunnerTestDescriptorPostProcessor |
|
| 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 |
|
| 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 |
|
| 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> |
|
| 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. |
| StandardStreamsHandler |
|
| 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. |
| SuiteEngineDescriptor |
|
| SuiteLauncher |
|
| SuiteLauncherDiscoveryRequestBuilder |
The SuiteLauncherDiscoveryRequestBuilder provides a light-weight DSL
for generating a LauncherDiscoveryRequest specifically tailored for
suite execution.
|
| SuiteTestDescriptor |
TestDescriptor for tests based on the JUnit Platform Suite API.
|
| SuiteTestDescriptor.DiscoveryIssueForwardingListener |
|
| SuiteTestDescriptor.LifecycleMethods |
|
| SuiteTestEngine |
The JUnit Platform Suite TestEngine.
|
| 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 |
|
| TestDiscoveryOptions |
|
| TestDiscoveryOptionsMixin |
|
| TestDiscoveryOptionsMixin.FilterOptions |
|
| TestDiscoveryOptionsMixin.RuntimeConfigurationOptions |
|
| TestDiscoveryOptionsMixin.SelectorOptions |
|
| TestExecutionResultConditions |
Collection of AssertJ conditions for
TestExecutionResult.
|
| TestFactoryTestDescriptor |
TestDescriptor for
@TestFactory methods.
|
| TestFeedPrintingListener |
|
| 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.
|
| TestReporterParameterResolver |
ParameterResolver that injects a TestReporter.
|
| TestRuleAnnotatedField |
|
| TestRuleAnnotatedMember |
|
| TestRuleAnnotatedMethod |
|
| TestRuleSupport |
|
| TestRuleSupport.AdviceInvoker |
|
| TestRun |
|
| TestRun.VintageDescriptors |
|
| TestSourceProvider |
|
| TestTemplateExtensionContext |
|
| TestTemplateInvocationTestDescriptor |
TestDescriptor for a @TestTemplate
invocation.
|
| TestTemplateTestDescriptor |
TestDescriptor for @TestTemplate
methods.
|
| Theme |
|
| TimeoutConfiguration |
|
| TimeoutDuration |
|
| TimeoutDurationParser |
|
| TimeoutExceptionFactory |
|
| TimeoutExtension |
|
| TimeoutExtension.TimeoutProvider |
|
| TimeoutInvocationFactory |
|
| TimeoutInvocationFactory.ExecutorResource |
|
| TimeoutInvocationFactory.SingleThreadExecutorResource |
|
| TimeoutInvocationFactory.TimeoutInvocationParameters<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. |
| UniqueIdFilter |
|
| UniqueIdPrefixTransformer |
|
| UniqueIdReader |
|
| UniqueIdStringifier |
|
| UseTechnicalNames |
Deprecated.
|
| 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.
|