test: fix the DiffTreeParser tests for non-GumTree matchers

Previously, all tests would run with the default GumTree matcher instead
of the matcher stated in the test case file name.

As stated in my bachelor thesis, some matchers fail to return a valid
matching. Hence, some test cases need to be removed. In particular, the
theta matcher contains a bug that results in matchings that are
inconsistent (e.g., A->B but B->C). Furthermore, the
gumtree-partition-id matcher tests have been removed. This matcher is
already removed in a newer GumTree version.

Author: ibbem

src/main/java/org/variantsync/diffdetective/variation/diff/construction/GumTreeDiff.java

@@ -35,10 +35,18 @@ public class GumTreeDiff {
      * @see diffUsingMatching(VariationNode, VariationNode, Matcher)
      */
     public static <L extends Label> VariationDiff<L> diffUsingMatching(VariationTree<L> before, VariationTree<L> after) {
+        return diffUsingMatching(before, after, Matchers.getInstance().getMatcher());
+    }
+
+    /**
+     * Create a {@link VariationDiff} by matching nodes between {@code before} and {@code after}
+     * with {@code matcher}.
+     */
+    public static <L extends Label> VariationDiff<L> diffUsingMatching(VariationTree<L> before, VariationTree<L> after, Matcher matcher) {
         DiffNode<L> root = diffUsingMatching(
             before.root(),
             after.root(),
-            Matchers.getInstance().getMatcher()
+            matcher
         );
 
         return new VariationDiff<>(root, new VariationTreeDiffSource(before.source(), after.source()));
@@ -85,7 +93,10 @@ public static <B extends VariationNode<B, L>, L extends Label> DiffNode<L> diffU
         var dst = new VariationTreeAdapter<L>(after);
 
         MappingStore matching = matcher.match(src, dst);
-        Assert.assertTrue(matching.has(src, dst));
+
+        // The following algorithm assumes that the root nodes are matched so we ensure that this is
+        // the case here by establishing that mapping if necessary.
+        ensureMapping(matching, src, dst);
 
         removeUnmapped(matching, src);
         for (var child : dst.getChildren()) {
@@ -182,7 +193,10 @@ public static <L extends Label> DiffNode<L> improveMatching(DiffNode<L> tree, Ma
         MappingStore matching = new MappingStore(src, dst);
         extractMatching(src, dst, matching);
         matcher.match(src, dst, matching);
-        Assert.assertTrue(matching.has(src, dst));
+
+        // The following algorithm assumes that the root nodes are matched so we ensure that this is
+        // the case here by establishing that mapping if necessary.
+        ensureMapping(matching, src, dst);
 
         for (var srcNode : src.preOrder()) {
             var dstNode = matching.getDstForSrc(srcNode);
@@ -299,4 +313,20 @@ private static <L extends Label> void extractMatching(
             }
         }
     }
+
+    /**
+     * Add a mapping between {@code src} and {@code dst}.
+     * In case {@code src} or {@code dst} are mapped to some other nodes, these mappings are
+     * removed.
+     */
+    private static void ensureMapping(MappingStore matching, Tree src, Tree dst) {
+        if (matching.isSrcMapped(src)) {
+            matching.removeMapping(src, matching.getDstForSrc(src));
+        }
+        if (matching.isDstMapped(dst)) {
+            matching.removeMapping(dst, matching.getSrcForDst(dst));
+        }
+
+        matching.addMapping(src, dst);
+    }
 }

src/test/java/TreeDiffingTest.java

@@ -85,7 +85,7 @@ private static Stream<TestCase> createMatchingTestCases() throws IOException {
     public void createMatchingTestCase(TestCase testCase) throws IOException, DiffParseException {
         VariationTree<DiffLinesLabel> beforeEdit = parseVariationTree(testCase.beforeEdit());
         VariationTree<DiffLinesLabel> afterEdit = parseVariationTree(testCase.afterEdit());
-        assertExpectedVariationDiffs(testCase, GumTreeDiff.diffUsingMatching(beforeEdit, afterEdit));
+        assertExpectedVariationDiffs(testCase, GumTreeDiff.diffUsingMatching(beforeEdit, afterEdit, testCase.matcher()));
     }
 
     private static Stream<TestCase> improveMatchingTestCases() throws IOException {

src/test/resources/tree-diffing/createMatching/07_change-distiller-theta_expected.lg

@@ -1,12 +1,11 @@
 v 80 NON;IF;(old: -1, diff: 0, new: -1);(old: -1, diff: 0, new: -1);True
-v 136 REM;IF;(old: 1, diff: 1, new: -1);(old: 5, diff: 1, new: -1);defined(CONFIG_A);#ifdef CONFIG_A
+v 144 NON;IF;(old: 1, diff: 1, new: 1);(old: 5, diff: 1, new: 5);defined(CONFIG_A);#ifdef CONFIG_A
 v 200 REM;IF;(old: 2, diff: 2, new: -1);(old: 4, diff: 2, new: -1);defined(CONFIG_B);#ifdef CONFIG_B
 v 275 NON;ARTIFACT;(old: 3, diff: 3, new: 3);(old: 4, diff: 3, new: 4);;Line
 v 320 ADD;IF;(old: -1, diff: 4, new: 1);(old: -1, diff: 4, new: 5);defined(CONFIG_B);#ifdef CONFIG_B
-v 384 ADD;IF;(old: -1, diff: 5, new: 2);(old: -1, diff: 5, new: 4);defined(CONFIG_A);#ifdef CONFIG_A
-e 136 80 b;0,-1
+e 144 80 b;0,-1
 e 320 80 a;-1,0
-e 200 136 b;0,-1
+e 200 144 b;0,-1
+e 275 144 a;-1,0
 e 275 200 b;0,-1
-e 384 320 a;-1,0
-e 275 384 a;-1,0
+e 144 320 a;-1,0

src/test/resources/tree-diffing/createMatching/07_classic-gumtree-theta_expected.lg

@@ -1,12 +1,13 @@
 v 80 NON;IF;(old: -1, diff: 0, new: -1);(old: -1, diff: 0, new: -1);True
 v 136 REM;IF;(old: 1, diff: 1, new: -1);(old: 5, diff: 1, new: -1);defined(CONFIG_A);#ifdef CONFIG_A
 v 200 REM;IF;(old: 2, diff: 2, new: -1);(old: 4, diff: 2, new: -1);defined(CONFIG_B);#ifdef CONFIG_B
-v 275 NON;ARTIFACT;(old: 3, diff: 3, new: 3);(old: 4, diff: 3, new: 4);;Line
+v 267 REM;ARTIFACT;(old: 3, diff: 3, new: -1);(old: 4, diff: 3, new: -1);;Line
 v 320 ADD;IF;(old: -1, diff: 4, new: 1);(old: -1, diff: 4, new: 5);defined(CONFIG_B);#ifdef CONFIG_B
 v 384 ADD;IF;(old: -1, diff: 5, new: 2);(old: -1, diff: 5, new: 4);defined(CONFIG_A);#ifdef CONFIG_A
+v 451 ADD;ARTIFACT;(old: -1, diff: 6, new: 3);(old: -1, diff: 6, new: 4);;Line
 e 136 80 b;0,-1
 e 320 80 a;-1,0
 e 200 136 b;0,-1
-e 275 200 b;0,-1
+e 267 200 b;0,-1
 e 384 320 a;-1,0
-e 275 384 a;-1,0
+e 451 384 a;-1,0