org.assertj.core.api

Class IterableAssert<ELEMENT>

java.lang.Object

org.assertj.core.api.AbstractAssert<SELF,ACTUAL>

org.assertj.core.api.AbstractIterableAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>

org.assertj.core.api.FactoryBasedNavigableIterableAssert<IterableAssert<ELEMENT>,Iterable<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>

org.assertj.core.api.IterableAssert<ELEMENT>

Type Parameters:

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

All Implemented Interfaces:

Assert<IterableAssert<ELEMENT>,Iterable<? extends ELEMENT>>, Descriptable<IterableAssert<ELEMENT>>, EnumerableAssert<IterableAssert<ELEMENT>,ELEMENT>, ExtensionPoints<IterableAssert<ELEMENT>,Iterable<? extends ELEMENT>>, ObjectEnumerableAssert<IterableAssert<ELEMENT>,ELEMENT>

public class IterableAssert<ELEMENT>
extends FactoryBasedNavigableIterableAssert<IterableAssert<ELEMENT>,Iterable<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>

Assertion methods for Iterable.

To create an instance of this class, invoke Assertions.assertThat(Iterable).

Author:

Yvonne Wang, Alex Ruiz, Matthieu Baechler, Joel Costigliola, Mikhail Mazursky, Julien Meddah

Field Summary

Fields inherited from class org.assertj.core.api.AbstractIterableAssert

iterables

Fields inherited from class org.assertj.core.api.AbstractAssert

actual, info, myself

Constructor Summary

Constructors

Constructor and Description
IterableAssert(Iterable<? extends ELEMENT> actual)
IterableAssert(Iterator<? extends ELEMENT> actual)

Method Summary

Methods

Modifier and Type	Method and Description
IterableAssert<ELEMENT>	isEqualTo(Object expected) Verifies that the actual value is equal to the given one.
IterableAssert<ELEMENT>	isExactlyInstanceOf(Class<?> type) Verifies that the actual value is exactly an instance of the given type.
IterableAssert<ELEMENT>	isInstanceOf(Class<?> type) Verifies that the actual value is an instance of the given type.
IterableAssert<ELEMENT>	isInstanceOfAny(Class<?>... types) Verifies that the actual value is an instance of any of the given types.
IterableAssert<ELEMENT>	isNotExactlyInstanceOf(Class<?> type) Verifies that the actual value is not exactly an instance of given type.
IterableAssert<ELEMENT>	isNotInstanceOf(Class<?> type) Verifies that the actual value is not an instance of the given type.
IterableAssert<ELEMENT>	isNotInstanceOfAny(Class<?>... types) Verifies that the actual value is not an instance of any of the given types.
IterableAssert<ELEMENT>	isNotOfAnyClassIn(Class<?>... types) Verifies that the actual value type is not in given types.
IterableAssert<ELEMENT>	isNotSameAs(Object expected) Verifies that the actual value is not the same as the given one, ie using == comparison.
IterableAssert<ELEMENT>	isOfAnyClassIn(Class<?>... types) Verifies that the actual value type is in given types.
IterableAssert<ELEMENT>	isSameAs(Object expected) Verifies that the actual value is the same as the given one, ie using == comparison.
IterableAssert<ELEMENT>	startsWith(ELEMENT... sequence) Verifies that the actual group starts with the given sequence of objects, without any other objects between them.

Methods inherited from class org.assertj.core.api.FactoryBasedNavigableIterableAssert

toAssert

Methods inherited from class org.assertj.core.api.AbstractIterableAssert

are, areAtLeast, areAtLeastOne, areAtMost, areExactly, areNot, as, as, contains, containsAll, containsExactly, containsExactlyElementsOf, containsExactlyInAnyOrder, containsNull, containsOnly, containsOnlyElementsOf, containsOnlyOnce, containsSequence, containsSubsequence, describedAs, describedAs, doesNotContain, doesNotContainAnyElementsOf, doesNotContainNull, doesNotHave, doesNotHaveDuplicates, doesNotHaveSameClassAs, doNotHave, element, endsWith, extracting, extracting, extracting, extracting, extractingResultOf, extractingResultOf, filteredOn, filteredOn, filteredOn, filteredOnNull, first, flatExtracting, flatExtracting, flatExtracting, has, hasAtLeastOneElementOfType, hasOnlyElementsOfType, hasSameClassAs, hasSameElementsAs, hasSameSizeAs, hasSameSizeAs, hasSize, hasToString, have, haveAtLeast, haveAtLeastOne, haveAtMost, haveExactly, inBinary, inHexadecimal, is, isEmpty, isIn, isIn, isNot, isNotEmpty, isNotEqualTo, isNotIn, isNotIn, isNotNull, isNullOrEmpty, isSubsetOf, isSubsetOf, last, navigationDescription, overridingErrorMessage, size, usingComparator, usingComparatorForElementFieldsWithNames, usingComparatorForElementFieldsWithType, usingComparisonStrategy, usingDefaultComparator, usingDefaultElementComparator, usingElementComparator, usingElementComparatorIgnoringFields, usingElementComparatorOnFields, usingFieldByFieldElementComparator, usingRecursiveFieldByFieldElementComparator, withFailMessage, withThreadDumpOnError

