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();
assertTrue((cc.connect(sc.localAddress()).await()).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 readable with clear structure: imports are organized, methods are logically separated, and error handling uses a try-finally block. Naming is mostly clear (sb, cb, sc, cc are somewhat abbreviated but understandable in context). The test method follows a typical Netty test pattern, making the purpose clear. Nesting is minimal, with only one anonymous inner class and one if statement. The main readability issue is the long line in assertTrue, which combines multiple operations (connect, await, cause check) and makes the intent slightly harder to parse. Also, some variable names could be more descriptive. The newFactories method is reasonably structured but uses long generic type declarations. Overall, the code is maintainable and follows established Netty testing conventions, with minor opportunities for improvement in line length and variable naming.
Run 2
The code is well-structured with clear separation between test setup, execution, and teardown. The main test logic is flat with minimal nesting, using try-finally for clean resource management. Variables are named descriptively (sc, cc, sb, cb). Each line generally performs one action, though the assertion line combines connect, await, and cause extraction. The factory method is straightforward but could be more concise with streams. The reading flow is natural: setup, execute, verify, cleanup. Points deducted for the long generic type declarations, the slightly complex assertion line, and the verbose loop in newFactories that could use a stream filter. Overall, the code demonstrates good readability practices despite some minor verbosity in type declarations.
Run 3
The code is well-structured and readable for a Netty test class. It has clear logical organization, minimal nesting, and good separation of concerns. Method names are descriptive, and the test follows a clear setup-execute-assert pattern. The use of try-finally for resource cleanup is proper. However, there are a few minor issues: the assertTrue line is long with nested method calls, the anonymous inner class Runner adds slight complexity, and the newFactories method could benefit from more line breaks for clarity. The single long assert statement could be split into multiple lines for better readability. Overall, the code is concise, follows good practices, and clearly expresses its intent, making it accessible to developers familiar with Netty testing patterns.
Run 1
Code Structure: Clearly separates test execution, connection verification, and bootstrap factory filtering. Nesting: Mostly shallow; the anonymous runner and try/finally cleanup add modest nesting without becoming tangled. Clarity of intent: The test name and AlreadyConnectedException assertion communicate the purpose, but abbreviated variables (sb, cb, sc, cc) and the unexplained factory filter reduce clarity. Code length: Reasonably concise, though verbose generic declarations and the anonymous runner add boilerplate; ChannelFuture is an unused import. Action granularity: Statements generally perform one logical action per line, although chained asynchronous operations and the assertion combine several steps. Reading flow: Setup, connection, verification, and cleanup follow a natural sequence. Long generic signatures, redundant assertion parentheses, and limited explanation of transport filtering slightly interrupt readability.
Run 2
Code Structure: Well-organized methods separate test execution, connection behavior, and factory selection. Nesting: Mostly shallow; the anonymous runner and cleanup checks add modest nesting. Clarity of intent: The test name and AlreadyConnectedException assertion clearly communicate the purpose, but abbreviated names such as sb, cb, sc, and cc require extra interpretation. Code length: Reasonably concise, although the anonymous runner and repeated generic types are verbose, and ChannelFuture is unused. Action granularity: Statements generally perform one logical action per line, though chained asynchronous operations and the inline assertion combine several steps. Reading flow: Setup, connection, assertion, and cleanup follow a natural sequence; long generic declarations and the compound factory-filter condition slightly interrupt scanning.
Run 3
Code Structure: Clearly separates the test entry point, connection test, and bootstrap factory filtering. Nesting: Mostly shallow; the anonymous runner and try/finally cleanup introduce manageable nesting. Clarity of intent: The test name and AlreadyConnectedException assertion communicate the purpose, but abbreviated names (sb, cb, sc, cc) and the unexplained factory restriction reduce clarity. Code length: Reasonably concise, though verbose generic declarations and the anonymous runner add boilerplate; ChannelFuture is an unused import. Action granularity: Most statements perform one logical action, but chained registration/binding calls and the connect-await-cause assertion combine several operations. Reading flow: Setup, connection, verification, and cleanup follow a natural sequence. Factory filtering is straightforward, although long type declarations and the compound type-check condition slow scanning.