Fix text justification and linked tests
[nikiroo-utils.git] / src / be / nikiroo / utils / test / TestCase.java
... / ...
CommitLineData
1package be.nikiroo.utils.test;
2
3import java.util.List;
4
5/**
6 * A {@link TestCase} that can be run with {@link TestLauncher}.
7 *
8 * @author niki
9 */
10abstract public class TestCase {
11 /**
12 * The type of {@link Exception} used to signal a failed assertion or a
13 * force-fail.
14 *
15 * @author niki
16 */
17 class AssertException extends Exception {
18 private static final long serialVersionUID = 1L;
19
20 public AssertException(String reason, Exception source) {
21 super(reason, source);
22 }
23
24 public AssertException(String reason) {
25 super(reason);
26 }
27 }
28
29 private String name;
30
31 /**
32 * Create a new {@link TestCase}.
33 *
34 * @param name
35 * the test name
36 */
37 public TestCase(String name) {
38 this.name = name;
39 }
40
41 /**
42 * Setup the test (called before the test is run).
43 *
44 * @throws Exception
45 * in case of error
46 */
47 @SuppressWarnings("unused")
48 public void setUp() throws Exception {
49 }
50
51 /**
52 * Tear-down the test (called when the test has been ran).
53 *
54 * @throws Exception
55 * in case of error
56 */
57 @SuppressWarnings("unused")
58 public void tearDown() throws Exception {
59 }
60
61 /**
62 * The test name.
63 *
64 * @return the name
65 */
66 public String getName() {
67 return name;
68 }
69
70 /**
71 * Actually do the test.
72 *
73 * @throws Exception
74 * in case of error
75 */
76 abstract public void test() throws Exception;
77
78 /**
79 * Force a failure.
80 *
81 * @throws AssertException
82 * every time
83 */
84 public void fail() throws AssertException {
85 fail(null);
86 }
87
88 /**
89 * Force a failure.
90 *
91 * @param reason
92 * the failure reason
93 * @throws AssertException
94 * every time
95 */
96 public void fail(String reason) throws AssertException {
97 throw new AssertException("Failed!" + //
98 reason != null ? "\n" + reason : "");
99 }
100
101 /**
102 * Check that 2 {@link Object}s are equals.
103 *
104 * @param expected
105 * the expected value
106 * @param actual
107 * the actual value
108 *
109 * @throws AssertException
110 * in case they differ
111 */
112 public void assertEquals(Object expected, Object actual)
113 throws AssertException {
114 assertEquals(null, expected, actual);
115 }
116
117 /**
118 * Check that 2 {@link Object}s are equals.
119 *
120 * @param errorMessage
121 * the error message to display if they differ
122 * @param expected
123 * the expected value
124 * @param actual
125 * the actual value
126 *
127 * @throws AssertException
128 * in case they differ
129 */
130 public void assertEquals(String errorMessage, Object expected, Object actual)
131 throws AssertException {
132 if ((expected == null && actual != null)
133 || (expected != null && !expected.equals(actual))) {
134 if (errorMessage == null) {
135 throw new AssertException(generateAssertMessage(expected,
136 actual));
137 }
138
139 throw new AssertException(errorMessage, new AssertException(
140 generateAssertMessage(expected, actual)));
141 }
142 }
143
144 /**
145 * Check that 2 longs are equals.
146 *
147 * @param expected
148 * the expected value
149 * @param actual
150 * the actual value
151 *
152 * @throws AssertException
153 * in case they differ
154 */
155 public void assertEquals(long expected, long actual) throws AssertException {
156 assertEquals(Long.valueOf(expected), Long.valueOf(actual));
157 }
158
159 /**
160 * Check that 2 longs are equals.
161 *
162 * @param errorMessage
163 * the error message to display if they differ
164 * @param expected
165 * the expected value
166 * @param actual
167 * the actual value
168 *
169 * @throws AssertException
170 * in case they differ
171 */
172 public void assertEquals(String errorMessage, long expected, long actual)
173 throws AssertException {
174 assertEquals(errorMessage, Long.valueOf(expected), Long.valueOf(actual));
175 }
176
177 /**
178 * Check that 2 booleans are equals.
179 *
180 * @param expected
181 * the expected value
182 * @param actual
183 * the actual value
184 *
185 * @throws AssertException
186 * in case they differ
187 */
188 public void assertEquals(boolean expected, boolean actual)
189 throws AssertException {
190 assertEquals(Boolean.valueOf(expected), Boolean.valueOf(actual));
191 }
192
193 /**
194 * Check that 2 booleans are equals.
195 *
196 * @param errorMessage
197 * the error message to display if they differ
198 * @param expected
199 * the expected value
200 * @param actual
201 * the actual value
202 *
203 * @throws AssertException
204 * in case they differ
205 */
206 public void assertEquals(String errorMessage, boolean expected,
207 boolean actual) throws AssertException {
208 assertEquals(errorMessage, Boolean.valueOf(expected),
209 Boolean.valueOf(actual));
210 }
211
212 /**
213 * Check that 2 doubles are equals.
214 *
215 * @param expected
216 * the expected value
217 * @param actual
218 * the actual value
219 *
220 * @throws AssertException
221 * in case they differ
222 */
223 public void assertEquals(double expected, double actual)
224 throws AssertException {
225 assertEquals(Double.valueOf(expected), Double.valueOf(actual));
226 }
227
228 /**
229 * Check that 2 doubles are equals.
230 *
231 * @param errorMessage
232 * the error message to display if they differ
233 * @param expected
234 * the expected value
235 * @param actual
236 * the actual value
237 *
238 * @throws AssertException
239 * in case they differ
240 */
241 public void assertEquals(String errorMessage, double expected, double actual)
242 throws AssertException {
243 assertEquals(errorMessage, Double.valueOf(expected),
244 Double.valueOf(actual));
245 }
246
247 /**
248 * Check that 2 {@link List}s are equals.
249 *
250 * @param errorMessage
251 * the error message to display if they differ
252 * @param expected
253 * the expected value
254 * @param actual
255 * the actual value
256 *
257 * @throws AssertException
258 * in case they differ
259 */
260 public void assertEquals(List<?> expected, List<?> actual)
261 throws AssertException {
262
263 assertEquals("The 2 lists don't contain the same number of items",
264 expected.size(), actual.size());
265
266 int size = expected.size();
267 for (int i = 0; i < size; i++) {
268 assertEquals("Line " + i + " (0-based) is not correct",
269 expected.get(i), actual.get(i));
270 }
271 }
272
273 /**
274 * Check that given {@link Object} is not NULL.
275 *
276 * @param errorMessage
277 * the error message to display if it is NULL
278 * @param actual
279 * the actual value
280 *
281 * @throws AssertException
282 * in case they differ
283 */
284 public void assertNotNull(String errorMessage, Object actual)
285 throws AssertException {
286 if (actual == null) {
287 String defaultReason = String.format("" //
288 + "Assertion failed!%n" //
289 + "Object should not have been NULL");
290
291 if (errorMessage == null) {
292 throw new AssertException(defaultReason);
293 }
294
295 throw new AssertException(errorMessage, new AssertException(
296 defaultReason));
297 }
298 }
299
300 /**
301 * Generate the default assert message for 2 different values that were
302 * supposed to be equals.
303 *
304 * @param expected
305 * the expected value
306 * @param actual
307 * the actual value
308 *
309 * @return the message
310 */
311 public static String generateAssertMessage(Object expected, Object actual) {
312 return String.format("" //
313 + "Assertion failed!%n" //
314 + "Expected value: [%s]%n" //
315 + "Actual value: [%s]", expected, actual);
316 }
317}