public class TestCaseTest extends TestCase
1: package junit.tests.framework;
3: import junit.framework.*;
4: import junit.tests.WasRun;
6: /**
7: * A test case testing the testing framework.
8: *
9: */
10: public class TestCaseTest extends TestCase {
11:
12: static class TornDown extends TestCase {
13: boolean fTornDown= false;
14:
15: protected void tearDown() {
16: fTornDown= true;
17: }
18: protected void runTest() {
19: throw new Error();
20: }
21: }
23: public void testCaseToString() {
24: // This test wins the award for twisted snake tail eating while
25: // writing self tests. And you thought those weird anonymous
26: // inner classes were bad...
27: assertEquals("testCaseToString(junit.tests.framework.TestCaseTest)", toString());
28: }
29: public void testError() {
30: TestCase error= new TestCase("error") {
31: protected void runTest() {
32: throw new Error();
33: }
34: };
35: verifyError(error);
36: }
37: public void testRunAndTearDownFails() {
38: TornDown fails= new TornDown() {
39: protected void tearDown() {
40: super.tearDown();
41: throw new Error();
42: }
43: protected void runTest() {
44: throw new Error();
45: }
46: };
47: verifyError(fails);
48: assertTrue(fails.fTornDown);
49: }
50: public void testSetupFails() {
51: TestCase fails= new TestCase("success") {
52: protected void setUp() {
53: throw new Error();
54: }
55: protected void runTest() {
56: }
57: };
58: verifyError(fails);
59: }
60: public void testSuccess() {
61: TestCase success= new TestCase("success") {
62: protected void runTest() {
63: }
64: };
65: verifySuccess(success);
66: }
67: public void testFailure() {
68: TestCase failure= new TestCase("failure") {
69: protected void runTest() {
70: fail();
71: }
72: };
73: verifyFailure(failure);
74: }
76: public void testTearDownAfterError() {
77: TornDown fails= new TornDown();
78: verifyError(fails);
79: assertTrue(fails.fTornDown);
80: }
81:
82: public void testTearDownFails() {
83: TestCase fails= new TestCase("success") {
84: protected void tearDown() {
85: throw new Error();
86: }
87: protected void runTest() {
88: }
89: };
90: verifyError(fails);
91: }
92: public void testTearDownSetupFails() {
93: TornDown fails= new TornDown() {
94: protected void setUp() {
95: throw new Error();
96: }
97: };
98: verifyError(fails);
99: assertTrue(!fails.fTornDown);
100: }
101: public void testWasRun() {
102: WasRun test= new WasRun();
103: test.run();
104: assertTrue(test.fWasRun);
105: }
106: public void testExceptionRunningAndTearDown() {
107: // This test documents the current behavior. With 1.4, we should
108: // wrap the exception thrown while running with the exception thrown
109: // while tearing down
110: Test t= new TornDown() {
111: public void tearDown() {
112: throw new Error("tearDown");
113: }
114: };
115: TestResult result= new TestResult();
116: t.run(result);
117: TestFailure failure= (TestFailure) result.errors().nextElement();
118: assertEquals("tearDown", failure.thrownException().getMessage());
119: }
120:
121: public void testNoArgTestCasePasses() {
122: Test t= new TestSuite(NoArgTestCaseTest.class);
123: TestResult result= new TestResult();
124: t.run(result);
125: assertTrue(result.runCount() == 1);
126: assertTrue(result.failureCount() == 0);
127: assertTrue(result.errorCount() == 0);
128: }
129:
130: public void testNamelessTestCase() {
131: TestCase t= new TestCase() {};
132: try {
133: t.run();
134: fail();
135: } catch (AssertionFailedError e) {
136: }
137: }
138:
139: void verifyError(TestCase test) {
140: TestResult result= test.run();
141: assertTrue(result.runCount() == 1);
142: assertTrue(result.failureCount() == 0);
143: assertTrue(result.errorCount() == 1);
144: }
145: void verifyFailure(TestCase test) {
146: TestResult result= test.run();
147: assertTrue(result.runCount() == 1);
148: assertTrue(result.failureCount() == 1);
149: assertTrue(result.errorCount() == 0);
150: }
151: void verifySuccess(TestCase test) {
152: TestResult result= test.run();
153: assertTrue(result.runCount() == 1);
154: assertTrue(result.failureCount() == 0);
155: assertTrue(result.errorCount() == 0);
156: }
157: }