001 package junit.framework;
002
003 import java.lang.reflect.InvocationTargetException;
004 import java.lang.reflect.Method;
005 import java.lang.reflect.Modifier;
006
007 /**
008 * A test case defines the fixture to run multiple tests. To define a test case<br/>
009 * <ol>
010 * <li>implement a subclass of <code>TestCase</code></li>
011 * <li>define instance variables that store the state of the fixture</li>
012 * <li>initialize the fixture state by overriding {@link #setUp()}</li>
013 * <li>clean-up after a test by overriding {@link #tearDown()}.</li>
014 * </ol>
015 * Each test runs in its own fixture so there
016 * can be no side effects among test runs.
017 * Here is an example:
018 * <pre>
019 * public class MathTest extends TestCase {
020 * protected double fValue1;
021 * protected double fValue2;
022 *
023 * protected void setUp() {
024 * fValue1= 2.0;
025 * fValue2= 3.0;
026 * }
027 * }
028 * </pre>
029 *
030 * For each test implement a method which interacts
031 * with the fixture. Verify the expected results with assertions specified
032 * by calling {@link junit.framework.Assert#assertTrue(String, boolean)} with a boolean.
033 * <pre>
034 * public void testAdd() {
035 * double result= fValue1 + fValue2;
036 * assertTrue(result == 5.0);
037 * }
038 * </pre>
039 *
040 * Once the methods are defined you can run them. The framework supports
041 * both a static type safe and more dynamic way to run a test.
042 * In the static way you override the runTest method and define the method to
043 * be invoked. A convenient way to do so is with an anonymous inner class.
044 * <pre>
045 * TestCase test= new MathTest("add") {
046 * public void runTest() {
047 * testAdd();
048 * }
049 * };
050 * test.run();
051 * </pre>
052 * The dynamic way uses reflection to implement {@link #runTest()}. It dynamically finds
053 * and invokes a method.
054 * In this case the name of the test case has to correspond to the test method
055 * to be run.
056 * <pre>
057 * TestCase test= new MathTest("testAdd");
058 * test.run();
059 * </pre>
060 *
061 * The tests to be run can be collected into a TestSuite. JUnit provides
062 * different <i>test runners</i> which can run a test suite and collect the results.
063 * A test runner either expects a static method <code>suite</code> as the entry
064 * point to get a test to run or it will extract the suite automatically.
065 * <pre>
066 * public static Test suite() {
067 * suite.addTest(new MathTest("testAdd"));
068 * suite.addTest(new MathTest("testDivideByZero"));
069 * return suite;
070 * }
071 * </pre>
072 *
073 * @see TestResult
074 * @see TestSuite
075 */
076 @SuppressWarnings("deprecation")
077 public abstract class TestCase extends Assert implements Test {
078 /**
079 * the name of the test case
080 */
081 private String fName;
082
083 /**
084 * No-arg constructor to enable serialization. This method
085 * is not intended to be used by mere mortals without calling setName().
086 */
087 public TestCase() {
088 fName = null;
089 }
090
091 /**
092 * Constructs a test case with the given name.
093 */
094 public TestCase(String name) {
095 fName = name;
096 }
097
098 /**
099 * Counts the number of test cases executed by run(TestResult result).
100 */
101 public int countTestCases() {
102 return 1;
103 }
104
105 /**
106 * Creates a default TestResult object.
107 *
108 * @see TestResult
109 */
110 protected TestResult createResult() {
111 return new TestResult();
112 }
113
114 /**
115 * A convenience method to run this test, collecting the results with a
116 * default TestResult object.
117 *
118 * @see TestResult
119 */
120 public TestResult run() {
121 TestResult result = createResult();
122 run(result);
123 return result;
124 }
125
126 /**
127 * Runs the test case and collects the results in TestResult.
128 */
129 public void run(TestResult result) {
130 result.run(this);
131 }
132
133 /**
134 * Runs the bare test sequence.
135 *
136 * @throws Throwable if any exception is thrown
137 */
138 public void runBare() throws Throwable {
139 Throwable exception = null;
140 setUp();
141 try {
142 runTest();
143 } catch (Throwable running) {
144 exception = running;
145 } finally {
146 try {
147 tearDown();
148 } catch (Throwable tearingDown) {
149 if (exception == null) exception = tearingDown;
150 }
151 }
152 if (exception != null) throw exception;
153 }
154
155 /**
156 * Override to run the test and assert its state.
157 *
158 * @throws Throwable if any exception is thrown
159 */
160 protected void runTest() throws Throwable {
161 assertNotNull("TestCase.fName cannot be null", fName); // Some VMs crash when calling getMethod(null,null);
162 Method runMethod = null;
163 try {
164 // use getMethod to get all public inherited
165 // methods. getDeclaredMethods returns all
166 // methods of this class but excludes the
167 // inherited ones.
168 runMethod = getClass().getMethod(fName, (Class[]) null);
169 } catch (NoSuchMethodException e) {
170 fail("Method \"" + fName + "\" not found");
171 }
172 if (!Modifier.isPublic(runMethod.getModifiers())) {
173 fail("Method \"" + fName + "\" should be public");
174 }
175
176 try {
177 runMethod.invoke(this);
178 } catch (InvocationTargetException e) {
179 e.fillInStackTrace();
180 throw e.getTargetException();
181 } catch (IllegalAccessException e) {
182 e.fillInStackTrace();
183 throw e;
184 }
185 }
186
187 /**
188 * Asserts that a condition is true. If it isn't it throws
189 * an AssertionFailedError with the given message.
190 */
191 public static void assertTrue(String message, boolean condition) {
192 Assert.assertTrue(message, condition);
193 }
194
195 /**
196 * Asserts that a condition is true. If it isn't it throws
197 * an AssertionFailedError.
198 */
199 public static void assertTrue(boolean condition) {
200 Assert.assertTrue(condition);
201 }
202
203 /**
204 * Asserts that a condition is false. If it isn't it throws
205 * an AssertionFailedError with the given message.
206 */
207 public static void assertFalse(String message, boolean condition) {
208 Assert.assertFalse(message, condition);
209 }
210
211 /**
212 * Asserts that a condition is false. If it isn't it throws
213 * an AssertionFailedError.
214 */
215 public static void assertFalse(boolean condition) {
216 Assert.assertFalse(condition);
217 }
218
219 /**
220 * Fails a test with the given message.
221 */
222 public static void fail(String message) {
223 Assert.fail(message);
224 }
225
226 /**
227 * Fails a test with no message.
228 */
229 public static void fail() {
230 Assert.fail();
231 }
232
233 /**
234 * Asserts that two objects are equal. If they are not
235 * an AssertionFailedError is thrown with the given message.
236 */
237 public static void assertEquals(String message, Object expected, Object actual) {
238 Assert.assertEquals(message, expected, actual);
239 }
240
241 /**
242 * Asserts that two objects are equal. If they are not
243 * an AssertionFailedError is thrown.
244 */
245 public static void assertEquals(Object expected, Object actual) {
246 Assert.assertEquals(expected, actual);
247 }
248
249 /**
250 * Asserts that two Strings are equal.
251 */
252 public static void assertEquals(String message, String expected, String actual) {
253 Assert.assertEquals(message, expected, actual);
254 }
255
256 /**
257 * Asserts that two Strings are equal.
258 */
259 public static void assertEquals(String expected, String actual) {
260 Assert.assertEquals(expected, actual);
261 }
262
263 /**
264 * Asserts that two doubles are equal concerning a delta. If they are not
265 * an AssertionFailedError is thrown with the given message. If the expected
266 * value is infinity then the delta value is ignored.
267 */
268 public static void assertEquals(String message, double expected, double actual, double delta) {
269 Assert.assertEquals(message, expected, actual, delta);
270 }
271
272 /**
273 * Asserts that two doubles are equal concerning a delta. If the expected
274 * value is infinity then the delta value is ignored.
275 */
276 public static void assertEquals(double expected, double actual, double delta) {
277 Assert.assertEquals(expected, actual, delta);
278 }
279
280 /**
281 * Asserts that two floats are equal concerning a positive delta. If they
282 * are not an AssertionFailedError is thrown with the given message. If the
283 * expected value is infinity then the delta value is ignored.
284 */
285 public static void assertEquals(String message, float expected, float actual, float delta) {
286 Assert.assertEquals(message, expected, actual, delta);
287 }
288
289 /**
290 * Asserts that two floats are equal concerning a delta. If the expected
291 * value is infinity then the delta value is ignored.
292 */
293 public static void assertEquals(float expected, float actual, float delta) {
294 Assert.assertEquals(expected, actual, delta);
295 }
296
297 /**
298 * Asserts that two longs are equal. If they are not
299 * an AssertionFailedError is thrown with the given message.
300 */
301 public static void assertEquals(String message, long expected, long actual) {
302 Assert.assertEquals(message, expected, actual);
303 }
304
305 /**
306 * Asserts that two longs are equal.
307 */
308 public static void assertEquals(long expected, long actual) {
309 Assert.assertEquals(expected, actual);
310 }
311
312 /**
313 * Asserts that two booleans are equal. If they are not
314 * an AssertionFailedError is thrown with the given message.
315 */
316 public static void assertEquals(String message, boolean expected, boolean actual) {
317 Assert.assertEquals(message, expected, actual);
318 }
319
320 /**
321 * Asserts that two booleans are equal.
322 */
323 public static void assertEquals(boolean expected, boolean actual) {
324 Assert.assertEquals(expected, actual);
325 }
326
327 /**
328 * Asserts that two bytes are equal. If they are not
329 * an AssertionFailedError is thrown with the given message.
330 */
331 public static void assertEquals(String message, byte expected, byte actual) {
332 Assert.assertEquals(message, expected, actual);
333 }
334
335 /**
336 * Asserts that two bytes are equal.
337 */
338 public static void assertEquals(byte expected, byte actual) {
339 Assert.assertEquals(expected, actual);
340 }
341
342 /**
343 * Asserts that two chars are equal. If they are not
344 * an AssertionFailedError is thrown with the given message.
345 */
346 public static void assertEquals(String message, char expected, char actual) {
347 Assert.assertEquals(message, expected, actual);
348 }
349
350 /**
351 * Asserts that two chars are equal.
352 */
353 public static void assertEquals(char expected, char actual) {
354 Assert.assertEquals(expected, actual);
355 }
356
357 /**
358 * Asserts that two shorts are equal. If they are not
359 * an AssertionFailedError is thrown with the given message.
360 */
361 public static void assertEquals(String message, short expected, short actual) {
362 Assert.assertEquals(message, expected, actual);
363 }
364
365 /**
366 * Asserts that two shorts are equal.
367 */
368 public static void assertEquals(short expected, short actual) {
369 Assert.assertEquals(expected, actual);
370 }
371
372 /**
373 * Asserts that two ints are equal. If they are not
374 * an AssertionFailedError is thrown with the given message.
375 */
376 public static void assertEquals(String message, int expected, int actual) {
377 Assert.assertEquals(message, expected, actual);
378 }
379
380 /**
381 * Asserts that two ints are equal.
382 */
383 public static void assertEquals(int expected, int actual) {
384 Assert.assertEquals(expected, actual);
385 }
386
387 /**
388 * Asserts that an object isn't null.
389 */
390 public static void assertNotNull(Object object) {
391 Assert.assertNotNull(object);
392 }
393
394 /**
395 * Asserts that an object isn't null. If it is
396 * an AssertionFailedError is thrown with the given message.
397 */
398 public static void assertNotNull(String message, Object object) {
399 Assert.assertNotNull(message, object);
400 }
401
402 /**
403 * Asserts that an object is null. If it isn't an {@link AssertionError} is
404 * thrown.
405 * Message contains: Expected: <null> but was: object
406 *
407 * @param object Object to check or <code>null</code>
408 */
409 public static void assertNull(Object object) {
410 Assert.assertNull(object);
411 }
412
413 /**
414 * Asserts that an object is null. If it is not
415 * an AssertionFailedError is thrown with the given message.
416 */
417 public static void assertNull(String message, Object object) {
418 Assert.assertNull(message, object);
419 }
420
421 /**
422 * Asserts that two objects refer to the same object. If they are not
423 * an AssertionFailedError is thrown with the given message.
424 */
425 public static void assertSame(String message, Object expected, Object actual) {
426 Assert.assertSame(message, expected, actual);
427 }
428
429 /**
430 * Asserts that two objects refer to the same object. If they are not
431 * the same an AssertionFailedError is thrown.
432 */
433 public static void assertSame(Object expected, Object actual) {
434 Assert.assertSame(expected, actual);
435 }
436
437 /**
438 * Asserts that two objects do not refer to the same object. If they do
439 * refer to the same object an AssertionFailedError is thrown with the
440 * given message.
441 */
442 public static void assertNotSame(String message, Object expected, Object actual) {
443 Assert.assertNotSame(message, expected, actual);
444 }
445
446 /**
447 * Asserts that two objects do not refer to the same object. If they do
448 * refer to the same object an AssertionFailedError is thrown.
449 */
450 public static void assertNotSame(Object expected, Object actual) {
451 Assert.assertNotSame(expected, actual);
452 }
453
454 public static void failSame(String message) {
455 Assert.failSame(message);
456 }
457
458 public static void failNotSame(String message, Object expected, Object actual) {
459 Assert.failNotSame(message, expected, actual);
460 }
461
462 public static void failNotEquals(String message, Object expected, Object actual) {
463 Assert.failNotEquals(message, expected, actual);
464 }
465
466 public static String format(String message, Object expected, Object actual) {
467 return Assert.format(message, expected, actual);
468 }
469
470 /**
471 * Sets up the fixture, for example, open a network connection.
472 * This method is called before a test is executed.
473 */
474 protected void setUp() throws Exception {
475 }
476
477 /**
478 * Tears down the fixture, for example, close a network connection.
479 * This method is called after a test is executed.
480 */
481 protected void tearDown() throws Exception {
482 }
483
484 /**
485 * Returns a string representation of the test case.
486 */
487 @Override
488 public String toString() {
489 return getName() + "(" + getClass().getName() + ")";
490 }
491
492 /**
493 * Gets the name of a TestCase.
494 *
495 * @return the name of the TestCase
496 */
497 public String getName() {
498 return fName;
499 }
500
501 /**
502 * Sets the name of a TestCase.
503 *
504 * @param name the name to set
505 */
506 public void setName(String name) {
507 fName = name;
508 }
509 }