AbstractListAssert (AssertJ fluent assertions 3.5.2 API)

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>

Type Parameters:

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

ACTUAL - the type of the "actual" value.

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

ELEMENT_ASSERT - used for navigational assertions to return the right assert type.

All Implemented Interfaces:

Assert<SELF,ACTUAL>, Descriptable<SELF>, EnumerableAssert<SELF,ELEMENT>, ExtensionPoints<SELF,ACTUAL>, IndexedObjectEnumerableAssert<SELF,ELEMENT>, ObjectEnumerableAssert<SELF,ELEMENT>

Direct Known Subclasses:

ClassBasedNavigableListAssert, FactoryBasedNavigableListAssert
```
public abstract class AbstractListAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
extends AbstractIterableAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>
implements IndexedObjectEnumerableAssert<SELF,ELEMENT>
```
Base class for all implementations of assertions for Lists.

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

AbstractListAssert(ACTUAL actual, Class<?> selfType)

Constructors
Constructor and Description
`AbstractListAssert(ACTUAL actual, Class<?> selfType)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`SELF`	`as(Description description)` Sets the description of the assertion that is going to be called after.
`SELF`	`as(String description, Object... args)` Sets the description of the assertion that is going to be called after.
`SELF`	`contains(ELEMENT value, Index index)` Verifies that the actual group contains the given object at the given index.
`SELF`	`describedAs(Description description)` Sets the description of the assertion that is going to be called after.
`SELF`	`describedAs(String description, Object... args)` Sets the description of the assertion that is going to be called after.
`SELF`	`doesNotContain(ELEMENT value, Index index)` Verifies that the actual group does not contain the given object at the given index.
`SELF`	`doesNotHave(Condition<? super ACTUAL> condition)` Verifies that the actual value does not satisfy the given condition.
`SELF`	`doesNotHaveSameClassAs(Object other)` Verifies that the actual value does not have the same class as the given object.
`SELF`	`has(Condition<? super ACTUAL> condition)` Verifies that the actual value satisfies the given condition.
`SELF`	`has(Condition<? super ELEMENT> condition, Index index)` Verifies that the actual object at the given index in the actual group satisfies the given condition.
`SELF`	`hasSameClassAs(Object other)` Verifies that the actual value has the same class as the given object.
`SELF`	`hasToString(String expectedToString)` Verifies that actual `actual.toString()` is equal to the given `String`.
`SELF`	`is(Condition<? super ACTUAL> condition)` Verifies that the actual value satisfies the given condition.
`SELF`	`is(Condition<? super ELEMENT> condition, Index index)` Verifies that the actual object at the given index in the actual group satisfies the given condition.
`SELF`	`isEqualTo(Object expected)` Verifies that the actual value is equal to the given one.
`SELF`	`isExactlyInstanceOf(Class<?> type)` Verifies that the actual value is exactly an instance of the given type.
`SELF`	`isIn(Iterable<?> values)` Verifies that the actual value is present in the given values.
`SELF`	`isIn(Object... values)` Verifies that the actual value is present in the given array of values.
`SELF`	`isInstanceOf(Class<?> type)` Verifies that the actual value is an instance of the given type.
`SELF`	`isInstanceOfAny(Class<?>... types)` Verifies that the actual value is an instance of any of the given types.
`SELF`	`isNot(Condition<? super ACTUAL> condition)` Verifies that the actual value does not satisfy the given condition.
`SELF`	`isNotEqualTo(Object other)` Verifies that the actual value is not equal to the given one.
`SELF`	`isNotExactlyInstanceOf(Class<?> type)` Verifies that the actual value is not exactly an instance of given type.
`SELF`	`isNotIn(Iterable<?> values)` Verifies that the actual value is not present in the given values.
`SELF`	`isNotIn(Object... values)` Verifies that the actual value is not present in the given array of values.
`SELF`	`isNotInstanceOf(Class<?> type)` Verifies that the actual value is not an instance of the given type.
`SELF`	`isNotInstanceOfAny(Class<?>... types)` Verifies that the actual value is not an instance of any of the given types.
`SELF`	`isNotNull()` Verifies that the actual value is not `null`.
`SELF`	`isNotOfAnyClassIn(Class<?>... types)` Verifies that the actual value type is not in given types.
`SELF`	`isNotSameAs(Object other)` Verifies that the actual value is not the same as the given one, ie using == comparison.
`SELF`	`isOfAnyClassIn(Class<?>... types)` Verifies that the actual value type is in given types.
`SELF`	`isSameAs(Object expected)` Verifies that the actual value is the same as the given one, ie using == comparison.
`SELF`	`isSorted()` Verifies that the actual list is sorted into ascending order according to the natural ordering of its elements.
`SELF`	`isSortedAccordingTo(Comparator<? super ELEMENT> comparator)` Verifies that the actual list is sorted according to the given comparator. Empty lists are considered sorted whatever the comparator is. One element lists are considered sorted if element is compatible with comparator.
`SELF`	`overridingErrorMessage(String newErrorMessage, Object... args)` Overrides AssertJ default error message by the given one.
`SELF`	`usingComparator(Comparator<? super ACTUAL> customComparator)` Use given custom comparator instead of relying on actual type A equals method for incoming assertion checks.
`protected SELF`	`usingComparisonStrategy(ComparisonStrategy comparisonStrategy)`
`SELF`	`usingDefaultComparator()` Revert to standard comparison for incoming assertion checks.
`SELF`	`usingDefaultElementComparator()` Revert to standard comparison for incoming assertion group element checks.
`SELF`	`usingElementComparator(Comparator<? super ELEMENT> customComparator)` Use given custom comparator instead of relying on actual type A `equals` method to compare group elements for incoming assertion checks.
`SELF`	`withFailMessage(String newErrorMessage, Object... args)` Alternative method for `AbstractAssert.overridingErrorMessage(java.lang.String, java.lang.Object...)`
`SELF`	`withThreadDumpOnError()` In case of assertion error, the thread dump will be printed on `System.err`.

Methods inherited from class org.assertj.core.api.AbstractIterableAssert
allMatch, are, areAtLeast, areAtLeastOne, areAtMost, areExactly, areNot, contains, containsAll, containsExactly, containsExactlyElementsOf, containsExactlyInAnyOrder, containsNull, containsOnly, containsOnlyElementsOf, containsOnlyOnce, containsSequence, containsSubsequence, doesNotContain, doesNotContainAnyElementsOf, doesNotContainNull, doesNotHaveDuplicates, doNotHave, element, endsWith, extracting, extracting, extracting, extracting, extracting, extractingResultOf, extractingResultOf, filteredOn, filteredOn, filteredOn, filteredOn, filteredOnNull, first, flatExtracting, flatExtracting, flatExtracting, flatExtracting, hasAtLeastOneElementOfType, hasOnlyElementsOfType, hasOnlyOneElementSatisfying, hasSameElementsAs, hasSameSizeAs, hasSameSizeAs, hasSize, have, haveAtLeast, haveAtLeastOne, haveAtMost, haveExactly, inBinary, inHexadecimal, isEmpty, isNotEmpty, isNullOrEmpty, isSubsetOf, isSubsetOf, last, navigationDescription, size, startsWith, toAssert, usingComparatorForElementFieldsWithNames, usingComparatorForElementFieldsWithType, usingElementComparatorIgnoringFields, usingElementComparatorOnFields, usingFieldByFieldElementComparator, usingRecursiveFieldByFieldElementComparator

Methods inherited from class org.assertj.core.api.AbstractAssert
asList, asString, descriptionText, equals, failWithMessage, getWritableAssertionInfo, hashCode, isNull, matches, matches, satisfies, setCustomRepresentation, throwAssertionError, 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.EnumerableAssert
hasSameSizeAs, hasSameSizeAs, hasSize, isEmpty, isNotEmpty, isNullOrEmpty

- Constructor Detail
  - AbstractListAssert
```
public AbstractListAssert(ACTUAL actual,
                          Class<?> selfType)
