AbstractMapAssert (AssertJ fluent assertions 3.5.2 API)

java.lang.Object
- org.assertj.core.api.AbstractAssert<S,A>
- - org.assertj.core.api.AbstractMapAssert<S,A,K,V>

Type Parameters:

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

A - the type of the "actual" value.

K - the type of keys in map.

V - the type of values in map.

All Implemented Interfaces:

Assert<S,A>, Descriptable<S>, EnumerableAssert<S,Map.Entry<? extends K,? extends V>>, ExtensionPoints<S,A>

Direct Known Subclasses:

MapAssert, SoftAssertionMapAssert
```
public abstract class AbstractMapAssert<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>,K,V>
extends AbstractAssert<S,A>
implements EnumerableAssert<S,Map.Entry<? extends K,? extends V>>
```
Base class for all implementations of assertions for Maps.

Author:

David DIDIER, Yvonne Wang, Alex Ruiz, Mikhail Mazursky, Nicolas François, dorzey

Field Summary
- Fields inherited from class org.assertj.core.api.AbstractAssert
  actual, info, myself

Constructor Summary

Constructors
Constructor and Description

AbstractMapAssert(A actual, Class<?> selfType)

Constructors
Constructor and Description
`AbstractMapAssert(A actual, Class<?> selfType)`

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`S`	`as(Description description)` Sets the description of the assertion that is going to be called after.
`S`	`as(String description, Object... args)` Sets the description of the assertion that is going to be called after.
`S`	`contains(Map.Entry<? extends K,? extends V>... entries)` Verifies that the actual map contains the given entries, in any order.
`S`	`containsAllEntriesOf(Map<? extends K,? extends V> other)` Verifies that the actual map contains all entries of the given map, in any order.
`S`	`containsEntry(K key, V value)` Verifies that the actual map contains the given entry.
`S`	`containsExactly(Map.Entry<? extends K,? extends V>... entries)` Verifies that the actual map contains only the given entries and nothing else, in order. This assertion should only be used with map that have a consistent iteration order (i.e.
`S`	`containsKey(K key)` Verifies that the actual map contains the given key.
`S`	`containsKeys(K... keys)` Verifies that the actual map contains the given keys.
`S`	`containsOnly(Map.Entry<? extends K,? extends V>... entries)` Verifies that the actual map contains only the given entries and nothing else, in any order.
`S`	`containsOnlyKeys(K... keys)` Verifies that the actual map contains only the given keys and nothing else, in any order.
`S`	`containsValue(V value)` Verifies that the actual map contains the given value.
`S`	`containsValues(V... values)` Verifies that the actual map contains the given values.
`S`	`describedAs(Description description)` Sets the description of the assertion that is going to be called after.
`S`	`describedAs(String description, Object... args)` Sets the description of the assertion that is going to be called after.
`S`	`doesNotContain(Map.Entry<? extends K,? extends V>... entries)` Verifies that the actual map does not contain the given entries.
`S`	`doesNotContainEntry(K key, V value)` Verifies that the actual map does not contain the given entry.
`S`	`doesNotContainKey(K key)` Verifies that the actual map does not contain the given key.
`S`	`doesNotContainKeys(K... keys)` Verifies that the actual map does not contain any of the given keys.
`S`	`doesNotContainValue(V value)` Verifies that the actual map does not contain the given value.
`S`	`doesNotHave(Condition<? super A> condition)` Verifies that the actual value does not satisfy the given condition.
`S`	`doesNotHaveSameClassAs(Object other)` Verifies that the actual value does not have the same class as the given object.
`S`	`has(Condition<? super A> condition)` Verifies that the actual value satisfies the given condition.
`S`	`hasSameClassAs(Object other)` Verifies that the actual value has the same class as the given object.
`S`	`hasSameSizeAs(Iterable<?> other)` Verifies that the actual map has the same size as the given `Iterable`.
`S`	`hasSameSizeAs(Map<?,?> other)` Verifies that the actual map has the same size as the given `Map`.
`S`	`hasSameSizeAs(Object other)` Verifies that the actual map has the same size as given array.
`S`	`hasSize(int expected)` Verifies that the number of values in the `Map` is equal to the given one.
`S`	`hasToString(String expectedToString)` Verifies that actual `actual.toString()` is equal to the given `String`.
`S`	`is(Condition<? super A> condition)` Verifies that the actual value satisfies the given condition.
`void`	`isEmpty()` Verifies that the `Map` is empty.
`S`	`isEqualTo(Object expected)` Verifies that the actual value is equal to the given one.
`S`	`isExactlyInstanceOf(Class<?> type)` Verifies that the actual value is exactly an instance of the given type.
`S`	`isIn(Iterable<?> values)` Verifies that the actual value is present in the given values.
`S`	`isIn(Object... values)` Verifies that the actual value is present in the given array of values.
`S`	`isInstanceOf(Class<?> type)` Verifies that the actual value is an instance of the given type.
`S`	`isInstanceOfAny(Class<?>... types)` Verifies that the actual value is an instance of any of the given types.
`S`	`isNot(Condition<? super A> condition)` Verifies that the actual value does not satisfy the given condition.
`S`	`isNotEmpty()` Verifies that the `Map` is not empty.
`S`	`isNotEqualTo(Object other)` Verifies that the actual value is not equal to the given one.
`S`	`isNotExactlyInstanceOf(Class<?> type)` Verifies that the actual value is not exactly an instance of given type.
`S`	`isNotIn(Iterable<?> values)` Verifies that the actual value is not present in the given values.
`S`	`isNotIn(Object... values)` Verifies that the actual value is not present in the given array of values.
`S`	`isNotInstanceOf(Class<?> type)` Verifies that the actual value is not an instance of the given type.
`S`	`isNotInstanceOfAny(Class<?>... types)` Verifies that the actual value is not an instance of any of the given types.
`S`	`isNotNull()` Verifies that the actual value is not `null`.
`S`	`isNotOfAnyClassIn(Class<?>... types)` Verifies that the actual value type is not in given types.
`S`	`isNotSameAs(Object other)` Verifies that the actual value is not the same as the given one, ie using == comparison.
`void`	`isNullOrEmpty()` Verifies that the `Map` is `null` or empty.
`S`	`isOfAnyClassIn(Class<?>... types)` Verifies that the actual value type is in given types.
`S`	`isSameAs(Object expected)` Verifies that the actual value is the same as the given one, ie using == comparison.
`S`	`overridingErrorMessage(String newErrorMessage, Object... args)` Overrides AssertJ default error message by the given one.
`AbstractMapSizeAssert<S,A,K,V>`	`size()` Return an `Assert` object that allows to perform assertions on the size of the `Map` under test.
`S`	`usingComparator(Comparator<? super A> customComparator)` Use given custom comparator instead of relying on actual type A equals method for incoming assertion checks.
`S`	`usingDefaultComparator()` Revert to standard comparison for incoming assertion checks.
`S`	`usingDefaultElementComparator()` Deprecated. Custom element Comparator is not supported for MapEntry comparison.
`S`	`usingElementComparator(Comparator<? super Map.Entry<? extends K,? extends V>> customComparator)` Deprecated. Custom element Comparator is not supported for MapEntry comparison.
`S`	`withFailMessage(String newErrorMessage, Object... args)` Alternative method for `AbstractAssert.overridingErrorMessage(java.lang.String, java.lang.Object...)`
`S`	`withThreadDumpOnError()` In case of assertion error, the thread dump will be printed on `System.err`.

Methods inherited from class org.assertj.core.api.AbstractAssert
asList, asString, descriptionText, equals, failWithMessage, getWritableAssertionInfo, hashCode, inBinary, inHexadecimal, isNull, matches, matches, satisfies, setCustomRepresentation, throwAssertionError, withRepresentation

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - AbstractMapAssert
```
public AbstractMapAssert(A actual,
                         Class<?> selfType)
```
- Method Detail
  - isNullOrEmpty
```
public void isNullOrEmpty()
```
    Verifies that the Map is null or empty.
    Example:
```
 // assertions will pass
 Map<Integer, String> map = null;
 assertThat(map).isNullOrEmpty();
 assertThat(new HashMap()).isNullOrEmpty();
 
 // assertion will fail
 Map<String, String> keyToValue = new HashMap();
 keyToValue.put("key", "value");
 assertThat(keyToValue).isNullOrEmpty()
```
    Specified by:
    
    isNullOrEmpty in interface EnumerableAssert<S extends AbstractMapAssert<S,A,K,V>,Map.Entry<? extends K,? extends V>>
    
    Throws:
    
    AssertionError - if the Map is not null or not empty.
  - isEmpty
```
public void isEmpty()
```
    Verifies that the Map is empty.
    Example:
```
 // assertion will pass
 assertThat(new HashMap()).isEmpty();
 
 // assertion will fail
 Map<String, String> map = new HashMap();
 map.put("key", "value");
 assertThat(map).isEmpty();
```
    Specified by:
    
    isEmpty in interface EnumerableAssert<S extends AbstractMapAssert<S,A,K,V>,Map.Entry<? extends K,? extends V>>
    
    Throws:
    
    AssertionError - if the Map of values is not empty.
  - isNotEmpty
```
public S isNotEmpty()
```
    Verifies that the Map is not empty.
    Example:
```
 Map<String, String> map = new HashMap();
 map.put("key", "value");
 
 // assertion will pass
 assertThat(map).isNotEmpty();

 // assertion will fail
 assertThat(new HashMap()).isNotEmpty();
```
    Specified by:
    
    isNotEmpty in interface EnumerableAssert<S extends AbstractMapAssert<S,A,K,V>,Map.Entry<? extends K,? extends V>>
    
    Returns:
    
    this assertion object.
    
    Throws:
    
    AssertionError - if the Map is empty.
  - hasSize
```
public S hasSize(int expected)
```
    Verifies that the number of values in the Map is equal to the given one.
    Example:
```
 Map<String, String> map = new HashMap();
 map.put("key", "value");
 
 // assertion will pass
 assertThat(map).hasSize(1);
 
 // assertions will fail
 assertThat(map).hasSize(0);
 assertThat(map).hasSize(2);
```
    Specified by:
    
    hasSize in interface EnumerableAssert<S extends AbstractMapAssert<S,A,K,V>,Map.Entry<? extends K,? extends V>>
    
    Parameters:
    
    expected - the expected number of values in the Map.
    
    Returns:
    
    this assertion object.
    
    Throws:
    
    AssertionError - if the number of values of the Map is not equal to the given one.
  - hasSameSizeAs
```
public S hasSameSizeAs(Object other)
```
    Verifies that the actual map has the same size as given array.
    Parameter is declared as Object to accept both Object[] and primitive arrays (e.g. int[]).
    Example:
```
 int[] oneTwoThree = {1, 2, 3};
 
 Map<Ring, TolkienCharacter> elvesRingBearers = new HashMap<>();
 elvesRingBearers.put(nenya, galadriel);
 elvesRingBearers.put(narya, gandalf);
 elvesRingBearers.put(vilya, elrond);
 
 // assertion will pass
 assertThat(elvesRingBearers).hasSameSizeAs(oneTwoThree);
 
 // assertions will fail
 assertThat(elvesRingBearers).hasSameSizeAs(new int[] {1});
 assertThat(keyToValue).hasSameSizeAs(new char[] {'a', 'b', 'c', 'd'});
```
    Specified by:
    
    hasSameSizeAs in interface EnumerableAssert<S extends AbstractMapAssert<S,A,K,V>,Map.Entry<? extends K,? extends V>>
    
    Parameters:
    
    array - the array to compare size with actual group.
    
    Returns:
    
    this assertion object.
    
    Throws:
    
    AssertionError - if the actual group is null.
    
    AssertionError - if the array parameter is null or is not a true array.
    
    AssertionError - if actual group and given array don't have the same size.
  - hasSameSizeAs
```
public S hasSameSizeAs(Iterable<?> other)
```
    Verifies that the actual map has the same size as the given Iterable.
    Example :
```
 Map<Ring, TolkienCharacter> elvesRingBearers = new HashMap<>();
 elvesRingBearers.put(nenya, galadriel);
 elvesRingBearers.put(narya, gandalf);
 elvesRingBearers.put(vilya, elrond);
 
 // assertion will pass
 assertThat(elvesRingBearers).hasSameSizeAs(Array.asList(vilya, nenya, narya));
 
 // assertions will fail
 assertThat(elvesRingBearers).hasSameSizeAs(Array.asList(1));
 assertThat(keyToValue).hasSameSizeAs(Array.asList('a', 'b', 'c', 'd'));
```
    Specified by:
    
    hasSameSizeAs in interface EnumerableAssert<S extends AbstractMapAssert<S,A,K,V>,Map.Entry<? extends K,? extends V>>
    
    Parameters:
    
    other - the Iterable to compare size with actual group.
    
    Returns:
    
    this assertion object.
    
    Throws:
    
    AssertionError - if the actual map is null.
    
    AssertionError - if the other Iterable is null.
    
    AssertionError - if the actual map and the given Iterable don't have the same size
  - hasSameSizeAs
```
public S hasSameSizeAs(Map<?,?> other)
```
    Verifies that the actual map has the same size as the given Map.
    Example :
```
 Map<Ring, TolkienCharacter> ringBearers = new HashMap<>();
 ringBearers.put(nenya, galadriel);
 ringBearers.put(narya, gandalf);
 ringBearers.put(vilya, elrond);
 ringBearers.put(oneRing, frodo);
 
 // assertion will pass
 assertThat(ringBearers).hasSameSizeAs(mapOf(entry(oneRing, frodo),
                                             entry(narya, gandalf),
                                             entry(nenya, galadriel),
                                             entry(vilya, elrond)));
 
 // assertions will fail
 assertThat(elvesRingBearers).hasSameSizeAs(new HashMap());
 Map<String, String> keyToValue = new HashMap();
 keyToValue.put("key", "value");
 assertThat(keyToValue).hasSameSizeAs(keyToValue);
```
    Parameters:
    
    other - the Map to compare size with actual map
    
    Returns:
    
    this assertion object
    
    Throws:
    
    NullPointerException - if the other Map is null
    
    AssertionError - if the actual map is null
    
    AssertionError - if the actual map and the given Map don't have the same size
  - contains
```
public S contains(Map.Entry<? extends K,? extends V>... entries)
```
    Verifies that the actual map contains the given entries, in any order.
    Example :
```
 Map<Ring, TolkienCharacter> ringBearers = new HashMap<>();
 ringBearers.put(nenya, galadriel);
 ringBearers.put(narya, gandalf);
 ringBearers.put(vilya, elrond);
 ringBearers.put(oneRing, frodo);
 
 // assertion will pass
 assertThat(ringBearers).contains(entry(oneRing, frodo), entry(nenya, galadriel));
 
 // assertions will fail
 assertThat(ringBearers).contains(entry(oneRing, sauron));
 assertThat(ringBearers).contains(entry(oneRing, sauron), entry(oneRing, aragorn));
 assertThat(ringBearers).contains(entry(narya, gandalf), entry(oneRing, sauron));
```
    Parameters:
    
    entries - the given entries.
    
    Returns:
    
    this assertion object.
    
    Throws:
    
    NullPointerException - if the given argument is null.
    
    IllegalArgumentException - if the given argument is an empty array.
    
    NullPointerException - if any of the entries in the given array is null.
    
    AssertionError - if the actual map is null.
    
    AssertionError - if the actual map does not contain the given entries.
  - containsAllEntriesOf
```
public S containsAllEntriesOf(Map<? extends K,? extends V> other)
```
    Verifies that the actual map contains all entries of the given map, in any order.
    Example :
```
 Map<Ring, TolkienCharacter> ringBearers = new HashMap<>();
 ringBearers.put(nenya, galadriel);
 ringBearers.put(narya, gandalf);
 ringBearers.put(vilya, elrond);
 ringBearers.put(oneRing, frodo);

 Map<Ring, TolkienCharacter> elvesRingBearers = new HashMap<>();
 elvesRingBearers.put(nenya, galadriel);
 elvesRingBearers.put(narya, gandalf);
 elvesRingBearers.put(vilya, elrond);
 
 // assertion will succeed
 assertThat(ringBearers).containsAllEntriesOf(elvesRingBearers);
 
 // assertion will fail
 assertThat(elvesRingBearers).containsAllEntriesOf(ringBearers);
```
    Parameters:
    
    the - map with the given entries.
    
    Returns:
    
    this assertion object.
    
    Throws:
    
    NullPointerException - if the given argument is null.
    
    NullPointerException - if any of the entries in the given map is null.
    
    AssertionError - if the actual map is null.
    
    AssertionError - if the actual map does not contain the given entries.
  - containsEntry
```
public S containsEntry(K key,
                       V value)
```
    Verifies that the actual map contains the given entry.
    Example :
```
 Map<Ring, TolkienCharacter> ringBearers = new HashMap<>();
 ringBearers.put(nenya, galadriel);
 ringBearers.put(narya, gandalf);
 ringBearers.put(vilya, elrond);
 ringBearers.put(oneRing, frodo);
 
 // assertions will pass
 assertThat(ringBearers).containsEntry(oneRing, frodo).containsEntry(nenya, galadriel);
```
    // assertion will fail assertThat(ringBearers).containsEntry(oneRing, sauron);
    Parameters:
    
    key - the given key to check.
    
    value - the given value to check.
    
    Returns:
    
    this assertion object.
    
    Throws:
    
    NullPointerException - if the given argument is null.
    
    IllegalArgumentException - if the given argument is an empty array.
    
    NullPointerException - if any of the entries in the given array is null.
    
    AssertionError - if the actual map is null.
    
    AssertionError - if the actual map does not contain the given entries.
  - doesNotContain
```
public S doesNotContain(Map.Entry<? extends K,? extends V>... entries)
```
    Verifies that the actual map does not contain the given entries.
    Example :
```
 Map<Ring, TolkienCharacter> ringBearers = new HashMap<>();
 ringBearers.put(nenya, galadriel);
 ringBearers.put(narya, gandalf);
 ringBearers.put(vilya, elrond);
 ringBearers.put(oneRing, frodo);
 
 // assertion will pass
 assertThat(ringBearers).doesNotContain(entry(oneRing, aragorn), entry(oneRing, sauron));
 
 // assertions will fail
 assertThat(ringBearers).doesNotContain(entry(oneRing, frodo));
 assertThat(ringBearers).doesNotContain(entry(oneRing, frodo), entry(oneRing, aragorn));
```
    Parameters:
    
    entries - the given entries.
    
    Returns:
    
    this assertion object.
    
    Throws:
    
    NullPointerException - if the given argument is null.
    
    IllegalArgumentException - if the given argument is an empty array.
    
    AssertionError - if the actual map is null.
    
    AssertionError - if the actual map contains any of the given entries.
  - doesNotContainEntry
```
public S doesNotContainEntry(K key,
                             V value)
```
    Verifies that the actual map does not contain the given entry.
    Example :
```
 Map<Ring, TolkienCharacter> ringBearers = new HashMap<>();
 ringBearers.put(nenya, galadriel);
 ringBearers.put(narya, gandalf);
 ringBearers.put(vilya, elrond);
 ringBearers.put(oneRing, frodo);
 
 // assertion will pass
 assertThat(ringBearers).doesNotContainEntry(oneRing, aragorn);
 
 // assertion will fail
 assertThat(ringBearers).doesNotContain(oneRing, frodo);
```
    Parameters:
    
    key - key of the entry.
    
    value - value of the entry.
    
    Returns:
    
    this assertion object.
    
    Throws:
    
    NullPointerException - if the given argument is null.
    
    IllegalArgumentException - if the given argument is an empty array.
    
    AssertionError - if the actual map is null.
    
    AssertionError - if the actual map contains any of the given entries.
  - containsKey
```
public S containsKey(K key)
```
    Verifies that the actual map contains the given key.
    Example :
```
 Map<Ring, TolkienCharacter> ringBearers = new HashMap<>();
 ringBearers.put(nenya, galadriel);
 ringBearers.put(narya, gandalf);
 ringBearers.put(vilya, elrond);
 
 // assertion will pass
 assertThat(ringBearers).containsKey(vilya);
 
 // assertion will fail
 assertThat(ringBearers).containsKey(oneRing);
```
    Parameters:
    
    key - the given key
    
    Throws:
    
    AssertionError - if the actual map is null.
    
    AssertionError - if the actual map does not contain the given key.
  - containsKeys
```
public S containsKeys(K... keys)
```
    Verifies that the actual map contains the given keys.
    Example :
```
 Map<Ring, TolkienCharacter> ringBearers = new HashMap<>();
 ringBearers.put(nenya, galadriel);
 ringBearers.put(narya, gandalf);
 ringBearers.put(oneRing, frodo);
 
 // assertions will pass
 assertThat(ringBearers).containsKeys(nenya, oneRing);
 
 // assertions will fail
 assertThat(ringBearers).containsKeys(vilya);
 assertThat(ringBearers).containsKeys(vilya, oneRing);
```
    Parameters:
    
    keys - the given keys
    
    Throws:
    
    AssertionError - if the actual map is null.
    
    AssertionError - if the actual map does not contain the given key.
    
    IllegalArgumentException - if the given argument is an empty array.
  - doesNotContainKey
```
public S doesNotContainKey(K key)
```
    Verifies that the actual map does not contain the given key.
    Example :
```
 Map<Ring, TolkienCharacter> elvesRingBearers = new HashMap<>();
 elvesRingBearers.put(nenya, galadriel);
 elvesRingBearers.put(narya, gandalf);
 elvesRingBearers.put(vilya, elrond);
 
 // assertion will pass
 assertThat(elvesRingBearers).doesNotContainKey(oneRing);
 
 // assertion will fail
 assertThat(elvesRingBearers).doesNotContainKey(vilya);
```
    Parameters:
    
    key - the given key
    
    Throws:
    
    AssertionError - if the actual map is null.
    
    AssertionError - if the actual map contains the given key.
  - doesNotContainKeys
```
public S doesNotContainKeys(K... keys)
```
    Verifies that the actual map does not contain any of the given keys.
    Example :
```
 Map<Ring, TolkienCharacter> elvesRingBearers = new HashMap<>();
 elvesRingBearers.put(nenya, galadriel);
 elvesRingBearers.put(narya, gandalf);
 elvesRingBearers.put(vilya, elrond);
 
 // assertion will pass
 assertThat(elvesRingBearers).doesNotContainKeys(oneRing, someManRing);
 
 // assertions will fail
 assertThat(elvesRingBearers).doesNotContainKeys(vilya, nenya);
 assertThat(elvesRingBearers).doesNotContainKeys(vilya, oneRing);
```
    Parameters:
    
    key - the given key
    
    Throws:
    
    AssertionError - if the actual map is null.
    
    AssertionError - if the actual map contains the given key.
  - containsOnlyKeys
```
public S containsOnlyKeys(K... keys)
```
    Verifies that the actual map contains only the given keys and nothing else, in any order.
    Examples :
```
 Map<Ring, TolkienCharacter> ringBearers = new HashMap<>();
 ringBearers.put(nenya, galadriel);
 ringBearers.put(narya, gandalf);
 ringBearers.put(vilya, elrond);
 ringBearers.put(oneRing, frodo);
 
 // assertion will pass
 assertThat(ringBearers).containsOnlyKeys(oneRing, nenya, narya, vilya);
 
 // assertion will fail
 assertThat(ringBearers).containsOnlyKeys(oneRing, nenya);
```
    Parameters:
    
    keys - the given keys that should be in the actual map.
    
    Throws:
    
    AssertionError - if the actual map is null.
    
    AssertionError - if the actual map does not contain the given keys, i.e. the actual map contains some or none of the given keys, or the actual map contains more entries than the given ones.
    
    IllegalArgumentException - if the given argument is an empty array.
  - containsValue
```
public S containsValue(V value)
```
    Verifies that the actual map contains the given value.
    Example :
```
 Map<Ring, TolkienCharacter> ringBearers = new HashMap<>();
 ringBearers.put(nenya, galadriel);
 ringBearers.put(narya, gandalf);
 ringBearers.put(vilya, elrond);
 ringBearers.put(oneRing, frodo);
 
 // assertion will pass
 assertThat(ringBearers).containsValue(frodo);
 
 // assertion will fail
 assertThat(ringBearers).containsValue(sauron);
```
    Parameters:
    
    value - the value to look for.
    
    Throws:
    
    AssertionError - if the actual map is null.
    
    AssertionError - if the actual map does not contain the given value.
  - containsValues
```
public S containsValues(V... values)
```
    Verifies that the actual map contains the given values.
    Example :
```
 Map<Ring, TolkienCharacter> ringBearers = new HashMap<>();
 ringBearers.put(nenya, galadriel);
 ringBearers.put(narya, gandalf);
 ringBearers.put(vilya, elrond);
 ringBearers.put(oneRing, frodo);

 // assertion will pass
 assertThat(ringBearers).containsValues(frodo, galadriel);
 
 // assertions will fail
 assertThat(ringBearers).containsValues(sauron, aragorn);
 assertThat(ringBearers).containsValues(sauron, frodo);
```
    Parameters:
    
    values - the values to look for in the actual map.
    
    Throws:
    
    AssertionError - if the actual map is null.
    
    AssertionError - if the actual map does not contain the given values.
  - doesNotContainValue
```
public S doesNotContainValue(V value)
```
    Verifies that the actual map does not contain the given value.
    Example :
```
 Map<Ring, TolkienCharacter> ringBearers = new HashMap<>();
 ringBearers.put(nenya, galadriel);
 ringBearers.put(narya, gandalf);
 ringBearers.put(vilya, elrond);
 ringBearers.put(oneRing, frodo);
 
 // assertion will pass
 assertThat(ringBearers).doesNotContainValue(aragorn);
 
 // assertion will fail
 assertThat(ringBearers).doesNotContainValue(frodo);
```
    Parameters:
    
    value - the value that should not be in actual map.
    
    Throws:
    
    AssertionError - if the actual map is null.
    
    AssertionError - if the actual map contains the given value.
  - containsOnly
```
public S containsOnly(Map.Entry<? extends K,? extends V>... entries)
```
    Verifies that the actual map contains only the given entries and nothing else, in any order.
    Examples :
```
 Map<Ring, TolkienCharacter> ringBearers = new HashMap<>();
 ringBearers.put(nenya, galadriel);
 ringBearers.put(narya, gandalf);
 ringBearers.put(vilya, elrond);
 ringBearers.put(oneRing, frodo);
 
 // assertion will pass
 assertThat(ringBearers).containsOnly(entry(oneRing, frodo), entry(nenya, galadriel), entry(narya, gandalf), entry(vilya, elrond));
 
 // assertion will fail
 assertThat(ringBearers).containsOnly(entry(oneRing, frodo), entry(nenya, galadriel));
```
    Parameters:
    
    entries - the entries that should be in the actual map.
    
    Throws:
    
    AssertionError - if the actual map is null.
    
    NullPointerException - if the given argument is null.
    
    IllegalArgumentException - if the given argument is an empty array.
    
    AssertionError - if the actual map does not contain the given entries, i.e. the actual map contains some or none of the given entries, or the actual map contains more entries than the given ones.
  - containsExactly
```
public S containsExactly(Map.Entry<? extends K,? extends V>... entries)
```
    Verifies that the actual map contains only the given entries and nothing else, in order.
    This assertion should only be used with map that have a consistent iteration order (i.e. don't use it with HashMap, prefer #containsOnly(org.assertj.core.data.MapEntry...) in that case).
    Example :
```
 Map<Ring, TolkienCharacter> ringBearers = newLinkedHashMap(entry(oneRing, frodo),   
                                                            entry(nenya, galadriel), 
                                                            entry(narya, gandalf));  
 
 // assertion will pass
 assertThat(ringBearers).containsExactly(entry(oneRing, frodo), 
                                         entry(nenya, galadriel), 
                                         entry(narya, gandalf));
 
 // assertion will fail as actual and expected order differ
 assertThat(ringBearers).containsExactly(entry(nenya, galadriel), 
                                         entry(narya, gandalf), 
                                         entry(oneRing, frodo));
```
    Parameters:
    
    entries - the given entries.
    
    Throws:
    
    NullPointerException - if the given entries array is null.
    
    AssertionError - if the actual map is null.
    
    IllegalArgumentException - if the given entries array is empty.
    
    AssertionError - if the actual map does not contain the given entries with same order, i.e. the actual map contains some or none of the given entries, or the actual map contains more entries than the given ones or entries are the same but the order is not.
  - usingElementComparator
```
@Deprecated
public S usingElementComparator(Comparator<? super Map.Entry<? extends K,? extends V>> customComparator)
```
    Deprecated. Custom element Comparator is not supported for MapEntry comparison.
    
    Do not use this method.
    
    Specified by:
    
    usingElementComparator in interface EnumerableAssert<S extends AbstractMapAssert<S,A,K,V>,Map.Entry<? extends K,? extends V>>
    
    Parameters:
    
    customComparator - the comparator to use for incoming assertion checks.
    
    Returns:
    
    this assertion object.
    
    Throws:
    
    UnsupportedOperationException - if this method is called.
  - usingDefaultElementComparator
```
@Deprecated
public S usingDefaultElementComparator()
```
    Deprecated. Custom element Comparator is not supported for MapEntry comparison.
    
    Do not use this method.
    
    Specified by:
    
    usingDefaultElementComparator in interface EnumerableAssert<S extends AbstractMapAssert<S,A,K,V>,Map.Entry<? extends K,? extends V>>
    
    Returns:
    
    this assertion object.
    
    Throws:
    
    UnsupportedOperationException - if this method is called.
  - as
```
public S 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<S extends AbstractMapAssert<S,A,K,V>>
    
    Overrides:
    
    as in class AbstractAssert<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    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 S 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<S extends AbstractMapAssert<S,A,K,V>>
    
    Overrides:
    
    as in class AbstractAssert<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Parameters:
    
    description - the new description to set.
    
    Returns:
    
    this object.
    
    See Also:
    
    Descriptable.describedAs(Description)
  - describedAs
```
public S 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<S extends AbstractMapAssert<S,A,K,V>>
    
    Overrides:
    
    describedAs in class AbstractAssert<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Parameters:
    
    description - the new description to set.
    
    Returns:
    
    this object.
  - describedAs
```
public S 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<S extends AbstractMapAssert<S,A,K,V>>
    
    Overrides:
    
    describedAs in class AbstractAssert<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Parameters:
    
    description - the new description to set.
    
    Returns:
    
    this object.
  - doesNotHave
```
public S doesNotHave(Condition<? super A> 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<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Overrides:
    
    doesNotHave in class AbstractAssert<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Parameters:
    
    condition - the given condition.
    
    Returns:
    
    this ExtensionPoints object.
    
    See Also:
    
    ExtensionPoints.isNot(Condition)
  - doesNotHaveSameClassAs
```
public S 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<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Overrides:
    
    doesNotHaveSameClassAs in class AbstractAssert<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Parameters:
    
    other - the object to check type against.
    
    Returns:
    
    this assertion object.
  - has
```
public S has(Condition<? super A> 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<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Overrides:
    
    has in class AbstractAssert<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Parameters:
    
    condition - the given condition.
    
    Returns:
    
    this ExtensionPoints object.
    
    See Also:
    
    ExtensionPoints.is(Condition)
  - hasSameClassAs
```
public S 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<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Overrides:
    
    hasSameClassAs in class AbstractAssert<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Parameters:
    
    other - the object to check type against.
    
    Returns:
    
    this assertion object.
  - hasToString
```
public S 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<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Overrides:
    
    hasToString in class AbstractAssert<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Parameters:
    
    expectedToString - the expected String description of actual.
    
    Returns:
    
    this assertion object.
  - is
```
public S is(Condition<? super A> 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<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Overrides:
    
    is in class AbstractAssert<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Parameters:
    
    condition - the given condition.
    
    Returns:
    
    this ExtensionPoints object.
    
    See Also:
    
    ExtensionPoints.is(Condition)
  - isEqualTo
```
public S 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<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Overrides:
    
    isEqualTo in class AbstractAssert<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Parameters:
    
    expected - the given value to compare the actual value to.
    
    Returns:
    
    this assertion object.
  - isExactlyInstanceOf
```
public S 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<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Overrides:
    
    isExactlyInstanceOf in class AbstractAssert<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Parameters:
    
    type - the type to check the actual value against.
    
    Returns:
    
    this assertion object.
  - isIn
```
public S 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<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Overrides:
    
    isIn in class AbstractAssert<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Parameters:
    
    values - the given iterable to search the actual value in.
    
    Returns:
    
    this assertion object.
  - isIn
```
public S 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<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Overrides:
    
    isIn in class AbstractAssert<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Parameters:
    
    values - the given array to search the actual value in.
    
    Returns:
    
    this assertion object.
  - isInstanceOf
```
public S 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<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Overrides:
    
    isInstanceOf in class AbstractAssert<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Parameters:
    
    type - the type to check the actual value against.
    
    Returns:
    
    this assertion object.
  - isInstanceOfAny
```
public S 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<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Overrides:
    
    isInstanceOfAny in class AbstractAssert<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Parameters:
    
    types - the types to check the actual value against.
    
    Returns:
    
    this assertion object.
  - isNot
```
public S isNot(Condition<? super A> 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<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Overrides:
    
    isNot in class AbstractAssert<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Parameters:
    
    condition - the given condition.
    
    Returns:
    
    this ExtensionPoints object.
    
    See Also:
    
    ExtensionPoints.isNot(Condition)
  - isNotEqualTo
```
public S 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<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Overrides:
    
    isNotEqualTo in class AbstractAssert<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Parameters:
    
    other - the given value to compare the actual value to.
    
    Returns:
    
    this assertion object.
  - isNotExactlyInstanceOf
```
public S 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<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Overrides:
    
    isNotExactlyInstanceOf in class AbstractAssert<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Parameters:
    
    type - the type to check the actual value against.
    
    Returns:
    
    this assertion object.
  - isNotIn
```
public S 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<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Overrides:
    
    isNotIn in class AbstractAssert<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Parameters:
    
    values - the given iterable to search the actual value in.
    
    Returns:
    
    this assertion object.
  - isNotIn
```
public S 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<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Overrides:
    
    isNotIn in class AbstractAssert<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Parameters:
    
    values - the given array to search the actual value in.
    
    Returns:
    
    this assertion object.
  - isNotInstanceOf
```
public S 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<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Overrides:
    
    isNotInstanceOf in class AbstractAssert<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Parameters:
    
    type - the type to check the actual value against.
    
    Returns:
    
    this assertion object.
  - isNotInstanceOfAny
```
public S 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<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Overrides:
    
    isNotInstanceOfAny in class AbstractAssert<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Parameters:
    
    types - the types to check the actual value against.
    
    Returns:
    
    this assertion object.
  - isNotOfAnyClassIn
```
public S 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<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Overrides:
    
    isNotOfAnyClassIn in class AbstractAssert<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Parameters:
    
    types - the types to check the actual value against.
    
    Returns:
    
    this assertion object.
  - isNotNull
```
public S 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<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Overrides:
    
    isNotNull in class AbstractAssert<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Returns:
    
    this assertion object.
  - isNotSameAs
```
public S 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<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Overrides:
    
    isNotSameAs in class AbstractAssert<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Parameters:
    
    other - the given value to compare the actual value to.
    
    Returns:
    
    this assertion object.
  - isOfAnyClassIn
```
public S 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<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Overrides:
    
    isOfAnyClassIn in class AbstractAssert<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Parameters:
    
    types - the types to check the actual value against.
    
    Returns:
    
    this assertion object.
  - isSameAs
```
public S 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<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Overrides:
    
    isSameAs in class AbstractAssert<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Parameters:
    
    expected - the given value to compare the actual value to.
    
    Returns:
    
    this assertion object.
  - overridingErrorMessage
```
public S 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 AbstractAssert<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    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 S 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<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Overrides:
    
    usingDefaultComparator in class AbstractAssert<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Returns:
    
    this assertion object.
  - usingComparator
```
public S usingComparator(Comparator<? super A> 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<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Overrides:
    
    usingComparator in class AbstractAssert<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Parameters:
    
    customComparator - the comparator to use for incoming assertion checks.
    
    Returns:
    
    this assertion object.
  - withFailMessage
```
public S 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 AbstractAssert<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    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 S 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<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Overrides:
    
    withThreadDumpOnError in class AbstractAssert<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>>
    
    Returns:
    
    this assertion object.
  - size
```
public AbstractMapSizeAssert<S,A,K,V> size()
```
    Return an Assert object that allows to perform assertions on the size of the Map under test.
    Once this method is called, the object under test is no more the initial Map but its size, to perform assertions on the initial Map, call AbstractMapSizeAssert.returnToMap().
    Example :
```
 Map<Ring, TolkienCharacter> ringBearers = newHashMap(entry(oneRing, frodo),   
                                                      entry(nenya, galadriel), 
                                                      entry(narya, gandalf));  
 
 // assertion will pass:
 assertThat(ringBearers).size().isGreaterThan(1)                
                               .isLessThanOrEqualTo(3)
                        returnToMap().contains(entry(oneRing, frodo), 
                                               entry(nenya, galadriel), 
                                               entry(narya, gandalf));
 
 // assertion will fail:
 assertThat(ringBearers).size().isGreaterThan(5);
```
    Throws:
    
    NullPointerException - if the given map is null.

Class AbstractMapAssert<S extends AbstractMapAssert<S,A,K,V>,A extends Map<K,V>,K,V>

Field Summary

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

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

Constructor Detail

AbstractMapAssert

Method Detail

isNullOrEmpty

isEmpty

isNotEmpty

hasSize

hasSameSizeAs

hasSameSizeAs

hasSameSizeAs

contains

containsAllEntriesOf

containsEntry

doesNotContain

doesNotContainEntry

containsKey

containsKeys

doesNotContainKey

doesNotContainKeys

containsOnlyKeys

containsValue

containsValues

doesNotContainValue

containsOnly

containsExactly

usingElementComparator

usingDefaultElementComparator

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

size