Fix test failures that aries when running under different Java configurations.

cgruber · cgruber · commit 5015d69a52ed · 2014-07-17T13:56:07.000-07:00
TreeDifferTest was relying on the assumption that TreePath.getPath() would find a valid tree path from CompilationUnitTree A to subtree B if that subtree was identical to one found by a traversal of CompilationUnitTree A. This behavior is apparently not guaranteed. JavaSourcesSubjectFactoryTest makes some assumptions about how many diagnostics will be reported before failure. This CL changes it to only look for the specific diagnostics for which it is testing. ------------- Created by MOE: http://code.google.com/p/moe-java MOE_MIGRATED_REVID=70104902
diff --git a/src/main/java/com/google/testing/compile/TreeDiffer.java b/src/main/java/com/google/testing/compile/TreeDiffer.java
@@ -108,19 +108,18 @@ static final TreeDifference diffCompilationUnits(@Nullable CompilationUnitTree e
   }
 
   /**
-   * Returns a {@code TreeDifference} describing the difference between the two
-   * sub-{@code Tree}s of the {@code CompilationUnitTree}s provided.
+   * Returns a {@link TreeDifference} describing the difference between the two
+   * sub-{@code Tree}s. The trees diffed are the leaves of the {@link TreePath}s
+   * provided.
    *
-   * @throws IllegalArgumentException if the subtrees given are not members of their respective
-   *   compilation units.
+   * <p>Used for testing.
    */
-  static final TreeDifference diffSubtrees(CompilationUnitTree expectedCompilationUnit,
-      @Nullable Tree expectedSubtree, CompilationUnitTree actualCompilationUnit,
-      @Nullable Tree actualSubtree) {
+  static final TreeDifference diffSubtrees(@Nullable TreePath pathToExpected,
+      @Nullable TreePath pathToActual) {
     TreeDifference.Builder diffBuilder = new TreeDifference.Builder();
     DiffVisitor diffVisitor = new DiffVisitor(diffBuilder,
-        expectedCompilationUnit, expectedSubtree, actualCompilationUnit, actualSubtree);
-    diffVisitor.scan(expectedSubtree, actualSubtree);
+        pathToExpected, pathToActual);
+    diffVisitor.scan(pathToExpected.getLeaf(), pathToActual.getLeaf());
     return diffBuilder.build();
   }
 
