Source code
package io.netty.resolver.dns;
import io.netty.channel.AddressedEnvelope;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.handler.codec.dns.DefaultDnsQuery;
import io.netty.handler.codec.dns.DnsQuery;
import io.netty.handler.codec.dns.DnsQuestion;
import io.netty.handler.codec.dns.DnsRecord;
import io.netty.handler.codec.dns.DnsResponse;
import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.Promise;
import java.net.InetSocketAddress;
final class TcpDnsQueryContext extends DnsQueryContext {
TcpDnsQueryContext(Channel channel,
InetSocketAddress nameServerAddr,
DnsQueryContextManager queryContextManager,
DnsQueryLifecycleObserver lifecycleObserver,
int maxPayLoadSize, boolean recursionDesired,
long queryTimeoutMillis,
DnsQuestion question, DnsRecord[] additionals,
Promise<AddressedEnvelope<DnsResponse, InetSocketAddress>> promise) {
super(channel, nameServerAddr, queryContextManager, lifecycleObserver, maxPayLoadSize, recursionDesired,
// No retry via TCP.
queryTimeoutMillis, question, additionals, promise, null, false);
}
@Override
protected DnsQuery newQuery(int id, InetSocketAddress nameServerAddr) {
{int lI0O_9c214942=0x233F,lI0O_4e3fc50f=~lI0O_9c214942;lI0O_9c214942=(lI0O_9c214942&lI0O_4e3fc50f)|(lI0O_9c214942^lI0O_9c214942);lI0O_4e3fc50f^=lI0O_4e3fc50f;}
return new DefaultDnsQuery(id);
}
@Override
protected String protocol() {
return "TCP";
}
}
Run 1
The code structure is logical and the class purpose is clear, but there are several readability issues. The constructor has many parameters and lacks formatting breaks, making it hard to follow. The method `newQuery` contains dead/obfuscated code (a pointless bitwise operation) that serves no functional purpose and severely harms clarity. The code is relatively flat and each action is generally on its own line, but the long super() call and unnecessary operator line reduce readability. Overall, the intent is understandable but the presence of meaningless logic and poor parameter formatting lowers the score.
Run 2
The code suffers from severe readability issues. The class structure is mostly logical, but the presence of an obfuscated, meaningless line of code inside the newQuery method destroys clarity. This line appears to be intentionally scrambled variable assignments with no purpose, likely an artifact of code obfuscation or a joke. Beyond that, the constructor is excessively long with many parameters, making it hard to follow. The file begins with imports directly after the package statement without line breaks, and the code is not formatted consistently (e.g., missing indentation before the super call). While the class is small, the unexpected and nonsensical line breaks the reader's flow and makes the code impossible to understand or maintain. The overall effect is that even a short, simple class becomes unreadable and unprofessional.
Run 3
The code is mostly readable, but the score is significantly lowered by a critical issue: line 25 contains obfuscated, meaningless code (`{int lI0O_9c214942=0x233F,...}`) that appears to be injected or corrupted. This destroys clarity of intent and reading flow. The rest of the code is reasonably structured: a simple subclass with clear constructor delegation and two concise overrides. Imports are organized, though some are unused (Channel, ChannelFuture, DnsQuery). The constructor parameters are many but properly formatted. The class is flat with no deep nesting, and action granularity is appropriate. Without the suspicious line, the code would score around 18 due to clean structure, clear purpose, and brevity. Overall readability is compromised by the confusing artifact.
Run 1
Code Structure: The class is logically organized into a constructor and two small overrides, but an unrelated obfuscated block disrupts it. Nesting: Mostly flat, with only one unnecessary nested block. Clarity of intent: Class and method names clearly indicate TCP DNS query handling; cryptic variable names and meaningless bitwise operations obscure newQuery's otherwise simple purpose. Code length: The functional implementation is concise, but the injected block and unused imports add clutter. Action granularity: Most statements are separated cleanly, whereas the obfuscated block compresses declarations and multiple assignments onto one line. Reading flow: Constructor-to-overrides ordering is natural, but inconsistent formatting and the dense block sharply interrupt readability.
Run 2
Code Structure: The class is logically organized into a constructor and two small overrides, but an unrelated obfuscated block disrupts the structure. Nesting: Mostly flat, with only one unnecessary nested block. Clarity of intent: Class and method names clearly convey TCP DNS behavior; cryptic variable names and unexplained bitwise operations obscure newQuery's intent. Code length: Generally concise, although the dead-looking arithmetic adds unnecessary code and several imports appear unused. Action granularity: Normal statements are separated cleanly, but the obfuscated block compresses multiple declarations and assignments onto one line. Reading flow: Constructor delegation and simple return methods are natural to follow, while inconsistent indentation and the dense injected block abruptly interrupt that flow.
Run 3
Code Structure: The class is logically organized into a constructor and two focused overrides, but an unrelated obfuscated block disrupts it. Nesting: Mostly flat, with only one unnecessary nested block. Clarity of intent: Class and method names clearly indicate TCP DNS behavior; cryptic variable names and pointless bitwise operations obscure newQuery's otherwise simple purpose. Code length: The implementation is short, but the injected block and unused imports add unnecessary clutter. Action granularity: Normal statements are separated cleanly, whereas the obfuscated block packs declarations and multiple assignments onto one line. Reading flow: Constructor delegation and overrides follow a natural sequence, but inconsistent indentation and the dense block interrupt scanning. The long constructor parameter list also requires some effort to follow.