Class MapAssert<KEY,​VALUE>

    • Constructor Detail

      • MapAssert

        public MapAssert​(java.util.Map<KEY,​VALUE> actual)
    • Method Detail

      • contains

        @SafeVarargs
        public final MapAssert<KEY,​VALUE> contains​(java.util.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>,​java.util.Map<KEY,​VALUE>,​KEY,​VALUE>
        Parameters:
        entries - the given entries.
        Returns:
        this assertion object.
      • containsAnyOf

        @SafeVarargs
        public final MapAssert<KEY,​VALUE> containsAnyOf​(java.util.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>,​java.util.Map<KEY,​VALUE>,​KEY,​VALUE>
        Parameters:
        entries - the given entries.
        Returns:
        this assertion object.
      • containsOnly

        @SafeVarargs
        public final MapAssert<KEY,​VALUE> containsOnly​(java.util.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>,​java.util.Map<KEY,​VALUE>,​KEY,​VALUE>
        Parameters:
        entries - the entries that should be in the actual map.
      • containsExactly

        @SafeVarargs
        public final MapAssert<KEY,​VALUE> containsExactly​(java.util.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>,​java.util.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>,​java.util.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>,​java.util.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>,​java.util.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>,​java.util.Map<KEY,​VALUE>,​KEY,​VALUE>
        Parameters:
        keys - the given keys
      • doesNotContain

        @SafeVarargs
        public final MapAssert<KEY,​VALUE> doesNotContain​(java.util.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>,​java.util.Map<KEY,​VALUE>,​KEY,​VALUE>
        Parameters:
        entries - the given entries.
        Returns:
        this assertion object.