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 package org.jomc.ant.test.support;
32
33 import java.text.MessageFormat;
34 import java.util.ResourceBundle;
35 import org.apache.tools.ant.BuildEvent;
36 import static org.junit.Assert.assertEquals;
37 import static org.junit.Assert.assertNotNull;
38 import static org.junit.Assert.assertNull;
39 import static org.junit.Assert.assertTrue;
40
41
42
43
44
45
46
47 public abstract class Assert
48 {
49
50
51 public Assert()
52 {
53 super();
54 }
55
56
57
58
59
60
61
62 public static void assertException( final AntExecutionResult result, final Class<? extends Throwable> exception )
63 {
64 assertNotNull( result );
65 assertNotNull( exception );
66 assertNotNull( getMessage( "expectedException", exception.getName() ), result.getThrowable() );
67 assertTrue( getMessage( "unexpectedExceptionClass", result.getThrowable().getClass().getName(),
68 exception.getName() ), result.getThrowable().getClass() == exception );
69
70 }
71
72
73
74
75
76
77
78
79 public static void assertException( final AntExecutionResult result, final Class<? extends Throwable> exception,
80 final CharSequence reason )
81 {
82 assertNotNull( result );
83 assertNotNull( exception );
84 assertNotNull( reason );
85 assertNotNull( reason.toString(), result.getThrowable() );
86 assertTrue( reason.toString(), result.getThrowable().getClass() == exception );
87 }
88
89
90
91
92
93
94
95 public static void assertExceptionInstance( final AntExecutionResult result,
96 final Class<? extends Throwable> exception )
97 {
98 assertNotNull( result );
99 assertNotNull( exception );
100 assertNotNull( getMessage( "expectedException", exception.getName() ), result.getThrowable() );
101 assertTrue( getMessage( "unexpectedExceptionInstance", result.getThrowable().getClass().getName(),
102 exception.getName() ), result.getThrowable().getClass().isAssignableFrom( exception ) );
103
104 }
105
106
107
108
109
110
111
112
113 public static void assertExceptionInstance( final AntExecutionResult result,
114 final Class<? extends Throwable> exception, final CharSequence reason )
115 {
116 assertNotNull( result );
117 assertNotNull( exception );
118 assertNotNull( reason.toString(), result.getThrowable() );
119 assertTrue( reason.toString(), result.getThrowable().getClass().isAssignableFrom( exception ) );
120 }
121
122
123
124
125
126
127
128 public static void assertExceptionMessage( final AntExecutionResult result, final CharSequence message )
129 {
130 assertNotNull( result );
131 assertNotNull( message );
132 assertNotNull( getMessage( "unexpectedSuccess" ), result.getThrowable() );
133 assertEquals( getMessage( "unexpectedExceptionMessage", result.getThrowable().getMessage(), message ), message,
134 result.getThrowable().getMessage() );
135
136 }
137
138
139
140
141
142
143
144
145 public static void assertExceptionMessage( final AntExecutionResult result, final CharSequence message,
146 final CharSequence reason )
147 {
148 assertNotNull( result );
149 assertNotNull( message );
150 assertNotNull( reason );
151 assertNotNull( reason.toString(), result.getThrowable() );
152 assertEquals( reason.toString(), message, result.getThrowable().getMessage() );
153 }
154
155
156
157
158
159
160
161 public static void assertExceptionMessageContaining( final AntExecutionResult result, final CharSequence needle )
162 {
163 assertNotNull( result );
164 assertNotNull( needle );
165 assertNotNull( getMessage( "unexpectedSuccess" ), result.getThrowable() );
166 assertTrue( getMessage( "unexpectedExceptionMessageContaining", result.getThrowable().getMessage(), needle ),
167 result.getThrowable().getMessage().contains( needle ) );
168
169 }
170
171
172
173
174
175
176
177
178 public static void assertExceptionMessageContaining( final AntExecutionResult result, final CharSequence needle,
179 final CharSequence reason )
180 {
181 assertNotNull( result );
182 assertNotNull( needle );
183 assertNotNull( reason );
184 assertNotNull( reason.toString(), result.getThrowable() );
185 assertTrue( reason.toString(), result.getThrowable().getMessage().contains( needle ) );
186 }
187
188
189
190
191
192
193 public static void assertNoException( final AntExecutionResult result )
194 {
195 assertNotNull( result );
196 assertNull( getMessage( "unexpectedException", result.getThrowable() ), result.getThrowable() );
197 }
198
199
200
201
202
203
204
205 public static void assertNoException( final AntExecutionResult result, final CharSequence reason )
206 {
207 assertNotNull( result );
208 assertNotNull( reason );
209 assertNull( reason.toString(), result.getThrowable() );
210 }
211
212
213
214
215
216
217
218 public static void assertSystemOutputContaining( final AntExecutionResult result, final CharSequence needle )
219 {
220 assertNotNull( result );
221 assertNotNull( needle );
222 assertNotNull( getMessage( "expectedSystemOutputContaining", needle ), result.getSystemOutput() );
223 assertTrue( getMessage( "expectedSystemOutputContaining", needle ),
224 result.getSystemOutput().contains( needle ) );
225
226 }
227
228
229
230
231
232
233
234
235 public static void assertSystemOutputContaining( final AntExecutionResult result, final CharSequence needle,
236 final CharSequence reason )
237 {
238 assertNotNull( result );
239 assertNotNull( needle );
240 assertNotNull( reason );
241 assertNotNull( reason.toString(), result.getSystemOutput() );
242 assertTrue( reason.toString(), result.getSystemOutput().contains( needle ) );
243 }
244
245
246
247
248
249
250
251 public static void assertSystemErrorContaining( final AntExecutionResult result, final CharSequence needle )
252 {
253 assertNotNull( result );
254 assertNotNull( needle );
255 assertNotNull( getMessage( "expectedSystemErrorContaining", needle ), result.getSystemError() );
256 assertTrue( getMessage( "expectedSystemErrorContaining", needle ),
257 result.getSystemError().contains( needle ) );
258
259 }
260
261
262
263
264
265
266
267
268 public static void assertSystemErrorContaining( final AntExecutionResult result, final CharSequence needle,
269 final CharSequence reason )
270 {
271 assertNotNull( result );
272 assertNotNull( needle );
273 assertNotNull( reason );
274 assertNotNull( reason.toString(), result.getSystemError() );
275 assertTrue( reason.toString(), result.getSystemError().contains( needle ) );
276 }
277
278
279
280
281
282
283
284 public static void assertMessageLogged( final AntExecutionResult result, final CharSequence message )
285 {
286 assertNotNull( result );
287 assertNotNull( message );
288
289 BuildEvent messageLoggedEvent = null;
290
291 for ( BuildEvent e : result.getMessageLoggedEvents() )
292 {
293 if ( message.equals( e.getMessage() ) )
294 {
295 messageLoggedEvent = e;
296 break;
297 }
298 }
299
300 assertNotNull( getMessage( "expectedMessageLogged", message ), messageLoggedEvent );
301 }
302
303
304
305
306
307
308
309
310 public static void assertMessageLogged( final AntExecutionResult result, final CharSequence message,
311 final CharSequence reason )
312 {
313 assertNotNull( result );
314 assertNotNull( message );
315 assertNotNull( reason );
316
317 BuildEvent messageLoggedEvent = null;
318
319 for ( BuildEvent e : result.getMessageLoggedEvents() )
320 {
321 if ( message.equals( e.getMessage() ) )
322 {
323 messageLoggedEvent = e;
324 break;
325 }
326 }
327
328 assertNotNull( reason.toString(), messageLoggedEvent );
329 }
330
331
332
333
334
335
336
337
338 public static void assertMessageLogged( final AntExecutionResult result, final CharSequence message,
339 final int priority )
340 {
341 assertNotNull( result );
342 assertNotNull( message );
343
344 BuildEvent messageLoggedEvent = null;
345
346 for ( BuildEvent e : result.getMessageLoggedEvents() )
347 {
348 if ( message.equals( e.getMessage() ) )
349 {
350 messageLoggedEvent = e;
351 break;
352 }
353 }
354
355 assertNotNull( getMessage( "expectedMessageLogged", message ), messageLoggedEvent );
356 assertEquals( getMessage( "unexpectedMessagePriority", messageLoggedEvent.getPriority(), priority ), priority,
357 messageLoggedEvent.getPriority() );
358
359 }
360
361
362
363
364
365
366
367
368
369
370 public static void assertMessageLogged( final AntExecutionResult result, final CharSequence message,
371 final int priority, final CharSequence reason )
372 {
373 assertNotNull( result );
374 assertNotNull( message );
375 assertNotNull( reason );
376
377 BuildEvent messageLoggedEvent = null;
378
379 for ( BuildEvent e : result.getMessageLoggedEvents() )
380 {
381 if ( message.equals( e.getMessage() ) )
382 {
383 messageLoggedEvent = e;
384 break;
385 }
386 }
387
388 assertNotNull( reason.toString(), messageLoggedEvent );
389 assertEquals( reason.toString(), priority, messageLoggedEvent.getPriority() );
390 }
391
392
393
394
395
396
397
398 public static void assertMessageLoggedContaining( final AntExecutionResult result, final CharSequence needle )
399 {
400 assertNotNull( result );
401 assertNotNull( needle );
402
403 BuildEvent messageLoggedEvent = null;
404
405 for ( BuildEvent e : result.getMessageLoggedEvents() )
406 {
407 if ( e.getMessage() != null && e.getMessage().contains( needle ) )
408 {
409 messageLoggedEvent = e;
410 break;
411 }
412 }
413
414 assertNotNull( getMessage( "expectedMessageLoggedContaining", needle ), messageLoggedEvent );
415 }
416
417
418
419
420
421
422
423
424
425 public static void assertMessageLoggedContaining( final AntExecutionResult result, final CharSequence needle,
426 final CharSequence reason )
427 {
428 assertNotNull( result );
429 assertNotNull( needle );
430 assertNotNull( reason );
431
432 BuildEvent messageLoggedEvent = null;
433
434 for ( BuildEvent e : result.getMessageLoggedEvents() )
435 {
436 if ( e.getMessage() != null && e.getMessage().contains( needle ) )
437 {
438 messageLoggedEvent = e;
439 break;
440 }
441 }
442
443 assertNotNull( reason.toString(), messageLoggedEvent );
444 }
445
446
447
448
449
450
451
452
453
454 public static void assertMessageLoggedContaining( final AntExecutionResult result, final CharSequence needle,
455 final int priority )
456 {
457 assertNotNull( result );
458 assertNotNull( needle );
459
460 BuildEvent messageLoggedEvent = null;
461
462 for ( BuildEvent e : result.getMessageLoggedEvents() )
463 {
464 if ( e.getMessage() != null && e.getMessage().contains( needle ) )
465 {
466 messageLoggedEvent = e;
467 break;
468 }
469 }
470
471 assertNotNull( getMessage( "expectedMessageLoggedContaining", needle ), messageLoggedEvent );
472 assertEquals( getMessage( "unexpectedMessagePriority", messageLoggedEvent.getPriority(), priority ), priority,
473 messageLoggedEvent.getPriority() );
474
475 }
476
477
478
479
480
481
482
483
484
485
486 public static void assertMessageLoggedContaining( final AntExecutionResult result, final CharSequence needle,
487 final int priority, final CharSequence reason )
488 {
489 assertNotNull( result );
490 assertNotNull( needle );
491 assertNotNull( reason );
492
493 BuildEvent messageLoggedEvent = null;
494
495 for ( BuildEvent e : result.getMessageLoggedEvents() )
496 {
497 if ( e.getMessage() != null && e.getMessage().contains( needle ) )
498 {
499 messageLoggedEvent = e;
500 break;
501 }
502 }
503
504 assertNotNull( reason.toString(), messageLoggedEvent );
505 assertEquals( reason.toString(), priority, messageLoggedEvent.getPriority() );
506 }
507
508
509
510
511
512
513
514 public static void assertMessageNotLogged( final AntExecutionResult result, final CharSequence message )
515 {
516 assertNotNull( result );
517 assertNotNull( message );
518
519 BuildEvent messageLoggedEvent = null;
520
521 for ( BuildEvent e : result.getMessageLoggedEvents() )
522 {
523 if ( message.equals( e.getMessage() ) )
524 {
525 messageLoggedEvent = e;
526 break;
527 }
528 }
529
530 assertNull( getMessage( "unexpectedMessageLogged", messageLoggedEvent != null
531 ? messageLoggedEvent.getMessage() : null ),
532 messageLoggedEvent );
533
534 }
535
536
537
538
539
540
541
542
543 public static void assertMessageNotLogged( final AntExecutionResult result, final CharSequence message,
544 final CharSequence reason )
545 {
546 assertNotNull( result );
547 assertNotNull( message );
548 assertNotNull( reason );
549
550 BuildEvent messageLoggedEvent = null;
551
552 for ( BuildEvent e : result.getMessageLoggedEvents() )
553 {
554 if ( message.equals( e.getMessage() ) )
555 {
556 messageLoggedEvent = e;
557 break;
558 }
559 }
560
561 assertNull( reason.toString(), messageLoggedEvent );
562 }
563
564
565
566
567
568
569
570 public static void assertMessageNotLoggedContaining( final AntExecutionResult result, final CharSequence needle )
571 {
572 assertNotNull( result );
573 assertNotNull( needle );
574
575 BuildEvent messageLoggedEvent = null;
576
577 for ( BuildEvent e : result.getMessageLoggedEvents() )
578 {
579 if ( e.getMessage() != null && e.getMessage().contains( needle ) )
580 {
581 messageLoggedEvent = e;
582 break;
583 }
584 }
585
586 assertNull( getMessage( "unexpectedMessageLogged", messageLoggedEvent != null
587 ? messageLoggedEvent.getMessage() : null ),
588 messageLoggedEvent );
589
590 }
591
592
593
594
595
596
597
598
599
600 public static void assertMessageNotLoggedContaining( final AntExecutionResult result, final CharSequence needle,
601 final CharSequence reason )
602 {
603 assertNotNull( result );
604 assertNotNull( needle );
605 assertNotNull( reason );
606
607 BuildEvent messageLoggedEvent = null;
608
609 for ( BuildEvent e : result.getMessageLoggedEvents() )
610 {
611 if ( e.getMessage() != null && e.getMessage().contains( needle ) )
612 {
613 messageLoggedEvent = e;
614 break;
615 }
616 }
617
618 assertNull( reason.toString(), messageLoggedEvent );
619 }
620
621 private static String getMessage( final String key, final Object... arguments )
622 {
623 return MessageFormat.format( ResourceBundle.getBundle( Assert.class.getName().replace( '.', '/' ) ).
624 getString( key ), arguments );
625
626 }
627
628 }