Add ignoringExtraRepeatedFieldElements() to ProtoTruth.

RELNOTES=Add ignoringExtraRepeatedFieldElements() to ProtoTruth.

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

Author: torquestomp

extensions/proto/src/main/java/com/google/common/truth/extensions/proto/DiffResult.java

@@ -148,8 +148,9 @@ final void printContents(boolean includeMatches, String fieldPrefix, StringBuild
             sb.append(valueString(fieldDescriptorOrUnknown().get(), expected().get())).append("\n");
           }
           return;
+        default:
+          throw new AssertionError("Impossible: " + result());
       }
-      throw new AssertionError("Impossible: " + result());
     }
 
     @Override
@@ -278,7 +279,16 @@ final void printContentsForRepeatedField(
                   .append(" -> ")
                   .append(indexed(fieldPrefix, actualFieldIndex()));
             }
-            sb.append("\n");
+
+            // We output the message contents for ignored pair results, since it's likely not clear
+            // from the index alone why they were ignored.
+            sb.append(":");
+            if (isMessage()) {
+              sb.append("\n");
+              printChildContents(includeMatches, indexed(fieldPrefix, actualFieldIndex()), sb);
+            } else {
+              sb.append(" ").append(valueString(fieldDescriptor(), actual().get())).append("\n");
+            }
             return;
           case MATCHED:
             if (actualFieldIndex().get().equals(expectedFieldIndex().get())) {
@@ -297,6 +307,19 @@ final void printContentsForRepeatedField(
               sb.append(" ").append(valueString(fieldDescriptor(), actual().get())).append("\n");
             }
             return;
+          case MOVED_OUT_OF_ORDER:
+            sb.append("out_of_order: ")
+                .append(indexed(fieldPrefix, expectedFieldIndex()))
+                .append(" -> ")
+                .append(indexed(fieldPrefix, actualFieldIndex()));
+            sb.append(":");
+            if (isMessage()) {
+              sb.append("\n");
+              printChildContents(includeMatches, indexed(fieldPrefix, actualFieldIndex()), sb);
+            } else {
+              sb.append(" ").append(valueString(fieldDescriptor(), actual().get())).append("\n");
+            }
+            return;
           case MODIFIED:
             sb.append("modified: ");
             if (actualFieldIndex().get().equals(expectedFieldIndex().get())) {
@@ -334,6 +357,8 @@ final boolean isContentEmpty() {
         return false;
       }
 
+      abstract Builder toBuilder();
+
       static Builder newBuilder() {
         return new AutoValue_DiffResult_RepeatedField_PairResult.Builder();
       }

extensions/proto/src/main/java/com/google/common/truth/extensions/proto/FluentEqualityConfig.java

@@ -48,6 +48,7 @@ abstract class FluentEqualityConfig {
       new AutoValue_FluentEqualityConfig.Builder()
           .setIgnoreFieldAbsence(false)
           .setIgnoreRepeatedFieldOrder(false)
+          .setIgnoreExtraRepeatedFieldElements(false)
           .setCompareExpectedFieldsOnly(false)
           .setFieldScopeLogic(FieldScopeLogic.all())
           .setReportMismatchesOnly(false)
@@ -76,7 +77,7 @@ public ProtoTruthMessageDifferencer load(Descriptor descriptor) {
 
   abstract boolean ignoreRepeatedFieldOrder();
 
-  abstract boolean reportMismatchesOnly();
+  abstract boolean ignoreExtraRepeatedFieldElements();
 
   abstract Optional<Correspondence<Number, Number>> doubleCorrespondence();
 
@@ -94,6 +95,8 @@ public ProtoTruthMessageDifferencer load(Descriptor descriptor) {
 
   abstract FieldScopeLogic fieldScopeLogic();
 
+  abstract boolean reportMismatchesOnly();
+
   // For pretty-printing, does not affect behavior.
   abstract Function<? super Optional<Descriptor>, String> usingCorrespondenceStringFunction();
 
@@ -119,10 +122,10 @@ final FluentEqualityConfig ignoringRepeatedFieldOrder() {
         .build();
   }
 
-  final FluentEqualityConfig reportingMismatchesOnly() {
+  final FluentEqualityConfig ignoringExtraRepeatedFieldElements() {
     return toBuilder()
-        .setReportMismatchesOnly(true)
-        .addUsingCorrespondenceString(".reportingMismatchesOnly()")
+        .setIgnoreExtraRepeatedFieldElements(true)
+        .addUsingCorrespondenceString(".ignoringExtraRepeatedFieldElements()")
         .build();
   }
 
@@ -192,6 +195,13 @@ final FluentEqualityConfig ignoringFieldScope(FieldScope fieldScope) {
         .build();
   }
 
+  final FluentEqualityConfig reportingMismatchesOnly() {
+    return toBuilder()
+        .setReportMismatchesOnly(true)
+        .addUsingCorrespondenceString(".reportingMismatchesOnly()")
+        .build();
+  }
+
   //////////////////////////////////////////////////////////////////////////////////////////////////
   // Converters into comparison utilities.
   //////////////////////////////////////////////////////////////////////////////////////////////////
@@ -246,7 +256,7 @@ abstract static class Builder {
 
     abstract Builder setIgnoreRepeatedFieldOrder(boolean ignoringRepeatedFieldOrder);
 
-    abstract Builder setReportMismatchesOnly(boolean reportMismatchesOnly);
+    abstract Builder setIgnoreExtraRepeatedFieldElements(boolean ignoreExtraRepeatedFieldElements);
 
     abstract Builder setDoubleCorrespondence(Correspondence<Number, Number> doubleCorrespondence);
 
@@ -258,6 +268,8 @@ abstract static class Builder {
 
     abstract Builder setFieldScopeLogic(FieldScopeLogic fieldScopeLogic);
 
+    abstract Builder setReportMismatchesOnly(boolean reportMismatchesOnly);
+
     @CheckReturnValue
     abstract Function<? super Optional<Descriptor>, String> usingCorrespondenceStringFunction();
 

extensions/proto/src/main/java/com/google/common/truth/extensions/proto/IterableOfProtosFluentAssertion.java

@@ -112,6 +112,21 @@ public interface IterableOfProtosFluentAssertion<M extends Message>
    */
   IterableOfProtosFluentAssertion<M> ignoringRepeatedFieldOrder();
 
+  /**
+   * Specifies that, for all repeated and map fields, any elements in the 'actual' proto which are
+   * not found in the 'expected' proto are ignored, with the exception of fields in the expected
+   * proto which are empty. To ignore empty repeated fields as well, use {@link
+   * #comparingExpectedFieldsOnly}.
+   *
+   * <p>This rule is applied independently from {@link #ignoringRepeatedFieldOrder}. If ignoring
+   * repeated field order AND extra repeated field elements, all that is tested is that the expected
+   * elements comprise a subset of the actual elements. If not ignoring repeated field order, but
+   * still ignoring extra repeated field elements, the actual elements must contain a subsequence
+   * that matches the expected elements for the test to pass. (The subsequence rule does not apply
+   * to Map fields, which are always compared by key.)
+   */
+  IterableOfProtosFluentAssertion<M> ignoringExtraRepeatedFieldElements();
+
   /**
    * Compares double fields as equal if they are both finite and their absolute difference is less
    * than or equal to {@code tolerance}.

extensions/proto/src/main/java/com/google/common/truth/extensions/proto/IterableOfProtosSubject.java

@@ -492,6 +492,23 @@ public IterableOfProtosFluentAssertion<M> ignoringRepeatedFieldOrder() {
     return usingConfig(config.ignoringRepeatedFieldOrder());
   }
 
+  /**
+   * Specifies that, for all repeated and map fields, any elements in the 'actual' proto which are
+   * not found in the 'expected' proto are ignored, with the exception of fields in the expected
+   * proto which are empty. To ignore empty repeated fields as well, use {@link
+   * #comparingExpectedFieldsOnly}.
+   *
+   * <p>This rule is applied independently from {@link #ignoringRepeatedFieldOrder}. If ignoring
+   * repeated field order AND extra repeated field elements, all that is tested is that the expected
+   * elements comprise a subset of the actual elements. If not ignoring repeated field order, but
+   * still ignoring extra repeated field elements, the actual elements must contain a subsequence
+   * that matches the expected elements for the test to pass. (The subsequence rule does not apply
+   * to Map fields, which are always compared by key.)
+   */
+  public IterableOfProtosFluentAssertion<M> ignoringExtraRepeatedFieldElements() {
+    return usingConfig(config.ignoringExtraRepeatedFieldElements());
+  }
+
   /**
    * Compares double fields as equal if they are both finite and their absolute difference is less
    * than or equal to {@code tolerance}.
@@ -774,6 +791,11 @@ public IterableOfProtosFluentAssertion<M> ignoringRepeatedFieldOrder() {
       return subject.ignoringRepeatedFieldOrder();
     }
 
+    @Override
+    public IterableOfProtosFluentAssertion<M> ignoringExtraRepeatedFieldElements() {
+      return subject.ignoringExtraRepeatedFieldElements();
+    }
+
     @Override
     public IterableOfProtosFluentAssertion<M> usingDoubleTolerance(double tolerance) {
       return subject.usingDoubleTolerance(tolerance);

extensions/proto/src/main/java/com/google/common/truth/extensions/proto/MapWithProtoValuesFluentAssertion.java

@@ -121,6 +121,21 @@ public interface MapWithProtoValuesFluentAssertion<M extends Message> {
    */
   MapWithProtoValuesFluentAssertion<M> ignoringRepeatedFieldOrderForValues();
 
+  /**
+   * Specifies that, for all repeated and map fields, any elements in the 'actual' proto which are
+   * not found in the 'expected' proto are ignored, with the exception of fields in the expected
+   * proto which are empty. To ignore empty repeated fields as well, use {@link
+   * #comparingExpectedFieldsOnlyForValues}.
+   *
+   * <p>This rule is applied independently from {@link #ignoringRepeatedFieldOrderForValues}. If
+   * ignoring repeated field order AND extra repeated field elements, all that is tested is that the
+   * expected elements comprise a subset of the actual elements. If not ignoring repeated field
+   * order, but still ignoring extra repeated field elements, the actual elements must contain a
+   * subsequence that matches the expected elements for the test to pass. (The subsequence rule does
+   * not apply to Map fields, which are always compared by key.)
+   */
+  MapWithProtoValuesFluentAssertion<M> ignoringExtraRepeatedFieldElementsForValues();
+
   /**
    * Compares double fields as equal if they are both finite and their absolute difference is less
    * than or equal to {@code tolerance}.

extensions/proto/src/main/java/com/google/common/truth/extensions/proto/MapWithProtoValuesSubject.java

@@ -301,6 +301,23 @@ public MapWithProtoValuesFluentAssertion<M> ignoringRepeatedFieldOrderForValues(
     return usingConfig(config.ignoringRepeatedFieldOrder());
   }
 
+  /**
+   * Specifies that, for all repeated and map fields, any elements in the 'actual' proto which are
+   * not found in the 'expected' proto are ignored, with the exception of fields in the expected
+   * proto which are empty. To ignore empty repeated fields as well, use {@link
+   * #comparingExpectedFieldsOnlyForValues}.
+   *
+   * <p>This rule is applied independently from {@link #ignoringRepeatedFieldOrderForValues}. If
+   * ignoring repeated field order AND extra repeated field elements, all that is tested is that the
+   * expected elements comprise a subset of the actual elements. If not ignoring repeated field
+   * order, but still ignoring extra repeated field elements, the actual elements must contain a
+   * subsequence that matches the expected elements for the test to pass. (The subsequence rule does
+   * not apply to Map fields, which are always compared by key.)
+   */
+  public MapWithProtoValuesFluentAssertion<M> ignoringExtraRepeatedFieldElementsForValues() {
+    return usingConfig(config.ignoringExtraRepeatedFieldElements());
+  }
+
   /**
    * Compares double fields as equal if they are both finite and their absolute difference is less
    * than or equal to {@code tolerance}.
@@ -475,6 +492,11 @@ public MapWithProtoValuesFluentAssertion<M> ignoringRepeatedFieldOrderForValues(
       return subject.ignoringRepeatedFieldOrderForValues();
     }
 
+    @Override
+    public MapWithProtoValuesFluentAssertion<M> ignoringExtraRepeatedFieldElementsForValues() {
+      return subject.ignoringExtraRepeatedFieldElementsForValues();
+    }
+
     @Override
     public MapWithProtoValuesFluentAssertion<M> usingDoubleToleranceForValues(double tolerance) {
       return subject.usingDoubleToleranceForValues(tolerance);

extensions/proto/src/main/java/com/google/common/truth/extensions/proto/MultimapWithProtoValuesFluentAssertion.java

@@ -121,6 +121,21 @@ public interface MultimapWithProtoValuesFluentAssertion<M extends Message> {
    */
   MultimapWithProtoValuesFluentAssertion<M> ignoringRepeatedFieldOrderForValues();
 
+  /**
+   * Specifies that, for all repeated and map fields, any elements in the 'actual' proto which are
+   * not found in the 'expected' proto are ignored, with the exception of fields in the expected
+   * proto which are empty. To ignore empty repeated fields as well, use {@link
+   * #comparingExpectedFieldsOnlyForValues}.
+   *
+   * <p>This rule is applied independently from {@link #ignoringRepeatedFieldOrderForValues}. If
+   * ignoring repeated field order AND extra repeated field elements, all that is tested is that the
+   * expected elements comprise a subset of the actual elements. If not ignoring repeated field
+   * order, but still ignoring extra repeated field elements, the actual elements must contain a
+   * subsequence that matches the expected elements for the test to pass. (The subsequence rule does
+   * not apply to Map fields, which are always compared by key.)
+   */
+  MultimapWithProtoValuesFluentAssertion<M> ignoringExtraRepeatedFieldElementsForValues();
+
   /**
    * Compares double fields as equal if they are both finite and their absolute difference is less
    * than or equal to {@code tolerance}.

extensions/proto/src/main/java/com/google/common/truth/extensions/proto/MultimapWithProtoValuesSubject.java

@@ -345,6 +345,23 @@ public MultimapWithProtoValuesFluentAssertion<M> ignoringRepeatedFieldOrderForVa
     return usingConfig(config.ignoringRepeatedFieldOrder());
   }
 
+  /**
+   * Specifies that, for all repeated and map fields, any elements in the 'actual' proto which are
+   * not found in the 'expected' proto are ignored, with the exception of fields in the expected
+   * proto which are empty. To ignore empty repeated fields as well, use {@link
+   * #comparingExpectedFieldsOnlyForValues}.
+   *
+   * <p>This rule is applied independently from {@link #ignoringRepeatedFieldOrderForValues}. If
+   * ignoring repeated field order AND extra repeated field elements, all that is tested is that the
+   * expected elements comprise a subset of the actual elements. If not ignoring repeated field
+   * order, but still ignoring extra repeated field elements, the actual elements must contain a
+   * subsequence that matches the expected elements for the test to pass. (The subsequence rule does
+   * not apply to Map fields, which are always compared by key.)
+   */
+  public MultimapWithProtoValuesFluentAssertion<M> ignoringExtraRepeatedFieldElementsForValues() {
+    return usingConfig(config.ignoringExtraRepeatedFieldElements());
+  }
+
   /**
    * Compares double fields as equal if they are both finite and their absolute difference is less
    * than or equal to {@code tolerance}.
@@ -521,6 +538,11 @@ public MultimapWithProtoValuesFluentAssertion<M> ignoringRepeatedFieldOrderForVa
       return subject.ignoringRepeatedFieldOrderForValues();
     }
 
+    @Override
+    public MultimapWithProtoValuesFluentAssertion<M> ignoringExtraRepeatedFieldElementsForValues() {
+      return subject.ignoringExtraRepeatedFieldElementsForValues();
+    }
+
     @Override
     public MultimapWithProtoValuesFluentAssertion<M> usingDoubleToleranceForValues(
         double tolerance) {

extensions/proto/src/main/java/com/google/common/truth/extensions/proto/ProtoFluentAssertion.java

@@ -110,6 +110,21 @@ public interface ProtoFluentAssertion {
    */
   ProtoFluentAssertion ignoringRepeatedFieldOrder();
 
+  /**
+   * Specifies that, for all repeated and map fields, any elements in the 'actual' proto which are
+   * not found in the 'expected' proto are ignored, with the exception of fields in the expected
+   * proto which are empty. To ignore empty repeated fields as well, use {@link
+   * #comparingExpectedFieldsOnly}.
+   *
+   * <p>This rule is applied independently from {@link #ignoringRepeatedFieldOrder}. If ignoring
+   * repeated field order AND extra repeated field elements, all that is tested is that the expected
+   * elements comprise a subset of the actual elements. If not ignoring repeated field order, but
+   * still ignoring extra repeated field elements, the actual elements must contain a subsequence
+   * that matches the expected elements for the test to pass. (The subsequence rule does not apply
+   * to Map fields, which are always compared by key.)
+   */
+  ProtoFluentAssertion ignoringExtraRepeatedFieldElements();
+
   /**
    * Compares double fields as equal if they are both finite and their absolute difference is less
    * than or equal to {@code tolerance}.

extensions/proto/src/main/java/com/google/common/truth/extensions/proto/ProtoSubject.java

@@ -83,6 +83,11 @@ public ProtoFluentAssertion ignoringRepeatedFieldOrder() {
     return usingConfig(config.ignoringRepeatedFieldOrder());
   }
 
+  @Override
+  public ProtoFluentAssertion ignoringExtraRepeatedFieldElements() {
+    return usingConfig(config.ignoringExtraRepeatedFieldElements());
+  }
+
   @Override
   public ProtoFluentAssertion usingDoubleTolerance(double tolerance) {
     return usingConfig(config.usingDoubleTolerance(tolerance));