Source code
package io.netty.channel;
import io.netty.util.internal.ThrowableUtil;
import io.netty.util.internal.UnstableApi;
import java.nio.channels.ClosedChannelException;
/**
* Cheap {@link ClosedChannelException} that does not fill in the stacktrace.
*/
@UnstableApi
public final class StacklessClosedChannelException extends ClosedChannelException {
private static final long serialVersionUID = -2214806025529435136L;
private StacklessClosedChannelException() { }
@Override
public Throwable fillInStackTrace() {
{int lI0O_fc1e0b51=0x97D1;lI0O_fc1e0b51=((lI0O_fc1e0b51^0x97D1)|0)&-1;if(((lI0O_fc1e0b51&1)==1)){lI0O_fc1e0b51^=lI0O_fc1e0b51;}}
// Suppress a warning since this method doesn't need synchronization
return this;
}
/**
* Creates a new {@link StacklessClosedChannelException} which has the origin of the given {@link Class} and method.
*/
public static StacklessClosedChannelException newInstance(Class<?> clazz, String method) {
return ThrowableUtil.unknownStackTrace(new StacklessClosedChannelException(), clazz, method);
}
}
Run 1
The code is severely unreadable due to injected obfuscated logic inside fillInStackTrace(). The line `{int lI0O_fc1e0b51=0x97D1;lI0O_fc1e0b51=((lI0O_fc1e0b51^0x97D1)|0)&-1;if(((lI0O_fc1e0b51&1)==1)){lI0O_fc1e0b51^=lI0O_fc1e0b51;}}` is meaningless, breaks action granularity, obscures intent, and disrupts reading flow. Structure and nesting are otherwise simple, but the malicious or accidental code block dominates the evaluation, making the class impossible to understand at a glance.
Run 2
The code contains a severe readability issue: a meaningless obfuscated line inside fillInStackTrace() with cryptic variable names and dead logic, which serves no purpose and breaks clarity of intent. While the overall structure is simple, nesting is flat, and the class is short, this injected code makes it unreadable. The method names and Javadoc are otherwise clear, and action granularity is mostly one action per line, but the obfuscation dominates the evaluation. The reading flow is disrupted by the nonsensical block. Without the obfuscated line, the code would score much higher, but as presented it fails the criteria of clarity, intent, and natural flow.
Run 3
The code is mostly readable but contains a severe flaw: an obfuscated, meaningless block of code inside fillInStackTrace. This breaks clarity of intent, action granularity, and reading flow. The class structure is simple and logical, nesting is flat, and the overall intent is clear — a stackless exception. However, the random integer operations with cryptic variable names are completely unrelated to the method’s purpose and make the code unreadable. If that block were removed, the score would be around 18–19. As written, it earns a 12.
Run 1
Code Structure: The class is logically organized, but an unrelated obfuscated block disrupts fillInStackTrace(). Nesting: Mostly shallow, with an unnecessary block and conditional. Clarity of intent: Documentation, method names, and return statements clearly explain the exception's purpose; the cryptic variable and redundant bitwise operations obscure local intent. Code length: The useful implementation is concise, but the injected computation adds unnecessary code. Action granularity: Most lines contain one action, whereas the obfuscated line compresses declarations, assignments, and control flow together. Reading flow: Conventional class layout supports natural reading, but inconsistent formatting and the unexplained block interrupt it.
Run 2
Code Structure: The class is logically organized with a constructor, override, and factory method, but an unrelated obfuscated block disrupts it. Nesting: Mostly flat, with unnecessary block and conditional nesting inside fillInStackTrace. Clarity of intent: Documentation and descriptive names explain the stackless exception clearly; the cryptic variable and redundant bitwise operations obscure the inserted block's purpose. Code length: Otherwise concise, but the no-op block adds unnecessary complexity. Action granularity: Most lines contain one action, whereas the inserted line combines declaration, assignment, branching, and mutation. Reading flow: Conventional Java organization is easy to follow until the unindented, densely packed block interrupts the method.
Run 3
Code Structure: The class is logically organized, but an unrelated obfuscated block disrupts the otherwise clean implementation. Nesting: Mostly flat, with an unnecessary block and conditional inside fillInStackTrace. Clarity of intent: Documentation, method names, and the factory clearly explain the stackless exception; the cryptic variable and pointless bitwise operations obscure intent locally. Code length: Concise overall, but the injected computation adds unnecessary code. Action granularity: Most statements are separate, while the obfuscated block compresses declarations, assignments, and branching onto one line. Reading flow: Natural class and method progression is interrupted by the poorly formatted block.