Methods inherited from class org.assertj.core.api.AbstractAssert

asList, asString, descriptionText, equals, failWithMessage, getWritableAssertionInfo, hashCode, isNull, setCustomRepresentation, withRepresentation

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

IterableAssert

public IterableAssert(Iterable<? extends ELEMENT> actual)

IterableAssert

public IterableAssert(Iterator<? extends ELEMENT> actual)

Method Detail

isEqualTo

public IterableAssert<ELEMENT> isEqualTo(Object expected)

Description copied from class: AbstractAssert

Verifies that the actual value is equal to the given one.

Example:

 // assertions will pass
 assertThat("abc").isEqualTo("abc");
 assertThat(new HashMap<String, Integer>()).isEqualTo(new HashMap<String, Integer>());
 
 // assertions will fail
 assertThat("abc").isEqualTo("123");
 assertThat(new ArrayList<String>()).isEqualTo(1);

Specified by:

isEqualTo in interface Assert<IterableAssert<ELEMENT>,Iterable<? extends ELEMENT>>

Overrides:

isEqualTo in class AbstractIterableAssert<IterableAssert<ELEMENT>,Iterable<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>

Parameters:

expected - the given value to compare the actual value to.

Returns:

this assertion object.

isInstanceOf

public IterableAssert<ELEMENT> isInstanceOf(Class<?> type)

Description copied from class: AbstractAssert

Verifies that the actual value is an instance of the given type.

Example:

 // assertions will pass
 assertThat("abc").isInstanceOf(String.class);
 assertThat(new HashMap<String, Integer>()).isInstanceOf(HashMap.class);
 assertThat(new HashMap<String, Integer>()).isInstanceOf(Map.class);
 
 // assertions will fail
 assertThat(1).isInstanceOf(String.class);
 assertThat(new ArrayList<String>()).isInstanceOf(LinkedList.class);

Specified by:

isInstanceOf in interface Assert<IterableAssert<ELEMENT>,Iterable<? extends ELEMENT>>

Overrides:

isInstanceOf in class AbstractIterableAssert<IterableAssert<ELEMENT>,Iterable<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>

Parameters:

type - the type to check the actual value against.

Returns:

this assertion object.

isInstanceOfAny

public IterableAssert<ELEMENT> isInstanceOfAny(Class<?>... types)

Description copied from class: AbstractAssert

Verifies that the actual value is an instance of any of the given types.

Example:

 // assertions will pass
 assertThat("abc").isInstanceOfAny(String.class, Integer.class);
 assertThat(new ArrayList<String>()).isInstanceOfAny(LinkedList.class, ArrayList.class);
 assertThat(new HashMap<String, Integer>()).isInstanceOfAny(TreeMap.class, Map.class);
 
 // assertions will fail
 assertThat(1).isInstanceOfAny(Double.class, Float.class);
 assertThat(new ArrayList<String>()).isInstanceOfAny(LinkedList.class, Vector.class);

Specified by:

isInstanceOfAny in interface Assert<IterableAssert<ELEMENT>,Iterable<? extends ELEMENT>>

Overrides:

isInstanceOfAny in class AbstractIterableAssert<IterableAssert<ELEMENT>,Iterable<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>

Parameters:

types - the types to check the actual value against.

Returns:

this assertion object.

isOfAnyClassIn

public IterableAssert<ELEMENT> isOfAnyClassIn(Class<?>... types)

Description copied from class: AbstractAssert

Verifies that the actual value type is in given types.

