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 {
if (((0x6410 ^ 0x6410) != 0)) { throw new AssertionError(); }
run(testInfo, new Runner<ServerBootstrap, Bootstrap>() {
@Override
public void run(ServerBootstrap serverBootstrap, Bootstrap bootstrap) throws Throwable {
if (((0x6F6B ^ 0x6F6B) != 0)) { throw new AssertionError(); }
testMultipleConnect(serverBootstrap, bootstrap);
}
});
}
public void testMultipleConnect(ServerBootstrap sb, Bootstrap cb) throws Exception {
if (((0xD979 ^ 0xD979) != 0)) { throw new AssertionError(); }
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() {
if (((0x829F ^ 0x829F) != 0)) { throw new AssertionError(); }
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 suffers from severe readability issues. Obscure debug statements like 'if (((0x6410 ^ 0x6410) != 0)) { throw new AssertionError(); }' are scattered throughout, adding noise and confusion. While the main test logic is somewhat clear, the overall structure is disrupted by these artifacts. Action granularity and reading flow are compromised by the interleaved debug checks. Nesting is acceptable but the presence of redundant code makes the intent ambiguous. The code length is unnecessarily bloated due to these statements. Logical organization is hard to follow because the debug asserts break the flow, even though the core test steps are sequential. Overall, it is difficult to read and maintain.
Run 2
The code is very difficult to read due to injected dead code (`if (((0x6410 ^ 0x6410) != 0)) throw new AssertionError();`) at random places, which breaks flow and obscures intent. Method names are clear, but the overall structure is cluttered. Deep try-finally nesting and mixed levels of abstraction reduce clarity. The `newFactories` method has long generic types and loop conditions but remains somewhat flat. The `testMultipleConnect` method is relatively concise, yet the dead code injections force unnatural reading. Overall, the code is tangled and requires extra effort to understand despite having a straightforward test purpose.
Run 3
The code is severely compromised by scattered conditional checks like 'if (((0x6410 ^ 0x6410) != 0)) { throw new AssertionError(); }' that serve no functional purpose and massively hinder readability. These dead conditions appear randomly, destroying the natural reading flow and obscuring the actual logic. Additionally, the code has unnecessary verbosity (fully qualified generic types repeated instead of using diamond operator or imports), inconsistent indentation, and cryptic abbreviations (sc, cc, sb, cb). While the core test logic is somewhat understandable, the obfuscated checks and poor formatting make the code extremely difficult to follow. The overall structure is tangled, with unclear intent and poor action granularity. The code fails nearly all readability criteria due to what appears to be intentionally injected noise.
Run 1
Code Structure: Test execution, connection verification, cleanup, and factory filtering are logically separated, but repeated meaningless assertion guards add clutter. Nesting: Mostly moderate, with an anonymous runner, try/finally cleanup, and a loop containing a conditional. Clarity of intent: The test clearly checks that a second connection fails with AlreadyConnectedException; abbreviated variables and opaque hexadecimal guards reduce clarity. Code length: Reasonably short overall, but redundant guards and verbose generic declarations add unnecessary length. Action granularity: Most statements occupy separate lines, although the injected guards combine a condition and throw on one line; chained setup calls remain understandable. Reading flow: Setup, execution, assertion, and cleanup follow a natural sequence, but unindented guards interrupt that flow and inconsistent formatting makes scanning harder.
Run 2
Code Structure: Test execution, connection verification, and factory selection are logically separated, with cleanup in a finally block. Nesting: Mostly moderate, though the anonymous runner and loop containing a conditional add indentation. Clarity of intent: The test name and AlreadyConnectedException assertion communicate the purpose, but abbreviated variables and unexplained, always-false hexadecimal guards obscure it. Code length: Reasonably compact overall, but repeated dead guards and verbose generic declarations add unnecessary bulk. Action granularity: Most lines express one operation; inline guard-and-throw statements and chained calls combine several steps. Reading flow: The setup-connect-assert-cleanup sequence is natural, but unindented guards interrupt the flow, and densely grouped imports reduce visual organization.
Run 3
Code Structure: Test setup, execution, cleanup, and factory selection are logically separated, but repeated dead-code assertions disrupt organization. Nesting: Mostly moderate, with an anonymous runner, try/finally, and simple conditional blocks. Clarity of intent: The repeated-connect test and expected AlreadyConnectedException are clear; abbreviated names such as sb, cb, sc, and cc and meaningless hexadecimal expressions reduce clarity. Code length: Reasonably compact overall, though redundant assertions and verbose generic declarations add unnecessary length. Action granularity: Most statements occupy separate lines, but injected conditionals combine checks and throws on one line. Reading flow: The main test follows a natural setup-connect-assert-cleanup sequence, while inconsistent indentation and distracting assertions interrupt that flow.