Assertions (AssertJ fluent assertions 1.3.0 API)

java.lang.Object
- org.assertj.core.api.Assertions

```
public class Assertions
extends Object
```
Entry point for assertion methods for different data types. Each method in this class is a static factory for the type-specific assertion objects. The purpose of this class is to make test code more readable.
For example:
```
 int removed = employees.removeFired();
 assertThat(removed).isZero();
 
 List<Employee> newEmployees = employees.hired(TODAY);
 assertThat(newEmployees).hasSize(6);
 
```
Author:

Alex Ruiz, Yvonne Wang, David DIDIER, Ted Young, Joel Costigliola, Matthieu Baechler, Mikhail Mazursky, Nicolas François, Julien Meddah, William Delanoue

Constructor Summary

Constructors
Modifier Constructor and Description

protected Assertions()
Creates a new Assertions.

Constructors
Modifier	Constructor and Description
`protected`	`Assertions()` Creates a new `Assertions`.

Method Summary

Methods
Modifier and Type	Method and Description
`static <T> Condition<T>`	`allOf(Condition<? super T>... conditions)` Creates a new `AllOf`
`static <T> Condition<T>`	`allOf(Iterable<? extends Condition<? super T>> conditions)` Creates a new `AllOf`
`static <T> Condition<T>`	`anyOf(Condition<? super T>... conditions)` Only delegate to `AnyOf.anyOf(Condition...)` so that Assertions offers a full feature entry point to all Fest Assert features (but you can use `AnyOf` if you prefer).
`static <T> Condition<T>`	`anyOf(Iterable<? extends Condition<? super T>> conditions)` Creates a new `AnyOf`
`static BigDecimalAssert`	`assertThat(BigDecimal actual)` Creates a new instance of `BigDecimalAssert`.
`static BooleanAssert`	`assertThat(boolean actual)` Creates a new instance of `BooleanAssert`.
`static BooleanAssert`	`assertThat(Boolean actual)` Creates a new instance of `BooleanAssert`.
`static BooleanArrayAssert`	`assertThat(boolean[] actual)` Creates a new instance of `BooleanArrayAssert`.
`static ByteAssert`	`assertThat(byte actual)` Creates a new instance of `ByteAssert`.
`static ByteAssert`	`assertThat(Byte actual)` Creates a new instance of `ByteAssert`.
`static ByteArrayAssert`	`assertThat(byte[] actual)` Creates a new instance of `ByteArrayAssert`.
`static CharacterAssert`	`assertThat(char actual)` Creates a new instance of `CharacterAssert`.
`static CharArrayAssert`	`assertThat(char[] actual)` Creates a new instance of `CharArrayAssert`.
`static CharacterAssert`	`assertThat(Character actual)` Creates a new instance of `CharacterAssert`.
`static CharSequenceAssert`	`assertThat(CharSequence actual)` Creates a new instance of `CharSequenceAssert`.
`static ClassAssert`	`assertThat(Class<?> actual)` Creates a new instance of `ClassAssert`
`static DateAssert`	`assertThat(Date actual)` Creates a new instance of `DateAssert`.
`static DoubleAssert`	`assertThat(double actual)` Creates a new instance of `DoubleAssert`.
`static DoubleAssert`	`assertThat(Double actual)` Creates a new instance of `DoubleAssert`.
`static DoubleArrayAssert`	`assertThat(double[] actual)` Creates a new instance of `DoubleArrayAssert`.
`static FileAssert`	`assertThat(File actual)` Creates a new instance of `FileAssert`.
`static FloatAssert`	`assertThat(float actual)` Creates a new instance of `FloatAssert`.
`static FloatAssert`	`assertThat(Float actual)` Creates a new instance of `FloatAssert`.
`static FloatArrayAssert`	`assertThat(float[] actual)` Creates a new instance of `FloatArrayAssert`.
`static InputStreamAssert`	`assertThat(InputStream actual)` Creates a new instance of `InputStreamAssert`.
`static IntegerAssert`	`assertThat(int actual)` Creates a new instance of `IntegerAssert`.
`static IntArrayAssert`	`assertThat(int[] actual)` Creates a new instance of `IntArrayAssert`.
`static IntegerAssert`	`assertThat(Integer actual)` Creates a new instance of `IntegerAssert`.
`static <T> IterableAssert<T>`	`assertThat(Iterable<T> actual)` Creates a new instance of `IterableAssert`.
`static <T> IterableAssert<T>`	`assertThat(Iterator<T> actual)` Creates a new instance of `IterableAssert`.
`static <T> ListAssert<T>`	`assertThat(List<T> actual)` Creates a new instance of `ListAssert`.
`static LongAssert`	`assertThat(long actual)` Creates a new instance of `LongAssert`.
`static LongAssert`	`assertThat(Long actual)` Creates a new instance of `LongAssert`.
`static LongArrayAssert`	`assertThat(long[] actual)` Creates a new instance of `LongArrayAssert`.
`static <K,V> MapAssert<K,V>`	`assertThat(Map<K,V> actual)` Creates a new instance of `MapAssert`.
`static ShortAssert`	`assertThat(short actual)` Creates a new instance of `ShortAssert`.
`static ShortAssert`	`assertThat(Short actual)` Creates a new instance of `ShortAssert`.
`static ShortArrayAssert`	`assertThat(short[] actual)` Creates a new instance of `ShortArrayAssert`.
`static StringAssert`	`assertThat(String actual)` Creates a new instance of `StringAssert`.
`static <T> ObjectAssert<T>`	`assertThat(T actual)` Creates a new instance of `ObjectAssert`.
`static <T> ObjectArrayAssert<T>`	`assertThat(T[] actual)` Creates a new instance of `ObjectArrayAssert`.
`static ThrowableAssert`	`assertThat(Throwable actual)` Creates a new instance of `ThrowableAssert`.
`static Index`	`atIndex(int index)` Only delegate to `Index.atIndex(int)` so that Assertions offers a full feature entry point to all Fest Assert features (but you can use `Index` if you prefer).
`static String`	`contentOf(File file)` Loads the text content of a file with the default character set, so that it can be passed to `assertThat(String)`.
`static String`	`contentOf(File file, Charset charset)` Loads the text content of a file, so that it can be passed to `assertThat(String)`.
`static String`	`contentOf(File file, String charsetName)` Loads the text content of a file, so that it can be passed to `assertThat(String)`.
`static <T> DoesNotHave<T>`	`doesNotHave(Condition<? super T> condition)` Creates a new `DoesNotHave`.
`static MapEntry`	`entry(Object key, Object value)` Only delegate to `MapEntry.entry(Object, Object)` so that Assertions offers a full feature entry point to all Fest Assert features (but you can use `MapEntry` if you prefer).
`static Properties<Object>`	`extractProperty(String propertyName)` Only delegate to `Properties.extractProperty(String)` so that Assertions offers a full feature entry point to all Fest Assert features (but you can use `Properties` if you prefer).
`static <T> Properties<T>`	`extractProperty(String propertyName, Class<T> propertyType)` Only delegate to `Properties.extractProperty(String)` so that Assertions offers a full feature entry point to all Fest Assert features (but you can use `Properties` if you prefer).
`static void`	`fail(String failureMessage)` Only delegate to `Fail.fail(String)` so that Assertions offers a full feature entry point to all Fest Assert features (but you can use Fail if you prefer).
`static void`	`fail(String failureMessage, Throwable realCause)` Only delegate to `Fail.fail(String, Throwable)` so that Assertions offers a full feature entry point to all Fest Assert features (but you can use Fail if you prefer).
`static void`	`failBecauseExceptionWasNotThrown(Class<? extends Throwable> exceptionClass)` Only delegate to `Fail.failBecauseExceptionWasNotThrown(Class)` so that Assertions offers a full feature entry point to all Fest Assert features (but you can use Fail if you prefer).
`static <E> Filters<E>`	`filter(E[] array)` Only delegate to `Filters.filter(Object[])` so that Assertions offers a full feature entry point to all Fest Assert features (but you can use `Filters` if you prefer).
`static <E> Filters<E>`	`filter(Iterable<E> iterableToFilter)` Only delegate to `Filters.filter(Object[])` so that Assertions offers a full feature entry point to all Fest Assert features (but you can use `Filters` if you prefer).
`static <T> Not<T>`	`not(Condition<? super T> condition)` Creates a new `Not`.
`static Offset<Double>`	`offset(Double value)` Only delegate to `Offset.offset(Double)` so that Assertions offers a full feature entry point to all Fest Assert features (but you can use `Offset` if you prefer).
`static Offset<Float>`	`offset(Float value)` Only delegate to `Offset.offset(Float)` so that Assertions offers a full feature entry point to all Fest Assert features (but you can use `Offset` if you prefer).
`static void`	`setRemoveAssertJRelatedElementsFromStackTrace(boolean removeAssertJRelatedElementsFromStackTrace)` Only delegate to `Fail.setRemoveAssertJRelatedElementsFromStackTrace(boolean)` so that Assertions offers a full feature entry point to all AssertJ Assert features (but you can use `Fail` if you prefer).
`static Tuple`	`tuple(Object... values)` Utility method to build nicely a `Tuple` when working with `AbstractIterableAssert.extracting(String...)` or `AbstractObjectArrayAssert.extracting(String...)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - Assertions
```
protected Assertions()
```
    Creates a new Assertions.
- Method Detail
  - assertThat
```
public static BigDecimalAssert assertThat(BigDecimal actual)
```
    Creates a new instance of BigDecimalAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static BooleanAssert assertThat(boolean actual)
```
    Creates a new instance of BooleanAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static BooleanAssert assertThat(Boolean actual)
