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);
}
}
}