```
- Method Detail
  - contains
```
public SELF contains(ELEMENT value,
                     Index index)
```
    Verifies that the actual group contains the given object at the given index.
    Example:
```
 List<Ring> elvesRings = newArrayList(vilya, nenya, narya);

 // assertions will pass
 assertThat(elvesRings).contains(vilya, atIndex(0));
 assertThat(elvesRings).contains(nenya, atIndex(1));
 assertThat(elvesRings).contains(narya, atIndex(2));

 // assertions will fail
 assertThat(elvesRings).contains(vilya, atIndex(1));
 assertThat(elvesRings).contains(nenya, atIndex(2));
 assertThat(elvesRings).contains(narya, atIndex(0));
```
    Specified by:
    
    contains in interface IndexedObjectEnumerableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ELEMENT>
    
    Parameters:
    
    value - the object to look for.
    
    index - the index where the object should be stored in the actual group.
    
    Returns:
    
    this assertion object.
  - doesNotContain
```
public SELF doesNotContain(ELEMENT value,
                           Index index)
```
    Verifies that the actual group does not contain the given object at the given index.
    Example:
```
 List<Ring> elvesRings = newArrayList(vilya, nenya, narya);

 // assertions will pass
 assertThat(elvesRings).contains(vilya, atIndex(1));
 assertThat(elvesRings).contains(nenya, atIndex(2));
 assertThat(elvesRings).contains(narya, atIndex(0));

 // assertions will fail
 assertThat(elvesRings).contains(vilya, atIndex(0));
 assertThat(elvesRings).contains(nenya, atIndex(1));
 assertThat(elvesRings).contains(narya, atIndex(2));
