1 package junit.tests.framework;
2
3 import junit.framework.*;
4 import junit.tests.WasRun;
5
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 }
22
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 }
|
75
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 } |