org.assertj.core.api

Interface ObjectEnumerableAssert<S extends ObjectEnumerableAssert<S,T>,T>

Type Parameters:

S - the "self" type of this assertion class. Please read "Emulating 'self types' using Java Generics to simplify fluent API implementation" for more details.

T - the type of elements of the "actual" value.

All Superinterfaces:

EnumerableAssert<S,T>

All Known Subinterfaces:

IndexedObjectEnumerableAssert<S,T>

All Known Implementing Classes:

AbstractIterableAssert, AbstractListAssert, AbstractObjectArrayAssert, IterableAssert, ListAssert, ObjectArrayAssert

public interface ObjectEnumerableAssert<S extends ObjectEnumerableAssert<S,T>,T>
extends EnumerableAssert<S,T>

Assertions methods applicable to groups of objects (e.g. arrays or collections.)

Author:

Yvonne Wang, Alex Ruiz, Nicolas François, Mikhail Mazursky, Joel Costigliola, Nicolas François

Method Summary

Methods

Modifier and Type	Method and Description
S	are(Condition<? super T> condition) Verifies that each element value satisfies the given condition
S	areAtLeast(int n, Condition<? super T> condition) Verifies that there is at least n elements in the actual group satisfying the given condition.
S	areAtLeastOne(Condition<? super T> condition) Verifies that there is at least one element in the actual group satisfying the given condition.
S	areAtMost(int n, Condition<? super T> condition) Verifies that there is at most n elements in the actual group satisfying the given condition.
S	areExactly(int n, Condition<? super T> condition) Verifies that there is exactly n elements in the actual group satisfying the given condition.
S	areNot(Condition<? super T> condition) Verifies that each element value does not satisfy the given condition
S	contains(T... values) Verifies that the actual group contains the given values, in any order.
S	containsAll(Iterable<? extends T> iterable) Verifies that the actual group contains all the elements of given Iterable, in any order.
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 group that have a consistent iteration order (i.e.
S	containsExactlyElementsOf(Iterable<? extends T> 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.
S	containsNull() Verifies that the actual group contains at least a null element.
S	containsOnly(T... values) Verifies that the actual group contains only the given values and nothing else, in any order.
S	containsOnlyElementsOf(Iterable<? extends T> iterable) Same semantic as containsOnly(Object[]) : verifies that actual contains all the elements of the given iterable and nothing else, in any order.
S	containsOnlyOnce(T... values) Verifies that the actual group contains the given values only once.
S	containsSequence(T... sequence) Verifies that the actual group contains the given sequence in the correct order and without extra value between the sequence values.
S	containsSubsequence(T... sequence) Verifies that the actual group contains the given subsequence in the correct order (possibly with other values between them).
S	doesNotContain(T... values) Verifies that the actual group does not contain the given values.
S	doesNotContainAnyElementsOf(Iterable<? extends T> iterable) Verifies that actual does not contain any elements of the given Iterable (i.e.
S	doesNotContainNull() Verifies that the actual group does not contain null elements.
S	doesNotHaveDuplicates() Verifies that the actual group does not contain duplicates.
S	doNotHave(Condition<? super T> condition) Verifies that all elements don't satisfy the given condition.
S	endsWith(T... sequence) Verifies that the actual group ends with the given sequence of objects, without any other objects between them.
S	hasAtLeastOneElementOfType(Class<?> expectedType) Verifies that at least one element in the actual Object group belong to the specified type (matching includes subclasses of the given type).
S	hasOnlyElementsOfType(Class<?> expectedType) Verifies that all the elements in the actual Object group belong to the specified type (matching includes subclasses of the given type).
S	hasSameElementsAs(Iterable<? extends T> iterable) An alias of containsOnlyElementsOf(Iterable) : verifies that actual contains all the elements of the given iterable and nothing else, in any order.
S	have(Condition<? super T> condition) Verifies that all elements satisfy the given condition.
S	haveAtLeast(int n, Condition<? super T> condition) Verifies that there is at least n elements in the actual group satisfying the given condition.
S	haveAtLeastOne(Condition<? super T> condition) Verifies that there is at least one element in the actual group satisfying the given condition.
S	haveAtMost(int n, Condition<? super T> condition) Verifies that there is at most n elements in the actual group satisfying the given condition.
S	haveExactly(int n, Condition<? super T> condition) Verifies that there is exactly n elements in the actual group satisfying the given condition.
S	isSubsetOf(Iterable<? extends T> values) Verifies that all the elements of actual are present in the given Iterable.
S	isSubsetOf(T... values) Verifies that all the elements of actual are present in the given values.
S	startsWith(T... sequence) Verifies that the actual group starts with the given sequence of objects, without any other objects between them.

Methods inherited from interface org.assertj.core.api.EnumerableAssert

hasSameSizeAs, hasSameSizeAs, hasSize, isEmpty, isNotEmpty, isNullOrEmpty, usingDefaultElementComparator, usingElementComparator

Method Detail

contains

S contains(T... values)

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

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).contains("b", "a");
 assertThat(abc).contains("b", "a", "b");
 
 // assertions will fail
 assertThat(abc).contains("d");

Parameters:

values - the given values.

Returns:

this assertion object.

Throws:

NullPointerException - if the given argument is null.

IllegalArgumentException - if the given argument is an empty array.

AssertionError - if the actual group is null.

AssertionError - if the actual group does not contain the given values.

containsOnly

S containsOnly(T... values)

Verifies that the actual group contains only 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<String> abc = newArrayList("a", "b", "c");

  // assertion will pass
 assertThat(abc).containsOnly("c", "b", "a");
 
  // assertion will fail as some elements of abc are missing
 assertThat(abc).containsOnly("a", "b");

Parameters:

values - the given values.

Returns:

this assertion object.

Throws:

NullPointerException - if the given argument is null.

IllegalArgumentException - if the given argument is an empty array.

AssertionError - if the actual group is null.

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

S containsOnlyOnce(T... 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("Aria", "Stark", "daughter", "of", "Ned", "Stark")).containsOnlyOnce("Stark");
 assertThat(newArrayList("Aria", "Stark", "daughter", "of", "Ned", "Stark")).containsOnlyOnce("Stark", "Lannister", "Aria");

Parameters:

values - the given values.

Returns:

this assertion object.

Throws:

NullPointerException - if the given argument is null.

IllegalArgumentException - if the given argument is an empty array.

AssertionError - if the actual group is null.

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

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 group 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 orders differ.
 assertThat(elvesRings).containsExactly(nenya, vilya, narya);

Parameters:

values - the given values.

Returns:

this assertion object.

Throws:

NullPointerException - if the given argument is null.

AssertionError - if the actual group is null.

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.

containsSequence

S containsSequence(T... sequence)

Verifies that the actual group contains the given sequence in the correct order and without extra value 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);
 
 // assertion will pass
 assertThat(elvesRings).containsSequence(vilya, nenya);
 assertThat(elvesRings).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:

AssertionError - if the actual group is null.

AssertionError - if the given array is null.

AssertionError - if the actual group does not contain the given sequence.

containsSubsequence

S containsSubsequence(T... 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);
 assertThat(elvesRings).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:

AssertionError - if the actual group is null.

AssertionError - if the given array is null.

AssertionError - if the actual group does not contain the given subsequence.

doesNotContain

S doesNotContain(T... 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");

 // assertion will pass
 assertThat(abc).doesNotContain("d", "e");

Parameters:

values - the given values.

Returns:

this assertion object.

Throws:

NullPointerException - if the given argument is null.

IllegalArgumentException - if the given argument is an empty array.

AssertionError - if the actual group is null.

AssertionError - if the actual group contains any of the given values.

doesNotHaveDuplicates

S 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:

AssertionError - if the actual group is null.

AssertionError - if the actual group contains duplicates.

startsWith

S startsWith(T... 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");

 // assertion will pass
 assertThat(abc).startsWith("a", "b");
 
 // assertion will fail
 assertThat(abc).startsWith("c");

Parameters:

sequence - the sequence of objects to look for.

Returns:

this assertion object.

Throws:

NullPointerException - if the given argument is null.

IllegalArgumentException - if the given argument is an empty array.

AssertionError - if the actual group is null.

AssertionError - if the actual group does not start with the given sequence of objects.

endsWith

S endsWith(T... 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");

 // assertion will pass
 assertThat(abc).endsWith("b", "c");
 
 // assertion will fail
 assertThat(abc).endsWith("a");

Parameters:

sequence - the sequence of objects to look for.

Returns:

this assertion object.

Throws:

NullPointerException - if the given argument is null.

IllegalArgumentException - if the given argument is an empty array.

AssertionError - if the actual group is null.

AssertionError - if the actual group does not end with the given sequence of objects.

containsNull

S containsNull()

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

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> abNull = newArrayList("a", "b", null);

 // assertion will pass
 assertThat(abNull).containsNull();
 
 // assertion will fail
 assertThat(abc).containsNull();

Returns:

this assertion object.

Throws:

AssertionError - if the actual group is null.

AssertionError - if the actual group does not contain a null element.

doesNotContainNull

S doesNotContainNull()

Verifies that the actual group does not contain null elements.

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> abNull = newArrayList("a", "b", null);

 // assertion will pass
 assertThat(abc).doesNotContainNull();

 // assertion will fail
 assertThat(abNull).doesNotContainNull();

Returns:

this assertion object.

Throws:

AssertionError - if the actual group is null.

AssertionError - if the actual group contains a null element.

are

S are(Condition<? super T> condition)

Verifies that each element value satisfies the given condition

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> abcc = newArrayList("a", "b", "cc");

 Condition<String> singleCharacterString = new Condition<String>() {
   public boolean matches(String value) {
     return value.length() == 1;
   }
 });

 // assertion will pass
 assertThat(abc).are(singleCharacterString);
 
 // assertion will fail
 assertThat(abcc).are(singleCharacterString);

Parameters:

condition - the given condition.

Returns:

this object.

Throws:

NullPointerException - if the given condition is null.

AssertionError - if a element cannot be cast to E.

AssertionError - if one or more element not satisfy the given condition.

areNot

S areNot(Condition<? super T> condition)

Verifies that each element value does not satisfy the given condition

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> abcc = newArrayList("a", "b", "cc");

 Condition<String> longerThanOneCharacter = new Condition<String>() {
   public boolean matches(String value) {
     return value.length() > 1;
   }
 });

 // assertion will pass
 assertThat(abc).areNot(longerThanOneCharacter);
 
 // assertion will fail
 assertThat(abcc).areNot(longerThanOneCharacter);

Parameters:

condition - the given condition.

Returns:

this object.

Throws:

NullPointerException - if the given condition is null.

AssertionError - if a element cannot be cast to E.

AssertionError - if one or more element satisfy the given condition.

have

S have(Condition<? super T> condition)

Verifies that all elements satisfy the given condition.

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> abcc = newArrayList("a", "b", "cc");

 Condition<String> singleCharacterStringOnly = new Condition<String>() {
   public boolean matches(String value) {
     return value.length() == 1;
   }
 });

 // assertion will pass
 assertThat(abc).have(singleCharacterStringOnly);
 
 // assertion will fail
 assertThat(abcc).have(singleCharacterStringOnly);

Parameters:

condition - the given condition.

Returns:

this object.

Throws:

NullPointerException - if the given condition is null.

AssertionError - if a element cannot be cast to E.

AssertionError - if one or more element not satisfy the given condition.

doNotHave

S doNotHave(Condition<? super T> condition)

Verifies that all elements don't satisfy the given condition.

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> abcc = newArrayList("a", "b", "cc");

 Condition<String> longerThanOneCharacterString = new Condition<String>() {
   public boolean matches(String value) {
     return value.length() > 1;
   }
 });

 // assertion will pass
 assertThat(abc).doNotHave(longerThanOneCharacterString);
 
 // assertion will fail
 assertThat(abcc).doNotHave(longerThanOneCharacterString);

