How to use compareUnorderedMap method of org.assertj.core.internal.DeepDifference class

Best Assertj code snippet using org.assertj.core.internal.DeepDifference.compareUnorderedMap

Source:RecursiveComparisonDifferenceCalculator.java

...221      }222      // Compare two Unordered Maps. This is a slightly more expensive comparison because order cannot be assumed, therefore a223      // temporary Map must be created, however the comparison still runs in O(N) time.224      if (dualValue.isExpectedFieldAMap()) {225        compareUnorderedMap(dualValue, comparisonState);226        continue;227      }228      if (shouldCompareDualValue(recursiveComparisonConfiguration, dualValue)) {229        if (!actualFieldValue.equals(expectedFieldValue)) comparisonState.addDifference(dualValue);230        continue;231      }232      Class<?> actualFieldValueClass = actualFieldValue.getClass();233      Class<?> expectedFieldClass = expectedFieldValue.getClass();234      if (recursiveComparisonConfiguration.isInStrictTypeCheckingMode() && expectedTypeIsNotSubtypeOfActualType(dualValue)) {235        comparisonState.addDifference(dualValue, STRICT_TYPE_ERROR, expectedFieldClass.getName(),236                                      actualFieldValueClass.getName());237        continue;238      }239      Set<String> actualNonIgnoredFieldsNames = recursiveComparisonConfiguration.getNonIgnoredActualFieldNames(dualValue);240      Set<String> expectedFieldsNames = getFieldsNames(expectedFieldClass);241      // Check if expected has more fields than actual, in that case the additional fields are reported as difference242      if (!expectedFieldsNames.containsAll(actualNonIgnoredFieldsNames)) {243        // report missing fields in actual244        Set<String> actualFieldsNamesNotInExpected = newHashSet(actualNonIgnoredFieldsNames);245        actualFieldsNamesNotInExpected.removeAll(expectedFieldsNames);246        String missingFields = actualFieldsNamesNotInExpected.toString();247        String expectedClassName = expectedFieldClass.getName();248        String actualClassName = actualFieldValueClass.getName();249        String missingFieldsDescription = format(MISSING_FIELDS, actualClassName, expectedClassName,250                                                 expectedFieldClass.getSimpleName(), actualFieldValueClass.getSimpleName(),251                                                 missingFields);252        comparisonState.addDifference(dualValue, missingFieldsDescription);253      } else { // TODO remove else to report more diff254        // compare actual's fields against expected :255        // - if actual has more fields than expected, the additional fields are ignored as expected is the reference256        for (String actualFieldName : actualNonIgnoredFieldsNames) {257          if (expectedFieldsNames.contains(actualFieldName)) {258            DualValue newDualValue = new DualValue(currentPath, actualFieldName,259                                                   COMPARISON.getSimpleValue(actualFieldName, actualFieldValue),260                                                   COMPARISON.getSimpleValue(actualFieldName, expectedFieldValue));261            comparisonState.registerForComparison(newDualValue);262          }263        }264      }265    }266    return comparisonState.getDifferences();267  }268  private static boolean shouldCompareDualValue(RecursiveComparisonConfiguration recursiveComparisonConfiguration,269                                                final DualValue dualValue) {270    return !recursiveComparisonConfiguration.shouldIgnoreOverriddenEqualsOf(dualValue)271           && hasOverriddenEquals(dualValue.actual.getClass());272  }273  // avoid comparing enum recursively since they contain static fields which are ignored in recursive comparison274  // this would make different field enum value to be considered the same!275  private static void compareAsEnums(final DualValue dualValue,276                                     ComparisonState comparisonState,277                                     RecursiveComparisonConfiguration recursiveComparisonConfiguration) {278    if (recursiveComparisonConfiguration.isInStrictTypeCheckingMode()) {279      // we can use == for comparison which checks both actual and expected values and types are the same280      if (dualValue.actual != dualValue.expected) comparisonState.addDifference(dualValue);281      return;282    }283    if (!dualValue.isActualAnEnum()) {284      comparisonState.addDifference(dualValue, differentTypeErrorMessage(dualValue, "an enum"));285      return;286    }287    // both actual and expected are enums288    Enum<?> actualEnum = (Enum<?>) dualValue.actual;289    Enum<?> expectedEnum = (Enum<?>) dualValue.expected;290    // we must only compare actual and expected enum by value but not by type291    if (!actualEnum.name().equals(expectedEnum.name())) comparisonState.addDifference(dualValue);292  }293  private static boolean shouldHonorOverriddenEquals(DualValue dualValue,294                                                     RecursiveComparisonConfiguration recursiveComparisonConfiguration) {295    boolean shouldNotIgnoreOverriddenEqualsIfAny = !recursiveComparisonConfiguration.shouldIgnoreOverriddenEqualsOf(dualValue);296    return shouldNotIgnoreOverriddenEqualsIfAny && dualValue.actual != null && hasOverriddenEquals(dualValue.actual.getClass());297  }298  private static void compareArrays(DualValue dualValue, ComparisonState comparisonState) {299    if (!dualValue.isActualFieldAnArray()) {300      // at the moment we only allow comparing arrays with arrays but we might allow comparing to collections later on301      // but only if we are not in strict type mode.302      comparisonState.addDifference(dualValue, differentTypeErrorMessage(dualValue, "an array"));303      return;304    }305    // both values in dualValue are arrays306    int actualArrayLength = Array.getLength(dualValue.actual);307    int expectedArrayLength = Array.getLength(dualValue.expected);308    if (actualArrayLength != expectedArrayLength) {309      comparisonState.addDifference(dualValue, DIFFERENT_SIZE_ERROR, "arrays", actualArrayLength, expectedArrayLength);310      // no need to inspect elements, arrays are not equal as they don't have the same size311      return;312    }313    // register each pair of actual/expected elements for recursive comparison314    List<String> arrayFieldPath = dualValue.getPath();315    for (int i = 0; i < actualArrayLength; i++) {316      Object actualElement = Array.get(dualValue.actual, i);317      Object expectedElement = Array.get(dualValue.expected, i);318      // TODO add [i] to the path ?319      comparisonState.registerForComparison(new DualValue(arrayFieldPath, actualElement, expectedElement));320    }321  }322  /*323   * Deeply compare two Collections that must be same length and in same order.324   */325  private static void compareOrderedCollections(DualValue dualValue, ComparisonState comparisonState) {326    if (!dualValue.isActualFieldAnOrderedCollection()) {327      // at the moment if expected is an ordered collection then actual should also be one328      comparisonState.addDifference(dualValue, ACTUAL_NOT_ORDERED_COLLECTION, dualValue.actual.getClass().getCanonicalName());329      return;330    }331    Collection<?> actualCollection = (Collection<?>) dualValue.actual;332    Collection<?> expectedCollection = (Collection<?>) dualValue.expected;333    if (actualCollection.size() != expectedCollection.size()) {334      comparisonState.addDifference(dualValue, DIFFERENT_SIZE_ERROR,335                                    "collections", actualCollection.size(), expectedCollection.size());336      // no need to inspect elements, arrays are not equal as they don't have the same size337      return;338    }339    // register pair of elements with same index for later comparison as we compare elements in order340    Iterator<?> expectedIterator = expectedCollection.iterator();341    List<String> path = dualValue.getPath();342    actualCollection.stream()343                    .map(element -> new DualValue(path, element, expectedIterator.next()))344                    .forEach(comparisonState::registerForComparison);345  }346  private static String differentTypeErrorMessage(DualValue dualValue, String actualTypeDescription) {347    return format(DIFFERENT_ACTUAL_AND_EXPECTED_FIELD_TYPES,348                  actualTypeDescription, dualValue.actual.getClass().getCanonicalName());349  }350  private static void compareUnorderedIterables(DualValue dualValue, ComparisonState comparisonState) {351    if (!dualValue.isActualFieldAnIterable()) {352      // at the moment we only compare iterable with iterables (but we might allow arrays too)353      comparisonState.addDifference(dualValue, differentTypeErrorMessage(dualValue, "an iterable"));354      return;355    }356    Iterable<?> actual = (Iterable<?>) dualValue.actual;357    Iterable<?> expected = (Iterable<?>) dualValue.expected;358    int actualSize = sizeOf(actual);359    int expectedSize = sizeOf(expected);360    if (actualSize != expectedSize) {361      comparisonState.addDifference(dualValue, DIFFERENT_SIZE_ERROR, "collections", actualSize, expectedSize);362      // no need to inspect elements, iterables are not equal as they don't have the same size363      return;364      // TODO instead we could register the diff between expected and actual that is:365      // - unexpected actual elements (the ones not matching any expected)366      // - expected elements not found in actual.367    }368    List<String> path = dualValue.getPath();369    // copy expected as we will remove elements found in actual370    Collection<?> expectedCopy = new LinkedList<>(toCollection(expected));371    for (Object actualElement : actual) {372      // compare recursively actualElement to all remaining expected elements373      Iterator<?> expectedIterator = expectedCopy.iterator();374      while (expectedIterator.hasNext()) {375        Object expectedElement = expectedIterator.next();376        // we need to get the currently visited dual values otherwise a cycle would cause an infinite recursion.377        List<ComparisonDifference> differences = determineDifferences(actualElement, expectedElement, path, false,378                                                                      comparisonState.visitedDualValues,379                                                                      comparisonState.recursiveComparisonConfiguration);380        if (differences.isEmpty()) {381          // we found an element in expected matching actualElement, we must remove it as if actual matches expected382          // it means for each actual element there is one and only matching expected element.383          expectedIterator.remove();384          // jump to next actual element check385          break;386        }387      }388    }389    // expectedCopy not empty = there was at least one actual element not matching any expected elements.390    if (!expectedCopy.isEmpty()) comparisonState.addDifference(dualValue);391    // TODO instead we could register the diff between expected and actual that is:392    // - unexpected actual elements (the ones not matching any expected)393    // - expected elements not found in actual.394  }395  private static <K, V> void compareSortedMap(DualValue dualValue, ComparisonState comparisonState) {396    if (!dualValue.isActualFieldASortedMap()) {397      // at the moment we only compare iterable with iterables (but we might allow arrays too)398      comparisonState.addDifference(dualValue, differentTypeErrorMessage(dualValue, "a sorted map"));399      return;400    }401    Map<?, ?> actualMap = (Map<?, ?>) dualValue.actual;402    @SuppressWarnings("unchecked")403    Map<K, V> expectedMap = (Map<K, V>) dualValue.expected;404    if (actualMap.size() != expectedMap.size()) {405      comparisonState.addDifference(dualValue, DIFFERENT_SIZE_ERROR, "sorted maps", actualMap.size(), expectedMap.size());406      // no need to inspect entries, maps are not equal as they don't have the same size407      return;408      // TODO instead we could register the diff between expected and actual that is:409      // - unexpected actual entries (the ones not matching any expected)410      // - expected entries not found in actual.411    }412    List<String> path = dualValue.getPath();413    Iterator<Map.Entry<K, V>> expectedMapEntries = expectedMap.entrySet().iterator();414    for (Map.Entry<?, ?> actualEntry : actualMap.entrySet()) {415      Map.Entry<?, ?> expectedEntry = expectedMapEntries.next();416      // Must split the Key and Value so that Map.Entry's equals() method is not used.417      comparisonState.registerForComparison(new DualValue(path, actualEntry.getKey(), expectedEntry.getKey()));418      comparisonState.registerForComparison(new DualValue(path, actualEntry.getValue(), expectedEntry.getValue()));419    }420  }421  private static void compareUnorderedMap(DualValue dualValue, ComparisonState comparisonState) {422    if (!dualValue.isActualFieldAMap()) {423      comparisonState.addDifference(dualValue, differentTypeErrorMessage(dualValue, "a map"));424      return;425    }426    Map<?, ?> actualMap = (Map<?, ?>) dualValue.actual;427    Map<?, ?> expectedMap = (Map<?, ?>) dualValue.expected;428    if (actualMap.size() != expectedMap.size()) {429      comparisonState.addDifference(dualValue, DIFFERENT_SIZE_ERROR, "maps", actualMap.size(), expectedMap.size());430      // no need to inspect entries, maps are not equal as they don't have the same size431      return;432      // TODO instead we could register the diff between expected and actual that is:433      // - unexpected actual entries (the ones not matching any expected)434      // - expected entries not found in actual.435    }...

