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.
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.
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.
An EngineDescriptor is a TestDescriptor for a specific TestEngine.
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.
 
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.
 
 
@EnumSource is an ArgumentsSource for constants of an Enum.
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 Method supplied to FallbackStringToObjectConverter.IsFactoryMethod.test(Method) is a non-private static factory method for the supplied FallbackStringToObjectConverter.IsFactoryMethod.targetType.
Position inside a file represented by line and column numbers.
Position inside a file represented by line and column numbers.
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.
The result of applying a Filter.
 
A ForkJoinPool-based executor service that executes test tasks with the configured parallelism.
 
 
 
 
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.0
 
 
 
 
 
 
 
 
 
 
The 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.
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.
 
 
 
 
 
 
 
 
 
 
SelectorResolutionResult encapsulates the result of resolving a DiscoverySelector by a TestEngine.
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.
 
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.