Parameters:

condition - the given condition.

Returns:

this object.

Throws:

NullPointerException - if the given condition is null.

AssertionError - if a element cannot be cast to E.

AssertionError - if one or more element satisfy the given condition.

areAtLeast

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

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

Example :

 // an Iterable is used in the example but it would also work with an array
 Iterable<Integer> oneTwoThree = newArrayList(1, 2, 3);

 Condition<Integer> odd = new Condition<Integer>() {
   public boolean matches(Integer value) {
     return value % 2 == 1;
   }
 });

 // assertion will pass
 oneTwoThree.areAtLeast(2, odd);
 
 // assertion will fail
 oneTwoThree.areAtLeast(3, odd);

Parameters:

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

condition - the given condition.

Returns:

this object.

Throws:

NullPointerException - if the given condition is null.

AssertionError - if an element can not be cast to E.

AssertionError - if the number of elements satisfying the given condition is < n.

areAtLeastOne

S areAtLeastOne(Condition<? super T> 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:

 // an Iterable is used in the example but it would also work with an array
 
 // jedi is a Condition<String>
 assertThat(newLinkedHashSet("Luke", "Solo", "Leia")).areAtLeastOne(jedi);

See Also:

haveAtLeast(int, Condition)

areAtMost

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

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

Example :

 // an Iterable is used in the example but it would also work with an array
 Iterable<Integer> oneTwoThree = newArrayList(1, 2, 3);

 Condition<Integer> odd = new Condition<Integer>() {
   public boolean matches(Integer value) {
     return value % 2 == 1;
   }
 });

 // assertions will pass
 oneTwoThree.areAtMost(2, odd);
 oneTwoThree.areAtMost(3, odd);
 
 // assertions will fail
 oneTwoThree.areAtMost(1, odd);