```
    Specified by:
    
    doesNotContain in interface IndexedObjectEnumerableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ELEMENT>
    
    Parameters:
    
    value - the object to look for.
    
    index - the index where the object should not be stored in the actual group.
    
    Returns:
    
    this assertion object.
  - has
```
public SELF has(Condition<? super ELEMENT> condition,
                Index index)
```
    Verifies that the actual object at the given index in the actual group satisfies the given condition.
    
    Parameters:
    
    condition - the given condition.
    
    index - the index where the object should be stored in the actual group.
    
    Returns:
    
    this assertion object.
    
    Throws:
    
    AssertionError - if the given List is null or empty.
    
    NullPointerException - if the given Index is null.
    
    IndexOutOfBoundsException - if the value of the given Index is equal to or greater than the size of the given List.
    
    NullPointerException - if the given Condition is null.
    
    AssertionError - if the value in the given List at the given index does not satisfy the given Condition .
  - is
```
public SELF is(Condition<? super ELEMENT> condition,
               Index index)
```
    Verifies that the actual object at the given index in the actual group satisfies the given condition.
    
    Parameters:
    
    condition - the given condition.
    
    index - the index where the object should be stored in the actual group.
    
    Returns:
    
    this assertion object.
    
    Throws:
    
    AssertionError - if the given List is null or empty.
    
    NullPointerException - if the given Index is null.
    
    IndexOutOfBoundsException - if the value of the given Index is equal to or greater than the size of the given List.
    
    NullPointerException - if the given Condition is null.
    
    AssertionError - if the value in the given List at the given index does not satisfy the given Condition .
  - isSorted
```
public SELF isSorted()
```
    Verifies that the actual list is sorted into ascending order according to the natural ordering of its elements.
    All list elements must implement the Comparable interface and must be mutually comparable (that is, e1.compareTo(e2) must not throw a ClassCastException for any elements e1 and e2 in the list), examples :
    - a list composed of {"a1", "a2", "a3"} is ok because the element type (String) is Comparable
    - a list composed of Rectangle {r1, r2, r3} is NOT ok because Rectangle is not Comparable
    - a list composed of {True, "abc", False} is NOT ok because elements are not mutually comparable
    Empty lists are considered sorted.
    Unique element lists are considered sorted unless the element type is not Comparable.
    Returns:
    
    this assertion object.
    
    Throws:
    
    AssertionError - if the actual list is not sorted into ascending order according to the natural ordering of its elements.
    
    AssertionError - if the actual list is null.
    
    AssertionError - if the actual list element type does not implement Comparable.
    
    AssertionError - if the actual list elements are not mutually Comparable.
  - isSortedAccordingTo
```
public SELF isSortedAccordingTo(Comparator<? super ELEMENT> comparator)
```
    Verifies that the actual list is sorted according to the given comparator.
    Empty lists are considered sorted whatever the comparator is.
    One element lists are considered sorted if element is compatible with comparator.
    
    Parameters:
    
    comparator - the Comparator used to compare list elements
    
    Returns:
    
    this assertion object.
    
    Throws:
    
    AssertionError - if the actual list is not sorted according to the given comparator.
    
    AssertionError - if the actual list is null.
    
    NullPointerException - if the given comparator is null.
    
    AssertionError - if the actual list elements are not mutually comparable according to given Comparator.
  - usingElementComparator
```
public SELF usingElementComparator(Comparator<? super ELEMENT> customComparator)
```
    Description copied from class: AbstractIterableAssert
    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<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ELEMENT>
    
    Overrides:
    
    usingElementComparator in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
    
    Parameters:
    
    customComparator - the comparator to use for incoming assertion checks.
    
    Returns:
    
    this assertion object.
  - usingDefaultElementComparator
```
public SELF usingDefaultElementComparator()
```
    Description copied from class: AbstractIterableAssert
    
    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<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ELEMENT>
    
    Overrides:
    
    usingDefaultElementComparator in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
    
    Returns:
    
    this assertion object.
  - usingComparisonStrategy
```
protected SELF usingComparisonStrategy(ComparisonStrategy comparisonStrategy)
```
    Overrides:
    
    usingComparisonStrategy in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
  - as
```
public SELF as(String description,
               Object... args)
