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.
Base class for OS-based
ExecutionCondition implementations.Abstract base class for
ExecutionCondition implementations that support
repeatable annotations.Abstract base implementation of
TestDescriptor that may be used by
custom TestEngines.@AfterAll is used to signal that the annotated method should be
executed after all tests in the current test class.AfterAllCallback defines the API for Extensions
that wish to provide additional behavior to test containers once
after all tests in the container have been executed.@AfterEach is used to signal that the annotated method should be
executed after each @Test,
@RepeatedTest, @ParameterizedTest, @TestFactory,
and @TestTemplate method in the current test class.AfterEachCallback defines the API for Extensions
that wish to provide additional behavior to tests after an individual test
and any user-defined teardown methods (e.g.,
@AfterEach methods) for that test
have been executed.Functional interface for registering an
@AfterEach method
as a pseudo-extension.AfterTestExecutionCallback defines the API for Extensions that wish to provide additional behavior to tests
immediately after an individual test has been executed but
before any user-defined teardown methods (e.g.,
@AfterEach methods) have been executed
for that test.@AggregateWith is an annotation that allows one to specify an
ArgumentsAggregator.AnnotatedElementContext encapsulates the context in which an
AnnotatedElement is declared.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.AnnotationSupport provides static utility methods for common tasks
regarding annotations — for example, checking if a class, method, or
field is annotated with a particular annotation; finding annotations on a
given class, method, or field; finding fields or methods annotated with
a particular annotation, etc.Collection of utilities for working with annotations.
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.AssertAll is a collection of utility methods that support asserting
multiple conditions in tests at once.AssertArrayEquals is a collection of utility methods that support asserting
array equality in tests.AssertDoesNotThrow is a collection of utility methods that support
explicitly asserting that a given code block does not throw an exception.AssertEquals is a collection of utility methods that support asserting
equality on objects and primitives in tests.AssertFalse is a collection of utility methods that support asserting
false in tests.AssertInstanceOf is a collection of utility methods that support
asserting that an object is of an expected type — in other words, if it
can be assigned to the expected type.Builder for
AssertionFailedErrors.Assertions is a collection of utility methods that support asserting
conditions in tests.Assertions is a collection of selected assertion utility methods
from JUnit Jupiter for use within the JUnit Platform Test Kit.Factory for timeout failures.
AssertionUtils is a collection of utility methods that are common to
all assertion implementations.AssertIterable is a collection of utility methods that support asserting
Iterable equality in tests.AssertNotEquals is a collection of utility methods that support asserting
inequality in objects and primitive values in tests.AssertNotNull is a collection of utility methods that support asserting
that there is an object.AssertNotSame is a collection of utility methods that support asserting
two objects are not the same.AssertNull is a collection of utility methods that support asserting
there is no object.AssertSame is a collection of utility methods that support asserting
two objects are the same.AssertThrows is a collection of utility methods that support asserting
an exception of an expected type is thrown.AssertThrowsExactly is a collection of utility methods that support asserting
an exception of an exact type is thrown.AssertTimeout is a collection of utility methods that support asserting
the execution of the code under test did not take longer than the timeout duration.AssertTimeout is a collection of utility methods that support asserting
the execution of the code under test did not take longer than the timeout duration
using a preemptive approach.The thread factory used for preemptive timeout.
AssertTrue is a collection of utility methods that support asserting
true in tests.Assumptions is a collection of utility methods that support
conditional test execution based on assumptions.@BeforeAll is used to signal that the annotated method should be
executed before all tests in the current test class.BeforeAllCallback defines the API for Extensions
that wish to provide additional behavior to test containers once
before all tests in the container have been executed.@BeforeEach is used to signal that the annotated method should be
executed before each @Test,
@RepeatedTest, @ParameterizedTest, @TestFactory,
and @TestTemplate method in the current test class.BeforeEachCallback defines the API for Extensions
that wish to provide additional behavior to tests before an individual test
and any user-defined setup methods (e.g.,
@BeforeEach methods) for that test
have been executed.Functional interface for registering a
@BeforeEach method
as a pseudo-extension.BeforeTestExecutionCallback defines the API for Extensions that wish to provide additional behavior to tests
immediately before an individual test is executed but after
any user-defined setup methods (e.g.,
@BeforeEach methods) have been
executed for that test.Deprecated.
Caching implementation of the
JupiterConfiguration API.TestDescriptor for tests based on Java classes.ClassDescriptor encapsulates functionality for a given Class.Class-related predicate used by reflection utilities.
Collection of utilities for working with ClassLoader and associated tasks.
DiscoveryFilter that is applied to the name of a Class.Collection of utilities for creating filters based on class names.
ClassOrderer defines the API for ordering top-level test classes and
@Nested test classes.ClassOrderer that sorts classes alphanumerically based on their
fully qualified names using String.compareTo(String).ClassOrderer that sorts classes alphanumerically based on their
display names using String.compareTo(String)ClassOrderer that sorts classes based on the @Order
annotation.ClassOrderer that orders classes pseudo-randomly.ClassOrdererContext encapsulates the context in which
a ClassOrderer will be invoked.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.DISCLAIMER
Deprecated.
Please use
EngineDiscoveryRequestResolver instead.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.ClassSupport provides static utility methods for common tasks
regarding classes — for example, generating a
comma-separated list of fully qualified class names for a set of supplied
classes.TestDescriptor for tests based on Java classes.Collection of utilities for working with
classes.Enumeration of cleanup modes for
@TempDir.Collection of utilities for working with
Collections.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.The result of 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.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.@Disabled is used to signal that the annotated test class or
test method is currently disabled and should not be executed.ExecutionCondition that supports the @Disabled annotation.@DisabledForJreRange is used to signal that the annotated test class or
test method is only disabled for a specific range of Java Runtime
Environment (JRE) versions from DisabledForJreRange.min() to DisabledForJreRange.max().@DisabledIf is used to signal that the annotated test class or test
method is disabled only if the provided
condition evaluates to true.@DisabledIfEnvironmentVariable is used to signal that the annotated test
class or test method is disabled if the value of the specified
environment variable matches the specified
regular expression.@DisabledIfEnvironmentVariables is a container for one or more
@DisabledIfEnvironmentVariable declarations.@DisabledIfSystemProperties is a container for one or more
@DisabledIfSystemProperty declarations.@DisabledIfSystemProperty is used to signal that the annotated test
class or test method is disabled if the value of the specified
system property matches the specified
regular expression.@DisabledInNativeImage is used to signal that the annotated test class
or test method is only disabled when executing within a GraalVM native
image.@DisabledOnJre is used to signal that the annotated test class or
test method is disabled on one or more specified Java
Runtime Environment (JRE) versions.@DisabledOnOs is used to signal that the annotated test class or
test method is disabled on one or more specified
operating systems or on one or more specified
architecturesDisable 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.@DisplayName is used to declare a custom display
name for the annotated test class or test method.@DisplayNameGeneration is used to declare a custom display name
generator for the annotated test class.DisplayNameGenerator defines the SPI for generating display names
programmatically.DisplayNameGenerator that generates complete sentences.DisplayNameGenerator that replaces underscores with spaces.Simple
DisplayNameGenerator that removes trailing parentheses
for methods with no parameters.Standard
DisplayNameGenerator.Collection of utilities for working with display names.
A
DynamicContainer is a container generated at runtime.TestDescriptor for a DynamicContainer.Filter for dynamic descendants of
TestDescriptors that
implement Filterable.DynamicNode serves as the abstract base class for a container or a
test case generated at runtime.Base
TestDescriptor for a DynamicNode.A
DynamicTest is a test case generated at runtime.DynamicTestInvocationContext represents the context of a
single invocation of a dynamic test.TestDescriptor for a DynamicTest.@EmptySource is an ArgumentsSource which provides a single
empty argument to the annotated @ParameterizedTest method.@EnabledForJreRange is used to signal that the annotated test class or
test method is only enabled for a specific range of Java Runtime
Environment (JRE) versions from EnabledForJreRange.min() to EnabledForJreRange.max().@EnabledIf is used to signal that the annotated test class or test
method is enabled only if the provided
condition evaluates to true.@EnabledIfEnvironmentVariable is used to signal that the annotated test
class or test method is only enabled if the value of the specified
environment variable matches the specified
regular expression.@EnabledIfEnvironmentVariables is a container for one or more
@EnabledIfEnvironmentVariable declarations.@EnabledIfSystemProperties is a container for one or more
@EnabledIfSystemProperty declarations.@EnabledIfSystemProperty is used to signal that the annotated test
class or test method is only enabled if the value of the specified
system property matches the specified
regular expression.@EnabledInNativeImage is used to signal that the annotated test class
or test method is only enabled when executing within a GraalVM native
image.@EnabledOnJre is used to signal that the annotated test class or
test method is only enabled on one or more specified Java
Runtime Environment (JRE) versions.@EnabledOnOs is used to signal that the annotated test class or
test method is only enabled on one or more specified
operating systems or one or more specified
architectures.EnableJUnit4MigrationSupport 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.Collection of utilities for working with exceptions.
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.Executable is a functional interface that can be used to
implement any generic block of code that potentially throws a
Throwable.ExecutableInvoker allows invoking methods and constructors
with support for dynamic resolution of parameters via
ParameterResolvers.@Execution is used to configure the parallel execution
mode of a test class or test method.Execution encapsulates metadata for the execution of a single
TestDescriptor.ExecutionCondition defines the Extension API for
programmatic, conditional test execution.An
ExecutionListenerAdapter adapts a TestPlan and a corresponding
TestExecutionListener to the EngineExecutionListener API.Supported execution modes for parallel test execution.
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.@ExtendWith is a repeatable annotation
that is used to register extensions for the annotated
test class, test interface, test method, parameter, or field.Marker interface for all extensions.
Thrown if an error is encountered regarding the configuration of an
extension.
ExtensionContext encapsulates the context in which the
current test or container is being executed.A
Namespace is used to provide a scope for data saved by
extensions within a ExtensionContext.Store.Store provides methods for extensions to save and retrieve data.Classes implementing this interface indicate that they want to
ExtensionContext.Store.CloseableResource.close()
some underlying resource or resources when the enclosing Store
is closed.Thrown if an error is encountered regarding the use of an
ExtensionContext or ExtensionContext.Store.An
ExtensionRegistrar is used to register extensions.An
ExtensionRegistry holds all registered extensions (i.e.@Extensions is a container for one or more @ExtendWith
declarations.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.Collection of utilities for working with
Functions,
Predicates, etc.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.
Modes in which a hierarchy can be traversed — for example, when
searching for methods or fields within a class hierarchy.
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.@IndicativeSentencesGeneration is used to register the
DisplayNameGenerator.IndicativeSentences display name generator and configure it.InterceptingExecutableInvoker encapsulates the invocation of a
Executable (i.e., method or constructor),
including support for dynamic resolution of method parameters via
ParameterResolvers.InvocationInterceptor defines the API for Extensions that wish to intercept calls to test code.An invocation that returns a result and may throw a
Throwable.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.@Isolated is used to declare that the annotated test class should be
executed in isolation from other test classes.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.Enumeration of Java Runtime Environment (JRE) versions.
Base class for all
RuntimeExceptions thrown
by JUnit.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
instead.
invalid reference
org.junit.platform.reporting.legacy.LegacyReportingUtilsLifecycleMethodExecutionExceptionHandler defines the API for
Extensions that wish to handle exceptions thrown during
the execution of @BeforeAll, @BeforeEach, @AfterEach,
and @AfterAll lifecycle methods.Collection of utilities for working with test lifecycle methods.
The
Logger API serves as a simple logging facade for
java.util.logging (JUL).Factory for the
Logger facade for JUL.Simple
TestExecutionListener for logging informational messages
for all events via a BiConsumer that consumes Throwable
and Supplier<String>.LogRecordListener is only intended for testing purposes within
JUnit's own test suite.A simple LRU cache with a maximum size.
Base class for
TestDescriptors based on Java methods.MethodDescriptor encapsulates functionality for a given Method.MethodOrderer defines the API for ordering the test methods
in a given test class.Deprecated.
as of JUnit Jupiter 5.7 in favor of
MethodOrderer.MethodName;
to be removed in 6.0MethodOrderer that sorts methods alphanumerically based on their
display names using String.compareTo(String)MethodOrderer that sorts methods alphanumerically based on their
names using String.compareTo(String).MethodOrderer that sorts methods based on the @Order
annotation.MethodOrderer that orders methods pseudo-randomly.MethodOrdererContext encapsulates the context in which
a MethodOrderer will be invoked.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.ModifierSupport provides static utility methods for working with
class and member modifiers —
for example, to determine if a class or member is declared as
public, private, abstract, static, etc.A
DiscoverySelector that selects a module name so that
TestEngines can discover
tests or containers based on modules.Collection of utilities for working with
java.lang.Module
and friends.Default, mutable implementation of
ExtensionRegistry.Mutable, internal implementation of the
TestExecutionSummary API.Named is a container that associates a name with a given payload.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.@Nested is used to signal that the annotated class is a nested,
non-static test class (i.e., an inner class) that can share
setup and state with an instance of its enclosing class.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.@Order is an annotation that is used to configure the
order in which the annotated element (i.e., field,
method, or class) should be evaluated or executed relative to other elements
of the same category.Enumeration of common operating systems used for testing Java applications.
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.Collection of utilities for working with packages.
Configuration to use for parallel test execution.
A strategy to use for configuring parallel test execution.
ParameterContext encapsulates the context in which an
Executable will be invoked for a given
Parameter.@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.
Thrown if an error is encountered in the configuration or execution of a
ParameterResolver.ParameterResolutionUtils provides support for dynamic resolution
of executable parameters via ParameterResolvers.ParameterResolver defines the API for Extensions
that wish to dynamically resolve arguments for parameters
at runtime.The result of attempting to parse a
TagExpression.A
PostDiscoveryFilter is applied to TestDescriptors
after test discovery.Collection of utilities for asserting preconditions for method and
constructor arguments.
Thrown if a precondition is violated.
Deprecated.
Use PreconditionViolationException instead.
View of
ConfigurationParameters that applies a supplied prefix to all
queries.ReflectionSupport provides static utility methods for common
reflection tasks — for example, scanning for classes in the class-path
or module-path, loading classes, finding methods, invoking methods, etc.Collection of utilities for working with the Java reflection APIs.
Modes in which a hierarchy can be traversed — for example, when
searching for methods or fields within a class hierarchy.
ReflectiveInvocationContext encapsulates the context of
a reflective invocation of an executable (method or constructor).@RegisterExtension is used to register an Extension via a
field in a test class.@RepeatedTest is used to signal that the annotated method is a
test template method that should be repeated a specified number of times with a configurable display
name and an optional failure threshold.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.RepetitionInfo is used to inject information about the current
repetition of a repeated test into @RepeatedTest, @BeforeEach,
and @AfterEach methods.ReportEntry encapsulates a time-stamped map of String-based
key-value pairs to be published to the reporting infrastructure.The access mode required by a test class or method for a given resource.
@ResourceLock is used to declare that the annotated test class or test
method requires access to a shared resource identified by a key.A lock for a one or more resources.
@ResourceLocks is a container for one or more
@ResourceLock declarations.Common resource names for synchronizing test execution.
Collection of static utility methods for working with resources.
Collection of utilities for working with
Runtime,
RuntimeMXBean, etc.A simple executor service that
executes all test tasks in the caller's thread.
Search options for finding an annotation within a class hierarchy.
@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.Collection of utilities for working with
Strings,
CharSequences, etc.@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.@Tag is a repeatable annotation that is
used to declare a tag for the annotated test class or test method.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.@Tags is a container for one or more @Tag declarations.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.TempDirFactory defines the SPI for creating temporary directories
programmatically.Standard
TempDirFactory implementation which delegates to
Files.createTempDirectory(java.nio.file.Path, java.lang.String, java.nio.file.attribute.FileAttribute<?>...) using "junit" as the prefix.TerminationInfo is a union type that allows propagation of terminated
container/test state, supporting either the reason if the container/test
was skipped or the TestExecutionResult if the container/test was executed.@Test is used to signal that the annotated method is a
test method.@Testable is used to signal to IDEs and tooling vendors that the
annotated or meta-annotated element is testable.@TestClassOrder is a type-level annotation that is used to configure
a ClassOrderer for the @Nested test classes of
the annotated test class.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.TestExecutionExceptionHandler defines the API for Extensions that wish to handle exceptions thrown during test execution.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.
@TestFactory is used to signal that the annotated method is a
test factory method.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.TestInfo is used to inject information about the current test or
container into to @Test, @RepeatedTest,
@ParameterizedTest, @TestFactory, @BeforeEach,
@AfterEach, @BeforeAll, and @AfterAll methods.ParameterResolver that resolves the TestInfo for
the currently executing test.@TestInstance is a type-level annotation that is used to configure
the lifecycle of test instances for the annotated
test class or test interface.Enumeration of test instance lifecycle modes.
TestInstanceFactoryContext encapsulates the context in which
a test class is to be instantiated by a
TestInstanceFactory.Collection of utilities for retrieving the test instance lifecycle mode.
TestInstancePostProcessor defines the API for Extensions that wish to post-process test instances.TestInstancePreConstructCallback defines the API for Extensions that wish to be invoked prior to creation of test instances.TestInstancePreDestroyCallback defines the API for Extensions that wish to process test instances after they have been
used in tests but before they are destroyed.TestInstances encapsulates the test instances of a test.Thrown if an error is encountered during the execution of
a
TestInstanceFactory.@TestMethodOrder is a type-level annotation that is used to configure
a MethodOrderer for the test methods of the annotated
test class or test interface.TestDescriptor for @Test methods.TestPlan describes the tree of tests and containers as discovered
by a Launcher.Visitor for
TestIdentifiers in a TestPlan.Parameters of type
TestReporter can be injected into
@BeforeEach and @AfterEach lifecycle
methods as well as methods annotated with @Test,
@RepeatedTest,
@ParameterizedTest,
@TestFactory, etc.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.
@TestTemplate is used to signal that the annotated method is a
test template method.TestTemplateInvocationContext represents the context of a
single invocation of a test
template.TestTemplateInvocationContextProvider defines the API for
Extensions that wish to provide one or multiple contexts
for the invocation of a
@TestTemplate method.TestDescriptor for a @TestTemplate
invocation.TestDescriptor for @TestTemplate
methods.TestWatcher defines the API for Extensions that
wish to process test results.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.ThrowingConsumer is a functional interface that can be used to
implement any generic block of code that consumes an argument and
potentially throws a Throwable.ThrowingSupplier is a functional interface that can be used to
implement any generic block of code that returns an object and
potentially throws a Throwable.@Timeout is used to define a timeout for a method or all testable
methods within one class and its @Nested classes.ThreadMode is use to define whether the test code should be executed in the thread
of the calling code or in a separated thread.Simple builder for generating strings in custom implementations of
toString().A container object which may either contain a nullable value in case of
success or an exception in case of failure.
A transformer for values of type
S to type T.ParameterResolver adapter which resolves a parameter based on its exact type.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.Internal utilities for working with unrecoverable exceptions.
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.
UnrecoverableExceptionsinstead.