Source:DeepDifference.java

...242      // Compare two Unordered Maps. This is a slightly more expensive comparison because243      // order cannot be assumed, therefore a temporary Map must be created, however the244      // comparison still runs in O(N) time.245      if (key1 instanceof Map) {246        if (!compareUnorderedMap((Map<?, ?>) key1, (Map<?, ?>) key2, currentPath, toCompare, visited)) {247          differences.add(new Difference(currentPath, key1, key2));248          continue;249        }250        continue;251      }252      if (hasCustomEquals(key1.getClass())) {253        if (!key1.equals(key2)) {254          differences.add(new Difference(currentPath, key1, key2));255          continue;256        }257        continue;258      }259      Set<String> key1FieldsNames = getFieldsNames(getDeclaredFieldsIncludingInherited(key1.getClass()));260      Set<String> key2FieldsNames = getFieldsNames(getDeclaredFieldsIncludingInherited(key2.getClass()));261      if (!key2FieldsNames.containsAll(key1FieldsNames)) {262        differences.add(new Difference(currentPath, key1, key2));263      } else {264        for (String fieldName : key1FieldsNames) {265          List<String> path = new ArrayList<>(currentPath);266          path.add(fieldName);267          DualKey dk = new DualKey(path,268                                   COMPARISON.getSimpleValue(fieldName, key1),269                                   COMPARISON.getSimpleValue(fieldName, key2));270          if (!visited.contains(dk)) {271            toCompare.addFirst(dk);272          }273        }274      }275    }276    return differences;277  }278  private static boolean hasCustomComparator(DualKey dualKey, Map<String, Comparator<?>> comparatorByPropertyOrField,279                                             TypeComparators comparatorByType) {280    String fieldName = dualKey.getConcatenatedPath();281    if (comparatorByPropertyOrField.containsKey(fieldName)) return true;282    // we know that dualKey.key1 != dualKey.key2 at this point, so one the key is not null283    Class<?> keyType = dualKey.key1 != null ? dualKey.key1.getClass() : dualKey.key2.getClass();284    return comparatorByType.get(keyType) != null;285  }286  private static Deque<DualKey> initStack(Object a, Object b, List<String> parentPath,287                                          Map<String, Comparator<?>> comparatorByPropertyOrField,288                                          TypeComparators comparatorByType) {289    Deque<DualKey> stack = new LinkedList<>();290    boolean isRootObject = parentPath == null;291    List<String> currentPath = isRootObject ? new ArrayList<String>() : parentPath;292    DualKey basicDualKey = new DualKey(currentPath, a, b);293    if (a != null && b != null && !isContainerType(a) && !isContainerType(b)294        && (isRootObject || !hasCustomComparator(basicDualKey, comparatorByPropertyOrField, comparatorByType))) {295      // disregard the equals method and start comparing fields296      Set<String> aFieldsNames = getFieldsNames(getDeclaredFieldsIncludingInherited(a.getClass()));297      if (!aFieldsNames.isEmpty()) {298        Set<String> bFieldsNames = getFieldsNames(getDeclaredFieldsIncludingInherited(b.getClass()));299        if (!bFieldsNames.containsAll(aFieldsNames)) {300          stack.addFirst(basicDualKey);301        } else {302          for (String fieldName : aFieldsNames) {303            List<String> fieldPath = new ArrayList<>(currentPath);304            fieldPath.add(fieldName);305            DualKey dk = new DualKey(fieldPath,306                                     COMPARISON.getSimpleValue(fieldName, a),307                                     COMPARISON.getSimpleValue(fieldName, b));308            stack.addFirst(dk);309          }310        }311      } else {312        stack.addFirst(basicDualKey);313      }314    } else {315      stack.addFirst(basicDualKey);316    }317    return stack;318  }319  private static Set<String> getFieldsNames(Collection<Field> fields) {320    Set<String> fieldNames = new LinkedHashSet<>();321    for (Field field : fields) {322      fieldNames.add(field.getName());323    }324    return fieldNames;325  }326  private static boolean isContainerType(Object o) {327    return o instanceof Collection || o instanceof Map;328  }329  /**330   * Deeply compare to Arrays []. Both arrays must be of the same type, same331   * length, and all elements within the arrays must be deeply equal in order332   * to return true.333   * 334   * @param array1 [] type (Object[], String[], etc.)335   * @param array2 [] type (Object[], String[], etc.)336   * @param path the path to the arrays to compare337   * @param toCompare add items to compare to the Stack (Stack versus recursion)338   * @param visited Set of objects already compared (prevents cycles)339   * @return true if the two arrays are the same length and contain deeply340   *         equivalent items.341   */342  private static boolean compareArrays(Object array1, Object array2, List<String> path, Deque<DualKey> toCompare,343                                       Set<DualKey> visited) {344    int len = Array.getLength(array1);345    if (len != Array.getLength(array2)) {346      return false;347    }348    for (int i = 0; i < len; i++) {349      DualKey dk = new DualKey(path, Array.get(array1, i), Array.get(array2, i));350      if (!visited.contains(dk)) {351        toCompare.addFirst(dk);352      }353    }354    return true;355  }356  /**357   * Deeply compare two Collections that must be same length and in same358   * order.359   * 360   * @param col1 First collection of items to compare361   * @param col2 Second collection of items to compare362   * @param path The path to the collections363   * @param toCompare add items to compare to the Stack (Stack versus recursion)364   * @param visited365   *          Set of objects already compared (prevents cycles) value of366   *          'true' indicates that the Collections may be equal, and the367   *          sets items will be added to the Stack for further comparison.368   */369  private static <K, V> boolean compareOrderedCollection(Collection<K> col1, Collection<V> col2,370                                                         List<String> path, Deque<DualKey> toCompare,371                                                         Set<DualKey> visited) {372    if (col1.size() != col2.size()) return false;373    Iterator<V> i2 = col2.iterator();374    for (K k : col1) {375      DualKey dk = new DualKey(path, k, i2.next());376      if (!visited.contains(dk)) toCompare.addFirst(dk);377    }378    return true;379  }380  /**381   * It places one collection into a temporary Map by deepHashCode(), so that it382   * can walk the other collection and look for each item in the map, which383   * runs in O(N) time, rather than an O(N^2) lookup that would occur if each384   * item from collection one was scanned for in collection two.385   * 386   * @param col1 First collection of items to compare387   * @param col2 Second collection of items to compare388   * @param path the path to the collections to compare389   * @param toCompare add items to compare to the Stack (Stack versus recursion)390   * @param visited Set containing items that have already been compared, so as to391   *          prevent cycles.392   * @return boolean false if the Collections are for certain not equals. A393   *         value of 'true' indicates that the Collections may be equal, and394   *         the sets items will be added to the Stack for further comparison.395   */396  private static <K, V> boolean compareUnorderedCollectionByHashCodes(Collection<K> col1, Collection<V> col2,397                                                                      List<String> path, Deque<DualKey> toCompare,398                                                                      Set<DualKey> visited) {399    Map<Integer, Object> fastLookup = new HashMap<>();400    for (Object o : col2) {401      fastLookup.put(deepHashCode(o), o);402    }403    for (Object o : col1) {404      Object other = fastLookup.get(deepHashCode(o));405      if (other == null) {406        // Item not even found in other Collection, no need to continue.407        return false;408      }409      DualKey dk = new DualKey(path, o, other);410      if (!visited.contains(dk)) {411        toCompare.addFirst(dk);412      }413    }414    return true;415  }416  /**417   * Deeply compares two collections referenced by dualKey. This method attempts418   * to quickly determine inequality by length, then if lengths match, in case of419   * collection type is Set and there are passed no custom comparators, there is used420   * comparison on hashcodes basis, otherwise each element from one collection is checked421   * for existence in another one using 'deep' comparison.422   */423  private static <K, V> boolean compareUnorderedCollection(Collection<K> col1, Collection<V> col2,424                                                           List<String> path, Deque<DualKey> toCompare,425                                                           Set<DualKey> visited,426                                                           Map<String, Comparator<?>> comparatorByPropertyOrField,427                                                           TypeComparators comparatorByType) {428    if (col1.size() != col2.size()) return false;429    boolean noCustomComparators = comparatorByPropertyOrField.isEmpty() && comparatorByType.isEmpty();430    if (noCustomComparators && col1 instanceof Set) {431      // this comparison is used for performance optimization reasons432      return compareUnorderedCollectionByHashCodes(col1, col2, path, toCompare, visited);433    }434    Collection<V> col2Copy = new LinkedList<>(col2);435    for (Object o1 : col1) {436      Iterator<V> iterator = col2Copy.iterator();437      while (iterator.hasNext()) {438        Object o2 = iterator.next();439        if (determineDifferences(o1, o2, path, comparatorByPropertyOrField, comparatorByType).isEmpty()) {440          iterator.remove();441          break;442        }443      }444    }445    return col2Copy.isEmpty();446  }447  /**448   * Deeply compare two SortedMap instances. This method walks the Maps in449   * order, taking advantage of the fact that the Maps are SortedMaps.450   * 451   * @param map1 SortedMap one452   * @param map2 SortedMap two453   * @param path the path to the maps to compare454   * @param toCompare add items to compare to the Stack (Stack versus recursion)455   * @param visited Set containing items that have already been compared, to456   *          prevent cycles.457   * @return false if the Maps are for certain not equals. 'true' indicates458   *         that 'on the surface' the maps are equal, however, it will place459   *         the contents of the Maps on the stack for further comparisons.460   */461  private static <K1, V1, K2, V2> boolean compareSortedMap(SortedMap<K1, V1> map1, SortedMap<K2, V2> map2,462                                                           List<String> path, Deque<DualKey> toCompare,463                                                           Set<DualKey> visited) {464    if (map1.size() != map2.size()) {465      return false;466    }467    Iterator<Map.Entry<K2, V2>> i2 = map2.entrySet().iterator();468    for (Map.Entry<K1, V1> entry1 : map1.entrySet()) {469      Map.Entry<K2, V2> entry2 = i2.next();470      // Must split the Key and Value so that Map.Entry's equals() method is not used.471      DualKey dk = new DualKey(path, entry1.getKey(), entry2.getKey());472      if (!visited.contains(dk)) {473        toCompare.addFirst(dk);474      }475      dk = new DualKey(path, entry1.getValue(), entry2.getValue());476      if (!visited.contains(dk)) {477        toCompare.addFirst(dk);478      }479    }480    return true;481  }482  /**483   * Deeply compare two Map instances. After quick short-circuit tests, this484   * method uses a temporary Map so that this method can run in O(N) time.485   * 486   * @param map1 Map one487   * @param map2 Map two488   * @param path the path to the maps to compare489   * @param toCompare add items to compare to the Stack (Stack versus recursion)490   * @param visited Set containing items that have already been compared, to491   *          prevent cycles.492   * @return false if the Maps are for certain not equals. 'true' indicates493   *         that 'on the surface' the maps are equal, however, it will place494   *         the contents of the Maps on the stack for further comparisons.495   */496  private static <K1, V1, K2, V2> boolean compareUnorderedMap(Map<K1, V1> map1, Map<K2, V2> map2,497                                                              List<String> path, Deque<DualKey> toCompare,498                                                              Set<DualKey> visited) {499    if (map1.size() != map2.size()) {500      return false;501    }502    Map<Integer, Map.Entry<K2, V2>> fastLookup = new HashMap<>();503    for (Map.Entry<K2, V2> entry : map2.entrySet()) {504      fastLookup.put(deepHashCode(entry.getKey()), entry);505    }506    for (Map.Entry<K1, V1> entry : map1.entrySet()) {507      Map.Entry<K2, V2> other = fastLookup.get(deepHashCode(entry.getKey()));508      if (other == null) {509        return false;510      }...

