Source code
package org.apache.kafka.common.test;
import org.apache.kafka.server.fault.FaultHandler;
import org.apache.kafka.server.fault.FaultHandlerException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* This is a fault handler suitable for use in JUnit tests. It will store the result of the first
* call to handleFault that was made.
*/
public class MockFaultHandler implements FaultHandler {
private static final Logger log = LoggerFactory.getLogger(MockFaultHandler.class);
private final String name;
private FaultHandlerException firstException = null;
private boolean ignore = false;
public MockFaultHandler(String a) {
this.name = a;
}
@Override
public synchronized RuntimeException a(String b, Throwable c) {
if (c == null) {
log.error("Encountered {} fault: {}", name, b);
} else {
log.error("Encountered {} fault: {}", name, b, c);
}
FaultHandlerException d = (c == null) ?
new FaultHandlerException(name + ": " + b) :
new FaultHandlerException(name + ": " + b +
": " + c.getMessage(), c);
if (firstException == null) {
firstException = d;
}
return firstException;
}
public synchronized void b() {
if (firstException != null && !ignore) {
throw firstException;
}
}
public synchronized FaultHandlerException c() {
return firstException;
}
public synchronized void d(boolean e) {
this.ignore = e;
}
}
Run 1
The code structure is logical but significantly hampered by poor naming conventions. Parameters and local variables use single-letter or cryptic names ('a', 'b', 'c', 'd', 'e') that obscure intent. The method names are also single letters, making the code ambiguous. Nesting is minimal, and action granularity is reasonable, but reading flow suffers due to unclear naming. The code is concise, but this conciseness comes at the cost of understandability. The ternary expressions are compact but slightly reduce readability. Proper documentation exists for the class, but it does not compensate for the internal naming issues.
Run 2
The code has a clear purpose and basic structure, but suffers from several readability issues. The method and parameter names (a, b, c, d, e) are meaningless, forcing readers to infer intent from usage rather than names. The class-level Javadoc is helpful, but method-level documentation is absent. While the nesting is minimal and action granularity is reasonable, the conditional logging and exception creation create some duplication. The abbreviation of variable names and lack of descriptive method signatures significantly impacts clarity of intent. The overall flow is logical but the naming conventions make it harder to follow than necessary. With proper naming (e.g., handleFault, maybeThrow, firstException, setIgnore), this would be a solid 17-18.
Run 3
The code has a clear purpose and decent structure, but readability suffers from poor naming and unconventional exception handling. The class is logically organized with fields separated from methods. Nesting is minimal (one if-else with nested ternary). However, method and parameter names like 'a', 'b', 'c', 'd', 'e' are cryptic and obscure intent. The ternary expressions are slightly dense, making the exception creation harder to scan. Action granularity is mostly one action per line. The reading flow is disrupted by inconsistent naming and the fact that handleFault always returns the *first* exception rather than the current one, which is unusual but at least documented. Overall, the structure is sound, but clarity of intent is significantly reduced by poor naming choices.
Run 1
Code Structure: Fields, constructor, fault handling, and accessors are logically organized into small methods. Nesting: Shallow conditionals keep control flow easy to follow. Clarity of intent: The class documentation and descriptive fields explain the overall purpose, but method names a, b, c, d and parameter names a–e obscure individual operations. The documentation references handleFault, while the implementation is named a, creating confusion. Code length: Compact without substantial unnecessary code, though repeated null checks add minor redundancy. Action granularity: Most lines perform one action; the multiline exception-construction ternary combines conditional selection, string composition, and construction. Reading flow: The main method follows a natural log-create-store-return sequence, but cryptic identifiers and the wrapped ternary interrupt readability.
Run 2
Code Structure: Fields, constructor, fault handling, and accessors are logically organized into small methods. Nesting: Shallow conditionals keep control flow easy to follow. Clarity of intent: The class documentation and descriptive fields explain the overall purpose, but single-letter method names, parameters, and local variables obscure individual operations. The documentation references handleFault, whereas the implemented method is named a, adding confusion. Code length: Compact and mostly appropriate, although the multiline ternary requires extra attention. Action granularity: Statements generally perform one action per line; the exception construction combines message formatting and object creation but remains manageable. Reading flow: Conventional Java layout and consistent formatting help, while opaque identifiers and the split ternary interrupt otherwise natural reading.
Run 3
Code Structure: Fields, constructor, fault handling, and accessors are logically organized into small methods. Nesting: Shallow conditionals keep control flow easy to follow. Clarity of intent: The class documentation and descriptive field names help, but single-letter method names and parameters obscure operations and require readers to infer their meaning. The documentation references handleFault, whereas the implementation is named a, creating confusion. Code length: Compact and largely free of unnecessary code, though exception construction spans several lines. Action granularity: Statements generally perform one action per line; the multiline ternary combines selection and construction but remains manageable. Reading flow: The overall sequence is natural, but cryptic identifiers and the split exception-construction expression interrupt comprehension.