ObjectEnumerableAssert (AssertJ fluent assertions 2.9.1 API)

Type Parameters:
SELF - the "self" type of this assertion class. Please read "Emulating 'self types' using Java Generics to simplify fluent API implementation" for more details.
ELEMENT - the type of elements of the "actual" value.

All Superinterfaces:

EnumerableAssert<SELF,ELEMENT>

All Known Subinterfaces:

IndexedObjectEnumerableAssert<SELF,ELEMENT>

All Known Implementing Classes:

AbstractIterableAssert, AbstractListAssert, AbstractObjectArrayAssert, AtomicReferenceArrayAssert, ClassBasedNavigableIterableAssert, ClassBasedNavigableListAssert, FactoryBasedNavigableIterableAssert, FactoryBasedNavigableListAssert, IterableAssert, ListAssert, ObjectArrayAssert, SoftAssertionIterableAssert, SoftAssertionListAssert
```
public interface ObjectEnumerableAssert<SELF extends ObjectEnumerableAssert<SELF,ELEMENT>,ELEMENT>
extends EnumerableAssert<SELF,ELEMENT>
```
Assertions methods applicable to groups of objects (e.g. arrays or collections.)

Author:

Yvonne Wang, Alex Ruiz, Nicolas François, Mikhail Mazursky, Joel Costigliola, Nicolas François, Florent Biville

Method Summary

