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.