ELEMENT - the type of elements of the "actual" value.public class ListAssert<ELEMENT> extends FactoryBasedNavigableListAssert<ListAssert<ELEMENT>,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>
Lists.
To create an instance of this class, invoke Assertions.assertThat(List)
iterablesactual, info, myself| Constructor and Description |
|---|
ListAssert(List<? extends ELEMENT> actual) |
| 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 exactly 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> |
containsOnly(ELEMENT... values)
Verifies that the actual group contains only the given values and nothing else, in any order and ignoring duplicates (i.e.
|
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> |
doesNotContainSequence(ELEMENT... sequence)
Verifies that the actual group does not contain the given sequence,
a sequence is defined by an ordered group of values without extra values between them.
|
ListAssert<ELEMENT> |
doesNotContainSubsequence(ELEMENT... sequence)
Verifies that the actual group does not contain the given subsequence,
a subsequence is defined by an ordered group of values with possibly extra values between them.
|
ListAssert<ELEMENT> |
endsWith(ELEMENT first,
ELEMENT... rest)
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.
|
toAssertas, 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, usingComparator, usingComparisonStrategy, usingDefaultComparator, usingDefaultElementComparator, usingElementComparator, withFailMessage, withThreadDumpOnErrorare, areAtLeast, areAtLeastOne, areAtMost, areExactly, areNot, containsAll, containsAnyElementsOf, containsAnyOf, containsExactlyElementsOf, containsExactlyInAnyOrderElementsOf, containsNull, containsOnlyElementsOf, containsOnlyNulls, containsSequence, containsSubsequence, doesNotContainAnyElementsOf, doesNotContainNull, doesNotContainSequence, doesNotContainSubsequence, doesNotHaveAnyElementsOfTypes, doesNotHaveDuplicates, doNotHave, element, endsWith, extracting, extracting, extracting, extracting, extractingResultOf, extractingResultOf, filteredOn, filteredOn, filteredOn, filteredOnNull, first, flatExtracting, flatExtracting, flatExtracting, hasAtLeastOneElementOfType, hasOnlyElementsOfType, hasOnlyElementsOfTypes, hasSameElementsAs, hasSameSizeAs, hasSameSizeAs, hasSize, have, haveAtLeast, haveAtLeastOne, haveAtMost, haveExactly, inBinary, inHexadecimal, isEmpty, isNotEmpty, isNullOrEmpty, isSubsetOf, last, navigationDescription, newListAssertInstance, size, toLazyIterable, usingComparatorForElementFieldsWithNames, usingComparatorForElementFieldsWithType, usingComparatorForType, usingElementComparatorIgnoringFields, usingElementComparatorOnFields, usingFieldByFieldElementComparator, usingRecursiveFieldByFieldElementComparatorasList, asString, descriptionText, equals, failWithMessage, getWritableAssertionInfo, hashCode, hasSameHashCodeAs, isNull, setCustomRepresentation, throwAssertionError, withRepresentationclone, finalize, getClass, notify, notifyAll, toString, wait, wait, waitare, areAtLeast, areAtLeastOne, areAtMost, areExactly, areNot, containsAll, containsAnyElementsOf, containsAnyOf, containsExactlyElementsOf, containsExactlyInAnyOrderElementsOf, containsNull, containsOnlyElementsOf, containsOnlyNulls, containsSequence, containsSubsequence, doesNotContainAnyElementsOf, doesNotContainNull, doesNotContainSequence, doesNotContainSubsequence, doesNotHaveAnyElementsOfTypes, doesNotHaveDuplicates, doNotHave, endsWith, hasAtLeastOneElementOfType, hasOnlyElementsOfType, hasOnlyElementsOfTypes, hasSameElementsAs, have, haveAtLeast, haveAtLeastOne, haveAtMost, haveExactly, isSubsetOfhasSameSizeAs, hasSameSizeAs, hasSize, isEmpty, isNotEmpty, isNullOrEmpty@SafeVarargs public final ListAssert<ELEMENT> contains(ELEMENT... values)
AbstractIterableAssertExample:
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");
If you want to specify the elements to check with an Iterable, use containsAll(Iterable) instead.
contains in interface ObjectEnumerableAssert<ListAssert<ELEMENT>,ELEMENT>contains in class AbstractIterableAssert<ListAssert<ELEMENT>,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>values - the given values.this assertion object.@SafeVarargs public final ListAssert<ELEMENT> containsOnly(ELEMENT... values)
AbstractIterableAssertIf you need to check exactly the elements and their duplicates use:
containsExactly(Object...) if the order does mattercontainsExactlyInAnyOrder(Object...) if the order does not matterExample:
Iterable<String> abc = newArrayList("a", "b", "c");
// assertions will pass as order does not matter
assertThat(abc).containsOnly("c", "b", "a");
// duplicates are ignored
assertThat(abc).containsOnly("a", "a", "b", "c", "c");
// ... on both actual and expected values
assertThat(asList("a", "a", "b")).containsOnly("a", "b")
.containsOnly("a", "a", "b", "b");
// assertion will fail because "c" is missing in the given values
assertThat(abc).containsOnly("a", "b");
// assertion will fail because "d" is missing in abc (use isSubsetOf if you want this assertion to pass)
assertThat(abc).containsOnly("a", "b", "c", "d");
If you need to check that actual is a subset of the given values, use ObjectEnumerableAssert.isSubsetOf(Object...).
If you want to specify the elements to check with an Iterable, use containsOnlyElementsOf(Iterable) instead.
containsOnly in interface ObjectEnumerableAssert<ListAssert<ELEMENT>,ELEMENT>containsOnly in class AbstractIterableAssert<ListAssert<ELEMENT>,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>values - the given values.this assertion object.@SafeVarargs public final ListAssert<ELEMENT> containsOnlyOnce(ELEMENT... values)
AbstractIterableAssertExamples :
// 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");containsOnlyOnce in interface ObjectEnumerableAssert<ListAssert<ELEMENT>,ELEMENT>containsOnlyOnce in class AbstractIterableAssert<ListAssert<ELEMENT>,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>values - the given values.this assertion object.@SafeVarargs public final ListAssert<ELEMENT> containsExactly(ELEMENT... values)
AbstractIterableAssertHashSet, 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);
If you want to specify the elements to check with an Iterable, use containsExactlyElementsOf(Iterable) instead.
containsExactly in interface ObjectEnumerableAssert<ListAssert<ELEMENT>,ELEMENT>containsExactly in class AbstractIterableAssert<ListAssert<ELEMENT>,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>values - the given values.this assertion object.@SafeVarargs public final ListAssert<ELEMENT> containsExactlyInAnyOrder(ELEMENT... values)
AbstractIterableAssertExample:
// 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);
If you want to specify the elements to check with an Iterable, use containsExactlyInAnyOrderElementsOf(Iterable) instead.
containsExactlyInAnyOrder in interface ObjectEnumerableAssert<ListAssert<ELEMENT>,ELEMENT>containsExactlyInAnyOrder in class AbstractIterableAssert<ListAssert<ELEMENT>,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>values - the given values.this assertion object.@SafeVarargs public final ListAssert<ELEMENT> isSubsetOf(ELEMENT... values)
AbstractIterableAssertExample:
// 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)
.isSubsetOf(vilya, nenya, narya, dwarfRing);
// assertions will fail:
assertThat(elvesRings).isSubsetOf(vilya, nenya);
assertThat(elvesRings).isSubsetOf(vilya, nenya, dwarfRing);
If you want to specify the set of elements an Iterable, use isSubsetOf(Iterable) instead.
isSubsetOf in interface ObjectEnumerableAssert<ListAssert<ELEMENT>,ELEMENT>isSubsetOf in class AbstractIterableAssert<ListAssert<ELEMENT>,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>values - the values that should be used for checking the elements of actual.@SafeVarargs public final ListAssert<ELEMENT> containsSequence(ELEMENT... sequence)
AbstractIterableAssert
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)
.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);
If you want to specify the sequence to check with an Iterable, use containsSequence(Iterable) instead.
containsSequence in interface ObjectEnumerableAssert<ListAssert<ELEMENT>,ELEMENT>containsSequence in class AbstractIterableAssert<ListAssert<ELEMENT>,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>sequence - the sequence of objects to look for.@SafeVarargs public final ListAssert<ELEMENT> doesNotContainSequence(ELEMENT... sequence)
AbstractIterableAssert
Use ObjectEnumerableAssert.doesNotContainSubsequence(Object...) to also ensure the sequence does not exist with 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, the elements order is correct but there is a value between them (nenya)
assertThat(elvesRings).doesNotContainSequence(vilya, narya)
.doesNotContainSequence(nenya, vilya);
// assertions will fail
assertThat(elvesRings).doesNotContainSequence(vilya, nenya);
assertThat(elvesRings).doesNotContainSequence(nenya, narya);
If you want to specify the sequence not to find with an Iterable, use doesNotContainSequence(Iterable) instead.
doesNotContainSequence in interface ObjectEnumerableAssert<ListAssert<ELEMENT>,ELEMENT>doesNotContainSequence in class AbstractIterableAssert<ListAssert<ELEMENT>,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>sequence - the sequence of objects to look for.@SafeVarargs public final ListAssert<ELEMENT> containsSubsequence(ELEMENT... sequence)
AbstractIterableAssertExample:
// 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)
.containsSubsequence(vilya, narya);
// assertion will fail
assertThat(elvesRings).containsSubsequence(nenya, vilya);
If you want to specify the elements of the subsequence to check with an Iterable, use containsSubsequence(Iterable) instead.
containsSubsequence in interface ObjectEnumerableAssert<ListAssert<ELEMENT>,ELEMENT>containsSubsequence in class AbstractIterableAssert<ListAssert<ELEMENT>,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>sequence - the sequence of objects to look for.@SafeVarargs public final ListAssert<ELEMENT> doesNotContainSubsequence(ELEMENT... sequence)
AbstractIterableAssertExample:
// 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).doesNotContainSubsequence(nenya, vilya)
.doesNotContainSubsequence(narya, vilya);
// assertion will fail
assertThat(elvesRings).doesNotContainSubsequence(vilya, nenya);
assertThat(elvesRings).doesNotContainSubsequence(vilya, narya);
If you want to specify the subsequence not to find with an Iterable, use doesNotContainSubsequence(Iterable) instead.
doesNotContainSubsequence in interface ObjectEnumerableAssert<ListAssert<ELEMENT>,ELEMENT>doesNotContainSubsequence in class AbstractIterableAssert<ListAssert<ELEMENT>,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>sequence - the sequence of objects to look for.@SafeVarargs public final ListAssert<ELEMENT> doesNotContain(ELEMENT... values)
ObjectEnumerableAssertExample:
// 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")
.doesNotContain("d", "e");
// assertions will fail
assertThat(abc).doesNotContain("a");
assertThat(abc).doesNotContain("a", "b");
assertThat(abc).doesNotContain("c", "d");
If you want to specify the elements not to find with an Iterable, use doesNotContainAnyElementsOf(Iterable) instead.
doesNotContain in interface ObjectEnumerableAssert<ListAssert<ELEMENT>,ELEMENT>doesNotContain in class AbstractIterableAssert<ListAssert<ELEMENT>,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>values - the given values.this assertion object.@SafeVarargs public final ListAssert<ELEMENT> startsWith(ELEMENT... sequence)
AbstractIterableAssertObjectEnumerableAssert.containsSequence(Object...)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")
.startsWith("a", "b");
// assertion will fail
assertThat(abc).startsWith("c");startsWith in interface ObjectEnumerableAssert<ListAssert<ELEMENT>,ELEMENT>startsWith in class AbstractIterableAssert<ListAssert<ELEMENT>,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>sequence - the sequence of objects to look for.@SafeVarargs public final ListAssert<ELEMENT> endsWith(ELEMENT first, ELEMENT... rest)
AbstractIterableAssertObjectEnumerableAssert.containsSequence(Object...)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")
.endsWith("b", "c");
// assertions will fail
assertThat(abc).endsWith("a");
assertThat(abc).endsWith("a", "b");endsWith in interface ObjectEnumerableAssert<ListAssert<ELEMENT>,ELEMENT>endsWith in class AbstractIterableAssert<ListAssert<ELEMENT>,List<? extends ELEMENT>,ELEMENT,ObjectAssert<ELEMENT>>rest - the sequence of objects to look for.Copyright © 2013–2018 AssertJ. All rights reserved.