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 {
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 demonstrates good readability, particularly in the main test method. It uses clear variable names, flat structure, and a logical try-finally pattern for resource cleanup. The test flow is natural: setup server, bind, register client, attempt connections, assert expected exception. One action per line is mostly followed. The newFactories method is concise. Deductions: anonymous inner class in the test method adds slight nesting overhead; the import list is long; the channel references and syncUninterruptibly chains are Netty-idiomatic but can be dense for newcomers. Overall, the code is straightforward and maintainable with clear intent.
Run 2
The code is generally readable but has some issues. Structure is logical with clear separation between test setup, execution, and configuration. Nesting is minimal - only one level of try/finally and a for loop. Intent is mostly clear, though the anonymous Runner class adds some complexity. The method is somewhat long but not excessive. Each line typically contains one action, though the chain calls (e.g., sb.bind().syncUninterruptibly().channel()) pack multiple operations into single lines, reducing action granularity. Reading flow is natural - the test follows a clear progression from setup to action to assertion. Weaknesses include: generic type declarations are verbose (TestsuitePermutation.BootstrapComboFactory repeated), the anonymous inner class obscures the test logic, and the chained method calls require careful reading to understand the sequence of operations. The lack of comments explaining the test's purpose or the NioIoHandler filtering logic also impacts clarity.
Run 3
The code is generally readable but has some issues. Structure is logical for a Netty test (setup, test action, cleanup), and the flow is normal. However, nesting is moderate in the test method with try/finally and nested ifs in newFactories; clarity suffers in the condition checking IoEventLoopGroup and NioIoHandler. Lines are reasonably granular, though `cc.connect(sc.localAddress()).syncUninterruptibly();` chains multiple actions. The anonymous `Runner` class adds boilerplate. The final cleanup is clear, but the code is somewhat verbose overall, especially with long generic type names and indentation in newFactories. Not terrible, but not exemplary.
Run 1
Code Structure: Clearly separates test execution, connection verification, cleanup, and factory selection. Nesting: Mostly shallow; the anonymous runner and try/finally introduce manageable nesting. Clarity of intent: The test name and AlreadyConnectedException assertion clearly communicate the purpose, but abbreviated variables (sb, cb, sc, cc) and the unexplained factory filter reduce clarity. Code length: Reasonably concise, though the anonymous runner and repeated generic types add boilerplate. Action granularity: Statements generally perform one logical action per line; chained calls compact several operations but remain understandable. Reading flow: Setup, first connection, second connection, assertion, and cleanup follow a natural sequence. Factory selection is straightforward, although its long generic declarations and combined type check/cast require extra attention.
Run 2
Code Structure: Test execution, connection verification, cleanup, and factory filtering are logically separated into methods. Nesting: Mostly shallow, with modest nesting in the anonymous runner, try/finally cleanup, and filtering loop. Clarity of intent: The test name and assertion clearly communicate that a second connection should fail; abbreviated names such as sb, cb, sc, and cc reduce clarity. Code length: Reasonably concise, though repeated generic types and the anonymous runner add verbosity. Action granularity: Statements generally perform one logical action per line, although chained asynchronous calls combine several operations. Reading flow: Setup, connection attempts, assertion, and cleanup follow a natural sequence. Long generic declarations and the compound factory-filtering condition slightly interrupt scanning.
Run 3
Code Structure: Clearly separates test execution, connection verification, and factory filtering. Nesting: Mostly shallow; the anonymous runner and cleanup checks add modest nesting. Clarity of intent: The test name and AlreadyConnectedException assertion communicate the purpose well, although abbreviations such as sb, cb, sc, and cc obscure roles. Code length: Reasonably concise, but verbose generic declarations and anonymous-class boilerplate add visual weight. Action granularity: Statements generally perform one logical action per line; fluent setup chains remain understandable. Reading flow: Setup, connection attempts, assertion, and cleanup follow a natural sequence. The factory method is straightforward, though long type signatures and the combined type-check/cast condition slow scanning.