View Javadoc

1   /*
2    *   Copyright (C) Christian Schulte, 2005-206
3    *   All rights reserved.
4    *
5    *   Redistribution and use in source and binary forms, with or without
6    *   modification, are permitted provided that the following conditions
7    *   are met:
8    *
9    *     o Redistributions of source code must retain the above copyright
10   *       notice, this list of conditions and the following disclaimer.
11   *
12   *     o Redistributions in binary form must reproduce the above copyright
13   *       notice, this list of conditions and the following disclaimer in
14   *       the documentation and/or other materials provided with the
15   *       distribution.
16   *
17   *   THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
18   *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
19   *   AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
20   *   THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY DIRECT, INDIRECT,
21   *   INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22   *   NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23   *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24   *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25   *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26   *   THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27   *
28   *   $JOMC: Assert.java 3850 2011-10-10 16:22:55Z schulte2005 $
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   * Provides static methods for testing various assertions related to Ant executions.
43   *
44   * @author <a href="mailto:schulte2005@users.sourceforge.net">Christian Schulte</a>
45   * @version $JOMC: Assert.java 3850 2011-10-10 16:22:55Z schulte2005 $
46   */
47  public abstract class Assert
48  {
49  
50      /** Creates a new {@code Assert} instance. */
51      public Assert()
52      {
53          super();
54      }
55  
56      /**
57       * Tests an Ant execution to have thrown an exception of a given type.
58       *
59       * @param result The result to test.
60       * @param exception The class of the expected exception.
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       * Tests an Ant execution to have thrown an exception of a given type taking a reason.
74       *
75       * @param result The result to test.
76       * @param exception The class of the expected exception.
77       * @param reason The reason describing why {@code exception} should have been thrown.
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       * Tests an Ant execution to have thrown an instance of a given exception.
91       *
92       * @param result The result to test.
93       * @param exception The class the expected exception should be an instance of.
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      * Tests an Ant execution to have thrown an instance of a given exception taking a reason.
108      *
109      * @param result The result to test.
110      * @param exception The class the expected exception should be an instance of.
111      * @param reason The reason describing why {@code exception} should have been thrown.
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      * Tests an Ant execution to have thrown an exception with a given message.
124      *
125      * @param result The result to test.
126      * @param message The message of the expected exception.
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      * Tests an Ant execution to have thrown an exception with a given message taking a reason.
140      *
141      * @param result The result to test.
142      * @param message The message of the expected exception.
143      * @param reason The reason describing why {@code exception} should have been thrown.
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      * Tests an Ant execution to have thrown an exception with a message containing a given string.
157      *
158      * @param result The result to test.
159      * @param needle The text the message of the expected exception should contain.
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      * Tests an Ant execution to have thrown an exception with a message containing a given string taking a reason.
173      *
174      * @param result The result to test.
175      * @param needle The text the message of the expected exception should contain.
176      * @param reason The reason describing why {@code exception} should have been thrown.
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      * Tests an Ant execution to not have thrown an exception.
190      *
191      * @param result The result to test.
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      * Tests an Ant execution to not have thrown an exception taking a reason.
201      *
202      * @param result The result to test.
203      * @param reason The reason describing why the execution should not have thrown an exception.
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      * Tests an Ant execution to have written a given text to the system output stream.
214      *
215      * @param result The result to test.
216      * @param needle The text which should have been written to the system output stream.
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      * Tests an Ant execution to have written a given text to the system output stream taking a reason.
230      *
231      * @param result The result to test.
232      * @param needle The text which should have been written to the system output stream.
233      * @param reason The reason describing why {@code needle} should have been written to the system output stream.
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      * Tests an Ant execution to have written a given text to the system error stream.
247      *
248      * @param result The result to test.
249      * @param needle The text which should have been written to the system error stream.
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      * Tests an Ant execution to have written a given text to the system error stream taking a reason.
263      *
264      * @param result The result to test.
265      * @param needle The text which should have been written to the system error stream.
266      * @param reason The reason describing why {@code needle} should have been written to the system error stream.
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      * Tests an Ant execution to have fired a {@code messageLogged} event holding a given message.
280      *
281      * @param result The result to test.
282      * @param message The message which should have been logged.
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      * Tests an Ant execution to have fired a {@code messageLogged} event holding a given message taking a reason.
305      *
306      * @param result The result to test.
307      * @param message The message which should have been logged.
308      * @param reason The reason describing why {@code message} should have been logged.
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      * Tests an Ant execution to have fired a {@code messageLogged} event holding a given message with a given priority.
333      *
334      * @param result The result to test.
335      * @param message The message which should have been logged.
336      * @param priority The priority the message should have been logged with.
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      * Tests an Ant execution to have fired a {@code messageLogged} event holding a given message with a given priority
363      * taking a reason.
364      *
365      * @param result The result to test.
366      * @param message The message which should have been logged.
367      * @param priority The priority the message should have been logged with.
368      * @param reason The reason describing why {@code message} should have been logged.
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      * Tests an Ant execution to have fired a {@code messageLogged} event holding a message containing a given text.
394      *
395      * @param result The result to test.
396      * @param needle The text contained in a message which should have been logged.
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      * Tests an Ant execution to have fired a {@code messageLogged} event holding a message containing a given text
419      * taking a reason.
420      *
421      * @param result The result to test.
422      * @param needle The text contained in a message which should have been logged.
423      * @param reason The reason describing why {@code needle} should have been logged.
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      * Tests an Ant execution to have fired a {@code messageLogged} event holding a message containing a given text with
448      * a given priority.
449      *
450      * @param result The result to test.
451      * @param needle The text contained in a message which should have been logged.
452      * @param priority The priority the message should have been logged with.
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      * Tests an Ant execution to have fired a {@code messageLogged} event holding a message containing a given text with
479      * a given priority taking a reason.
480      *
481      * @param result The result to test.
482      * @param needle The text contained in a message which should have been logged.
483      * @param priority The priority the message should have been logged with.
484      * @param reason The reason describing why {@code message} should have been logged.
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      * Tests an Ant execution to not have fired a {@code messageLogged} event holding a given message.
510      *
511      * @param result The result to test.
512      * @param message The message which should not have been logged.
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      * Tests an Ant execution to not have fired a {@code messageLogged} event holding a given message taking a reason.
538      *
539      * @param result The result to test.
540      * @param message The message which should not have been logged.
541      * @param reason The reason describing why {@code message} should not have been logged.
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      * Tests an Ant execution to not have fired a {@code messageLogged} event holding a message containing a given text.
566      *
567      * @param result The result to test.
568      * @param needle The text contained in a message which should not have been logged.
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      * Tests an Ant execution to not have fired a {@code messageLogged} event holding a message containing a given text
594      * taking a reason.
595      *
596      * @param result The result to test.
597      * @param needle The text contained in a message which should not have been logged.
598      * @param reason The reason describing why {@code message} should not have been logged.
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 }