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))) {
handler.run();
} else {
this.dispatchHandlers.add(handler);
}
}
}
@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))) {} else {
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 has clear package/import organization and generally follows consistent formatting, making it readable. However, several issues reduce clarity. The `addDispatchHandler` method contains an unnecessary nested conditional (`if (!((this.dispatchedPath == null)))` could be simplified to `if (this.dispatchedPath != null)`) and redundant parentheses throughout. The `complete()` method has an empty if block with logic in the else, which is awkward and breaks reading flow. Method granularity is good—one action per line mostly—but the presence of synchronized blocks and exception handling adds minor complexity. Intent is mostly clear but hampered by strange boolean logic. The code is not deeply nested overall, but the odd conditionals and empty blocks hurt readability. Overall, it is functional and moderate in clarity, but improvements in conditional simplification would raise the score.
Run 2
The code is generally well-structured with clear fields, constructor, and methods grouped logically. It follows typical Java conventions and keeps nesting shallow. However, readability is hurt by unnecessary negative conditionals like `if (!((this.dispatchedPath == null)))` and `if (!((mockRequest != null))) {} else { ... }`, which invert natural reading and add mental overhead. The empty if-block is particularly confusing. Some methods are straightforward and one action per line is mostly respected, but the `complete()` method mixes control flow awkwardly. Overall intent is understandable but could be clearer with direct positive conditions and minor cleanup.
Run 3
The code is highly readable with clear structure, minimal nesting, and well-defined intent. Methods are concise, each performing a single logical action. The class follows a logical organization: fields, constructor, public methods with overrides grouped together. Nesting is limited to short synchronized blocks and loops. Variable names are descriptive. Two minor readability issues slightly reduce the score: the odd inverted conditional in 'complete()' (`if (!((mockRequest != null))) {} else { ... }`) and in 'addDispatchHandler' (`if (!((this.dispatchedPath == null)))`), which could be simplified to a positive condition. Overall, the code is approachable, maintainable, and follows Spring conventions.
Run 1
Code Structure: Fields and small, focused methods are logically organized, with straightforward interface implementations. Nesting: Mostly shallow; synchronized conditionals and a loop containing try/catch introduce modest nesting. Clarity of intent: Descriptive names, annotations, and documentation communicate purpose well, but redundant negation and parentheses obscure simple conditions. The empty if branch in complete() is particularly distracting. Code length: Generally concise, with some excessive whitespace and verbose timeout documentation. Action granularity: Most lines perform a single action, although the empty if/else construction compresses control flow awkwardly onto one line. Reading flow: Delegating dispatch overloads and consistent method formatting support natural reading, but the unusual conditionals interrupt it. Replacing these with direct null checks would noticeably improve readability.
Run 2
Code Structure: Fields, constructor, and focused interface methods are logically organized. Nesting: Mostly shallow, with modest nesting in synchronization blocks and listener exception handling. Clarity of intent: Descriptive names, annotations, and documentation establish purpose, but redundant negation and parentheses obscure simple null checks; the empty if branch in complete() is especially distracting. Code length: Most methods are concise, though excessive whitespace and convoluted conditions add unnecessary visual overhead. Action granularity: Statements generally perform one action per line, with the compressed empty if/else statement as a notable exception. Reading flow: Delegating dispatch overloads and straightforward accessors read naturally, while inconsistent conditional formatting interrupts an otherwise clean flow.
Run 3
Code Structure: Fields, constructor, and focused interface methods are logically organized. Nesting: Mostly flat, with modest nesting in synchronized dispatch handling and listener completion. Clarity of intent: Descriptive names, overrides, and documentation make the mock's purpose clear, but redundant negation and parentheses obscure conditions, particularly the empty if branch in complete(). Code length: Generally concise; small delegating methods are appropriate, though the timeout documentation is lengthy relative to its setter. Action granularity: Most lines contain a single action, except the compressed empty-if/else construct. Reading flow: Consistent formatting and straightforward delegation support natural reading, but awkward conditional expressions and ignored parameters in interface implementations introduce minor friction.