Parameters:

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

condition - the given condition.

Returns:

this object.

Throws:

NullPointerException - if the given condition is null.

AssertionError - if a element cannot be cast to E.

AssertionError - if the number of elements satisfying the given condition is > n.

areExactly

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

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

Example :

 // an Iterable is used in the example but it would also work with an array
 Iterable<Integer> oneTwoThree = newArrayList(1, 2, 3);

 Condition<Integer> odd = new Condition<Integer>() {
   public boolean matches(Integer value) {
     return value % 2 == 1;
   }
 });

 // assertion will pass
 oneTwoThree.areExactly(2, odd);
 
 // assertions will fail
 oneTwoThree.areExactly(1, odd);
 oneTwoThree.areExactly(3, odd);

Parameters:

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

condition - the given condition.

Returns:

this object.

Throws:

NullPointerException - if the given condition is null.

AssertionError - if a element cannot be cast to E.

AssertionError - if the number of elements satisfying the given condition is ≠ n.

haveAtLeastOne

S haveAtLeastOne(Condition<? super T> 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:

 // an Iterable is used in the example but it would also work with an array
 
 List<BasketBallPlayer> bullsPlayers = newArrayList(noah, rose);
 
 // potentialMvp is a Condition<BasketBallPlayer>
 assertThat(bullsPlayers).haveAtLeastOne(potentialMvp);

See Also:

haveAtLeast(int, Condition)

haveAtLeast

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

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

Example :

 // an Iterable is used in the example but it would also work with an array
 Iterable<Integer> oneTwoThree = newArrayList(1, 2, 3);

 Condition<Integer> odd = new Condition<Integer>() {
   public boolean matches(Integer value) {
     return value % 2 == 1;
   }
 });

 // assertion will pass
 oneTwoThree.haveAtLeast(2, odd);
 
 // assertion will fail
 oneTwoThree.haveAtLeast(3, odd);

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

