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) { | |
ArrayList<String> result = new ArrayList<String>(); | |
for (int j = from; j != to; ++j) { | |
result.add(args[j]); | |
} | |
return result.toArray(new String[result.size()]); | |
} | |
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); | |
} | |
} | |
} |