| package org.junit.runner; |
| |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.List; |
| |
| import org.junit.internal.Classes; |
| import org.junit.runner.FilterFactory.FilterNotCreatedException; |
| import org.junit.runner.manipulation.Filter; |
| import org.junit.runners.model.InitializationError; |
| |
| class JUnitCommandLineParseResult { |
| private final List<String> filterSpecs = new ArrayList<String>(); |
| private final List<Class<?>> classes = new ArrayList<Class<?>>(); |
| private final List<Throwable> parserErrors = new ArrayList<Throwable>(); |
| |
| /** |
| * Do not use. Testing purposes only. |
| */ |
| JUnitCommandLineParseResult() {} |
| |
| /** |
| * Returns filter specs parsed from command line. |
| */ |
| public List<String> getFilterSpecs() { |
| return Collections.unmodifiableList(filterSpecs); |
| } |
| |
| /** |
| * Returns test classes parsed from command line. |
| */ |
| public List<Class<?>> getClasses() { |
| return Collections.unmodifiableList(classes); |
| } |
| |
| /** |
| * Parses the arguments. |
| * |
| * @param args Arguments |
| */ |
| public static JUnitCommandLineParseResult parse(String[] args) { |
| JUnitCommandLineParseResult result = new JUnitCommandLineParseResult(); |
| |
| result.parseArgs(args); |
| |
| return result; |
| } |
| |
| private void parseArgs(String[] args) { |
| parseParameters(parseOptions(args)); |
| } |
| |
| String[] parseOptions(String... args) { |
| for (int i = 0; i != args.length; ++i) { |
| String arg = args[i]; |
| |
| if (arg.equals("--")) { |
| return copyArray(args, i + 1, args.length); |
| } else if (arg.startsWith("--")) { |
| if (arg.startsWith("--filter=") || arg.equals("--filter")) { |
| String filterSpec; |
| if (arg.equals("--filter")) { |
| ++i; |
| |
| if (i < args.length) { |
| filterSpec = args[i]; |
| } else { |
| parserErrors.add(new CommandLineParserError(arg + " value not specified")); |
| break; |
| } |
| } else { |
| filterSpec = arg.substring(arg.indexOf('=') + 1); |
| } |
| |
| filterSpecs.add(filterSpec); |
| } else { |
| parserErrors.add(new CommandLineParserError("JUnit knows nothing about the " + arg + " option")); |
| } |
| } else { |
| return copyArray(args, i, args.length); |
| } |
| } |
| |
| return new String[]{}; |
| } |
| |
| private String[] copyArray(String[] args, int from, int to) { |
| String[] result = new String[to - from]; |
| for (int j = from; j != to; ++j) { |
| result[j - from] = args[j]; |
| } |
| return result; |
| } |
| |
| void parseParameters(String[] args) { |
| for (String arg : args) { |
| try { |
| classes.add(Classes.getClass(arg)); |
| } catch (ClassNotFoundException e) { |
| parserErrors.add(new IllegalArgumentException("Could not find class [" + arg + "]", e)); |
| } |
| } |
| } |
| |
| private Request errorReport(Throwable cause) { |
| return Request.errorReport(JUnitCommandLineParseResult.class, cause); |
| } |
| |
| /** |
| * Creates a {@link Request}. |
| * |
| * @param computer {@link Computer} to be used. |
| */ |
| public Request createRequest(Computer computer) { |
| if (parserErrors.isEmpty()) { |
| Request request = Request.classes( |
| computer, classes.toArray(new Class<?>[classes.size()])); |
| return applyFilterSpecs(request); |
| } else { |
| return errorReport(new InitializationError(parserErrors)); |
| } |
| } |
| |
| private Request applyFilterSpecs(Request request) { |
| try { |
| for (String filterSpec : filterSpecs) { |
| Filter filter = FilterFactories.createFilterFromFilterSpec( |
| request, filterSpec); |
| request = request.filterWith(filter); |
| } |
| return request; |
| } catch (FilterNotCreatedException e) { |
| return errorReport(e); |
| } |
| } |
| |
| /** |
| * Exception used if there's a problem parsing the command line. |
| */ |
| public static class CommandLineParserError extends Exception { |
| private static final long serialVersionUID= 1L; |
| |
| public CommandLineParserError(String message) { |
| super(message); |
| } |
| } |
| } |