```
    Creates a new instance of BooleanAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static BooleanArrayAssert assertThat(boolean[] actual)
```
    Creates a new instance of BooleanArrayAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static ByteAssert assertThat(byte actual)
```
    Creates a new instance of ByteAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static ByteAssert assertThat(Byte actual)
```
    Creates a new instance of ByteAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static ByteArrayAssert assertThat(byte[] actual)
```
    Creates a new instance of ByteArrayAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static CharacterAssert assertThat(char actual)
```
    Creates a new instance of CharacterAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static CharArrayAssert assertThat(char[] actual)
```
    Creates a new instance of CharArrayAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static CharacterAssert assertThat(Character actual)
```
    Creates a new instance of CharacterAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static ClassAssert assertThat(Class<?> actual)
```
    Creates a new instance of ClassAssert
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static <T> IterableAssert<T> assertThat(Iterable<T> actual)
```
    Creates a new instance of IterableAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static <T> IterableAssert<T> assertThat(Iterator<T> actual)
```
    Creates a new instance of IterableAssert. The Iterator is first converted into an Iterable
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static DoubleAssert assertThat(double actual)
```
    Creates a new instance of DoubleAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static DoubleAssert assertThat(Double actual)
```
    Creates a new instance of DoubleAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static DoubleArrayAssert assertThat(double[] actual)
```
    Creates a new instance of DoubleArrayAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static FileAssert assertThat(File actual)