```
    Description copied from class: AbstractAssert
    Sets the description of the assertion that is going to be called after.
    You must set it before calling the assertion otherwise it is ignored as the failing assertion breaks the chained call by throwing an AssertionError.
    The description follows String.format(String, Object...) syntax.
    Example :
```
 try {
   // set a bad age to Mr Frodo which is really 33 years old.
   frodo.setAge(50);
   // specify a test description (call as() before the assertion !), it supports String format syntax.
   assertThat(frodo.getAge()).as("check %s's age", frodo.getName()).isEqualTo(33);
 } catch (AssertionError e) {
   assertThat(e).hasMessage("[check Frodo's age] expected:<[33]> but was:<[50]>");
 }
```
    Specified by:
    
    as in interface Descriptable<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>>
    
    Overrides:
    
    as in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
    
    Parameters:
    
    description - the new description to set.
    
    args - optional parameter if description is a format String.
    
    Returns:
    
    this object.
    
    See Also:
    
    Descriptable.describedAs(String, Object...)
  - as
```
public SELF as(Description description)
```
    Description copied from class: AbstractAssert
    
    Sets the description of the assertion that is going to be called after.
    You must set it before calling the assertion otherwise it is ignored as the failing assertion breaks the chained call by throwing an AssertionError.
    This overloaded version of "describedAs" offers more flexibility than the one taking a String by allowing users to pass their own implementation of a description. For example, a description that creates its value lazily, only when an assertion failure occurs.
    
    Specified by:
    
    as in interface Descriptable<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>>
    
    Overrides:
    
    as in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
    
    Parameters:
    
    description - the new description to set.
    
    Returns:
    
    this object.
    
    See Also:
    
    Descriptable.describedAs(Description)
  - describedAs
```
public SELF describedAs(Description description)
```
    Description copied from class: AbstractAssert
    
    Sets the description of the assertion that is going to be called after.
    You must set it before calling the assertion otherwise it is ignored as the failing assertion breaks the chained call by throwing an AssertionError.
    This overloaded version of "describedAs" offers more flexibility than the one taking a String by allowing users to pass their own implementation of a description. For example, a description that creates its value lazily, only when an assertion failure occurs.
    
    Specified by:
    
    describedAs in interface Descriptable<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>>
    
    Overrides:
    
    describedAs in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
    
    Parameters:
    
    description - the new description to set.
    
    Returns:
    
    this object.
  - describedAs
```
public SELF describedAs(String description,
                        Object... args)
