All Classes and Interfaces
Class
Description
Abstract base class for wrappers for test descriptors based on annotated
elements.
Abstract
ClassNameFilter
that servers as a superclass
for filters including or excluding fully qualified class names
based on pattern-matching.Abstract base class for visitors that
order children nodes.
Abstract base implementation of
TestDescriptor
that may be used by
custom TestEngines
.Functional interface for registering an
@AfterEach
method
as a pseudo-extension.@AggregateWith
is an annotation that allows one to specify an
ArgumentsAggregator
.AnnotationBasedArgumentConverter
is an abstract base class for
ArgumentConverter
implementations that also need to consume an
annotation in order to perform the conversion.AnnotationBasedArgumentsProvider
is an abstract base class for
ArgumentsProvider
implementations that also need to consume an
annotation in order to provide the arguments.AnnotationConsumer
is a functional
interface for consuming annotations.AnnotationConsumerInitializer
is an internal helper class for
initializing AnnotationConsumers
.ArgumentAccessException
is an exception thrown by an
ArgumentsAccessor
if an error occurs while accessing
or converting an argument.ArgumentConversionException
is an exception that can occur when an
object is converted to another object by an implementation of an
ArgumentConverter
.ArgumentConverter
is an abstraction that allows an input object to
be converted to an instance of a different class.Arguments
is an abstraction that provides access to an array of
objects to be used for invoking a @ParameterizedTest
method.ArgumentsAccessor
defines the public API for accessing arguments provided
by an ArgumentsProvider
for a single invocation of a
@ParameterizedTest
method.ArgumentsAggregationException
is an exception thrown by an
ArgumentsAggregator
when an error occurs while aggregating
arguments.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.An
ArgumentsProvider
is responsible for providing a stream of arguments to be passed to a @ParameterizedTest
method.@ArgumentsSource
is a repeatable annotation
that is used to register argument providers
for the annotated test method.@ArgumentsSources
is a simple container for one or more
ArgumentsSource
annotations.Assertions
is a collection of selected assertion utility methods
from JUnit Jupiter for use within the JUnit Platform Test Kit.Functional interface for registering a
@BeforeEach
method
as a pseudo-extension.Caching implementation of the
JupiterConfiguration
API.TestDescriptor
for tests based on Java classes.DiscoveryFilter
that is applied to the name of a Class
.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.Classpath resource based
TestSource
with an optional position.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.Deprecated.
A
DiscoverySelector
that selects a Class
or class name so
that TestEngines
can discover
tests or containers based on classes.Class based
TestSource
with
an optional file position.TestDescriptor
for tests based on Java classes.Internal facade to run a CLI command that exists to hide implementation
details such as the used library.
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.A
CompositeTestSource
contains one or more TestSources
.Thrown if an error is encountered while evaluating an
ExecutionCondition
.ConditionEvaluator
evaluates ExecutionCondition
extensions.@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.Configuration parameters that
TestEngines
may use to
influence test discovery and execution.@ConfigurationParameters
is a container for one or more
@ConfigurationParameter
declarations.The
ConsoleLauncher
is a stand-alone application for launching the
JUnit Platform from the console.Collection of utilities for working with
java.io.Console
and friends.Collection of constants related to the
JupiterTestEngine
.@ConvertWith
is an annotation that allows one to specify an explicit
ArgumentConverter
.@CsvFileSource
is an ArgumentsSource
which is used to load
comma-separated value (CSV) files from one or more classpath CsvFileSource.resources()
or CsvFileSource.files()
.Thrown if an error is encountered while parsing CSV input.
@CsvSource
is an ArgumentsSource
which reads comma-separated
values (CSV) from one or more CSV records supplied via the CsvSource.value()
attribute or CsvSource.textBlock()
attribute.DefaultArgumentConverter
is the default implementation of the
ArgumentConverter
API.Default implementation of the
ArgumentsAccessor
API.Default implementation of
ClassDescriptor
, backed by
a ClassBasedTestDescriptor
.Default implementation of
ClassOrdererContext
.DefaultDiscoveryRequest
is the default implementation of the
EngineDiscoveryRequest
and LauncherDiscoveryRequest
APIs.Default implementation of the
DynamicTestInvocationContext
API.Default implementation of the
JupiterConfiguration
API.Default implementation of the
Launcher
API.Default implementation of the
LauncherConfig
API.Default implementation of
MethodDescriptor
, backed by
a MethodBasedTestDescriptor
.Default implementation of
MethodOrdererContext
.Default implementations of configuration strategies for parallel test
execution.
Default implementation of
RepetitionInfo
.Default implementation of the
TestInstanceFactoryContext
API.Default implementation of
UriSource
.Customization of
AllDefaultPossibilitiesBuilder
from JUnit 4 to
ignore certain classes that would otherwise be reported as errors or cause
infinite recursion.Customization of
AnnotatedBuilder
that ignores classes annotated
with @RunWith(JUnitPlatform.class)
to avoid infinite recursion.Customization of
JUnit4Builder
that ignores classes that do not
contain any test methods in order not to report errors for them.Customization of
IgnoredBuilder
that always returns null
.A
DiscoverySelector
that selects a directory so that
TestEngines
can discover tests or containers based on directories in the
file system.Directory based
TestSource
.ExecutionCondition
that supports the @Disabled
annotation.Disable parent configuration parameters.
A
DiscoveryFilter
is applied during test discovery to determine if
a given container or test should be included in the test plan.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
resolves TestDescriptors
for containers and tests selected by DiscoverySelectors with the help of the
JavaElementsResolver
.Collection of
static
factory methods for creating
DiscoverySelectors
.Collection of utilities for working with display names.
TestDescriptor
for a DynamicContainer
.Filter for dynamic descendants of
TestDescriptors
that
implement Filterable
.Base
TestDescriptor
for a DynamicNode
.TestDescriptor
for a DynamicTest
.@EmptySource
is an ArgumentsSource
which provides a single
empty argument to the annotated @ParameterizedTest
method.EnableJUnit4MigrationSupport
is a class-level annotation that
enables all JUnit 4 migration support within JUnit Jupiter.This class-level annotation enables native JUnit 4 rule support
within JUnit Jupiter.
Represents an error thrown by a
TestEngine
during discovery.EngineDiscoveryListener
contains TestEngine
access to the
information necessary to discover tests and containers.Orchestrates test discovery using the configured test engines.
EngineDiscoveryRequest
provides a TestEngine
access to the
information necessary to discover tests and containers.Configurable test discovery implementation based on
SelectorResolver
and TestDescriptor.Visitor
that can be reused by different
TestEngines
.Builder for
EngineDiscoveryRequestResolver
.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
encapsulates the result of test discovery by a
TestEngine
.Status of test discovery by a
TestEngine
.Perform common validation checks on the result from the `discover()` method.
Marker interface for an execution context used by a concrete implementation
of
HierarchicalTestEngine
and its collaborators.Listener to be notified of test execution events by
test engines.
Orchestrates test execution using the configured test engines.
EngineExecutionResults
provides a fluent API for processing the
results of executing a test plan on the JUnit Platform for a given
TestEngine
.An
EngineFilter
is applied to all TestEngines
before they are used.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.TestEngine
execution builder.Enumeration of modes for selecting enum constants by name.
Event
represents a single event fired during execution of
a test plan on the JUnit Platform.Collection of AssertJ conditions for
Event
.Events
is a facade that provides a fluent API for working with
events.EventStatistics
provides a fluent API for asserting statistics
for events.Enumeration of the different possible
Event
types.ClassNameFilter
that matches fully qualified class names against
patterns in the form of regular expressions.@ExcludeClassNamePatterns
specifies regular expressions that are used
to match against fully qualified class names when running a test suite on the
JUnit Platform.@ExcludeEngines
specifies the IDs of
TestEngines
to be excluded
when running a test suite on the JUnit Platform.PackageNameFilter
that matches fully qualified package names that
are not prefixed by one of the package names provided to the filter.@ExcludePackages
specifies the packages to be
excluded when running a test suite on the JUnit Platform.@ExcludeTags
specifies the
tags or tag expressions to be excluded when running a
test suite on the JUnit Platform.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.
LockMode
translates to the respective ReadWriteLock
locks.Execution
encapsulates metadata for the execution of a single
TestDescriptor
.An
ExecutionListenerAdapter
adapts a TestPlan
and a corresponding
TestExecutionListener
to the EngineExecutionListener
API.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
.Provides a single
TestEngine
access to the information necessary to
execute its tests.Executions
is a facade that provides a fluent API for working with
executions.This
Extension
provides native support for the
ExpectedException
rule from JUnit 4.An
ExtensionRegistrar
is used to register extensions.An
ExtensionRegistry
holds all registered extensions (i.e.Collection of utilities for working with extensions and the extension registry.
This
Extension
provides native support for subclasses of
the ExternalResource
rule from JUnit 4.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.Predicate
that determines if the Constructor
supplied to
FallbackStringToObjectConverter.IsFactoryConstructor.test(Constructor)
is a non-private factory constructor for the
supplied FallbackStringToObjectConverter.IsFactoryConstructor.targetType
.Predicate
that determines if the Method
supplied to
FallbackStringToObjectConverter.IsFactoryMethod.test(Method)
is a non-private static factory method for the
supplied FallbackStringToObjectConverter.IsFactoryMethod.targetType
.A
DiscoverySelector
that selects a file so that
TestEngines
can discover tests or containers based on files in the
file system.File based
TestSource
with an optional
position.File system based
TestSource
.A
Filter
can be applied to determine if an object should be
included or excluded in a result set.Filterable
is implemented by
TestDescriptors
that may
register dynamic tests during execution and support selective test execution.Filterable
IgnoringRunnerDecorator
.The result of applying a
Filter
.Abstract base class for all
TestEngine
implementations that wish
to organize test suites hierarchically based on the Node
abstraction.Implementation core of all
TestEngines
that wish to
use the Node
abstraction as the driving principle for structuring
and executing test suites.A closeable service that executes test tasks.
An executable task that represents a single test or container.
ExecutionCondition
that supports JUnit 4's @Ignore
annotation.Decorator for Runners that will be ignored completely.
ClassNameFilter
that matches fully qualified class names against
patterns in the form of regular expressions.@IncludeClassNamePatterns
specifies regular expressions that are used
to match against fully qualified class names when running a test suite on the
JUnit Platform.@IncludeEngines
specifies the IDs of
TestEngines
to be included
when running a test suite on the JUnit Platform.PackageNameFilter
that matches fully qualified package names that
are prefixed by one of the package names provided to the filter.@IncludePackages
specifies the packages to be
included when running a test suite on the JUnit Platform.@IncludeTags
specifies the
tags or tag expressions to be included when running a
test suite on the JUnit Platform.InterceptingExecutableInvoker
encapsulates the invocation of a
Executable
(i.e., method or constructor),
including support for dynamic resolution of method parameters via
ParameterResolvers
.Test if a class is a non-private inner class (i.e., a non-static nested class).
Test if a class is a JUnit Jupiter
@Nested
test class.Test if a class is a potential top-level JUnit Jupiter test container, even if
it does not contain tests.
Test if a class is a JUnit Jupiter test class containing executable tests,
test factories, test templates, or nested tests.
Test if a method is a JUnit Jupiter
@TestFactory
method.Test if a method is a JUnit Jupiter
@Test
method.Test if a method is a JUnit Jupiter
@TestTemplate
method.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.@JavaTimeConversionPattern
is an annotation that allows a date/time
conversion pattern to be specified on a parameter of a
@ParameterizedTest
method.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.0The JUnit Jupiter
TestEngine
.Factory for creating
ThrowableCollectors
within
the JUnit Jupiter test engine.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
defines the configuration API for creating
Launcher
instances via the LauncherFactory
.Builder API for
LauncherConfig
.Collection of constants related to
Launcher
.Register a concrete implementation of this interface with a
LauncherDiscoveryRequestBuilder
or
Launcher
to be notified of events that occur during test discovery.Collection of
static
factory methods for creating
LauncherDiscoveryListeners
.LauncherDiscoveryRequest
extends the EngineDiscoveryRequest
API
with additional filters that are applied by the Launcher
itself.The
LauncherDiscoveryRequestBuilder
provides a light-weight DSL for
generating a LauncherDiscoveryRequest
.Represents the result of test discovery of the configured
test engines.
Factory for creating
Launcher
instances by invoking LauncherFactory.create()
or LauncherFactory.create(LauncherConfig)
.Interceptor for test discovery and execution by a
Launcher
in the
context of a LauncherSession
.An invocation that can be intercepted.
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.Register an implementation of this interface to be notified when a
LauncherSession
is opened and closed.Collection of
static
factory methods for creating
LauncherSessionListeners
.Deprecated.
Use
LegacyReportingUtils
instead.Utility methods for dealing with legacy reporting infrastructure, such as
reporting systems built on the Ant-based XML reporting format for JUnit 4.
LegacyXmlReportGeneratingListener
is a TestExecutionListener
that
generates a separate XML report for each root
in the TestPlan
.Collection of utilities for working with test lifecycle methods.
Simple
TestExecutionListener
for logging informational messages
for all events via a BiConsumer
that consumes Throwable
and Supplier<String>
.Base class for
TestDescriptors
based on Java methods.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.@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.Method based
TestSource
.Jupiter internal support for creating
MethodSource
from URI
.A
DiscoverySelector
that selects a module name so that
TestEngines
can discover
tests or containers based on modules.Default, mutable implementation of
ExtensionRegistry
.Mutable, internal implementation of the
TestExecutionSummary
API.NamespacedHierarchicalStore
is a hierarchical, namespaced key-value store.Called for each successfully stored non-null value in the store when a
NamespacedHierarchicalStore
is
closed
.Thread-safe
Supplier
that memoizes the result of calling its
delegate and ensures it is called at most once.Exception thrown by failed
NamespacedHierarchicalStore
operations.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.TestDescriptor
for tests based on nested (but not static) Java classes.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.A node within the execution hierarchy.
Executor for additional, dynamic test descriptors discovered during
execution of a
Node
.Supported execution modes for parallel execution.
Represents an invocation that runs with the supplied context.
The result of determining whether the execution of a given
context
should be skipped.No-op
ResourceLock
implementation.@NullAndEmptySource
is a composed annotation that combines
the functionality of @NullSource
and
@EmptySource
.Dummy enum class used as default value for optional attributes of
annotations.
@NullSource
is an ArgumentsSource
which provides a single
null
argument to the annotated @ParameterizedTest
method.Specialization of
ThrowableCollector
that treats instances of the
OTA's TestAbortedException
and JUnit 4's
org.junit.AssumptionViolatedException
as aborting.Specialization of
ThrowableCollector
that treats instances of
TestAbortedException
as aborting.Open Test Reporting events XML generating test execution listener.
Delays reporting of engine skipped/finished events so that exceptions thrown
by engines can be reported to listeners.
DiscoveryFilter
that is applied to the name of a Package
.A
DiscoverySelector
that selects a package name so that
TestEngines
can discover
tests or containers based on packages.Package based
TestSource
.Configuration to use for parallel test execution.
A strategy to use for configuring parallel test execution.
@ParameterizedTest
is used to signal that the annotated method is a
parameterized test method.Encapsulates access to the parameters of a parameterized test method and
caches the converters and aggregators used to resolve them.
ParameterResolutionUtils
provides support for dynamic resolution
of executable parameters via ParameterResolvers
.The result of attempting to parse a
TagExpression
.A
PostDiscoveryFilter
is applied to TestDescriptors
after test discovery.View of
ConfigurationParameters
that applies a supplied prefix to all
queries.Display name formatter for a
@RepeatedTest
.TestTemplateInvocationContextProvider
that supports the
@RepeatedTest
annotation.TestTemplateInvocationContext
for a @RepeatedTest
.RepetitionExtension
implements the following extension APIs to support
repetitions of a @RepeatedTest
method.ReportEntry
encapsulates a time-stamped map of String
-based
key-value pairs to be published to the reporting infrastructure.A lock for a one or more resources.
Collection of static utility methods for working with resources.
A simple executor service that
executes all test tasks in the caller's thread.
@SelectClasses
specifies the classes to select when running
a test suite on the JUnit Platform.@SelectClasspathResource
is a repeatable
annotation that specifies a classpath resource to select when running
a test suite on the JUnit Platform.@SelectClasspathResources
is a container for one or more
@SelectClasspathResource
declarations.@SelectDirectories
specifies the directories to select when
running a test suite on the JUnit Platform.@SelectFile
is a repeatable annotation that
specifies a file to select when running a test suite on the JUnit
Platform.@SelectFiles
is a container for one or more
@SelectFile
declarations.@SelectMethod
is a repeatable annotation that
specifies a method to select when running a test suite on the JUnit
Platform.@SelectMethods
is a container for one or more
@SelectMethod
declarations.@SelectModules
specifies the modules to select when running
a test suite on the JUnit Platform.Status of resolving a
DiscoverySelector
.A resolver that supports resolving one or multiple types of
DiscoverySelectors
.The context for resolving a
DiscoverySelector
and adding it to
the test tree.An exact or partial match for resolving a
DiscoverySelector
into
a TestDescriptor
.The result of an attempt to resolve a
DiscoverySelector
.@SelectPackages
specifies the names of packages to select
when running a test suite on the JUnit Platform.@SelectUris
specifies the URIs to select when running a test
suite on the JUnit Platform.This is based on a modified version of the
Shunting-yard algorithm.
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.Deprecated.
Functional interface for a single test to be executed by
SingleTestExecutor
.Prunes the stack trace in case of a failed event.
Internal API for converting arguments of type
String
to a specified
target type.@Suite
marks a class as a test suite on the JUnit Platform.@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.Simple
TestExecutionListener
that generates a
summary of the test execution.A tag expression can be evaluated against a collection of
tags to determine if they match the expression.
Factory methods for creating
PostDiscoveryFilters
based on included and excluded tags or tag expressions.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
.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.Mutable descriptor for a test or container that has been discovered by a
TestEngine
.Supported types for
TestDescriptors
.Visitor for the tree-like
TestDescriptor
structure.A
TestEngine
facilitates discovery and execution of
tests for a particular programming model.Register a concrete implementation of this interface with a
Launcher
to be notified of events that occur during test execution.TestExecutionResult
encapsulates the result of executing a single test
or container.Status of executing a single test or container.
Collection of AssertJ conditions for
TestExecutionResult
.Summary of test plan execution.
Failure of a test or container.
TestDescriptor
for
@TestFactory
methods.Immutable data transfer object that represents a test or container which is
usually part of a
TestPlan
.Represents the serialized output of
TestIdentifier
.ParameterResolver
that resolves the TestInfo
for
the currently executing test.Collection of utilities for retrieving the test instance lifecycle mode.
TestDescriptor
for @Test
methods.TestPlan
describes the tree of tests and containers as discovered
by a Launcher
.Visitor for
TestIdentifiers
in a TestPlan
.ParameterResolver
that injects a TestReporter
.Representation of the source of a test or container used to navigate to
its location by IDEs and build tools.
Immutable value object for a tag that is assigned to a test or
container.
TestDescriptor
for a @TestTemplate
invocation.TestDescriptor
for @TestTemplate
methods.Simple component that can be used to collect one or more instances of
Throwable
.Functional interface for an executable block of code that may throw a
Throwable
.Factory for
ThrowableCollector
instances.TypedArgumentConverter
is an abstract base class for
ArgumentConverter
implementations that always convert objects of a
given source type into a given target type.UniqueId
encapsulates the creation, parsing, and display of unique IDs
for TestDescriptors
.A segment of a
UniqueId
comprises a type and a
value.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.A
DiscoverySelector
that selects a UniqueId
so that
TestEngines
can discover
tests or containers based on unique IDs.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.A
DiscoverySelector
that selects a URI
so that
TestEngines
can discover tests or containers based on URIs.A
TestSource
that can be represented as a URI
.Deprecated.
since 1.8, in favor of the
@Suite
support provided by
the junit-platform-suite-engine
module; to be removed in JUnit Platform 2.0@ValueSource
is an ArgumentsSource
which provides access to
an array of literal values.This
Extension
provides native support for subclasses of
the Verifier
rule from JUnit 4.The JUnit Vintage
TestEngine
.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.
EngineDiscoveryRequestResolver
instead.