org.assertj.core.api

Class MapAssert<KEY,VALUE>

java.lang.Object

org.assertj.core.api.AbstractAssert<SELF,ACTUAL>

org.assertj.core.api.AbstractObjectAssert<SELF,ACTUAL>

org.assertj.core.api.AbstractMapAssert<MapAssert<KEY,VALUE>,Map<KEY,VALUE>,KEY,VALUE>

org.assertj.core.api.MapAssert<KEY,VALUE>

All Implemented Interfaces:

Assert<MapAssert<KEY,VALUE>,Map<KEY,VALUE>>, Descriptable<MapAssert<KEY,VALUE>>, EnumerableAssert<MapAssert<KEY,VALUE>,Map.Entry<? extends KEY,? extends VALUE>>, ExtensionPoints<MapAssert<KEY,VALUE>,Map<KEY,VALUE>>

public class MapAssert<KEY,VALUE>
extends AbstractMapAssert<MapAssert<KEY,VALUE>,Map<KEY,VALUE>,KEY,VALUE>

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, throwUnsupportedExceptionOnEquals

Constructor Summary

Constructors

Constructor and Description
MapAssert(Map<KEY,VALUE> actual)

Method Summary

Modifier and Type	Method and Description
MapAssert<KEY,VALUE>	contains(Map.Entry<? extends KEY,? extends VALUE>... entries) Verifies that the actual map contains the given entries, in any order.
MapAssert<KEY,VALUE>	containsAnyOf(Map.Entry<? extends KEY,? extends VALUE>... entries) Verifies that the actual map contains at least one of the given entries.
MapAssert<KEY,VALUE>	containsExactly(Map.Entry<? extends KEY,? extends VALUE>... entries) Verifies that the actual map contains only the given entries and nothing else, in order. This assertion should only be used with maps that have a consistent iteration order (i.e.
MapAssert<KEY,VALUE>	containsKeys(KEY... keys) Verifies that the actual map contains the given keys.
MapAssert<KEY,VALUE>	containsOnly(Map.Entry<? extends KEY,? extends VALUE>... entries) Verifies that the actual map contains only the given entries and nothing else, in any order.
MapAssert<KEY,VALUE>	containsOnlyKeys(KEY... keys) Verifies that the actual map contains only the given keys and nothing else, in any order.
MapAssert<KEY,VALUE>	containsValues(VALUE... values) Verifies that the actual map contains the given values.
MapAssert<KEY,VALUE>	doesNotContain(Map.Entry<? extends KEY,? extends VALUE>... entries) Verifies that the actual map does not contain the given entries.
MapAssert<KEY,VALUE>	doesNotContainKeys(KEY... keys) Verifies that the actual map does not contain any of the given keys.
AbstractListAssert<?,List<? extends Object>,Object,ObjectAssert<Object>>	extracting(Function<? super Map<KEY,VALUE>,Object>... extractors) Use the given Functions to extract the values from the object under test into a list, this new list becoming the object under test.

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

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

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

extracting, getComparatorsByType, hasFieldOrProperty, hasFieldOrPropertyWithValue, hasNoNullFieldsOrProperties, hasNoNullFieldsOrPropertiesExcept, isEqualToComparingFieldByField, isEqualToComparingFieldByFieldRecursively, isEqualToComparingOnlyGivenFields, isEqualToIgnoringGivenFields, isEqualToIgnoringNullFields, returns, usingComparatorForFields, usingComparatorForType

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

asList, asString, descriptionText, equals, failWithMessage, getWritableAssertionInfo, hashCode, hasSameHashCodeAs, inBinary, inHexadecimal, isInstanceOfSatisfying, isNull, matches, matches, newListAssertInstance, satisfies, setCustomRepresentation, throwAssertionError, withRepresentation

Methods inherited from class java.lang.Object

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

Constructor Detail

MapAssert

public MapAssert(Map<KEY,VALUE> actual)

Method Detail

contains

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

Description copied from class: AbstractMapAssert

Verifies that the actual map contains the given entries, in any order.

This assertion succeeds if both actual map and given entries are empty.

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).contains(entry(oneRing, frodo), entry(nenya, galadriel));
 assertThat(emptyMap).contains();
 
 // 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<KEY,VALUE>,Map<KEY,VALUE>,KEY,VALUE>