```
    Description copied from class: AbstractAssert
    
    Sets the description of the assertion that is going to be called after.
    You must set it before calling the assertion otherwise it is ignored as the failing assertion breaks the chained call by throwing an AssertionError.
    Alias for Descriptable.as(String, Object...) since "as" is a keyword in Groovy.
    
    Specified by:
    
    describedAs in interface Descriptable<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>>
    
    Overrides:
    
    describedAs in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
    
    Parameters:
    
    description - the new description to set.
    
    Returns:
    
    this object.
  - doesNotHave
```
public SELF doesNotHave(Condition<? super ACTUAL> condition)
```
    Description copied from class: AbstractAssert
    
    Verifies that the actual value does not satisfy the given condition. This method is an alias for ExtensionPoints.isNot(Condition).
    
    Specified by:
    
    doesNotHave in interface ExtensionPoints<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>>
    
    Overrides:
    
    doesNotHave in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
    
    Parameters:
    
    condition - the given condition.
    
    Returns:
    
    this ExtensionPoints object.
    
    See Also:
    
    ExtensionPoints.isNot(Condition)
  - doesNotHaveSameClassAs
```
public SELF doesNotHaveSameClassAs(Object other)
```
    Description copied from class: AbstractAssert
    Verifies that the actual value does not have the same class as the given object.
    Example:
```
 // assertions will pass
 assertThat(1).doesNotHaveSameClassAs("abc");
 assertThat(new ArrayList<String>()).doesNotHaveSameClassAs(new LinkedList<String>());
 
 // assertions will fail
 assertThat(1).doesNotHaveSameClassAs(2);
 assertThat("abc").doesNotHaveSameClassAs("123");
 assertThat(new ArrayList<String>()).doesNotHaveSameClassAs(new ArrayList<Integer>());
```
    Specified by:
    
    doesNotHaveSameClassAs in interface Assert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>>
    
    Overrides:
    
    doesNotHaveSameClassAs in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
    
    Parameters:
    
    other - the object to check type against.
    
    Returns:
    
    this assertion object.
  - has
```
public SELF has(Condition<? super ACTUAL> condition)
```
    Description copied from class: AbstractAssert
    
    Verifies that the actual value satisfies the given condition. This method is an alias for ExtensionPoints.is(Condition) .
    
    Specified by:
    
    has in interface ExtensionPoints<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>>
    
    Overrides:
    
    has in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
    
    Parameters:
    
    condition - the given condition.
    
    Returns:
    
    this ExtensionPoints object.
    
    See Also:
    
    ExtensionPoints.is(Condition)
  - hasSameClassAs
```
public SELF hasSameClassAs(Object other)
```
    Description copied from class: AbstractAssert
    Verifies that the actual value has the same class as the given object.
    Example:
```
 // assertions will pass
 assertThat(1).hasSameClassAs(2);
 assertThat("abc").hasSameClassAs("123");
 assertThat(new ArrayList<String>()).hasSameClassAs(new ArrayList<Integer>());
 
 // assertions will fail
 assertThat(1).hasSameClassAs("abc");
 assertThat(new ArrayList<String>()).hasSameClassAs(new LinkedList<String>());
```
    Specified by:
    
    hasSameClassAs in interface Assert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>>
    
    Overrides:
    
    hasSameClassAs in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
    
    Parameters:
    
    other - the object to check type against.
    
    Returns:
    
    this assertion object.
  - hasToString
```
public SELF hasToString(String expectedToString)
```
    Description copied from class: AbstractAssert
    Verifies that actual actual.toString() is equal to the given String.
    Example :
```
 CartoonCaracter homer = new CartoonCaracter("Homer");

 // Instead of writing ...  
 assertThat(homer.toString()).isEqualTo("Homer");
 // ... you can simply write: 
 assertThat(homer).hasToString("Homer");
```
    Specified by:
    
    hasToString in interface Assert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>>
    
    Overrides:
    
    hasToString in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
    
    Parameters:
    
    expectedToString - the expected String description of actual.
    
    Returns:
    
    this assertion object.
  - is
```
public SELF is(Condition<? super ACTUAL> condition)
```
    Description copied from class: AbstractAssert
    
    Verifies that the actual value satisfies the given condition. This method is an alias for ExtensionPoints.has(Condition).
    
    Specified by:
    
    is in interface ExtensionPoints<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>>
    
    Overrides:
    
    is in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
    
    Parameters:
    
    condition - the given condition.
    
    Returns:
    
    this ExtensionPoints object.
    
    See Also:
    
    ExtensionPoints.is(Condition)
  - isEqualTo
```
public SELF 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<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>>
    
    Overrides:
    
    isEqualTo in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
    
    Parameters:
    
    expected - the given value to compare the actual value to.
    
    Returns:
    
    this assertion object.
  - isExactlyInstanceOf
