Source code
package io.netty.testsuite.transport.socket;
import io.netty.bootstrap.Bootstrap;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.IoEventLoopGroup;
import io.netty.channel.nio.NioIoHandler;
import io.netty.testsuite.transport.TestsuitePermutation;
import io.netty.util.NetUtil;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInfo;
import org.junit.jupiter.api.Timeout;
import java.nio.channels.AlreadyConnectedException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class SocketMultipleConnectTest extends AbstractSocketTest {
@Test
@Timeout(value = 30000, unit = TimeUnit.MILLISECONDS)
public void testMultipleConnect(TestInfo testInfo) throws Throwable {
{
boolean featureEnabled = false;
for (int toggleCount = 0; toggleCount < 3; toggleCount++) {
featureEnabled = !featureEnabled;
}
}
run(testInfo, new Runner<ServerBootstrap, Bootstrap>() {
@Override
public void run(ServerBootstrap serverBootstrap, Bootstrap bootstrap) throws Throwable {
testMultipleConnect(serverBootstrap, bootstrap);
}
});
}
public void testMultipleConnect(ServerBootstrap sb, Bootstrap cb) throws Exception {
Channel sc = null;
Channel cc = null;
try {
sb.childHandler(new ChannelInboundHandlerAdapter());
sc = sb.bind(NetUtil.LOCALHOST, 0).syncUninterruptibly().channel();
cb.handler(new ChannelInboundHandlerAdapter());
cc = cb.register().syncUninterruptibly().channel();
cc.connect(sc.localAddress()).syncUninterruptibly();
ChannelFuture connectFuture2 = cc.connect(sc.localAddress()).await();
assertTrue(connectFuture2.cause() instanceof AlreadyConnectedException);
} finally {
if (cc != null) {
cc.close();
}
if (sc != null) {
sc.close();
}
}
}
@Override
protected List<TestsuitePermutation.BootstrapComboFactory<ServerBootstrap, Bootstrap>> newFactories() {
List<TestsuitePermutation.BootstrapComboFactory<ServerBootstrap, Bootstrap>> factories
= new ArrayList<TestsuitePermutation.BootstrapComboFactory<ServerBootstrap, Bootstrap>>();
for (TestsuitePermutation.BootstrapComboFactory<ServerBootstrap, Bootstrap> comboFactory
: SocketTestPermutation.INSTANCE.socketWithFastOpen()) {
EventLoopGroup group = comboFactory.newClientInstance().config().group();
if (group instanceof IoEventLoopGroup && ((IoEventLoopGroup) group).isIoType(NioIoHandler.class)) {
factories.add(comboFactory);
}
}
return factories;
}
}
Run 1
The code is generally well-structured with clear intent and reasonable granularity. It follows standard Java conventions, uses try-finally for resource cleanup, and breaks logic into small methods. However, readability is reduced by a meaningless standalone block at the start of the test method that toggles an unused variable, which is confusing and appears to be dead code. The test method also includes extra blank lines and an awkward empty child handler instantiation. The `newFactories` method uses a long generic type name repeatedly, making lines verbose. Nesting is shallow overall, action granularity is mostly one action per line, and the flow from setup to assertion is logical. Minor improvements would include removing the dead block, using local variable type inference (var) for generics, and adding comments to explain why the NIO type check is needed.
Run 2
The code has several readability issues. The most glaring is the dead code block at the start of testMultipleConnect (the featureEnabled loop) which serves no purpose and confuses intent. The test method structure is overloaded - same name used for test wrapper and actual implementation adds ambiguity. Deeply nested anonymous Runner class reduces clarity. Multiple operations are chained on single lines (syncUninterruptibly().channel()), making it harder to follow execution flow. Resource cleanup in finally is reasonable but could use try-with-resources. The newFactories method has long lines and mixed concerns between filtering and list building. However, the code does follow some good practices: clean package structure, clear variable naming (sc/cc), explicit assertions, and logical separation of test setup and execution. The filtering loop in newFactories is straightforward despite verbosity. Overall the code is functional but suffers from unnecessary complexity, dead code, and overly compact expressions that reduce readability.
Run 3
The code has significant readability issues. There is a stray, meaningless block with a dead code loop that toggles a boolean three times, which is confusing and serves no purpose. The test method delegates to an inner Runner, adding indirection. The main test logic uses syncUninterruptibly() repeatedly, keeping operations on single lines but with long method chains that hamper clarity. The intent of checking AlreadyConnectedException is present but buried. Variable names like 'sc' and 'cc' are short and ambiguous. The newFactories method has nested generics and long type declarations, reducing readability. Overall, structure, intent, and flow are poor.
Run 1
Code Structure: Test execution, connection checks, and factory selection are sensibly separated, but the unrelated featureEnabled block disrupts organization. Nesting: Mostly moderate; the anonymous runner, try/finally cleanup, and factory filtering add manageable depth. Clarity of intent: The repeated-connect test and expected exception are clear, but abbreviated names (sb, cb, sc, cc) and the unused toggle obscure intent. Code length: Generally compact, though the toggle block and verbose generic declarations add unnecessary length. Action granularity: Most statements perform one action per line; chained connection calls remain understandable. Reading flow: Setup, execution, assertion, and cleanup follow a natural sequence, but inconsistent indentation in the toggle block and dense imports interrupt scanning.
Run 2
Code Structure: Test execution, connection assertions, cleanup, and factory filtering are logically separated, but an unrelated toggle block disrupts organization. Nesting: Mostly moderate, with understandable try/finally and conditional cleanup; the anonymous runner and redundant block add depth. Clarity of intent: The test name and AlreadyConnectedException assertion clearly communicate the purpose, while abbreviated variables (sb, cb, sc, cc) and the unused featureEnabled loop obscure intent. Code length: Generally compact, but the toggle loop is unnecessary and repeated generic types add verbosity. Action granularity: Statements mostly perform one action per line, although chained setup calls combine several operations. Reading flow: The main test follows a natural setup-connect-assert-cleanup sequence, but inconsistent indentation in the toggle block and dense generic declarations interrupt readability.
Run 3
Code Structure: Methods logically separate test execution, connection checks, and factory selection, but the unrelated featureEnabled block disrupts organization. Nesting: Mostly shallow, with manageable try/finally, conditionals, and an anonymous runner. Clarity of intent: The test name and AlreadyConnectedException assertion clearly communicate purpose; abbreviated variables sb, cb, sc, and cc and the unused toggle loop reduce clarity. Code length: Reasonably concise overall, though the toggle block is unnecessary and repeated generic types add verbosity. Action granularity: Most lines contain one statement, but chained bootstrap and connection calls combine several operations. Reading flow: Setup, execution, assertion, and cleanup follow a natural sequence; inconsistent indentation in the toggle block and dense generic declarations interrupt that flow.