Class Maps

java.lang.Object
org.assertj.core.internal.Maps

public class Maps extends Object
Reusable assertions for Maps.
  • Field Details

  • Constructor Details

    • Maps

      Maps()
  • Method Details

    • instance

      public static Maps instance()
      Returns the singleton instance of this class.
      Returns:
      the singleton instance of this class.
    • assertNullOrEmpty

      public void assertNullOrEmpty(AssertionInfo info, Map<?,?> actual)
      Asserts that the given Map is null or empty.
      Parameters:
      info - contains information about the assertion.
      actual - the given map.
      Throws:
      AssertionError - if the given Map is not null *and* contains one or more entries.
    • assertEmpty

      public void assertEmpty(AssertionInfo info, Map<?,?> actual)
      Asserts that the given Map is empty.
      Parameters:
      info - contains information about the assertion.
      actual - the given Map.
      Throws:
      AssertionError - if the given Map is null.
      AssertionError - if the given Map is not empty.
    • assertNotEmpty

      public void assertNotEmpty(AssertionInfo info, Map<?,?> actual)
      Asserts that the given Map is not empty.
      Parameters:
      info - contains information about the assertion.
      actual - the given Map.
      Throws:
      AssertionError - if the given Map is null.
      AssertionError - if the given Map is empty.
    • assertHasSize

      public void assertHasSize(AssertionInfo info, Map<?,?> actual, int expectedSize)
      Asserts that the number of entries in the given Map is equal to the expected one.
      Parameters:
      info - contains information about the assertion.
      actual - the given Map.
      expectedSize - the expected size of actual.
      Throws:
      AssertionError - if the given Map is null.
      AssertionError - if the number of entries in the given Map is different than the expected one.
    • assertHasSameSizeAs

      public void assertHasSameSizeAs(AssertionInfo info, Map<?,?> map, Iterable<?> other)
      Asserts that the number of entries in the given Map has the same size as the other Iterable.
      Parameters:
      info - contains information about the assertion.
      map - the given Map.
      other - the group to compare
      Throws:
      AssertionError - if the given Map is null.
      AssertionError - if the given Iterable is null.
      AssertionError - if the number of entries in the given Map does not have the same size.
    • assertHasSameSizeAs

      public void assertHasSameSizeAs(AssertionInfo info, Map<?,?> map, Object other)
      Asserts that the number of entries in the given Map has the same size as the other array.
      Parameters:
      info - contains information about the assertion.
      map - the given Map.
      other - the group to compare
      Throws:
      AssertionError - if the given Map is null.
      AssertionError - if the given array is null.
      AssertionError - if the number of entries in the given Map does not have the same size.
    • assertHasSameSizeAs

      public void assertHasSameSizeAs(AssertionInfo info, Map<?,?> map, Map<?,?> other)
      Asserts that the size of the given Map is equal to the size of the other Map.
      Parameters:
      info - contains information about the assertion.
      map - the given Map.
      other - the other Map to compare
      Throws:
      NullPointerException - if the other Map is null.
      AssertionError - if the given Map is null.
      AssertionError - if the size of the given Map is not equal to the other Map size
    • assertContains

      public <K, V> void assertContains(AssertionInfo info, Map<K,V> actual, Map.Entry<? extends K,? extends V>[] entries)
      Asserts that the given Map contains the given entries, in any order.
      Parameters:
      info - contains information about the assertion.
      actual - the given Map.
      entries - the entries that are expected to be in the given Map.
      Throws:
      NullPointerException - if the array of entries is null.
      IllegalArgumentException - if the array of entries is empty.
      NullPointerException - if any of the entries in the given array is null.
      AssertionError - if the given Map is null.
      AssertionError - if the given Map does not contain the given entries.
    • assertContainsAnyOf

      public <K, V> void assertContainsAnyOf(AssertionInfo info, Map<K,V> actual, Map.Entry<? extends K,? extends V>[] entries)
    • assertHasEntrySatisfying

      public <K, V> void assertHasEntrySatisfying(AssertionInfo info, Map<K,V> actual, K key, Condition<? super V> valueCondition)
      Verifies that the given Map contains the value for given key that satisfy given valueCondition.
      Parameters:
      info - contains information about the assertion.
      actual - the given Map.
      key - he given key to check.
      valueCondition - the given condition for check value.
      Throws:
      NullPointerException - if the given values is null.
      AssertionError - if the actual map is null.
      AssertionError - if the actual map not contains the given key.
      AssertionError - if the actual map contains the given key, but value not match the given valueCondition.
      Since:
      2.6.0 / 3.6.0
    • assertHasEntrySatisfying

      public <K, V> void assertHasEntrySatisfying(AssertionInfo info, Map<K,V> actual, K key, Consumer<? super V> valueRequirements)
      Verifies that the Map contains the value for given key that satisfy given valueRequirements.
      Parameters:
      info - contains information about the assertion.
      actual - the given Map.
      key - he given key to check.
      valueRequirements - the given requirements for check value.
      Throws:
      NullPointerException - if the given values is null.
      AssertionError - if the actual map is null.
      AssertionError - if the actual map not contains the given key.
      AssertionError - if the actual map contains the given key, but value not pass the given valueRequirements.
    • assertHasEntrySatisfying

      public <K, V> void assertHasEntrySatisfying(AssertionInfo info, Map<K,V> actual, Condition<? super Map.Entry<K,V>> entryCondition)
      Verifies that the given Map contains an entry satisfying given entryCondition.
      Parameters:
      info - contains information about the assertion.
      actual - the given Map.
      entryCondition - the condition for searching entry.
      Throws:
      NullPointerException - if the given condition is null.
      AssertionError - if the actual map is null.
      AssertionError - if there is no entry matching given entryCondition.
      Since:
      2.7.0 / 3.7.0
    • assertHasEntrySatisfyingConditions

      public <K, V> void assertHasEntrySatisfyingConditions(AssertionInfo info, Map<K,V> actual, Condition<? super K> keyCondition, Condition<? super V> valueCondition)
      Verifies that the given Map contains an entry with key satisfying keyCondition and value satisfying valueCondition.
      Parameters:
      info - contains information about the assertion.
      actual - the given Map.
      keyCondition - the condition for entry key.
      valueCondition - the condition for entry value.
      Throws:
      NullPointerException - if any of the given conditions is null.
      AssertionError - if the actual map is null.
      AssertionError - if there is no entry matching given keyCondition and valueCondition.
      Since:
      2.7.0 / 3.7.0
    • assertHasKeySatisfying

      public <K> void assertHasKeySatisfying(AssertionInfo info, Map<K,?> actual, Condition<? super K> keyCondition)
      Verifies that the given Map contains an entry with key satisfying keyCondition.
      Parameters:
      info - contains information about the assertion.
      actual - the given Map.
      keyCondition - the condition for key search.
      Throws:
      NullPointerException - if the given condition is null.
      AssertionError - if the actual map is null.
      AssertionError - if there is no key matching given keyCondition.
      Since:
      2.7.0 / 3.7.0
    • assertHasValueSatisfying

      public <V> void assertHasValueSatisfying(AssertionInfo info, Map<?,V> actual, Condition<? super V> valueCondition)
      Verifies that the given Map contains an entry with value satisfying valueCondition.
      Parameters:
      info - contains information about the assertion.
      actual - the given Map.
      valueCondition - the condition for value search.
      Throws:
      NullPointerException - if the given condition is null.
      AssertionError - if the actual map is null.
      AssertionError - if there is no value matching given valueCondition.
      Since:
      2.7.0 / 3.7.0
    • assertDoesNotContain

      public <K, V> void assertDoesNotContain(AssertionInfo info, Map<K,V> actual, Map.Entry<? extends K,? extends V>[] entries)
      Asserts that the given Map does not contain the given entries.
      Parameters:
      info - contains information about the assertion.
      actual - the given Map.
      entries - the entries that are expected to be in the given Map.
      Throws:
      NullPointerException - if the array of entries is null.
      IllegalArgumentException - if the array of entries is empty.
      NullPointerException - if any of the entries in the given array is null.
      AssertionError - if the given Map is null.
      AssertionError - if the given Map contains any of the given entries.
    • assertContainsKeys

      public <K, V> void assertContainsKeys(AssertionInfo info, Map<K,V> actual, K... keys)
      Verifies that the actual map contain the given key.
      Parameters:
      info - contains information about the assertion.
      actual - the given Map.
      keys - the given keys
      Throws:
      AssertionError - if the actual map is null.
      AssertionError - if the actual map not contains the given key.
    • assertDoesNotContainKey

      public <K, V> void assertDoesNotContainKey(AssertionInfo info, Map<K,V> actual, K key)
      Verifies that the actual map not contains the given key.
      Parameters:
      info - contains information about the assertion.
      actual - the given Map.
      key - the given key
      Throws:
      AssertionError - if the actual map is null.
      AssertionError - if the actual map contains the given key.
    • assertDoesNotContainKeys

      public <K, V> void assertDoesNotContainKeys(AssertionInfo info, Map<K,V> actual, K... keys)
      Verifies that the actual map not contains all the given keys.
      Parameters:
      info - contains information about the assertion.
      actual - the given Map.
      keys - the given keys
      Throws:
      AssertionError - if the actual map is null.
      AssertionError - if the actual map contains all the given keys.
    • assertContainsOnlyKeys

      public <K, V> void assertContainsOnlyKeys(AssertionInfo info, Map<K,V> actual, K... keys)
      Verifies that the actual map contains only the given keys and nothing else, in any order.
      Parameters:
      info - contains information about the assertion.
      actual - the given Map.
      keys - the keys that are expected to be in the given Map.
      Throws:
      NullPointerException - if the array of keys is null.
      IllegalArgumentException - if the array of keys is empty.
      AssertionError - if the given Map is null.
      AssertionError - if the given Map does not contain the given keys or if the given Map contains keys that are not in the given array.
    • assertContainsValue

      public <K, V> void assertContainsValue(AssertionInfo info, Map<K,V> actual, V value)
      Verifies that the actual map contain the given value.
      Parameters:
      info - contains information about the assertion.
      actual - the given Map.
      value - the given value
      Throws:
      AssertionError - if the actual map is null.
      AssertionError - if the actual map not contains the given value.
    • assertContainsValues

      public <K, V> void assertContainsValues(AssertionInfo info, Map<K,V> actual, V... values)
      Verifies that the actual map contain the given values.
      Parameters:
      info - contains information about the assertion.
      actual - the given Map.
      values - the given values
      Throws:
      AssertionError - if the actual map is null.
      AssertionError - if the actual map not contains the given values.
      NullPointerException - if values vararg is null.
    • assertDoesNotContainValue

      public <K, V> void assertDoesNotContainValue(AssertionInfo info, Map<K,V> actual, V value)
      Verifies that the actual map not contains the given value.
      Parameters:
      info - contains information about the assertion.
      actual - the given Map.
      value - the given value
      Throws:
      AssertionError - if the actual map is null.
      AssertionError - if the actual map contains the given value.
    • assertContainsOnly

      public <K, V> void assertContainsOnly(AssertionInfo info, Map<K,V> actual, Map.Entry<? extends K,? extends V>... entries)
      Verifies that the actual map contains only the given entries and nothing else, in any order.
      Parameters:
      info - contains information about the assertion.
      actual - the given Map.
      entries - the entries that should be in the actual map.
      Throws:
      AssertionError - if the actual map is null.
      NullPointerException - if the given entries array is null.
      IllegalArgumentException - if the given entries array is empty.
      AssertionError - if the actual map does not contain the given entries, i.e. the actual map contains some or none of the given entries, or the actual map contains more entries than the given ones.
    • assertContainsExactly

      public <K, V> void assertContainsExactly(AssertionInfo info, Map<K,V> actual, 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. don't use it with HashMap).
      Parameters:
      info - contains information about the assertion.
      actual - the given Map.
      entries - the given entries.
      Throws:
      NullPointerException - if the given entries array is null.
      AssertionError - if the actual map is null.
      IllegalArgumentException - if the given entries array is empty.
      AssertionError - if the actual map does not contain the given entries with same order, i.e. the actual map contains some or none of the given entries, or the actual map contains more entries than the given ones or entries are the same but the order is not.
    • compareActualMapAndExpectedKeys

      private <K, V> void compareActualMapAndExpectedKeys(Map<K,V> actual, K[] keys, Set<K> notExpected, Set<K> notFound)
    • compareActualMapAndExpectedEntries

      private <K, V> void compareActualMapAndExpectedEntries(Map<K,V> actual, Map.Entry<? extends K,? extends V>[] entries, Set<Map.Entry<? extends K,? extends V>> notExpected, Set<Map.Entry<? extends K,? extends V>> notFound)
    • doCommonContainsCheck

      private <K, V> void doCommonContainsCheck(AssertionInfo info, Map<K,V> actual, Map.Entry<? extends K,? extends V>[] entries)
    • entriesToMap

      private static <K, V> Map<K,V> entriesToMap(Map.Entry<? extends K,? extends V>[] entries)
    • failIfEmpty

      private static <K> void failIfEmpty(K[] keys)
    • failIfEmpty

      private static <K, V> void failIfEmpty(Map.Entry<? extends K,? extends V>[] entries)
    • failIfNullOrEmpty

      private static <K, V> void failIfNullOrEmpty(Map.Entry<? extends K,? extends V>[] entries)
    • failIfNull

      private static <K> void failIfNull(K[] keys)
    • failIfNull

      private static <K, V> void failIfNull(Map.Entry<? extends K,? extends V>[] entries)
    • containsEntry

      private <K, V> boolean containsEntry(Map<K,V> actual, Map.Entry<? extends K,? extends V> entry)
    • assertNotNull

      private void assertNotNull(AssertionInfo info, Map<?,?> actual)
    • failIfEmptySinceActualIsNotEmpty

      private static <K, V> void failIfEmptySinceActualIsNotEmpty(Map.Entry<? extends K,? extends V>[] values)