Methods
Modifier and Type	Method and Description
`SELF`	`are(Condition<? super ELEMENT> condition)` Verifies that each element value satisfies the given condition.
`SELF`	`areAtLeast(int n, Condition<? super ELEMENT> condition)` Verifies that there are at least n elements in the actual group satisfying the given condition.
`SELF`	`areAtLeastOne(Condition<? super ELEMENT> condition)` Verifies that there is at least one element in the actual group satisfying the given condition.
`SELF`	`areAtMost(int n, Condition<? super ELEMENT> condition)` Verifies that there are at most n elements in the actual group satisfying the given condition.
`SELF`	`areExactly(int n, Condition<? super ELEMENT> condition)` Verifies that there are exactly n elements in the actual group satisfying the given condition.
`SELF`	`areNot(Condition<? super ELEMENT> condition)` Verifies that each element value does not satisfy the given condition.
`SELF`	`contains(ELEMENT... values)` Verifies that the actual group contains the given values, in any order.
`SELF`	`containsAll(Iterable<? extends ELEMENT> iterable)` Verifies that the actual group contains all the elements of given `Iterable`, in any order.
`SELF`	`containsAnyElementsOf(Iterable<ELEMENT> iterable)` Verifies that the `Iterable` under test contains at least one of the given `Iterable` elements.
`SELF`	`containsAnyOf(ELEMENT... values)` Verifies that the actual `Iterable` contains at least one of the given values.
`SELF`	`containsExactly(ELEMENT... values)` Verifies that the actual group contains exactly the given values and nothing else, in order. This assertion should only be used with groups that have a consistent iteration order (i.e.
`SELF`	`containsExactlyElementsOf(Iterable<? extends ELEMENT> iterable)` Same as `containsExactly(Object...)` but handle the `Iterable` to array conversion : verifies that actual contains exactly the elements of the given iterable and nothing else in the same order.
`SELF`	`containsExactlyInAnyOrder(ELEMENT... values)` Verifies that the actual group contains exactly the given values and nothing else, in any order.
`SELF`	`containsExactlyInAnyOrderElementsOf(Iterable<? extends ELEMENT> values)` Verifies that the actual group contains exactly the given values and nothing else, in any order.
`SELF`	`containsNull()` Verifies that the actual group contains at least a null element.
`SELF`	`containsOnly(ELEMENT... values)` Verifies that the actual group contains only the given values and nothing else, in any order and ignoring duplicates (i.e.
`SELF`	`containsOnlyElementsOf(Iterable<? extends ELEMENT> iterable)` Same semantic as `containsOnly(Object[])` : verifies that actual contains all the elements of the given iterable and nothing else, in any order and ignoring duplicates (i.e.
`SELF`	`containsOnlyNulls()` Verifies that the actual group contains only null elements and nothing else.
`SELF`	`containsOnlyOnce(ELEMENT... values)` Verifies that the actual group contains the given values only once.
`SELF`	`containsSequence(ELEMENT... sequence)` Verifies that the actual group contains the given sequence in the correct order and without extra values between the sequence values.
`SELF`	`containsSequence(Iterable<? extends ELEMENT> sequence)` Verifies that the actual group contains the given sequence in the correct order and without extra values between the sequence values.
`SELF`	`containsSubsequence(ELEMENT... sequence)` Verifies that the actual group contains the given subsequence in the correct order (possibly with other values between them).
`SELF`	`containsSubsequence(Iterable<? extends ELEMENT> sequence)` Verifies that the actual group contains the given subsequence in the correct order (possibly with other values between them).
`SELF`	`doesNotContain(ELEMENT... values)` Verifies that the actual group does not contain the given values.
`SELF`	`doesNotContainAnyElementsOf(Iterable<? extends ELEMENT> iterable)` Verifies that actual does not contain any elements of the given `Iterable` (i.e.
`SELF`	`doesNotContainNull()` Verifies that the actual group does not contain null elements.
`SELF`	`doesNotContainSequence(ELEMENT... sequence)` Verifies that the actual group does not contain the given sequence, a sequence is defined by an ordered group of values without extra values between them.
`SELF`	`doesNotContainSequence(Iterable<? extends ELEMENT> sequence)` Verifies that the actual group does not contain the given sequence, a sequence is defined by an ordered group of values without extra values between them.
`SELF`	`doesNotContainSubsequence(ELEMENT... sequence)` Verifies that the actual group does not contain the given subsequence, a subsequence is defined by an ordered group of values with possibly extra values between them.
`SELF`	`doesNotContainSubsequence(Iterable<? extends ELEMENT> sequence)` Verifies that the actual group does not contain the given subsequence, a subsequence is defined by an ordered group of values with possibly extra values between them.
`SELF`	`doesNotHaveAnyElementsOfTypes(Class<?>... unexpectedTypes)` Verifies that all the elements in the actual `Object` group do not belong to the specified types (including subclasses).
`SELF`	`doesNotHaveDuplicates()` Verifies that the actual group does not contain duplicates.
`SELF`	`doNotHave(Condition<? super ELEMENT> condition)` Verifies that all elements do not satisfy the given condition.
`SELF`	`endsWith(ELEMENT[] sequence)` Verifies that the actual group ends with the given sequence of objects, without any other objects between them.
`SELF`	`endsWith(ELEMENT first, ELEMENT... sequence)` Verifies that the actual group ends with the given sequence of objects, without any other objects between them.
`SELF`	`hasAtLeastOneElementOfType(Class<?> expectedType)` Verifies that at least one element in the actual `Object` group has the specified type (matching includes subclasses of the given type).
`SELF`	`hasOnlyElementsOfType(Class<?> expectedType)` Verifies that all the elements in the actual `Object` group belong to the specified type (matching includes subclasses of the given type).
`SELF`	`hasOnlyElementsOfTypes(Class<?>... types)` Verifies that all elements of the actual group are instances of the given types.
`SELF`	`hasSameElementsAs(Iterable<? extends ELEMENT> iterable)` An alias of `containsOnlyElementsOf(Iterable)` : verifies that actual contains all the elements of the given iterable and nothing else, in any order.
`SELF`	`have(Condition<? super ELEMENT> condition)` Verifies that all elements satisfy the given condition.
`SELF`	`haveAtLeast(int n, Condition<? super ELEMENT> condition)` Verifies that there are at least n elements in the actual group satisfying the given condition.
`SELF`	`haveAtLeastOne(Condition<? super ELEMENT> condition)` Verifies that there is at least one element in the actual group satisfying the given condition.
`SELF`	`haveAtMost(int n, Condition<? super ELEMENT> condition)` Verifies that there are at most n elements in the actual group satisfying the given condition.
`SELF`	`haveExactly(int n, Condition<? super ELEMENT> condition)` Verifies that there are exactly n elements in the actual group satisfying the given condition.
`SELF`	`isSubsetOf(ELEMENT... values)` Verifies that all the elements of actual are present in the given values.
`SELF`	`isSubsetOf(Iterable<? extends ELEMENT> values)` Verifies that all the elements of actual are present in the given `Iterable`.
`SELF`	`startsWith(ELEMENT... sequence)` Verifies that the actual group starts with the given sequence of objects, without any other objects between them.

Methods inherited from interface org.assertj.core.api.EnumerableAssert
hasSameSizeAs, hasSameSizeAs, hasSize, isEmpty, isNotEmpty, isNullOrEmpty, usingDefaultElementComparator, usingElementComparator

- Method Detail
  - contains
```
SELF contains(ELEMENT... values)
```
    Verifies that the actual group contains the given values, in any order.
    Example:
```
 Iterable<String> abc = newArrayList("a", "b", "c");
 
 // assertions will pass
 assertThat(abc).contains("b", "a");
 assertThat(abc).contains("b", "a", "b");
 
 // assertion will fail
 assertThat(abc).contains("d");
```
    If you want to specify the elements to check with an Iterable, use containsAll(Iterable) instead.
    Parameters:
    values - the given values.
    
    Returns:
    this assertion object.
    
    Throws:
    
    NullPointerException - if the given argument is null.
    
    IllegalArgumentException - if the given argument is an empty array.
    
    AssertionError - if the actual group is null.
    
    AssertionError - if the actual group does not contain the given values.
  - containsOnly
```
SELF containsOnly(ELEMENT... values)
```
    Verifies that the actual group contains only the given values and nothing else, in any order and ignoring duplicates (i.e. once a value is found, its duplicates are also considered found).
    If you need to check exactly the elements and their duplicates use:
    - containsExactly(Object...) if the order does matter
    - containsExactlyInAnyOrder(Object...) if the order does not matter
    Example:
```
 Iterable<String> abc = newArrayList("a", "b", "c");

 // assertions will pass as order does not matter
 assertThat(abc).containsOnly("c", "b", "a");
 // duplicates are ignored   
 assertThat(abc).containsOnly("a", "a", "b", "c", "c");
 // ... on both actual and expected values 
 assertThat(asList("a", "a", "b")).containsOnly("a", "b")
                                  .containsOnly("a", "a", "b", "b");
 
 // assertion will fail because "c" is missing in the given values
 assertThat(abc).containsOnly("a", "b");
 // assertion will fail because "d" is missing in abc (use isSubsetOf if you want this assertion to pass)
 assertThat(abc).containsOnly("a", "b", "c", "d");
```
    If you need to check that actual is a subset of the given values, use isSubsetOf(Object...).
    If you want to specify the elements to check with an Iterable, use containsOnlyElementsOf(Iterable) instead.
    Parameters:
    values - the given values.
    
    Returns:
    this assertion object.
    
    Throws:
    
    NullPointerException - if the given argument is null.
    
    IllegalArgumentException - if the given argument is an empty array.
    
    AssertionError - if the actual group is null.
    
    AssertionError - if the actual group does not contain the given values, i.e. the actual group contains some or none of the given values, or the actual group contains more values than the given ones.
  - containsOnlyNulls
```
SELF containsOnlyNulls()
```
    Verifies that the actual group contains only null elements and nothing else.
    Example:
```
 // assertion will pass
 Iterable<String> items = Arrays.asList(null, null, null);
 assertThat(items).containsOnlyNulls();

 // assertion will fail because items2 contains a not null element
 Iterable<String> items2 = Arrays.asList(null, null, "notNull");
 assertThat(items2).containsOnlyNulls();
 
 // assertion will fail since an empty iterable does not contain any elements and therefore no null ones.
 Iterable<String> empty = new ArrayList<>();
 assertThat(empty).containsOnlyNulls();
```
    Returns:
    this assertion object.
    
    Throws:
    
    AssertionError - if the actual group is null.
    
    AssertionError - if the actual group is empty or contains non null elements.
    Since:
    
    2.9.0 / 3.9.0
  - containsOnlyOnce
```
SELF containsOnlyOnce(ELEMENT... values)
```
    Verifies that the actual group contains the given values only once.
    Examples :
```
 // lists are used in the examples but it would also work with arrays
 
 // assertions will pass
 assertThat(newArrayList("winter", "is", "coming")).containsOnlyOnce("winter");
 assertThat(newArrayList("winter", "is", "coming")).containsOnlyOnce("coming", "winter");
 
 // assertions will fail
 assertThat(newArrayList("winter", "is", "coming")).containsOnlyOnce("Lannister");
 assertThat(newArrayList("Arya", "Stark", "daughter", "of", "Ned", "Stark")).containsOnlyOnce("Stark");
 assertThat(newArrayList("Arya", "Stark", "daughter", "of", "Ned", "Stark")).containsOnlyOnce("Stark", "Lannister", "Arya");
```
    Parameters:
    values - the given values.
    
    Returns:
    this assertion object.
    
    Throws:
    
    NullPointerException - if the given argument is null.
    
    IllegalArgumentException - if the given argument is an empty array.
    
    AssertionError - if the actual group is null.
    
    AssertionError - if the actual group does not contain the given values, i.e. the actual group contains some or none of the given values, or the actual group contains more than once these values.
  - containsExactly
```
SELF containsExactly(ELEMENT... values)
```
    Verifies that the actual group contains exactly the given values and nothing else, in order.
    This assertion should only be used with groups that have a consistent iteration order (i.e. don't use it with HashSet, prefer containsOnly(Object...) in that case).
    Example:
```
 // an Iterable is used in the example but it would also work with an array
 Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya);
 
 // assertion will pass
 assertThat(elvesRings).containsExactly(vilya, nenya, narya);
 
 // assertion will fail as actual and expected order differ
 assertThat(elvesRings).containsExactly(nenya, vilya, narya);
```
    If you want to specify the elements to check with an Iterable, use containsExactlyElementsOf(Iterable) instead.
    Parameters:
    values - the given values.
    
    Returns:
    this assertion object.
    
    Throws:
    
    NullPointerException - if the given argument is null.
    
    AssertionError - if the actual group is null.
    
    AssertionError - if the actual group does not contain the given values with same order, i.e. the actual group contains some or none of the given values, or the actual group contains more values than the given ones or values are the same but the order is not.
  - containsExactlyInAnyOrder
```
SELF containsExactlyInAnyOrder(ELEMENT... values)
```
    Verifies that the actual group contains exactly the given values and nothing else, in any order.
    
    Example:
```
 // an Iterable is used in the example but it would also work with an array
 Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya, vilya);

 // assertion will pass
 assertThat(elvesRings).containsExactlyInAnyOrder(vilya, vilya, nenya, narya);

 // assertion will fail as vilya is contained twice in elvesRings.
 assertThat(elvesRings).containsExactlyInAnyOrder(nenya, vilya, narya);
```
    If you want to specify the elements to check with an Iterable, use containsExactlyInAnyOrderElementsOf(Iterable) instead.
    Parameters:
    values - the given values.
    
    Returns:
    this assertion object.
    
    Throws:
    
    NullPointerException - if the given argument is null.
    
    AssertionError - if the actual group is null.
    
    AssertionError - if the actual group does not contain the given values, i.e. the actual group contains some or none of the given values, or the actual group contains more values than the given ones.
  - containsExactlyInAnyOrderElementsOf
```
SELF containsExactlyInAnyOrderElementsOf(Iterable<? extends ELEMENT> values)
```
    Verifies that the actual group contains exactly the given values and nothing else, in any order.
    
    Example:
```
 // an Iterable is used in the example but it would also work with an array
 Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya, vilya);
 Iterable<Ring> elvesRingsSomeMissing = newArrayList(vilya, nenya, narya);
 Iterable<Ring> elvesRingsDifferentOrder = newArrayList(nenya, narya, vilya, vilya);

 // assertion will pass
 assertThat(elvesRings).containsExactlyInAnyOrder(elvesRingsDifferentOrder);

 // assertion will fail as vilya is contained twice in elvesRings.
 assertThat(elvesRings).containsExactlyInAnyOrder(elvesRingsSomeMissing);
```
    If you want to directly specify the elements to check, use containsExactlyInAnyOrder(Object...) instead.
    Parameters:
    values - the given values.
    
    Returns:
    this assertion object.
    
    Throws:
    
    NullPointerException - if the given argument is null.
    
    AssertionError - if the actual group is null.
    
    AssertionError - if the actual group does not contain the given values, i.e. the actual group contains some or none of the given values, or the actual group contains more values than the given ones.
    Since:
    
    2.9.0 / 3.9.0
  - containsSequence
```
SELF containsSequence(ELEMENT... sequence)
```
    Verifies that the actual group contains the given sequence in the correct order and without extra values between the sequence values.
    Use containsSubsequence(Object...) to allow values between the expected sequence values.
    Example:
```
 // an Iterable is used in the example but it would also work with an array
 Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya);
 
 // assertions will pass
 assertThat(elvesRings).containsSequence(vilya, nenya)
                       .containsSequence(nenya, narya);
 
 // assertions will fail, the elements order is correct but there is a value between them (nenya) 
 assertThat(elvesRings).containsSequence(vilya, narya);  
 assertThat(elvesRings).containsSequence(nenya, vilya);
```
    If you want to specify the sequence to check with an Iterable, use containsSequence(Iterable) instead.
    Parameters:
    sequence - the sequence of objects to look for.
    
    Returns:
    this assertion object.
    
    Throws:
    
    AssertionError - if the actual group is null.
    
    AssertionError - if the given array is null.
    
    AssertionError - if the actual group does not contain the given sequence.
  - containsSequence
```
SELF containsSequence(Iterable<? extends ELEMENT> sequence)
```
    Verifies that the actual group contains the given sequence in the correct order and without extra values between the sequence values.
    Use containsSubsequence(Iterable) to allow values between the expected sequence values.
    Example:
```
 Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya);

 // assertions will pass
 assertThat(elvesRings).containsSequence(newArrayList(vilya, nenya))
                       .containsSequence(newArrayList(nenya, narya));

 // assertions will fail, the elements order is correct but there is a value between them (nenya)
 assertThat(elvesRings).containsSequence(newArrayList(vilya, narya));
 assertThat(elvesRings).containsSequence(newArrayList(nenya, vilya));
```
    If you want to directly specify the elements of the sequence to check, use containsSequence(Object...) instead.
    Parameters:
    sequence - the sequence of objects to look for.
    
    Returns:
    this assertion object.
    
    Throws:
    
    AssertionError - if the actual group is null.
    
    AssertionError - if the given array is null.
    
    AssertionError - if the actual group does not contain the given sequence.
  - doesNotContainSequence
```
SELF doesNotContainSequence(ELEMENT... sequence)
```
    Verifies that the actual group does not contain the given sequence, a sequence is defined by an ordered group of values without extra values between them.
    Use doesNotContainSubsequence(Object...) to also ensure the sequence does not exist with values between the expected sequence values.
    Example:
```
 // an Iterable is used in the example but it would also work with an array
 Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya);

 // assertions will pass, the elements order is correct but there is a value between them (nenya)
 assertThat(elvesRings).doesNotContainSequence(vilya, narya)
                       .doesNotContainSequence(nenya, vilya);

 // assertions will fail
 assertThat(elvesRings).doesNotContainSequence(vilya, nenya);
 assertThat(elvesRings).doesNotContainSequence(nenya, narya);
```
    If you want to specify the sequence not to find with an Iterable, use doesNotContainSequence(Iterable) instead.
    Parameters:
    sequence - the sequence of objects to look for.
    
    Returns:
    this assertion object.
    
    Throws:
    
    AssertionError - if the actual group is null.
    
    AssertionError - if the given array is null.
    
    AssertionError - if the actual group contains the given sequence.
  - doesNotContainSequence
```
SELF doesNotContainSequence(Iterable<? extends ELEMENT> sequence)
```
    Verifies that the actual group does not contain the given sequence, a sequence is defined by an ordered group of values without extra values between them.
    Use doesNotContainSubsequence(Iterable) to also ensure the sequence does not exist with values between the sequence values.
    Example:
```
 // an Iterable is used in the example but it would also work with an array
 Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya);

 // assertions will pass, the elements order is correct but there is a value between them (nenya)
 assertThat(elvesRings).doesNotContainSequence(newArrayList(vilya, narya))
                       .doesNotContainSequence(newArrayList(nenya, vilya));

 // assertions will fail
 assertThat(elvesRings).doesNotContainSequence(newArrayList(vilya, nenya));
 assertThat(elvesRings).doesNotContainSequence(newArrayList(nenya, narya));
```
    If you want to directly specify the elements of the sequence not to find, use doesNotContainSequence(Object...) instead.
    Parameters:
    sequence - the sequence of objects to look for.
    
    Returns:
    this assertion object.
    
    Throws:
    
    AssertionError - if the actual group is null.
    
    AssertionError - if the given array is null.
    
    AssertionError - if the actual group contains the given sequence.
  - containsSubsequence
```
SELF containsSubsequence(ELEMENT... sequence)
```
    Verifies that the actual group contains the given subsequence in the correct order (possibly with other values between them).
    Example:
```
 // an Iterable is used in the example but it would also work with an array
 Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya);
 
 // assertions will pass
 assertThat(elvesRings).containsSubsequence(vilya, nenya)
                       .containsSubsequence(vilya, narya);
 
 // assertion will fail
 assertThat(elvesRings).containsSubsequence(nenya, vilya);
```
    If you want to specify the elements of the subsequence to check with an Iterable, use containsSubsequence(Iterable) instead.
    Parameters:
    sequence - the sequence of objects to look for.
    
    Returns:
    this assertion object.
    
    Throws:
    
    AssertionError - if the actual group is null.
    
    AssertionError - if the given array is null.
    
    AssertionError - if the actual group does not contain the given subsequence.
  - containsSubsequence
```
SELF containsSubsequence(Iterable<? extends ELEMENT> sequence)
```
    Verifies that the actual group contains the given subsequence in the correct order (possibly with other values between them).
    Example:
```
 Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya);

 // assertions will pass
 assertThat(elvesRings).containsSubsequence(newArrayList(vilya, nenya))
                       .containsSubsequence(newArrayList(vilya, narya));

 // assertion will fail
 assertThat(elvesRings).containsSubsequence(newArrayList(nenya, vilya));
```
    If you want to directly specify the subsequence to check, use containsSubsequence(Object...) instead.
    Parameters:
    sequence - the sequence of objects to look for.
    
    Returns:
    this assertion object.
    
    Throws:
    
    AssertionError - if the actual group is null.
    
    AssertionError - if the given array is null.
    
    AssertionError - if the actual group does not contain the given subsequence.
  - doesNotContainSubsequence
```
SELF doesNotContainSubsequence(ELEMENT... sequence)
```
    Verifies that the actual group does not contain the given subsequence, a subsequence is defined by an ordered group of values with possibly extra values between them.
    Example:
```
 // an Iterable is used in the example but it would also work with an array
 Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya);

 // assertions will pass
 assertThat(elvesRings).doesNotContainSubsequence(nenya, vilya)
                       .doesNotContainSubsequence(narya, vilya);

 // assertion will fail
 assertThat(elvesRings).doesNotContainSubsequence(vilya, nenya);
 assertThat(elvesRings).doesNotContainSubsequence(vilya, narya);
```
    If you want to specify the subsequence not to find with an Iterable, use doesNotContainSubsequence(Iterable) instead.
    Parameters:
    sequence - the sequence of objects to look for.
    
    Returns:
    this assertion object.
    
    Throws:
    
    AssertionError - if the actual group is null.
    
    AssertionError - if the given array is null.
    
    AssertionError - if the actual group contains the given subsequence.
  - doesNotContainSubsequence
```
SELF doesNotContainSubsequence(Iterable<? extends ELEMENT> sequence)
```
    Verifies that the actual group does not contain the given subsequence, a subsequence is defined by an ordered group of values with possibly extra values between them.
    Example:
```
 Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya);

 // assertions will pass
 assertThat(elvesRings).doesNotContainSubsequence(newArrayList(nenya, vilya));
                       .doesNotContainSubsequence(newArrayList(narya, vilya));

 // assertion will fail
 assertThat(elvesRings).doesNotContainSubsequence(newArrayList(vilya, nenya));
 assertThat(elvesRings).doesNotContainSubsequence(newArrayList(vilya, narya));
```
    If you want to directly specify the elements of the subsequence not to find, use doesNotContainSubsequence(Object...) instead.
    Parameters:
    sequence - the sequence of objects to look for.
    
    Returns:
    this assertion object.
    
    Throws:
    
    AssertionError - if the actual group is null.
    
    AssertionError - if the given array is null.
    
    AssertionError - if the actual group contains the given subsequence.
  - doesNotContain
```
SELF doesNotContain(ELEMENT... values)
```
    Verifies that the actual group does not contain the given values.
    Example:
```
 // an Iterable is used in the example but it would also work with an array
 Iterable<String> abc = newArrayList("a", "b", "c");

 // assertions will pass
 assertThat(abc).doesNotContain("d")
                .doesNotContain("d", "e");
 
 // assertions will fail
 assertThat(abc).doesNotContain("a");
 assertThat(abc).doesNotContain("a", "b");
 assertThat(abc).doesNotContain("c", "d");
```
    If you want to specify the elements not to find with an Iterable, use doesNotContainAnyElementsOf(Iterable) instead.
    Parameters:
    values - the given values.
    
    Returns:
    this assertion object.
    
    Throws:
    
    NullPointerException - if the given argument is null.
    
    IllegalArgumentException - if the given argument is an empty array.
    
    AssertionError - if the actual group is null.
    
    AssertionError - if the actual group contains any of the given values.
  - doesNotHaveDuplicates
```
SELF doesNotHaveDuplicates()
```
    Verifies that the actual group does not contain duplicates.
    Example:
```
 // an Iterable is used in the example but it would also work with an array
 Iterable<String> abc = newArrayList("a", "b", "c");
 Iterable<String> lotsOfAs = newArrayList("a", "a", "a");

 // assertion will pass
 assertThat(abc).doesNotHaveDuplicates();
 
 // assertion will fail
 assertThat(lotsOfAs).doesNotHaveDuplicates();
```
    Returns:
    this assertion object.
    
    Throws:
    
    AssertionError - if the actual group is null.
    
    AssertionError - if the actual group contains duplicates.
  - startsWith
```
SELF startsWith(ELEMENT... sequence)
```
    Verifies that the actual group starts with the given sequence of objects, without any other objects between them. Similar to containsSequence(Object...), but it also verifies that the first element in the sequence is also first element of the actual group.
    Example:
```
 // an Iterable is used in the example but it would also work with an array
 Iterable<String> abc = newArrayList("a", "b", "c");

 // assertions will pass
 assertThat(abc).startsWith("a")
                .startsWith("a", "b");
 
 // assertion will fail
 assertThat(abc).startsWith("c");
```
    Parameters:
    sequence - the sequence of objects to look for.
    
    Returns:
    this assertion object.
    
    Throws:
    
    NullPointerException - if the given argument is null.
    
    IllegalArgumentException - if the given argument is an empty array.
    
    AssertionError - if the actual group is null.
    
    AssertionError - if the actual group does not start with the given sequence of objects.
  - endsWith
```
SELF endsWith(ELEMENT first,
            ELEMENT... sequence)
```
    Verifies that the actual group ends with the given sequence of objects, without any other objects between them. Similar to containsSequence(Object...), but it also verifies that the last element in the sequence is also last element of the actual group.
    Example:
```
 // an Iterable is used in the example but it would also work with an array
 Iterable<String> abc = newArrayList("a", "b", "c");

 // assertions will pass
 assertThat(abc).endsWith("c")
                .endsWith("b", "c");
 
 // assertions will fail
 assertThat(abc).endsWith("a");
 assertThat(abc).endsWith("a", "b");
```
    Parameters:
    sequence - the sequence of objects to look for.
    
    Returns:
    this assertion object.
    
    Throws:
    
    NullPointerException - if the given argument is null.
    
    IllegalArgumentException - if the given argument is an empty array.
    
    AssertionError - if the actual group is null.
    
    AssertionError - if the actual group does not end with the given sequence of objects.
  - endsWith
```
SELF endsWith(ELEMENT[] sequence)
```
    Verifies that the actual group ends with the given sequence of objects, without any other objects between them. Similar to containsSequence(Object...), but it also verifies that the last element in the sequence is also last element of the actual group.
    Example:
```
 // an Iterable is used in the example but it would also work with an array
 Iterable<String> abc = newArrayList("a", "b", "c");

 // assertions will pass
 assertThat(abc).endsWith(new String[0])
                .endsWith(new String[] {"c"})
                .endsWith(new String[] {"b", "c"});

 // assertions will fail
 assertThat(abc).endsWith(new String[] {"a"});
 assertThat(abc).endsWith(new String[] {"a", "b"});
```
    Parameters:
    sequence - the sequence of objects to look for.
    
    Returns:
    this assertion object.
    
    Throws:
    
    NullPointerException - if the given argument is null.
    
    AssertionError - if the actual group is null.
    
    AssertionError - if the actual group does not end with the given sequence of objects.
  - containsNull
```
SELF containsNull()
```
    Verifies that the actual group contains at least a null element.
    Example:
```
 Iterable<String> abc = newArrayList("a", "b", "c");
 Iterable<String> abNull = newArrayList("a", "b", null);

 // assertion will pass
 assertThat(abNull).containsNull();
 
 // assertion will fail
 assertThat(abc).containsNull();
```
    Returns:
    this assertion object.
    
    Throws:
    
    AssertionError - if the actual group is null.
    
    AssertionError - if the actual group does not contain a null element.
  - doesNotContainNull
```
SELF doesNotContainNull()
```
    Verifies that the actual group does not contain null elements.
    Example:
```
 Iterable<String> abc = newArrayList("a", "b", "c");
 Iterable<String> abNull = newArrayList("a", "b", null);

 // assertion will pass
 assertThat(abc).doesNotContainNull();

 // assertion will fail
 assertThat(abNull).doesNotContainNull();
```
    Returns:
    this assertion object.
    
    Throws:
    
    AssertionError - if the actual group is null.
    
    AssertionError - if the actual group contains a null element.
  - are
```
SELF are(Condition<? super ELEMENT> condition)
```
    Verifies that each element value satisfies the given condition.
    Example:
```
 Iterable<String> abc  = newArrayList("a", "b", "c");
 Iterable<String> abcc = newArrayList("a", "b", "cc");

 Condition<String> singleCharacterString = new Condition<String>() {
   public boolean matches(String value) {
     return value.length() == 1;
   }
 });

 // assertion will pass
 assertThat(abc).are(singleCharacterString);
 
 // assertion will fail
 assertThat(abcc).are(singleCharacterString);
```
    Parameters:
    condition - the given condition.
    
    Returns:
    this object.
    
    Throws:
    
    NullPointerException - if the given condition is null.
    
    AssertionError - if an element cannot be cast to T.
    
    AssertionError - if one or more elements do not satisfy the given condition.
  - areNot
```
SELF areNot(Condition<? super ELEMENT> condition)
```
    Verifies that each element value does not satisfy the given condition.
    Example:
```
 Iterable<String> abc = newArrayList("a", "b", "c");
 Iterable<String> abcc = newArrayList("a", "b", "cc");

 Condition<String> moreThanOneCharacter = new Condition<String>() {
   public boolean matches(String value) {
     return value.length() > 1;
   }
 });

 // assertion will pass
 assertThat(abc).areNot(moreThanOneCharacter);
 
 // assertion will fail
 assertThat(abcc).areNot(moreThanOneCharacter);
```
    Parameters:
    condition - the given condition.
    
    Returns:
    this object.
    
    Throws:
    
    NullPointerException - if the given condition is null.
    
    AssertionError - if an element cannot be cast to T.
    
    AssertionError - if one or more elements satisfy the given condition.
  - have
```
SELF have(Condition<? super ELEMENT> condition)
```
    Verifies that all elements satisfy the given condition.
    Example:
```
 Iterable<String> abc = newArrayList("a", "b", "c");
 Iterable<String> abcc = newArrayList("a", "b", "cc");

 Condition<String> onlyOneCharacter = new Condition<String>() {
   public boolean matches(String value) {
     return value.length() == 1;
   }
 });

 // assertion will pass
 assertThat(abc).have(onlyOneCharacter);
 
 // assertion will fail
 assertThat(abcc).have(onlyOneCharacter);
```
    Parameters:
    condition - the given condition.
    
    Returns:
    this object.
    
    Throws:
    
    NullPointerException - if the given condition is null.
    
    AssertionError - if an element cannot be cast to T.
    
    AssertionError - if one or more elements do not satisfy the given condition.
  - doNotHave
```
SELF doNotHave(Condition<? super ELEMENT> condition)
```
    Verifies that all elements do not satisfy the given condition.
    Example:
```
 Iterable<String> abc = newArrayList("a", "b", "c");
 Iterable<String> abcc = newArrayList("a", "b", "cc");

 Condition<String> moreThanOneCharacter = new Condition<String>() {
   public boolean matches(String value) {
     return value.length() > 1;
   }
 });

 // assertion will pass
 assertThat(abc).doNotHave(moreThanOneCharacter);
 
 // assertion will fail
 assertThat(abcc).doNotHave(moreThanOneCharacter);
```
    Parameters:
    condition - the given condition.
    
    Returns:
    this object.
    
    Throws:
    
    NullPointerException - if the given condition is null.
    
    AssertionError - if an element cannot be cast to T.
    
    AssertionError - if one or more elements satisfy the given condition.
  - areAtLeast
```
SELF areAtLeast(int n,
              Condition<? super ELEMENT> condition)
```
    Verifies that there are at least n elements in the actual group satisfying the given condition.
    Example:
```
 Iterable<Integer> oneTwoThree = newArrayList(1, 2, 3);

 Condition<Integer> oddNumber = new Condition<Integer>() {
   public boolean matches(Integer value) {
     return value % 2 == 1;
   }
 });

 // assertion will pass
 oneTwoThree.areAtLeast(2, oddNumber);
 
 // assertion will fail
 oneTwoThree.areAtLeast(3, oddNumber);
```
    Parameters:
    n - the minimum number of times the condition should be verified.
    condition - the given condition.
    
    Returns:
    this object.
    
    Throws:
    
    NullPointerException - if the given condition is null.
    
    AssertionError - if an element can not be cast to T.
    
    AssertionError - if the number of elements satisfying the given condition is < n.
  - areAtLeastOne
```
SELF areAtLeastOne(Condition<? super ELEMENT> condition)
```
    Verifies that there is at least one element in the actual group satisfying the given condition.
    This method is an alias for areAtLeast(1, condition).
    Example:
```
 // jedi is a Condition<String>
 assertThat(newLinkedHashSet("Luke", "Solo", "Leia")).areAtLeastOne(jedi);
```
    Parameters:
    condition - the given condition.
    
    Returns:
    this assertion object.
    See Also:
    haveAtLeast(int, Condition)
  - areAtMost
```
SELF areAtMost(int n,
             Condition<? super ELEMENT> condition)
```
    Verifies that there are at most n elements in the actual group satisfying the given condition.
    Example:
```
 Iterable<Integer> oneTwoThree = newArrayList(1, 2, 3);

 Condition<Integer> oddNumber = new Condition<Integer>() {
   public boolean matches(Integer value) {
     return value % 2 == 1;
   }
 });

 // assertions will pass
 oneTwoThree.areAtMost(2, oddNumber)
            .areAtMost(3, oddNumber);
 
 // assertion will fail
 oneTwoThree.areAtMost(1, odd);
```
    Parameters:
    n - the number of times the condition should be at most verified.
    condition - the given condition.
    
    Returns:
    this object.
    
    Throws:
    
    NullPointerException - if the given condition is null.
    
    AssertionError - if an element cannot be cast to T.
    
    AssertionError - if the number of elements satisfying the given condition is > n.
  - areExactly
```
SELF areExactly(int n,
              Condition<? super ELEMENT> condition)
```
    Verifies that there are exactly n elements in the actual group satisfying the given condition.
    Example:
```
 Iterable<Integer> oneTwoThree = newArrayList(1, 2, 3);

 Condition<Integer> odd = new Condition<Integer>() {
   public boolean matches(Integer value) {
     return value % 2 == 1;
   }
 });

 // assertion will pass
 oneTwoThree.areExactly(2, odd);
 
 // assertions will fail
 oneTwoThree.areExactly(1, odd);
 oneTwoThree.areExactly(3, odd);
```
    Parameters:
    n - the exact number of times the condition should be verified.
    condition - the given condition.
    
    Returns:
    this object.
    
    Throws:
    
    NullPointerException - if the given condition is null.
    
    AssertionError - if an element cannot be cast to T.
    
    AssertionError - if the number of elements satisfying the given condition is ≠ n.
  - haveAtLeastOne
```
SELF haveAtLeastOne(Condition<? super ELEMENT> condition)
```
    Verifies that there is at least one element in the actual group satisfying the given condition.
    This method is an alias for haveAtLeast(1, condition).
    Example:
```
 List<BasketBallPlayer> bullsPlayers = newArrayList(noah, rose);
 
 // potentialMvp is a Condition<BasketBallPlayer>
 assertThat(bullsPlayers).haveAtLeastOne(potentialMvp);
```
    Parameters:
    condition - the given condition.
    
    Returns:
    this assertion object.
    See Also:
    haveAtLeast(int, Condition)
  - haveAtLeast
```
SELF haveAtLeast(int n,
               Condition<? super ELEMENT> condition)
```
    Verifies that there are at least n elements in the actual group satisfying the given condition.
    Example:
```
 Iterable<Integer> oneTwoThree = newArrayList(1, 2, 3);

 Condition<Integer> oddNumber = new Condition<Integer>() {
   public boolean matches(Integer value) {
     return value % 2 == 1;
   }
 });

 // assertion will pass
 oneTwoThree.haveAtLeast(2, oddNumber);
 
 // assertion will fail
 oneTwoThree.haveAtLeast(3, oddNumber);
```
    This method is an alias for areAtLeast(int, Condition).
    Parameters:
    n - the minimum number of times the condition must hold.
    condition - the given condition.
    
    Returns:
    this assertion object.
  - haveAtMost
```
SELF haveAtMost(int n,
              Condition<? super ELEMENT> condition)
```
    Verifies that there are at most n elements in the actual group satisfying the given condition.
    Example:
```
 Iterable<Integer> oneTwoThree = newArrayList(1, 2, 3);

 Condition<Integer> oddNumber = new Condition<Integer>() {
   public boolean matches(Integer value) {
     return value % 2 == 1;
   }
 });

 // assertions will pass
 oneTwoThree.haveAtMost(2, oddNumber);
 oneTwoThree.haveAtMost(3, oddNumber);
 
 // assertion will fail
 oneTwoThree.haveAtMost(1, odd);
```
    This method is an alias areAtMost(int, Condition).
    Parameters:
    n - the maximum number of times the condition must hold.
    condition - the given condition.
    
    Returns:
    this assertion object.
  - haveExactly
```
SELF haveExactly(int n,
               Condition<? super ELEMENT> condition)
```
    Verifies that there are exactly n elements in the actual group satisfying the given condition.
    Example:
```
 Iterable<Integer> oneTwoThree = newArrayList(1, 2, 3);

 Condition<Integer> oddNumber = new Condition<Integer>() {
   public boolean matches(Integer value) {
     return value % 2 == 1;
   }
 });

 // assertion will pass
 oneTwoThree.haveExactly(2, oddNumber);
 
 // assertions will fail
 oneTwoThree.haveExactly(1, oddNumber);
 oneTwoThree.haveExactly(3, oddNumber);
```
    This method is an alias areExactly(int, Condition).
    Parameters:
    n - the exact number of times the condition must hold.
    condition - the given condition.
    
    Returns:
    this assertion object.
  - containsAll
```
SELF containsAll(Iterable<? extends ELEMENT> iterable)
```
    Verifies that the actual group contains all the elements of given Iterable, in any order.
    Example:
```
 Iterable<String> abc = Arrays.asList("a", "b", "c");
 
 // assertions will pass
 assertThat(abc).containsAll(Arrays.asList("b", "c"))
                .containsAll(Arrays.asList("a", "b", "c"));
 
 // assertions will fail
 assertThat(abc).containsAll(Arrays.asList("d"));
 assertThat(abc).containsAll(Arrays.asList("a", "b", "c", "d"));
```
    If you want to directly specify the elements to check, use contains(Object...) instead.
    Parameters:
    iterable - the given Iterable we will get elements from.
    
    Returns:
    this assertion object.
    
    Throws:
    
    NullPointerException - if the given argument is null.
    
    AssertionError - if the actual group is null.
    
    AssertionError - if the actual group does not contain all the elements of given Iterable.
  - hasOnlyElementsOfTypes
```
SELF hasOnlyElementsOfTypes(Class<?>... types)
```
    Verifies that all elements of the actual group are instances of the given types.
    Example:
```
 Iterable<? extends Object> objects = Arrays.asList("foo", new StringBuilder());
 
 // assertions will pass
 assertThat(objects).hasOnlyElementsOfTypes(CharSequence.class)
                    .hasOnlyElementsOfTypes(String.class, StringBuilder.class);
 
 // assertions will fail
 assertThat(objects).hasOnlyElementsOfTypes(Number.class);
 assertThat(objects).hasOnlyElementsOfTypes(String.class, Number.class);
 assertThat(objects).hasOnlyElementsOfTypes(String.class);
```
    Parameters:
    types - the expected classes and interfaces
    
    Returns:
    this assertion object.
    
    Throws:
    
    NullPointerException - if the given argument is null.
    
    AssertionError - if the actual group is null.
    
    AssertionError - if not all elements of the actual group are instances of one of the given types
    Since:
    
    2.7.0 / 3.7.0
  - hasAtLeastOneElementOfType
```
SELF hasAtLeastOneElementOfType(Class<?> expectedType)
```
    Verifies that at least one element in the actual Object group has the specified type (matching includes subclasses of the given type).
    Example:
```
 Number[] numbers = { 2, 6L, 8.0 };
 
 // successful assertion:
 assertThat(numbers).hasAtLeastOneElementOfType(Long.class);
 
 // assertion failure:
 assertThat(numbers).hasAtLeastOneElementOfType(Float.class);
```
    Parameters:
    expectedType - the expected type.
    
    Returns:
    this assertion object.
    
    Throws:
    
    NullPointerException - if the given type is null.
    
    AssertionError - if the actual Object group does not have any elements of the given type.
  - hasOnlyElementsOfType
```
SELF hasOnlyElementsOfType(Class<?> expectedType)
```
    Verifies that all the elements in the actual Object group belong to the specified type (matching includes subclasses of the given type).
    Example:
```
 Number[] numbers = { 2, 6, 8 };
 
 // successful assertion:
 assertThat(numbers).hasOnlyElementsOfType(Integer.class);
 
 // assertion failure:
 assertThat(numbers).hasOnlyElementsOfType(Long.class);
```
    Parameters:
    expectedType - the expected type.
    
    Returns:
    this assertion object.
    
    Throws:
    
    NullPointerException - if the given type is null.
    
    AssertionError - if one element is not of the expected type.
  - doesNotHaveAnyElementsOfTypes
```
SELF doesNotHaveAnyElementsOfTypes(Class<?>... unexpectedTypes)
```
    Verifies that all the elements in the actual Object group do not belong to the specified types (including subclasses).
    Example:
```
 Number[] numbers = { 2, 6, 8.0 };

 // successful assertion:
 assertThat(numbers).doesNotHaveAnyElementsOfTypes(Long.class, Float.class);

 // assertion failure:
 assertThat(numbers).doesNotHaveAnyElementsOfTypes(Long.class, Integer.class);
```
    Parameters:
    unexpectedTypes - the not expected types.
    
    Returns:
    this assertion object.
    
    Throws:
    
    NullPointerException - if the given type is null.
    
    AssertionError - if one element's type matches the given types.
    Since:
    
    2.9.0 / 3.9.0
  - containsExactlyElementsOf
```
SELF containsExactlyElementsOf(Iterable<? extends ELEMENT> iterable)
```
    Same as containsExactly(Object...) but handle the Iterable to array conversion : verifies that actual contains exactly the elements of the given iterable and nothing else in the same order.
    Example:
```
 Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya);
 
 // assertion will pass
 assertThat(elvesRings).containsExactlyElementsOf(newLinkedList(vilya, nenya, narya));
 
 // assertion will fail as actual and expected order differ
 assertThat(elvesRings).containsExactlyElementsOf(newLinkedList(nenya, vilya, narya));
```
    If you want to directly specify the elements to check, use containsExactly(Object...) instead.
    Parameters:
    iterable - the given Iterable we will get elements from.
    
    Returns:
    this assertion object.
  - containsOnlyElementsOf
```
SELF containsOnlyElementsOf(Iterable<? extends ELEMENT> iterable)
```
    Same semantic as containsOnly(Object[]) : verifies that actual contains all the elements of the given iterable and nothing else, in any order and ignoring duplicates (i.e. once a value is found, its duplicates are also considered found).
    Use isSubsetOf(Iterable) to check that actual is a subset of given iterable
    Example:
```
 Iterable<Ring> rings = newArrayList(nenya, vilya);
 
 // assertion will pass
 assertThat(rings).containsOnlyElementsOf(newArrayList(nenya, vilya))
                  .containsOnlyElementsOf(newArrayList(nenya, nenya, vilya, vilya));
 assertThat(newArrayList(nenya, nenya, vilya, vilya)).containsOnlyElementsOf(rings);
 
 // assertion will fail as actual does not contain narya
 assertThat(rings).containsOnlyElementsOf(newLinkedList(nenya, vilya, narya));
 // assertion will fail as actual contains nenya
 assertThat(rings).containsOnlyElementsOf(newLinkedList(vilya));
```
    If you want to directly specify the elements to check, use containsOnly(Object...) instead.
    Parameters:
    iterable - the given Iterable we will get elements from.
    
    Returns:
    this assertion object.
  - hasSameElementsAs
```
SELF hasSameElementsAs(Iterable<? extends ELEMENT> iterable)
```
    An alias of containsOnlyElementsOf(Iterable) : verifies that actual contains all the elements of the given iterable and nothing else, in any order.
    Example:
```
 Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya);
 
 // assertions will pass:
 assertThat(elvesRings).hasSameElementsAs(newArrayList(nenya, narya, vilya))
                       .hasSameElementsAs(newArrayList(nenya, narya, vilya, nenya));
 
 // assertions will fail:
 assertThat(elvesRings).hasSameElementsAs(newArrayList(nenya, narya));
 assertThat(elvesRings).hasSameElementsAs(newArrayList(nenya, narya, vilya, oneRing));
```
    Parameters:
    iterable - the Iterable whose elements we expect to be present
    
    Returns:
    this assertion object
    
    Throws:
    
    AssertionError - if the actual group is null
    
    NullPointerException - if the given Iterable is null
    
    AssertionError - if the actual Iterable does not have the same elements, in any order, as the given Iterable
  - doesNotContainAnyElementsOf
```
SELF doesNotContainAnyElementsOf(Iterable<? extends ELEMENT> iterable)
```
    Verifies that actual does not contain any elements of the given Iterable (i.e. none).
    Example:
```
 Iterable<String> abc = newArrayList("a", "b", "c"); 
 
 // assertion succeeds:
 assertThat(actual).doesNotContainAnyElementsOf(newArrayList("d", "e"));
 
 // assertion fails:
 assertThat(actual).doesNotContainAnyElementsOf(newArrayList("d", "e", "a"));
```
    If you want to directly specify the elements not to find, use doesNotContain(Object...) instead.
    Parameters:
    iterable - the Iterable whose elements must not be in the actual group.
    
    Returns:
    this assertion object.
    
    Throws:
    
    NullPointerException - if the given argument is null.
    
    IllegalArgumentException - if the given argument is an empty iterable.
    
    AssertionError - if the actual group is null.
    
    AssertionError - if the actual group contains some elements of the given Iterable.
  - isSubsetOf
```
SELF isSubsetOf(Iterable<? extends ELEMENT> values)
```
    Verifies that all the elements of actual are present in the given Iterable.
    Example:
```
 // an Iterable is used in the example but it would also work with an array
 List<Ring> ringsOfPower = newArrayList(oneRing, vilya, nenya, narya, dwarfRing, manRing);
 Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya);
 
 // assertion will pass:
 assertThat(elvesRings).isSubsetOf(ringsOfPower);
 
 // assertion will fail:
 assertThat(elvesRings).isSubsetOf(newArrayList(nenya, narya));
```
    If you want to directly specify the set of elements, use isSubsetOf(Object...) instead.
    Parameters:
    values - the Iterable that should contain all actual elements.
    
    Returns:
    this assertion object.
    
    Throws:
    
    AssertionError - if the actual Iterable is null.
    
    NullPointerException - if the given Iterable is null.
    
    AssertionError - if the actual Iterable is not subset of set Iterable.
  - isSubsetOf
```
SELF isSubsetOf(ELEMENT... values)
```
    Verifies that all the elements of actual are present in the given values.
    Example:
```
 // an Iterable is used in the example but it would also work with an array
 Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya);
 
 // assertions will pass:
 assertThat(elvesRings).isSubsetOf(vilya, nenya, narya)
                       .isSubsetOf(vilya, nenya, narya, dwarfRing);
 
 // assertions will fail:
 assertThat(elvesRings).isSubsetOf(vilya, nenya);
 assertThat(elvesRings).isSubsetOf(vilya, nenya, dwarfRing);
```
    If you want to specify the set of elements an Iterable, use isSubsetOf(Iterable) instead.
    Parameters:
    values - the values that should be used for checking the elements of actual.
    
    Returns:
    this assertion object.
    
    Throws:
    
    AssertionError - if the actual Iterable is null.
    
    AssertionError - if the actual Iterable is not subset of the given values.
  - containsAnyOf
```
SELF containsAnyOf(ELEMENT... values)
```
    Verifies that the actual Iterable contains at least one of the given values.
    Example:
```
 Iterable<String> abc = Arrays.asList("a", "b", "c");

 // assertions will pass
 assertThat(abc).containsAnyOf("b")
                .containsAnyOf("b", "c")
                .containsAnyOf("a", "b", "c")
                .containsAnyOf("a", "b", "c", "d")
                .containsAnyOf("e", "f", "g", "b");

 // assertions will fail
 assertThat(abc).containsAnyOf("d");
 assertThat(abc).containsAnyOf("d", "e", "f", "g");
```
    If you want to specify the elements to check with an Iterable, use containsAnyElementsOf(Iterable) instead.
    Parameters:
    values - the values whose at least one which is expected to be in the Iterable under test.
    
    Returns:
    this assertion object.
    
    Throws:
    
    NullPointerException - if the array of values is null.
    
    IllegalArgumentException - if the array of values is empty and the Iterable under test is not empty.
    
    AssertionError - if the Iterable under test is null.
    
    AssertionError - if the Iterable under test does not contain any of the given values.
    Since:
    
    2.9.0 / 3.9.0
  - containsAnyElementsOf
```
SELF containsAnyElementsOf(Iterable<ELEMENT> iterable)
```
    Verifies that the Iterable under test contains at least one of the given Iterable elements.
    Example:
```
 Iterable<String> abc = Arrays.asList("a", "b", "c");

 // assertions will pass
 assertThat(abc).containsAnyElementsOf(Arrays.asList("b"))
                .containsAnyElementsOf(Arrays.asList("b", "c"))
                .containsAnyElementsOf(Arrays.asList("a", "b", "c"))
                .containsAnyElementsOf(Arrays.asList("a", "b", "c", "d"))
                .containsAnyElementsOf(Arrays.asList("e", "f", "g", "b"));

 // assertions will fail
 assertThat(abc).containsAnyElementsOf(Arrays.asList("d"));
 assertThat(abc).containsAnyElementsOf(Arrays.asList("d", "e", "f", "g"));
```
    If you want to directly specify the elements to check, use containsAnyOf(Object...) instead.
    Parameters:
    iterable - the iterable whose at least one element is expected to be in the Iterable under test.
    
    Returns:
    this assertion object.
    
    Throws:
    
    NullPointerException - if the iterable of expected values is null.
    
    IllegalArgumentException - if the iterable of expected values is empty and the Iterable under test is not empty.
    
    AssertionError - if the Iterable under test is null.
    
    AssertionError - if the Iterable under test does not contain any of elements from the given Iterable.
    Since:
    
    2.9.0 / 3.9.0

Interface ObjectEnumerableAssert<SELF extends ObjectEnumerableAssert<SELF,ELEMENT>,ELEMENT>

Method Summary

Methods inherited from interface org.assertj.core.api.EnumerableAssert

Method Detail

contains

containsOnly

containsOnlyNulls

containsOnlyOnce

containsExactly

containsExactlyInAnyOrder

containsExactlyInAnyOrderElementsOf

containsSequence

containsSequence

doesNotContainSequence

doesNotContainSequence

containsSubsequence

containsSubsequence

doesNotContainSubsequence

doesNotContainSubsequence

doesNotContain

doesNotHaveDuplicates

startsWith

endsWith

endsWith

containsNull

doesNotContainNull

are

areNot

have

doNotHave

areAtLeast

areAtLeastOne

areAtMost

areExactly

haveAtLeastOne

haveAtLeast

haveAtMost

haveExactly

containsAll

hasOnlyElementsOfTypes

hasAtLeastOneElementOfType

hasOnlyElementsOfType

doesNotHaveAnyElementsOfTypes

containsExactlyElementsOf

containsOnlyElementsOf

hasSameElementsAs

doesNotContainAnyElementsOf

isSubsetOf

isSubsetOf

containsAnyOf

containsAnyElementsOf