```
    Creates a new instance of FileAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static InputStreamAssert assertThat(InputStream actual)
```
    Creates a new instance of InputStreamAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static FloatAssert assertThat(float actual)
```
    Creates a new instance of FloatAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static FloatAssert assertThat(Float actual)
```
    Creates a new instance of FloatAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static FloatArrayAssert assertThat(float[] actual)
```
    Creates a new instance of FloatArrayAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static IntegerAssert assertThat(int actual)
```
    Creates a new instance of IntegerAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static IntArrayAssert assertThat(int[] actual)
```
    Creates a new instance of IntArrayAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static IntegerAssert assertThat(Integer actual)
```
    Creates a new instance of IntegerAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static <T> ListAssert<T> assertThat(List<T> actual)
```
    Creates a new instance of ListAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static LongAssert assertThat(long actual)
```
    Creates a new instance of LongAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static LongAssert assertThat(Long actual)
```
    Creates a new instance of LongAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static LongArrayAssert assertThat(long[] actual)
```
    Creates a new instance of LongArrayAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static <T> ObjectAssert<T> assertThat(T actual)
```
    Creates a new instance of ObjectAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static <T> ObjectArrayAssert<T> assertThat(T[] actual)
```
    Creates a new instance of ObjectArrayAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static <K,V> MapAssert<K,V> assertThat(Map<K,V> actual)
