Package 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).

  • Constructor Details

  • Method Details

    • 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.

    • 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.

    • 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

    • 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.

    • 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.

    • 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

    • 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.