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

    • Method Detail

      • isNullOrEmpty

        void isNullOrEmpty()
        Verifies that the actual group of values is null or empty.

        Example:

         // assertions will pass
         List<String> strings = new ArrayList<>();
         assertThat(strings).isNullOrEmpty();
         assertThat(new int[] { }).isNullOrEmpty();
         
         // assertions will fail
         assertThat(new String[] { "a", "b"}).isNullOrEmpty();
         assertThat(Arrays.asList(1, 2, 3)).isNullOrEmpty();

        Throws:
        AssertionError - if the actual group of values is not null or not empty.
      • isEmpty

        void isEmpty()
        Verifies that the actual group of values is empty.

        Example:

         // assertions will pass
         assertThat(new ArrayList()).isEmpty();
         assertThat(new int[] { }).isEmpty();
         
         // assertions will fail
         assertThat(new String[] { "a", "b" }).isEmpty();
         assertThat(Arrays.asList(1, 2, 3)).isEmpty();

        Throws:
        AssertionError - if the actual group of values is not empty.
      • isNotEmpty

        SELF isNotEmpty()
        Verifies that the actual group of values is not empty.

        Example:

         // assertions will pass
         assertThat(new String[] { "a", "b" }).isNotEmpty();
         assertThat(Arrays.asList(1, 2, 3)).isNotEmpty();
         
         // assertions will fail
         assertThat(new ArrayList()).isNotEmpty();
         assertThat(new int[] { }).isNotEmpty();

        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual group of values is empty.
      • hasSize

        SELF hasSize​(int expected)
        Verifies that the number of values in the actual group is equal to the given one.

        Example:

         // assertions will pass
         assertThat(new String[] { "a", "b" }).hasSize(2);
         assertThat(Arrays.asList(1, 2, 3)).hasSize(3);
         
         // assertions will fail
         assertThat(new ArrayList()).hasSize(1);
         assertThat(new int[] { 1, 2, 3 }).hasSize(2);

        Parameters:
        expected - the expected number of values in the actual group.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the number of values of the actual group is not equal to the given one.
      • hasSameSizeAs

        SELF hasSameSizeAs​(Iterable<?> other)
        Verifies that the actual group has the same size as given Iterable.

        Example:

         Iterable<String> abc = newArrayList("a", "b", "c");
         Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya); 
         
         // assertion will pass
         assertThat(elvesRings).hasSameSizeAs(abc);
         
         // assertions will fail
         assertThat(elvesRings).hasSameSizeAs(Arrays.asList(1, 2));
         assertThat(elvesRings).hasSameSizeAs(Arrays.asList(1, 2, 3, 4));
        Parameters:
        other - the Iterable to compare size with actual group.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual group is null.
        AssertionError - if the other Iterable is null.
        AssertionError - if actual group and given Iterable don't have the same size.
      • hasSameSizeAs

        SELF hasSameSizeAs​(Object array)
        Verifies that the actual group has the same size as given array.

        Parameter is declared as Object to accept both Object[] and primitive arrays (e.g. int[]).

        Example:

         int[] oneTwoThree = {1, 2, 3};
         Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya); 
         
         // assertion will pass
         assertThat(elvesRings).hasSameSizeAs(oneTwoThree);
         
         // assertions will fail
         assertThat(elvesRings).hasSameSizeAs(new int[] { 1, 2});
         assertThat(elvesRings).hasSameSizeAs(new int[] { 1, 2, 3, 4});
        Parameters:
        array - the array to compare size with actual group.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual group is null.
        AssertionError - if the array parameter is null or is not a true array.
        AssertionError - if actual group and given array don't have the same size.
      • usingElementComparator

        SELF usingElementComparator​(Comparator<? super ELEMENT> customComparator)
        Use given custom comparator instead of relying on actual type A equals method to compare group elements for incoming assertion checks.

        Custom comparator is bound to assertion instance, meaning that if a new assertion is created, it will use default comparison strategy.

        Examples :

         // compares invoices by payee
         assertThat(invoiceList).usingComparator(invoicePayeeComparator).isEqualTo(expectedInvoiceList);
         
         // compares invoices by date, doesNotHaveDuplicates and contains both use the given invoice date comparator
         assertThat(invoiceList).usingComparator(invoiceDateComparator).doesNotHaveDuplicates().contains(may2010Invoice);
         
         // as assertThat(invoiceList) creates a new assertion, it falls back to standard comparison strategy 
         // based on Invoice's equal method to compare invoiceList elements to lowestInvoice.                                                      
         assertThat(invoiceList).contains(lowestInvoice);
         
         // standard comparison : the fellowshipOfTheRing includes Gandalf but not Sauron (believe me) ...
         assertThat(fellowshipOfTheRing).contains(gandalf)
                                        .doesNotContain(sauron);
         
         // ... but if we compare only races, Sauron is in fellowshipOfTheRing because he's a Maia like Gandalf.
         assertThat(fellowshipOfTheRing).usingElementComparator(raceComparator)
                                        .contains(sauron);
        Parameters:
        customComparator - the comparator to use for incoming assertion checks.
        Returns:
        this assertion object.
        Throws:
        NullPointerException - if the given comparator is null.
      • usingDefaultElementComparator

        SELF usingDefaultElementComparator()
        Revert to standard comparison for incoming assertion group element checks.

        This method should be used to disable a custom comparison strategy set by calling usingElementComparator(Comparator).

        Returns:
        this assertion object.