Package org.assertj.core.internal

Class Maps

  • public class Maps
extends java.lang.Object
    Reusable assertions for Maps.

    • Constructor Detail

      • Maps

        Maps()

    • Method Detail

      • instance

        public static Maps instance()

      • assertAllSatisfy

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

      • failsRequirements

        private static <K,​V> java.util.Optional<UnsatisfiedRequirement> failsRequirements​(java.util.function.BiConsumer<? super K,​? super V> entryRequirements,
                                                                                        java.util.Map.Entry<K,​V> entry)

      • assertAnySatisfy

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

      • assertNoneSatisfy

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

      • failsRestrictions

        private <V,​K> java.util.Optional<java.util.Map.Entry<K,​V>> failsRestrictions​(java.util.Map.Entry<K,​V> entry,
                                                                                         java.util.function.BiConsumer<? super K,​? super V> entryRequirements)

      • assertNullOrEmpty

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

      • assertEmpty

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

      • assertNotEmpty

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

      • assertHasSize

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

      • assertHasSizeGreaterThan

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

      • assertHasSizeGreaterThanOrEqualTo

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

      • assertHasSizeLessThan

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

      • assertHasSizeLessThanOrEqualTo

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

      • assertHasSizeBetween

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

      • assertHasSameSizeAs

        public void assertHasSameSizeAs​(AssertionInfo info,
                                java.util.Map<?,​?> map,
                                java.lang.Iterable<?> other)

      • assertHasSameSizeAs

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

      • assertHasSameSizeAs

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

      • assertContains

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

      • assertContainsAllEntriesOf

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

      • assertContainsAnyOf

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

      • assertHasEntrySatisfying

        public <K,​V> void assertHasEntrySatisfying​(AssertionInfo info,
                                                 java.util.Map<K,​V> actual,
                                                 K key,
                                                 Condition<? super V> valueCondition)

      • assertHasEntrySatisfying

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

      • assertHasEntrySatisfying

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

      • assertHasEntrySatisfyingConditions

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

      • assertHasKeySatisfying

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

      • assertHasValueSatisfying

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

      • assertDoesNotContain

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

      • assertContainsKeys

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

      • assertContainsKey

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

      • assertDoesNotContainKey

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

      • assertDoesNotContainKeys

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

      • assertContainsOnlyKeys

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

      • assertContainsOnlyKeys

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

      • assertContainsOnlyKeys

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

      • getFoundKeys

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

      • getNotFoundKeys

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

      • containsKey

        private static <K> boolean containsKey​(java.util.Map<K,​?> actual,
                                       K key)

      • getNotExpectedKeys

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

      • clone

        private static <K,​V> java.util.Map<K,​V> clone​(java.util.Map<K,​V> map)
                                                   throws java.lang.NoSuchMethodException
        Throws:
        java.lang.NoSuchMethodException

      • isMultiValueMapAdapterInstance

        private static boolean isMultiValueMapAdapterInstance​(java.util.Map<?,​?> map)

      • isInstanceOf

        private static boolean isInstanceOf​(java.lang.Object object,
                                    java.lang.String className)

      • assertContainsValue

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

      • assertContainsValues

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

      • assertDoesNotContainValue

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

      • getNotFoundValues

        private static <V> java.util.Set<V> getNotFoundValues​(java.util.Map<?,​V> actual,
                                                      V[] expectedValues)

      • containsValue

        private static <V> boolean containsValue​(java.util.Map<?,​V> actual,
                                         V value)

      • assertContainsOnly

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

      • getNotFoundEntries

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

      • getNotExpectedEntries

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

      • mapWithoutExpectedEntries

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

      • removeEntries

        private static <K,​V> void removeEntries​(java.util.Map<K,​V> map,
                                              java.util.Map.Entry<? extends K,​? extends V>[] entries)

      • assertContainsExactly

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

      • compareActualMapAndExpectedEntries

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

      • doCommonContainsCheck

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

      • failIfAnyEntryNotFoundInActualMap

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

      • entriesToMap

        private static <K,​V> java.util.Map<K,​V> entriesToMap​(java.util.Map.Entry<? extends K,​? extends V>[] entries)

      • failIfEmpty

        private static <K> void failIfEmpty​(K[] keys,
                                    java.lang.String errorMessage)

      • failIfEmpty

        private static <K,​V> void failIfEmpty​(java.util.Map.Entry<? extends K,​? extends V>[] entries)

      • failIfNullOrEmpty

        private static <K,​V> void failIfNullOrEmpty​(java.util.Map.Entry<? extends K,​? extends V>[] entries)

      • failIfNull

        private static <K,​V> void failIfNull​(java.util.Map.Entry<? extends K,​? extends V>[] entries)

      • failIfNull

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

      • containsEntry

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

      • assertNotNull

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

      • failIfEntriesIsEmptySinceActualIsNotEmpty

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