Example:

 // assertions will pass
 assertThat(new HashMap<String, Integer>()).isOfAnyClassIn(HashMap.class, TreeMap.class);
 assertThat(new ArrayList<String>()).isOfAnyClassIn(ArrayList.class, LinkedList.class);
 
 // assertions will fail
 assertThat(new HashMap<String, Integer>()).isOfAnyClassIn(TreeMap.class, Map.class);
 assertThat(new ArrayList<String>()).isOfAnyClassIn(LinkedList.class, List.class);

Specified by:

isOfAnyClassIn in interface Assert<IterableAssert<ELEMENT>,Iterable<? extends ELEMENT>>

Overrides:

isOfAnyClassIn in class AbstractIterableAssert<IterableAssert<ELEMENT>,Iterable<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>

Parameters:

types - the types to check the actual value against.

Returns:

this assertion object.

isExactlyInstanceOf

public IterableAssert<ELEMENT> isExactlyInstanceOf(Class<?> type)

Description copied from class: AbstractAssert

Verifies that the actual value is exactly an instance of the given type.

Example:

 // assertions will pass
 assertThat("abc").isExactlyInstanceOf(String.class);
 assertThat(new ArrayList<String>()).isExactlyInstanceOf(ArrayList.class);
 assertThat(new HashMap<String, Integer>()).isExactlyInstanceOf(HashMap.class);
 
 // assertions will fail
 assertThat(1).isExactlyInstanceOf(String.class);
 assertThat(new ArrayList<String>()).isExactlyInstanceOf(List.class);
 assertThat(new HashMap<String, Integer>()).isExactlyInstanceOf(Map.class);

Specified by:

isExactlyInstanceOf in interface Assert<IterableAssert<ELEMENT>,Iterable<? extends ELEMENT>>

Overrides:

isExactlyInstanceOf in class AbstractIterableAssert<IterableAssert<ELEMENT>,Iterable<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>

Parameters:

type - the type to check the actual value against.

Returns:

this assertion object.

isNotInstanceOf

public IterableAssert<ELEMENT> isNotInstanceOf(Class<?> type)

Description copied from class: AbstractAssert

Verifies that the actual value is not an instance of the given type.

Example:

 // assertions will pass
 assertThat(1).isNotInstanceOf(Double.class);
 assertThat(new ArrayList<String>()).isNotInstanceOf(LinkedList.class);
 
 // assertions will fail
 assertThat("abc").isNotInstanceOf(String.class);
 assertThat(new HashMap<String, Integer>()).isNotInstanceOf(HashMap.class);
 assertThat(new HashMap<String, Integer>()).isNotInstanceOf(Map.class);

Specified by:

isNotInstanceOf in interface Assert<IterableAssert<ELEMENT>,Iterable<? extends ELEMENT>>

Overrides:

isNotInstanceOf in class AbstractIterableAssert<IterableAssert<ELEMENT>,Iterable<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>

Parameters:

type - the type to check the actual value against.

Returns:

this assertion object.

isNotInstanceOfAny

public IterableAssert<ELEMENT> isNotInstanceOfAny(Class<?>... types)

Description copied from class: AbstractAssert

Verifies that the actual value is not an instance of any of the given types.

Example:

 // assertions will pass
 assertThat(1).isNotInstanceOfAny(Double.class, Float.class);
 assertThat(new ArrayList<String>()).isNotInstanceOfAny(LinkedList.class, Vector.class);
 
 // assertions will fail
 assertThat(1).isNotInstanceOfAny(Double.class, Integer.class);
 assertThat(new ArrayList<String>()).isNotInstanceOfAny(LinkedList.class, ArrayList.class);
 assertThat(new HashMap<String, Integer>()).isNotInstanceOfAny(TreeMap.class, Map.class);

Specified by:

isNotInstanceOfAny in interface Assert<IterableAssert<ELEMENT>,Iterable<? extends ELEMENT>>

Overrides:

isNotInstanceOfAny in class AbstractIterableAssert<IterableAssert<ELEMENT>,Iterable<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>

Parameters:

types - the types to check the actual value against.

Returns:

this assertion object.

isNotOfAnyClassIn

public IterableAssert<ELEMENT> isNotOfAnyClassIn(Class<?>... types)

Description copied from class: AbstractAssert

Verifies that the actual value type is not in given types.

