Remove deprecated containsAllOf+containsAllIn and isOrdered+isStrictlyOrdered.

(Also, internally remove isSameAs+isNotSameAs, which had already been removed externally.)

Relnotes:
  Removed deprecated `containsAllOf` and `containsAllIn`. Use `containsAtLeast` and `containsAtLeastElementsIn`, which are equivalent.
  Removed deprecated `isOrdered` and `isStrictlyOrdered`. Use `isInOrder` and `isInStrictOrder`, which are equivalent.

[]

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

Author: cpovirk

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

@@ -219,60 +219,6 @@ public final void containsAnyIn(Object[] expected) {
     containsAnyIn(asList(expected));
   }
 
-  /**
-   * Checks that the actual iterable contains at least all of the expected elements or fails. If an
-   * element appears more than once in the expected elements to this call then it must appear at
-   * least that number of times in the actual elements.
-   *
-   * <p>To also test that the contents appear in the given order, make a call to {@code inOrder()}
-   * on the object returned by this method. The expected elements must appear in the given order
-   * within the actual elements, but they are not required to be consecutive.
-   *
-   * @deprecated Use {@link #containsAtLeast}, which is equivalent.
-   */
-  @CanIgnoreReturnValue
-  @Deprecated
-  public final Ordered containsAllOf(
-      @NullableDecl Object firstExpected,
-      @NullableDecl Object secondExpected,
-      @NullableDecl Object... restOfExpected) {
-    return containsAtLeast(firstExpected, secondExpected, restOfExpected);
-  }
-
-  /**
-   * Checks that the actual iterable contains at least all of the expected elements or fails. If an
-   * element appears more than once in the expected elements then it must appear at least that
-   * number of times in the actual elements.
-   *
-   * <p>To also test that the contents appear in the given order, make a call to {@code inOrder()}
-   * on the object returned by this method. The expected elements must appear in the given order
-   * within the actual elements, but they are not required to be consecutive.
-   *
-   * @deprecated Use {@link #containsAtLeastElementsIn(Iterable)}, which is equivalent.
-   */
-  @CanIgnoreReturnValue
-  @Deprecated
-  public final Ordered containsAllIn(Iterable<?> expectedIterable) {
-    return containsAtLeastElementsIn(expectedIterable);
-  }
-
-  /**
-   * Checks that the actual iterable contains at least all of the expected elements or fails. If an
-   * element appears more than once in the expected elements then it must appear at least that
-   * number of times in the actual elements.
-   *
-   * <p>To also test that the contents appear in the given order, make a call to {@code inOrder()}
-   * on the object returned by this method. The expected elements must appear in the given order
-   * within the actual elements, but they are not required to be consecutive.
-   *
-   * @deprecated Use {@link #containsAtLeastElementsIn(Object[])}, which is equivalent.
-   */
-  @CanIgnoreReturnValue
-  @Deprecated
-  public final Ordered containsAllIn(Object[] expected) {
-    return containsAtLeastElementsIn(expected);
-  }
-
   /**
    * Checks that the actual iterable contains at least all of the expected elements or fails. If an
    * element appears more than once in the expected elements to this call then it must appear at
@@ -847,61 +793,6 @@ public boolean check(Object prev, Object next) {
         });
   }
 
-  /**
-   * Fails if the iterable is not strictly ordered, according to the natural ordering of its
-   * elements. Strictly ordered means that each element in the iterable is <i>strictly</i> greater
-   * than the element that preceded it.
-   *
-   * @throws ClassCastException if any pair of elements is not mutually Comparable
-   * @throws NullPointerException if any element is null
-   * @deprecated Use {@link #isInStrictOrder()}.
-   */
-  @Deprecated
-  public final void isStrictlyOrdered() {
-    isInStrictOrder();
-  }
-
-  /**
-   * Fails if the iterable is not strictly ordered, according to the given comparator. Strictly
-   * ordered means that each element in the iterable is <i>strictly</i> greater than the element
-   * that preceded it.
-   *
-   * @throws ClassCastException if any pair of elements is not mutually Comparable
-   * @deprecated Use {@link #isInStrictOrder(Comparator)}.
-   */
-  @Deprecated
-  @SuppressWarnings({"unchecked"})
-  public final void isStrictlyOrdered(final Comparator<?> comparator) {
-    isInStrictOrder(comparator);
-  }
-
-  /**
-   * Fails if the iterable is not ordered, according to the natural ordering of its elements.
-   * Ordered means that each element in the iterable is greater than or equal to the element that
-   * preceded it.
-   *
-   * @throws ClassCastException if any pair of elements is not mutually Comparable
-   * @throws NullPointerException if any element is null
-   * @deprecated Use {@link #isInOrder()}
-   */
-  @Deprecated
-  public final void isOrdered() {
-    isInOrder();
-  }
-
-  /**
-   * Fails if the iterable is not ordered, according to the given comparator. Ordered means that
-   * each element in the iterable is greater than or equal to the element that preceded it.
-   *
-   * @throws ClassCastException if any pair of elements is not mutually Comparable
-   * @deprecated Use {@link #isInOrder(Comparator)}.
-   */
-  @Deprecated
-  @SuppressWarnings({"unchecked"})
-  public final void isOrdered(final Comparator<?> comparator) {
-    isInOrder(comparator);
-  }
-
   private interface PairwiseChecker {
     boolean check(Object prev, Object next);
   }
