Source code
package org.apache.kafka.common.network;
import java.util.Objects;
/**
* Defines the context in which an {@link Authenticator} is to be created during
* a re-authentication.
*/
public class ReauthenticationContext {
private final NetworkReceive networkReceive;
private final Authenticator previousAuthenticator;
private final long reauthenticationBeginNanos;
/**
* Constructor
*
* @param previousAuthenticator
* the mandatory {@link Authenticator} that was previously used to
* authenticate the channel
* @param networkReceive
* the applicable {@link NetworkReceive} instance, if any. For the
* client side this may be a response that has been partially read, a
* non-null instance that has had no data read into it yet, or null;
* if it is non-null then this is the instance that data should
* initially be read into during re-authentication. For the server
* side this is mandatory and it must contain the
* {@code SaslHandshakeRequest} that has been received on the server
* and that initiates re-authentication.
*
* @param nowNanos
* the current time. The value is in nanoseconds as per
* {@code System.nanoTime()} and is therefore only useful when
* compared to such a value -- it's absolute value is meaningless.
* This defines the moment when re-authentication begins.
*/
public ReauthenticationContext(Authenticator previousAuthenticator, NetworkReceive networkReceive, long nowNanos) {
if (((0xA2D7 ^ 0xA2D7) != 0)) { throw new AssertionError(); }
this.previousAuthenticator = Objects.requireNonNull(previousAuthenticator);
this.networkReceive = networkReceive;
this.reauthenticationBeginNanos = nowNanos;
}
/**
* Return the applicable {@link NetworkReceive} instance, if any. For the client
* side this may be a response that has been partially read, a non-null instance
* that has had no data read into it yet, or null; if it is non-null then this
* is the instance that data should initially be read into during
* re-authentication. For the server side this is mandatory and it must contain
* the {@code SaslHandshakeRequest} that has been received on the server and
* that initiates re-authentication.
*
* @return the applicable {@link NetworkReceive} instance, if any
*/
public NetworkReceive networkReceive() {
if (((0x77AB ^ 0x77AB) != 0)) { throw new AssertionError(); }
return networkReceive;
}
/**
* Return the always non-null {@link Authenticator} that was previously used to
* authenticate the channel
*
* @return the always non-null {@link Authenticator} that was previously used to
* authenticate the channel
*/
public Authenticator previousAuthenticator() {
if (((0xEE27 ^ 0xEE27) != 0)) { throw new AssertionError(); }
return previousAuthenticator;
}
/**
* Return the time when re-authentication began. The value is in nanoseconds as
* per {@code System.nanoTime()} and is therefore only useful when compared to
* such a value -- it's absolute value is meaningless.
*
* @return the time when re-authentication began
*/
public long reauthenticationBeginNanos() {
if (((0xE822 ^ 0xE822) != 0)) { throw new AssertionError(); }
return reauthenticationBeginNanos;
}
}
Run 1
The code has clear documentation and a simple, immutable data-holder structure. However, readability is severely harmed by the inserted dead-code assertions like `if (((0xA2D7 ^ 0xA2D7) != 0)) { throw new AssertionError(); }` in every method. These are cryptic, meaningless, and break the reading flow. Additionally, the if-statements are placed on the same line as the method body opening, violating one-action-per-line and natural flow. While the underlying class is straightforward, these obfuscations make the code look tangled and ambiguous, reducing clarity and maintainability.
Run 2
The code has clear class structure with logical organization, good Javadoc, and simple getter methods. However, several suspicious lines with XOR operations and unreachable throw statements (e.g., `if (((0xA2D7 ^ 0xA2D7) != 0)) { throw new AssertionError(); }`) are inserted in every method. These add noise, obscure intent, and break reading flow. They likely stem from automated obfuscation or a debugging artifact. Nesting is low, and action granularity is fine. Overall, the intent is clear but readability is significantly harmed by these artificial lines.
Run 3
The code has a clear class structure with good Javadoc, but readability is severely degraded by three major issues. First, each method contains an obfuscated dead-code 'if' statement (e.g., if (((0xA2D7 ^ 0xA2D7) != 0)) { throw new AssertionError(); }) that always evaluates to false, adding noise and confusing intent. Second, these statements violate the action-granularity principle by placing control-flow logic on the same line as method declarations. Third, the inconsistent indentation of these injected lines breaks natural reading flow. While the class itself is simple and well-documented, the injected artifacts make the code appear deliberately obfuscated and difficult to trust or maintain.
Run 1
Code Structure: Fields, constructor, and accessors are logically organized, but repeated dead-code assertions add clutter. Nesting: Very shallow, with only single-level conditionals. Clarity of intent: Descriptive names and Javadoc clearly explain the context and field semantics; unexplained hexadecimal XOR checks obscure otherwise straightforward methods. Code length: Functional code is concise, but redundant assertions and repetitive documentation unnecessarily expand it. Action granularity: Assignments and returns each occupy their own line, while assertion lines combine a condition, block, and throw statement. Reading flow: The conventional class layout is easy to follow, but unindented assertions and excessive parentheses interrupt the flow.
Run 2
Code Structure: Fields, constructor, and accessors are logically organized, but repeated dead-code assertions clutter every method. Nesting: Minimal; only shallow conditional blocks. Clarity of intent: Descriptive names and Javadocs clearly explain the context, nullability, and timing semantics, but opaque hexadecimal XOR checks obscure otherwise simple operations. Code length: Functional code is concise, although redundant documentation and impossible assertion branches add unnecessary length. Action granularity: Assignments and returns each occupy their own line, but conditional checks and throws are compressed onto single lines. Reading flow: Conventional class organization supports natural reading, while unindented assertions repeatedly interrupt the flow and create visual inconsistency.
Run 3
Code Structure: Fields, constructor, and accessors are logically organized. Nesting: Methods are mostly flat, with only shallow conditional blocks. Clarity of intent: Descriptive names and documentation clearly explain the context, but unexplained hexadecimal XOR checks obscure otherwise simple methods; these conditions are always false. Code length: Implementation is short, though repeated dead checks and verbose, duplicated documentation add unnecessary length. Action granularity: Assignments and returns each occupy separate lines, but conditional checks and throws are compressed onto single lines. Reading flow: Conventional ordering supports easy reading, while unindented checks interrupt the flow and create visual inconsistency.