Class AbstractIterableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>,T>

Method Details

• isNullOrEmpty

  public void isNullOrEmpty()

  Verifies that the actual group of values is null or empty.

  Specified by:

  isNullOrEmpty in interface EnumerableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>>

• isEmpty

  public void isEmpty()

  Verifies that the actual group of values is empty.

  Specified by:

  isEmpty in interface EnumerableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>>

• isNotEmpty

  public S isNotEmpty()

  Verifies that the actual group of values is not empty.

  Specified by:

  isNotEmpty in interface EnumerableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>>

  Returns:

  this assertion object.

• hasSize

  public S hasSize(int expected)

  Verifies that the number of values in the actual group is equal to the given one.

  Specified by:

  hasSize in interface EnumerableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>>

  Parameters:

  expected - the expected number of values in the actual group.

  Returns:

  this assertion object.

• hasSameSizeAs

  public S hasSameSizeAs(Object[] other)

  Verifies that the actual group has the same size as given array.

  Specified by:

  hasSameSizeAs in interface EnumerableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>>

  Parameters:

  other - the array to compare size with actual group.

  Returns:

  this assertion object.

• hasSameSizeAs

  public S hasSameSizeAs(Iterable<?> other)

  Verifies that the actual group has the same size as given Iterable.

  Specified by:

  hasSameSizeAs in interface EnumerableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>>

  Parameters:

  other - the Iterable to compare size with actual group.

  Returns:

  this assertion object.

• contains

  public S contains(T... values)

  Verifies that the actual group contains the given values, in any order.

  Specified by:

  contains in interface ObjectEnumerableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>>

  Parameters:

  values - the given values.

  Returns:

  this assertion object.

• containsOnly

  public S containsOnly(T... values)

  Verifies that the actual group contains only the given values and nothing else, in any order.

  Specified by:

  containsOnly in interface ObjectEnumerableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>>

  Parameters:

  values - the given values.

  Returns:

  this assertion object.

• containsExactly

  public S containsExactly(T... values)

  Verifies that the actual group contains only the given values and nothing else, in order.
  This assertion should only be used with Iterable that have a consistent iteration order (i.e. don't use it with HashSet, prefer ObjectEnumerableAssert.containsOnly(Object...) in that case).

  Example :

   Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya);
   
   // assertion will pass
   assertThat(elvesRings).containsExactly(vilya, nenya, narya);
   
   // assertion will fail as actual and expected orders differ.
   assertThat(elvesRings).containsExactly(nenya, vilya, narya);
   

  Specified by:

  containsExactly in interface ObjectEnumerableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>>

  Parameters:

  values - the given values.

  Returns:

  this assertion object.

• isSubsetOf

  public S isSubsetOf(Iterable<? extends T> values)

  Verifies that all the elements of the actual Iterable are present in the given Iterable.

  Parameters:

  values - the Iterable that should contain all actual elements.

  Returns:

  this assertion object.

  Throws:

  AssertionError - if the actual Iterable is null.

  NullPointerException - if the given Iterable is null.

  AssertionError - if the actual Iterable is not subset of set Iterable.

• containsSequence

  public S containsSequence(T... sequence)

  Verifies that the actual group contains the given sequence, without any other values between them.

  Specified by:

  containsSequence in interface ObjectEnumerableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>>

  Parameters:

  sequence - the sequence of objects to look for.

  Returns:

  this assertion object.

• doesNotContain

  public S doesNotContain(T... values)

  Verifies that the actual group does not contain the given values.

  Specified by:

  doesNotContain in interface ObjectEnumerableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>>

  Parameters:

  values - the given values.

  Returns:

  this assertion object.

• doesNotHaveDuplicates

  public S doesNotHaveDuplicates()

  Verifies that the actual group does not contain duplicates.

  Specified by:

  doesNotHaveDuplicates in interface ObjectEnumerableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>>

  Returns:

  this assertion object.

• startsWith

  public S startsWith(T... sequence)

  Verifies that the actual group starts with the given sequence of objects, without any other objects between them. Similar to ObjectEnumerableAssert.containsSequence(Object...), but it also verifies that the first element in the sequence is also first element of the actual group.

  Specified by:

  startsWith in interface ObjectEnumerableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>>

  Parameters:

  sequence - the sequence of objects to look for.

  Returns:

  this assertion object.

• endsWith

  public S endsWith(T... sequence)

  Verifies that the actual group ends with the given sequence of objects, without any other objects between them. Similar to ObjectEnumerableAssert.containsSequence(Object...), but it also verifies that the last element in the sequence is also last element of the actual group.

  Specified by:

  endsWith in interface ObjectEnumerableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>>

  Parameters:

  sequence - the sequence of objects to look for.

  Returns:

  this assertion object.

• containsNull

  public S containsNull()

  Verifies that the actual group contains at least a null element.

  Specified by:

  containsNull in interface ObjectEnumerableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>>

  Returns:

  this assertion object.

• doesNotContainNull

  public S doesNotContainNull()

  Verifies that the actual group does not contain null elements.

  Specified by:

  doesNotContainNull in interface ObjectEnumerableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>>

  Returns:

  this assertion object.

• are

  public S are(Condition<? super T> condition)

  Verifies that each element value satisfies the given condition

  Specified by:

  are in interface ObjectEnumerableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>>

  Parameters:

  condition - the given condition.

  Returns:

  this object.

