Package org.assertj.core.internal

Class Maps

  • public class Maps
extends Object
    Reusable assertions for Maps.
    Author:
    Alex Ruiz, Nicolas François, dorzey

    • Constructor Detail

      • Maps

        Maps()

    • Method Detail

      • instance

        public static Maps instance()

      • assertAllSatisfy

        public <K,​V> void assertAllSatisfy​(AssertionInfo info,
                                         Map<K,​V> actual,
                                         BiConsumer<? super K,​? super V> entryRequirements)

      • assertAnySatisfy

        public <K,​V> void assertAnySatisfy​(AssertionInfo info,
                                         Map<K,​V> actual,
                                         BiConsumer<? super K,​? super V> entryRequirements)

      • assertNoneSatisfy

        public <K,​V> void assertNoneSatisfy​(AssertionInfo info,
                                          Map<K,​V> actual,
                                          BiConsumer<? super K,​? super V> entryRequirements)

      • assertNullOrEmpty

        public void assertNullOrEmpty​(AssertionInfo info,
                              Map<?,​?> actual)

      • assertEmpty

        public void assertEmpty​(AssertionInfo info,
                        Map<?,​?> actual)

      • assertNotEmpty

        public void assertNotEmpty​(AssertionInfo info,
                           Map<?,​?> actual)

      • assertHasSize

        public void assertHasSize​(AssertionInfo info,
                          Map<?,​?> actual,
                          int expectedSize)

      • assertHasSizeGreaterThan

        public void assertHasSizeGreaterThan​(AssertionInfo info,
                                     Map<?,​?> actual,
                                     int boundary)

      • assertHasSizeGreaterThanOrEqualTo

        public void assertHasSizeGreaterThanOrEqualTo​(AssertionInfo info,
                                              Map<?,​?> actual,
                                              int boundary)

      • assertHasSizeLessThan

        public void assertHasSizeLessThan​(AssertionInfo info,
                                  Map<?,​?> actual,
                                  int boundary)

      • assertHasSizeLessThanOrEqualTo

        public void assertHasSizeLessThanOrEqualTo​(AssertionInfo info,
                                           Map<?,​?> actual,
                                           int boundary)

      • assertHasSizeBetween

        public void assertHasSizeBetween​(AssertionInfo info,
                                 Map<?,​?> actual,
                                 int lowerBoundary,
                                 int higherBoundary)

      • assertHasSameSizeAs

        public void assertHasSameSizeAs​(AssertionInfo info,
                                Map<?,​?> map,
                                Object other)

      • assertHasSameSizeAs

        public void assertHasSameSizeAs​(AssertionInfo info,
                                Map<?,​?> map,
                                Map<?,​?> other)

      • assertContains

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

      • assertContainsAllEntriesOf

        public <K,​V> void assertContainsAllEntriesOf​(AssertionInfo info,
                                                   Map<K,​V> actual,
                                                   Map<? extends K,​? extends V> other)

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

      • assertHasEntrySatisfying

        public <K,​V> void assertHasEntrySatisfying​(AssertionInfo info,
                                                 Map<K,​V> actual,
                                                 K key,
                                                 Consumer<? super V> valueRequirements)

      • assertHasEntrySatisfying

        public <K,​V> void assertHasEntrySatisfying​(AssertionInfo info,
                                                 Map<K,​V> actual,
                                                 Condition<? super Map.Entry<K,​V>> entryCondition)

      • assertHasEntrySatisfyingConditions

        public <K,​V> void assertHasEntrySatisfyingConditions​(AssertionInfo info,
                                                           Map<K,​V> actual,
                                                           Condition<? super K> keyCondition,
                                                           Condition<? super V> valueCondition)

      • assertHasKeySatisfying

        public <K> void assertHasKeySatisfying​(AssertionInfo info,
                                       Map<K,​?> actual,
                                       Condition<? super K> keyCondition)

      • assertHasValueSatisfying

        public <V> void assertHasValueSatisfying​(AssertionInfo info,
                                         Map<?,​V> actual,
                                         Condition<? super V> valueCondition)

      • assertDoesNotContain

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

      • assertContainsKeys

        public <K,​V> void assertContainsKeys​(AssertionInfo info,
                                           Map<K,​V> actual,
                                           K[] keys)

      • assertContainsKey

        public <K,​V> void assertContainsKey​(AssertionInfo info,
                                          Map<K,​V> actual,
                                          K key)

      • assertDoesNotContainKey

        public <K,​V> void assertDoesNotContainKey​(AssertionInfo info,
                                                Map<K,​V> actual,
                                                K key)

      • assertDoesNotContainKeys

        public <K,​V> void assertDoesNotContainKeys​(AssertionInfo info,
                                                 Map<K,​V> actual,
                                                 K[] keys)

      • assertContainsOnlyKeys

        public <K,​V> void assertContainsOnlyKeys​(AssertionInfo info,
                                               Map<K,​V> actual,
                                               K[] keys)

      • assertContainsOnlyKeys

        public <K,​V> void assertContainsOnlyKeys​(AssertionInfo info,
                                               Map<K,​V> actual,
                                               Iterable<? extends K> keys)

      • assertContainsOnlyKeys

        private <K,​V> void assertContainsOnlyKeys​(AssertionInfo info,
                                                Map<K,​V> actual,
                                                String placeholderForErrorMessages,
                                                K[] keys)

      • getFoundKeys

        private static <K> Set<K> getFoundKeys​(Map<K,​?> actual,
                                       K[] expectedKeys)

      • getNotFoundKeys

        private static <K> Set<K> getNotFoundKeys​(Map<K,​?> actual,
                                          K[] expectedKeys)

      • getNotExpectedKeys

        private static <K> Set<K> getNotExpectedKeys​(Map<K,​?> actual,
                                             K[] expectedKeys)

      • assertContainsValue

        public <K,​V> void assertContainsValue​(AssertionInfo info,
                                            Map<K,​V> actual,
                                            V value)

      • assertContainsValues

        public <K,​V> void assertContainsValues​(AssertionInfo info,
                                             Map<K,​V> actual,
                                             V[] values)

      • assertDoesNotContainValue

        public <K,​V> void assertDoesNotContainValue​(AssertionInfo info,
                                                  Map<K,​V> actual,
                                                  V value)

      • assertContainsOnly

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

      • getNotFoundEntries

        private static <K,​V> Set<Map.Entry<? extends K,​? extends V>> getNotFoundEntries​(Map<K,​V> actual,
                                                                                            Map.Entry<? extends K,​? extends V>[] entries)

      • getNotExpectedEntries

        private static <K,​V> Set<Map.Entry<K,​V>> getNotExpectedEntries​(Map<K,​V> actual,
                                                                           Map.Entry<? extends K,​? extends V>[] entries)

      • mapWithoutExpectedEntries

        private static <K,​V> Map<K,​V> mapWithoutExpectedEntries​(Map<K,​V> actual,
                                                                    Map.Entry<? extends K,​? extends V>[] expectedEntries)

      • assertContainsExactly

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

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

      • failIfAnyEntryNotFoundInActualMap

        private <K,​V> void failIfAnyEntryNotFoundInActualMap​(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,
                                    String errorMessage)

      • 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,​V> void failIfNull​(Map.Entry<? extends K,​? extends V>[] entries)

      • failIfNull

        private static <K,​V> void failIfNull​(Map<? extends K,​? extends V> map)

      • containsEntry

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

      • assertNotNull

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

      • failIfEntriesIsEmptyEmptySinceActualIsNotEmpty

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