Source code
package org.springframework.mock.web;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import jakarta.servlet.AsyncContext;
import jakarta.servlet.AsyncEvent;
import jakarta.servlet.AsyncListener;
import jakarta.servlet.ServletContext;
import jakarta.servlet.ServletException;
import jakarta.servlet.ServletRequest;
import jakarta.servlet.ServletResponse;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.jspecify.annotations.Nullable;
import org.springframework.beans.BeanUtils;
import org.springframework.util.Assert;
import org.springframework.web.util.WebUtils;
/**
* Mock implementation of the {@link AsyncContext} interface.
*
* @author Rossen Stoyanchev
* @since 3.2
*/
public class MockAsyncContext implements AsyncContext {
private final HttpServletRequest request;
private final @Nullable HttpServletResponse response;
private final List<AsyncListener> listeners = new ArrayList<>();
private @Nullable String dispatchedPath;
private long timeout = 10 * 1000L;
private final List<Runnable> dispatchHandlers = new ArrayList<>();
public MockAsyncContext(ServletRequest request, @Nullable ServletResponse response) {
this.request = (HttpServletRequest) request;
this.response = (HttpServletResponse) response;
}
public void addDispatchHandler(Runnable handler) {
Assert.notNull(handler, "Dispatch handler must not be null");
synchronized (this) {
if (this.dispatchedPath == null) {
this.dispatchHandlers.add(handler);
}
else {
handler.run();
}
}
}
@Override
public ServletRequest getRequest() {
return this.request;
}
@Override
public @Nullable ServletResponse getResponse() {
return this.response;
}
@Override
public boolean hasOriginalRequestAndResponse() {
return (this.request instanceof MockHttpServletRequest && this.response instanceof MockHttpServletResponse);
}
@Override
public void dispatch() {
dispatch(this.request.getRequestURI());
}
@Override
public void dispatch(String path) {
dispatch(null, path);
}
@Override
public void dispatch(@Nullable ServletContext context, String path) {
synchronized (this) {
this.dispatchedPath = path;
this.dispatchHandlers.forEach(Runnable::run);
}
}
public @Nullable String getDispatchedPath() {
return this.dispatchedPath;
}
@Override
public void complete() {
MockHttpServletRequest mockRequest = WebUtils.getNativeRequest(this.request, MockHttpServletRequest.class);
if (mockRequest != null) {
mockRequest.setAsyncStarted(false);
}
for (AsyncListener listener : this.listeners) {
try {
listener.onComplete(new AsyncEvent(this, this.request, this.response));
}
catch (IOException ex) {
throw new IllegalStateException("AsyncListener failure", ex);
}
}
}
@Override
public void start(Runnable runnable) {
runnable.run();
}
@Override
public void addListener(AsyncListener listener) {
this.listeners.add(listener);
}
@Override
public void addListener(AsyncListener listener, ServletRequest request, ServletResponse response) {
this.listeners.add(listener);
}
public List<AsyncListener> getListeners() {
return this.listeners;
}
@Override
public <T extends AsyncListener> T createListener(Class<T> clazz) throws ServletException {
return BeanUtils.instantiateClass(clazz);
}
/**
* By default this is set to 10000 (10 seconds) even though the Servlet API
* specifies a default async request timeout of 30 seconds. Keep in mind the
* timeout could further be impacted by global configuration through the MVC
* Java config or the XML namespace, as well as be overridden per request on
* {@link org.springframework.web.context.request.async.DeferredResult DeferredResult}
* or on
* {@link org.springframework.web.servlet.mvc.method.annotation.SseEmitter SseEmitter}.
* @param timeout the timeout value to use.
* @see AsyncContext#setTimeout(long)
*/
@Override
public void setTimeout(long timeout) {
this.timeout = timeout;
}
@Override
public long getTimeout() {
return this.timeout;
}
}
Run 1
The code is well-structured, with clear separation of concerns and consistent naming conventions. Methods are concise and focused, generally performing a single action or a small set of related actions. Nesting is minimal, limited to simple conditional blocks and loops. Intent is clear from method names and field declarations. The only minor issues are the use of synchronized blocks in a few methods, which slightly interrupt the reading flow, and the complete() method which catches IOException and wraps it in an IllegalStateException, adding a small layer of complexity. Overall, it is highly readable and maintainable.
Run 2
The code is well-structured and highly readable. The class follows a clear logical organization with fields, constructor, and methods grouped logically. It maintains a flat structure with minimal nesting, only using one level inside synchronized blocks and loops. Each method has a single, clear purpose, and the action granularity is appropriate—most lines perform one operation. The reading flow is natural, with methods following a sensible order. The code is concise without being overly compressed; methods are appropriately sized. Naming is clear and descriptive, and the use of annotations and nullability markers adds clarity. Minor deductions: the getListeners method exposes internal state directly, and the addListener method ignores its parameters, which could confuse readers. Overall, this is exemplary Spring framework code demonstrating good practices, clear intent, and maintainable structure.
Run 3
The code is well-structured, with clear separation of fields, constructor, and methods, and follows consistent naming conventions. Nesting is minimal—only a few synchronized blocks and a single if/else. Intent is generally clear, with descriptive method names and a helpful Javadoc explaining the non-standard timeout default. Code length is appropriate; methods are concise and focused. Action granularity is good, with one logical operation per line in most cases. Reading flow is natural, progressing from fields to constructor to core async lifecycle methods, followed by utility methods. Minor deductions: the dispatch methods create slight redundancy, and the synchronized block in addDispatchHandler could be simplified. Overall, this is highly readable code with only minor areas for improvement.
Run 1
Code Structure: Well-organized class with clearly separated fields, constructors, and focused interface methods. Nesting: Mostly flat; synchronization, conditionals, and listener exception handling introduce only modest nesting. Clarity of intent: Descriptive names, overrides, nullability annotations, and documentation make the mock's purpose clear. However, ignored parameters in dispatch and addListener, plus synchronous execution in start, could benefit from brief explanations of mock-specific behavior. Code length: Concise overall, with justified interface boilerplate; timeout documentation is somewhat lengthy relative to the implementation. Action granularity: Statements generally perform one action per line, and delegation keeps methods focused. Reading flow: Consistent formatting and straightforward method bodies support natural reading, though imports lack visual grouping and related dispatch methods are separated by accessors.
Run 2
Code Structure: Fields, constructor, and focused interface methods are logically organized, with dispatch overloads grouped together. Nesting: Mostly flat; synchronization and listener exception handling introduce only modest nesting. Clarity of intent: Descriptive names, explicit overrides, and timeout documentation make the mock's purpose clear. However, ignored context and listener request/response parameters, plus synchronous start execution, could benefit from brief explanatory comments. Code length: Concise overall; repetitive accessors and overloads are largely required by the interface. Action granularity: Statements generally perform one action per line, and the method reference expresses handler execution cleanly. Reading flow: Consistent formatting and straightforward delegation support natural reading, though the dense import block and a few long lines slightly reduce scanability.
Run 3
Code Structure: Clearly organized fields, constructor, and focused interface methods; dispatch overloads delegate consistently. Nesting: Mostly flat, with modest nesting limited to synchronization, conditionals, and listener exception handling. Clarity of intent: Descriptive names, annotations, and straightforward implementations make the mock's purpose clear, though ignored parameters and synchronous execution of asynchronous operations could use brief explanations. Code length: Appropriately concise overall; interface boilerplate and detailed timeout documentation add length but remain useful. Action granularity: Statements generally perform one action per line, and the method reference expresses handler execution compactly. Reading flow: Consistent formatting and predictable method progression support easy scanning, although unseparated imports and extra blank lines slightly reduce polish.