compareUnorderedMap

Using AI Code Generation

1import static org.assertj.core.internal.DeepDifference.compareUnorderedMap;2import java.util.HashMap;3import java.util.Map;4import org.assertj.core.internal.DeepDifference;5public class 1 {6    public static void main(String[] args) {7        Map<String, String> expected = new HashMap<>();8        expected.put("key1", "value1");9        expected.put("key2", "value2");10        Map<String, String> actual = new HashMap<>();11        actual.put("key2", "value2");12        actual.put("key1", "value1");13        DeepDifference deepDifference = new DeepDifference();14        compareUnorderedMap(deepDifference, expected, actual);15    }16}17  <{"key1"="value1", "key2"="value2"}>18  <{"key2"="value2", "key1"="value1"}>19  <{"key2"="value2", "key1"="value1"}>20  <{"key2"="value2", "key1"="value1"}>

compareUnorderedMap

Using AI Code Generation

1public class Test {2    public static void main(String[] args) {3        Map<String, String> expectedMap = new HashMap<String, String>();4        expectedMap.put("key1", "value1");5        expectedMap.put("key2", "value2");6        expectedMap.put("key3", "value3");7        Map<String, String> actualMap = new HashMap<String, String>();8        actualMap.put("key3", "value3");9        actualMap.put("key2", "value2");10        actualMap.put("key1", "value1");11        DeepDifference deepDifference = new DeepDifference(expectedMap, actualMap);12        deepDifference.compareUnorderedMap();13    }14}15{key1=value1, key2=value2, key3=value3} and {key3=value3, key2=value2, key1=value1} are equal

