Stop using ImmutableList for storing elements in the implementation o…

…f Fuzzy Truth, because we want to support nulls. (Unfortunately, the previous test case only went through the most trivial code path and didn't trigger the bug.)

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

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

@@ -619,8 +619,8 @@ public Ordered containsExactlyElementsIn(Iterable<? extends E> expected) {
       // We know they don't correspond in order, so we're going to have to do an any-order test.
       // Find a many:many mapping between the indexes of the elements which correspond, and check
       // it for completeness.
-      ImmutableList<A> actualList = ImmutableList.copyOf(getCastSubject());
-      ImmutableList<? extends E> expectedList = ImmutableList.copyOf(expected);
+      List<A> actualList = Lists.newArrayList(getCastSubject());
+      List<? extends E> expectedList = Lists.newArrayList(expected);
       ImmutableSetMultimap<Integer, Integer> candidateMapping =
           findCandidateMapping(actualList, expectedList);
       failIfCandidateMappingHasMissingOrExtra(actualList, expectedList, candidateMapping);
@@ -681,8 +681,8 @@ void failIfCandidateMappingHasMissingOrExtra(
         List<? extends A> actual,
         List<? extends E> expected,
         ImmutableMultimap<Integer, Integer> mapping) {
-      ImmutableList<? extends A> extra = findNotIndexed(actual, mapping.keySet());
-      ImmutableList<? extends E> missing = findNotIndexed(expected, mapping.inverse().keySet());
+      List<? extends A> extra = findNotIndexed(actual, mapping.keySet());
+      List<? extends E> missing = findNotIndexed(expected, mapping.inverse().keySet());
       Optional<String> missingOrExtraMessage = describeMissingOrExtra(extra, missing);
       if (missingOrExtraMessage.isPresent()) {
           failWithRawMessage(
@@ -721,19 +721,19 @@ private Optional<String> describeMissingOrExtra(
      * Returns all the elements of the given list other than those with the given indexes. Assumes
      * that all the given indexes really are valid indexes into the list.
      */
-    private <T> ImmutableList<T> findNotIndexed(List<T> list, Set<Integer> indexes) {
+    private <T> List<T> findNotIndexed(List<T> list, Set<Integer> indexes) {
       if (indexes.size() == list.size()) {
         // If there are as many distinct valid indexes are there are elements in the list then every
         // index must be in there once.
         return ImmutableList.of();
       }
-      ImmutableList.Builder<T> notIndexed = ImmutableList.builder();
+      List<T> notIndexed = Lists.newArrayList();
       for (int index = 0; index < list.size(); index++) {
         if (!indexes.contains(index)) {
           notIndexed.add(list.get(index));
         }
       }
-      return notIndexed.build();
+      return notIndexed;
     }
 
     /**
@@ -786,8 +786,8 @@ void failIfOneToOneMappingHasMissingOrExtra(
         List<? extends A> actual,
         List<? extends E> expected,
         BiMap<Integer, Integer> mapping) {
-      ImmutableList<? extends A> extra = findNotIndexed(actual, mapping.keySet());
-      ImmutableList<? extends E> missing = findNotIndexed(expected, mapping.inverse().keySet());
+      List<? extends A> extra = findNotIndexed(actual, mapping.keySet());
+      List<? extends E> missing = findNotIndexed(expected, mapping.inverse().keySet());
       Optional<String> missingOrExtraMessage = describeMissingOrExtra(extra, missing);
       if (missingOrExtraMessage.isPresent()) {
         failWithRawMessage(

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

@@ -24,7 +24,6 @@
 
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Iterables;
-import com.google.common.primitives.Ints;
 import java.util.Arrays;
 import java.util.Comparator;
 import java.util.Iterator;
@@ -1258,12 +1257,11 @@ public void comparingElementsUsing_containsExactlyElementsIn_inOrder_failsOutOfO
 
   @Test
   public void comparingElementsUsing_containsExactlyElementsIn_null() {
-    List<Integer> expected = Arrays.asList((Integer) null);
-    List<String> actual = Arrays.asList((String) null);
+    List<Integer> expected = Arrays.asList(128, null);
+    List<String> actual = Arrays.asList(null, "0x80");
     assertThat(actual)
         .comparingElementsUsing(STRING_PARSES_TO_INTEGER_CORRESPONDENCE)
-        .containsExactlyElementsIn(expected)
-        .inOrder();
+        .containsExactlyElementsIn(expected);
   }
 
   @Test
@@ -1309,11 +1307,10 @@ public void comparingElementsUsing_containsExactly_failsMissingAndExtraInOneToOn
 
   @Test
   public void comparingElementsUsing_containsExactly_nullValueInArray() {
-    List<String> actual = Arrays.asList((String) null);
+    List<String> actual = Arrays.asList(null, "0x80");
     assertThat(actual)
         .comparingElementsUsing(STRING_PARSES_TO_INTEGER_CORRESPONDENCE)
-        .containsExactly((Integer) null)
-        .inOrder();
+        .containsExactly(128, null);
   }
 
   @Test