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