```
    Creates a new instance of MapAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static ShortAssert assertThat(short actual)
```
    Creates a new instance of ShortAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static ShortAssert assertThat(Short actual)
```
    Creates a new instance of ShortAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static ShortArrayAssert assertThat(short[] actual)
```
    Creates a new instance of ShortArrayAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static CharSequenceAssert assertThat(CharSequence actual)
```
    Creates a new instance of CharSequenceAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static StringAssert assertThat(String actual)
```
    Creates a new instance of StringAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static DateAssert assertThat(Date actual)
```
    Creates a new instance of DateAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion object.
  - assertThat
```
public static ThrowableAssert assertThat(Throwable actual)
```
    Creates a new instance of ThrowableAssert.
    
    Parameters:
    actual - the actual value.
    
    Returns:
    the created assertion Throwable.
  - setRemoveAssertJRelatedElementsFromStackTrace
```
public static void setRemoveAssertJRelatedElementsFromStackTrace(boolean removeAssertJRelatedElementsFromStackTrace)
```
    Only delegate to Fail.setRemoveAssertJRelatedElementsFromStackTrace(boolean) so that Assertions offers a full feature entry point to all AssertJ Assert features (but you can use Fail if you prefer).
  - fail
```
public static void fail(String failureMessage)
```
    Only delegate to Fail.fail(String) so that Assertions offers a full feature entry point to all Fest Assert features (but you can use Fail if you prefer).
  - fail
```
public static void fail(String failureMessage,
        Throwable realCause)
```
    Only delegate to Fail.fail(String, Throwable) so that Assertions offers a full feature entry point to all Fest Assert features (but you can use Fail if you prefer).
  - failBecauseExceptionWasNotThrown
```
public static void failBecauseExceptionWasNotThrown(Class<? extends Throwable> exceptionClass)
```
    Only delegate to Fail.failBecauseExceptionWasNotThrown(Class) so that Assertions offers a full feature entry point to all Fest Assert features (but you can use Fail if you prefer).
  - extractProperty
```
public static <T> Properties<T> extractProperty(String propertyName,
                                Class<T> propertyType)
```
    Only delegate to Properties.extractProperty(String) so that Assertions offers a full feature entry point to all Fest Assert features (but you can use Properties if you prefer).
    Typical usage is to chain extractProperty with from method, see examples below :
```
 // extract simple property values having a java standard type (here String)
 assertThat(extractProperty("name", String.class).from(fellowshipOfTheRing)).contains("Boromir", "Gandalf", "Frodo",
     "Legolas").doesNotContain("Sauron", "Elrond");
 
 // extracting property works also with user's types (here Race)
 assertThat(extractProperty("race", String.class).from(fellowshipOfTheRing)).contains(HOBBIT, ELF).doesNotContain(ORC);
 
 // extract nested property on Race
 assertThat(extractProperty("race.name", String.class).from(fellowshipOfTheRing)).contains("Hobbit", "Elf")
     .doesNotContain("Orc");
 
