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).

Author: ibbem

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

@@ -34,10 +34,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()));
@@ -84,7 +92,19 @@ 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.
+        if (!matching.has(src, 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);
+        }
 
         removeUnmapped(matching, src);
         for (var child : dst.getChildren()) {

src/test/java/TreeDiffingTest.java

@@ -79,7 +79,7 @@ public void testCase(TestCase testCase) throws IOException, DiffParseException {
         VariationTree<DiffLinesLabel> beforeEdit = parseVariationTree(testCase.beforeEdit());
         VariationTree<DiffLinesLabel> afterEdit = parseVariationTree(testCase.afterEdit());
 
-        VariationDiff<DiffLinesLabel> variationDiff = GumTreeDiff.diffUsingMatching(beforeEdit, afterEdit);
+        VariationDiff<DiffLinesLabel> variationDiff = GumTreeDiff.diffUsingMatching(beforeEdit, afterEdit, testCase.matcher());
 
         try (var output = IO.newBufferedOutputStream(testCase.actual())) {
             new LineGraphExporter<>(new Format<>(new FullNodeFormat(), new ChildOrderEdgeFormat<>()))

src/test/resources/tree-diffing/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