Make all Fuzzy Truth assertions in MapSubject handle exceptions from Correspondence.formatDiff.

RELNOTES=All Fuzzy Truth assertions now handle exceptions thrown by Correspondence.formatDiff (see the javadoc of that method for details).

-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=229710440

Author: peteg

core/src/main/java/com/google/common/truth/MapSubject.java

@@ -497,7 +497,8 @@ public void containsEntry(@NullableDecl Object expectedKey, @NullableDecl E expe
           return;
         }
         // Found matching key with non-matching value.
-        @NullableDecl String diff = correspondence.formatDiff(actualValue, expectedValue);
+        @NullableDecl
+        String diff = correspondence.safeFormatDiff(actualValue, expectedValue, exceptions);
         if (diff != null) {
           failWithoutActual(
               facts(
@@ -663,7 +664,7 @@ public boolean test(A actualValue, E expectedValue) {
                           actualAsString(),
                           correspondence,
                           expectedMap,
-                          diff.describe(this.<V>valueDiffFormat()))))
+                          diff.describe(this.<V>valueDiffFormat(exceptions)))))
               .and(exceptions.describeAsAdditionalInfo()));
       return ALREADY_FAILED;
     }
@@ -672,12 +673,14 @@ public boolean test(A actualValue, E expectedValue) {
      * Returns a formatting function for value differences when compared using the current
      * correspondence.
      */
-    private final <V extends E> Function<ValueDifference<A, V>, String> valueDiffFormat() {
+    private final <V extends E> Function<ValueDifference<A, V>, String> valueDiffFormat(
+        final Correspondence.ExceptionStore exceptions) {
       return new Function<ValueDifference<A, V>, String>() {
         @Override
         public String apply(ValueDifference<A, V> values) {
           @NullableDecl
-          String diffString = correspondence.formatDiff(values.actual, values.expected);
+          String diffString =
+              correspondence.safeFormatDiff(values.actual, values.expected, exceptions);
           if (diffString != null) {
             return lenientFormat(
                 "(expected %s but got %s, diff: %s)", values.expected, values.actual, diffString);

core/src/test/java/com/google/common/truth/MapSubjectTest.java

@@ -922,6 +922,29 @@ public void comparingValuesUsing_containsEntry_diffExpectedKeyHasWrongValue() {
                 + "within 10 of <60>. However, it has a mapping from that key to <71> (diff: 11)");
   }
 
+  @Test
+  public void comparingValuesUsing_containsEntry_handlesFormatDiffExceptions() {
+    Map<String, Integer> actual = new LinkedHashMap<>();
+    actual.put("abc", 35);
+    actual.put("def", null);
+    expectFailureWhenTestingThat(actual)
+        .comparingValuesUsing(WITHIN_10_OF)
+        .containsEntry("def", 60);
+    assertFailureKeys(
+        "Not true that <{abc=35, def=null}> contains an entry with key <def> and a value that is "
+            + "within 10 of <60>. However, it has a mapping from that key to <null>",
+        "additionally, one or more exceptions were thrown while comparing values",
+        "first exception",
+        "additionally, one or more exceptions were thrown while formatting diffs",
+        "first exception");
+    assertThatFailure()
+        .factValue("first exception", 0)
+        .startsWith("compare(null, 60) threw java.lang.NullPointerException");
+    assertThatFailure()
+        .factValue("first exception", 1)
+        .startsWith("formatDiff(null, 60) threw java.lang.NullPointerException");
+  }
+
   @Test
   public void comparingValuesUsing_containsEntry_handlesExceptions_expectedKeyHasWrongValue() {
     Map<Integer, String> actual = new LinkedHashMap<>();
@@ -1274,6 +1297,33 @@ public void comparingValuesUsing_containsExactlyEntriesIn_diffMissingAndExtraAnd
                 + "{ghi=(expected 90 but got 101, diff: 11)}");
   }
 
+  @Test
+  public void comparingValuesUsing_containsExactlyEntriesIn_handlesFormatDiffExceptions() {
+    ImmutableMap<String, Integer> expected = ImmutableMap.of("abc", 30, "def", 60, "ghi", 90);
+    Map<String, Integer> actual = new LinkedHashMap<>();
+    actual.put("abc", 35);
+    actual.put("def", null);
+    actual.put("ghi", 95);
+    expectFailureWhenTestingThat(actual)
+        .comparingValuesUsing(WITHIN_10_OF)
+        .containsExactlyEntriesIn(expected);
+    assertFailureKeys(
+        "Not true that <{abc=35, def=null, ghi=95}> contains exactly one entry that has a key that "
+            + "is equal to and a value that is within 10 of the key and value of each entry of "
+            + "<{abc=30, def=60, ghi=90}>. It has the following entries with matching keys but "
+            + "different values: {def=(expected 60 but got null)}",
+        "additionally, one or more exceptions were thrown while comparing values",
+        "first exception",
+        "additionally, one or more exceptions were thrown while formatting diffs",
+        "first exception");
+    assertThatFailure()
+        .factValue("first exception", 0)
+        .startsWith("compare(null, 60) threw java.lang.NullPointerException");
+    assertThatFailure()
+        .factValue("first exception", 1)
+        .startsWith("formatDiff(null, 60) threw java.lang.NullPointerException");
+  }
+
   @Test
   public void comparingValuesUsing_containsExactlyEntriesIn_inOrder_failsOutOfOrder() {
     ImmutableMap<String, Integer> expected = ImmutableMap.of("def", 456, "abc", 123);