```
  - extractProperty
```
public static Properties<Object> extractProperty(String propertyName)
```
    Only delegate to Properties.extractProperty(String) so that Assertions offers a full feature entry point to all Fest Assert features (but you can use Properties if you prefer).
    Typical usage is to chain extractProperty with from method, see examples below :
```
 // extract simple property values, as no type has been defined the extracted property will be considered as Object
 // to define the real property type (here String) use extractProperty("name", String.class) instead.
 assertThat(extractProperty("name").from(fellowshipOfTheRing)).contains("Boromir", "Gandalf", "Frodo", "Legolas")
     .doesNotContain("Sauron", "Elrond");
 
 // extracting property works also with user's types (here Race), even though it will be considered as Object
 // to define the real property type (here String) use extractProperty("name", Race.class) instead.
 assertThat(extractProperty("race").from(fellowshipOfTheRing)).contains(HOBBIT, ELF).doesNotContain(ORC);
 
 // extract nested property on Race
 assertThat(extractProperty("race.name").from(fellowshipOfTheRing)).contains("Hobbit", "Elf").doesNotContain("Orc");
 
```
  - tuple
```
public static Tuple tuple(Object... values)
```
    Utility method to build nicely a Tuple when working with AbstractIterableAssert.extracting(String...) or AbstractObjectArrayAssert.extracting(String...)
    
    Parameters:
    values - the values stored in the Tuple
    
    Returns:
    the built Tuple
  - entry
```
public static MapEntry entry(Object key,
             Object value)
```
    Only delegate to MapEntry.entry(Object, Object) so that Assertions offers a full feature entry point to all Fest Assert features (but you can use MapEntry if you prefer).
    Typical usage is to call entry in MapAssert contains assertion, see examples below :
```
 assertThat(ringBearers).contains(entry(oneRing, frodo), entry(nenya, galadriel));
 
```
  - atIndex
```
public static Index atIndex(int index)
```
    Only delegate to Index.atIndex(int) so that Assertions offers a full feature entry point to all Fest Assert features (but you can use Index if you prefer).
    Typical usage :
```
 List<Ring> elvesRings = newArrayList(vilya, nenya, narya);
 assertThat(elvesRings).contains(vilya, atIndex(0)).contains(nenya, atIndex(1)).contains(narya, atIndex(2));
 
```
  - offset
```
public static Offset<Double> offset(Double value)
```
    Only delegate to Offset.offset(Double) so that Assertions offers a full feature entry point to all Fest Assert features (but you can use Offset if you prefer).
    Typical usage :
```
 assertThat(8.1).isEqualTo(8.0, offset(0.1));
 
```
  - offset
```
public static Offset<Float> offset(Float value)
```
    Only delegate to Offset.offset(Float) so that Assertions offers a full feature entry point to all Fest Assert features (but you can use Offset if you prefer).
    Typical usage :
```
 assertThat(8.2f).isEqualTo(8.0f, offset(0.2f));
 
```
  - allOf
```
public static <T> Condition<T> allOf(Condition<? super T>... conditions)
```
    Creates a new AllOf
    
    Type Parameters:
    T - the type of object the given condition accept.
    Parameters:
    conditions - the conditions to evaluate.
    
    Returns:
    the created AnyOf.
    
    Throws:
    
    NullPointerException - if the given array is null.
    
    NullPointerException - if any of the elements in the given array is null.
  - allOf
```
public static <T> Condition<T> allOf(Iterable<? extends Condition<? super T>> conditions)
```
    Creates a new AllOf
    
    Type Parameters:
    T - the type of object the given condition accept.
    Parameters:
    conditions - the conditions to evaluate.
    
    Returns:
    the created AnyOf.
    
    Throws:
    
    NullPointerException - if the given iterable is null.
    
    NullPointerException - if any of the elements in the given iterable is null.
  - anyOf
```
public static <T> Condition<T> anyOf(Condition<? super T>... conditions)
```
    Only delegate to AnyOf.anyOf(Condition...) so that Assertions offers a full feature entry point to all Fest Assert features (but you can use AnyOf if you prefer).
    Typical usage (jedi and sith are Condition) :
```
 assertThat("Vader").is(anyOf(jedi, sith));
 
