001 /* 002 * Created on Sep 30, 2010 003 * 004 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with 005 * the License. You may obtain a copy of the License at 006 * 007 * http://www.apache.org/licenses/LICENSE-2.0 008 * 009 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on 010 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the 011 * specific language governing permissions and limitations under the License. 012 * 013 * Copyright @2010-2011 the original author or authors. 014 */ 015 package org.fest.assertions.api; 016 017 import java.awt.image.BufferedImage; 018 import java.io.File; 019 import java.io.InputStream; 020 import java.math.BigDecimal; 021 import java.util.Collection; 022 import java.util.Date; 023 import java.util.List; 024 import java.util.Map; 025 026 import org.fest.assertions.condition.AnyOf; 027 import org.fest.assertions.core.Condition; 028 import org.fest.assertions.data.MapEntry; 029 import org.fest.assertions.groups.Properties; 030 import org.fest.assertions.util.ImageReader; 031 032 /** 033 * Entry point for assertion methods for different data types. Each method in this class is a static factory for the 034 * type-specific assertion objects. The purpose of this class is to make test code more readable. 035 * <p> 036 * For example: 037 * 038 * <pre> 039 * int removed = employees.removeFired(); 040 * {@link Assertions#assertThat(int) assertThat}(removed).{@link IntegerAssert#isZero isZero}(); 041 * 042 * List<Employee> newEmployees = employees.hired(TODAY); 043 * {@link Assertions#assertThat(Iterable) assertThat}(newEmployees).{@link IterableAssert#hasSize(int) hasSize}(6); 044 * </pre> 045 * </p> 046 * 047 * @author Alex Ruiz 048 * @author Yvonne Wang 049 * @author David DIDIER 050 * @author Ted Young 051 * @author Joel Costigliola 052 * @author Matthieu Baechler 053 */ 054 public class Assertions { 055 056 /** 057 * Creates a new instance of <code>{@link BigDecimalAssert}</code>. 058 * @param actual the actual value. 059 * @return the created assertion object. 060 */ 061 public static BigDecimalAssert assertThat(BigDecimal actual) { 062 return new BigDecimalAssert(actual); 063 } 064 065 /** 066 * Creates a new instance of <code>{@link BooleanAssert}</code>. 067 * @param actual the actual value. 068 * @return the created assertion object. 069 */ 070 public static BooleanAssert assertThat(boolean actual) { 071 return new BooleanAssert(actual); 072 } 073 074 /** 075 * Creates a new instance of <code>{@link BooleanAssert}</code>. 076 * @param actual the actual value. 077 * @return the created assertion object. 078 */ 079 public static BooleanAssert assertThat(Boolean actual) { 080 return new BooleanAssert(actual); 081 } 082 083 /** 084 * Creates a new instance of <code>{@link BooleanArrayAssert}</code>. 085 * @param actual the actual value. 086 * @return the created assertion object. 087 */ 088 public static BooleanArrayAssert assertThat(boolean[] actual) { 089 return new BooleanArrayAssert(actual); 090 } 091 092 /** 093 * Creates a new instance of <code>{@link ImageAssert}</code>. To read an image from the file system use 094 * <code>{@link ImageReader#readImageFrom(String)}</code>. 095 * @param actual the actual value. 096 * @return the created assertion object. 097 */ 098 public static ImageAssert assertThat(BufferedImage actual) { 099 return new ImageAssert(actual); 100 } 101 102 /** 103 * Creates a new instance of <code>{@link ByteAssert}</code>. 104 * @param actual the actual value. 105 * @return the created assertion object. 106 */ 107 public static ByteAssert assertThat(byte actual) { 108 return new ByteAssert(actual); 109 } 110 111 /** 112 * Creates a new instance of <code>{@link ByteAssert}</code>. 113 * @param actual the actual value. 114 * @return the created assertion object. 115 */ 116 public static ByteAssert assertThat(Byte actual) { 117 return new ByteAssert(actual); 118 } 119 120 /** 121 * Creates a new instance of <code>{@link ByteArrayAssert}</code>. 122 * @param actual the actual value. 123 * @return the created assertion object. 124 */ 125 public static ByteArrayAssert assertThat(byte[] actual) { 126 return new ByteArrayAssert(actual); 127 } 128 129 /** 130 * Creates a new instance of <code>{@link CharacterAssert}</code>. 131 * @param actual the actual value. 132 * @return the created assertion object. 133 */ 134 public static CharacterAssert assertThat(char actual) { 135 return new CharacterAssert(actual); 136 } 137 138 /** 139 * Creates a new instance of <code>{@link CharArrayAssert}</code>. 140 * @param actual the actual value. 141 * @return the created assertion object. 142 */ 143 public static CharArrayAssert assertThat(char[] actual) { 144 return new CharArrayAssert(actual); 145 } 146 147 /** 148 * Creates a new instance of <code>{@link CharacterAssert}</code>. 149 * @param actual the actual value. 150 * @return the created assertion object. 151 */ 152 public static CharacterAssert assertThat(Character actual) { 153 return new CharacterAssert(actual); 154 } 155 156 /** 157 * Creates a new instance of <code>{@link IterableAssert}</code>. 158 * @param actual the actual value. 159 * @return the created assertion object. 160 */ 161 public static IterableAssert assertThat(Iterable<?> actual) { 162 return new IterableAssert(actual); 163 } 164 165 /** 166 * Creates a new instance of <code>{@link DoubleAssert}</code>. 167 * @param actual the actual value. 168 * @return the created assertion object. 169 */ 170 public static DoubleAssert assertThat(double actual) { 171 return new DoubleAssert(actual); 172 } 173 174 /** 175 * Creates a new instance of <code>{@link DoubleAssert}</code>. 176 * @param actual the actual value. 177 * @return the created assertion object. 178 */ 179 public static DoubleAssert assertThat(Double actual) { 180 return new DoubleAssert(actual); 181 } 182 183 /** 184 * Creates a new instance of <code>{@link DoubleArrayAssert}</code>. 185 * @param actual the actual value. 186 * @return the created assertion object. 187 */ 188 public static DoubleArrayAssert assertThat(double[] actual) { 189 return new DoubleArrayAssert(actual); 190 } 191 192 /** 193 * Creates a new instance of <code>{@link FileAssert}</code>. 194 * @param actual the actual value. 195 * @return the created assertion object. 196 */ 197 public static FileAssert assertThat(File actual) { 198 return new FileAssert(actual); 199 } 200 201 /** 202 * Creates a new instance of <code>{@link InputStreamAssert}</code>. 203 * @param actual the actual value. 204 * @return the created assertion object. 205 */ 206 public static InputStreamAssert assertThat(InputStream actual) { 207 return new InputStreamAssert(actual); 208 } 209 210 /** 211 * Creates a new instance of <code>{@link FloatAssert}</code>. 212 * @param actual the actual value. 213 * @return the created assertion object. 214 */ 215 public static FloatAssert assertThat(float actual) { 216 return new FloatAssert(actual); 217 } 218 219 /** 220 * Creates a new instance of <code>{@link FloatAssert}</code>. 221 * @param actual the actual value. 222 * @return the created assertion object. 223 */ 224 public static FloatAssert assertThat(Float actual) { 225 return new FloatAssert(actual); 226 } 227 228 /** 229 * Creates a new instance of <code>{@link FloatArrayAssert}</code>. 230 * @param actual the actual value. 231 * @return the created assertion object. 232 */ 233 public static FloatArrayAssert assertThat(float[] actual) { 234 return new FloatArrayAssert(actual); 235 } 236 237 /** 238 * Creates a new instance of <code>{@link IntegerAssert}</code>. 239 * @param actual the actual value. 240 * @return the created assertion object. 241 */ 242 public static IntegerAssert assertThat(int actual) { 243 return new IntegerAssert(actual); 244 } 245 246 /** 247 * Creates a new instance of <code>{@link IntArrayAssert}</code>. 248 * @param actual the actual value. 249 * @return the created assertion object. 250 */ 251 public static IntArrayAssert assertThat(int[] actual) { 252 return new IntArrayAssert(actual); 253 } 254 255 /** 256 * Creates a new instance of <code>{@link IntegerAssert}</code>. 257 * @param actual the actual value. 258 * @return the created assertion object. 259 */ 260 public static IntegerAssert assertThat(Integer actual) { 261 return new IntegerAssert(actual); 262 } 263 264 /** 265 * Creates a new instance of <code>{@link ListAssert}</code>. 266 * @param actual the actual value. 267 * @return the created assertion object. 268 */ 269 public static ListAssert assertThat(List<?> actual) { 270 return new ListAssert(actual); 271 } 272 273 /** 274 * Creates a new instance of <code>{@link LongAssert}</code>. 275 * @param actual the actual value. 276 * @return the created assertion object. 277 */ 278 public static LongAssert assertThat(long actual) { 279 return new LongAssert(actual); 280 } 281 282 /** 283 * Creates a new instance of <code>{@link LongAssert}</code>. 284 * @param actual the actual value. 285 * @return the created assertion object. 286 */ 287 public static LongAssert assertThat(Long actual) { 288 return new LongAssert(actual); 289 } 290 291 /** 292 * Creates a new instance of <code>{@link LongArrayAssert}</code>. 293 * @param actual the actual value. 294 * @return the created assertion object. 295 */ 296 public static LongArrayAssert assertThat(long[] actual) { 297 return new LongArrayAssert(actual); 298 } 299 300 /** 301 * Creates a new instance of <code>{@link ObjectAssert}</code>. 302 * @param actual the actual value. 303 * @return the created assertion object. 304 */ 305 public static ObjectAssert assertThat(Object actual) { 306 return new ObjectAssert(actual); 307 } 308 309 /** 310 * Creates a new instance of <code>{@link ObjectArrayAssert}</code>. 311 * @param actual the actual value. 312 * @return the created assertion object. 313 */ 314 public static ObjectArrayAssert assertThat(Object[] actual) { 315 return new ObjectArrayAssert(actual); 316 } 317 318 /** 319 * Creates a new instance of <code>{@link MapAssert}</code>. 320 * @param actual the actual value. 321 * @return the created assertion object. 322 */ 323 public static MapAssert assertThat(Map<?, ?> actual) { 324 return new MapAssert(actual); 325 } 326 327 /** 328 * Creates a new instance of <code>{@link ShortAssert}</code>. 329 * @param actual the actual value. 330 * @return the created assertion object. 331 */ 332 public static ShortAssert assertThat(short actual) { 333 return new ShortAssert(actual); 334 } 335 336 /** 337 * Creates a new instance of <code>{@link ShortAssert}</code>. 338 * @param actual the actual value. 339 * @return the created assertion object. 340 */ 341 public static ShortAssert assertThat(Short actual) { 342 return new ShortAssert(actual); 343 } 344 345 /** 346 * Creates a new instance of <code>{@link ShortArrayAssert}</code>. 347 * @param actual the actual value. 348 * @return the created assertion object. 349 */ 350 public static ShortArrayAssert assertThat(short[] actual) { 351 return new ShortArrayAssert(actual); 352 } 353 354 /** 355 * Creates a new instance of <code>{@link StringAssert}</code>. 356 * @param actual the actual value. 357 * @return the created assertion object. 358 */ 359 public static StringAssert assertThat(String actual) { 360 return new StringAssert(actual); 361 } 362 363 /** 364 * Creates a new instance of <code>{@link DateAssert}</code>. 365 * @param actual the actual value. 366 * @return the created assertion object. 367 */ 368 public static DateAssert assertThat(Date actual) { 369 return new DateAssert(actual); 370 } 371 372 /** 373 * Creates a new instance of <code>{@link ThrowableAssert}</code>. 374 * @param actual the actual value. 375 * @return the created assertion Throwable. 376 */ 377 public static ThrowableAssert assertThat(Throwable actual) { 378 return new ThrowableAssert(actual); 379 } 380 381 // ------------------------------------------------------------------------------------------------- 382 // fail methods : not assertions but here to have a single entry point to all Fest Assert features. 383 // ------------------------------------------------------------------------------------------------- 384 385 /** 386 * Only delegate to {@link Fail#setRemoveFestRelatedElementsFromStackTrace(boolean)} so that Assertions offers a full 387 * feature entry point to all Fest Assert features (but you can use Fail if you prefer). 388 */ 389 public static void setRemoveFestRelatedElementsFromStackTrace(boolean removeFestRelatedElementsFromStackTrace) { 390 Fail.setRemoveFestRelatedElementsFromStackTrace(removeFestRelatedElementsFromStackTrace); 391 } 392 393 /** 394 * Only delegate to {@link Fail#fail(String)} so that Assertions offers a full feature entry point to all Fest Assert 395 * features (but you can use Fail if you prefer). 396 */ 397 public static void fail(String failureMessage) { 398 Fail.fail(failureMessage); 399 } 400 401 /** 402 * Only delegate to {@link Fail#fail(String, Throwable)} so that Assertions offers a full feature entry point to all 403 * Fest Assert features (but you can use Fail if you prefer). 404 */ 405 public static void fail(String failureMessage, Throwable realCause) { 406 Fail.fail(failureMessage, realCause); 407 } 408 409 /** 410 * Only delegate to {@link Fail#failBecauseExceptionWasNotThrown(Class)} so that Assertions offers a full feature 411 * entry point to all Fest Assert features (but you can use Fail if you prefer). 412 */ 413 public static void failBecauseExceptionWasNotThrown(Class<? extends Exception> exceptionClass) { 414 Fail.failBecauseExceptionWasNotThrown(exceptionClass); 415 } 416 417 // ------------------------------------------------------------------------------------------------------ 418 // properties methods : not assertions but here to have a single entry point to all Fest Assert features. 419 // ------------------------------------------------------------------------------------------------------ 420 421 /** 422 * Only delegate to {@link Properties#extractProperty(String)} so that Assertions offers a full feature entry point to 423 * all Fest Assert features (but you can use Fail if you prefer). 424 * <p> 425 * Typical usage is to chain <code>extractProperty</code> with <code>from</code> method, see examples below : 426 * 427 * <pre> 428 * // extract simple property values having a java standard type (here String) 429 * assertThat(extractProperty("name").from(fellowshipOfTheRing)).contains("Boromir", "Gandalf", "Frodo", "Legolas") 430 * .doesNotContain("Sauron", "Elrond"); 431 * 432 * // extracting property works also with user's types (here Race) 433 * assertThat(extractProperty("race").from(fellowshipOfTheRing)).contains(HOBBIT, ELF).doesNotContain(ORC); 434 * 435 * // extract nested property on Race 436 * assertThat(extractProperty("race.name").from(fellowshipOfTheRing)).contains("Hobbit", "Elf").doesNotContain("Orc"); 437 * </pre> 438 */ 439 public static Properties extractProperty(String propertyName) { 440 return Properties.extractProperty(propertyName); 441 } 442 443 // ------------------------------------------------------------------------------------------------------ 444 // Map utility methods : not assertions but here to have a single entry point to all Fest Assert features. 445 // ------------------------------------------------------------------------------------------------------ 446 447 /** 448 * Only delegate to {@link MapEntry#entry(Object, Object)} so that Assertions offers a full feature entry point to all 449 * Fest Assert features (but you can use Fail if you prefer). 450 * <p> 451 * Typical usage is to call <code>entry</code> in MapAssert <code>contains</code> assertion, see examples below : 452 * 453 * <pre> 454 * assertThat(ringBearers).contains(entry(oneRing, frodo), entry(nenya, galadriel)); 455 * </pre> 456 */ 457 public static MapEntry entry(Object key, Object value) { 458 return MapEntry.entry(key, value); 459 } 460 461 // ------------------------------------------------------------------------------------------------------ 462 // Condition methods : not assertions but here to have a single entry point to all Fest Assert features. 463 // ------------------------------------------------------------------------------------------------------ 464 /** 465 * Only delegate to {@link AnyOf#anyOf(Condition...)} so that Assertions offers a full feature entry point to all Fest 466 * Assert features (but you can use AnyOf if you prefer). 467 * <p> 468 * Typical usage (<code>jedi</code> and <code>sith</code> are {@link Condition}) : 469 * 470 * <pre> 471 * assertThat("Vader").is(anyOf(jedi, sith)); 472 * </pre> 473 * See 474 */ 475 public static <T> Condition<T> anyOf(Condition<T>... conditions) { 476 return AnyOf.anyOf(conditions); 477 } 478 479 /** 480 * Creates a new <code>{@link AnyOf}</code> 481 * @param <T> the type of object the given condition accept. 482 * @param conditions the conditions to evaluate. 483 * @return the created {@code AnyOf}. 484 * @throws NullPointerException if the given collection is {@code null}. 485 * @throws NullPointerException if any of the elements in the given collection is {@code null}. 486 */ 487 public static <T> Condition<T> anyOf(Collection<Condition<T>> conditions) { 488 return AnyOf.anyOf(conditions); 489 } 490 491 /** Creates a new </code>{@link Assertions}</code>. */ 492 protected Assertions() {} 493 }