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 is generally readable with clear intent and logical structure. It follows standard Java conventions and Netty patterns. The test method is well-organized with proper resource cleanup. However, there are minor readability issues: the generic type declarations in newFactories() are verbose and repetitive, making that method harder to parse. The mixed use of syncUninterruptibly() and await() could be clarified. Indentation is consistent and nesting is shallow. The code would benefit from extracting the complex generic type into a type alias or using diamond operators where possible. Overall, it's maintainable and understandable but has some verbosity in the factory method.
Run 2
The code demonstrates strong readability through clear structure and logical organization. The test method is concise, follows a standard setup-action-assertion pattern, and maintains flat nesting with minimal conditional complexity. Each line typically performs a single action (e.g., binding, registering, connecting), which enhances action granularity. Variable names like 'sb', 'cb', 'sc', and 'cc' are conventional but slightly terse; however, they're consistent with Netty test patterns. The override method uses a clear loop with a logical filter condition. The only minor drawbacks are the lack of try-with-resources (requiring manual null checks in finally) and somewhat lengthy loop variable declaration, but these don't significantly impair readability. The intent is immediately apparent: testing that multiple connects on the same channel fail with AlreadyConnectedException.
Run 3
The code is generally well-structured and readable. It follows a clear logical organization: a test method wrapping a runner, a core test implementation, and a factory method for permutations. Nesting is minimal, with only one anonymous inner class and one if statement in a loop. Intent is clear — testing multiple connection attempts to the same channel. Code length is moderate and mostly concise, though the factory method's generic type declarations add verbosity. Action granularity is good: one logical operation per line, especially in the test's try block. Reading flow is natural, with cleanup handled properly in a finally block. Minor issues: long generic lines in the factory method reduce readability, and variable names like 'sb', 'cb', 'sc', 'cc' are terse but acceptable for a test. The anonymous Runner class adds slight overhead compared to Java 8 lambdas.
Run 1
Code Structure: Clearly separates test execution, connection assertions, and bootstrap factory filtering, with cleanup in a finally block. Nesting: Mostly shallow; the anonymous runner and loop condition introduce only modest nesting. Clarity of intent: The test name and AlreadyConnectedException assertion clearly communicate the purpose, but abbreviations such as sb, cb, sc, and cc obscure channel roles. Code length: Appropriately concise overall, though the anonymous runner and repeated generic types add boilerplate. Action granularity: Statements generally perform one logical action per line; chained setup and synchronization calls remain understandable. Reading flow: Setup, initial connection, repeated connection, assertion, and cleanup follow a natural sequence. Long generic declarations and the combined type-check/cast condition slightly interrupt the otherwise straightforward flow.
Run 2
Code Structure: Well organized into a test entry point, connection test, and factory-selection method. Nesting: Mostly shallow; the anonymous runner and cleanup checks add modest nesting. Clarity of intent: The test name and assertion clearly express that a second connection should fail, but abbreviated variables (sb, cb, sc, cc) and the unexplained factory filter reduce clarity. Code length: Reasonably concise, although repeated generic types and anonymous-class boilerplate add verbosity. Action granularity: Statements generally perform one logical action per line; chained calls compact related asynchronous operations without becoming difficult to follow. Reading flow: Setup, connection attempts, assertion, and cleanup follow a natural sequence. Long generic declarations and minimal separation around imports slightly interrupt scanning.
Run 3
Code Structure: Clearly separates test execution, connection assertions, cleanup, and factory filtering. Nesting: Mostly shallow; the anonymous runner and cleanup conditionals add modest depth. Clarity of intent: The test name and AlreadyConnectedException assertion communicate the purpose well, although abbreviations such as sb, cb, sc, and cc reduce immediate clarity. Code length: Reasonably concise, but verbose generic declarations and anonymous-class boilerplate add visual weight. Action granularity: Generally one action per statement; chained asynchronous calls combine related operations without significantly obscuring intent. Reading flow: Setup, initial connection, repeated connection, assertion, and cleanup follow a natural sequence. Long factory signatures and filtering expressions slightly interrupt readability.