Source code
package org.junit.experimental.categories;
import java.util.ArrayList;
import java.util.List;
import org.junit.internal.Classes;
import org.junit.runner.FilterFactory;
import org.junit.runner.FilterFactoryParams;
import org.junit.runner.manipulation.Filter;
/**
* Implementation of FilterFactory for Category filtering.
*/
abstract class CategoryFilterFactory implements FilterFactory {
/**
* Creates a {@link org.junit.experimental.categories.Categories.CategoryFilter} given a
* {@link FilterFactoryParams} argument.
*
* @param params Parameters needed to create the {@link Filter}
* @throws FilterNotCreatedException
*/
public Filter createFilter(FilterFactoryParams params) throws FilterNotCreatedException {
try {
return createFilter(parseCategories(params.getArgs()));
} catch (ClassNotFoundException e) {
throw new FilterNotCreatedException(e);
}
}
/**
* Creates a {@link org.junit.experimental.categories.Categories.CategoryFilter} given an array of classes.
*
* @param categories Category classes.
*/
protected abstract Filter createFilter(List<Class<?>> categories);
private List<Class<?>> parseCategories(String categories) throws ClassNotFoundException {
List<Class<?>> categoryClasses = new ArrayList<Class<?>>();
for (String category : categories.split(",")) {
Class<?> categoryClass = Classes.getClass(category);
categoryClasses.add(categoryClass);
}
return categoryClasses;
}
}
Run 1
The code is well-structured with clear separation of concerns: public API, abstract factory method, and private parsing logic. Nesting is minimal, with only a try-catch block and a simple loop. Intent is clearly documented through Javadoc and method names. The code is concise without unnecessary boilerplate. Action granularity is appropriate—each logical step (splitting, resolving class, adding to list) is on its own line. Reading flow is natural, following top-down order from public method to implementation details. Minor deductions: the comment '@throws FilterNotCreatedException' could be more descriptive, and the parsing logic could potentially be extracted into a utility class if reused elsewhere. Overall, this is highly readable, production-quality code.
Run 2
The code is well-structured and highly readable. It has a clear single responsibility per method: createFilter delegates parsing and filter creation, while parseCategories handles conversion. Nesting is minimal, with a simple try-catch and a for loop. Intent is explicit through descriptive method names and Javadoc. The code is concise without being overly compressed—each line performs one logical action, improving readability. Reading flow is natural: public API first, then abstract protected method, then private helper. Minor deductions: the exception handling adds slight indirection, and the split(",") magic delimiter could be a named constant, but overall this is exemplary clarity.
Run 3
The code is highly readable with clear structure and purpose. It follows single responsibility by separating filter creation, category parsing, and exception handling. Nesting is minimal, with only one try-catch and one loop. Method names are descriptive and intent is obvious. The code is concise, avoiding unnecessary verbosity. Each action is on its own line, and reading flow is natural from high-level filter creation down to parsing details. Minor deductions: 'parseCategories' could be static, and the Javadoc could include @throws for the abstract method.
Run 1
Code Structure: Well-organized methods separate argument parsing, filter creation, and exception translation. Nesting: Shallow, with only a simple try/catch and loop. Clarity of intent: Descriptive names and Javadoc make category-based filter construction easy to understand, though overloaded createFilter methods require slight attention. Code length: Concise implementation; some documentation is repetitive. Action granularity: Each statement performs one clear action, and the intermediate categoryClass variable makes class loading explicit. Reading flow: The public entry point leads naturally to the abstract extension point and private parsing helper. Consistent formatting supports readability.
Run 2
Code Structure: Well organized, separating parameter handling, category parsing, and subclass-specific filter creation. Nesting: Shallow, with only a try/catch and a simple loop. Clarity of intent: Descriptive names and documentation make the purpose clear, though overloaded createFilter methods require slight attention. Code length: Concise overall; lengthy fully qualified Javadoc references add minor visual clutter. Action granularity: Statements generally perform one action per line, and class loading is separated from list insertion. Reading flow: Natural top-to-bottom progression from the public entry point to the abstract extension point and private parsing helper. Minor whitespace and documentation verbosity slightly reduce readability.
Run 3
Code Structure: Clearly separates argument parsing, filter creation, and exception translation into focused methods. Nesting: Minimal, with only a simple try/catch and a flat loop. Clarity of intent: Descriptive method and variable names, supported by Javadoc, make category filtering easy to understand; overloaded createFilter methods introduce slight ambiguity. Code length: Concise overall, though some documentation and blank lines are more verbose than necessary. Action granularity: Statements generally perform one action each; the nested calls in the return statement compactly combine argument retrieval, parsing, and filter creation. Reading flow: Natural progression from the public entry point to the abstract extension point and private parsing helper.