Package org.assertj.core.internal

Class Iterables

  • public class Iterables
extends Object
    Reusable assertions for Iterables.
    Author:
    Alex Ruiz, Yvonne Wang, Maciej Jaskowski, Nicolas François, Joel Costigliola, Florent Biville

    • Constructor Detail

      • Iterables

        Iterables()

    • Method Detail

      • getComparator

        public Comparator<?> getComparator()

      • assertNullOrEmpty

        public void assertNullOrEmpty​(AssertionInfo info,
                              Iterable<?> actual)
        Asserts that the given Iterable is null or empty.
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        Throws:
        AssertionError - if the given Iterable is not null *and* contains one or more elements.

      • assertEmpty

        public void assertEmpty​(AssertionInfo info,
                        Iterable<?> actual)
        Asserts that the given Iterable is empty.
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        Throws:
        AssertionError - if the given Iterable is null.
        AssertionError - if the given Iterable is not empty.

      • assertNotEmpty

        public void assertNotEmpty​(AssertionInfo info,
                           Iterable<?> actual)
        Asserts that the given Iterable is not empty.
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        Throws:
        AssertionError - if the given Iterable is null.
        AssertionError - if the given Iterable is empty.

      • assertHasSize

        public void assertHasSize​(AssertionInfo info,
                          Iterable<?> actual,
                          int expectedSize)
        Asserts that the number of elements in the given Iterable is equal to the expected one.
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        expectedSize - the expected size of actual.
        Throws:
        AssertionError - if the given Iterable is null.
        AssertionError - if the number of elements in the given Iterable is different than the expected one.

      • assertHasOnlyOneElementSatisfying

        public <T> void assertHasOnlyOneElementSatisfying​(AssertionInfo info,
                                                  Iterable<? extends T> actual,
                                                  Consumer<? super T> consumer)
        Asserts that the unique element of the Iterable satisfies the given assertions expressed as a Consumer,
        Type Parameters:
        T - the type of elements in actual.
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        consumer - the given requirements.
        Throws:
        AssertionError - if the Iterable does not have a unique element.
        AssertionError - if the Iterable's unique element does not satisfies the given assertions.

      • assertHasSizeGreaterThan

        public void assertHasSizeGreaterThan​(AssertionInfo info,
                                     Iterable<?> actual,
                                     int boundary)
        Asserts that the number of elements in the given Iterable is greater than the boundary.
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        boundary - the given value to compare the size of actual to.
        Throws:
        AssertionError - if the given Iterable is null.
        AssertionError - if the number of elements in the given Iterable is greater than the boundary.

      • assertHasSizeGreaterThanOrEqualTo

        public void assertHasSizeGreaterThanOrEqualTo​(AssertionInfo info,
                                              Iterable<?> actual,
                                              int boundary)
        Asserts that the number of elements in the given Iterable is greater than or equal to the boundary.
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        boundary - the given value to compare the size of actual to.
        Throws:
        AssertionError - if the given Iterable is null.
        AssertionError - if the number of elements in the given Iterable is greater than or equal to the boundary.

      • assertHasSizeLessThan

        public void assertHasSizeLessThan​(AssertionInfo info,
                                  Iterable<?> actual,
                                  int boundary)
        Asserts that the number of elements in the given Iterable is less than the boundary.
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        boundary - the given value to compare the size of actual to.
        Throws:
        AssertionError - if the given Iterable is null.
        AssertionError - if the number of elements in the given Iterable is less than the expected one.

      • assertHasSizeLessThanOrEqualTo

        public void assertHasSizeLessThanOrEqualTo​(AssertionInfo info,
                                           Iterable<?> actual,
                                           int boundary)
        Asserts that the number of elements in the given Iterable is less than or equal to the boundary.
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        boundary - the given value to compare the size of actual to.
        Throws:
        AssertionError - if the given Iterable is null.
        AssertionError - if the number of elements in the given Iterable is less than or equal to the boundary.

      • assertHasSizeBetween

        public void assertHasSizeBetween​(AssertionInfo info,
                                 Iterable<?> actual,
                                 int lowerBoundary,
                                 int higherBoundary)
        Asserts that the number of elements in the given Iterable is between the given lower and higher boundary (inclusive).
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        lowerBoundary - the lower boundary compared to which actual size should be greater than or equal to.
        higherBoundary - the higher boundary compared to which actual size should be less than or equal to.
        Throws:
        AssertionError - if the given array is null.
        AssertionError - if the number of elements in the given array is not between the boundaries.

      • assertHasSameSizeAs

        public void assertHasSameSizeAs​(AssertionInfo info,
                                Iterable<?> actual,
                                Object other)
        Assert that the actual Iterable has the same size as the other array.
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        other - the given array to compare.
        Throws:
        AssertionError - if the actual group is null.
        AssertionError - if the other group is null.
        AssertionError - if actual Iterable and other array don't have the same size.

      • assertHasSameSizeAs

        public void assertHasSameSizeAs​(AssertionInfo info,
                                Iterable<?> actual,
                                Iterable<?> other)
        Assert that the actual Iterable has the same size as the other Iterable.
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        other - the given Iterable.
        Throws:
        AssertionError - if the actual group is null.
        AssertionError - if the other group is null.
        AssertionError - if actual and other Iterable don't have the same size.

      • assertContains

        public void assertContains​(AssertionInfo info,
                           Iterable<?> actual,
                           Object[] values)
        Asserts that the given Iterable contains the given values, in any order.
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        values - the values that are expected to be in the given Iterable.
        Throws:
        NullPointerException - if the array of values is null.
        IllegalArgumentException - if the array of values is empty.
        AssertionError - if the given Iterable is null.
        AssertionError - if the given Iterable does not contain the given values.

      • assertIterableContainsGivenValues

        private void assertIterableContainsGivenValues​(Iterable<?> actual,
                                               Object[] values,
                                               AssertionInfo info)

      • iterableContains

        private boolean iterableContains​(Iterable<?> actual,
                                 Object value)

      • iterablesRemoveFirst

        private void iterablesRemoveFirst​(Iterable<?> actual,
                                  Object value)

      • iterablesRemove

        private void iterablesRemove​(Iterable<?> actual,
                             Object value)

      • assertContainsOnly

        public void assertContainsOnly​(AssertionInfo info,
                               Iterable<?> actual,
                               Object[] expectedValues)
        Asserts that the given Iterable contains only the given values and nothing else, in any order.
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        expectedValues - the values that are expected to be in the given Iterable.
        Throws:
        NullPointerException - if the array of values is null.
        IllegalArgumentException - if the array of values is empty.
        AssertionError - if the given Iterable is null.
        AssertionError - if the given Iterable does not contain the given values or if the given Iterable contains values that are not in the given array.

      • assertContainsOnlyOnce

        public void assertContainsOnlyOnce​(AssertionInfo info,
                                   Iterable<?> actual,
                                   Object[] values)
        Asserts that the given Iterable contains the given values and only once.
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        values - the values that are expected to be in the given Iterable.
        Throws:
        NullPointerException - if the array of values is null.
        IllegalArgumentException - if the array of values is empty.
        AssertionError - if the given Iterable is null.
        AssertionError - if the given Iterable does not contain the given values or if the given Iterable contains values that are not in the given array.

      • assertContainsOnlyNulls

        public void assertContainsOnlyNulls​(AssertionInfo info,
                                    Iterable<?> actual)
        Asserts that the given Iterable contains only null elements and nothing else.
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        Throws:
        AssertionError - if the given Iterable is null.
        AssertionError - if the given Iterable does not contain at least a null element or if the given Iterable contains values that are not null elements.

      • assertContainsSequence

        public void assertContainsSequence​(AssertionInfo info,
                                   Iterable<?> actual,
                                   Object[] sequence)
        Verifies that the given Iterable contains the given sequence of objects, without any other objects between them.
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        sequence - the sequence of objects to look for.
        Throws:
        AssertionError - if the given Iterable is null.
        NullPointerException - if the given sequence is null.
        IllegalArgumentException - if the given sequence is empty.
        AssertionError - if the given Iterable does not contain the given sequence of objects.

      • assertDoesNotContainSequence

        public void assertDoesNotContainSequence​(AssertionInfo info,
                                         Iterable<?> actual,
                                         Object[] sequence)
        Verifies that the given Iterable does not contain the given sequence of objects in order.
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        sequence - the sequence of objects to look for.
        Throws:
        AssertionError - if the given Iterable is null.
        NullPointerException - if the given sequence is null.
        IllegalArgumentException - if the given sequence is empty.
        AssertionError - if the given Iterable does contain the given sequence of objects.

      • assertContainsSubsequence

        public void assertContainsSubsequence​(AssertionInfo info,
                                      Iterable<?> actual,
                                      Object[] subsequence)
        Verifies that the given Iterable contains the given subsequence of objects (possibly with other values between them).
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        subsequence - the subsequence of objects to look for.
        Throws:
        AssertionError - if the given Iterable is null.
        NullPointerException - if the given sequence is null.
        IllegalArgumentException - if the given subsequence is empty.
        AssertionError - if the given Iterable does not contain the given subsequence of objects.

      • assertContainsSubsequence

        public void assertContainsSubsequence​(AssertionInfo info,
                                      Iterable<?> actual,
                                      List<?> subsequence)

      • assertDoesNotContainSubsequence

        public void assertDoesNotContainSubsequence​(AssertionInfo info,
                                            Iterable<?> actual,
                                            Object[] subsequence)
        Verifies that the given Iterable does not contain the given subsequence of objects (possibly with other values between them).
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        subsequence - the subsequence of objects to look for.
        Throws:
        AssertionError - if the given Iterable is null.
        NullPointerException - if the given sequence is null.
        IllegalArgumentException - if the given subsequence is empty.
        AssertionError - if the given Iterable contains the given subsequence of objects.

      • assertIsSubsetOf

        public void assertIsSubsetOf​(AssertionInfo info,
                             Iterable<?> actual,
                             Iterable<?> values)
        Verifies that the actual Iterable is a subset of values Iterable.
        Both actual and given iterable are treated as sets, therefore duplicates on either of them are ignored.
        Parameters:
        info - contains information about the assertion.
        actual - the actual Iterable.
        values - the Iterable that should contain all actual elements.
        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

      • containsSequenceAtGivenIndex

        private boolean containsSequenceAtGivenIndex​(List<?> actualAsList,
                                             Object[] sequence,
                                             int startingIndex)
        Return true if actualAsList contains exactly the given sequence at given starting index, false otherwise.
        Parameters:
        actualAsList - the list to look sequence in
        sequence - the sequence to look for
        startingIndex - the index of actual list at which we start looking for sequence.
        Returns:
        true if actualAsList contains exactly the given sequence at given starting index, false otherwise.

      • areEqual

        private boolean areEqual​(Object actual,
                         Object other)

      • assertDoesNotContain

        public void assertDoesNotContain​(AssertionInfo info,
                                 Iterable<?> actual,
                                 Object[] values)
        Asserts that the given Iterable does not contain the given values.
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        values - the values that are expected not to be in the given Iterable.
        Throws:
        NullPointerException - if the array of values is null.
        IllegalArgumentException - if the array of values is empty.
        AssertionError - if the given Iterable is null.
        AssertionError - if the given Iterable contains any of given values.

      • assertDoesNotContainAnyElementsOf

        public <T> void assertDoesNotContainAnyElementsOf​(AssertionInfo info,
                                                  Iterable<? extends T> actual,
                                                  Iterable<? extends T> iterable)
        Asserts that the given Iterable does not contain the given values.
        Type Parameters:
        T - the type of actual elements
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        iterable - the values that are expected not to be in the given Iterable.
        Throws:
        NullPointerException - if the array of values is null.
        IllegalArgumentException - if the array of values is empty.
        AssertionError - if the given Iterable is null.
        AssertionError - if the given Iterable contains any of given values.

      • assertDoesNotHaveDuplicates

        public void assertDoesNotHaveDuplicates​(AssertionInfo info,
                                        Iterable<?> actual)
        Asserts that the given Iterable does not have duplicate values.
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        Throws:
        NullPointerException - if the array of values is null.
        IllegalArgumentException - if the array of values is empty.
        AssertionError - if the given Iterable is null.
        AssertionError - if the given Iterable contains duplicate values.

      • assertStartsWith

        public void assertStartsWith​(AssertionInfo info,
                             Iterable<?> actual,
                             Object[] sequence)
        Verifies that the given Iterable starts with the given sequence of objects, without any other objects between them. Similar to assertContainsSequence(AssertionInfo, Iterable, Object[]), but it also verifies that the first element in the sequence is also the first element of the given Iterable.
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        sequence - the sequence of objects to look for.
        Throws:
        NullPointerException - if the given argument is null.
        IllegalArgumentException - if the given argument is an empty array.
        AssertionError - if the given Iterable is null.
        AssertionError - if the given Iterable does not start with the given sequence of objects.

      • assertEndsWith

        public void assertEndsWith​(AssertionInfo info,
                           Iterable<?> actual,
                           Object first,
                           Object[] rest)
        Verifies that the given Iterable ends with the given sequence of objects, without any other objects between them. Similar to assertContainsSequence(AssertionInfo, Iterable, Object[]), but it also verifies that the last element in the sequence is also the last element of the given Iterable.
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        first - the first element of the end sequence.
        rest - the optional next elements of the end sequence.
        Throws:
        NullPointerException - if the given argument is null.
        IllegalArgumentException - if the given argument is an empty array.
        AssertionError - if the given Iterable is null.
        AssertionError - if the given Iterable does not end with the given sequence of objects.

      • assertEndsWith

        public void assertEndsWith​(AssertionInfo info,
                           Iterable<?> actual,
                           Object[] sequence)
        Verifies that the given Iterable ends with the given sequence of objects, without any other objects between them. Similar to assertContainsSequence(AssertionInfo, Iterable, Object[]), but it also verifies that the last element in the sequence is also the last element of the given Iterable.
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        sequence - the sequence of objects to look for.
        Throws:
        NullPointerException - if the given argument is null.
        IllegalArgumentException - if the given argument is an empty array.
        AssertionError - if the given Iterable is null.
        AssertionError - if the given Iterable does not end with the given sequence of objects.

      • commonCheckThatIterableAssertionSucceeds

        private boolean commonCheckThatIterableAssertionSucceeds​(AssertionInfo info,
                                                         Iterable<?> actual,
                                                         Object[] sequence)

      • assertContainsNull

        public void assertContainsNull​(AssertionInfo info,
                               Iterable<?> actual)
        Asserts that the given Iterable contains at least a null element.
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        Throws:
        AssertionError - if the given Iterable is null.
        AssertionError - if the given Iterable does not contain at least a null element.

      • assertDoesNotContainNull

        public void assertDoesNotContainNull​(AssertionInfo info,
                                     Iterable<?> actual)
        Asserts that the given Iterable does not contain null elements.
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        Throws:
        AssertionError - if the given Iterable is null.
        AssertionError - if the given Iterable contains a null element.

      • assertAre

        public <T> void assertAre​(AssertionInfo info,
                          Iterable<? extends T> actual,
                          Condition<? super T> condition)
        Assert that each element of given Iterable satisfies the given condition.
        Type Parameters:
        T - the type of actual elements
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        condition - the given Condition.
        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.

      • assertAreNot

        public <E> void assertAreNot​(AssertionInfo info,
                             Iterable<? extends E> actual,
                             Condition<? super E> condition)
        Assert that each element of given Iterable not satisfies the given condition.
        Type Parameters:
        E - the type of actual elements
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        condition - the given Condition.
        Throws:
        NullPointerException - if the given condition is null.
        AssertionError - if an element cannot be cast to E.
        AssertionError - if one or more elements satisfy the given condition.

      • assertHave

        public <E> void assertHave​(AssertionInfo info,
                           Iterable<? extends E> actual,
                           Condition<? super E> condition)
        Assert that each element of given Iterable satisfies the given condition.
        Type Parameters:
        E - the type of actual elements
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        condition - the given Condition.
        Throws:
        NullPointerException - if the given condition is null.
        AssertionError - if an element cannot be cast to E.
        AssertionError - if one or more elements do not satisfy the given condition.

      • assertDoNotHave

        public <E> void assertDoNotHave​(AssertionInfo info,
                                Iterable<? extends E> actual,
                                Condition<? super E> condition)
        Assert that each element of given Iterable not satisfies the given condition.
        Type Parameters:
        E - the type of actual elements
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        condition - the given Condition.
        Throws:
        NullPointerException - if the given condition is null.
        AssertionError - if an element cannot be cast to E.
        AssertionError - if one or more elements satisfy the given condition.

      • assertAreAtLeast

        public <E> void assertAreAtLeast​(AssertionInfo info,
                                 Iterable<? extends E> actual,
                                 int times,
                                 Condition<? super E> condition)
        Assert that there are at least n elements in the actual Iterable satisfying the given condition.
        Type Parameters:
        E - the type of actual elements
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        times - the minimum number of times the condition should be verified.
        condition - the given Condition.
        Throws:
        NullPointerException - if the given condition is null.
        AssertionError - if an element cannot be cast to E.
        AssertionError - if the number of elements satisfying the given condition is < n.

      • conditionIsSatisfiedAtLeastNTimes

        private <E> boolean conditionIsSatisfiedAtLeastNTimes​(Iterable<? extends E> actual,
                                                      int n,
                                                      Condition<? super E> condition)

      • assertAreAtMost

        public <E> void assertAreAtMost​(AssertionInfo info,
                                Iterable<? extends E> actual,
                                int n,
                                Condition<? super E> condition)
        Assert that there are at most n elements in the actual Iterable satisfying the given condition.
        Type Parameters:
        E - the type of actual elements
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        n - the number of times the condition should be at most verified.
        condition - the given Condition.
        Throws:
        NullPointerException - if the given condition is null.
        AssertionError - if an element cannot be cast to E.
        AssertionError - if the number of elements satisfying the given condition is > n.

      • conditionIsSatisfiedAtMostNTimes

        private <E> boolean conditionIsSatisfiedAtMostNTimes​(Iterable<? extends E> actual,
                                                     Condition<? super E> condition,
                                                     int n)

      • assertAreExactly

        public <E> void assertAreExactly​(AssertionInfo info,
                                 Iterable<? extends E> actual,
                                 int times,
                                 Condition<? super E> condition)
        Verifies that there are exactly n elements in the actual Iterable satisfying the given condition.
        Type Parameters:
        E - the type of actual elements
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        times - the exact number of times the condition should be verified.
        condition - the given Condition.
        Throws:
        NullPointerException - if the given condition is null.
        AssertionError - if an element cannot be cast to E.
        AssertionError - if the number of elements satisfying the given condition is ≠ n.

      • conditionIsSatisfiedNTimes

        private <E> boolean conditionIsSatisfiedNTimes​(Iterable<? extends E> actual,
                                               Condition<? super E> condition,
                                               int times)

      • assertHaveAtLeast

        public <E> void assertHaveAtLeast​(AssertionInfo info,
                                  Iterable<? extends E> actual,
                                  int times,
                                  Condition<? super E> condition)
        An alias method of assertAreAtLeast(AssertionInfo, Iterable, int, Condition) to provide a richer fluent api (same logic, only error message differs).
        Type Parameters:
        E - the type of actual elements
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        times - the minimum number of times the condition should be verified.
        condition - the given Condition.
        Throws:
        NullPointerException - if the given condition is null.
        AssertionError - if an element cannot be cast to E.
        AssertionError - if the number of elements satisfying the given condition is < n.

      • assertHaveAtMost

        public <E> void assertHaveAtMost​(AssertionInfo info,
                                 Iterable<? extends E> actual,
                                 int times,
                                 Condition<? super E> condition)
        An alias method of assertAreAtMost(AssertionInfo, Iterable, int, Condition) to provide a richer fluent api (same logic, only error message differs).
        Type Parameters:
        E - the type of actual elements
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        times - the number of times the condition should be at most verified.
        condition - the given Condition.
        Throws:
        NullPointerException - if the given condition is null.
        AssertionError - if an element cannot be cast to E.
        AssertionError - if the number of elements satisfying the given condition is > n.

      • assertHaveExactly

        public <E> void assertHaveExactly​(AssertionInfo info,
                                  Iterable<? extends E> actual,
                                  int times,
                                  Condition<? super E> condition)
        An alias method of assertAreExactly(AssertionInfo, Iterable, int, Condition) to provide a richer fluent api (same logic, only error message differs).
        Type Parameters:
        E - the type of actual elements
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        times - the exact number of times the condition should be verified.
        condition - the given Condition.
        Throws:
        NullPointerException - if the given condition is null.
        AssertionError - if an element cannot be cast to E.
        AssertionError - if the number of elements satisfying the given condition is ≠ n.

      • assertContainsAll

        public void assertContainsAll​(AssertionInfo info,
                              Iterable<?> actual,
                              Iterable<?> other)
        Asserts that the given Iterable contains all the elements of the other Iterable, in any order.
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        other - the other Iterable.
        Throws:
        NullPointerException - if Iterable is null.
        AssertionError - if the given Iterable is null.
        AssertionError - if the given Iterable does not contain all the elements of the other Iterable, in any order.

      • assertContainsExactly

        public void assertContainsExactly​(AssertionInfo info,
                                  Iterable<?> actual,
                                  Object[] values)
        Asserts that the given Iterable contains exactly the given values and nothing else, in order.
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        values - the values that are expected to be in the given Iterable in order.
        Throws:
        NullPointerException - if the array of values is null.
        AssertionError - if the given Iterable is null.
        AssertionError - if the given Iterable does not contain the given values or if the given Iterable contains values that are not in the given array, in order.

      • assertZipSatisfy

        public <ACTUAL_ELEMENT,​OTHER_ELEMENT> void assertZipSatisfy​(AssertionInfo info,
                                                                  Iterable<? extends ACTUAL_ELEMENT> actual,
                                                                  Iterable<OTHER_ELEMENT> other,
                                                                  BiConsumer<? super ACTUAL_ELEMENT,​OTHER_ELEMENT> zipRequirements)

      • assertNoneSatisfy

        public <E> void assertNoneSatisfy​(AssertionInfo info,
                                  Iterable<? extends E> actual,
                                  Consumer<? super E> restrictions)

      • failsRestrictions

        private <E> Optional<E> failsRestrictions​(E element,
                                          Consumer<? super E> restrictions)

      • assertContainsAnyOf

        public void assertContainsAnyOf​(AssertionInfo info,
                                Iterable<?> actual,
                                Object[] values)
        Asserts that the given Iterable contains at least one of the given values.
        Parameters:
        info - contains information about the assertion.
        actual - the given Iterable.
        values - the values that, at least one of which is expected to be in the given Iterable.
        Throws:
        NullPointerException - if the array of values is null.
        IllegalArgumentException - if the array of values is empty and given Iterable is not empty.
        AssertionError - if the given Iterable is null.
        AssertionError - if the given Iterable does not contain any of given values.

      • assertContainsExactlyInAnyOrder

        public void assertContainsExactlyInAnyOrder​(AssertionInfo info,
                                            Iterable<?> actual,
                                            Object[] values)

      • notSatisfyingCondition

        private <E> List<E> notSatisfyingCondition​(Iterable<? extends E> actual,
                                           Condition<? super E> condition)

      • satisfiesCondition

        private <E> List<E> satisfiesCondition​(Iterable<? extends E> actual,
                                       Condition<? super E> condition)

      • byPassingAssertions

        public static <T> Predicate<T> byPassingAssertions​(Consumer<? super T> assertions)

      • checkIsNotEmptySequence

        private static void checkIsNotEmptySequence​(Object[] sequence)

      • checkIsNotEmptySubsequence

        private static void checkIsNotEmptySubsequence​(Object[] subsequence)