• areNot

  public S areNot(Condition<? super T> condition)

  Verifies that each element value not satisfies the given condition

  Specified by:

  areNot in interface ObjectEnumerableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>>

  Parameters:

  condition - the given condition.

  Returns:

  this object.

• have

  public S have(Condition<? super T> condition)

  Verifies that each element value satisfies the given condition

  Specified by:

  have in interface ObjectEnumerableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>>

  Parameters:

  condition - the given condition.

  Returns:

  this object.

• doNotHave

  public S doNotHave(Condition<? super T> condition)

  Verifies that each element value not satisfies the given condition

  Specified by:

  doNotHave in interface ObjectEnumerableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>>

  Parameters:

  condition - the given condition.

  Returns:

  this object.

• areAtLeast

  public S areAtLeast(int times, Condition<? super T> condition)

  Verifies that there is at least n elements in the actual group satisfying the given condition.

  Specified by:

  areAtLeast in interface ObjectEnumerableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>>

  Parameters:

  times - the minimum number of times the condition should be verified.

  condition - the given condition.

  Returns:

  this object.

• areNotAtLeast

  public S areNotAtLeast(int times, Condition<? super T> condition)

  Verifies that there is at least n elements in the actual group not satisfying the given condition.

  Specified by:

  areNotAtLeast in interface ObjectEnumerableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>>

  Parameters:

  times - the number of times the condition should not be verified at least.

  condition - the given condition.

  Returns:

  this object.

• areAtMost

  public S areAtMost(int times, Condition<? super T> condition)

  Verifies that there is at most n elements in the actual group satisfying the given condition.

  Specified by:

  areAtMost in interface ObjectEnumerableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>>

  Parameters:

  times - the number of times the condition should be at most verified.

  condition - the given condition.

  Returns:

  this object.

• areNotAtMost

  public S areNotAtMost(int times, Condition<? super T> condition)

  Verifies that there is at most n elements in the actual group not satisfying the given condition.

  Specified by:

  areNotAtMost in interface ObjectEnumerableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>>

  Parameters:

  times - the number of times the condition should not be verified at most.

  condition - the given condition.

  Returns:

  this object.

• areExactly

  public S areExactly(int times, Condition<? super T> condition)

  Verifies that there is exactly n elements in the actual group satisfying the given condition.

  Specified by:

  areExactly in interface ObjectEnumerableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>>

  Parameters:

  times - the exact number of times the condition should be verified.

  condition - the given condition.

  Returns:

  this object.

• areNotExactly

  public S areNotExactly(int times, Condition<? super T> condition)

  Verifies that there is exactly n elements in the actual group not satisfying the given condition.

  Specified by:

  areNotExactly in interface ObjectEnumerableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>>

  Parameters:

  times - the exact number of times the condition should not be verified.

  condition - the given condition.

  Returns:

  this object.

• haveAtLeast

  public S haveAtLeast(int times, Condition<? super T> condition)

  This method is an alias for ObjectEnumerableAssert.areAtLeast(int, Condition).

  Specified by:

  haveAtLeast in interface ObjectEnumerableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>>

• doNotHaveAtLeast

  public S doNotHaveAtLeast(int times, Condition<? super T> condition)

  This method is an alias ObjectEnumerableAssert.areNotAtLeast(int, Condition).

  Specified by:

  doNotHaveAtLeast in interface ObjectEnumerableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>>

• haveAtMost

  public S haveAtMost(int times, Condition<? super T> condition)

  This method is an alias ObjectEnumerableAssert.areAtMost(int, Condition).

  Specified by:

  haveAtMost in interface ObjectEnumerableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>>

• doNotHaveAtMost

  public S doNotHaveAtMost(int times, Condition<? super T> condition)

  This method is an alias ObjectEnumerableAssert.areNotAtMost(int, Condition).

  Specified by:

  doNotHaveAtMost in interface ObjectEnumerableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>>

• haveExactly

  public S haveExactly(int times, Condition<? super T> condition)

  This method is an alias ObjectEnumerableAssert.areExactly(int, Condition).

  Specified by:

  haveExactly in interface ObjectEnumerableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>>

• doNotHaveExactly

  public S doNotHaveExactly(int times, Condition<? super T> condition)

  This method is an alias ObjectEnumerableAssert.areNotExactly(int, Condition).

  Specified by:

  doNotHaveExactly in interface ObjectEnumerableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>>

• containsAll

  public S containsAll(Iterable<? extends T> iterable)

  Verifies that the actual group contains all the elements of given Iterable, in any order.

  Specified by:

  containsAll in interface ObjectEnumerableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>>

  Parameters:

  iterable - the given Iterable we will get elements from.

  Returns:

  this assertion object.

• usingElementComparator

  public S usingElementComparator(Comparator<? super T> 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);
   

  Specified by:

  usingElementComparator in interface EnumerableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>>

  Parameters:

  customComparator - the comparator to use for incoming assertion checks.

  Returns:

  this assertion object.

• usingDefaultElementComparator

  public S 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 EnumerableAssert.usingElementComparator(Comparator).

  Specified by:

  usingDefaultElementComparator in interface EnumerableAssert<S extends AbstractIterableAssert<S,A,T>,A extends Iterable<T>>

  Returns:

  this assertion object.