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);
}
{
java.util.Iterator<?> loopIterator = (this.listeners).iterator();
while (loopIterator.hasNext()) {
AsyncListener listener = (AsyncListener) loopIterator.next();
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 generally well-structured with clear class-level organization and consistent formatting. Methods are short and focused, following single responsibility. Imports are organized, and the Javadoc explains non-obvious timeout defaults. However, the `complete()` method has unusual manual iterator looping with an unnecessary block scope, breaking the otherwise modern style (could use for-each). The `dispatchHandlers` synchronization logic is somewhat implicit, requiring careful reading to understand the dispatch path check. Minor inconsistency exists in nullability annotations and handling. Grounds for scoring lower include the slightly awkward iterator block and synchronized blocks adding cognitive load without clear comments. Overall, the code is readable but not exemplary.
Run 2
The code is generally well-structured with clear class organization, separate methods for distinct actions, and appropriate use of JavaDoc. It maintains a flat structure in most methods. However, the 'complete()' method stands out as problematic: it uses a manually-written while loop instead of an enhanced for-loop, with unnecessary braces and an awkward 'loopIterator' variable name. This reduces readability and consistency compared to the rest of the class, which otherwise uses modern Java patterns. The constructor and field declarations are clean, but the cast of ServletRequest/Response to HttpServletRequest/Response without validation is slightly concerning. Overall, the code is readable but has one notably awkward section that could be simplified.
Run 3
The code is well-structured with clear class organization and logical method grouping. It maintains a flat nesting structure overall, with only minor deep nesting in the 'complete()' method. Intent is generally obvious, though some methods have redundant overloads. Code length is concise and appropriate. Action granularity is mostly one action per line, but the 'complete()' method could be clearer. Reading flow is natural, with methods arranged logically. Deductions come from the overly generic 'dispatch(null, path)' call which obscures intent, the unnecessarily verbose iterator block in 'complete()' where a for-each loop would be cleaner, and the redundant overloaded methods that don't add value. Overall, this is readable production-quality code with minor improvements possible.
Run 1
Code Structure: Fields, constructor, and focused interface methods are logically organized. Nesting: Mostly flat, with modest synchronization and conditionals; complete() introduces unnecessary block, loop, and try/catch nesting. Clarity of intent: Descriptive names, override annotations, nullability markers, and documentation make the mock's purpose clear, though ignored overload parameters are unexplained. Code length: Most methods are concise, but the explicit wildcard iterator and cast in complete() are unnecessarily verbose compared with an enhanced for-loop. Action granularity: Statements generally perform one action per line, supporting easy scanning. Reading flow: Dispatch overloads and simple accessors read naturally; inconsistent indentation and the extra block in complete() interrupt otherwise consistent formatting.
Run 2
Code Structure: Fields, constructor, and focused interface methods are logically organized. Nesting: Mostly shallow, though complete() adds an unnecessary scope around a loop containing try/catch. Clarity of intent: Descriptive names, annotations, and documentation make the mock's purpose clear; ignored parameters and the manually expanded iterator slightly obscure behavior. Code length: Most methods are concise, but complete() could use an enhanced for-loop instead of a wildcard iterator and cast. Action granularity: Statements generally perform one action per line, with no compressed multi-statement lines. Reading flow: Dispatch overloads delegate naturally, and accessors are easy to scan. Inconsistent indentation in complete(), fully qualified iterator usage, and extra blank lines interrupt otherwise clean flow.
Run 3
Code Structure: Fields, constructor, and focused interface methods are logically organized. Nesting: Mostly shallow, but complete() adds an unnecessary block around an iterator loop and nested try/catch. Clarity of intent: Descriptive names, annotations, and documentation make the mock's purpose clear; ignored parameters in some overloads leave minor ambiguity. Code length: Most methods are concise, though the explicit wildcard iterator and cast are unnecessarily verbose compared with an enhanced for-loop. Action granularity: Statements generally perform one action per line, supporting easy scanning. Reading flow: Dispatch overloads delegate naturally, and consistent method formatting helps navigation. However, inconsistent indentation in complete(), redundant parentheses, and the fully qualified iterator type interrupt the otherwise clean flow.