@@ -142,22 +141,14 @@ public DiffVisitor(TreeDifference.Builder diffBuilder) {
     }
 
     /**
-     * Constructs a DiffVisitor whose {@code TreePath}s are initialized with paths constructed
-     * from the trees provided
-     *
-     * @throws IllegalArgumentException if the subtrees given are not members of their respective
-     *   compilation units.
+     * Constructs a DiffVisitor whose {@code TreePath}s are initialized with the paths
+     * provided.
      */
     public DiffVisitor(TreeDifference.Builder diffBuilder,
-        CompilationUnitTree expectedCompilationUnit, Tree expectedSubtree,
-        CompilationUnitTree actualCompilationUnit, Tree actualSubtree) {
+        TreePath pathToExpected, TreePath pathToActual) {
       this.diffBuilder = diffBuilder;
-      expectedPath = TreePath.getPath(expectedCompilationUnit, expectedSubtree);
-      actualPath = TreePath.getPath(actualCompilationUnit, actualSubtree);
-      checkArgument(expectedPath != null, "Couldn't initialize differ because no "
-          + "path could be found connecting the node and compilation root given.");
-      checkArgument(actualPath != null, "Couldn't initialize differ because no "
-          + "path could be found connecting the node and compilation root given.");
+      expectedPath = pathToExpected;
+      actualPath = pathToActual;
     }
 
     /**
diff --git a/src/test/java/com/google/testing/compile/JavaSourcesSubjectFactoryTest.java b/src/test/java/com/google/testing/compile/JavaSourcesSubjectFactoryTest.java
@@ -175,9 +175,9 @@ public void failsToCompile_throwsNotInFile() {
       fail();
     } catch (VerificationException expected) {
       ASSERT.that(expected.getMessage())
-          .isEqualTo(String.format("Expected an error in %s, but only found errors in %s",
-              otherFileObject.getName(), ImmutableSet.of(fileObject.getName(),
-                  "(no associated file)")));
+          .contains(String.format("Expected an error in %s", otherFileObject.getName()));
+      ASSERT.that(expected.getMessage()).contains(fileObject.getName());
+      //                  "(no associated file)")));
     }
   }
 
@@ -192,10 +192,10 @@ public void failsToCompile_throwsNotOnLine() {
           .in(fileObject).onLine(1);
       fail();
     } catch (VerificationException expected) {
+      int actualErrorLine = 18;
       ASSERT.that(expected.getMessage())
-          .isEqualTo(String.format(
-              "Expected an error on line 1 of %s, but only found errors on line(s) [18]",
-              fileObject.getName()));
+          .contains(String.format("Expected an error on line 1 of %s", fileObject.getName()));
+      ASSERT.that(expected.getMessage()).contains("" + actualErrorLine);
     }
   }
 
@@ -210,10 +210,10 @@ public void failsToCompile_throwsNotAtColumn() {
           .in(fileObject).onLine(18).atColumn(1);
       fail();
     } catch (VerificationException expected) {
+      int actualErrorCol = 8;
       ASSERT.that(expected.getMessage())
-          .isEqualTo(String.format(
-              "Expected an error at 18:1 of %s, but only found errors at column(s) [8]",
-              fileObject.getName()));
+          .contains(String.format("Expected an error at 18:1 of %s", fileObject.getName()));
+      ASSERT.that(expected.getMessage()).contains("" + actualErrorCol);
     }
   }
 
diff --git a/src/test/java/com/google/testing/compile/TreeDifferTest.java b/src/test/java/com/google/testing/compile/TreeDifferTest.java
@@ -20,6 +20,7 @@
 import com.google.common.collect.ImmutableList;
 
 import com.sun.source.tree.*;
+import com.sun.source.util.TreePath;
 
 import org.junit.Rule;
 import org.junit.Test;
@@ -140,27 +141,29 @@ public void scan_sameCompilationUnit() {
 
   @Test
   public void scan_identicalMethods() {
-    ASSERT.that(
-        TreeDiffer.diffSubtrees(EXPECTED_TREE, baseToStringTree(), ACTUAL_TREE, diffToStringTree())
+    ASSERT.that(TreeDiffer.diffSubtrees(baseToStringTree(), diffToStringTree())
         .isEmpty()).isTrue();
   }
 
   @Test
   public void scan_differentTypes() {
-    TreeDifference diff =
-        TreeDiffer.diffSubtrees(EXPECTED_TREE, EXPECTED_TREE, ACTUAL_TREE, diffToStringTree());
+    TreeDifference diff = TreeDiffer.diffSubtrees(asPath(EXPECTED_TREE), diffToStringTree());
     ASSERT.that(diff.isEmpty()).isFalse();
     for (TreeDifference.TwoWayDiff differingNode : diff.getDifferingNodes()) {
       ASSERT.that(differingNode.getDetails()).contains("Expected node kind to be");
     }
   }
 
-  private Tree baseToStringTree() {
-    return MoreTrees.findSubtree(EXPECTED_TREE, Tree.Kind.METHOD, "toString");
+  private TreePath asPath(CompilationUnitTree compilationUnit) {
+    return MoreTrees.findSubtreePath(compilationUnit, Tree.Kind.COMPILATION_UNIT);
+  }
+
+  private TreePath baseToStringTree() {
+    return MoreTrees.findSubtreePath(EXPECTED_TREE, Tree.Kind.METHOD, "toString");
   }
 
-  private Tree diffToStringTree() {
-    return MoreTrees.findSubtree(ACTUAL_TREE, Tree.Kind.METHOD, "toString");
+  private TreePath diffToStringTree() {
+    return MoreTrees.findSubtreePath(ACTUAL_TREE, Tree.Kind.METHOD, "toString");
   }
 
   private static class SimplifiedDiff {
