assertj
diff --git a/‎assertj-core/src/main/java/org/assertj/core/internal/Maps.java‎
Lines changed: 2 additions & 35 deletions b/‎assertj-core/src/main/java/org/assertj/core/internal/Maps.java‎
Lines changed: 2 additions & 35 deletions
diff --git a/‎assertj-core/src/test/java/org/assertj/core/internal/MapsBaseTest.java‎
Lines changed: 0 additions & 3 deletions b/‎assertj-core/src/test/java/org/assertj/core/internal/MapsBaseTest.java‎
Lines changed: 0 additions & 3 deletions
@@ -440,10 +440,6 @@ private static <K, V> Map<K, V> clone(Map<K, V> map) throws NoSuchMethodExceptio
     }
   }
 
-  private static boolean isSingletonMap(Map<?, ?> map) {
-    return map.size() == 1;
-  }
-
   private static boolean isMultiValueMapAdapterInstance(Map<?, ?> map) {
     return isInstanceOf(map, "org.springframework.util.MultiValueMapAdapter");
   }
@@ -457,16 +453,6 @@ private static boolean isInstanceOf(Object object, String className) {
     }
   }
 
-  private static <K, V> Map<K, V> createEmptyMap(Map<K, V> map) {
-    try {
-      Map<K, V> cloned = clone(map);
-      cloned.clear();
-      return cloned;
-    } catch (NoSuchMethodException | RuntimeException e) {
-      return new LinkedHashMap<>();
-    }
-  }
-
   public <K, V> void assertContainsValue(AssertionInfo info, Map<K, V> actual, V value) {
     assertNotNull(info, actual);
     if (!containsValue(actual, value)) throw failures.failure(info, shouldContainValue(actual, value));
@@ -565,16 +551,6 @@ public <K, V> void assertContainsExactly(AssertionInfo info, Map<K, V> actual, E
     failIfEntriesIsEmptySinceActualIsNotEmpty(info, actual, entries);
     assertHasSameSizeAs(info, actual, entries);
 
-    if (isSingletonMap(actual)) {
-      // shortcut for any singleton map but specifically for org.apache.commons.collections4.map.SingletonMap that is immutable
-      // and fail when we try to remove elements from them in compareActualMapAndExpectedEntries
-      // we only have to compare the map unique element
-      if (!actual.containsKey(entries[0].getKey()) || !actual.containsValue(entries[0].getValue())) {
-        throw failures.failure(info, elementsDifferAtIndex(actual.entrySet().iterator().next(), entries[0], 0));
-      }
-      return;
-    }
-
     Set<Entry<? extends K, ? extends V>> notFound = new LinkedHashSet<>();
     Set<Entry<? extends K, ? extends V>> notExpected = new LinkedHashSet<>();
 
@@ -583,15 +559,11 @@ public <K, V> void assertContainsExactly(AssertionInfo info, Map<K, V> actual, E
     if (notExpected.isEmpty() && notFound.isEmpty()) {
       // check entries order
       int index = 0;
-      // Create a map with the same type as actual to use the Map built-in comparison, ex: maps string case insensitive keys.
-      Map<K, V> emptyMap = createEmptyMap(actual);
       for (K keyFromActual : actual.keySet()) {
-        emptyMap.put(keyFromActual, null);
-        if (!emptyMap.containsKey(entries[index].getKey())) {
+        if (!deepEquals(keyFromActual, entries[index].getKey())) {
           Entry<K, V> actualEntry = entry(keyFromActual, actual.get(keyFromActual));
           throw failures.failure(info, elementsDifferAtIndex(actualEntry, entries[index], index));
         }
-        emptyMap.remove(keyFromActual);
         index++;
       }
       // all entries are in the same order.
@@ -605,12 +577,7 @@ private <K, V> void compareActualMapAndExpectedEntries(Map<K, V> actual, Entry<?
                                                          Set<Entry<? extends K, ? extends V>> notExpected,
                                                          Set<Entry<? extends K, ? extends V>> notFound) {
     Map<K, V> expectedEntries = entriesToMap(entries);
-    Map<K, V> actualEntries = null;
-    try {
-      actualEntries = clone(actual);
-    } catch (NoSuchMethodException | RuntimeException e) {
-      actualEntries = new LinkedHashMap<>(actual);
-    }
+    Map<K, V> actualEntries = new LinkedHashMap<>(actual);
     for (Entry<K, V> entry : expectedEntries.entrySet()) {
       if (containsEntry(actualEntries, entry(entry.getKey(), entry.getValue()))) {
         // this is an expected entry
 
@@ -70,9 +70,6 @@ public class MapsBaseTest extends WithPlayerData {
                                                                                              MapsBaseTest::persistentMap,
                                                                                              MapsBaseTest::persistentSortedMap);
 
-  protected static final Supplier<Map<String, String>> PERSISTENT_MAP = MapsBaseTest::persistentMap;
-  protected static final Supplier<Map<String, String>> PERSISTENT_SORTED_MAP = MapsBaseTest::persistentSortedMap;
-
   private static <K, V> PersistentMap<K, V> persistentMap() {
     return hibernateMap(PersistentMap::new, HashMap::new);
   }
Original file line number	Diff line number	Diff line change
`@@ -70,9 +70,6 @@ public class MapsBaseTest extends WithPlayerData {`
`70`	`70`	`MapsBaseTest::persistentMap,`
`71`	`71`	`MapsBaseTest::persistentSortedMap);`
`72`	`72`
`73`		`- protected static final Supplier<Map<String, String>> PERSISTENT_MAP = MapsBaseTest::persistentMap;`
`74`		`- protected static final Supplier<Map<String, String>> PERSISTENT_SORTED_MAP = MapsBaseTest::persistentSortedMap;`
`75`		`-`
`76`	`73`	`private static <K, V> PersistentMap<K, V> persistentMap() {`
`77`	`74`	`return hibernateMap(PersistentMap::new, HashMap::new);`
`78`	`75`	`}`