org.assertj.core.api

Class MapAssert<K,V>

java.lang.Object

org.assertj.core.api.AbstractAssert<S,A>

org.assertj.core.api.AbstractMapAssert<MapAssert<K,V>,Map<K,V>,K,V>

org.assertj.core.api.MapAssert<K,V>

All Implemented Interfaces:

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

public class MapAssert<K,V>
extends AbstractMapAssert<MapAssert<K,V>,Map<K,V>,K,V>

Assertions for Maps.

To create a new instance of this class, invoke Assertions.assertThat(Map).

Author:

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

Field Summary

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

actual, info, myself

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	MapAssert(Map<K,V> actual)

Method Summary

Methods

Modifier and Type	Method and Description
MapAssert<K,V>	contains(Map.Entry<? extends K,? extends V>... entries) Verifies that the actual map contains the given entries, in any order.
MapAssert<K,V>	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.
MapAssert<K,V>	containsKeys(K... keys) Verifies that the actual map contains the given keys.
MapAssert<K,V>	containsOnly(Map.Entry<? extends K,? extends V>... entries) Verifies that the actual map contains only the given entries and nothing else, in any order.
MapAssert<K,V>	containsOnlyKeys(K... keys) Verifies that the actual map contains only the given keys and nothing else, in any order.
MapAssert<K,V>	containsValues(V... values) Verifies that the actual map contains the given values.
MapAssert<K,V>	doesNotContain(Map.Entry<? extends K,? extends V>... entries) Verifies that the actual map does not contain the given entries.
MapAssert<K,V>	doesNotContainKeys(K... keys) Verifies that the actual map does not contain any of the given keys.

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

as, as, containsAllEntriesOf, containsEntry, containsKey, containsValue, describedAs, describedAs, doesNotContainEntry, doesNotContainKey, doesNotContainValue, doesNotHave, doesNotHaveSameClassAs, has, hasSameClassAs, hasSameSizeAs, hasSameSizeAs, hasSameSizeAs, hasSize, hasToString, is, isEmpty, isEqualTo, isExactlyInstanceOf, isIn, isIn, isInstanceOf, isInstanceOfAny, isNot, isNotEmpty, isNotEqualTo, isNotExactlyInstanceOf, isNotIn, isNotIn, isNotInstanceOf, isNotInstanceOfAny, isNotNull, isNotOfAnyClassIn, isNotSameAs, isNullOrEmpty, isOfAnyClassIn, isSameAs, overridingErrorMessage, usingComparator, usingDefaultComparator, usingDefaultElementComparator, usingElementComparator, withFailMessage, withThreadDumpOnError

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

asList, asString, descriptionText, equals, failWithMessage, getWritableAssertionInfo, hashCode, inBinary, inHexadecimal, isNull

Methods inherited from class java.lang.Object

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

Constructor Detail

MapAssert

protected MapAssert(Map<K,V> actual)

Method Detail

contains

@SafeVarargs
public final MapAssert<K,V> contains(Map.Entry<? extends K,? extends V>... entries)

Description copied from class: AbstractMapAssert

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

Overrides:

contains in class AbstractMapAssert<MapAssert<K,V>,Map<K,V>,K,V>

Parameters:

entries - the given entries.

Returns:

this assertion object.

containsOnly

@SafeVarargs
public final MapAssert<K,V> containsOnly(Map.Entry<? extends K,? extends V>... entries)

Description copied from class: AbstractMapAssert

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

Overrides:

containsOnly in class AbstractMapAssert<MapAssert<K,V>,Map<K,V>,K,V>

Parameters:

entries - the entries that should be in the actual map.

containsExactly

@SafeVarargs
public final MapAssert<K,V> containsExactly(Map.Entry<? extends K,? extends V>... entries)

Description copied from class: AbstractMapAssert

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

Overrides:

containsExactly in class AbstractMapAssert<MapAssert<K,V>,Map<K,V>,K,V>

Parameters:

entries - the given entries.

containsKeys

@SafeVarargs
public final MapAssert<K,V> containsKeys(K... keys)

Description copied from class: AbstractMapAssert

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

Overrides:

containsKeys in class AbstractMapAssert<MapAssert<K,V>,Map<K,V>,K,V>

Parameters:

keys - the given keys

containsOnlyKeys

@SafeVarargs
public final MapAssert<K,V> containsOnlyKeys(K... keys)

Description copied from class: AbstractMapAssert

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

Overrides:

containsOnlyKeys in class AbstractMapAssert<MapAssert<K,V>,Map<K,V>,K,V>

Parameters:

keys - the given keys that should be in the actual map.

containsValues

@SafeVarargs
public final MapAssert<K,V> containsValues(V... values)

Description copied from class: AbstractMapAssert

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

Overrides:

containsValues in class AbstractMapAssert<MapAssert<K,V>,Map<K,V>,K,V>

Parameters:

values - the values to look for in the actual map.

doesNotContainKeys

@SafeVarargs
public final MapAssert<K,V> doesNotContainKeys(K... keys)

Description copied from class: AbstractMapAssert

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

Overrides:

doesNotContainKeys in class AbstractMapAssert<MapAssert<K,V>,Map<K,V>,K,V>

doesNotContain

@SafeVarargs
public final MapAssert<K,V> doesNotContain(Map.Entry<? extends K,? extends V>... entries)

Description copied from class: AbstractMapAssert

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

Overrides:

doesNotContain in class AbstractMapAssert<MapAssert<K,V>,Map<K,V>,K,V>

Parameters:

entries - the given entries.

Returns:

this assertion object.