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

    • Method Summary

      All Methods Instance Methods Abstract Methods 
      Modifier and Type Method Description
      SELF allMatch​(java.util.function.Predicate<? super ELEMENT> predicate)
      Verifies that all the elements of actual match the given Predicate.
      SELF allMatch​(java.util.function.Predicate<? super ELEMENT> predicate, java.lang.String predicateDescription)
      Verifies that all the elements of actual match the given Predicate.
      SELF allSatisfy​(java.util.function.Consumer<? super ELEMENT> requirements)
      Verifies that all the elements satisfy given requirements expressed as a Consumer.
      SELF anySatisfy​(java.util.function.Consumer<? super ELEMENT> requirements)
      Verifies that at least one element satisfies the given requirements expressed as a Consumer.
      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​(java.lang.Iterable<? extends ELEMENT> iterable)
      Verifies that the actual group contains all the elements of given Iterable, in any order.
      SELF containsExactly​(ELEMENT... values)
      Verifies that the actual group contains only 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​(java.lang.Iterable<? extends ELEMENT> iterable)
      Same as containsExactly(Object...) but handle the Iterable to array conversion : verifies that actual contains all 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 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.
      SELF containsOnlyElementsOf​(java.lang.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.
      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​(java.lang.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​(java.lang.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​(java.lang.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​(java.lang.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​(java.lang.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 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 hasAtLeastOneElementOfType​(java.lang.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​(java.lang.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​(java.lang.Class<?>... types)
      Verifies that all elements of the actual group are instances of the given types.
      SELF hasSameElementsAs​(java.lang.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​(java.lang.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.
    • 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");
        Parameters:
        values - the given values.
        Returns:
        this assertion object.
        Throws:
        java.lang.NullPointerException - if the given argument is null.
        java.lang.IllegalArgumentException - if the given argument is an empty array.
        java.lang.AssertionError - if the actual group is null.
        java.lang.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.

        Example :

         Iterable<String> abc = newArrayList("a", "b", "c");
        
         // assertion will pass
         assertThat(abc).containsOnly("c", "b", "a");
         
         // assertion will fail because "c" is missing
         assertThat(abc).containsOnly("a", "b");
        Parameters:
        values - the given values.
        Returns:
        this assertion object.
        Throws:
        java.lang.NullPointerException - if the given argument is null.
        java.lang.IllegalArgumentException - if the given argument is an empty array.
        java.lang.AssertionError - if the actual group is null.
        java.lang.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.
      • 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:
        java.lang.NullPointerException - if the given argument is null.
        java.lang.IllegalArgumentException - if the given argument is an empty array.
        java.lang.AssertionError - if the actual group is null.
        java.lang.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 only 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);
        Parameters:
        values - the given values.
        Returns:
        this assertion object.
        Throws:
        java.lang.NullPointerException - if the given argument is null.
        java.lang.AssertionError - if the actual group is null.
        java.lang.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);
        Parameters:
        values - the given values.
        Returns:
        this assertion object.
        Throws:
        java.lang.NullPointerException - if the given argument is null.
        java.lang.AssertionError - if the actual group is null.
        java.lang.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.
      • 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);
        Parameters:
        sequence - the sequence of objects to look for.
        Returns:
        this assertion object.
        Throws:
        java.lang.AssertionError - if the actual group is null.
        java.lang.AssertionError - if the given array is null.
        java.lang.AssertionError - if the actual group does not contain the given sequence.
      • containsSequence

        SELF containsSequence​(java.lang.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));
        Parameters:
        sequence - the sequence of objects to look for.
        Returns:
        this assertion object.
        Throws:
        java.lang.AssertionError - if the actual group is null.
        java.lang.AssertionError - if the given array is null.
        java.lang.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);
        Parameters:
        sequence - the sequence of objects to look for.
        Returns:
        this assertion object.
        Throws:
        java.lang.AssertionError - if the actual group is null.
        java.lang.AssertionError - if the given array is null.
        java.lang.AssertionError - if the actual group contains the given sequence.
      • doesNotContainSequence

        SELF doesNotContainSequence​(java.lang.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));
        Parameters:
        sequence - the sequence of objects to look for.
        Returns:
        this assertion object.
        Throws:
        java.lang.AssertionError - if the actual group is null.
        java.lang.AssertionError - if the given array is null.
        java.lang.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);
        Parameters:
        sequence - the sequence of objects to look for.
        Returns:
        this assertion object.
        Throws:
        java.lang.AssertionError - if the actual group is null.
        java.lang.AssertionError - if the given array is null.
        java.lang.AssertionError - if the actual group does not contain the given subsequence.
      • containsSubsequence

        SELF containsSubsequence​(java.lang.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));
        Parameters:
        sequence - the sequence of objects to look for.
        Returns:
        this assertion object.
        Throws:
        java.lang.AssertionError - if the actual group is null.
        java.lang.AssertionError - if the given array is null.
        java.lang.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);
        Parameters:
        sequence - the sequence of objects to look for.
        Returns:
        this assertion object.
        Throws:
        java.lang.AssertionError - if the actual group is null.
        java.lang.AssertionError - if the given array is null.
        java.lang.AssertionError - if the actual group contains the given subsequence.
      • doesNotContainSubsequence

        SELF doesNotContainSubsequence​(java.lang.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));
        Parameters:
        sequence - the sequence of objects to look for.
        Returns:
        this assertion object.
        Throws:
        java.lang.AssertionError - if the actual group is null.
        java.lang.AssertionError - if the given array is null.
        java.lang.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");
        Parameters:
        values - the given values.
        Returns:
        this assertion object.
        Throws:
        java.lang.NullPointerException - if the given argument is null.
        java.lang.IllegalArgumentException - if the given argument is an empty array.
        java.lang.AssertionError - if the actual group is null.
        java.lang.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:
        java.lang.AssertionError - if the actual group is null.
        java.lang.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:
        java.lang.NullPointerException - if the given argument is null.
        java.lang.IllegalArgumentException - if the given argument is an empty array.
        java.lang.AssertionError - if the actual group is null.
        java.lang.AssertionError - if the actual group does not start 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("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:
        java.lang.NullPointerException - if the given argument is null.
        java.lang.IllegalArgumentException - if the given argument is an empty array.
        java.lang.AssertionError - if the actual group is null.
        java.lang.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:
        java.lang.AssertionError - if the actual group is null.
        java.lang.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:
        java.lang.AssertionError - if the actual group is null.
        java.lang.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<>(s -> s.length() == 1, "single character String");
        
         // assertion will pass
         assertThat(abc).are(singleCharacterString);
         
         // assertion will fail
         assertThat(abcc).are(singleCharacterString);
        Parameters:
        condition - the given condition.
        Returns:
        this object.
        Throws:
        java.lang.NullPointerException - if the given condition is null.
        java.lang.AssertionError - if an element cannot be cast to T.
        java.lang.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<>(s -> s.length() > 1, "more than one character");
        
         // assertion will pass
         assertThat(abc).areNot(moreThanOneCharacter);
         
         // assertion will fail
         assertThat(abcc).areNot(moreThanOneCharacter);
        Parameters:
        condition - the given condition.
        Returns:
        this object.
        Throws:
        java.lang.NullPointerException - if the given condition is null.
        java.lang.AssertionError - if an element cannot be cast to T.
        java.lang.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<>(s -> s.length() == 1, "only one character");
        
         // assertion will pass
         assertThat(abc).have(onlyOneCharacter);
         
         // assertion will fail
         assertThat(abcc).have(onlyOneCharacter);
        Parameters:
        condition - the given condition.
        Returns:
        this object.
        Throws:
        java.lang.NullPointerException - if the given condition is null.
        java.lang.AssertionError - if an element cannot be cast to T.
        java.lang.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<>(s -> s.length() > 1, "more than one character");
        
         // assertion will pass
         assertThat(abc).doNotHave(moreThanOneCharacter);
         
         // assertion will fail
         assertThat(abcc).doNotHave(moreThanOneCharacter);
        Parameters:
        condition - the given condition.
        Returns:
        this object.
        Throws:
        java.lang.NullPointerException - if the given condition is null.
        java.lang.AssertionError - if an element cannot be cast to T.
        java.lang.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<>(value % 2 == 1, "odd number");
        
         // 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:
        java.lang.NullPointerException - if the given condition is null.
        java.lang.AssertionError - if an element can not be cast to T.
        java.lang.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);
        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<>(value % 2 == 1, "odd number");
        
         // assertions will pass
         oneTwoThree.areAtMost(2, oddNumber)
                    .areAtMost(3, oddNumber);
         
         // assertion will fail
         oneTwoThree.areAtMost(1, oddNumber);
        Parameters:
        n - the number of times the condition should be at most verified.
        condition - the given condition.
        Returns:
        this object.
        Throws:
        java.lang.NullPointerException - if the given condition is null.
        java.lang.AssertionError - if an element cannot be cast to T.
        java.lang.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> oddNumber = new Condition<>(value % 2 == 1, "odd number");
        
         // assertion will pass
         oneTwoThree.areExactly(2, oddNumber);
         
         // assertions will fail
         oneTwoThree.areExactly(1, oddNumber);
         oneTwoThree.areExactly(3, oddNumber);
        Parameters:
        n - the exact number of times the condition should be verified.
        condition - the given condition.
        Returns:
        this object.
        Throws:
        java.lang.NullPointerException - if the given condition is null.
        java.lang.AssertionError - if an element cannot be cast to T.
        java.lang.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:

         Iterable<BasketBallPlayer> bullsPlayers = newArrayList(butler, rose);
         
         // potentialMvp is a Condition<BasketBallPlayer>
         assertThat(bullsPlayers).haveAtLeastOne(potentialMvp);
        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<>(value % 2 == 1, "odd number");
        
         // assertion will pass
         oneTwoThree.haveAtLeast(2, oddNumber);
         
         // assertion will fail
         oneTwoThree.haveAtLeast(3, oddNumber);
        This method is an alias for areAtLeast(int, Condition).
      • 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<>(value % 2 == 1, "odd number");
        
         // assertions will pass
         oneTwoThree.haveAtMost(2, oddNumber);
         oneTwoThree.haveAtMost(3, oddNumber);
         
         // assertion will fail
         oneTwoThree.haveAtMost(1, oddNumber);
        This method is an alias areAtMost(int, Condition).
      • 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<>(value % 2 == 1, "odd number");
        
         // 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).
      • containsAll

        SELF containsAll​(java.lang.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"));
        Parameters:
        iterable - the given Iterable we will get elements from.
        Returns:
        this assertion object.
        Throws:
        java.lang.NullPointerException - if the given argument is null.
        java.lang.AssertionError - if the actual group is null.
        java.lang.AssertionError - if the actual group does not contain all the elements of given Iterable.
      • hasOnlyElementsOfTypes

        SELF hasOnlyElementsOfTypes​(java.lang.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:
        java.lang.NullPointerException - if the given argument is null.
        java.lang.AssertionError - if the actual group is null.
        java.lang.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​(java.lang.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:
        java.lang.NullPointerException - if the given type is null.
        java.lang.AssertionError - if the actual Object group does not have any elements of the given type.
      • hasOnlyElementsOfType

        SELF hasOnlyElementsOfType​(java.lang.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:
        java.lang.NullPointerException - if the given type is null.
        java.lang.AssertionError - if one element is not of the expected type.
      • containsExactlyElementsOf

        SELF containsExactlyElementsOf​(java.lang.Iterable<? extends ELEMENT> iterable)
        Same as containsExactly(Object...) but handle the Iterable to array conversion : verifies that actual contains all 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));
        Parameters:
        iterable - the given Iterable we will get elements from.
      • containsOnlyElementsOf

        SELF containsOnlyElementsOf​(java.lang.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.

        Example :

         Iterable<Ring> rings = newArrayList(nenya, vilya);
         
         // assertion will pass
         assertThat(rings).containsOnlyElementsOf(newLinkedList(nenya, vilya))
                          .containsOnlyElementsOf(newLinkedList(nenya, nenya, vilya, vilya));
         
         // 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));
        Parameters:
        iterable - the given Iterable we will get elements from.
      • hasSameElementsAs

        SELF hasSameElementsAs​(java.lang.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:
        java.lang.AssertionError - if the actual group is null
        java.lang.NullPointerException - if the given Iterable is null
        java.lang.AssertionError - if the actual Iterable does not have the same elements, in any order, as the given Iterable
      • doesNotContainAnyElementsOf

        SELF doesNotContainAnyElementsOf​(java.lang.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"));
        Parameters:
        iterable - the Iterable whose elements must not be in the actual group.
        Returns:
        this assertion object.
        Throws:
        java.lang.NullPointerException - if the given argument is null.
        java.lang.IllegalArgumentException - if the given argument is an empty iterable.
        java.lang.AssertionError - if the actual group is null.
        java.lang.AssertionError - if the actual group contains some elements of the given Iterable.
      • isSubsetOf

        SELF isSubsetOf​(java.lang.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));
        Parameters:
        values - the Iterable that should contain all actual elements.
        Returns:
        this assertion object.
        Throws:
        java.lang.AssertionError - if the actual Iterable is null.
        java.lang.NullPointerException - if the given Iterable is null.
        java.lang.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);
        Parameters:
        values - the values that should be used for checking the elements of actual.
        Returns:
        this assertion object.
        Throws:
        java.lang.AssertionError - if the actual Iterable is null.
        java.lang.AssertionError - if the actual Iterable is not subset of the given values.
      • allMatch

        SELF allMatch​(java.util.function.Predicate<? super ELEMENT> predicate)
        Verifies that all the elements of actual match the given Predicate.

        Example :

         Iterable<String> abc  = newArrayList("a", "b", "c");
         Iterable<String> abcc = newArrayList("a", "b", "cc");
        
         // assertion will pass
         assertThat(abc).allMatch(s -> s.length() == 1);
         
         // assertion will fail
         assertThat(abcc).allMatch(s -> s.length() == 1);
        Note that you can achieve the same result with are(Condition) or have(Condition).
        Parameters:
        predicate - the given Predicate.
        Returns:
        this object.
        Throws:
        java.lang.NullPointerException - if the given predicate is null.
        java.lang.AssertionError - if an element cannot be cast to T.
        java.lang.AssertionError - if one or more elements don't satisfy the given predicate.
      • allMatch

        SELF allMatch​(java.util.function.Predicate<? super ELEMENT> predicate,
                      java.lang.String predicateDescription)
        Verifies that all the elements of actual match the given Predicate. The predicate description is used to get an informative error message.

        Example :

         Iterable<String> abc  = newArrayList("a", "b", "c");
         Iterable<String> abcc = newArrayList("a", "b", "cc");
        
         // assertion will pass
         assertThat(abc).allMatch(s -> s.length() == 1, "length of 1");
        
         // assertion will fail
         assertThat(abcc).allMatch(s -> s.length() == 1, "length of 1");
        The message of the failed assertion would be:
        Expecting all elements of:
          <["a", "b", "cc"]>
          to match 'length of 1' predicate but this element did not:
          <"cc">
        Parameters:
        predicate - the given Predicate.
        predicateDescription - a description of the Predicate used in the error message
        Returns:
        this object.
        Throws:
        java.lang.NullPointerException - if the given predicate is null.
        java.lang.AssertionError - if an element cannot be cast to T.
        java.lang.AssertionError - if one or more elements don't satisfy the given predicate.
        Since:
        3.6.0
      • allSatisfy

        SELF allSatisfy​(java.util.function.Consumer<? super ELEMENT> requirements)
        Verifies that all the elements satisfy given requirements expressed as a Consumer.

        This is useful to perform a group of assertions on elements.

        Example:

         assertThat(myIcelanderFriends).allSatisfy(person -> {
                                         assertThat(person.getCountry()).isEqualTo("Iceland");
                                         assertThat(person.getPhoneCountryCode()).isEqualTo("+354");
                                       });
        Parameters:
        requirements - the given Consumer.
        Returns:
        this object.
        Throws:
        java.lang.NullPointerException - if the given Consumer is null.
        java.lang.AssertionError - if one or more elements don't satisfy given requirements.
        Since:
        3.6.0
      • anySatisfy

        SELF anySatisfy​(java.util.function.Consumer<? super ELEMENT> requirements)
        Verifies that at least one element satisfies the given requirements expressed as a Consumer.

        This is useful to check that a group of assertions is verified by (at least) one element.

        If the group of elements to assert is empty, the assertion will fail.

        Example:

         // assume that one icelander in myIcelanderFriends has a name finishing by 'son'  
         assertThat(myIcelanderFriends).anySatisfy(person -> {
                                         assertThat(person.getCountry()).isEqualTo("Iceland");
                                         assertThat(person.getSurname()).endsWith("son");
                                       });
                                       
         // assertion fails for empty group, whatever the requirements are.  
         assertThat(emptyGroup).anySatisfy($ -> assertThat(true).isTrue());
        Parameters:
        requirements - the given Consumer.
        Returns:
        this object.
        Throws:
        java.lang.NullPointerException - if the given Consumer is null.
        java.lang.AssertionError - none elements satisfy the given requirements.
        Since:
        3.7.0