Implement JavaFileObjectSubject.containsElementsIn()

RELNOTES=Implement JavaFileObjectSubject.containsElementsIn()

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

Author: ronshapiro

pom.xml

@@ -15,6 +15,7 @@
   <description>Utilities for testing compilation.</description>
 
   <properties>
+    <auto-common.version>0.8</auto-common.version>
     <auto-value.version>1.5</auto-value.version>
     <guava.version>23.1-jre</guava.version>
     <truth.version>0.36</truth.version>
@@ -82,6 +83,11 @@
       <artifactId>auto-value</artifactId>
       <version>${auto-value.version}</version>
     </dependency>
+    <dependency>
+      <groupId>com.google.auto</groupId>
+      <artifactId>auto-common</artifactId>
+      <version>${auto-common.version}</version>
+    </dependency>
   </dependencies>
   <build>
     <plugins>

src/main/java/com/google/testing/compile/JavaFileObjectSubject.java

@@ -19,6 +19,7 @@
 import static com.google.common.truth.Truth.assertAbout;
 import static com.google.testing.compile.JavaFileObjects.asByteSource;
 import static com.google.testing.compile.TreeDiffer.diffCompilationUnits;
+import static com.google.testing.compile.TreeDiffer.matchCompilationUnits;
 import static java.nio.charset.StandardCharsets.UTF_8;
 
 import com.google.common.base.Joiner;
@@ -31,6 +32,7 @@
 import com.sun.source.tree.CompilationUnitTree;
 import java.io.IOException;
 import java.nio.charset.Charset;
+import java.util.function.BiFunction;
 import javax.annotation.Nullable;
 import javax.tools.JavaFileObject;
 
@@ -113,17 +115,65 @@ public StringSubject contentsAsUtf8String() {
   }
 
   /**
-   * Asserts that the actual file is a source file with contents equivalent to {@code
+   * Asserts that the actual file is a source file that has an equivalent <a
+   * href="https://en.wikipedia.org/wiki/Abstract_syntax_tree">AST</a> to that of {@code
    * expectedSource}.
    */
   public void hasSourceEquivalentTo(JavaFileObject expectedSource) {
+    performTreeDifference(
+        expectedSource,
+        "is equivalent to",
+        "Expected Source",
+        (expectedResult, actualResult) ->
+            diffCompilationUnits(
+                getOnlyElement(expectedResult.compilationUnits()),
+                getOnlyElement(actualResult.compilationUnits())));
+  }
+
+  /**
+   * Asserts that the every node in the <a
+   * href="https://en.wikipedia.org/wiki/Abstract_syntax_tree">AST</a> of {@code expectedPattern}
+   * exists in the actual file's AST, in the same order.
+   *
+   * <p>Methods, constructors, fields, and types that are in the pattern must have the exact same
+   * modifiers and annotations as the actual AST. Ordering of AST nodes is also important (i.e. a
+   * type with identical members in a different order will fail the assertion). Types must match the
+   * entire type declaration: type parameters, {@code extends}/{@code implements} clauses, etc.
+   * Methods must also match the throws clause as well.
+   *
+   * <p>The body of a method or constructor, or field initializer in the actual AST must match the
+   * pattern in entirety if the member is present in the pattern.
+   *
+   * <p>Said in another way (from a graph-theoretic perspective): the pattern AST must be a subgraph
+   * of the actual AST. If a method, constructor, or field is in the pattern, that entire subtree,
+   * including modifiers and annotations, must be equal to the corresponding subtree in the actual
+   * AST (no proper subgraphs).
+   */
+  public void containsElementsIn(JavaFileObject expectedPattern) {
+    performTreeDifference(
+        expectedPattern,
+        "contains elements in",
+        "Expected Pattern",
+        (expectedResult, actualResult) ->
+            matchCompilationUnits(
+                getOnlyElement(expectedResult.compilationUnits()),
+                actualResult.trees(),
+                getOnlyElement(actualResult.compilationUnits()),
+                expectedResult.trees()));
+  }
+
+  private void performTreeDifference(
+      JavaFileObject expected,
+      String failureVerb,
+      String expectedTitle,
+      BiFunction<ParseResult, ParseResult, TreeDifference> differencingFunction) {
     ParseResult actualResult = Parser.parse(ImmutableList.of(actual()));
     CompilationUnitTree actualTree = getOnlyElement(actualResult.compilationUnits());
 
-    ParseResult expectedResult = Parser.parse(ImmutableList.of(expectedSource));
+    ParseResult expectedResult = Parser.parse(ImmutableList.of(expected));
     CompilationUnitTree expectedTree = getOnlyElement(expectedResult.compilationUnits());
 
-    TreeDifference treeDifference = diffCompilationUnits(expectedTree, actualTree);
+    TreeDifference treeDifference = differencingFunction.apply(expectedResult, actualResult);
 
     if (!treeDifference.isEmpty()) {
       String diffReport =
@@ -134,17 +184,17 @@ public void hasSourceEquivalentTo(JavaFileObject expectedSource) {
         fail(
             Joiner.on('\n')
                 .join(
-                    String.format("is equivalent to <%s>.", expectedSource.toUri().getPath()),
+                    String.format("%s <%s>.", failureVerb, expected.toUri().getPath()),
                     "",
                     "Diffs:",
                     "======",
                     "",
                     diffReport,
                     "",
-                    "Expected Source:",
+                    expectedTitle + ":",
                     "================",
                     "",
-                    expectedSource.getCharContent(false),
+                    expected.getCharContent(false),
                     "",
                     "Actual Source:",
                     "==============",