Source code
package org.junit.experimental.theories.suppliers;
import java.util.ArrayList;
import java.util.List;
import org.junit.experimental.theories.ParameterSignature;
import org.junit.experimental.theories.ParameterSupplier;
import org.junit.experimental.theories.PotentialAssignment;
public class TestedOnSupplier extends ParameterSupplier {
@Override
public List<PotentialAssignment> getValueSources(ParameterSignature sig) {
List<PotentialAssignment> list = new ArrayList<PotentialAssignment>();
TestedOn testedOn = sig.getAnnotation(TestedOn.class);
int[] ints = testedOn.ints();
for (final int i : ints) {
list.add(PotentialAssignment.forValue("ints", i));
}
return list;
}
}
Run 1
The code is well-structured and highly readable. It follows a clear logical organization: imports, class declaration, single overridden method. Nesting is flat, with only a single loop and no conditional complexity. Intent is immediately clear — the supplier extracts an annotation, reads its integer values, and converts them into potential assignments. The code is concise, with no unnecessary verbosity or redundancy. Each line performs a single logical action, and the reading flow is natural from top to bottom: retrieve annotation, access values, iterate, build list, return. Minor improvements could include using a diamond operator for the list instantiation, but overall this is exemplary readable code.
Run 2
The code is well-structured and readable. It follows a clear logical flow: fetch the annotation, extract values, convert them into assignments, and return them. The nesting is minimal (single loop), and each line generally performs one action. Variable names are descriptive, and the method's purpose is immediately clear. The only minor deductions are for the fully qualified types in the generic declaration (which slightly adds noise) and the absence of a null check on testedOn, though that may be assumed by the framework. Overall, it is concise and maintainable.
Run 3
The code is highly readable. It has a clear, logical structure with a single focused method. Nesting is minimal (one loop); intent is unambiguous from method and variable names. The code is concise, avoiding boilerplate or unnecessary complexity. Each line performs one clear action, and the flow reads naturally: retrieve annotation, extract values, build list, return result. Minor improvement could modernize the code by using diamond operator or streams, but readability is not affected.
Run 1
Code Structure: The class contains one focused method with logically ordered steps. Nesting: A single loop keeps nesting shallow. Clarity of intent: Reading annotation values and converting them into potential assignments is straightforward, although generic names such as list, ints, and i provide limited context. Code length: The implementation is concise, with no unnecessary logic. Action granularity: Each statement performs one clear action. Reading flow: Imports, annotation lookup, value extraction, iteration, and return follow a natural sequence. More descriptive variable names would improve an already highly readable implementation.
Run 2
Code Structure: A single focused method is logically organized, with imports and class declaration clearly separated. Nesting: Only one loop, keeping the code shallow and easy to follow. Clarity of intent: The annotation values are plainly converted into potential assignments, though generic names such as list, sig, and ints offer limited context. Code length: Concise, with no unnecessary logic or repetition. Action granularity: Each statement performs one distinct action on its own line. Reading flow: Naturally progresses from creating the result list to retrieving values, transforming them, and returning the result.
Run 3
Code Structure: A single focused method logically organizes annotation retrieval, value conversion, and return. Nesting: Only one shallow loop, making control flow easy to follow. Clarity of intent: The method clearly converts annotated integers into potential assignments, though generic names such as list and ints are less descriptive than they could be. Code length: Concise, with no unnecessary logic or repetition. Action granularity: Each statement performs one distinct action on its own line. Reading flow: The straightforward top-to-bottom sequence is natural and easy to trace.