Package org.assertj.core.api

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

Type Parameters:
SELF - the "self" type of this assertion class. Please read "Emulating 'self types' using Java Generics to simplify fluent API implementation" for more details.
ELEMENT - the type of elements of the "actual" value.
All Known Subinterfaces:
IndexedObjectEnumerableAssert<SELF,ELEMENT>, ObjectEnumerableAssert<SELF,ELEMENT>
All Known Implementing Classes:
AbstractArrayAssert, AbstractBooleanArrayAssert, AbstractByteArrayAssert, AbstractCharArrayAssert, AbstractCharSequenceAssert, AbstractCollectionAssert, AbstractDoubleArrayAssert, AbstractEnumerableAssert, AbstractFloatArrayAssert, AbstractIntArrayAssert, AbstractIterableAssert, AbstractListAssert, AbstractLongArrayAssert, AbstractMapAssert, AbstractObjectArrayAssert, AbstractShortArrayAssert, AbstractStringAssert, AtomicIntegerArrayAssert, AtomicLongArrayAssert, AtomicReferenceArrayAssert, BooleanArrayAssert, ByteArrayAssert, CharArrayAssert, CharSequenceAssert, ClassBasedNavigableIterableAssert, ClassBasedNavigableListAssert, CollectionAssert, DoubleArrayAssert, FactoryBasedNavigableIterableAssert, FactoryBasedNavigableListAssert, FloatArrayAssert, IntArrayAssert, IterableAssert, ListAssert, LongArrayAssert, MapAssert, ObjectArrayAssert, ShortArrayAssert, StringAssert
public interface EnumerableAssert<SELF extends EnumerableAssert<SELF,ELEMENT>,ELEMENT>
Assertions applicable to groups of values that can be enumerated (e.g. arrays, collections or strings.)
Author:
Yvonne Wang, Alex Ruiz, Mikhail Mazursky, Nicolas François

  • Method Summary

    Modifier and Type
    Method
    Description
    SELF
    hasSameSizeAs(Iterable<?> other)
    Verifies that the actual group has the same size as given Iterable.
    SELF
    hasSameSizeAs(Object array)
    Verifies that the actual group has the same size as given array.
    SELF
    hasSize(int expected)
    Verifies that the number of values in the actual group is equal to the given one.
    SELF
    hasSizeBetween(int lowerBoundary, int higherBoundary)
    Verifies that the number of values in the actual group is between the given boundaries (inclusive).
    SELF
    hasSizeGreaterThan(int boundary)
    Verifies that the number of values in the actual group is greater than the given boundary.
    SELF
    hasSizeGreaterThanOrEqualTo(int boundary)
    Verifies that the number of values in the actual group is greater than or equal to the given boundary.
    SELF
    hasSizeLessThan(int boundary)
    Verifies that the number of values in the actual group is less than the given boundary.
    SELF
    hasSizeLessThanOrEqualTo(int boundary)
    Verifies that the number of values in the actual group is less than or equal to the given boundary.
    void
    isEmpty()
    Verifies that the actual group of values is empty.
    SELF
    isNotEmpty()
    Verifies that the actual group of values is not empty.
    void
    isNullOrEmpty()
    Verifies that the actual group of values is null or empty.
    SELF
    usingDefaultElementComparator()
    Revert to standard comparison for incoming assertion group element checks.
    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.

  • Method Details

    • 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.

    • hasSizeGreaterThan

      SELF hasSizeGreaterThan(int boundary)
      Verifies that the number of values in the actual group is greater than the given boundary.

      Example: 

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

 // assertions will fail
 assertThat(Arrays.asList(1, 2, 3)).hasSizeGreaterThan(3);
 assertThat(new int[] { 1, 2, 3 }).hasSizeGreaterThan(6);
      Parameters:
      boundary - the given value to compare the actual size to.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the number of values of the actual group is not greater than the boundary.

    • hasSizeGreaterThanOrEqualTo

      SELF hasSizeGreaterThanOrEqualTo(int boundary)
      Verifies that the number of values in the actual group is greater than or equal to the given boundary.

      Example: 

       // assertions will pass
 assertThat(Arrays.asList(1, 2, 3)).hasSizeGreaterThanOrEqualTo(3);
 assertThat(Arrays.asList(1, 2)).hasSizeGreaterThanOrEqualTo(1);

 // assertions will fail
 assertThat(Arrays.asList(1, 2)).hasSizeGreaterThanOrEqualTo(3);
 assertThat(new int[] { 1, 2, 3 }).hasSizeGreaterThanOrEqualTo(4);
      Parameters:
      boundary - the given value to compare the actual size to.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the number of values of the actual group is not greater than or equal to the boundary.

    • hasSizeLessThan

      SELF hasSizeLessThan(int boundary)
      Verifies that the number of values in the actual group is less than the given boundary.

      Example: 

       // assertions will pass
 assertThat(new String[] { "a", "b" }).hasSizeLessThan(5);
 assertThat(Arrays.asList(1, 2, 3)).hasSizeLessThan(4);

 // assertions will fail
 assertThat(Arrays.asList(1, 2, 3)).hasSizeLessThan(3);
 assertThat(new int[] { 1, 2, 3 }).hasSizeLessThan(2);
      Parameters:
      boundary - the given value to compare the actual size to.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the number of values of the actual group is not less than the boundary.

    • hasSizeLessThanOrEqualTo

      SELF hasSizeLessThanOrEqualTo(int boundary)
      Verifies that the number of values in the actual group is less than or equal to the given boundary.

      Example: 

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

 // assertions will fail
 assertThat(Arrays.asList(1, 2, 3)).hasSizeLessThanOrEqualTo(2);
 assertThat(new int[] { 1, 2, 3 }).hasSizeLessThanOrEqualTo(1);
      Parameters:
      boundary - the given value to compare the actual size to.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the number of values of the actual group is not less than or equal to the boundary.

    • hasSizeBetween

      SELF hasSizeBetween(int lowerBoundary, int higherBoundary)
      Verifies that the number of values in the actual group is between the given boundaries (inclusive).

      Example: 

       // assertions will pass
 assertThat(new String[] { "a", "b" }).hasSizeBetween(0, 4);
 assertThat(Arrays.asList(1, 2, 3)).hasSizeBetween(2, 3)
                                   .hasSizeBetween(3, 4)
                                   .hasSizeBetween(3, 3);

 // assertions will fail
 assertThat(new ArrayList()).hasSizeBetween(1, 3);
 assertThat(new int[] { 1, 2, 3 }).hasSizeBetween(4, 6);
 assertThat(new int[] { 1, 2, 3, 4 }).hasSizeBetween(0, 2);
      Parameters:
      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.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the number of values of the actual group is not between the boundaries.

    • 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.