@@ -1559,59 +1450,6 @@ private boolean failIfOneToOneMappingHasMissingOrExtra(
       return false;
     }
 
-    /**
-     * Checks that the subject contains elements that corresponds to all of the expected elements,
-     * i.e. that there is a 1:1 mapping between any subset of the actual elements and the expected
-     * elements where each pair of elements correspond.
-     *
-     * <p>To also test that the contents appear in the given order, make a call to {@code inOrder()}
-     * on the object returned by this method. The elements must appear in the given order within the
-     * subject, but they are not required to be consecutive.
-     *
-     * @deprecated Use {@link #containsAtLeast}, which is equivalent.
-     */
-    @SafeVarargs
-    @CanIgnoreReturnValue
-    @Deprecated
-    public final Ordered containsAllOf(
-        @NullableDecl E first, @NullableDecl E second, @NullableDecl E... rest) {
-      return containsAtLeast(first, second, rest);
-    }
-
-    /**
-     * Checks that the subject contains elements that corresponds to all of the expected elements,
-     * i.e. that there is a 1:1 mapping between any subset of the actual elements and the expected
-     * elements where each pair of elements correspond.
-     *
-     * <p>To also test that the contents appear in the given order, make a call to {@code inOrder()}
-     * on the object returned by this method. The elements must appear in the given order within the
-     * subject, but they are not required to be consecutive.
-     *
-     * @deprecated Use {@link #containsAtLeastElementsIn(Iterable)}, which is equivalent.
-     */
-    @CanIgnoreReturnValue
-    @Deprecated
-    public Ordered containsAllIn(final Iterable<? extends E> expected) {
-      return containsAtLeastElementsIn(expected);
-    }
-
-    /**
-     * Checks that the subject contains elements that corresponds to all of the expected elements,
-     * i.e. that there is a 1:1 mapping between any subset of the actual elements and the expected
-     * elements where each pair of elements correspond.
-     *
-     * <p>To also test that the contents appear in the given order, make a call to {@code inOrder()}
-     * on the object returned by this method. The elements must appear in the given order within the
-     * subject, but they are not required to be consecutive.
-     *
-     * @deprecated Use {@link #containsAtLeastElementsIn(Object[])}, which is equivalent.
-     */
-    @CanIgnoreReturnValue
-    @Deprecated
-    public Ordered containsAllIn(E[] expected) {
-      return containsAtLeastElementsIn(expected);
-    }
-
     /**
      * Checks that the subject contains elements that corresponds to all of the expected elements,
      * i.e. that there is a 1:1 mapping between any subset of the actual elements and the expected

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

@@ -748,7 +748,7 @@ public <K, V extends E> Ordered containsAtLeastEntriesIn(Multimap<K, V> expected
           .about(iterableEntries())
           .that(actual.entries())
           .comparingElementsUsing(new EntryCorrespondence<K, A, V>(correspondence))
-          .containsAllIn(expectedMultimap.entries());
+          .containsAtLeastElementsIn(expectedMultimap.entries());
     }
 
     /**

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

@@ -263,17 +263,6 @@ public Ordered containsAtLeast(double[] expected) {
       return containsAtLeastElementsIn(Doubles.asList(expected));
     }
 
-    /**
-     * As {@link #containsAllOf(Object, Object, Object...)} but taking a primitive double array.
-     *
-     * @deprecated Use {@link #containsAtLeast(double[])}, which is equivalent.
-     */
-    @CanIgnoreReturnValue
-    @Deprecated
-    public Ordered containsAllOf(double[] expected) {
-      return containsAtLeast(expected);
-    }
-
     /** As {@link #containsAnyOf(Object, Object, Object...)} but taking a primitive double array. */
     public void containsAnyOf(double[] expected) {
       containsAnyIn(Doubles.asList(expected));

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

@@ -270,17 +270,6 @@ public Ordered containsAtLeast(float[] expected) {
       return containsAtLeastElementsIn(Floats.asList(expected));
     }
 
-    /**
-     * As {@link #containsAllOf(Object, Object, Object...)} but taking a primitive float array.
-     *
-     * @deprecated Use {@link #containsAtLeast(float[])}, which is equivalent.
-     */
-    @CanIgnoreReturnValue
-    @Deprecated
-    public Ordered containsAllOf(float[] expected) {
-      return containsAtLeast(expected);
-    }
-
     /** As {@link #containsAnyOf(Object, Object, Object...)} but taking a primitive float array. */
     public void containsAnyOf(float[] expected) {
       containsAnyIn(Floats.asList(expected));

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

@@ -259,8 +259,8 @@ public final void isSameInstanceAs(@NullableDecl Object expected) {
           /*
            * Pass through *whether* the values are equal so that failEqualityCheck() can print that
            * information. But remove the description of the difference, which is always about
-           * content, since people calling isSameAs() are explicitly not interested in content, only
-           * object identity.
+           * content, since people calling isSameInstanceAs() are explicitly not interested in
+           * content, only object identity.
            */
           compareForEquality(expected).withoutDescription());
     }
@@ -820,7 +820,8 @@ private void failEqualityCheck(
     boolean sameToStrings = actualString.equals(expectedString);
     boolean sameClassNames = actualClass.equals(expectedClass);
     // TODO(cpovirk): Handle "same class name, different class loader."
-    boolean equal = difference.valuesAreEqual(); // always false for isEqualTo; varies for isSameAs
+    // `equal` is always false for isEqualTo, but it varies for isSameInstanceAs:
+    boolean equal = difference.valuesAreEqual();
     // TODO(cpovirk): Call attention to differing trailing whitespace.
 
     if (sameToStrings) {

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

@@ -42,8 +42,8 @@ protected ThrowableSubject(FailureMetadata metadata, @NullableDecl Throwable thr
   }
 
   /*
-   * TODO(cpovirk): consider a special case for isEqualTo and isSameAs that adds |expected| as a
-   * suppressed exception
+   * TODO(cpovirk): consider a special case for isEqualTo and isSameInstanceAs that adds |expected|
+   * as a suppressed exception
    */
 
   /** Returns a {@code StringSubject} to make assertions about the throwable's message. */

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

@@ -46,7 +46,7 @@
  * assertThat(a).isEqualTo(b);
  * assertThat(c).isTrue();
  * assertThat(d).contains(a);
- * assertThat(d).containsAllOf(a, b);
+ * assertThat(d).containsAtLeast(a, b);
  * assertThat(d).containsAnyOf(a, b, c);
  * }</pre>
  *