Parameters:

entries - the given entries.

Returns:

this assertion object.

containsAnyOf

@SafeVarargs
public final MapAssert<KEY,VALUE> containsAnyOf(Map.Entry<? extends KEY,? extends VALUE>... entries)

Description copied from class: AbstractMapAssert

Verifies that the actual map contains at least one of 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);
 
 // assertions will pass
 assertThat(ringBearers).containsAnyOf(entry(oneRing, frodo), entry(oneRing, sauron));
 assertThat(emptyMap).containsAnyOf();
 
 // assertion will fail
 assertThat(ringBearers).containsAnyOf(entry(oneRing, gandalf), entry(oneRing, aragorn));

Overrides:

containsAnyOf in class AbstractMapAssert<MapAssert<KEY,VALUE>,Map<KEY,VALUE>,KEY,VALUE>

Parameters:

entries - the given entries.

Returns:

this assertion object.

containsOnly

@SafeVarargs
public final MapAssert<KEY,VALUE> containsOnly(Map.Entry<? extends KEY,? extends VALUE>... 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<KEY,VALUE>,Map<KEY,VALUE>,KEY,VALUE>

Parameters:

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

Returns:

this assertions object

containsExactly

@SafeVarargs
public final MapAssert<KEY,VALUE> containsExactly(Map.Entry<? extends KEY,? extends VALUE>... 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 maps that have a consistent iteration order (i.e. don't use it with HashMap, prefer AbstractMapAssert.containsOnly(java.util.Map.Entry...) 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<KEY,VALUE>,Map<KEY,VALUE>,KEY,VALUE>

Parameters:

entries - the given entries.

Returns:

this assertions object

containsKeys

@SafeVarargs
public final MapAssert<KEY,VALUE> containsKeys(KEY... 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<KEY,VALUE>,Map<KEY,VALUE>,KEY,VALUE>

Parameters:

keys - the given keys

Returns:

this assertions object

containsOnlyKeys

@SafeVarargs
public final MapAssert<KEY,VALUE> containsOnlyKeys(KEY... 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<KEY,VALUE>,Map<KEY,VALUE>,KEY,VALUE>

Parameters:

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

Returns:

this assertions object

containsValues

@SafeVarargs
public final MapAssert<KEY,VALUE> containsValues(VALUE... 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<KEY,VALUE>,Map<KEY,VALUE>,KEY,VALUE>

Parameters:

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

Returns:

this assertions object

doesNotContainKeys

@SafeVarargs
public final MapAssert<KEY,VALUE> doesNotContainKeys(KEY... 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<KEY,VALUE>,Map<KEY,VALUE>,KEY,VALUE>

Parameters:

keys - the given keys

Returns:

this assertions object

doesNotContain

@SafeVarargs
public final MapAssert<KEY,VALUE> doesNotContain(Map.Entry<? extends KEY,? extends VALUE>... 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<KEY,VALUE>,Map<KEY,VALUE>,KEY,VALUE>

Parameters:

entries - the given entries.

Returns:

this assertion object.

extracting

@SafeVarargs
public final AbstractListAssert<?,List<? extends Object>,Object,ObjectAssert<Object>> extracting(Function<? super Map<KEY,VALUE>,Object>... extractors)

Description copied from class: AbstractObjectAssert

Use the given Functions to extract the values from the object under test into a list, this new list becoming the object under test.

If the given Functions extract the id, name and email values then the list will contain the id, name and email values of the object under test, you can then perform list assertions on the extracted values.

Example:

 // Create frodo, setting its name, age and Race (Race having a name property)
 TolkienCharacter frodo = new TolkienCharacter("Frodo", 33, HOBBIT);
 
 // let's verify Frodo's name, age and race name:
 assertThat(frodo).extracting(TolkienCharacter::getName, 
                              character -> character.age, // public field
                              character -> character.getRace().getName())
                  .containsExactly("Frodo", 33, "Hobbit");

Note that the order of extracted values is consistent with the order of given extractor functions.

Overrides:

extracting in class AbstractObjectAssert<MapAssert<KEY,VALUE>,Map<KEY,VALUE>>

Parameters:

extractors - the extractor functions to extract a value from an element of the Iterable under test.

Returns:

a new assertion object whose object under test is the list containing the extracted values