Source code
package org.junit.experimental.theories.internal;
import java.util.Arrays;
import java.util.List;
import org.junit.experimental.theories.ParameterSignature;
import org.junit.experimental.theories.ParameterSupplier;
import org.junit.experimental.theories.PotentialAssignment;
public class BooleanSupplier extends ParameterSupplier {
@Override
public List<PotentialAssignment> getValueSources(ParameterSignature sig) {
return Arrays.asList(PotentialAssignment.forValue("true", true),
PotentialAssignment.forValue("false", false));
}
}
Run 1
The code is highly readable. It has a clear, single purpose: supplying boolean parameter values. The structure is logical, with a simple class extending ParameterSupplier and overriding a single method. Nesting is minimal, with only one method and a single return statement. Intent is explicit from the class and method names. Code length is concise and appropriate. Action granularity is reasonable, with two related assignment objects created in one line, which is idiomatic Java for list creation. Reading flow is natural: package declaration, imports, class declaration, method override, and return statement. Minor deductions: the multiple imports could be considered slightly verbose for such a short class, and the line break with alignment might be slightly non-standard for some formatters, but neither significantly impacts readability.
Run 2
The code is highly readable. It follows a clear, logical structure with a single class extending ParameterSupplier. Nesting is minimal—only a method override with a single return statement. Intent is immediately clear: supply boolean true/false values as potential assignments. The code is concise without being overly terse, using Arrays.asList to cleanly construct the list. Each action (creating the two PotentialAssignment objects) occurs on its own line, improving granularity. Reading flow is natural: package declaration, imports, class definition, method override, and return value all follow expected order. Minor deductions could be argued for not using a constant for repeated strings 'true'/'false', but this is negligible for such a short, focused utility class.
Run 3
The code is highly readable. It has a clean, logical structure with a single class and one overridden method. There is no unnecessary nesting; the method body is flat. The intent is clear: supply boolean parameter values for theories. The code is concise, with no redundant lines. Each action (creating and returning the list of assignments) is expressed clearly, and the reading flow is natural: class declaration, override annotation, method signature, and a straightforward return statement. Minor deductions are for the slightly long single return line and lack of explanatory comments, but these are not significant enough to impact readability strongly.
Run 1
Code Structure: Imports, class declaration, and the single overridden method are logically organized. Nesting: Minimal nesting, with no conditional or loop complexity. Clarity of intent: BooleanSupplier and getValueSources clearly express the purpose of providing true and false assignments; the unused sig parameter is required by the overridden method signature. Code length: Concise, with no unnecessary logic. Action granularity: A single return statement constructs the result, and each assignment appears on its own line. Reading flow: Natural top-to-bottom progression and aligned formatting make the implementation immediately understandable.
Run 2
Code Structure: A single focused class with organized imports and one overridden method. Nesting: No nested control flow. Clarity of intent: BooleanSupplier and the explicit true/false assignments clearly convey the purpose; the unused sig parameter follows the superclass contract. Code length: Concise, with no unnecessary logic. Action granularity: One return operation, with each assignment on its own line. Reading flow: Natural top-to-bottom organization and consistent formatting make the code easy to follow.
Run 3
Code Structure: Cleanly organized imports, class, and overridden method. Nesting: Minimal, with no conditionals or loops. Clarity of intent: BooleanSupplier clearly supplies the two boolean values, and descriptive factory calls make their representation explicit. Code length: Concise with no unnecessary logic. Action granularity: One return statement constructs the list; each assignment is visually separated across lines. Reading flow: Natural progression from declaration to implementation, with consistent indentation and formatting.