org.assertj.core.api

Class ListAssert<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.AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>

org.assertj.core.api.FactoryBasedNavigableListAssert<ListAssert<ELEMENT>,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>

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

Type Parameters:

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

All Implemented Interfaces:

Assert<ListAssert<ELEMENT>,List<? extends ELEMENT>>, Descriptable<ListAssert<ELEMENT>>, EnumerableAssert<ListAssert<ELEMENT>,ELEMENT>, ExtensionPoints<ListAssert<ELEMENT>,List<? extends ELEMENT>>, IndexedObjectEnumerableAssert<ListAssert<ELEMENT>,ELEMENT>, ObjectEnumerableAssert<ListAssert<ELEMENT>,ELEMENT>

public class ListAssert<ELEMENT>
extends FactoryBasedNavigableListAssert<ListAssert<ELEMENT>,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>

Assertion methods for Lists.

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

Author:

Yvonne Wang, Alex Ruiz, Joel Costigliola, Mikhail Mazursky

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
ListAssert(List<? extends ELEMENT> actual)

Method Summary

Methods

Modifier and Type	Method and Description
ListAssert<ELEMENT>	contains(ELEMENT... values) Verifies that the actual group contains the given values, in any order.
ListAssert<ELEMENT>	containsExactly(ELEMENT... values) Verifies that the actual group contains only the given values and nothing else, in order. This assertion should only be used with groups that have a consistent iteration order (i.e.
ListAssert<ELEMENT>	containsExactlyInAnyOrder(ELEMENT... values) Verifies that the actual group contains exactly the given values and nothing else, in any order.
ListAssert<ELEMENT>	containsOnlyOnce(ELEMENT... values) Verifies that the actual group contains the given values only once.
ListAssert<ELEMENT>	containsSequence(ELEMENT... sequence) Verifies that the actual group contains the given sequence in the correct order and without extra values between the sequence values.
ListAssert<ELEMENT>	containsSubsequence(ELEMENT... sequence) Verifies that the actual group contains the given subsequence in the correct order (possibly with other values between them).
ListAssert<ELEMENT>	doesNotContain(ELEMENT... values) Verifies that the actual group does not contain the given values.
ListAssert<ELEMENT>	endsWith(ELEMENT... sequence) Verifies that the actual group ends with the given sequence of objects, without any other objects between them.
ListAssert<ELEMENT>	isSubsetOf(ELEMENT... values) Verifies that all the elements of actual are present in the given values.
ListAssert<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.FactoryBasedNavigableListAssert

toAssert

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

as, as, contains, describedAs, describedAs, doesNotContain, doesNotHave, doesNotHaveSameClassAs, has, has, hasSameClassAs, hasToString, is, is, isEqualTo, isExactlyInstanceOf, isIn, isIn, isInstanceOf, isInstanceOfAny, isNot, isNotEqualTo, isNotExactlyInstanceOf, isNotIn, isNotIn, isNotInstanceOf, isNotInstanceOfAny, isNotNull, isNotOfAnyClassIn, isNotSameAs, isOfAnyClassIn, isSameAs, isSorted, isSortedAccordingTo, overridingErrorMessage, usingComparator, usingComparisonStrategy, usingDefaultComparator, usingDefaultElementComparator, usingElementComparator, withFailMessage, withThreadDumpOnError

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

are, areAtLeast, areAtLeastOne, areAtMost, areExactly, areNot, containsAll, containsExactlyElementsOf, containsNull, containsOnly, containsOnlyElementsOf, doesNotContainAnyElementsOf, doesNotContainNull, doesNotHaveDuplicates, doNotHave, element, extracting, extracting, extracting, extracting, extractingResultOf, extractingResultOf, filteredOn, filteredOn, filteredOn, filteredOnNull, first, flatExtracting, flatExtracting, flatExtracting, hasAtLeastOneElementOfType, hasOnlyElementsOfType, hasSameElementsAs, hasSameSizeAs, hasSameSizeAs, hasSize, have, haveAtLeast, haveAtLeastOne, haveAtMost, haveExactly, inBinary, inHexadecimal, isEmpty, isNotEmpty, isNullOrEmpty, isSubsetOf, last, navigationDescription, newListAssertInstance, size, toLazyIterable, usingComparatorForElementFieldsWithNames, usingComparatorForElementFieldsWithType, usingElementComparatorIgnoringFields, usingElementComparatorOnFields, usingFieldByFieldElementComparator, usingRecursiveFieldByFieldElementComparator

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

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

are, areAtLeast, areAtLeastOne, areAtMost, areExactly, areNot, containsAll, containsExactlyElementsOf, containsNull, containsOnly, containsOnlyElementsOf, doesNotContainAnyElementsOf, doesNotContainNull, doesNotHaveDuplicates, doNotHave, hasAtLeastOneElementOfType, hasOnlyElementsOfType, hasSameElementsAs, have, haveAtLeast, haveAtLeastOne, haveAtMost, haveExactly, isSubsetOf

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

hasSameSizeAs, hasSameSizeAs, hasSize, isEmpty, isNotEmpty, isNullOrEmpty

Constructor Detail

ListAssert

public ListAssert(List<? extends ELEMENT> actual)

Method Detail

contains

@SafeVarargs
public final ListAssert<ELEMENT> contains(ELEMENT... values)

Description copied from class: AbstractIterableAssert

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

Example :

 Iterable<String> abc = newArrayList("a", "b", "c");
 
 // assertions will pass
 assertThat(abc).contains("b", "a");
 assertThat(abc).contains("b", "a", "b");
 
 // assertion will fail
 assertThat(abc).contains("d");

Specified by:

contains in interface ObjectEnumerableAssert<ListAssert<ELEMENT>,ELEMENT>

Overrides:

contains in class AbstractIterableAssert<ListAssert<ELEMENT>,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>

Parameters:

values - the given values.

Returns:

this assertion object.

containsOnlyOnce

@SafeVarargs
public final ListAssert<ELEMENT> containsOnlyOnce(ELEMENT... values)

Description copied from class: AbstractIterableAssert

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

Specified by:

containsOnlyOnce in interface ObjectEnumerableAssert<ListAssert<ELEMENT>,ELEMENT>

Overrides:

containsOnlyOnce in class AbstractIterableAssert<ListAssert<ELEMENT>,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>

Parameters:

values - the given values.

Returns:

this assertion object.

containsExactly

@SafeVarargs
public final ListAssert<ELEMENT> containsExactly(ELEMENT... values)

Description copied from class: AbstractIterableAssert

Verifies that the actual group contains only the given values and nothing else, in order.
This assertion should only be used with groups that have a consistent iteration order (i.e. don't use it with HashSet, prefer ObjectEnumerableAssert.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 order differ
 assertThat(elvesRings).containsExactly(nenya, vilya, narya);

Specified by:

containsExactly in interface ObjectEnumerableAssert<ListAssert<ELEMENT>,ELEMENT>

Overrides:

containsExactly in class AbstractIterableAssert<ListAssert<ELEMENT>,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>

Parameters:

values - the given values.

Returns:

this assertion object.

containsExactlyInAnyOrder

@SafeVarargs
public final ListAssert<ELEMENT> containsExactlyInAnyOrder(ELEMENT... values)

Description copied from class: AbstractIterableAssert

Verifies that the actual group contains exactly 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<Ring> elvesRings = newArrayList(vilya, nenya, narya, vilya);

 // assertion will pass
 assertThat(elvesRings).containsExactlyInAnyOrder(vilya, vilya, nenya, narya);

 // assertion will fail as vilya is contained twice in elvesRings.
 assertThat(elvesRings).containsExactlyInAnyOrder(nenya, vilya, narya);

Specified by:

containsExactlyInAnyOrder in interface ObjectEnumerableAssert<ListAssert<ELEMENT>,ELEMENT>

Overrides:

containsExactlyInAnyOrder in class AbstractIterableAssert<ListAssert<ELEMENT>,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>

Parameters:

values - the given values.

Returns:

this assertion object.

isSubsetOf

@SafeVarargs
public final ListAssert<ELEMENT> isSubsetOf(ELEMENT... values)

Description copied from class: AbstractIterableAssert

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

Specified by:

isSubsetOf in interface ObjectEnumerableAssert<ListAssert<ELEMENT>,ELEMENT>

Overrides:

isSubsetOf in class AbstractIterableAssert<ListAssert<ELEMENT>,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>

Parameters:

values - the values that should be used for checking the elements of actual.

Returns:

this assertion object.

containsSequence

@SafeVarargs
public final ListAssert<ELEMENT> containsSequence(ELEMENT... sequence)

Description copied from class: AbstractIterableAssert

Verifies that the actual group contains the given sequence in the correct order and without extra values between the sequence values.

Use ObjectEnumerableAssert.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);
 
 // assertions 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);

Specified by:

containsSequence in interface ObjectEnumerableAssert<ListAssert<ELEMENT>,ELEMENT>

Overrides:

containsSequence in class AbstractIterableAssert<ListAssert<ELEMENT>,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>

Parameters:

sequence - the sequence of objects to look for.

Returns:

this assertion object.

containsSubsequence

@SafeVarargs
public final ListAssert<ELEMENT> containsSubsequence(ELEMENT... sequence)

Description copied from class: AbstractIterableAssert

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

Specified by:

containsSubsequence in interface ObjectEnumerableAssert<ListAssert<ELEMENT>,ELEMENT>

Overrides:

containsSubsequence in class AbstractIterableAssert<ListAssert<ELEMENT>,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>

Parameters:

sequence - the sequence of objects to look for.

Returns:

this assertion object.

doesNotContain

@SafeVarargs
public final ListAssert<ELEMENT> doesNotContain(ELEMENT... values)

Description copied from interface: ObjectEnumerableAssert

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

 // assertions will pass
 assertThat(abc).doesNotContain("d")
 assertThat(abc).doesNotContain("d", "e");
 
 // assertions will fail
 assertThat(abc).doesNotContain("a");
 assertThat(abc).doesNotContain("a", "b");
 assertThat(abc).doesNotContain("c", "d");

Specified by:

doesNotContain in interface ObjectEnumerableAssert<ListAssert<ELEMENT>,ELEMENT>

Overrides:

doesNotContain in class AbstractIterableAssert<ListAssert<ELEMENT>,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>

Parameters:

values - the given values.

Returns:

this assertion object.

startsWith

@SafeVarargs
public final ListAssert<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");

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

Specified by:

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

Overrides:

startsWith in class AbstractIterableAssert<ListAssert<ELEMENT>,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>

Parameters:

sequence - the sequence of objects to look for.

Returns:

this assertion object.

endsWith

@SafeVarargs
public final ListAssert<ELEMENT> endsWith(ELEMENT... sequence)

Description copied from class: AbstractIterableAssert

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.

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

Specified by:

endsWith in interface ObjectEnumerableAssert<ListAssert<ELEMENT>,ELEMENT>

Overrides:

endsWith in class AbstractIterableAssert<ListAssert<ELEMENT>,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>

Parameters:

sequence - the sequence of objects to look for.

Returns:

this assertion object.