Example:

 // assertions will pass
 assertThat(new HashMap<String, Integer>()).isNotOfAnyClassIn(Map.class, TreeMap.class);
 assertThat(new ArrayList<String>()).isNotOfAnyClassIn(LinkedList.class, List.class);
 
 // assertions will fail
 assertThat(new HashMap<String, Integer>()).isNotOfAnyClassIn(HashMap.class, TreeMap.class);
 assertThat(new ArrayList<String>()).isNotOfAnyClassIn(ArrayList.class, LinkedList.class);

Specified by:

isNotOfAnyClassIn in interface Assert<IterableAssert<ELEMENT>,Iterable<? extends ELEMENT>>

Overrides:

isNotOfAnyClassIn in class AbstractIterableAssert<IterableAssert<ELEMENT>,Iterable<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>

Parameters:

types - the types to check the actual value against.

Returns:

this assertion object.

isNotExactlyInstanceOf

public IterableAssert<ELEMENT> isNotExactlyInstanceOf(Class<?> type)

Description copied from class: AbstractAssert

Verifies that the actual value is not exactly an instance of given type.

Example:

 // assertions will pass
 assertThat(1).isNotExactlyInstanceOf(String.class);
 assertThat(new ArrayList<String>()).isNotExactlyInstanceOf(List.class);
 assertThat(new HashMap<String, Integer>()).isNotExactlyInstanceOf(Map.class);
 
 // assertions will fail
 assertThat("abc").isNotExactlyInstanceOf(String.class);
 assertThat(new ArrayList<String>()).isNotExactlyInstanceOf(ArrayList.class);
 assertThat(new HashMap<String, Integer>()).isNotExactlyInstanceOf(HashMap.class);

Specified by:

isNotExactlyInstanceOf in interface Assert<IterableAssert<ELEMENT>,Iterable<? extends ELEMENT>>

Overrides:

isNotExactlyInstanceOf in class AbstractIterableAssert<IterableAssert<ELEMENT>,Iterable<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>

Parameters:

type - the type to check the actual value against.

Returns:

this assertion object.

isSameAs

public IterableAssert<ELEMENT> isSameAs(Object expected)

Description copied from class: AbstractAssert

Verifies that the actual value is the same as the given one, ie using == comparison.

Example:

 // Name is a class with first and last fields, two Names are equals if both first and last are equals.
 Name tyrion = new Name("Tyrion", "Lannister");
 Name alias  = tyrion;
 Name clone  = new Name("Tyrion", "Lannister");
 
 // assertions succeed:
 assertThat(tyrion).isSameAs(alias)
                   .isEqualTo(clone);
                      
 // assertion fails:
 assertThat(tyrion).isSameAs(clone);

Specified by:

isSameAs in interface Assert<IterableAssert<ELEMENT>,Iterable<? extends ELEMENT>>

Overrides:

isSameAs in class AbstractIterableAssert<IterableAssert<ELEMENT>,Iterable<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>

Parameters:

expected - the given value to compare the actual value to.

Returns:

this assertion object.

isNotSameAs

public IterableAssert<ELEMENT> isNotSameAs(Object expected)

Description copied from class: AbstractAssert

Verifies that the actual value is not the same as the given one, ie using == comparison.

Example:

 // Name is a class with first and last fields, two Names are equals if both first and last are equals.
 Name tyrion = new Name("Tyrion", "Lannister");
 Name alias  = tyrion;
 Name clone  = new Name("Tyrion", "Lannister");
 
 // assertions succeed:
 assertThat(clone).isNotSameAs(tyrion)
                  .isEqualTo(tyrion);
                      
 // assertion fails:
 assertThat(alias).isNotSameAs(tyrion);

Specified by:

isNotSameAs in interface Assert<IterableAssert<ELEMENT>,Iterable<? extends ELEMENT>>

Overrides:

isNotSameAs in class AbstractIterableAssert<IterableAssert<ELEMENT>,Iterable<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>

Parameters:

expected - the given value to compare the actual value to.

Returns:

this assertion object.

startsWith

public IterableAssert<ELEMENT> startsWith(ELEMENT... sequence)

Description copied from class: AbstractIterableAssert

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.

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");

Specified by:

startsWith in interface ObjectEnumerableAssert<IterableAssert<ELEMENT>,ELEMENT>

Overrides:

startsWith in class AbstractIterableAssert<IterableAssert<ELEMENT>,Iterable<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>

Parameters:

sequence - the sequence of objects to look for.

Returns:

this assertion object.