diff --git a/docs/snapshot/api/allclasses-index.html b/docs/snapshot/api/allclasses-index.html index 519f1e538350..345c8ab19e38 100644 --- a/docs/snapshot/api/allclasses-index.html +++ b/docs/snapshot/api/allclasses-index.html @@ -172,2061 +172,2065 @@
ArgumentConverter
is an abstraction that allows an input object to
be converted to an instance of a different class.@ParameterizedTest
.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.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 arguments providers
for the annotated test method.@ArgumentsSources
is a simple container for one or more
ArgumentsSource
annotations.AssertionFailedErrors
.Assertions
is a collection of utility methods that support asserting
conditions in tests.Assumptions
is a collection of utility methods that support
conditional test execution based on assumptions.@AutoClose
is used to indicate that an annotated field will be
automatically closed after test execution.@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.@BeforeEach
method
as a pseudo-extension.@BeforeSuite
is used to signal that the annotated method should be
executed before all tests in the current test suite.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.JupiterConfiguration
API.TestDescriptor
for tests based on Java classes.ClassDescriptor
encapsulates functionality for a given Class
.DiscoveryFilter
that is applied to the name of a Class
.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.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.TestSource
with an optional position.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.EngineDiscoveryRequestResolver
instead.DiscoverySelector
that selects a Class
or class name so
that TestEngines
can discover
tests or containers based on classes.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.classes
.@TempDir
.Collections
.CompositeTestSource
contains one or more TestSources
.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.TestEngines
may use to
influence test discovery and execution.@ConfigurationParameters
is a container for one or more
@ConfigurationParameter
declarations.@ConfigurationParametersResource
is a
repeatable annotation that specifies a configuration
file in Java's properties format on the classpath to be added to the
discovery request when running a test suite on the JUnit Platform.@ConfigurationParametersResources
is a container for one or more
@ConfigurationParametersResource
declarations.ConsoleLauncher
is a stand-alone application for launching the
JUnit Platform from the console.java.io.Console
and friends.JupiterTestEngine
.ConversionException
is an exception that can occur when an
object is converted to another object.ConversionSupport
provides static utility methods for converting a
given object into an instance of a specified type.@ConvertWith
is an annotation that allows one to specify an explicit
ArgumentConverter
.@CsvFileSource
is a repeatable
ArgumentsSource
which is used to load comma-separated value (CSV)
files from one or more classpath CsvFileSource.resources()
or CsvFileSource.files()
.@CsvFileSources
is a simple container for one or more
CsvFileSource
annotations.@CsvSource
is a repeatable
ArgumentsSource
which reads comma-separated values (CSV) from one
or more CSV records supplied via the CsvSource.value()
attribute or
CsvSource.textBlock()
attribute.@CsvSources
is a simple container for one or more
CsvSource
annotations.DefaultArgumentConverter
is the default implementation of the
ArgumentConverter
API.ArgumentsAccessor
API.JupiterConfiguration
API.DiscoverySelector
that selects a directory so that
TestEngines
can discover tests or containers based on directories in the
file system.TestSource
.@Disabled
is used to signal that the annotated test class or
test method is currently disabled and should not be executed.@DisabledForJreRange
is used to signal that the annotated test class
or test method is 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 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 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
architecturesDiscoveryFilter
is applied during test discovery to determine if
a given container or test should be included in the test plan.TestEngine
can use to discover tests
— for example, the name of a Java class, the path to a file or
directory, etc.DiscoverySelector
with a specific prefix.DiscoverySelectorIdentifier
with a specific prefix.DiscoverySelectorIdentifiers
.DiscoverySelectorResolver
resolves TestDescriptors
for containers and tests selected by DiscoverySelectors
, with the help of an EngineDiscoveryRequestResolver
.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.DisplayNameGenerator
that removes trailing parentheses
for methods with no parameters.DisplayNameGenerator
.DynamicContainer
is a container generated at runtime.TestDescriptors
that
implement Filterable
.DynamicNode
serves as the abstract base class for a container or a
test case generated at runtime.DynamicTest
is a test case generated at runtime.DynamicTestInvocationContext
represents the context of a
single invocation of a dynamic test.@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 only enabled 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.EngineDiscoveryListener
contains TestEngine
access to the
information necessary to discover tests and containers.EngineDiscoveryRequest
provides a TestEngine
access to the
information necessary to discover tests and containers.SelectorResolver
and TestDescriptor.Visitor
that can be reused by different
TestEngines
.EngineDiscoveryRequestResolver
.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
.TestEngine
.HierarchicalTestEngine
and its collaborators.EngineExecutionResults
provides a fluent API for processing the
results of executing a test plan on the JUnit Platform for a given
TestEngine
.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.@EnumSources
is a simple container for one or more
EnumSource
annotations.Event
represents a single event fired during execution of
a test plan on the JUnit Platform.Event
.Events
is a facade that provides a fluent API for working with
events.EventStatistics
provides a fluent API for asserting statistics
for events.Event
types.@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.@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.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.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
.TestEngine
access to the information necessary to
execute its tests.Executions
is a facade that provides a fluent API for working with
executions.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.ExtensionContext
encapsulates the context in which the
current test or container is being executed.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.ExtensionContext.Store.CloseableResource.close()
some underlying resource or resources when the enclosing Store
is closed.ExtensionContext
or ExtensionContext.Store
.ExtensionContextInternal
extends the ExtensionContext
with internal API.ExtensionContext
to simplify the legacy for
#3445.ExtensionRegistrar
is used to register extensions.ExtensionRegistry
holds all registered extensions (i.e.@Extensions
is a container for one or more @ExtendWith
declarations.Extension
provides native support for subclasses of
the ExternalResource
rule from JUnit 4.@FieldSource
is a repeatable
ArgumentsSource
which provides access to values of
fields of the class in which this annotation is declared
or from static fields in external classes referenced by fully qualified
field name.@FieldSources
is a simple container for one or more
FieldSource
annotations.DiscoverySelector
that selects a file so that
TestEngines
can discover tests or containers based on files in the
file system.TestSource
with an optional
position.TestSource
.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.Filter
.LauncherDiscoveryListener
that generates Java Flight Recorder
events.TestExecutionListener
that generates Java Flight Recorder
events.Functions
,
Predicates
, etc.TestEngine
implementations that wish
to organize test suites hierarchically based on the Node
abstraction.ExecutionCondition
that supports JUnit 4's @Ignore
annotation.@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.@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.Throwable
.@Nested
test class.@Isolated
is used to declare that the annotated test class should be
executed in isolation from other test classes.@TestFactory
method.@Test
method.@TestTemplate
method.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.RuntimeExceptions
thrown
by JUnit.@Suite
support provided by
the junit-platform-suite-engine
module; to be removed in JUnit Platform 2.0TestEngine
.ThrowableCollectors
within
the JUnit Jupiter test engine.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
.LauncherConfig
.Launcher
.LauncherDiscoveryRequestBuilder
or
Launcher
to be notified of events that occur during test discovery.static
factory methods for creating
LauncherDiscoveryListeners
.LauncherDiscoveryRequest
extends the EngineDiscoveryRequest
API
with additional filters that are applied by the Launcher
itself.LauncherDiscoveryRequestBuilder
provides a light-weight DSL for
generating a LauncherDiscoveryRequest
.Launcher
instances by invoking LauncherFactory.create()
or LauncherFactory.create(LauncherConfig)
.Launcher
in the
context of a LauncherSession
.LauncherSession
API is the main entry point for client code that
wishes to repeatedly discover and execute tests using one
or more test engines.LauncherSession
is opened and closed.static
factory methods for creating
LauncherSessionListeners
.LegacyReportingUtils
instead.LegacyXmlReportGeneratingListener
is a TestExecutionListener
that
generates a separate XML report for each root
in the TestPlan
.LifecycleMethodExecutionExceptionHandler
defines the API for
Extensions
that wish to handle exceptions thrown during
the execution of @BeforeAll
, @BeforeEach
, @AfterEach
,
and @AfterAll
lifecycle methods.Logger
API serves as a simple logging facade for
java.util.logging
(JUL).Logger
facade for JUL.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.TestDescriptors
based on Java methods.MethodDescriptor
encapsulates functionality for a given Method
.PostDiscoveryFilter
that is applied to the fully qualified
Method
name without parameters.MethodOrderer
defines the API for ordering the test methods
in a given test class.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.
UnrecoverableExceptions
instead.