```
public SELF 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<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>>
    
    Overrides:
    
    isExactlyInstanceOf in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
    
    Parameters:
    
    type - the type to check the actual value against.
    
    Returns:
    
    this assertion object.
  - isIn
```
public SELF isIn(Iterable<?> values)
```
    Description copied from class: AbstractAssert
    Verifies that the actual value is present in the given values.
    Example:
```
 Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya);
 
 // assertion will pass:
 assertThat(nenya).isIn(elvesRings);
 
 // assertion will fail:
 assertThat(oneRing).isIn(elvesRings);
```
    Specified by:
    
    isIn in interface Assert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>>
    
    Overrides:
    
    isIn in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
    
    Parameters:
    
    values - the given iterable to search the actual value in.
    
    Returns:
    
    this assertion object.
  - isIn
```
public SELF isIn(Object... values)
```
    Description copied from class: AbstractAssert
    Verifies that the actual value is present in the given array of values.
    Example:
```
 Ring[] elvesRings = new Ring[] { vilya, nenya, narya };
 
 // assertion will pass:
 assertThat(nenya).isIn(elvesRings);
 
 // assertion will fail:
 assertThat(oneRing).isIn(elvesRings);
```
    Specified by:
    
    isIn in interface Assert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>>
    
    Overrides:
    
    isIn in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
    
    Parameters:
    
    values - the given array to search the actual value in.
    
    Returns:
    
    this assertion object.
  - isInstanceOf
```
public SELF 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<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>>
    
    Overrides:
    
    isInstanceOf in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
    
    Parameters:
    
    type - the type to check the actual value against.
    
    Returns:
    
    this assertion object.
  - isInstanceOfAny
```
public SELF 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<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>>
    
    Overrides:
    
    isInstanceOfAny in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
    
    Parameters:
    
    types - the types to check the actual value against.
    
    Returns:
    
    this assertion object.
  - isNot
```
public SELF isNot(Condition<? super ACTUAL> condition)
```
    Description copied from class: AbstractAssert
    
    Verifies that the actual value does not satisfy the given condition. This method is an alias for ExtensionPoints.doesNotHave(Condition).
    
    Specified by:
    
    isNot in interface ExtensionPoints<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>>
    
    Overrides:
    
    isNot in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
    
    Parameters:
    
    condition - the given condition.
    
    Returns:
    
    this ExtensionPoints object.
    
    See Also:
    
    ExtensionPoints.isNot(Condition)
  - isNotEqualTo
```
public SELF isNotEqualTo(Object other)
```
    Description copied from class: AbstractAssert
    Verifies that the actual value is not equal to the given one.
    Example:
```
 // assertions will pass
 assertThat("abc").isNotEqualTo("123");
 assertThat(new ArrayList<String>()).isNotEqualTo(1);
 
 // assertions will fail
 assertThat("abc").isNotEqualTo("abc");
 assertThat(new HashMap<String, Integer>()).isNotEqualTo(new HashMap<String, Integer>());
```
    Specified by:
    
    isNotEqualTo in interface Assert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>>
    
    Overrides:
    
    isNotEqualTo in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
    
    Parameters:
    
    other - the given value to compare the actual value to.
    
    Returns:
    
    this assertion object.
  - isNotExactlyInstanceOf
```
public SELF 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<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>>
    
    Overrides:
    
    isNotExactlyInstanceOf in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
    
    Parameters:
    
    type - the type to check the actual value against.
    
    Returns:
    
    this assertion object.
  - isNotIn
```
public SELF isNotIn(Iterable<?> values)
```
    Description copied from class: AbstractAssert
    Verifies that the actual value is not present in the given values.
    Example:
```
 Iterable<Ring> elvesRings = newArrayList(vilya, nenya, narya);
 
 // assertion will pass:
 assertThat(oneRing).isNotIn(elvesRings);
 
 // assertion will fail:
 assertThat(nenya).isNotIn(elvesRings);
```
    Specified by:
    
    isNotIn in interface Assert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>>
    
    Overrides:
    
    isNotIn in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
    
    Parameters:
    
    values - the given iterable to search the actual value in.
    
    Returns:
    
    this assertion object.
  - isNotIn