compareUnorderedMap

Using AI Code Generation

1import java.util.Map;2import java.util.HashMap;3import org.assertj.core.internal.DeepDifference;4import org.assertj.core.internal.DeepDifference.Difference;5import org.assertj.core.api.Assertions;6public class 1 {7    public static void main(String[] args) {8        DeepDifference deepDifference = new DeepDifference();9        Map<String, String> map1 = new HashMap<>();10        map1.put("a", "b");11        map1.put("c", "d");12        Map<String, String> map2 = new HashMap<>();13        map2.put("c", "d");14        map2.put("a", "b");15        Difference diff = deepDifference.compareUnorderedMap(map1, map2);16        if (diff != null) {17            System.out.println(diff);18        }19    }20}21Map<String, String> map2 = new HashMap<>(); map2.put("a", "b"); map2.put("c", "d");22import java.util.Map;23import java.util.HashMap;24import org.assertj.core.internal.DeepDifference;25import org.assertj.core.internal.DeepDifference.Difference;26import org.assertj.core.api.Assertions;27public class 2 {28    public static void main(String[] args) {29        DeepDifference deepDifference = new DeepDifference();30        Map<String, String> map1 = new HashMap<>();31        map1.put("a", "b");32        map1.put("c", "d");33        Map<String, String> map2 = new HashMap<>();34        map2.put("a", "b");35        Difference diff = deepDifference.compareUnorderedMap(map1, map2);36        if (diff != null) {37            System.out.println(diff);38        }39    }40}

