test: create tests for GumTreeDiff.improveMatching

Author: ibbem

src/main/java/org/variantsync/diffdetective/gumtree/VariationDiffAdapter.java

@@ -22,6 +22,7 @@ public VariationDiffAdapter(Projection<L> node) {
         super(node);
     }
 
+    @Override
     protected VariationTreeAdapter<L> newInstance(VariationNode<?, L> node) {
         return new VariationDiffAdapter<>(Cast.unchecked(node));
     }

src/main/java/org/variantsync/diffdetective/gumtree/VariationTreeAdapter.java

@@ -2,6 +2,7 @@
 
 import java.util.ArrayList;
 import java.util.Iterator;
+import java.util.LinkedHashMap;
 import java.util.Map.Entry;
 import java.util.stream.Collectors;
 
@@ -24,9 +25,11 @@
 public class VariationTreeAdapter<L extends Label> extends AbstractTree {
     private String cachedLabel;
     private VariationNode<?, L> backingNode;
+    private LinkedHashMap<String, Object> metadata;
 
     public VariationTreeAdapter(VariationNode<?, L> node) {
         this.backingNode = node;
+        this.metadata = new LinkedHashMap<>();
 
         if (backingNode.isConditionalAnnotation()) {
             cachedLabel = backingNode.getFormula().toString();
@@ -41,7 +44,7 @@ public VariationTreeAdapter(VariationNode<?, L> node) {
         setChildren(children);
     }
 
-    protected VariationTreeAdapter newInstance(VariationNode<?, L> node) {
+    protected VariationTreeAdapter<L> newInstance(VariationNode<?, L> node) {
         return new VariationTreeAdapter<>(node);
     }
 
@@ -65,12 +68,12 @@ public int getLength() {
 
     @Override
     public Iterator<Entry<String, Object>> getMetadata() {
-        throw new UnsupportedOperationException();
+        return metadata.entrySet().iterator();
     }
 
     @Override
-    public Object getMetadata(String arg0) {
-        throw new UnsupportedOperationException();
+    public Object getMetadata(String key) {
+        return metadata.get(key);
     }
 
     /**
@@ -97,8 +100,8 @@ public void setLength(int length) {
     }
 
     @Override
-    public Object setMetadata(String name, Object value) {
-        throw new UnsupportedOperationException();
+    public Object setMetadata(String key, Object value) {
+        return metadata.put(key, value);
     }
 
     @Override

src/test/java/TreeDiffingTest.java

@@ -1,12 +1,13 @@
 import com.github.gumtreediff.matchers.Matcher;
 import com.github.gumtreediff.matchers.Matchers;
 import org.apache.commons.io.IOUtils;
+import org.eclipse.jgit.diff.DiffAlgorithm;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 import org.variantsync.diffdetective.diff.result.DiffParseException;
-import org.variantsync.diffdetective.feature.cpp.CPPAnnotationParser;
 import org.variantsync.diffdetective.util.IO;
 import org.variantsync.diffdetective.variation.DiffLinesLabel;
+import org.variantsync.diffdetective.variation.diff.DiffNode;
 import org.variantsync.diffdetective.variation.diff.VariationDiff;
 import org.variantsync.diffdetective.variation.diff.construction.GumTreeDiff;
 import org.variantsync.diffdetective.variation.diff.parse.VariationDiffParseOptions;
@@ -17,6 +18,7 @@
 import org.variantsync.diffdetective.variation.diff.serialize.edgeformat.ChildOrderEdgeFormat;
 import org.variantsync.diffdetective.variation.diff.serialize.edgeformat.DefaultEdgeLabelFormat;
 import org.variantsync.diffdetective.variation.diff.serialize.nodeformat.FullNodeFormat;
+import org.variantsync.diffdetective.variation.diff.source.VariationDiffSource;
 import org.variantsync.diffdetective.variation.tree.VariationTree;
 import org.variantsync.diffdetective.variation.tree.source.LocalFileSource;
 
@@ -33,7 +35,7 @@ public class TreeDiffingTest {
     private final static Path testDir = Constants.RESOURCE_DIR.resolve("tree-diffing");
     private static Pattern expectedFileNameRegex = Pattern.compile("([^_]+)_([^_]+)_expected.lg");
 
-    private static record TestCase(String basename, String matcherName, Matcher matcher) {
+    private static record TestCase(String expectedDir, String basename, String matcherName, Matcher matcher) {
         public Path beforeEdit() {
             return testDir.resolve(String.format("%s.before", basename()));
         }
@@ -43,28 +45,29 @@ public Path afterEdit() {
         }
 
         public Path actual() {
-            return testDir.resolve(String.format("%s_%s_actual.lg", basename(), matcherName()));
+            return testDir.resolve(expectedDir).resolve(String.format("%s_%s_actual.lg", basename(), matcherName()));
         }
 
         public Path expected() {
-            return testDir.resolve(String.format("%s_%s_expected.lg", basename(), matcherName()));
+            return testDir.resolve(expectedDir).resolve(String.format("%s_%s_expected.lg", basename(), matcherName()));
         }
 
         public Path visualisation() {
-            return testDir.resolve("tex").resolve(String.format("%s_%s.tex", basename(), matcherName()));
+            return testDir.resolve(expectedDir).resolve("tex").resolve(String.format("%s_%s.tex", basename(), matcherName()));
         }
     }
 
-    private static Stream<TestCase> testCases() throws IOException {
+    private static Stream<TestCase> testCases(String expectedDir) throws IOException {
         return Files
-                .list(testDir)
+                .list(testDir.resolve(expectedDir))
                 .mapMulti(((path, result) -> {
                     String filename = path.getFileName().toString();
                     var filenameMatcher = expectedFileNameRegex.matcher(filename);
                     if (filenameMatcher.matches()) {
                         var treeMatcherName = filenameMatcher.group(2);
 
                         result.accept(new TestCase(
+                                expectedDir,
                                 filenameMatcher.group(1),
                                 treeMatcherName,
                                 Matchers.getInstance().getMatcher(treeMatcherName))
@@ -73,14 +76,40 @@ private static Stream<TestCase> testCases() throws IOException {
                 }));
     }
 
+    private static Stream<TestCase> createMatchingTestCases() throws IOException {
+        return testCases("createMatching");
+    }
+
     @ParameterizedTest
-    @MethodSource("testCases")
-    public void testCase(TestCase testCase) throws IOException, DiffParseException {
+    @MethodSource("createMatchingTestCases")
+    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));
+    }
+
+    private static Stream<TestCase> improveMatchingTestCases() throws IOException {
+        return testCases("improveMatching");
+    }
 
-        VariationDiff<DiffLinesLabel> variationDiff = GumTreeDiff.diffUsingMatching(beforeEdit, afterEdit);
+    @ParameterizedTest
+    @MethodSource("improveMatchingTestCases")
+    public void improveMatchingTestCase(TestCase testCase) throws IOException, DiffParseException {
+        VariationDiff<DiffLinesLabel> variationDiff =
+            VariationDiff.fromFiles(
+                testCase.beforeEdit(),
+                testCase.afterEdit(),
+                DiffAlgorithm.SupportedAlgorithm.MYERS,
+                VariationDiffParseOptions.Default
+            );
+
+        DiffNode<DiffLinesLabel> improvedDiffNode = GumTreeDiff.improveMatching(variationDiff.getRoot(), testCase.matcher());
+        VariationDiff<DiffLinesLabel> improvedVariationDiff = new VariationDiff<>(improvedDiffNode, VariationDiffSource.Unknown);
+
+        assertExpectedVariationDiffs(testCase, improvedVariationDiff);
+    }
 
+    private static void assertExpectedVariationDiffs(TestCase testCase, VariationDiff<DiffLinesLabel> variationDiff) throws IOException {
         try (var output = IO.newBufferedOutputStream(testCase.actual())) {
             new LineGraphExporter<>(new Format<>(new FullNodeFormat(), new ChildOrderEdgeFormat<>()))
                     .exportVariationDiff(variationDiff, output);
@@ -111,15 +140,12 @@ public void testCase(TestCase testCase) throws IOException, DiffParseException {
         }
     }
 
-    public VariationTree<DiffLinesLabel> parseVariationTree(Path filename) throws IOException, DiffParseException {
+    private static VariationTree<DiffLinesLabel> parseVariationTree(Path filename) throws IOException, DiffParseException {
         try (var file = Files.newBufferedReader(filename)) {
             return new VariationTree<>(
                     VariationDiffParser.createVariationTree(
                             file,
-                            new VariationDiffParseOptions(
-                                    new CPPAnnotationParser(),
-                                    false,
-                                    false)
+                            VariationDiffParseOptions.Default
                     ).getRoot().projection(BEFORE).toVariationTree(),
                     new LocalFileSource(filename)
             );

src/test/resources/tree-diffing/.gitignore

@@ -1,2 +1,2 @@
-/tex/
+tex/
 *_actual.lg