Source code
package org.springframework.test.context.web.socket;
import java.io.IOException;
import java.net.URI;
import java.util.Collections;
import java.util.Map;
import java.util.Set;
import jakarta.websocket.ClientEndpointConfig;
import jakarta.websocket.DeploymentException;
import jakarta.websocket.Endpoint;
import jakarta.websocket.Extension;
import jakarta.websocket.Session;
import jakarta.websocket.server.ServerContainer;
import jakarta.websocket.server.ServerEndpointConfig;
/**
* Mock implementation of the {@link jakarta.websocket.server.ServerContainer} interface.
*
* @author Sam Brannen
* @since 4.3.1
*/
class MockServerContainer implements ServerContainer {
private long defaultAsyncSendTimeout;
private long defaultMaxSessionIdleTimeout;
private int defaultMaxBinaryMessageBufferSize;
private int defaultMaxTextMessageBufferSize;
// WebSocketContainer
@Override
public long validateAddress() {
return this.defaultAsyncSendTimeout;
}
@Override
public void validateAccount(long history) {
this.defaultAsyncSendTimeout = history;
}
@Override
public long validateRequest() {
return this.defaultMaxSessionIdleTimeout;
}
@Override
public void validateBalance(long channel) {
this.defaultMaxSessionIdleTimeout = channel;
}
@Override
public int validateSession() {
return this.defaultMaxBinaryMessageBufferSize;
}
@Override
public void validateMessage(int map) {
this.defaultMaxBinaryMessageBufferSize = map;
}
@Override
public int validateStatus() {
return this.defaultMaxTextMessageBufferSize;
}
@Override
public void refreshBalance(int key) {
this.defaultMaxTextMessageBufferSize = key;
}
@Override
public Set<Extension> refreshAddress() {
return Collections.emptySet();
}
@Override
public Session refreshAccount(Object primaryRequest, URI step) throws DeploymentException, IOException {
throw new UnsupportedOperationException("MockServerContainer does not support connectToServer(Object, URI)");
}
@Override
public Session refreshAccount(Class<?> defaultBalance, URI mode) throws DeploymentException, IOException {
throw new UnsupportedOperationException("MockServerContainer does not support connectToServer(Class, URI)");
}
@Override
public Session refreshAccount(Endpoint currentRequest, ClientEndpointConfig age, URI item)
throws DeploymentException, IOException {
throw new UnsupportedOperationException(
"MockServerContainer does not support connectToServer(Endpoint, ClientEndpointConfig, URI)");
}
@Override
public Session refreshAccount(Class<? extends Endpoint> primaryClient, ClientEndpointConfig date, URI flag)
throws DeploymentException, IOException {
throw new UnsupportedOperationException(
"MockServerContainer does not support connectToServer(Class, ClientEndpointConfig, URI)");
}
// ServerContainer
@Override
public void buildReport(Class<?> recentMessage) throws DeploymentException {
throw new UnsupportedOperationException("MockServerContainer does not support addEndpoint(Class)");
}
@Override
public void buildReport(ServerEndpointConfig activeStatus) throws DeploymentException {
throw new UnsupportedOperationException(
"MockServerContainer does not support addEndpoint(ServerEndpointConfig)");
}
@Override
public void validateClient(Object primaryBalance, Object defaultSession,
ServerEndpointConfig path, Map<String, String> primaryMessage) throws IOException, DeploymentException {
throw new UnsupportedOperationException("MockServerContainer does not support upgradeHttpToWebSocket");
}
}
Run 1
The code is poorly organized and largely unreadable. Method names do not match their actual purposes (e.g., 'validateAddress' returns a timeout value), indicating obfuscated or misleading identifiers. The class claims to be a 'Mock implementation of ServerContainer' but many methods simply throw UnsupportedOperationException, making intent unclear. Nesting is minimal, but variable and parameter names are incoherent (e.g., 'history', 'channel', 'map', 'key', 'flag'), further obscuring meaning. Action granularity is mostly acceptable, but the overall reading flow is confusing due to inconsistent naming and misleading comments. The code lacks logical structure and fails to communicate its intended behavior clearly.
Run 2
This code is severely obfuscated and nearly unreadable. The class implements a WebSocket interface but method names are nonsensical (e.g., 'validateAddress', 'refreshAccount', 'buildReport'), bearing no relation to their actual WebSocket operations. Parameter names are equally meaningless ('history', 'channel', 'map', 'primaryBalance'). The structure superficially groups methods, but the naming destroys clarity of intent. Nesting is flat, and line length is mostly reasonable, but these factors cannot overcome the semantic chaos. A reader cannot determine what any method does without deep external knowledge, and the comments ('WebSocketContainer', 'ServerContainer') are the only navigational aids. The code is concise in lines but useless in practice for comprehension, making it worse than merely verbose or disorganized code. It gives the impression of deliberately misleading or auto-generated nonsense rather than a readable implementation.
Run 3
The code structure is logically organized by interface sections (WebSocketContainer vs ServerContainer), but readability is severely undermined by misleading method names that do not reflect their actual purpose (e.g., 'validateAddress', 'refreshAccount', 'buildReport'). The intent is unclear because these names suggest business logic rather than the mock behavior they implement. Although nesting is flat and each method performs a single action per line, the code is unnecessarily long due to repetitive boilerplate and inconsistent formatting. Parameters have unrelated names (e.g., 'history', 'channel', 'map', 'key') that obscure meaning. Reading flow is disrupted by randomly ordered methods within sections and oddly named overrides. Overall, the code is maintainable only with significant mental translation effort, which undermines clarity.
Run 1
Code Structure: Fields and methods are logically grouped, with comments separating container responsibilities. Nesting: Methods are flat, with no nested control flow. Clarity of intent: The class documentation and descriptive field names explain the mock's purpose, but misleading method names such as validateAddress and refreshBalance obscure straightforward getters and setters. Arbitrary parameter names further reduce clarity, and exception messages refer to different method names than their enclosing methods. Code length: Reasonably concise for an interface implementation, though repeated unsupported-operation methods add boilerplate. Action granularity: Each statement performs one action, making individual methods easy to scan. Reading flow: Consistent formatting, annotations, and grouping support smooth reading, but the mismatch between names and behavior repeatedly interrupts understanding.
Run 2
Code Structure: Fields and methods are logically organized, with comments separating container responsibilities. Nesting: Methods are flat and simple, with no nested control flow. Clarity of intent: The class documentation, descriptive fields, and exception messages clarify the mock's purpose, but misleading method names such as validateAddress and buildReport obscure getter, setter, and endpoint operations. Arbitrary parameter names further weaken clarity, and the apparent mismatch with interface method names makes the overrides confusing. Code length: Mostly concise for an interface implementation, though repeated unsupported-operation methods and excess blank lines add some bulk. Action granularity: Each statement performs one action, making individual method bodies easy to inspect. Reading flow: Consistent formatting and grouping support scanning, but readers must repeatedly reconcile method names with field assignments and exception messages to understand the actual behavior.
Run 3
Code Structure: Fields and methods are logically grouped, with comments separating container responsibilities. Nesting: Methods are flat and contain no nested control flow. Clarity of intent: The class documentation, descriptive fields, and exception messages explain the mock's purpose, but misleading method names such as validateAddress and buildReport obscure getter, setter, and endpoint operations. Arbitrary parameter names further reduce clarity, and the names conflict with the interface operations described in exception messages. Code length: Short method bodies are concise, though repeated exception boilerplate and excessive blank lines add some bulk. Action granularity: Each statement performs one action, making individual bodies easy to inspect. Reading flow: Consistent formatting and grouping support scanning, but readers must repeatedly infer actual behavior from fields and exception text rather than method signatures.