haveAtMost

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

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

Example :

 // an Iterable is used in the example but it would also work with an array
 Iterable<Integer> oneTwoThree = newArrayList(1, 2, 3);

 Condition<Integer> odd = new Condition<Integer>() {
   public boolean matches(Integer value) {
     return value % 2 == 1;
   }
 });

 // assertions will pass
 oneTwoThree.haveAtMost(2, odd);
 oneTwoThree.haveAtMost(3, odd);
 
 // assertion will fail
 oneTwoThree.haveAtMost(1, odd);

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

haveExactly

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

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

Example :

 // an Iterable is used in the example but it would also work with an array
 Iterable<Integer> oneTwoThree = newArrayList(1, 2, 3);

 Condition<Integer> odd = new Condition<Integer>() {
   public boolean matches(Integer value) {
     return value % 2 == 1;
   }
 });

 // assertion will pass
 oneTwoThree.haveExactly(2, odd);
 
 // assertions will fail
 oneTwoThree.haveExactly(1, odd);
 oneTwoThree.haveExactly(3, odd);

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

containsAll

S containsAll(Iterable<? extends T> iterable)

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

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> cb = newArrayList("c", "b");

 // assertion will pass
 assertThat(abc).containsAll(cb);

Parameters:

iterable - the given Iterable we will get elements from.