```
public SELF isNotIn(Object... values)
```
    Description copied from class: AbstractAssert
    Verifies that the actual value is not present in the given array of values.
    Example:
```
 Ring[] elvesRings = new Ring[] { vilya, nenya, narya };
 
 // assertion will pass:
 assertThat(oneRing).isNotIn(elvesRings);
 
 // assertion will fail:
 assertThat(nenya).isNotIn(elvesRings);
```
    Specified by:
    
    isNotIn in interface Assert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>>
    
    Overrides:
    
    isNotIn in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
    
    Parameters:
    
    values - the given array to search the actual value in.
    
    Returns:
    
    this assertion object.
  - isNotInstanceOf
```
public SELF 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<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>>
    
    Overrides:
    
    isNotInstanceOf in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
    
    Parameters:
    
    type - the type to check the actual value against.
    
    Returns:
    
    this assertion object.
  - isNotInstanceOfAny
```
public SELF 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<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>>
    
    Overrides:
    
    isNotInstanceOfAny in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
    
    Parameters:
    
    types - the types to check the actual value against.
    
    Returns:
    
    this assertion object.
  - isNotOfAnyClassIn
```
public SELF 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<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>>
    
    Overrides:
    
    isNotOfAnyClassIn in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
    
    Parameters:
    
    types - the types to check the actual value against.
    
    Returns:
    
    this assertion object.
  - isNotNull
```
public SELF isNotNull()
```
    Description copied from class: AbstractAssert
    Verifies that the actual value is not null.
    Example:
```
 // assertion will pass
 assertThat("abc").isNotNull();
 assertThat(new HashMap<String, Integer>()).isNotNull();
 
 // assertion will fail
 String value = null;
 assertThat(value).isNotNull();
```
    Specified by:
    
    isNotNull in interface Assert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>>
    
    Overrides:
    
    isNotNull in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
    
    Returns:
    
    this assertion object.
  - isNotSameAs
```
public SELF isNotSameAs(Object other)
```
    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<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>>
    
    Overrides:
    
    isNotSameAs in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
    
    Parameters:
    
    other - the given value to compare the actual value to.
    
    Returns:
    
    this assertion object.
  - isOfAnyClassIn
```
public SELF 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<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>>
    
    Overrides:
    
    isOfAnyClassIn in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
    
    Parameters:
    
    types - the types to check the actual value against.
    
    Returns:
    
    this assertion object.
  - isSameAs
```
public SELF 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<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>>
    
    Overrides:
    
    isSameAs in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
    
    Parameters:
    
    expected - the given value to compare the actual value to.
    
    Returns:
    
    this assertion object.
  - overridingErrorMessage
```
public SELF overridingErrorMessage(String newErrorMessage,
                                   Object... args)
```
    Description copied from class: AbstractAssert
    Overrides AssertJ default error message by the given one.
    The new error message is built using String.format(String, Object...) if you provide args parameter (if you don't, the error message is taken as it is).
    Example :
```
assertThat(player.isRookie()).overridingErrorMessage("Expecting Player <%s> to be a rookie but was not.", player)
                              .isTrue();
```
    Overrides:
    
    overridingErrorMessage in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
    
    Parameters:
    
    newErrorMessage - the error message that will replace the default one provided by Assertj.
    
    args - the args used to fill error message as in String.format(String, Object...).
    
    Returns:
    
    this assertion object.
  - usingDefaultComparator
```
public SELF usingDefaultComparator()
```
    Description copied from class: AbstractAssert
    
    Revert to standard comparison for incoming assertion checks.
    This method should be used to disable a custom comparison strategy set by calling Assert.usingComparator(Comparator).
    
    Specified by:
    
    usingDefaultComparator in interface Assert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>>
    
    Overrides:
    
    usingDefaultComparator in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
    
    Returns:
    
    this assertion object.
  - usingComparator
```
public SELF usingComparator(Comparator<? super ACTUAL> customComparator)
```
    Description copied from class: AbstractAssert
    Use given custom comparator instead of relying on actual type A equals method 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 :
```
 // frodo and sam are instances of Character with Hobbit race (obviously :).
 // raceComparator implements Comparator<Character> 
 assertThat(frodo).usingComparator(raceComparator).isEqualTo(sam);
