1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package inc.che.common.assertion;
20
21
22 import inc.che.common.resource.ResourceManager;
23 import inc.che.common.resource.StringResources;
24
25 import java.util.Collection;
26 import java.util.Iterator;
27
28 import org.apache.log4j.Logger;
29
30 /***
31 * <b>Einfache Assertionklasse</b>
32 * @version $Id: Assert.java,v 1.1 2005/03/06 12:56:47 stevemcmee Exp $
33 * @author <address> Steve McMee <stevemcmee@users.sourceforge.net></address>
34 */
35
36 public abstract class Assert {
37
38 /*** CVS ID of this file */
39 public static final String CVS_ID =
40 "$Id: Assert.java,v 1.1 2005/03/06 12:56:47 stevemcmee Exp $";
41
42 /***
43 * logger instance for this class
44 */
45
46 private static Logger log = Logger.getLogger(Assert.class);
47
48 /***
49 * The ResourceManager
50 */
51 private static ResourceManager resourceManager =
52 ResourceManager.getResourceManager(StringResources.TEXT_RESOURCES);
53
54 /***
55 * enables Assertions
56 */
57 private static boolean doAssert =
58 Boolean
59 .valueOf(
60 System.getProperty(
61 StringResources.ASSERT_SYS_PROPERTY,
62 "false"))
63 .booleanValue();
64
65 public abstract boolean _assert(Object o);
66
67 /***
68 * Führt Zusicherung eines Booleschen Ausdruck durch
69 *
70 *@param b ein Boolescher Ausdruck. Bei false wird ein Error-Objekt
71 * geworfen
72 */
73 public static void _assert(boolean b) {
74 if (!Assert.doAssert) {
75 return;
76 }
77 if (log.isDebugEnabled()) {
78 log.debug("_assert(" + b + ")");
79 }
80 _assert(b, null);
81 }
82
83 /***
84 * Führt Zusicherung eines Booleschen Ausdruck durch
85 *
86 *@param b ein Boolescher Ausdruck. Bei false wird ein Error-Objekt
87 * geworfen
88 *@param source zusätzliche Meldung im Fehlerfall
89 */
90 public static void _assert(boolean b, String source) {
91 if (!Assert.doAssert) {
92 return;
93 }
94 if (log.isDebugEnabled()) {
95 log.debug("_assert(" + b + "," + source + ")");
96 }
97 if (false == b) {
98 throw new AssertionException(
99 resourceManager.getText(
100 "assertion_failed",
101 new String[] {(source != null ? source : null)}));
102 }
103 }
104
105 /***
106 * Überprüft zwei Objektereferenzen auf Gleichheit
107 *
108 *@param a erste Objektreferenz
109 *@param b zweite Objektreferenz
110 */
111 public static void eq(Object a, Object b) {
112 if (!Assert.doAssert) {
113 return;
114 }
115 if (log.isDebugEnabled()) {
116 log.debug("eq(" + a + "," + b + ")");
117 }
118 eq(a, b, null);
119 }
120
121 /***
122 * Überprüft zwei Objektereferenzen auf Gleichheit
123 *
124 *@param a erste Objektreferenz
125 *@param b zweite Objektreferenz
126 *@param where zusätzliche Meldung im Fehlerfall
127 */
128 public static void eq(Object a, Object b, String where) {
129 if (!Assert.doAssert) {
130 return;
131 }
132 if (log.isDebugEnabled()) {
133 log.debug("eq(" + a + "," + b + "," + where + ")");
134 }
135 if (a != b) {
136 throw new AssertionException(
137 resourceManager.getText(
138 "assertion_failed_1",
139 new String[] {
140 String.valueOf(a),
141 String.valueOf(b),
142 (where != null ? where : null)}));
143 }
144 }
145
146 /***
147 * Überprüft Objektreferenz auf Objekttyp mittels instanceof
148 *
149 *@param source zusätzliche Meldung im Fehlerfall
150 *@param ref zu überprüfende Objektreferenz
151 *@param type Klasse für Objekttyp
152 */
153 public static void isInstanceOf(Object ref, Class type, String source) {
154 if (!Assert.doAssert) {
155 return;
156 }
157 if (log.isDebugEnabled()) {
158 log.debug("isInstanceOf(" + ref + "," + type + "," + source + ")");
159 }
160 notNull(ref, source);
161 notNull(type, source);
162 try {
163 if (!(type.isInstance(ref))) {
164 throw new AssertionException(
165 resourceManager.getText(
166 "assertion_failed_2",
167 new String[] {
168 String.valueOf(ref),
169 type.getName(),
170 source != null ? source : null }));
171 }
172 } catch (Exception e) {
173 throw new AssertionException(source, e);
174 }
175 }
176
177 /***
178 * Überprüft Objektreferenz auf Objekttyp mittels instanceof
179 *
180 *@param ref zu überprüfende Objektreferenz
181 *@param type Klasse für Objekttyp
182 */
183
184 public static void isInstanceOf(Object ref, Class type) {
185 if (!Assert.doAssert) {
186 return;
187 }
188 if (log.isDebugEnabled()) {
189 log.debug("isInstanceOf(" + ref + "," + type + ")");
190 }
191 isInstanceOf(ref, type, null);
192 }
193
194 /***
195 * Überprüft Objektreferenz auf Klassentyp (nicht polymorph!!!)
196 *
197 *@param source zusätzliche Meldung im Fehlerfall
198 *@param ref zu überprüfende Objektreferenz
199 *@param type Klasse für Objekttyp
200 */
201
202 public static void isClass(Object ref, Class type, String source) {
203 if (!Assert.doAssert) {
204 return;
205 }
206 if (log.isDebugEnabled()) {
207 log.debug("isClass(" + ref + "," + type + "," + source + ")");
208 }
209 notNull(ref, "Parameter ref");
210 notNull(type, "Parameter type");
211
212 if (!(ref.getClass().equals(type))) {
213 throw new AssertionException(
214 resourceManager.getText(
215 "found_type_2",
216 new String[] {
217 ref.getClass().getName(),
218 type.getName(),
219 source != null ? source : null }));
220 }
221
222 }
223
224 /***
225 * Überprüft Objektreferenz auf Klassentyp (nicht polymorph!!!)
226 *
227 *@param ref zu überprüfende Objektreferenz
228 *@param type Klasse für Objekttyp
229 */
230
231 public static void isClass(Object ref, Class type) {
232 if (!Assert.doAssert) {
233 return;
234 }
235 if (log.isDebugEnabled()) {
236 log.debug("isClass(" + ref + "," + type + ")");
237 }
238 isClass(ref, type, null);
239 }
240
241 /***
242 * Überprüft zwei Objekte null-sicher mittels equals
243 * @param a zu vergleichendes Objekt
244 * @param b zu vergleichendes Objekt
245 * @param source zusätzliche Meldung
246 */
247
248 public static void equals(Object a, Object b, String source) {
249 if (!Assert.doAssert) {
250 return;
251 }
252 if (log.isDebugEnabled()) {
253 log.debug("equals(" + a + "," + b + "," + source + ")");
254 }
255 if (a == null && b == null) {
256 return;
257 }
258 if ((a != null && b == null)
259 || (a == null && b != null)
260 || (!a.equals(b))) {
261 throw new AssertionException(
262 resourceManager.getText(
263 "assertion_failed_3",
264 new String[] {
265 String.valueOf(a),
266 String.valueOf(b),
267 source }));
268 }
269 }
270
271 /***
272 * Überprüft zwei Objekte null-sicher mittels equals
273 * @param a zu vergleichendes Objekt
274 * @param b zu vergleichendes Objekt
275 */
276
277 public static void equals(Object a, Object b) {
278 if (!Assert.doAssert) {
279 return;
280 }
281 if (log.isDebugEnabled()) {
282 log.debug("equals(" + a + "," + b + ")");
283 }
284 equals(a, b, null);
285 }
286
287 /***
288 * Überprüft Objektrefernz auf null
289 *
290 *@param ref zu überprüfende Objektreferenz
291 */
292 public static void notNull(Object ref) {
293 if (!Assert.doAssert) {
294 return;
295 }
296 if (log.isDebugEnabled()) {
297 log.debug("notNull(" + ref + ")");
298 }
299 notNull(ref, null);
300
301 }
302
303 /***
304 * Überprüft Objektrefernz auf null
305 *
306 *@param source zusätzliche Meldung im Fehlerfall
307 *@param ref zu überprüfende Objektreferenz
308 */
309 public static void notNull(Object ref, String source) {
310 if (!Assert.doAssert) {
311 return;
312 }
313 if (log.isDebugEnabled()) {
314 log.debug("notNull(" + ref + "," + source + ")");
315 }
316 if (null == ref) {
317 throw new AssertionException(
318 resourceManager.getText(
319 "assertion_not_failed",
320 new String[] {source }));
321 }
322 }
323
324
325 /***
326 * mst 01.10.2001 Überprüft alle Elemente einer Collection mittels _assert()
327 * des Assertion-Objektes
328 * @param coll Collection
329 * @param assertion Assertion-Objekt
330 * @author Steve McMee
331 */
332 public static void _assert(Collection coll, Assert assertion) {
333 if (!Assert.doAssert) {
334 return;
335 }
336 if (log.isDebugEnabled()) {
337 log.debug("_assert(" + coll + "," + assertion + ")");
338 }
339 _assert(coll, assertion, null);
340 }
341
342 /***
343 * mst 01.10.2001 Überprüft alle Elemente einer Collection mittels _assert()
344 * des Assertion-Objektes
345 *
346 *@param coll Collection
347 *@param source zusätzliche Meldung im Fehlerfall
348 *@param assertion Assertion-Objekt
349 *@author Steve McMee
350 */
351 public static void _assert(
352 Collection coll,
353 Assert assertion,
354 String source) {
355 if (!Assert.doAssert) {
356 return;
357 }
358 if (log.isDebugEnabled()) {
359 log.debug("_assert(" + coll + "," + source + "," + assertion + ")");
360 }
361
362 Iterator iter = coll.iterator();
363 while (iter.hasNext()) {
364 Object item = iter.next();
365 if (assertion._assert(item) == false) {
366 throw new AssertionException(
367 resourceManager.getText(
368 "element_failed",
369 new String[] {
370 String.valueOf(item),
371 (source != null ? source : null)}));
372 }
373 }
374 }
375
376 /***
377 * mst 01.10.2001 Überprüft alle Elemente einer Collection auf null
378 *
379 *@param coll Collection
380 *@param source zusätzliche Meldung im Fehlerfall
381 *@author Steve McMee
382 */
383 public static void containsNotNull(Collection coll, String source) {
384 if (!Assert.doAssert) {
385 return;
386 }
387 if (log.isDebugEnabled()) {
388 log.debug("containsNotNull(" + coll + "," + source + ")");
389 }
390 notNull(coll, "Parameter coll");
391
392 Iterator iter = coll.iterator();
393 while (iter.hasNext()) {
394 notNull(iter.next(), source);
395 }
396 }
397
398 /***
399 * mst 01.10.2001 Überprüft alle Elemente einer Collection auf null
400 *
401 *@param coll Collection
402 *@author Steve McMee
403 */
404 public static void containsNotNull(Collection coll) {
405 if (!Assert.doAssert) {
406 return;
407 }
408 if (log.isDebugEnabled()) {
409 log.debug("containsNotNull(" + coll + ")");
410 }
411 containsNotNull(coll, null);
412 }
413
414 /***
415 * mst 01.10.2001 Überprüft alle Elemente einer Collection auf deren Typ
416 * (polymorph!)
417 *
418 *@param coll Collection
419 *@param type Typ
420 *@param source zusätzliche Meldung im Fehlerfall
421 *@author Steve McMee
422 */
423 public static void areInstanceOf(
424 Collection coll,
425 Class type,
426 String source) {
427 if (!Assert.doAssert) {
428 return;
429 }
430 if (log.isDebugEnabled()) {
431 log.debug(
432 "areInstanceOf(" + coll + "," + type + "," + source + ")");
433 }
434 notNull(coll, "Parameter coll");
435 notNull(type, "Parameter type");
436
437 Iterator iter = coll.iterator();
438 while (iter.hasNext()) {
439 Object item = iter.next();
440 if (item == null) {
441 continue;
442 }
443 if (!(type.isInstance(item))) {
444 throw new AssertionException(
445 resourceManager.getText(
446 "found_type",
447 new String[] {
448 item.getClass().getName(),
449 String.valueOf(item),
450 type.getName(),
451 (source != null ? source : null)}));
452 }
453 }
454 }
455
456 /***
457 * mst 01.10.2001 Überprüft alle Elemente einer Collection auf deren Typ (nicht polymorph!!!)
458 *
459 *@param coll Collection
460 *@param type Typ
461 *@param source zusätzliche Meldung im Fehlerfall
462 *@author Steve McMee
463 */
464 public static void areClass(Collection coll, Class type, String source) {
465 if (!Assert.doAssert) {
466 return;
467 }
468 if (log.isDebugEnabled()) {
469 log.debug("areClass(" + coll + "," + type + "," + source + ")");
470 }
471 notNull(coll, "Parameter coll");
472 notNull(type, "Parameter type");
473
474 Iterator iter = coll.iterator();
475 while (iter.hasNext()) {
476 Object item = iter.next();
477 if (item == null) {
478 continue;
479 }
480 if (!(type.getName().equals(item.getClass().getName()))) {
481 throw new AssertionException(
482 resourceManager.getText(
483 "found_type",
484 new String[] {
485 item.getClass().getName(),
486 item.toString(),
487 type.getName(),
488 (source != null ? source : null)}));
489 }
490 }
491 }
492
493
494
495
496
497
498 public static void enable(boolean pdoAssert) {
499 doAssert = pdoAssert;
500 }
501
502 /***
503 * Zum Testen der Klasse
504 *
505 *@param args The command line arguments
506 *@author Steve McMee Zum Testen
507 */
508 public static void main(String[] args) {
509 }
510 }