compareUnorderedMap

Using AI Code Generation

1import org.assertj.core.internal.DeepDifference;2import java.util.HashMap;3import java.util.Map;4import java.util.Set;5import java.util.HashSet;6import java.util.Arrays;7import java.util.List;8import java.util.ArrayList;9import java.util.Collections;10import java.util.Iterator;11import java.util.LinkedHashSet;12import java.util.Set;13import java.util.HashSet;14import java.util.Arrays;15import java.util.List;16import java.util.ArrayList;17import java.util.Collections;18import java.util.Iterator;19import java.util.LinkedHashSet;20import java.util.Set;21import java.util.HashSet;22import java.util.Arrays;23import java.util.List;24import java.util.ArrayList;25import java.util.Collections;26import java.util.Iterator;27import java.util.LinkedHashSet;28import java.util.Set;29import java.util.HashSet;30import java.util.Arrays;31import java.util.List;32import java.util.ArrayList;33import java.util.Collections;34import java.util.Iterator;35import java.util.LinkedHashSet;36import java.util.Set;37import java.util.HashSet;38import java.util.Arrays;39import java.util.List;40import java.util.ArrayList;41import java.util.Collections;42import java.util.Iterator;43import java.util.LinkedHashSet;44import java.util.Set;45import java.util.HashSet;46import java.util.Arrays;47import java.util.List;48import java.util.ArrayList;49import java.util.Collections;50import java.util.Iterator;51import java.util.LinkedHashSet;52import java.util.Set;53import java.util.HashSet;54import java.util.Arrays;55import java.util.List;56import java.util.ArrayList;57import java.util.Collections;58import java.util.Iterator;59import java.util.LinkedHashSet;60import java.util.Set;61import java.util.HashSet;62import java.util.Arrays;63import java.util.List;64import java.util.ArrayList;65import java.util.Collections;66import java.util.Iterator;67import java.util.LinkedHashSet;68import java.util.Set;69import java.util.HashSet;70import java.util.Arrays;71import java.util.List;72import java.util.ArrayList;73import java.util.Collections;74import java.util.Iterator;75import java.util.LinkedHashSet;76import java.util.Set;77import java.util.HashSet;78import java.util.Arrays;79import java.util.List;80import java.util.ArrayList;81import java.util.Collections;82import java.util.Iterator;83import java.util.LinkedHashSet;84import java.util.Set;85import java.util.HashSet;86import java.util.Arrays;87import java.util.List;88import java.util.ArrayList;89import java.util.Collections;90import java.util.Iterator;91import java.util.LinkedHashSet;92import java.util.Set;93import java.util.HashSet;94import java.util.Arrays;95import java.util.List;96import java.util.ArrayList;97import java.util.Collections

compareUnorderedMap

Using AI Code Generation

1import org.assertj.core.api.Assertions;2import org.assertj.core.internal.DeepDifference;3import java.util.Map;4import java.util.HashMap;5public class Test {6    public static void main(String[] args) {7        Map<String, String> one = new HashMap<>();8        Map<String, String> two = new HashMap<>();9        one.put("name", "John");10        one.put("age", "25");11        one.put("address", "US");12        two.put("name", "John");13        two.put("age", "25");14        two.put("address", "US");15        Assertions.assertThat(DeepDifference.compareUnorderedMap(one, two)).isNull();16    }17}18Actual   :{address=US, age=25, name=John}

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.