```
    Specified by:
    
    usingComparator in interface Assert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>>
    
    Overrides:
    
    usingComparator in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
    
    Parameters:
    
    customComparator - the comparator to use for incoming assertion checks.
    
    Returns:
    
    this assertion object.
  - withFailMessage
```
public SELF withFailMessage(String newErrorMessage,
                            Object... args)
```
    Description copied from class: AbstractAssert
    
    Alternative method for AbstractAssert.overridingErrorMessage(java.lang.String, java.lang.Object...)
    
    Overrides:
    
    withFailMessage in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
    
    Parameters:
    
    newErrorMessage - the error message that will replace the default one provided by Assertj.
    
    args - the args used to fill error message as in String.format(String, Object...).
    
    Returns:
    
    this assertion object.
  - withThreadDumpOnError
```
public SELF withThreadDumpOnError()
```
    Description copied from class: AbstractAssert
    In case of assertion error, the thread dump will be printed on System.err.
    Example :
```
 assertThat("Messi").withThreadDumpOnError().isEqualTo("Ronaldo");
```
    will print the thread dump, something looking like:
```
 "JDWP Command Reader"
 	java.lang.Thread.State: RUNNABLE

 "JDWP Event Helper Thread"
 	java.lang.Thread.State: RUNNABLE

 "JDWP Transport Listener: dt_socket"
 	java.lang.Thread.State: RUNNABLE

 "Signal Dispatcher"
 	java.lang.Thread.State: RUNNABLE

 "Finalizer"
 	java.lang.Thread.State: WAITING
 		at java.lang.Object.wait(Native Method)
 		at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:135)
 		at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:151)
 		at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:189)

 "Reference Handler"
 	java.lang.Thread.State: WAITING
 		at java.lang.Object.wait(Native Method)
 		at java.lang.Object.wait(Object.java:503)
 		at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:133)

 "main"
 	java.lang.Thread.State: RUNNABLE
 		at sun.management.ThreadImpl.dumpThreads0(Native Method)
 		at sun.management.ThreadImpl.dumpAllThreads(ThreadImpl.java:446)
 		at org.assertj.core.internal.Failures.threadDumpDescription(Failures.java:193)
 		at org.assertj.core.internal.Failures.printThreadDumpIfNeeded(Failures.java:141)
 		at org.assertj.core.internal.Failures.failure(Failures.java:91)
 		at org.assertj.core.internal.Objects.assertEqual(Objects.java:314)
 		at org.assertj.core.api.AbstractAssert.isEqualTo(AbstractAssert.java:198)
 		at org.assertj.examples.ThreadDumpOnErrorExample.main(ThreadDumpOnErrorExample.java:28)
```
    Specified by:
    
    withThreadDumpOnError in interface Assert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>>
    
    Overrides:
    
    withThreadDumpOnError in class AbstractIterableAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>
    
    Returns:
    
    this assertion object.

Class AbstractListAssert<SELF extends AbstractListAssert<SELF,ACTUAL,ELEMENT,ELEMENT_ASSERT>,ACTUAL extends List<? extends ELEMENT>,ELEMENT,ELEMENT_ASSERT extends AbstractAssert<ELEMENT_ASSERT,ELEMENT>>

Field Summary

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

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

Constructor Summary

Method Summary

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

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

Methods inherited from class java.lang.Object

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

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

Constructor Detail

AbstractListAssert

Method Detail

contains

doesNotContain

has

is

isSorted

isSortedAccordingTo

usingElementComparator

usingDefaultElementComparator

usingComparisonStrategy

as

as

describedAs

describedAs

doesNotHave

doesNotHaveSameClassAs

has

hasSameClassAs

hasToString

is

isEqualTo

isExactlyInstanceOf

isIn

isIn

isInstanceOf

isInstanceOfAny

isNot

isNotEqualTo

isNotExactlyInstanceOf

isNotIn

isNotIn

isNotInstanceOf

isNotInstanceOfAny

isNotOfAnyClassIn

isNotNull

isNotSameAs

isOfAnyClassIn

isSameAs

overridingErrorMessage

usingDefaultComparator

usingComparator

withFailMessage

withThreadDumpOnError