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