All Classes Interface Summary Class Summary Enum Summary Exception Summary Annotation Types Summary
Class |
Description |
AbortOnFailureLauncherDiscoveryListener |
|
AbstractClassNameFilter |
Abstract ClassNameFilter that servers as a superclass
for filters including or excluding fully qualified class names
based on pattern-matching.
|
AbstractExtensionContext<T extends TestDescriptor> |
|
AbstractRepeatableAnnotationCondition<A extends java.lang.annotation.Annotation> |
Abstract base class for ExecutionCondition implementations that support
repeatable annotations.
|
AbstractTestDescriptor |
|
AbstractTestRuleAdapter |
|
AbstractTestRuleAnnotatedMember |
|
AfterAll |
@AfterAll is used to signal that the annotated method should be
executed after all tests in the current test class.
|
AfterAllCallback |
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 |
@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 |
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.
|
AfterEachMethodAdapter |
Functional interface for registering an @AfterEach method
as a pseudo-extension.
|
AfterTestExecutionCallback |
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 |
|
AnnotationConsumer<A extends java.lang.annotation.Annotation> |
AnnotationConsumer is a functional
interface for consuming annotations.
|
AnnotationConsumerInitializer |
AnnotationConsumerInitializer is an internal helper class for
initializing AnnotationConsumers .
|
AnnotationSupport |
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.
|
AnnotationUtils |
Collection of utilities for working with annotations.
|
ArgumentAccessException |
ArgumentAccessException is an exception thrown by an
ArgumentsAccessor if an error occurs while accessing
or converting an argument.
|
ArgumentConversionException |
ArgumentConversionException is an exception that can occur when an
object is converted to another object by an implementation of an
ArgumentConverter .
|
ArgumentConverter |
ArgumentConverter is an abstraction that allows an input object to
be converted to an instance of a different class.
|
Arguments |
Arguments is an abstraction that provides access to an array of
objects to be used for invoking a @ParameterizedTest method.
|
ArgumentsAccessor |
|
ArgumentsAggregationException |
ArgumentsAggregationException is an exception thrown by an
ArgumentsAggregator when an error occurs while aggregating
arguments.
|
ArgumentsAggregator |
ArgumentsAggregator is an abstraction for the aggregation of arguments
provided by an ArgumentsProvider for a single invocation of a
@ParameterizedTest method
into a single object.
|
ArgumentsProvider |
An ArgumentsProvider is responsible for providing a stream of arguments to be passed to a @ParameterizedTest
method.
|
ArgumentsSource |
@ArgumentsSource is a repeatable annotation
that is used to register argument providers
for the annotated test method.
|
ArgumentsSources |
@ArgumentsSources is a simple container for one or more
ArgumentsSource annotations.
|
AssertAll |
AssertAll is a collection of utility methods that support asserting
multiple conditions in tests at once.
|
AssertArrayEquals |
AssertArrayEquals is a collection of utility methods that support asserting
array equality in tests.
|
AssertDoesNotThrow |
AssertDoesNotThrow is a collection of utility methods that support
explicitly asserting that a given code block does not throw an exception.
|
AssertEquals |
AssertEquals is a collection of utility methods that support asserting
equality on objects and primitives in tests.
|
AssertFalse |
AssertFalse is a collection of utility methods that support asserting
false in tests.
|
Assertions |
Assertions is a collection of utility methods that support asserting
conditions in tests.
|
AssertionUtils |
AssertionUtils is a collection of utility methods that are common to
all assertion implementations.
|
AssertIterableEquals |
AssertIterable is a collection of utility methods that support asserting
Iterable equality in tests.
|
AssertLinesMatch |
AssertLinesMatch is a collection of utility methods that support asserting
lines of String equality or Pattern -match in tests.
|
AssertLinesMatch.LinesMatcher |
|
AssertNotEquals |
AssertNotEquals is a collection of utility methods that support asserting
inequality in objects and primitive values in tests.
|
AssertNotNull |
AssertNotNull is a collection of utility methods that support asserting
that there is an object.
|
AssertNotSame |
AssertNotSame is a collection of utility methods that support asserting
two objects are not the same.
|
AssertNull |
AssertNull is a collection of utility methods that support asserting
there is no object.
|
AssertSame |
AssertSame is a collection of utility methods that support asserting
two objects are the same.
|
AssertThrows |
AssertThrows is a collection of utility methods that support asserting
an exception of an expected type is thrown.
|
AssertTimeout |
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.ExecutionTimeoutException |
|
AssertTimeout.TimeoutThreadFactory |
The thread factory used for preemptive timeout.
|
AssertTrue |
AssertTrue is a collection of utility methods that support asserting
true in tests.
|
Assumptions |
Assumptions is a collection of utility methods that support
conditional test execution based on assumptions.
|
BeforeAll |
@BeforeAll is used to signal that the annotated method should be
executed before all tests in the current test class.
|
BeforeAllCallback |
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 |
@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 |
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.
|
BeforeEachMethodAdapter |
Functional interface for registering a @BeforeEach method
as a pseudo-extension.
|
BeforeTestExecutionCallback |
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.
|
BlacklistedExceptions |
Deprecated.
|
BooleanExecutionCondition<A extends java.lang.annotation.Annotation> |
|
CachingJupiterConfiguration |
|
ClassBasedTestDescriptor |
|
ClassContainerSelectorResolver |
|
ClassExtensionContext |
|
ClassFileVisitor |
|
ClassFilter |
Class-related predicate used by reflection utilities.
|
ClassLoaderUtils |
Collection of utilities for working with ClassLoader and associated tasks.
|
ClassNameFilter |
|
ClassNamePatternFilterUtils |
Collection of utilities for creating filters based on class names.
|
ClasspathResourceSelector |
A DiscoverySelector that selects the name of a classpath resource
so that TestEngines can load resources
from the classpath — for example, to load XML or JSON files from the classpath,
potentially within JARs.
|
ClasspathResourceSource |
|
ClasspathRootSelector |
A DiscoverySelector that selects a classpath root so that
TestEngines can search for class
files or resources within the physical classpath — for example, to
scan for test classes.
|
ClasspathScanner |
DISCLAIMER
|
ClasspathScanningSupport |
Deprecated.
|
ClassSelector |
|
ClassSelectorResolver |
|
ClassSelectorResolver |
|
ClassSource |
|
ClassSupport |
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.
|
ClassTestDescriptor |
|
ClassUtils |
Collection of utilities for working with classes .
|
CloseablePath |
|
CollectionUtils |
Collection of utilities for working with Collections .
|
CompositeFilter<T> |
Combines a collection of Filters into a new filter that will
include elements if and only if all of the filters in the specified collection
include it.
|
CompositeLauncherDiscoveryListener |
|
CompositeLock |
|
CompositeTestSource |
A CompositeTestSource contains one or more TestSources .
|
ConditionEvaluationException |
|
ConditionEvaluationResult |
|
ConditionEvaluator |
|
ConfigurationParameters |
Configuration parameters that TestEngines may use to
influence test discovery and execution.
|
Constants |
|
ConstructorInvocation<T> |
|
ConvertWith |
@ConvertWith is an annotation that allows one to specify an explicit
ArgumentConverter .
|
CsvArgumentsProvider |
|
CsvFileArgumentsProvider |
|
CsvFileArgumentsProvider.CsvParserIterator |
|
CsvFileArgumentsProvider.DefaultInputStreamProvider |
|
CsvFileArgumentsProvider.InputStreamProvider |
|
CsvFileArgumentsProvider.Source |
|
CsvFileSource |
|
CsvParserFactory |
|
CsvParsingException |
Thrown if an error is encountered while parsing CSV input.
|
CsvSource |
|
DefaultArgumentConverter |
|
DefaultArgumentConverter.StringToCommonJavaTypesConverter |
|
DefaultArgumentConverter.StringToEnumConverter |
|
DefaultArgumentConverter.StringToJavaTimeConverter |
|
DefaultArgumentConverter.StringToObjectConverter |
|
DefaultArgumentConverter.StringToPrimitiveConverter |
|
DefaultArgumentsAccessor |
|
DefaultDiscoveryRequest |
|
DefaultJupiterConfiguration |
|
DefaultLauncher |
Default implementation of the Launcher API.
|
DefaultLauncherConfig |
|
DefaultMethodDescriptor |
|
DefaultMethodOrdererContext |
|
DefaultParallelExecutionConfiguration |
|
DefaultParallelExecutionConfigurationStrategy |
Default implementations of configuration strategies for parallel test
execution.
|
DefaultParameterContext |
|
DefaultTestInstanceFactoryContext |
|
DefaultTestInstances |
|
DefaultUriSource |
|
DefensiveAllDefaultPossibilitiesBuilder |
Customization of AllDefaultPossibilitiesBuilder from JUnit 4 to
ignore certain classes that would otherwise be reported as errors or cause
infinite recursion.
|
DefensiveAllDefaultPossibilitiesBuilder.DefensiveAnnotatedBuilder |
Customization of AnnotatedBuilder that ignores classes annotated
with @RunWith(JUnitPlatform.class) to avoid infinite recursion.
|
DefensiveAllDefaultPossibilitiesBuilder.DefensiveJUnit4Builder |
Customization of JUnit4Builder that ignores classes that do not
contain any test methods in order not to report errors for them.
|
DefensiveAllDefaultPossibilitiesBuilder.NullIgnoredBuilder |
Customization of IgnoredBuilder that always returns null .
|
DelegatingEngineExecutionListener |
|
DequeStack<T> |
|
DirectorySelector |
|
DirectorySource |
|
Disabled |
@Disabled is used to signal that the annotated test class or
test method is currently disabled and should not be executed.
|
DisabledCondition |
|
DisabledForJreRange |
|
DisabledForJreRangeCondition |
|
DisabledIf |
@DisabledIf is used to signal that the annotated test class or
test method is disabled only if the provided condition
evaluates to true .
|
DisabledIfCondition |
|
DisabledIfEnvironmentVariable |
@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.
|
DisabledIfEnvironmentVariableCondition |
|
DisabledIfEnvironmentVariables |
|
DisabledIfSystemProperties |
|
DisabledIfSystemProperty |
@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.
|
DisabledIfSystemPropertyCondition |
|
DisabledOnJre |
@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.
|
DisabledOnJreCondition |
|
DisabledOnOs |
@DisabledOnOs is used to signal that the annotated test class or
test method is disabled on one or more specified
operating systems.
|
DisabledOnOsCondition |
|
DiscoveryFilter<T> |
A DiscoveryFilter is applied during test discovery to determine if
a given container or test should be included in the test plan.
|
DiscoverySelector |
A selector defines what a TestEngine can use to discover tests
— for example, the name of a Java class, the path to a file or
directory, etc.
|
DiscoverySelectorResolver |
DiscoverySelectorResolver resolves TestDescriptors
for containers and tests selected by DiscoverySelectors with the help of the
JavaElementsResolver .
|
DiscoverySelectors |
|
DisplayName |
@DisplayName is used to declare a custom display
name for the annotated test class or test method.
|
DisplayNameGeneration |
@DisplayNameGeneration is used to declare a custom display name
generator for the annotated test class.
|
DisplayNameGenerator |
DisplayNameGenerator defines the SPI for generating display names
programmatically.
|
DisplayNameGenerator.IndicativeSentences |
DisplayNameGenerator that generates complete sentences.
|
DisplayNameGenerator.ReplaceUnderscores |
DisplayNameGenerator that replaces underscores with spaces.
|
DisplayNameGenerator.Simple |
Simple DisplayNameGenerator that removes trailing parentheses
for methods with no parameters.
|
DisplayNameGenerator.Standard |
Standard DisplayNameGenerator .
|
DisplayNameUtils |
Collection of utilities for working with display names.
|
DynamicContainer |
A DynamicContainer is a container generated at runtime.
|
DynamicContainerTestDescriptor |
|
DynamicDescendantFilter |
|
DynamicDescendantFilter.Mode |
|
DynamicExtensionContext |
|
DynamicNode |
DynamicNode serves as the abstract base class for a container or a
test case generated at runtime.
|
DynamicNodeTestDescriptor |
|
DynamicTest |
A DynamicTest is a test case generated at runtime.
|
DynamicTestTestDescriptor |
|
EmptyArgumentsProvider |
|
EmptySource |
@EmptySource is an ArgumentsSource which provides a single
empty argument to the annotated @ParameterizedTest method.
|
EnabledForJreRange |
|
EnabledForJreRangeCondition |
|
EnabledIf |
@EnabledIf is used to signal that the annotated test class or
test method is enabled only if the provided condition
evaluates to true .
|
EnabledIfCondition |
|
EnabledIfEnvironmentVariable |
@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.
|
EnabledIfEnvironmentVariableCondition |
|
EnabledIfEnvironmentVariables |
|
EnabledIfSystemProperties |
|
EnabledIfSystemProperty |
@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.
|
EnabledIfSystemPropertyCondition |
|
EnabledOnJre |
@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.
|
EnabledOnJreCondition |
|
EnabledOnOs |
@EnabledOnOs is used to signal that the annotated test class or
test method is only enabled on one or more specified
operating systems.
|
EnabledOnOsCondition |
|
EnableJUnit4MigrationSupport |
EnableJUnit4MigrationSupport is a class-level annotation that
enables all JUnit 4 migration support within JUnit Jupiter.
|
EnableRuleMigrationSupport |
This class-level annotation enables native JUnit 4 rule support
within JUnit Jupiter.
|
EngineDescriptor |
|
EngineDiscoveryErrorDescriptor |
Represents an error thrown by a TestEngine
during discovery.
|
EngineDiscoveryListener |
EngineDiscoveryListener contains TestEngine access to the
information necessary to discover tests and containers.
|
EngineDiscoveryOrchestrator |
Orchestrates test discovery using the configured test engines.
|
EngineDiscoveryRequest |
EngineDiscoveryRequest provides a TestEngine access to the
information necessary to discover tests and containers.
|
EngineDiscoveryRequestResolution |
|
EngineDiscoveryRequestResolver<T extends TestDescriptor> |
|
EngineDiscoveryRequestResolver.Builder<T extends TestDescriptor> |
|
EngineDiscoveryRequestResolver.DefaultInitializationContext<T extends TestDescriptor> |
|
EngineDiscoveryRequestResolver.InitializationContext<T extends TestDescriptor> |
|
EngineDiscoveryResult |
EngineDiscoveryResult encapsulates the result of test discovery by a
TestEngine .
|
EngineDiscoveryResult.Status |
|
EngineDiscoveryResultValidator |
Perform common validation checks on the result from the `discover()` method.
|
EngineExecutionContext |
Marker interface for an execution context used by a concrete implementation
of HierarchicalTestEngine and its collaborators.
|
EngineExecutionListener |
Listener to be notified of test execution events by
test engines.
|
EngineExecutionOrchestrator |
Orchestrates test execution using the configured test engines.
|
EngineFilter |
An EngineFilter is applied to all TestEngines
before they are used.
|
EngineFilter.Type |
|
EngineIdValidator |
|
EnumArgumentsProvider |
|
EnumConfigurationParameterConverter<E extends java.lang.Enum<E>> |
|
EnumSource |
|
EnumSource.Mode |
Enumeration of modes for selecting enum constants by name.
|
EnumSource.Mode.Validator |
|
EventType |
|
ExceptionUtils |
Collection of utilities for working with exceptions.
|
ExcludeClassNameFilter |
ClassNameFilter that matches fully qualified class names against
patterns in the form of regular expressions.
|
ExcludeClassNamePatterns |
@ExcludeClassNamePatterns specifies regular expressions that are used
to match against fully qualified class names when running a test suite on the
JUnit Platform.
|
ExcludeEngines |
@ExcludeEngines specifies the IDs of
TestEngines to be excluded
when running a test suite on the JUnit Platform.
|
ExcludePackageNameFilter |
PackageNameFilter that matches fully qualified package names that
are not prefixed by one of the package names provided to the filter.
|
ExcludePackages |
@ExcludePackages specifies the packages to be
excluded when running a test suite on the JUnit Platform.
|
ExcludeTags |
|
ExclusiveResource |
An exclusive resource identified by a key with a lock mode that is used to
synchronize access to shared resources when executing nodes in parallel.
|
ExclusiveResource.LockMode |
LockMode translates to the respective ReadWriteLock
locks.
|
Executable |
Executable is a functional interface that can be used to
implement any generic block of code that potentially throws a
Throwable .
|
ExecutableInvoker |
ExecutableInvoker encapsulates the invocation of a
Executable (i.e., method or constructor),
including support for dynamic resolution of method parameters via
ParameterResolvers .
|
ExecutableInvoker.ReflectiveInterceptorCall<E extends java.lang.reflect.Executable,T> |
|
ExecutableInvoker.ReflectiveInterceptorCall.VoidMethodInterceptorCall |
|
Execution |
@Execution is used to configure the parallel execution
mode of a test class or test method.
|
ExecutionCondition |
ExecutionCondition defines the Extension API for
programmatic, conditional test execution.
|
ExecutionListenerAdapter |
|
ExecutionMode |
Supported execution modes for parallel test execution.
|
ExecutionRequest |
Provides a single TestEngine access to the information necessary to
execute its tests.
|
ExpectedExceptionAdapter |
|
ExpectedExceptionSupport |
This Extension provides native support for the
ExpectedException rule from JUnit 4.
|
ExtendWith |
@ExtendWith is a repeatable annotation
that is used to register extensions for the
annotated test class or test method.
|
Extension |
Marker interface for all extensions.
|
ExtensionConfigurationException |
Thrown if an error is encountered regarding the configuration of an
extension.
|
ExtensionContext |
ExtensionContext encapsulates the context in which the
current test or container is being executed.
|
ExtensionContext.Namespace |
|
ExtensionContext.Store |
Store provides methods for extensions to save and retrieve data.
|
ExtensionContext.Store.CloseableResource |
|
ExtensionContextException |
|
ExtensionRegistrar |
An ExtensionRegistrar is used to register extensions.
|
ExtensionRegistry |
An ExtensionRegistry holds all registered extensions (i.e.
|
Extensions |
@Extensions is a container for one or more @ExtendWith
declarations.
|
ExtensionUtils |
Collection of utilities for working with extensions and the extension registry.
|
ExtensionValuesStore |
ExtensionValuesStore is used inside implementations of
ExtensionContext to store and retrieve values.
|
ExtensionValuesStore.CompositeKey |
|
ExtensionValuesStore.MemoizingSupplier |
|
ExtensionValuesStore.StoredValue |
|
ExternalResourceAdapter |
|
ExternalResourceSupport |
This Extension provides native support for subclasses of
the ExternalResource rule from JUnit 4.
|
FallbackStringToObjectConverter |
FallbackStringToObjectConverter is a DefaultArgumentConverter.StringToObjectConverter
that provides a fallback conversion strategy for converting from a
String to a given target type by invoking a static factory method
or factory constructor defined in the target type.
|
FallbackStringToObjectConverter.IsFactoryConstructor |
|
FallbackStringToObjectConverter.IsFactoryMethod |
|
FilePosition |
Position inside a file represented by line and
column numbers.
|
FilePosition |
Position inside a file represented by line and
column numbers.
|
FileSelector |
|
FileSource |
|
FileSystemSource |
|
Filter<T> |
A Filter can be applied to determine if an object should be
included or excluded in a result set.
|
Filterable |
Filterable is implemented by
TestDescriptors that may
register dynamic tests during execution and support selective test execution.
|
FilterableIgnoringRunnerDecorator |
|
FilterResult |
The result of applying a Filter .
|
ForkJoinPoolHierarchicalTestExecutorService |
|
ForkJoinPoolHierarchicalTestExecutorService.ExclusiveTask |
|
ForkJoinPoolHierarchicalTestExecutorService.WorkerThread |
|
ForkJoinPoolHierarchicalTestExecutorService.WorkerThreadFactory |
|
FunctionUtils |
Collection of utilities for working with Functions ,
Predicates , etc.
|
GenericBeforeAndAfterAdvice |
|
HierarchicalTestEngine<C extends EngineExecutionContext> |
Abstract base class for all TestEngine implementations that wish
to organize test suites hierarchically based on the Node abstraction.
|
HierarchicalTestExecutor<C extends EngineExecutionContext> |
Implementation core of all TestEngines that wish to
use the Node abstraction as the driving principle for structuring
and executing test suites.
|
HierarchicalTestExecutorService |
|
HierarchicalTestExecutorService.TestTask |
An executable task that represents a single test or container.
|
HierarchyTraversalMode |
Modes in which a hierarchy can be traversed — for example, when
searching for methods or fields within a class hierarchy.
|
IgnoreCondition |
|
IgnoringRunnerDecorator |
Decorator for Runners that will be ignored completely.
|
IncludeClassNameFilter |
ClassNameFilter that matches fully qualified class names against
patterns in the form of regular expressions.
|
IncludeClassNamePatterns |
@IncludeClassNamePatterns specifies regular expressions that are used
to match against fully qualified class names when running a test suite on the
JUnit Platform.
|
IncludeEngines |
@IncludeEngines specifies the IDs of
TestEngines to be included
when running a test suite on the JUnit Platform.
|
IncludePackageNameFilter |
PackageNameFilter that matches fully qualified package names that
are prefixed by one of the package names provided to the filter.
|
IncludePackages |
@IncludePackages specifies the packages to be
included when running a test suite on the JUnit Platform.
|
IncludeTags |
|
IndicativeSentencesGeneration |
@IndicativeSentencesGeneration is used to declare a custom parameters
by IndicativeSentences , if this notation has some not declared
parameters, it will use the default values instead.
|
InstantiatingConfigurationParameterConverter<T> |
|
InternalTestPlan |
|
InvocationInterceptor |
InvocationInterceptor defines the API for Extensions that wish to intercept calls to test code.
|
InvocationInterceptor.Invocation<T> |
An invocation that returns a result and may throw a Throwable .
|
InvocationInterceptorChain |
|
InvocationInterceptorChain.InterceptedInvocation<T> |
|
InvocationInterceptorChain.InterceptorCall<T> |
|
InvocationInterceptorChain.ValidatingInvocation<T> |
|
InvocationInterceptorChain.VoidInterceptorCall |
|
IsInnerClass |
Test if a class is a non-private inner class (i.e., a non-static nested class).
|
IsNestedTestClass |
Test if a class is a JUnit Jupiter @Nested test class.
|
Isolated |
@Isolated is used to declare that the annotated test class should be
executed in isolation from other test classes.
|
IsPotentialJUnit4TestClass |
|
IsPotentialJUnit4TestMethod |
|
IsPotentialTestContainer |
Test if a class is a potential top-level JUnit Jupiter test container, even if
it does not contain tests.
|
IsTestableMethod |
|
IsTestClassWithTests |
Test if a class is a JUnit Jupiter test class containing executable tests,
test factories, test templates, or nested tests.
|
IsTestFactoryMethod |
|
IsTestMethod |
Test if a method is a JUnit Jupiter @Test method.
|
IsTestTemplateMethod |
|
JavaTimeArgumentConverter |
|
JavaTimeConversionPattern |
@JavaTimeConversionPattern is an annotation that allows a date/time
conversion pattern to be specified on a parameter of a
@ParameterizedTest method.
|
JRE |
Enumeration of Java Runtime Environment (JRE) versions.
|
JUnit4VersionCheck |
|
JUnitException |
Base class for all RuntimeExceptions thrown
by JUnit.
|
JUnitPlatform |
JUnit 4 based Runner which runs tests on the JUnit Platform in a
JUnit 4 environment.
|
JUnitPlatformRunnerListener |
|
JUnitPlatformTestTree |
|
JupiterConfiguration |
|
JupiterEngineDescriptor |
|
JupiterEngineExecutionContext |
|
JupiterEngineExecutionContext.Builder |
|
JupiterEngineExecutionContext.State |
|
JupiterEngineExtensionContext |
|
JupiterTestDescriptor |
|
JupiterTestDescriptor.ExceptionHandlerInvoker<E extends Extension> |
|
JupiterTestEngine |
|
JupiterThrowableCollectorFactory |
|
Launcher |
The Launcher API is the main entry point for client code that
wishes to discover and execute tests using one or more
test engines.
|
LauncherConfig |
|
LauncherConfig.Builder |
|
LauncherConfigurationParameters |
|
LauncherConfigurationParameters.Builder |
|
LauncherConfigurationParameters.ParameterProvider |
|
LauncherConstants |
Collection of constants related to Launcher .
|
LauncherDiscoveryListener |
|
LauncherDiscoveryListeners |
|
LauncherDiscoveryListeners.LauncherDiscoveryListenerType |
|
LauncherDiscoveryRequest |
|
LauncherDiscoveryRequestBuilder |
|
LauncherDiscoveryResult |
Represents the result of test discovery of the configured
test engines.
|
LauncherFactory |
|
LegacyReportingUtils |
Deprecated.
|
LegacyReportingUtils |
Utility methods for dealing with legacy reporting infrastructure, such as
reporting systems built on the Ant-based XML reporting format for JUnit 4.
|
LegacyXmlReportGeneratingListener |
|
LifecycleMethodExecutionExceptionHandler |
LifecycleMethodExecutionExceptionHandler defines the API for
Extensions that wish to handle exceptions thrown during
the execution of @BeforeAll , @BeforeEach , @AfterEach ,
and @AfterAll lifecycle methods.
|
LifecycleMethodUtils |
Collection of utilities for working with test lifecycle methods.
|
LockManager |
|
Logger |
The Logger API serves as a simple logging facade for
java.util.logging (JUL).
|
LoggerFactory |
Factory for the Logger facade for JUL.
|
LoggerFactory.DelegatingLogger |
|
LoggingLauncherDiscoveryListener |
|
LoggingListener |
Simple TestExecutionListener for logging informational messages
for all events via a BiConsumer that consumes Throwable
and Supplier<String> .
|
LogRecordListener |
LogRecordListener is only intended for testing purposes within
JUnit's own test suite.
|
LruCache<K,V> |
A simple LRU cache with a maximum size.
|
MethodArgumentsProvider |
|
MethodBasedCondition<A extends java.lang.annotation.Annotation> |
|
MethodBasedTestDescriptor |
|
MethodDescriptor |
MethodDescriptor encapsulates functionality for a given Method .
|
MethodExtensionContext |
|
MethodFinder |
|
MethodInvocation<T> |
|
MethodOrderer |
MethodOrderer defines the API for ordering the test methods
in a given test class.
|
MethodOrderer.Alphanumeric |
Deprecated.
|
MethodOrderer.DisplayName |
MethodOrderer that sorts methods alphanumerically based on their
display names using String.compareTo(String)
|
MethodOrderer.MethodName |
MethodOrderer that sorts methods alphanumerically based on their
names using String.compareTo(String) .
|
MethodOrderer.OrderAnnotation |
MethodOrderer that sorts methods based on the @Order
annotation.
|
MethodOrderer.Random |
MethodOrderer that orders methods pseudo-randomly.
|
MethodOrdererContext |
MethodOrdererContext encapsulates the context in which
a MethodOrderer will be invoked.
|
MethodOrderingVisitor |
|
MethodSelector |
A DiscoverySelector that selects a Method or a combination of
class name, method name, and parameter types so that
TestEngines can discover tests
or containers based on methods.
|
MethodSelectorResolver |
|
MethodSelectorResolver |
|
MethodSelectorResolver.MethodType |
|
MethodSource |
@MethodSource is an ArgumentsSource which provides access
to values returned from factory methods of the class in
which this annotation is declared or from static factory methods in external
classes referenced by fully qualified method name.
|
MethodSource |
|
MethodSourceSupport |
Jupiter internal support for creating MethodSource from URI .
|
ModifierSupport |
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.
|
ModuleSelector |
|
ModuleUtils |
Collection of utilities for working with java.lang.Module
and friends.
|
MutableExtensionRegistry |
|
MutableTestExecutionSummary |
|
MutableTestExecutionSummary.DefaultFailure |
|
NamespaceAwareStore |
|
Nested |
@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.
|
NestedClassSelector |
A DiscoverySelector that selects a nested Class
or class name enclosed in other classes so that
TestEngines can discover
tests or containers based on classes.
|
NestedClassTestDescriptor |
TestDescriptor for tests based on nested (but not static) Java classes.
|
NestedMethodSelector |
A DiscoverySelector that selects a nested Method
or a combination of enclosing classes names, class name, method
name, and parameter types so that
TestEngines can discover
tests or containers based on methods.
|
Node<C extends EngineExecutionContext> |
A node within the execution hierarchy.
|
Node.DynamicTestExecutor |
Executor for additional, dynamic test descriptors discovered during
execution of a Node .
|
Node.ExecutionMode |
Supported execution modes for parallel execution.
|
Node.Invocation<C extends EngineExecutionContext> |
Represents an invocation that runs with the supplied context.
|
Node.SkipResult |
The result of determining whether the execution of a given context
should be skipped.
|
NodeExecutionAdvisor |
|
NodeTestTask<C extends EngineExecutionContext> |
|
NodeTestTaskContext |
|
NodeTreeWalker |
|
NodeUtils |
|
NopLock |
|
NullAndEmptySource |
|
NullArgumentsProvider |
|
NullEnum |
Dummy enum class used as default value for optional attributes of
annotations.
|
NullSource |
@NullSource is an ArgumentsSource which provides a single
null argument to the annotated @ParameterizedTest method.
|
OpenTest4JAndJUnit4AwareThrowableCollector |
Specialization of ThrowableCollector that treats instances of the
OTA's TestAbortedException and JUnit 4's
org.junit.AssumptionViolatedException as aborting.
|
OpenTest4JAwareThrowableCollector |
Specialization of ThrowableCollector that treats instances of
TestAbortedException as aborting.
|
Operator |
|
Operator.Associativity |
|
Operator.TagExpressionCreator |
|
Operators |
|
Order |
@Order is an annotation that is used to configure the
order in which the annotated element (i.e., field or
method) should be evaluated or executed relative to other elements of the
same category.
|
OrFilter |
|
OS |
Enumeration of common operating systems used for testing Java applications.
|
OutcomeDelayingEngineExecutionListener |
Delays reporting of engine skipped/finished events so that exceptions thrown
by engines can be reported to listeners.
|
OutcomeDelayingEngineExecutionListener.Outcome |
|
PackageNameFilter |
|
PackageSelector |
|
PackageSource |
|
PackageUtils |
Collection of utilities for working with packages.
|
PackageUtils.JavaNameUtils |
Collection of utilities for working with qualified names in Java.
|
ParallelExecutionConfiguration |
Configuration to use for parallel test execution.
|
ParallelExecutionConfigurationStrategy |
A strategy to use for configuring parallel test execution.
|
ParameterContext |
ParameterContext encapsulates the context in which an
Executable will be invoked for a given
Parameter .
|
ParameterizedTest |
@ParameterizedTest is used to signal that the annotated method is a
parameterized test method.
|
ParameterizedTestExtension |
|
ParameterizedTestInvocationContext |
|
ParameterizedTestMethodContext |
Encapsulates access to the parameters of a parameterized test method and
caches the converters and aggregators used to resolve them.
|
ParameterizedTestMethodContext.Aggregator |
|
ParameterizedTestMethodContext.Converter |
|
ParameterizedTestMethodContext.Resolver |
|
ParameterizedTestMethodContext.ResolverType |
|
ParameterizedTestNameFormatter |
|
ParameterizedTestParameterResolver |
|
ParameterResolutionException |
Thrown if an error is encountered in the configuration or execution of a
ParameterResolver .
|
ParameterResolver |
ParameterResolver defines the API for Extensions
that wish to dynamically resolve arguments for parameters
at runtime.
|
Parser |
|
ParseResult |
|
ParseResults |
|
ParseStatus |
|
PostDiscoveryFilter |
|
Preconditions |
Collection of utilities for asserting preconditions for method and
constructor arguments.
|
PreconditionViolationException |
Thrown if a precondition is violated.
|
PreconditionViolationException |
Deprecated.
|
PrefixedConfigurationParameters |
|
ReflectionSupport |
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.
|
ReflectionUtils |
Collection of utilities for working with the Java reflection APIs.
|
ReflectionUtils.HierarchyTraversalMode |
Modes in which a hierarchy can be traversed — for example, when
searching for methods or fields within a class hierarchy.
|
ReflectiveInvocationContext<T extends java.lang.reflect.Executable> |
ReflectiveInvocationContext encapsulates the context of
a reflective invocation of an executable (method or constructor).
|
RegisterExtension |
@RegisterExtension is used to register an Extension via a
field in a test class.
|
RepeatedTest |
|
RepeatedTestDisplayNameFormatter |
|
RepeatedTestExtension |
TestTemplateInvocationContextProvider that supports the
@RepeatedTest annotation.
|
RepeatedTestInvocationContext |
|
RepetitionInfo |
RepetitionInfo is used to inject information about the current
repetition of a repeated test into @RepeatedTest , @BeforeEach ,
and @AfterEach methods.
|
RepetitionInfoParameterResolver |
|
RepetitionInfoParameterResolver.DefaultRepetitionInfo |
|
ReportEntry |
ReportEntry encapsulates a time-stamped map of String -based
key-value pairs to be published to the reporting infrastructure.
|
ResourceAccessMode |
The access mode required by a test class or method for a given resource.
|
ResourceLock |
@ResourceLock is used to declare that the annotated test class or test
method requires access to a shared resource identified by a key.
|
ResourceLock |
A lock for a one or more resources.
|
ResourceLocks |
@ResourceLocks is a container for one or more
@ResourceLock declarations.
|
Resources |
Common resource names for synchronizing test execution.
|
ResourceUtils |
Collection of static utility methods for working with resources.
|
RunListenerAdapter |
|
RunnerDecorator |
|
RunnerExecutor |
|
RunnerRequest |
|
RunnerTestDescriptor |
|
RunnerTestDescriptor.ExcludeDescriptionFilter |
|
RunnerTestDescriptorPostProcessor |
|
RuntimeUtils |
Collection of utilities for working with Runtime ,
RuntimeMXBean , etc.
|
SameThreadHierarchicalTestExecutorService |
|
SelectClasses |
@SelectClasses specifies the classes to select when running
a test suite on the JUnit Platform.
|
SelectorResolutionResult |
|
SelectorResolutionResult.Status |
|
SelectorResolver |
|
SelectorResolver.Context |
|
SelectorResolver.Match |
|
SelectorResolver.Match.Type |
|
SelectorResolver.Resolution |
|
SelectPackages |
@SelectPackages specifies the names of packages to select
when running a test suite on the JUnit Platform.
|
ServiceLoaderPostDiscoveryFilterRegistry |
|
ServiceLoaderTestEngineRegistry |
|
ServiceLoaderTestExecutionListenerRegistry |
|
ShuntingYard |
|
SimpleArgumentConverter |
SimpleArgumentConverter is an abstract base class for ArgumentConverter
implementations.
|
SingleLock |
|
SingleTestExecutor |
Deprecated.
|
SingleTestExecutor.Executable |
|
Stack<T> |
|
StreamInterceptingTestExecutionListener |
|
StreamInterceptor |
|
StringUtils |
Collection of utilities for working with Strings ,
CharSequences , etc.
|
SuiteDisplayName |
@SuiteDisplayName is used to declare a custom
display name for the annotated test class that is executed as a test suite
on the JUnit Platform.
|
SummaryGeneratingListener |
|
Tag |
@Tag is a repeatable annotation that is
used to declare a tag for the annotated test class or test method.
|
TagExpression |
A tag expression can be evaluated against a collection of
tags to determine if they match the expression.
|
TagExpressions |
|
TagFilter |
Factory methods for creating PostDiscoveryFilters
based on included and excluded tags or tag expressions.
|
Tags |
@Tags is a container for one or more @Tag declarations.
|
TempDir |
@TempDir can be used to annotate a non-private field in a test class
or a parameter in a lifecycle method or test method of type Path or
File that should be resolved into a temporary directory.
|
TempDirectory |
TempDirectory is a JUnit Jupiter extension that creates and cleans
up temporary directories if field in a test class or a parameter in a
lifecycle method or test method is annotated with @TempDir .
|
TempDirectory.CloseablePath |
|
TempDirectory.UndeletableFileException |
|
Test |
@Test is used to signal that the annotated method is a
test method.
|
Testable |
@Testable is used to signal to IDEs and tooling vendors that the
annotated or meta-annotated element is testable.
|
TestDescriptor |
Mutable descriptor for a test or container that has been discovered by a
TestEngine .
|
TestDescriptor.Type |
|
TestDescriptor.Visitor |
|
TestEngine |
A TestEngine facilitates discovery and execution of
tests for a particular programming model.
|
TestExecutionExceptionHandler |
TestExecutionExceptionHandler defines the API for Extensions that wish to handle exceptions thrown during test execution.
|
TestExecutionListener |
Register a concrete implementation of this interface with a Launcher
to be notified of events that occur during test execution.
|
TestExecutionListenerRegistry |
|
TestExecutionListenerRegistry.EagerTestExecutionListener |
|
TestExecutionResult |
TestExecutionResult encapsulates the result of executing a single test
or container.
|
TestExecutionResult.Status |
Status of executing a single test or container.
|
TestExecutionSummary |
Summary of test plan execution.
|
TestExecutionSummary.Failure |
Failure of a test or container.
|
TestFactory |
@TestFactory is used to signal that the annotated method is a
test factory method.
|
TestFactoryTestDescriptor |
|
TestIdentifier |
Immutable data transfer object that represents a test or container which is
usually part of a TestPlan .
|
TestInfo |
TestInfo is used to inject information about the current test or
container into to @Test , @RepeatedTest ,
@ParameterizedTest , @TestFactory , @BeforeEach ,
@AfterEach , @BeforeAll , and @AfterAll methods.
|
TestInfoParameterResolver |
|
TestInfoParameterResolver.DefaultTestInfo |
|
TestInstance |
@TestInstance is a type-level annotation that is used to configure
the lifecycle of test instances for the annotated
test class or test interface.
|
TestInstance.Lifecycle |
Enumeration of test instance lifecycle modes.
|
TestInstanceFactory |
TestInstanceFactory defines the API for Extensions that wish to create test instances.
|
TestInstanceFactoryContext |
|
TestInstanceLifecycleUtils |
Collection of utilities for retrieving the test instance lifecycle mode.
|
TestInstancePostProcessor |
TestInstancePostProcessor defines the API for Extensions that wish to post-process test instances.
|
TestInstancePreDestroyCallback |
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 |
TestInstances encapsulates the test instances of a test.
|
TestInstancesProvider |
|
TestInstantiationException |
|
TestMethodOrder |
@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.
|
TestMethodTestDescriptor |
|
TestMethodTestDescriptor.CallbackInvoker<T extends Extension> |
|
TestPlan |
TestPlan describes the tree of tests and containers as discovered
by a Launcher .
|
TestReporter |
|
TestReporterParameterResolver |
|
TestRuleAnnotatedField |
|
TestRuleAnnotatedMember |
|
TestRuleAnnotatedMethod |
|
TestRuleSupport |
|
TestRun |
|
TestRun.VintageDescriptors |
|
TestSource |
Representation of the source of a test or container used to navigate to
its location by IDEs and build tools.
|
TestSourceProvider |
|
TestTag |
Immutable value object for a tag that is assigned to a test or
container.
|
TestTemplate |
@TestTemplate is used to signal that the annotated method is a
test template method.
|
TestTemplateExtensionContext |
|
TestTemplateInvocationContext |
TestTemplateInvocationContext represents the context of a
single invocation of a test
template.
|
TestTemplateInvocationContextProvider |
TestTemplateInvocationContextProvider defines the API for
Extensions that wish to provide one or multiple contexts
for the invocation of a
@TestTemplate method.
|
TestTemplateInvocationTestDescriptor |
|
TestTemplateTestDescriptor |
|
TestWatcher |
TestWatcher defines the API for Extensions that
wish to process test results.
|
ThrowableCollector |
Simple component that can be used to collect one or more instances of
Throwable .
|
ThrowableCollector.Executable |
Functional interface for an executable block of code that may throw a
Throwable .
|
ThrowableCollector.Factory |
Factory for ThrowableCollector instances.
|
ThrowingConsumer<T> |
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<T> |
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 |
@Timeout is used to define a timeout for a method or all testable
methods within one class and its @Nested classes.
|
TimeoutConfiguration |
|
TimeoutDuration |
|
TimeoutDurationParser |
|
TimeoutExtension |
|
TimeoutExtension.ExecutorResource |
|
TimeoutExtension.TimeoutProvider |
|
TimeoutInvocation<T> |
|
TimeoutInvocation.InterruptTask |
|
Token |
|
Tokenizer |
|
TokenWith<T> |
|
ToStringBuilder |
Simple builder for generating strings in custom implementations of
toString() .
|
Try<V> |
A container object which may either contain a nullable value in case of
success or an exception in case of failure.
|
Try.Failure<V> |
|
Try.Success<V> |
|
Try.Transformer<S,T> |
A transformer for values of type S to type T .
|
TypeBasedParameterResolver<T> |
|
TypedArgumentConverter<S,T> |
TypedArgumentConverter is an ArgumentConverter that
always converts a given type to another.
|
UniqueId |
UniqueId encapsulates the creation, parsing, and display of unique IDs
for TestDescriptors .
|
UniqueId.Segment |
A segment of a UniqueId comprises a type and a
value.
|
UniqueIdFilter |
|
UniqueIdFormat |
|
UniqueIdReader |
|
UniqueIdSelector |
|
UniqueIdStringifier |
|
UnrecoverableExceptions |
Internal utilities for working with unrecoverable exceptions.
|
UriSelector |
|
UriSource |
|
UseTechnicalNames |
@UseTechnicalNames specifies that technical names should be
used instead of display names when running a test suite on the
JUnit Platform.
|
ValueArgumentsProvider |
|
ValueSource |
@ValueSource is an ArgumentsSource which provides access to
an array of literal values.
|
VerifierAdapter |
|
VerifierSupport |
This Extension provides native support for subclasses of
the Verifier rule from JUnit 4.
|
VintageDiscoverer |
|
VintageEngineDescriptor |
|
VintageTestDescriptor |
|
VintageTestEngine |
|
XmlReportData |
|
XmlReportWriter |
XmlReportWriter writes an XML report whose format is compatible
with the de facto standard for JUnit 4 based test reports that was made
popular by the Ant build system.
|
XmlReportWriter.TestCounts |
|