001 /* 002 * Copyright (C) Christian Schulte, 2005-206 003 * All rights reserved. 004 * 005 * Redistribution and use in source and binary forms, with or without 006 * modification, are permitted provided that the following conditions 007 * are met: 008 * 009 * o Redistributions of source code must retain the above copyright 010 * notice, this list of conditions and the following disclaimer. 011 * 012 * o Redistributions in binary form must reproduce the above copyright 013 * notice, this list of conditions and the following disclaimer in 014 * the documentation and/or other materials provided with the 015 * distribution. 016 * 017 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, 018 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY 019 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL 020 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY DIRECT, INDIRECT, 021 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 022 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 023 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 024 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 025 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 026 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 027 * 028 * $JOMC: Assert.java 3850 2011-10-10 16:22:55Z schulte2005 $ 029 * 030 */ 031 package org.jomc.ant.test.support; 032 033 import java.text.MessageFormat; 034 import java.util.ResourceBundle; 035 import org.apache.tools.ant.BuildEvent; 036 import static org.junit.Assert.assertEquals; 037 import static org.junit.Assert.assertNotNull; 038 import static org.junit.Assert.assertNull; 039 import static org.junit.Assert.assertTrue; 040 041 /** 042 * Provides static methods for testing various assertions related to Ant executions. 043 * 044 * @author <a href="mailto:schulte2005@users.sourceforge.net">Christian Schulte</a> 045 * @version $JOMC: Assert.java 3850 2011-10-10 16:22:55Z schulte2005 $ 046 */ 047 public abstract class Assert 048 { 049 050 /** Creates a new {@code Assert} instance. */ 051 public Assert() 052 { 053 super(); 054 } 055 056 /** 057 * Tests an Ant execution to have thrown an exception of a given type. 058 * 059 * @param result The result to test. 060 * @param exception The class of the expected exception. 061 */ 062 public static void assertException( final AntExecutionResult result, final Class<? extends Throwable> exception ) 063 { 064 assertNotNull( result ); 065 assertNotNull( exception ); 066 assertNotNull( getMessage( "expectedException", exception.getName() ), result.getThrowable() ); 067 assertTrue( getMessage( "unexpectedExceptionClass", result.getThrowable().getClass().getName(), 068 exception.getName() ), result.getThrowable().getClass() == exception ); 069 070 } 071 072 /** 073 * Tests an Ant execution to have thrown an exception of a given type taking a reason. 074 * 075 * @param result The result to test. 076 * @param exception The class of the expected exception. 077 * @param reason The reason describing why {@code exception} should have been thrown. 078 */ 079 public static void assertException( final AntExecutionResult result, final Class<? extends Throwable> exception, 080 final CharSequence reason ) 081 { 082 assertNotNull( result ); 083 assertNotNull( exception ); 084 assertNotNull( reason ); 085 assertNotNull( reason.toString(), result.getThrowable() ); 086 assertTrue( reason.toString(), result.getThrowable().getClass() == exception ); 087 } 088 089 /** 090 * Tests an Ant execution to have thrown an instance of a given exception. 091 * 092 * @param result The result to test. 093 * @param exception The class the expected exception should be an instance of. 094 */ 095 public static void assertExceptionInstance( final AntExecutionResult result, 096 final Class<? extends Throwable> exception ) 097 { 098 assertNotNull( result ); 099 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 }