Source code
package junit.textui;
import java.io.PrintStream;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestResult;
import junit.framework.TestSuite;
import junit.runner.BaseTestRunner;
import junit.runner.Version;
/**
* A command line based tool to run tests.
* <pre>
* java junit.textui.TestRunner [-wait] TestCaseClass
* </pre>
* <p>
* TestRunner expects the name of a TestCase class as argument.
* If this class defines a static <code>suite</code> method it
* will be invoked and the returned test is run. Otherwise all
* the methods starting with "test" having no arguments are run.
* <p>
* When the wait command line argument is given TestRunner
* waits until the users types RETURN.
* <p>
* TestRunner prints a trace as the tests are executed followed by a
* summary at the end.
*/
public class TestRunner extends BaseTestRunner {
private ResultPrinter fPrinter;
public static final int SUCCESS_EXIT = 0;
public static final int FAILURE_EXIT = 1;
public static final int EXCEPTION_EXIT = 2;
/**
* Constructs a TestRunner.
*/
public TestRunner() {
this(System.out);
}
/**
* Constructs a TestRunner using the given stream for all the output
*/
public TestRunner(PrintStream writer) {
this(new ResultPrinter(writer));
}
/**
* Constructs a TestRunner using the given ResultPrinter all the output
*/
public TestRunner(ResultPrinter printer) {
fPrinter = printer;
}
/**
* Runs a suite extracted from a TestCase subclass.
*/
static public void run(Class<? extends TestCase> testClass) {
run(new TestSuite(testClass));
}
/**
* Runs a single test and collects its results.
* This method can be used to start a test run
* from your program.
* <pre>
* public static void main (String[] args) {
* test.textui.TestRunner.run(suite());
* }
* </pre>
*/
static public TestResult run(Test test) {
TestRunner runner = new TestRunner();
return runner.doRun(test);
}
/**
* Runs a single test and waits until the user
* types RETURN.
*/
static public void runAndWait(Test suite) {
TestRunner aTestRunner = new TestRunner();
aTestRunner.doRun(suite, true);
}
@Override
public void testFailed(int status, Test test, Throwable e) {
}
@Override
public void testStarted(String testName) {
}
@Override
public void testEnded(String testName) {
}
/**
* Creates the TestResult to be used for the test run.
*/
protected TestResult createTestResult() {
return new TestResult();
}
public TestResult doRun(Test test) {
return doRun(test, false);
}
public TestResult doRun(Test suite, boolean wait) {
TestResult result = createTestResult();
result.addListener(fPrinter);
long startTime = System.currentTimeMillis();
suite.run(result);
long endTime = System.currentTimeMillis();
long runTime = endTime - startTime;
fPrinter.print(result, runTime);
pause(wait);
return result;
}
protected void pause(boolean wait) {
if (!wait) return;
fPrinter.printWaitPrompt();
try {
System.in.read();
} catch (Exception e) {
}
}
public static void main(String args[]) {
TestRunner aTestRunner = new TestRunner();
try {
TestResult r = aTestRunner.start(args);
if (!r.wasSuccessful()) {
System.exit(FAILURE_EXIT);
}
System.exit(SUCCESS_EXIT);
} catch (Exception e) {
System.err.println(e.getMessage());
System.exit(EXCEPTION_EXIT);
}
}
/**
* Starts a test run. Analyzes the command line arguments and runs the given
* test suite.
*/
public TestResult start(String args[]) throws Exception {
String testCase = "";
String method = "";
boolean wait = false;
for (int i = 0; i < args.length; i++) {
if (args[i].equals("-wait")) {
wait = true;
} else if (args[i].equals("-c")) {
testCase = extractClassName(args[++i]);
} else if (args[i].equals("-m")) {
String arg = args[++i];
int lastIndex = arg.lastIndexOf('.');
testCase = arg.substring(0, lastIndex);
method = arg.substring(lastIndex + 1);
} else if (args[i].equals("-v")) {
System.err.println("JUnit " + Version.id() + " by Kent Beck and Erich Gamma");
} else {
testCase = args[i];
}
}
if (testCase.equals("")) {
throw new Exception("Usage: TestRunner [-wait] testCaseName, where name is the name of the TestCase class");
}
try {
if (!method.equals("")) {
return runSingleMethod(testCase, method, wait);
}
Test suite = getTest(testCase);
return doRun(suite, wait);
} catch (Exception e) {
throw new Exception("Could not create and run test suite: " + e);
}
}
protected TestResult runSingleMethod(String testCase, String method, boolean wait) throws Exception {
Class<? extends TestCase> testClass = loadSuiteClass(testCase).asSubclass(TestCase.class);
Test test = TestSuite.createTest(testClass, method);
return doRun(test, wait);
}
@Override
protected void runFailed(String message) {
System.err.println(message);
System.exit(FAILURE_EXIT);
}
public void setPrinter(ResultPrinter printer) {
fPrinter = printer;
}
}