Returns:

this assertion object.

Throws:

NullPointerException - if the given argument is null.

AssertionError - if the actual group is null.

AssertionError - if the actual group does not contain all the elements of given Iterable.

hasAtLeastOneElementOfType

S hasAtLeastOneElementOfType(Class<?> expectedType)

Verifies that at least one element in the actual Object group belong to the specified type (matching includes subclasses of the given type).

Example:

 // an array is used in the example but it would also work with an Iterable
 
 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:

NullPointerException - if the given type is null.

AssertionError - if the actual Object group does not have any elements of the given type.

hasOnlyElementsOfType

S hasOnlyElementsOfType(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:

 // an array is used in the example but it would also work with an Iterable
 
 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:

NullPointerException - if the given type is null.

AssertionError - if one element is not of the expected type.

containsExactlyElementsOf

S containsExactlyElementsOf(Iterable<? extends T> 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 :

 // 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).containsExactlyElementsOf(newLinkedList(vilya, nenya, narya));
 
 // assertion will fail as actual and expected orders differ.
 assertThat(elvesRings).containsExactlyElementsOf(newLinkedList(nenya, vilya, narya));

Parameters:

iterable - the given Iterable we will get elements from.

containsOnlyElementsOf

S containsOnlyElementsOf(Iterable<? extends T> iterable)

Same semantic as containsOnly(Object[]) : verifies that actual contains all the elements of the given iterable and nothing else, in any order.

Example :

 // an Iterable is used in the example but it would also work with an array
 Iterable<Ring> rings = newArrayList(nenya, vilya);
 
 // assertion will pass
 assertThat(rings).containsOnlyElementsOf(newLinkedList(nenya, vilya));
 assertThat(rings).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 contain nenya.
 assertThat(rings).containsOnlyElementsOf(newLinkedList(vilya));

Parameters:

iterable - the given Iterable we will get elements from.

hasSameElementsAs

S hasSameElementsAs(Iterable<? extends T> iterable)

An alias of containsOnlyElementsOf(Iterable) : verifies that actual contains all the elements of the given iterable 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);
 
 // assertions will pass:
 assertThat(elvesRings).hasSameElementsAs(newArrayList(nenya, narya, vilya));
 assertThat(elvesRings).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:

AssertionError - if the actual group is null

NullPointerException - if the given Iterable is null

AssertionError - if the actual Iterable does not have the same elements, in any order, as the given Iterable

doesNotContainAnyElementsOf

S doesNotContainAnyElementsOf(Iterable<? extends T> iterable)

Verifies that actual does not contain any elements of the given Iterable (i.e. none).

Example:

 // an Iterable is used in the example but it would also work with an array
 
 // These assertions succeed:
 List<String> actual = newArrayList("GIT", "CVS", "SOURCESAFE");
 List<String> values = newArrayList("git", "cvs", "subversion");
 assertThat(actual).doesNotContainAnyElementsOf(values);
 
 // These fail:
 List<String> actual = newArrayList("GIT", "cvs", "SOURCESAFE");
 List<String> values = newArrayList("git", "cvs", "subversion");
 assertThat(actual).doesNotContainAnyElementsOf(values);

Parameters:

iterable - the Iterable whose elements must not be in the actual group.

Returns:

this assertion object.

Throws:

NullPointerException - if the given argument is null.

IllegalArgumentException - if the given argument is an empty iterable.

AssertionError - if the actual group is null.

AssertionError - if the actual group contains some elements of the given Iterable.

isSubsetOf

S isSubsetOf(Iterable<? extends T> 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);
 
 // assertions will pass:
 assertThat(elvesRings).isSubsetOf(ringsOfPower);
 
 // assertions will fail:
 assertThat(elvesRings).isSubsetOf(newArrayList(nenya, narya));

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.

isSubsetOf

S isSubsetOf(T... 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);
 assertThat(elvesRings).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:

AssertionError - if the actual Iterable is null.

AssertionError - if the actual Iterable is not subset of the given values.