All Classes and Interfaces

Class	Description
AbstractBindingResultAssert<SELF extends AbstractBindingResultAssert<SELF>>	AssertJ assertions that can be applied to BindingResult.
AbstractContextLoader	Abstract application context loader that provides a basis for all concrete implementations of the ContextLoader SPI.
AbstractDelegatingSmartContextLoader	AbstractDelegatingSmartContextLoader serves as an abstract base class for implementations of the SmartContextLoader SPI that delegate to a set of candidate SmartContextLoaders (i.e., one that supports XML configuration files or Groovy scripts and one that supports annotated classes) to determine which context loader is appropriate for a given test class's configuration.
AbstractDirtiesContextTestExecutionListener	Abstract base class for TestExecutionListener implementations that provide support for marking the ApplicationContext associated with a test as dirty for both test classes and test methods annotated with the @DirtiesContext annotation.
AbstractGenericContextLoader	Abstract, generic extension of AbstractContextLoader that loads a GenericApplicationContext.
AbstractGenericWebContextLoader	Abstract, generic extension of AbstractContextLoader that loads a GenericWebApplicationContext.
AbstractHttpServletRequestAssert<SELF extends AbstractHttpServletRequestAssert<SELF,ACTUAL>,ACTUAL extends HttpServletRequest>	Base AssertJ assertions that can be applied to an HttpServletRequest.
AbstractHttpServletResponseAssert<R extends HttpServletResponse,SELF extends AbstractHttpServletResponseAssert<R,SELF,ACTUAL>,ACTUAL>	Base AssertJ assertions that can be applied to any object that provides an HttpServletResponse.
AbstractJsonContentAssert<SELF extends AbstractJsonContentAssert<SELF>>	Base AssertJ assertions that can be applied to a JSON document.
AbstractJsonValueAssert<SELF extends AbstractJsonValueAssert<SELF>>	Base AssertJ assertions that can be applied to a JSON value.
AbstractJUnit4SpringContextTests	Abstract base test class which integrates the Spring TestContext Framework with explicit ApplicationContext testing support in a JUnit 4 environment.
AbstractMockHttpServletRequestAssert<SELF extends AbstractMockHttpServletRequestAssert<SELF>>	AssertJ assertions that can be applied to MockHttpServletRequest.
AbstractMockHttpServletRequestBuilder<B extends AbstractMockHttpServletRequestBuilder<B>>	Base builder for MockHttpServletRequest required as input to perform requests in MockMvc.
AbstractMockHttpServletResponseAssert<SELF extends AbstractMockHttpServletResponseAssert<SELF,ACTUAL>,ACTUAL>	Extension of AbstractHttpServletResponseAssert for MockHttpServletResponse.
AbstractMockMultipartHttpServletRequestBuilder<B extends AbstractMockMultipartHttpServletRequestBuilder<B>>	Base builder for MockMultipartHttpServletRequest.
AbstractMockMvcBuilder<B extends AbstractMockMvcBuilder<B>>	Abstract implementation of MockMvcBuilder with common methods for configuring filters, default request properties, global expectations and global result actions.
AbstractRequestExpectationManager	Base class for RequestExpectationManager implementations responsible for storing expectations and actual requests, and checking for unsatisfied expectations at the end.
AbstractRequestExpectationManager.RequestExpectationGroup	Helper class to manage a group of remaining expectations.
AbstractTestContextBootstrapper	Abstract implementation of the TestContextBootstrapper interface which provides most of the behavior required by a bootstrapper.
AbstractTestExecutionListener	Abstract ordered implementation of the TestExecutionListener API.
AbstractTestNGSpringContextTests	Abstract base test class which integrates the Spring TestContext Framework with explicit ApplicationContext testing support in a TestNG environment.
AbstractTransactionalJUnit4SpringContextTests	Abstract transactional extension of AbstractJUnit4SpringContextTests which adds convenience functionality for JDBC access.
AbstractTransactionalTestNGSpringContextTests	Abstract transactional extension of AbstractTestNGSpringContextTests which adds convenience functionality for JDBC access.
ActiveProfiles	ActiveProfiles is an annotation that can be applied to a test class to declare which active bean definition profiles should be used when loading an ApplicationContext for integration tests.
ActiveProfilesResolver	Strategy interface for programmatically resolving which active bean definition profiles should be used when loading an ApplicationContext for a test class.
AfterTestClass	@EventListener annotation used to consume an AfterTestClassEvent published by the EventPublishingTestExecutionListener.
AfterTestClassEvent	TestContextEvent published by the EventPublishingTestExecutionListener when TestExecutionListener.afterTestClass(TestContext) is invoked.
AfterTestExecution	@EventListener annotation used to consume an AfterTestExecutionEvent published by the EventPublishingTestExecutionListener.
AfterTestExecutionEvent	TestContextEvent published by the EventPublishingTestExecutionListener when TestExecutionListener.afterTestExecution(TestContext) is invoked.
AfterTestMethod	@EventListener annotation used to consume an AfterTestMethodEvent published by the EventPublishingTestExecutionListener.
AfterTestMethodEvent	TestContextEvent published by the EventPublishingTestExecutionListener when TestExecutionListener.afterTestMethod(TestContext) is invoked.
AfterTransaction	Test annotation which indicates that the annotated void method should be executed after a transaction is ended for a test method configured to run within a transaction via Spring's @Transactional annotation.
AnnotationConfigContextLoader	Concrete implementation of AbstractGenericContextLoader that loads bean definitions from component classes.
AnnotationConfigContextLoaderUtils	Utility methods for SmartContextLoaders that deal with component classes (for example, @Configuration classes).
AnnotationConfigWebContextLoader	Concrete implementation of AbstractGenericWebContextLoader that loads bean definitions from annotated classes.
AopTestUtils	AopTestUtils is a collection of AOP-related utility methods for use in unit and integration testing scenarios.
AotContextLoader	Strategy interface for loading an ApplicationContext for build-time AOT processing as well as run-time AOT execution for an integration test managed by the Spring TestContext Framework.
AotTestAttributes	Holder for metadata specific to ahead-of-time (AOT) support in the Spring TestContext Framework.
AotTestContextInitializers	AotTestContextInitializers provides mappings from test classes to AOT-optimized context initializers.
AotTestExecutionListener	AotTestExecutionListener is an extension of the TestExecutionListener SPI that allows a listener to optionally provide ahead-of-time (AOT) support.
ApplicationContextFailureProcessor	Strategy for components that process failures related to application contexts within the Spring TestContext Framework.
ApplicationEvents	ApplicationEvents encapsulates all application events that were fired during the execution of a single test method.
ApplicationEventsHolder	Holder class to expose the application events published during the execution of a test in the form of a thread-bound ApplicationEvents object.
ApplicationEventsTestExecutionListener	TestExecutionListener which provides support for ApplicationEvents.
AssertionErrors	Test assertions that are independent of any third-party assertion library.
BeanOverride	Mark a composed annotation as eligible for Bean Override processing.
BeanOverrideHandler	Handler for Bean Override injection points that is responsible for creating the bean override instance for a given set of metadata and potentially for tracking the created instance.
BeanOverrideProcessor	Strategy interface for Bean Override processing, which creates BeanOverrideHandler instances that drive how target beans are overridden.
BeanOverrideStrategy	Strategies for bean override processing.
BeanOverrideTestExecutionListener	TestExecutionListener that enables @BeanOverride support in tests, by injecting overridden beans in appropriate fields of the test instance.
BeforeTestClass	@EventListener annotation used to consume a BeforeTestClassEvent published by the EventPublishingTestExecutionListener.
BeforeTestClassEvent	TestContextEvent published by the EventPublishingTestExecutionListener when TestExecutionListener.beforeTestClass(TestContext) is invoked.
BeforeTestExecution	@EventListener annotation used to consume a BeforeTestExecution published by the EventPublishingTestExecutionListener.
BeforeTestExecutionEvent	TestContextEvent published by the EventPublishingTestExecutionListener when TestExecutionListener.beforeTestExecution(TestContext) is invoked.
BeforeTestMethod	@EventListener annotation used to consume a BeforeTestMethodEvent published by the EventPublishingTestExecutionListener.
BeforeTestMethodEvent	TestContextEvent published by the EventPublishingTestExecutionListener when TestExecutionListener.beforeTestMethod(TestContext) is invoked.
BeforeTransaction	Test annotation which indicates that the annotated void method should be executed before a transaction is started for a test method configured to run within a transaction via Spring's @Transactional annotation.
BootstrapContext	BootstrapContext encapsulates the context in which the Spring TestContext Framework is bootstrapped.
BootstrapUtils	BootstrapUtils is a collection of utility methods to assist with bootstrapping the Spring TestContext Framework.
BootstrapWith	@BootstrapWith is an annotation that can be applied to a test class to define metadata that is used to determine how to bootstrap the Spring TestContext Framework.
CacheAwareContextLoaderDelegate	A CacheAwareContextLoaderDelegate is responsible for loading and closing application contexts, interacting transparently with a ContextCache behind the scenes.
Commit	@Commit is a test annotation that is used to indicate that a test-managed transaction should be committed after the test method has completed.
CommonCachesTestExecutionListener	TestExecutionListener which makes sure that common caches are cleared once they are no longer required.
ConfigurableMockMvcBuilder<B extends ConfigurableMockMvcBuilder<B>>	Defines common methods for building a MockMvc.
ConfigurableSmartRequestBuilder<B extends ConfigurableSmartRequestBuilder<B>>	An extension of SmartRequestBuilder that can be configured with RequestPostProcessors.
ContentRequestMatchers	Factory for request content RequestMatcher's.
ContentResultMatchers	Factory for response content assertions.
ContextCache	ContextCache defines the SPI for caching Spring ApplicationContexts within the Spring TestContext Framework.
ContextCacheUtils	Collection of utilities for working with context caching.
ContextConfiguration	@ContextConfiguration is an annotation that can be applied to a test class to define metadata that is used to determine how to load and configure an ApplicationContext for integration tests.
ContextConfigurationAttributes	ContextConfigurationAttributes encapsulates the context configuration attributes declared via @ContextConfiguration.
ContextCustomizer	Strategy interface for customizing application contexts that are created and managed by the Spring TestContext Framework.
ContextCustomizerFactories	@ContextCustomizerFactories is an annotation that can be applied to a test class to configure which ContextCustomizerFactory implementations should be registered with the Spring TestContext Framework.
ContextCustomizerFactories.MergeMode	Enumeration of modes that dictate whether explicitly declared factories are merged with the default factories when @ContextCustomizerFactories is declared on a class that does not inherit factories from a superclass or enclosing class.
ContextCustomizerFactory	Factory for creating ContextCustomizers.
ContextHierarchy	@ContextHierarchy is an annotation that can be applied to a test class to define a hierarchy of ApplicationContexts for integration tests.
ContextLoader	Strategy interface for loading an ApplicationContext for an integration test managed by the Spring TestContext Framework.
ContextLoadException	Exception thrown when an error occurs while a SmartContextLoader attempts to load an ApplicationContext.
CookieAssertions	Assertions on cookies of the response.
CookieMapAssert	AssertJ assertions that can be applied to cookies.
CookieResultMatchers	Factory for response cookie assertions.
DefaultActiveProfilesResolver	Default implementation of the ActiveProfilesResolver strategy that resolves active bean definition profiles based solely on profiles configured declaratively via ActiveProfiles.profiles() or ActiveProfiles.value().
DefaultBootstrapContext	Default implementation of the BootstrapContext interface.
DefaultCacheAwareContextLoaderDelegate	Default implementation of the CacheAwareContextLoaderDelegate strategy.
DefaultContextCache	Default implementation of the ContextCache API.
DefaultMockMvcBuilder	A concrete implementation of AbstractMockMvcBuilder that provides the WebApplicationContext supplied to it as a constructor argument.
DefaultRequestExpectation	Default implementation of RequestExpectation that simply delegates to the request matchers and the response creator it contains.
DefaultRequestExpectation.RequestCount	Helper class that keeps track of actual vs expected request count.
DefaultResponseCreator	A ResponseCreator with builder-style methods for adding response details.
DefaultTestContext	Default implementation of the TestContext interface.
DefaultTestContextBootstrapper	Default implementation of the TestContextBootstrapper SPI.
DelegatingServletInputStream	Delegating implementation of ServletInputStream.
DelegatingServletOutputStream	Delegating implementation of ServletOutputStream.
DelegatingSmartContextLoader	DelegatingSmartContextLoader is a concrete implementation of AbstractDelegatingSmartContextLoader that delegates to a GenericXmlContextLoader (or a GenericGroovyXmlContextLoader if Groovy is present in the classpath) and an AnnotationConfigContextLoader.
DelegatingWebConnection	Implementation of WebConnection that allows delegating to various WebConnection implementations.
DelegatingWebConnection.DelegateWebConnection	The delegate web connection.
DependencyInjectionTestExecutionListener	TestExecutionListener which provides support for dependency injection and initialization of test instances.
DirtiesContext	Test annotation which indicates that the ApplicationContext associated with a test is dirty and should therefore be closed and removed from the context cache.
DirtiesContext.ClassMode	Defines modes which determine how @DirtiesContext is interpreted when used to annotate a test class.
DirtiesContext.HierarchyMode	Defines modes which determine how the context cache is cleared when @DirtiesContext is used in a test whose context is configured as part of a hierarchy via @ContextHierarchy.
DirtiesContext.MethodMode	Defines modes which determine how @DirtiesContext is interpreted when used to annotate a test method.
DirtiesContextBeforeModesTestExecutionListener	TestExecutionListener which provides support for marking the ApplicationContext associated with a test as dirty for both test classes and test methods annotated with the @DirtiesContext annotation.
DirtiesContextTestExecutionListener	TestExecutionListener which provides support for marking the ApplicationContext associated with a test as dirty for both test classes and test methods annotated with the @DirtiesContext annotation.
DisabledIf	@DisabledIf is used to signal that the annotated test class or test method is disabled and should not be executed if the supplied DisabledIf.expression() evaluates to true.
DisabledIfCondition	DisabledIfCondition is an ExecutionCondition that supports the @DisabledIf annotation when using the Spring TestContext Framework in conjunction with JUnit 5's Jupiter programming model.
DisabledInAotMode	@DisabledInAotMode signals that the annotated test class is disabled in Spring AOT (ahead-of-time) mode, which means that the ApplicationContext for the test class will not be processed for AOT optimizations at build time.
DispatcherServletCustomizer	Strategy interface for customizing DispatcherServlet instances that are managed by MockMvc.
DynamicPropertyRegistrar	Registrar that is used to add properties with dynamically resolved values to the Environment via a DynamicPropertyRegistry.
DynamicPropertyRegistrarBeanInitializer	BeanFactoryInitializer that eagerly initializes DynamicPropertyRegistrar beans.
DynamicPropertyRegistry	Registry that is used to add properties with dynamically resolved values to the Environment.
DynamicPropertySource	@DynamicPropertySource is an annotation that can be applied to static methods in integration test classes in order to add properties with dynamic values to the Environment's set of PropertySources.
EnabledIf	@EnabledIf is used to signal that the annotated test class or test method is enabled and should be executed if the supplied EnabledIf.expression() evaluates to true.
EnabledIfCondition	EnabledIfCondition is an ExecutionCondition that supports the @EnabledIf annotation when using the Spring TestContext Framework in conjunction with JUnit 5's Jupiter programming model.
EntityExchangeResult<T>	ExchangeResult sub-class that exposes the response body fully extracted to a representation of type <T>.
EventPublishingTestExecutionListener	TestExecutionListener that publishes test execution events to the ApplicationContext for the currently executing test.
ExceptionCollector	ExceptionCollector is a test utility for executing code blocks, collecting exceptions, and generating a single AssertionError containing any exceptions encountered as suppressed exceptions.
ExceptionCollector.Executable	Executable is a functional interface that can be used to implement any generic block of code that potentially throws a Throwable.
ExchangeResult	Container for request and response details for exchanges performed through WebTestClient.
ExecutingResponseCreator	ResponseCreator that obtains the response by executing the request through a ClientHttpRequestFactory.
ExpectedCount	A simple type representing a range for an expected count.
FlashAttributeResultMatchers	Factory for "output" flash attribute assertions.
FluxExchangeResult<T>	ExchangeResult variant with the response body decoded as Flux<T> but not yet consumed.
GenericGroovyXmlContextLoader	Concrete implementation of AbstractGenericContextLoader that reads bean definitions from Groovy scripts and XML configuration files.
GenericGroovyXmlWebContextLoader	Concrete implementation of AbstractGenericWebContextLoader that loads bean definitions from Groovy scripts and XML configuration files.
GenericXmlContextLoader	Concrete implementation of AbstractGenericContextLoader that reads bean definitions from XML resources.
GenericXmlWebContextLoader	Concrete implementation of AbstractGenericWebContextLoader that loads bean definitions from XML resources.
HandlerResultAssert	AssertJ assertions that can be applied to a handler or handler method.
HandlerResultMatchers	Factory for assertions on the selected handler or handler method.
HeaderAssertions	Assertions on headers of the response.
HeaderResultMatchers	Factory for response header assertions.
HostRequestMatcher	A WebRequestMatcher that allows matching on the host and optionally the port of WebRequest#getUrl().
HttpHandlerConnector	Connector that handles requests by invoking an HttpHandler rather than making actual requests to a network socket.
HttpHandlerConnector.FailureAfterResponseCompletedException	Indicates that an error occurred after the server response was completed, via ReactiveHttpOutputMessage.writeWith(org.reactivestreams.Publisher<? extends org.springframework.core.io.buffer.DataBuffer>) or ReactiveHttpOutputMessage.setComplete(), and can no longer be changed.
HttpHeadersAssert	AssertJ assertions that can be applied to HttpHeaders.
HttpMessageContentConverter	Convert HTTP message content for testing purposes.
IfProfileValue	Test annotation for use with JUnit 4 to indicate whether the annotated test class or test method is enabled or disabled for a specific testing profile.
JdbcTestUtils	JdbcTestUtils is a collection of JDBC related utility functions intended to simplify standard database testing scenarios.
JsonAssert	Useful methods that can be used with org.skyscreamer.jsonassert.
JsonComparator	Strategy interface used to compare JSON strings.
JsonCompareMode	Modes that can be used to compare JSON.
JsonComparison	A comparison of two JSON strings as returned from a JsonComparator.
JsonComparison.Result	Comparison results.
JsonContent	JSON content which is generally used to provide JsonContentAssert to AssertJ assertThat calls.
JsonContentAssert	Default AbstractJsonContentAssert implementation.
JsonExpectationsHelper	Deprecated. in favor of using JSONAssert directly or the JsonComparator abstraction
JsonPathAssertions	JsonPath assertions.
JsonPathExpectationsHelper	A helper class for applying assertions via JSON path expressions.
JsonPathRequestMatchers	Factory for assertions on the request content using JsonPath expressions.
JsonPathResultMatchers	Factory for assertions on the response content using JsonPath expressions.
JsonPathValueAssert	AssertJ assertions that can be applied to a JSON value produced by evaluating a JSON path expression.
MediaTypeAssert	AssertJ assertions that can be applied to a MediaType.
MergedContextConfiguration	MergedContextConfiguration encapsulates the merged context configuration declared on a test class and all of its superclasses and enclosing classes via @ContextConfiguration, @ActiveProfiles, and @TestPropertySource.
MethodAssert	AssertJ assertions that can be applied to a Method.
MethodInvoker	MethodInvoker defines a generic API for invoking a Method within the Spring TestContext Framework.
MockAsyncContext	Mock implementation of the AsyncContext interface.
MockBodyContent	Mock implementation of the BodyContent class.
MockClientHttpRequest	Mock implementation of ClientHttpRequest.
MockClientHttpRequest	Mock implementation of ClientHttpRequest.
MockClientHttpResponse	Mock implementation of ClientHttpResponse.
MockClientHttpResponse	Mock implementation of ClientHttpResponse.
MockCookie	Extension of Cookie with extra attributes, as defined in RFC 6265.
MockEnvironment	Simple ConfigurableEnvironment implementation exposing MockEnvironment.setProperty(java.lang.String, java.lang.Object) and MockEnvironment.withProperty(java.lang.String, java.lang.Object) methods for testing purposes.
MockFilterChain	Mock implementation of the FilterChain interface.
MockFilterConfig	Mock implementation of the FilterConfig interface.
MockFilterRegistration	Mock implementation of FilterRegistration.
MockHttpInputMessage	Mock implementation of HttpInputMessage.
MockHttpOutputMessage	Mock implementation of HttpOutputMessage.
MockHttpServletMapping	Mock implementation of HttpServletMapping.
MockHttpServletRequest	Mock implementation of the HttpServletRequest interface.
MockHttpServletRequestBuilder	Default builder for MockHttpServletRequest required as input to perform requests in MockMvc.
MockHttpServletResponse	Mock implementation of the HttpServletResponse interface.
MockHttpSession	Mock implementation of the HttpSession interface.
MockitoBean	@MockitoBean is an annotation that can be used in test classes to override a bean in the test's ApplicationContext with a Mockito mock.
MockitoBeans	Container for @MockitoBean annotations which allows @MockitoBean to be used as a repeatable annotation at the type level — for example, on test classes or interfaces implemented by test classes.
MockitoResetTestExecutionListener	TestExecutionListener that resets any mock beans that have been marked with a MockReset.
MockitoSpyBean	@MockitoSpyBean is an annotation that can be used in test classes to override a bean in the test's ApplicationContext with a Mockito spy that wraps the original bean instance.
MockitoSpyBeans	Container for @MockitoSpyBean annotations which allows @MockitoSpyBean to be used as a repeatable annotation at the type level — for example, on test classes or interfaces implemented by test classes.
MockJspWriter	Mock implementation of the JspWriter class.
MockMultipartFile	Mock implementation of the MultipartFile interface.
MockMultipartHttpServletRequest	Mock implementation of the MultipartHttpServletRequest interface.
MockMultipartHttpServletRequestBuilder	Default builder for MockMultipartHttpServletRequest.
MockMvc	Main entry point for server-side Spring MVC test support.
MockMvcBuilder	Builds a MockMvc instance.
MockMvcBuilders	The main class to import in order to access all available MockMvcBuilders.
MockMvcBuilderSupport	Base class for MockMvc builder implementations, providing the capability to create a MockMvc instance.
MockMvcClientHttpRequestFactory	A ClientHttpRequestFactory for requests executed via MockMvc.
MockMvcConfigurer	Contract for customizing a ConfigurableMockMvcBuilder in some specific way, for example, a 3rd party library that wants to provide shortcuts for setting up a MockMvc.
MockMvcConfigurerAdapter	An empty method implementation of MockMvcConfigurer.
MockMvcHtmlUnitDriverBuilder	MockMvcHtmlUnitDriverBuilder simplifies the building of an HtmlUnitDriver that delegates to MockMvc and optionally delegates to an actual connection for specific requests.
MockMvcHttpConnector	Connector that handles requests by invoking a MockMvc rather than making actual requests over HTTP.
MockMvcRequestBuilders	Static factory methods for RequestBuilders.
MockMvcResultHandlers	Static factory methods for ResultHandler-based result actions.
MockMvcResultMatchers	Static factory methods for ResultMatcher-based result actions.
MockMvcTester	MockMvcTester provides support for testing Spring MVC applications with MockMvc for server request handling using AssertJ.
MockMvcWebClientBuilder	MockMvcWebClientBuilder simplifies the creation of an HtmlUnit WebClient that delegates to a MockMvc instance.
MockMvcWebConnection	MockMvcWebConnection enables MockMvc to transform a WebRequest into a WebResponse.
MockMvcWebConnectionBuilderSupport<T extends MockMvcWebConnectionBuilderSupport<T>>	Support class that simplifies the creation of a WebConnection that uses MockMvc and optionally delegates to a real WebConnection for specific requests.
MockMvcWebTestClient	The main class for testing Spring MVC applications via WebTestClient with MockMvc for server request handling.
MockMvcWebTestClient.ControllerSpec	Specification for configuring MockMvc to test one or more controllers directly, and a simple facade around StandaloneMockMvcBuilder.
MockMvcWebTestClient.MockMvcServerSpec<B extends MockMvcWebTestClient.MockMvcServerSpec<B>>	Base specification for configuring MockMvc, and a simple facade around ConfigurableMockMvcBuilder.
MockMvcWebTestClient.RouterFunctionSpec	Specification for configuring MockMvc to test one or more router functions directly, and a simple facade around RouterFunctionMockMvcBuilder.
MockPageContext	Mock implementation of the PageContext interface.
MockPart	Mock implementation of jakarta.servlet.http.Part.
MockPropertySource	Simple PropertySource implementation for use in testing.
MockRequestDispatcher	Mock implementation of the RequestDispatcher interface.
MockReset	Reset strategy used on a mock bean.
MockRestRequestMatchers	Static factory methods for RequestMatcher classes.
MockRestResponseCreators	Static factory methods to obtain a ResponseCreator with a fixed response.
MockRestServiceServer	Main entry point for client-side REST testing.
MockRestServiceServer.MockRestServiceServerBuilder	Builder to create a MockRestServiceServer.
MockServerClientHttpResponse	Simple ClientHttpResponse extension that also exposes a result object from the underlying mock server exchange for further assertions on the state of the server response after the request is performed.
MockServerConfigurer	Contract that frameworks or applications can use to pre-package a set of customizations to a WebTestClient.MockServerSpec and expose that as a shortcut.
MockServerHttpRequest	Mock extension of AbstractServerHttpRequest for use in tests without an actual server.
MockServerHttpRequest.BaseBuilder<B extends MockServerHttpRequest.BaseBuilder<B>>	Request builder exposing properties not related to the body.
MockServerHttpRequest.BodyBuilder	A builder that adds a body to the request.
MockServerHttpResponse	Mock extension of AbstractServerHttpResponse for use in tests without an actual server.
MockServerRequest	Mock implementation of ServerRequest.
MockServerRequest.Builder	Builder for MockServerRequest.
MockServerWebExchange	Extension of DefaultServerWebExchange for use in tests, along with MockServerHttpRequest and MockServerHttpResponse.
MockServerWebExchange.Builder	Builder for a MockServerWebExchange.
MockServletConfig	Mock implementation of the ServletConfig interface.
MockServletContext	Mock implementation of the ServletContext interface.
MockSessionCookieConfig	Mock implementation of the SessionCookieConfig interface.
MockWebSession	Implementation of WebSession that delegates to a session instance obtained via InMemoryWebSessionStore.
ModelAndViewAssert	A collection of assertions intended to simplify testing scenarios dealing with Spring Web MVC ModelAndView objects.
ModelAssert	AssertJ assertions that can be applied to a model.
ModelResultMatchers	Factory for assertions on the model.
MvcResult	Provides access to the result of an executed request.
MvcTestResult	Provides the result of an executed request using MockMvcTester that is meant to be used with assertThat.
MvcTestResultAssert	AssertJ assertions that can be applied to MvcTestResult.
NestedTestConfiguration	@NestedTestConfiguration is an annotation that can be applied to a test class to configure how Spring test configuration annotations are processed within enclosing class hierarchies (i.e., for inner test classes).
NestedTestConfiguration.EnclosingConfiguration	Enumeration of modes that dictate how test configuration from enclosing classes is processed for inner test classes.
PassThroughFilterChain	Implementation of the FilterChain interface which simply passes the call through to a given Filter/FilterChain combination (indicating the next Filter in the chain along with the FilterChain that it is supposed to work on) or to a given Servlet (indicating the end of the chain).
PrepareTestInstance	@EventListener annotation used to consume a PrepareTestInstanceEvent published by the EventPublishingTestExecutionListener.
PrepareTestInstanceEvent	TestContextEvent published by the EventPublishingTestExecutionListener when TestExecutionListener.prepareTestInstance(TestContext) is invoked.
PrintingResultHandler	Result handler that prints MvcResult details to a given output stream — for example: System.out, System.err, a custom java.io.PrintWriter, etc.
PrintingResultHandler.ResultValuePrinter	A contract for how to actually write result information.
ProfileValueChecker	ProfileValueChecker is a custom JUnit Statement that checks whether a test class or test method is enabled in the current environment via Spring's @IfProfileValue annotation.
ProfileValueSource	Strategy interface for retrieving profile values for a given testing environment.
ProfileValueSourceConfiguration	ProfileValueSourceConfiguration is an annotation that can be applied to a JUnit 4 based test class to specify what type of ProfileValueSource to use when retrieving profile values configured via @IfProfileValue.
ProfileValueUtils	General utility methods for working with profile values.
PropertyProvider	Strategy for providing named properties — for example, for looking up key-value pairs in a generic fashion.
RecordApplicationEvents	@RecordApplicationEvents is an annotation that can be applied to a test class to instruct the Spring TestContext Framework to record all application events that are published in the ApplicationContext during the execution of a single test, either from the test thread or its descendants.
ReflectionTestUtils	ReflectionTestUtils is a collection of reflection-based utility methods for use in unit and integration testing scenarios.
Repeat	Test annotation for use with JUnit 4 to indicate that a test method should be invoked repeatedly.
RequestBuilder	Builds a MockHttpServletRequest.
RequestExpectation	An extension of ResponseActions that also implements RequestMatcher and ResponseCreator
RequestExpectationManager	Encapsulates the behavior required to implement MockRestServiceServer including its public API (create expectations + verify/reset) along with an extra method for verifying actual requests.
RequestMatcher	A contract for matching requests to expectations.
RequestPostProcessor	Extension point for applications or 3rd party libraries that wish to further initialize a MockHttpServletRequest instance after it has been built by MockHttpServletRequestBuilder or its subclass MockMultipartHttpServletRequestBuilder.
RequestResultMatchers	Factory for assertions on the request.
ResponseActions	A contract for setting up request expectations and defining a response.
ResponseCreator	A contract for creating a ClientHttpResponse.
ResultActions	Allows applying actions, such as expectations, on the result of an executed request.
ResultHandler	A ResultHandler performs a generic action on the result of an executed request — for example, printing debug information.
ResultMatcher	A ResultMatcher matches the result of an executed request against some expectation.
Rollback	@Rollback is a test annotation that is used to indicate whether a test-managed transaction should be rolled back after the test method has completed.
RouterFunctionMockMvcBuilder	A MockMvcBuilder that accepts RouterFunction registrations thus allowing full control over the instantiation and initialization of router functions and their dependencies similar to plain unit tests, and also making it possible to test one function at a time.
RunAfterTestClassCallbacks	RunAfterTestClassCallbacks is a custom JUnit Statement which allows the Spring TestContext Framework to be plugged into the JUnit execution chain by calling afterTestClass() on the supplied TestContextManager.
RunAfterTestExecutionCallbacks	RunAfterTestExecutionCallbacks is a custom JUnit Statement which allows the Spring TestContext Framework to be plugged into the JUnit 4 execution chain by calling afterTestExecution() on the supplied TestContextManager.
RunAfterTestMethodCallbacks	RunAfterTestMethodCallbacks is a custom JUnit Statement which allows the Spring TestContext Framework to be plugged into the JUnit execution chain by calling afterTestMethod() on the supplied TestContextManager.
RunBeforeTestClassCallbacks	RunBeforeTestClassCallbacks is a custom JUnit Statement which allows the Spring TestContext Framework to be plugged into the JUnit execution chain by calling beforeTestClass() on the supplied TestContextManager.
RunBeforeTestExecutionCallbacks	RunBeforeTestExecutionCallbacks is a custom JUnit Statement which allows the Spring TestContext Framework to be plugged into the JUnit 4 execution chain by calling beforeTestExecution() on the supplied TestContextManager.
RunBeforeTestMethodCallbacks	RunBeforeTestMethodCallbacks is a custom JUnit Statement which allows the Spring TestContext Framework to be plugged into the JUnit execution chain by calling beforeTestMethod() on the supplied TestContextManager.
RunPrepareTestInstanceCallbacks	RunPrepareTestInstanceCallbacks is a custom JUnit Statement which allows the Spring TestContext Framework to be plugged into the JUnit execution chain by calling prepareTestInstance() on the supplied TestContextManager.
ServletTestExecutionListener	TestExecutionListener which provides mock Servlet API support to WebApplicationContexts loaded by the Spring TestContext Framework.
SharedHttpSessionConfigurer	MockMvcConfigurer that stores and re-uses the HTTP session across multiple requests performed through the same MockMvc instance.
SimpleRequestExpectationManager	Simple RequestExpectationManager that matches requests to expectations sequentially, i.e.
SmartContextLoader	Strategy interface for loading an ApplicationContext for an integration test managed by the Spring TestContext Framework.
SmartRequestBuilder	Extended variant of a RequestBuilder that applies its org.springframework.test.web.servlet.request.RequestPostProcessors as a separate step from the RequestBuilder.buildRequest(jakarta.servlet.ServletContext) method.
SpringClassRule	SpringClassRule is a custom JUnit TestRule that supports class-level features of the Spring TestContext Framework in standard JUnit tests by means of the TestContextManager and associated support classes and annotations.
SpringExtension	SpringExtension integrates the Spring TestContext Framework into JUnit 5's Jupiter programming model.
SpringFailOnTimeout	SpringFailOnTimeout is a custom JUnit Statement which adds support for Spring's @Timed annotation by throwing an exception if the next statement in the execution chain takes more than the specified number of milliseconds.
SpringJUnit4ClassRunner	SpringJUnit4ClassRunner is a custom extension of JUnit's BlockJUnit4ClassRunner which provides functionality of the Spring TestContext Framework to standard JUnit tests by means of the TestContextManager and associated support classes and annotations.
SpringJUnitConfig	@SpringJUnitConfig is a composed annotation that combines @ExtendWith(SpringExtension.class) from JUnit Jupiter with @ContextConfiguration from the Spring TestContext Framework.
SpringJUnitWebConfig	@SpringJUnitWebConfig is a composed annotation that combines @ExtendWith(SpringExtension.class) from JUnit Jupiter with @ContextConfiguration and @WebAppConfiguration from the Spring TestContext Framework.
SpringMethodRule	SpringMethodRule is a custom JUnit 4 MethodRule that supports instance-level and method-level features of the Spring TestContext Framework in standard JUnit tests by means of the TestContextManager and associated support classes and annotations.
SpringMockResolver	A MockResolver for testing Spring applications with Mockito.
SpringRepeat	SpringRepeat is a custom JUnit Statement which adds support for Spring's @Repeat annotation by repeating the test the specified number of times.
SpringRunner	SpringRunner is an alias for the SpringJUnit4ClassRunner.
Sql	@Sql is used to annotate a test class or test method to configure SQL Sql.scripts() and Sql.statements() to be executed against a given database during integration tests.
Sql.ExecutionPhase	Enumeration of phases that dictate when SQL scripts are executed.
SqlConfig	@SqlConfig defines metadata that is used to determine how to parse and execute SQL scripts configured via the @Sql annotation.
SqlConfig.ErrorMode	Enumeration of modes that dictate how errors are handled while executing SQL statements.
SqlConfig.TransactionMode	Enumeration of modes that dictate whether SQL scripts should be executed within a transaction and what the transaction propagation behavior should be.
SqlGroup	Container annotation that aggregates several @Sql annotations.
SqlMergeMode	@SqlMergeMode is used to annotate a test class or test method to configure whether method-level @Sql declarations are merged with class-level @Sql declarations.
SqlMergeMode.MergeMode	Enumeration of modes that dictate whether method-level @Sql declarations are merged with class-level @Sql declarations.
SqlScriptsTestExecutionListener	TestExecutionListener that provides support for executing SQL scripts and inlined statements configured via the @Sql annotation.
StandaloneMockMvcBuilder	A MockMvcBuilder that accepts @Controller registrations thus allowing full control over the instantiation and initialization of controllers and their dependencies similar to plain unit tests, and also making it possible to test one controller at a time.
StatusAssertions	Assertions on the response status.
StatusResultMatchers	Factory for assertions on the response status.
SystemProfileValueSource	Implementation of ProfileValueSource which uses system properties as the underlying source.
TestAnnotationUtils	Collection of utility methods for working with Spring's core testing annotations.
TestAotProcessor	Filesystem-based ahead-of-time (AOT) processing base implementation that scans the provided classpath roots for Spring integration test classes and then generates AOT artifacts for those test classes in the configured output directories.
TestBean	@TestBean is an annotation that can be applied to a non-static field in a test class to override a bean in the test's ApplicationContext using a static factory method.
TestConstructor	@TestConstructor is an annotation that can be applied to a test class to configure how the parameters of a test class constructor are autowired from components in the test's ApplicationContext.
TestConstructor.AutowireMode	Defines autowiring modes for parameters in a test constructor.
TestConstructorUtils	Utility methods for working with @TestConstructor.
TestContext	TestContext encapsulates the context in which a test is executed, agnostic of the actual testing framework in use.
TestContextAnnotationUtils	TestContextAnnotationUtils is a collection of utility methods that complements the standard support already available in MergedAnnotations, AnnotationUtils, and AnnotatedElementUtils, while transparently honoring @NestedTestConfiguration semantics.
TestContextAnnotationUtils.AnnotationDescriptor<T extends Annotation>	Descriptor for an Annotation, including the class on which the annotation is declared as well as the merged annotation instance.
TestContextAnnotationUtils.UntypedAnnotationDescriptor	Untyped extension of TestContextAnnotationUtils.AnnotationDescriptor that is used to describe the declaration of one of several candidate annotation types where the actual annotation type cannot be predetermined.
TestContextAotException	Thrown if an error occurs during AOT build-time processing or AOT run-time execution in the Spring TestContext Framework.
TestContextAotGenerator	TestContextAotGenerator generates AOT artifacts for integration tests that depend on support from the Spring TestContext Framework.
TestContextBootstrapper	TestContextBootstrapper defines the SPI for bootstrapping the Spring TestContext Framework.
TestContextEvent	Base class for events published by the EventPublishingTestExecutionListener.
TestContextManager	TestContextManager is the main entry point into the Spring TestContext Framework.
TestContextResourceUtils	Utility methods for working with resources within the Spring TestContext Framework.
TestContextSpringFactoriesUtils	Collection of utilities for working with SpringFactoriesLoader within the Spring TestContext Framework.
TestContextTransactionUtils	Utility methods for working with transactions and data access related beans within the Spring TestContext Framework.
TestExecutionListener	TestExecutionListener defines a listener API for reacting to test execution events published by the TestContextManager with which the listener is registered.
TestExecutionListeners	@TestExecutionListeners is an annotation that can be applied to a test class to configure which TestExecutionListeners should be registered with a TestContextManager.
TestExecutionListeners.MergeMode	Enumeration of modes that dictate whether explicitly declared listeners are merged with the default listeners when @TestExecutionListeners is declared on a class that does not inherit listeners from a superclass or enclosing class.
TestPropertySource	@TestPropertySource is an annotation that can be applied to a test class to configure the TestPropertySource.locations() of properties files and inlined TestPropertySource.properties() to be added to the Environment's set of PropertySources for an ApplicationContext for integration tests.
TestPropertySources	@TestPropertySources is a container for one or more @TestPropertySource declarations.
TestPropertySourceUtils	Utility methods for working with @TestPropertySource and adding test PropertySources to the Environment.
TestRuntimeHintsRegistrar	Contract for registering RuntimeHints for integration tests run with the Spring TestContext Framework based on the ClassLoader of the deployment unit.
TestSocketUtils	Simple utility for finding available TCP ports on localhost for use in integration testing scenarios.
TestTransaction	TestTransaction provides a collection of static utility methods for programmatic interaction with test-managed transactions within test methods, before methods, and after methods.
Timed	Test annotation for use with JUnit 4 to indicate that a test method has to finish execution in a specified time period.
TransactionalTestExecutionListener	TestExecutionListener that provides support for executing tests within test-managed transactions by honoring Spring's @Transactional annotation.
UnorderedRequestExpectationManager	RequestExpectationManager that matches requests to expectations regardless of the order of declaration of expected requests.
UriAssert	AssertJ assertions that can be applied to a String representing a URI.
UrlRegexRequestMatcher	A WebRequestMatcher that allows matching on WebRequest#getUrl().toExternalForm() using a regular expression.
ViewResultMatchers	Factory for assertions on the selected view.
WebAppConfiguration	@WebAppConfiguration is an annotation that can be applied to a test class to declare that the ApplicationContext loaded for an integration test should be a WebApplicationContext.
WebConnectionHtmlUnitDriver	WebConnectionHtmlUnitDriver enables configuration of the WebConnection for an HtmlUnitDriver instance.
WebDelegatingSmartContextLoader	WebDelegatingSmartContextLoader is a concrete implementation of AbstractDelegatingSmartContextLoader that delegates to a GenericXmlWebContextLoader (or a GenericGroovyXmlWebContextLoader if Groovy is present on the classpath) and an AnnotationConfigWebContextLoader.
WebMergedContextConfiguration	WebMergedContextConfiguration encapsulates the merged context configuration declared on a test class and all of its superclasses and enclosing classes via @ContextConfiguration, @WebAppConfiguration, @ActiveProfiles, and @TestPropertySource.
WebRequestMatcher	Strategy for matching on a WebRequest.
WebTestClient	Client for testing web servers that uses WebClient internally to perform requests while also providing a fluent API to verify responses.
WebTestClient.BodyContentSpec	Spec for expectations on the response body content.
WebTestClient.BodySpec<B,S extends WebTestClient.BodySpec<B,S>>	Spec for expectations on the response body decoded to a single Object.
WebTestClient.Builder	Steps for customizing the WebClient used to test with, internally delegating to a WebClient.Builder.
WebTestClient.ControllerSpec	Specification for customizing controller configuration equivalent to, and internally delegating to, a WebFluxConfigurer.
WebTestClient.ListBodySpec<E>	Spec for expectations on the response body decoded to a List.
WebTestClient.MockServerSpec<B extends WebTestClient.MockServerSpec<B>>	Base specification for setting up tests without a server.
WebTestClient.RequestBodySpec	Specification for providing body of a request.
WebTestClient.RequestBodyUriSpec	Specification for providing the body and the URI of a request.
WebTestClient.RequestHeadersSpec<S extends WebTestClient.RequestHeadersSpec<S>>	Specification for adding request headers and performing an exchange.
WebTestClient.RequestHeadersUriSpec<S extends WebTestClient.RequestHeadersSpec<S>>	Specification for providing request headers and the URI of a request.
WebTestClient.ResponseSpec	Chained API for applying assertions to a response.
WebTestClient.ResponseSpec.ResponseSpecConsumer	Consumer of a WebTestClient.ResponseSpec.
WebTestClient.RouterFunctionSpec	Specification for customizing router function configuration.
WebTestClient.UriSpec<S extends WebTestClient.RequestHeadersSpec<?>>	Specification for providing the URI of a request.
WebTestClientConfigurer	Contract to encapsulate customizations to a WebTestClient.Builder.
WebTestContextBootstrapper	Web-specific implementation of the TestContextBootstrapper SPI.
XmlExpectationsHelper	A helper class for assertions on XML content.
XpathAssertions	XPath assertions for the WebTestClient.
XpathExpectationsHelper	A helper class for applying assertions via XPath expressions.
XpathRequestMatchers	Factory methods for request content RequestMatcher implementations that use an XPath expression.
XpathResultMatchers	Factory for assertions on the response content using XPath expressions.