Source code
package org.junit.internal.runners;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.List;
import org.junit.After;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.Test.None;
import org.junit.runners.BlockJUnit4ClassRunner;
/**
* @deprecated Included for backwards compatibility with JUnit 4.4. Will be
* removed in the next release. Please use
* {@link BlockJUnit4ClassRunner} in place of {@link JUnit4ClassRunner}.
*/
@Deprecated
public class TestMethod {
private final Method fMethod;
private TestClass fTestClass;
public TestMethod(Method method, TestClass testClass) {
fMethod = method;
fTestClass = testClass;
}
public boolean isIgnored() {
return fMethod.getAnnotation(Ignore.class) != null;
}
public long getTimeout() {
Test annotation = fMethod.getAnnotation(Test.class);
if (annotation == null) {
return 0;
}
long timeout = annotation.timeout();
return timeout;
}
protected Class<? extends Throwable> getExpectedException() {
Test annotation = fMethod.getAnnotation(Test.class);
if (annotation == null || annotation.expected() == None.class) {
return null;
} else {
return annotation.expected();
}
}
boolean isUnexpected(Throwable exception) {
return !getExpectedException().isAssignableFrom(exception.getClass());
}
boolean expectsException() {
return getExpectedException() != null;
}
List<Method> getBefores() {
return fTestClass.getAnnotatedMethods(Before.class);
}
List<Method> getAfters() {
return fTestClass.getAnnotatedMethods(After.class);
}
public void invoke(Object test) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException {
fMethod.invoke(test);
}
}
Run 1
The code is well-structured with a clear single responsibility: representing a test method. Methods are short, focused, and named descriptively (e.g., isIgnored, getTimeout, expectsException). Nesting is flat, with no conditional depth beyond one level. Intent is clear throughout the class, and each line performs a single action. The reading flow is natural, moving from simple checks to invocation. Minor deductions: the getExpectedException method could be slightly more concise by returning annotation.expected() directly after the guard clause, and the isUnexpected method will throw a NullPointerException if getExpectedException() returns null, which is a readability/robustness concern. Overall, the code is highly readable and easy to follow.
Run 2
The code is generally clear and well-structured, with small focused methods and minimal nesting. Field naming (fMethod, fTestClass) follows an older convention but is consistent. Most methods have a single clear purpose. However, `getTimeout()` could be simplified (the timeout variable is unnecessary), and `isUnexpected` assumes `getExpectedException()` never returns null, which is a potential runtime issue. The deprecated class and backward-compatibility context reduce clarity slightly. Overall, it is readable but not exceptional due to minor redundancy and a hidden null-risk in exception handling.
Run 3
The code is highly readable with clear, focused methods that each perform a single action. Structure is logical: fields, constructor, query methods, then invocation. Nesting is minimal (only one if-else and one if). Intent is obvious from method names like isIgnored, expectsException, and getBefores. Length is appropriate—no unnecessary verbosity. Action granularity is well-maintained, with each line doing one thing. Reading flow is natural top-to-bottom. Minor improvements could include simplifying getExpectedException’s else branch, but overall this is excellent readability.
Run 1
Code Structure: Well-organized class with small methods separating annotation inspection, lifecycle lookup, and invocation. Nesting: Very shallow, with simple conditionals and early returns. Clarity of intent: Descriptive method names and explicit types communicate purpose; legacy f-prefixed fields and isUnexpected's implicit requirement that an expected exception exists slightly reduce clarity. Code length: Concise overall, though getTimeout uses an unnecessary temporary variable and getExpectedException has a redundant else after return. Action granularity: Each statement performs a single clear action. Reading flow: Consistent formatting and straightforward delegation make the code easy to follow; the long invoke signature is a minor visual distraction.
Run 2
Code Structure: Well-organized class with small, focused methods and straightforward delegation. Nesting: Minimal nesting; simple conditionals keep control flow easy to follow. Clarity of intent: Descriptive method names and familiar JUnit annotations communicate purpose clearly, though the f-prefixed fields are dated and isUnexpected implicitly requires an expected exception to exist. Code length: Concise overall, with minor redundancy in getTimeout's temporary variable and getExpectedException's unnecessary else after return. Action granularity: Each statement performs a single clear action. Reading flow: Consistent formatting and logical method grouping support natural reading, although the long invoke signature slightly reduces scanability.
Run 3
Code Structure: Well-organized class with small, focused methods separating annotation lookup, lifecycle methods, and invocation. Nesting: Very shallow, with simple conditionals and early returns. Clarity of intent: Descriptive method names and familiar JUnit annotations make the purpose clear; legacy f-prefixed fields and the implicit requirement that isUnexpected() only run when an exception is expected slightly reduce clarity. Code length: Concise overall, though getTimeout() has an unnecessary local variable and getExpectedException() uses an avoidable else after return. Action granularity: Each statement performs a single clear action. Reading flow: Consistent formatting and straightforward delegation make the code easy to follow, with only the long invoke() declaration mildly interrupting the flow.