All Classes Interface Summary Class Summary Enum Summary Exception Summary Annotation Types Summary
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> |
|
AbstractOrderingVisitor<PARENT extends TestDescriptor,CHILD extends TestDescriptor,WRAPPER extends AbstractAnnotatedDescriptorWrapper<?>> |
Abstract base class for visitors that
order children nodes.
|
AbstractOrderingVisitor.MessageGenerator |
|
AbstractTestDescriptor |
|
AbstractTestRuleAdapter |
|
AbstractTestRuleAnnotatedMember |
|
AdditionalDiscoverySelectors |
|
AfterEachMethodAdapter |
Functional interface for registering an @AfterEach method
as a pseudo-extension.
|
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 |
|
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.
|
Arguments |
Arguments is an abstraction that provides access to an array of
objects to be used for invoking a @ParameterizedTest method.
|
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.
|
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 argument providers
for the annotated test method.
|
ArgumentsSources |
@ArgumentsSources is a simple container for one or more
ArgumentsSource annotations.
|
Assertions |
Assertions is a collection of selected assertion utility methods
from JUnit Jupiter for use within the JUnit Platform Test Kit.
|
Assertions.Executable |
|
BaseCommand<T> |
|
BeforeEachMethodAdapter |
Functional interface for registering a @BeforeEach method
as a pseudo-extension.
|
CachingJupiterConfiguration |
|
ClassBasedTestDescriptor |
|
ClassContainerSelectorResolver |
|
ClassExtensionContext |
|
ClassNameFilter |
|
ClassOrderingVisitor |
|
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.
|
ClasspathResourceSource |
|
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.
|
ClasspathScanningSupport |
Deprecated.
|
ClassSelector |
|
ClassSelectorResolver |
|
ClassSelectorResolver |
|
ClassSource |
|
ClassTestDescriptor |
|
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 |
|
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 |
|
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 |
|
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 |
|
CsvParserFactory |
|
CsvParsingException |
Thrown if an error is encountered while parsing CSV input.
|
CsvSource |
|
CustomContextClassLoaderExecutor |
|
DefaultArgumentConverter |
|
DefaultArgumentsAccessor |
|
DefaultClassDescriptor |
|
DefaultClassOrdererContext |
Default implementation of ClassOrdererContext .
|
DefaultDiscoveryRequest |
|
DefaultDynamicTestInvocationContext |
Default implementation of the DynamicTestInvocationContext API.
|
DefaultExecutableInvoker |
|
DefaultJupiterConfiguration |
|
DefaultLauncher |
Default implementation of the Launcher API.
|
DefaultLauncherConfig |
|
DefaultLauncherSession |
|
DefaultLauncherSession.ClosedLauncher |
|
DefaultMethodDescriptor |
|
DefaultMethodOrdererContext |
Default implementation of MethodOrdererContext .
|
DefaultParallelExecutionConfiguration |
|
DefaultParallelExecutionConfigurationStrategy |
Default implementations of configuration strategies for parallel test
execution.
|
DefaultParameterContext |
|
DefaultRepetitionInfo |
Default implementation of RepetitionInfo .
|
DefaultTestInstanceFactoryContext |
Default implementation of the TestInstanceFactoryContext API.
|
DefaultTestInstances |
|
DefaultUriSource |
|
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 |
|
DequeStack<T> |
|
DescriptionUtils |
|
Details |
|
DetailsPrintingListener |
|
DirectorySelector |
|
DirectorySource |
|
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.
|
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.
|
DiscoverySelectorResolver |
DiscoverySelectorResolver resolves TestDescriptors
for containers and tests selected by DiscoverySelectors with the help of the
JavaElementsResolver .
|
DiscoverySelectors |
|
DisplayNameUtils |
Collection of utilities for working with display names.
|
DynamicContainerTestDescriptor |
|
DynamicDescendantFilter |
|
DynamicDescendantFilter.Mode |
|
DynamicExtensionContext |
|
DynamicNodeTestDescriptor |
|
DynamicTestTestDescriptor |
|
EmptyArgumentsProvider |
|
EmptySource |
@EmptySource is an ArgumentsSource which provides a single
empty argument to the annotated @ParameterizedTest method.
|
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 |
|
EngineDiscoveryErrorDescriptor |
Represents an error thrown by a TestEngine
during discovery.
|
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.
|
EngineDiscoveryRequestResolution |
|
EngineDiscoveryRequestResolver<T extends TestDescriptor> |
|
EngineDiscoveryRequestResolver.Builder<T extends TestDescriptor> |
|
EngineDiscoveryRequestResolver.DefaultInitializationContext<T extends TestDescriptor> |
|
EngineDiscoveryRequestResolver.InitializationContext<T extends TestDescriptor> |
|
EngineDiscoveryResult |
EngineDiscoveryResult encapsulates the result of test discovery by a
TestEngine .
|
EngineDiscoveryResult.Status |
|
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 executing a test plan for a given
TestEngine and then accessing the results via
a fluent API to verify the expected results.
|
EngineTestKit.Builder |
|
EnumArgumentsProvider |
|
EnumConfigurationParameterConverter<E extends java.lang.Enum<E>> |
|
EnumSource |
|
EnumSource.Mode |
Enumeration of modes for selecting enum constants by name.
|
EnumSource.Mode.Validator |
|
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.
|
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 |
|
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.
|
ExecuteTestsCommand |
|
ExecuteTestsCommand.ReportingOptions |
|
Execution |
Execution encapsulates metadata for the execution of a single
TestDescriptor .
|
ExecutionListenerAdapter |
|
ExecutionRecorder |
|
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.
|
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.
|
FallbackStringToObjectConverter |
FallbackStringToObjectConverter is a StringToObjectConverter
that provides a fallback conversion strategy for converting from a
String to a given target type by invoking a static factory method
or factory constructor defined in the target type.
|
FallbackStringToObjectConverter.IsFactoryConstructor |
|
FallbackStringToObjectConverter.IsFactoryMethod |
|
FilePosition |
Position inside a file represented by line and
column numbers.
|
FilePosition |
Position inside a file represented by line and
column numbers.
|
FileSelector |
|
FileSource |
|
FileSystemSource |
|
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 |
|
FilterResult |
The result of applying a Filter .
|
FlatPrintingListener |
|
ForkJoinPoolHierarchicalTestExecutorService |
|
ForkJoinPoolHierarchicalTestExecutorService.ExclusiveTask |
|
ForkJoinPoolHierarchicalTestExecutorService.WorkerThread |
|
ForkJoinPoolHierarchicalTestExecutorService.WorkerThreadFactory |
|
GenericBeforeAndAfterAdvice |
|
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 |
|
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.
|
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 |
|
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 |
|
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.
|
IsPotentialJUnit4TestClass |
|
IsPotentialJUnit4TestMethod |
|
IsPotentialTestContainer |
Test if a class is a potential top-level JUnit Jupiter test container, even if
it does not contain tests.
|
IsTestableMethod |
|
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.
|
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.
|
JavaTimeArgumentConverter |
|
JavaTimeConversionPattern |
@JavaTimeConversionPattern is an annotation that allows a date/time
conversion pattern to be specified on a parameter of a
@ParameterizedTest method.
|
JUnit4VersionCheck |
|
JUnitFactory |
|
JUnitPlatform |
Deprecated.
|
JUnitPlatformRunnerListener |
|
JUnitPlatformTestTree |
|
JupiterConfiguration |
|
JupiterEngineDescriptor |
|
JupiterEngineExecutionContext |
|
JupiterEngineExecutionContext.Builder |
|
JupiterEngineExecutionContext.State |
|
JupiterEngineExtensionContext |
|
JupiterTestDescriptor |
|
JupiterTestDescriptor.ExceptionHandlerInvoker<E extends org.junit.jupiter.api.extension.Extension> |
|
JupiterTestEngine |
|
JupiterThrowableCollectorFactory |
|
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.Builder |
|
LauncherConfigurationParameters |
|
LauncherConfigurationParameters.Builder |
|
LauncherConfigurationParameters.ParameterProvider |
|
LauncherConstants |
Collection of constants related to Launcher .
|
LauncherDiscoveryListener |
|
LauncherDiscoveryListeners |
|
LauncherDiscoveryListeners.LauncherDiscoveryListenerType |
|
LauncherDiscoveryRequest |
|
LauncherDiscoveryRequestBuilder |
|
LauncherDiscoveryResult |
Represents the result of test discovery of the configured
test engines.
|
LauncherFactory |
|
LauncherInterceptor |
|
LauncherInterceptor.Invocation<T> |
An invocation that can be intercepted.
|
LauncherListenerRegistry |
|
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 |
|
LegacyReportingName |
|
LegacyReportingUtils |
Deprecated.
|
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 |
|
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 |
|
MethodArgumentsProvider |
|
MethodBasedTestDescriptor |
|
MethodExtensionContext |
|
MethodFinder |
|
MethodInvocation<T> |
|
MethodOrderingVisitor |
|
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.
|
MethodSelectorResolver |
|
MethodSelectorResolver |
|
MethodSelectorResolver.MethodType |
|
MethodSource |
@MethodSource is an 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 |
|
MethodSourceSupport |
Jupiter internal support for creating MethodSource from URI .
|
ModuleSelector |
|
MutableExtensionRegistry |
|
MutableTestExecutionSummary |
|
MutableTestExecutionSummary.DefaultFailure |
|
NamespaceAwareStore |
|
NamespacedHierarchicalStore<N> |
NamespacedHierarchicalStore is a hierarchical, namespaced key-value store.
|
NamespacedHierarchicalStore.CloseAction<N> |
|
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 |
|
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.
|
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.
|
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 |
|
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 @ParameterizedTest method.
|
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.
|
OpenTestReportGeneratingListener |
Open Test Reporting events XML generating test execution listener.
|
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 |
|
OutputOptionsMixin |
|
PackageNameFilter |
|
PackageSelector |
|
PackageSource |
|
ParallelExecutionConfiguration |
Configuration to use for parallel test execution.
|
ParallelExecutionConfigurationStrategy |
A strategy to use for configuring parallel test execution.
|
ParameterizedTest |
@ParameterizedTest is used to signal that the annotated method is a
parameterized test method.
|
ParameterizedTestExtension |
|
ParameterizedTestInvocationContext |
|
ParameterizedTestMethodContext |
Encapsulates access to the parameters of a parameterized test method and
caches the converters and aggregators used to resolve them.
|
ParameterizedTestMethodContext.Aggregator |
|
ParameterizedTestMethodContext.Converter |
|
ParameterizedTestMethodContext.Resolver |
|
ParameterizedTestMethodContext.ResolverType |
|
ParameterizedTestNameFormatter |
|
ParameterizedTestParameterResolver |
|
ParameterizedTestParameterResolver.CloseableArgument |
|
ParameterResolutionUtils |
ParameterResolutionUtils provides support for dynamic resolution
of executable parameters via ParameterResolvers .
|
Parser |
|
ParseResult |
|
ParseResults |
|
ParseStatus |
|
PostDiscoveryFilter |
|
PrefixedConfigurationParameters |
|
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.
|
ResourceLock |
A lock for a one or more resources.
|
ResourceUtils |
Collection of static utility methods for working with resources.
|
RunListenerAdapter |
|
RunnerDecorator |
|
RunnerExecutor |
|
RunnerRequest |
|
RunnerTestDescriptor |
|
RunnerTestDescriptor.ExcludeDescriptionFilter |
|
RunnerTestDescriptorPostProcessor |
|
SameThreadHierarchicalTestExecutorService |
|
SameThreadTimeoutInvocation<T> |
|
SameThreadTimeoutInvocation.InterruptTask |
|
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.Iteration |
|
SelectorConverter.Method |
|
SelectorConverter.Module |
|
SelectorConverter.Package |
|
SelectorConverter.Uri |
|
SelectorResolutionResult |
|
SelectorResolutionResult.Status |
|
SelectorResolver |
|
SelectorResolver.Context |
|
SelectorResolver.Match |
|
SelectorResolver.Match.Type |
|
SelectorResolver.Resolution |
|
SelectPackages |
@SelectPackages specifies the names of packages to select
when running a test suite on the JUnit Platform.
|
SelectUris |
@SelectUris specifies the URIs to select when running a test
suite on the JUnit Platform.
|
SeparateThreadTimeoutInvocation<T> |
|
ServiceLoaderRegistry |
|
ServiceLoaderTestEngineRegistry |
|
SessionPerRequestLauncher |
|
ShuntingYard |
|
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.
|
SingleLock |
|
SingleTestExecutor |
Deprecated.
|
SingleTestExecutor.Executable |
|
Stack<T> |
|
StackTracePruningEngineExecutionListener |
Prunes the stack trace in case of a failed event.
|
StreamInterceptingTestExecutionListener |
|
StreamInterceptor |
|
StreamInterceptor.RewindableByteArrayOutputStream |
|
StringToBooleanConverter |
|
StringToCharacterConverter |
|
StringToClassConverter |
|
StringToCommonJavaTypesConverter |
|
StringToEnumConverter |
|
StringToJavaTimeConverter |
|
StringToNumberConverter |
|
StringToObjectConverter |
Internal API for converting arguments of type String to a specified
target type.
|
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 |
|
SummaryGeneratingListener |
|
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 field in a test class or a parameter in a
lifecycle method or test method is annotated with @TempDir .
|
TempDirectory.CloseablePath |
|
TempDirectory.FieldContext |
|
TempDirectory.FileOperations |
|
TempDirectory.Scope |
|
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.
|
TestConsoleOutputOptions |
|
TestConsoleOutputOptionsMixin |
|
TestConsoleOutputOptionsMixin.ConsoleOutputOptions |
|
TestDescriptor |
Mutable descriptor for a test or container that has been discovered by a
TestEngine .
|
TestDescriptor.Type |
|
TestDescriptor.Visitor |
|
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 |
|
TestExecutionSummary |
Summary of test plan execution.
|
TestExecutionSummary.Failure |
Failure of a test or container.
|
TestFactoryTestDescriptor |
|
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 |
|
TestMethodTestDescriptor.CallbackInvoker<T extends org.junit.jupiter.api.extension.Extension> |
|
TestPlan |
TestPlan describes the tree of tests and containers as discovered
by a Launcher .
|
TestPlan.Visitor |
|
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 |
|
TestTemplateTestDescriptor |
|
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 |
|
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 |
|
UniqueId.Segment |
A segment of a UniqueId comprises a type and a
value.
|
UniqueIdFilter |
|
UniqueIdFormat |
|
UniqueIdReader |
|
UniqueIdSelector |
|
UniqueIdStringifier |
|
UniqueIdTrackingListener |
|
UriSelector |
|
UriSource |
|
UseTechnicalNames |
Deprecated.
|
ValueArgumentsProvider |
|
ValueSource |
@ValueSource is an ArgumentsSource which provides access to
an array of literal values.
|
VerboseTreePrintingListener |
|
VerifierAdapter |
|
VerifierSupport |
This Extension provides native support for subclasses of
the Verifier rule from JUnit 4.
|
VintageDiscoverer |
|
VintageEngineDescriptor |
|
VintageTestDescriptor |
|
VintageTestEngine |
|
XmlReportData |
|
XmlReportWriter |
XmlReportWriter writes an XML report whose format is compatible
with the de facto standard for JUnit 4 based test reports that was made
popular by the Ant build system.
|
XmlReportWriter.AggregatedTestResult |
|
XmlReportWriter.AggregatedTestResult.Type |
|