Source code
package org.junit.runners.model;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import org.junit.runners.BlockJUnit4ClassRunner;
/**
* Represents a field on a test class (currently used only for Rules in
* {@link BlockJUnit4ClassRunner}, but custom runners can make other uses)
*
* @since 4.7
*/
public class FrameworkField extends FrameworkMember<FrameworkField> {
private final Field fField;
FrameworkField(Field field) {
if (field == null) {
throw new NullPointerException(
"FrameworkField cannot be created without an underlying field.");
}
fField = field;
}
@Override
public String getName() {
return getField().getName();
}
public Annotation[] getAnnotations() {
return fField.getAnnotations();
}
@Override
public boolean isShadowedBy(FrameworkField otherMember) {
return otherMember.getName().equals(getName());
}
@Override
protected int getModifiers() {
return fField.getModifiers();
}
/**
* @return the underlying java Field
*/
public Field getField() {
return fField;
}
/**
* @return the underlying Java Field type
* @see java.lang.reflect.Field#getType()
*/
@Override
public Class<?> getType() {
return fField.getType();
}
@Override
public Class<?> getDeclaringClass() {
return fField.getDeclaringClass();
}
/**
* Attempts to retrieve the value of this field on {@code target}
*/
public Object get(Object target) throws IllegalArgumentException, IllegalAccessException {
return fField.get(target);
}
@Override
public String toString() {
return fField.toString();
}
}
Run 1
The code is well-structured and highly readable. It follows a clear logical organization with a single class wrapping a Java reflection Field. The methods are concise, each performing one clear action, and the field is properly encapsulated. The constructor validates input with a meaningful exception. JavaDoc comments on public methods explain the purpose without redundancy. The class naming and inheritance hierarchy are clear. Minor deductions: the `getName()` method unnecessarily delegates to `getField()` instead of directly using `fField`, and the `isShadowedBy()` method compares only by name, which could be slightly confusing without deeper context. Overall, the code demonstrates excellent readability with natural reading flow, shallow nesting, and clear intent throughout.
Run 2
The code is highly readable due to its clear structure, flat nesting, and consistent naming conventions. Each method is concise and performs a single action, which improves comprehension. The class extends FrameworkMember and wraps a Field object, with methods delegating to the underlying field—intent is obvious. Javadoc comments are present for non-obvious methods and the constructor validates input properly. There is no deep nesting or tangled logic. Reading flow follows a logical order: constructor, overrides, public accessors, and utility methods. The only minor deductions are the slightly redundant getField() calls in getName() and toString(), and the lack of an @Override on getAnnotations(), though it implements an abstract method. Overall, the code is clean, well-organized, and easy to follow.
Run 3
The code is highly readable. It has a clear class structure with a single responsibility, wrapping a Field. Nesting is minimal; the only deep indentation is in the constructor's null check, which is acceptable. Intent is clear from method names and Javadoc. Code length is concise, with no unnecessary lines. Action granularity is one action per line. Reading flow is natural, with overrides grouped logically after the constructor. The only minor deductions are for the slightly verbose null check indentation and the unused import of 'Annotation', but these are trivial.
Run 1
Code Structure: A well-organized class with a single responsibility: wrapping a reflective Field. Nesting: Nearly flat, with only a simple constructor null check. Clarity of intent: Descriptive method names, straightforward delegation, and useful documentation make the purpose clear; the legacy name fField is slightly less natural than field. Code length: Concise, with short methods and no unnecessary logic. Action granularity: Each statement performs one clear action. Reading flow: Consistent formatting and predictable methods make the class easy to follow, though mixing direct fField access with getField() introduces minor stylistic inconsistency.
Run 2
Code Structure: A logically organized wrapper class with small, focused methods and a clear constructor validation step. Nesting: Minimal, with only one shallow conditional. Clarity of intent: Descriptive method names, straightforward delegation, and useful documentation make the purpose clear; the legacy name fField is slightly less natural than field. Code length: Concise, with no unnecessary logic or repetition beyond expected wrapper methods. Action granularity: Each statement performs one action, and methods generally delegate a single operation. Reading flow: Consistent formatting and predictable method bodies make the class easy to scan, although mixing direct fField access with getField() introduces a minor stylistic inconsistency.
Run 3
Code Structure: A logically organized wrapper class with small, focused methods and clear separation of responsibilities. Nesting: Almost entirely flat; only the constructor's null check introduces nesting. Clarity of intent: Method names, straightforward delegation, and targeted Javadoc make the purpose clear, although the legacy name fField is slightly less natural than field. Code length: Concise, with little unnecessary code; the repeated delegation is appropriate for the wrapper. Action granularity: Each statement performs one action, making individual operations easy to follow. Reading flow: Consistent formatting and predictable methods support smooth reading. Minor inconsistencies, such as using getField() in getName() but accessing fField directly elsewhere, slightly reduce uniformity.