1package junit.textui;
2
3
4import java.io.PrintStream;
5
6import junit.framework.Test;
7import junit.framework.TestCase;
8import junit.framework.TestResult;
9import junit.framework.TestSuite;
10import junit.runner.BaseTestRunner;
11import junit.runner.Version;
12
13/**
14 * A command line based tool to run tests.
15 * <pre>
16 * java junit.textui.TestRunner [-wait] TestCaseClass
17 * </pre>
18 *
19 * <p>TestRunner expects the name of a TestCase class as argument.
20 * If this class defines a static <code>suite</code> method it
21 * will be invoked and the returned test is run. Otherwise all
22 * the methods starting with "test" having no arguments are run.</p>
23 *
24 * <p> When the wait command line argument is given TestRunner
25 * waits until the users types RETURN.</p>
26 *
27 * <p>TestRunner prints a trace as the tests are executed followed by a
28 * summary at the end.</p>
29 */
30public class TestRunner extends BaseTestRunner {
31	private ResultPrinter fPrinter;
32
33	public static final int SUCCESS_EXIT= 0;
34	public static final int FAILURE_EXIT= 1;
35	public static final int EXCEPTION_EXIT= 2;
36
37	/**
38	 * Constructs a TestRunner.
39	 */
40	public TestRunner() {
41		this(System.out);
42	}
43
44	/**
45	 * Constructs a TestRunner using the given stream for all the output
46	 */
47	public TestRunner(PrintStream writer) {
48		this(new ResultPrinter(writer));
49	}
50
51	/**
52	 * Constructs a TestRunner using the given ResultPrinter all the output
53	 */
54	public TestRunner(ResultPrinter printer) {
55		fPrinter= printer;
56	}
57
58	/**
59	 * Runs a suite extracted from a TestCase subclass.
60	 */
61	static public void run(Class<? extends TestCase> testClass) {
62		run(new TestSuite(testClass));
63	}
64
65	/**
66	 * Runs a single test and collects its results.
67	 * This method can be used to start a test run
68	 * from your program.
69	 * <pre>
70	 * public static void main (String[] args) {
71	 *    test.textui.TestRunner.run(suite());
72	 * }
73	 * </pre>
74	 */
75	static public TestResult run(Test test) {
76		TestRunner runner= new TestRunner();
77		return runner.doRun(test);
78	}
79
80	/**
81	 * Runs a single test and waits until the user
82	 * types RETURN.
83	 */
84	static public void runAndWait(Test suite) {
85		TestRunner aTestRunner= new TestRunner();
86		aTestRunner.doRun(suite, true);
87	}
88
89	@Override
90	public void testFailed(int status, Test test, Throwable t) {
91	}
92
93	@Override
94	public void testStarted(String testName) {
95	}
96
97	@Override
98	public void testEnded(String testName) {
99	}
100
101	/**
102	 * Creates the TestResult to be used for the test run.
103	 */
104	protected TestResult createTestResult() {
105		return new TestResult();
106	}
107
108	public TestResult doRun(Test test) {
109		return doRun(test, false);
110	}
111
112	public TestResult doRun(Test suite, boolean wait) {
113		TestResult result= createTestResult();
114		result.addListener(fPrinter);
115		long startTime= System.currentTimeMillis();
116		suite.run(result);
117		long endTime= System.currentTimeMillis();
118		long runTime= endTime-startTime;
119		fPrinter.print(result, runTime);
120
121		pause(wait);
122		return result;
123	}
124
125	protected void pause(boolean wait) {
126		if (!wait) return;
127		fPrinter.printWaitPrompt();
128		try {
129			System.in.read();
130		}
131		catch(Exception e) {
132		}
133	}
134
135	public static void main(String args[]) {
136		TestRunner aTestRunner= new TestRunner();
137		try {
138			TestResult r= aTestRunner.start(args);
139			if (!r.wasSuccessful())
140				System.exit(FAILURE_EXIT);
141			System.exit(SUCCESS_EXIT);
142		} catch(Exception e) {
143			System.err.println(e.getMessage());
144			System.exit(EXCEPTION_EXIT);
145		}
146	}
147
148	/**
149	 * Starts a test run. Analyzes the command line arguments and runs the given
150	 * test suite.
151	 */
152	public TestResult start(String args[]) throws Exception {
153		String testCase= "";
154		String method= "";
155		boolean wait= false;
156
157		for (int i= 0; i < args.length; i++) {
158			if (args[i].equals("-wait"))
159				wait= true;
160			else if (args[i].equals("-c"))
161				testCase= extractClassName(args[++i]);
162			else if (args[i].equals("-m")) {
163				String arg= args[++i];
164				int lastIndex= arg.lastIndexOf('.');
165				testCase= arg.substring(0, lastIndex);
166				method= arg.substring(lastIndex + 1);
167			} else if (args[i].equals("-v"))
168				System.err.println("JUnit " + Version.id() + " by Kent Beck and Erich Gamma");
169			else
170				testCase= args[i];
171		}
172
173		if (testCase.equals(""))
174			throw new Exception("Usage: TestRunner [-wait] testCaseName, where name is the name of the TestCase class");
175
176		try {
177			if (!method.equals(""))
178				return runSingleMethod(testCase, method, wait);
179			Test suite= getTest(testCase);
180			return doRun(suite, wait);
181		} catch (Exception e) {
182			throw new Exception("Could not create and run test suite: " + e);
183		}
184	}
185
186	protected TestResult runSingleMethod(String testCase, String method, boolean wait) throws Exception {
187		Class<? extends TestCase> testClass= loadSuiteClass(testCase).asSubclass(TestCase.class);
188		Test test= TestSuite.createTest(testClass, method);
189		return doRun(test, wait);
190	}
191
192	@Override
193	protected void runFailed(String message) {
194		System.err.println(message);
195		System.exit(FAILURE_EXIT);
196	}
197
198	public void setPrinter(ResultPrinter printer) {
199		fPrinter= printer;
200	}
201
202
203}