```
  - anyOf
```
public static <T> Condition<T> anyOf(Iterable<? extends Condition<? super T>> conditions)
```
    Creates a new AnyOf
    
    Type Parameters:
    T - the type of object the given condition accept.
    Parameters:
    conditions - the conditions to evaluate.
    
    Returns:
    the created AnyOf.
    
    Throws:
    
    NullPointerException - if the given iterable is null.
    
    NullPointerException - if any of the elements in the given iterable is null.
  - doesNotHave
```
public static <T> DoesNotHave<T> doesNotHave(Condition<? super T> condition)
```
    Creates a new DoesNotHave.
    
    Parameters:
    condition - the condition to inverse.
    
    Returns:
    The Not condition created.
  - not
```
public static <T> Not<T> not(Condition<? super T> condition)
```
    Creates a new Not.
    
    Parameters:
    condition - the condition to inverse.
    
    Returns:
    The Not condition created.
  - filter
```
public static <E> Filters<E> filter(E[] array)
```
    Only delegate to Filters.filter(Object[]) so that Assertions offers a full feature entry point to all Fest Assert features (but you can use Filters if you prefer).
    Note that the given array is not modified, the filters are performed on an Iterable copy of the array.
    Typical usage with Condition :
```
 assertThat(filter(players).being(potentialMVP).get()).containsOnly(james, rose);
 
```
    and with filter language based on java bean property :
```
 assertThat(filter(players).with("pointsPerGame").greaterThan(20).and("assistsPerGame").greaterThan(7).get())
     .containsOnly(james, rose);
 
```
  - filter
```
public static <E> Filters<E> filter(Iterable<E> iterableToFilter)
```
    Only delegate to Filters.filter(Object[]) so that Assertions offers a full feature entry point to all Fest Assert features (but you can use Filters if you prefer).
    Note that the given Iterable is not modified, the filters are performed on a copy.
    Typical usage with Condition :
```
 assertThat(filter(players).being(potentialMVP).get()).containsOnly(james, rose);
 
```
    and with filter language based on java bean property :
```
 assertThat(filter(players).with("pointsPerGame").greaterThan(20).and("assistsPerGame").greaterThan(7).get())
     .containsOnly(james, rose);
 
```
  - contentOf
```
public static String contentOf(File file,
               Charset charset)
```
    Loads the text content of a file, so that it can be passed to assertThat(String).
    Note that this will load the entire file in memory; for larger files, there might be a more efficient alternative with assertThat(File).
    
    Parameters:
    file - the file.
    charset - the character set to use.
    
    Returns:
    the content of the file.
    
    Throws:
    
    NullPointerException - if the given charset is null.
    
    FilesException - if an I/O exception occurs.
  - contentOf
```
public static String contentOf(File file,
               String charsetName)
```
    Loads the text content of a file, so that it can be passed to assertThat(String).
    Note that this will load the entire file in memory; for larger files, there might be a more efficient alternative with assertThat(File).
    
    Parameters:
    file - the file.
    charsetName - the name of the character set to use.
    
    Returns:
    the content of the file.
    
    Throws:
    
    IllegalArgumentException - if the given character set is not supported on this platform.
    
    FilesException - if an I/O exception occurs.
  - contentOf
```
public static String contentOf(File file)
```
    Loads the text content of a file with the default character set, so that it can be passed to assertThat(String).
    Note that this will load the entire file in memory; for larger files, there might be a more efficient alternative with assertThat(File).
    
    Parameters:
    file - the file.
    
    Returns:
    the content of the file.
    
    Throws:
    
    FilesException - if an I/O exception occurs.

Class Assertions

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Assertions

Method Detail

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

assertThat

setRemoveAssertJRelatedElementsFromStackTrace

fail

fail

failBecauseExceptionWasNotThrown

extractProperty

extractProperty

tuple

entry

atIndex

offset

offset

allOf

allOf

anyOf

anyOf

doesNotHave

not

filter

filter

contentOf

contentOf

contentOf