Source code
package org.junit.internal.builders;
import org.junit.internal.runners.SuiteMethod;
import org.junit.runner.Runner;
import org.junit.runners.model.RunnerBuilder;
public class SuiteMethodBuilder extends RunnerBuilder {
@Override
public Runner runnerForClass(Class<?> each) throws Throwable {
if (hasSuiteMethod(each)) {
return new SuiteMethod(each);
}
return null;
}
public boolean hasSuiteMethod(Class<?> testClass) {
try {
testClass.getMethod("suite");
} catch (NoSuchMethodException e) {
return false;
}
return true;
}
}
Run 1
The code is highly readable with a clear, single-purpose class structure. It maintains flat nesting with early returns, making the control flow straightforward. Method names clearly express intent, and the use of a try-catch block appropriately handles the expected exception without obscuring the logic. Overall length is concise, each line performs a single action, and the reading flow is natural. Minor potential improvement could be using a more descriptive method name than `hasSuiteMethod` to clarify the reflection-based check, but this does not significantly impact readability.
Run 2
The code is highly readable due to its clear structure and concise implementation. The class has a single responsibility, and the methods are short with clear intent. There is minimal nesting, only one level inside methods, and the reading flow is natural. The action granularity is appropriate, with one action per line. One minor ambiguity is that hasSuiteMethod returns false only for NoSuchMethodException, while other exceptions propagate, which could be slightly clearer. Overall, the code is straightforward and well-organized.
Run 3
The code is highly readable with a clear, logical structure. The class has a single responsibility and is well-organized. Nesting is minimal, with only one level of indentation from the if statement and try-catch block. The intent of both methods is immediately clear from their names. The code is concise - no unnecessary boilerplate or redundant operations. Each method performs one action per line, maintaining good granularity. The reading flow is natural: the override method first checks for a suite method, then constructs the appropriate runner. The only minor issue is that hasSuiteMethod could be simplified using reflection's method checking alternative, but the current implementation is straightforward and easy to understand.
Run 1
Code Structure: Two focused methods cleanly separate runner creation from suite-method detection. Nesting: Shallow conditional and try/catch blocks make the code easy to follow. Clarity of intent: Class and method names clearly communicate purpose, although the parameter name 'each' is vague and returning null relies on framework conventions. Code length: Compact with no unnecessary implementation detail. Action granularity: Each statement performs a single action. Reading flow: The primary operation appears first, followed by its helper, providing a natural top-down flow. Exception-based method detection is understandable but slightly less direct than an explicit predicate.
Run 2
Code Structure: Two focused methods cleanly separate runner construction from suite-method detection. Nesting: Minimal nesting keeps both methods easy to scan. Clarity of intent: Class and method names communicate their purposes, although the parameter name 'each' is vague and the null return convention is unexplained. Code length: Compact without unnecessary boilerplate or repetition. Action granularity: Each statement performs one clear action. Reading flow: The main method delegates naturally to a straightforward helper, with simple return paths. Reflection-based detection is understandable, though a brief explanation of what qualifies as a suite method could improve clarity.
Run 3
Code Structure: Two small methods cleanly separate runner creation from suite-method detection. Nesting: A single conditional and a simple try/catch keep nesting shallow. Clarity of intent: Class and method names clearly convey purpose, though 'each' is vague and returning null relies on an implicit framework convention. Code length: Concise, with no unnecessary statements or duplication. Action granularity: Each statement performs one action, making individual steps easy to follow. Reading flow: The main operation appears first, followed by its helper, providing a natural top-down flow. Exception-based detection is straightforward, although familiarity with reflection helps explain why getMethod is called without using its result.