Add CI tests on merge

sdg-core/src/test/java/es/upv/mist/slicing/SlicerTest.java

@@ -11,6 +11,7 @@ import es.upv.mist.slicing.graphs.sdg.SDG;
 import es.upv.mist.slicing.slicing.FileLineSlicingCriterion;
 import es.upv.mist.slicing.slicing.Slice;
 import es.upv.mist.slicing.slicing.SlicingCriterion;
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
@@ -18,10 +19,9 @@ import org.junit.jupiter.params.provider.MethodSource;
 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.PrintWriter;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.LinkedList;
-import java.util.Scanner;
+import java.util.*;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
 
 public class SlicerTest {
     static {
@@ -32,63 +32,136 @@ public class SlicerTest {
         StaticJavaParser.getConfiguration().setAttributeComments(false);
     }
 
-    private static final String TEST_FILES = "./sdg-core/src/test/res/dinsa-tests";
+    private static final String TEST_PKG = "regression";
     private static final String DOT_JAVA = ".java";
+    private static final String SDG_CRITERION = ".sdg.criterion";
+    private static final String SDG_SLICE = ".sdg.sliced";
 
-    public static Collection<Arguments> findFiles(File directory, String suffix) throws FileNotFoundException {
-        Collection<Arguments> res = new LinkedList<>();
+    public static void findFiles(File directory, String suffix, Consumer<File> consumer) {
         File[] files = directory.listFiles();
-        if (files == null) return Collections.emptyList();
+        if (files == null)
+            return;
         for (File f : files) {
-            if (f.getName().endsWith(suffix))
-                res.add(Arguments.of(f, getSliceFile(f), getCriterionLine(f)));
             if (f.isDirectory())
-                res.addAll(findFiles(f, suffix));
+                findFiles(f, suffix, consumer);
+            else if (f.getName().endsWith(suffix))
+                consumer.accept(f);
         }
-        return res;
     }
 
-    public static Arguments[] findAllFiles() throws FileNotFoundException {
-        Collection<Arguments> args = findFiles(new File(TEST_FILES), DOT_JAVA);
+    public static Arguments[] findAllFiles() {
+        Collection<Arguments> args = new LinkedList<>();
+        File testFolder = new File(Thread.currentThread().getContextClassLoader().getResource(TEST_PKG).getPath());
+        findFiles(testFolder, DOT_JAVA, f -> createArgumentForTest(f).ifPresent(args::add));
         return args.toArray(Arguments[]::new);
     }
 
-    private static File getSliceFile(File file) {
-        return new File(file.getParent(), file.getName() + ".sdg.sliced");
-    }
-
-    private static int getCriterionLine(File file) throws FileNotFoundException {
-        return new Scanner(new File(file.getParent(), file.getName() + ".sdg.criterion")).nextInt();
+    private static Optional<Arguments> createArgumentForTest(File javaFile) {
+        File slice = new File(javaFile.getParent(), javaFile.getName() + SDG_SLICE);
+        Optional<SlicingCriterion> criterion = findSDGCriterion(javaFile);
+        if (!slice.isFile() || !slice.canRead() || criterion.isEmpty())
+            return Optional.empty();
+        return Optional.of(Arguments.of(javaFile, slice, criterion.get()));
     }
 
     @ParameterizedTest(name = "[{index}] {0}")
     @MethodSource("findAllFiles")
-    public void sdgCompare(File source, File target, int criterionLine) throws FileNotFoundException {
-        // Build the SDG
-        SDG sdg = new ESSDG();
-        sdg.build(new NodeList<>(StaticJavaParser.parse(source)));
-        SlicingCriterion sc = new FileLineSlicingCriterion(source, criterionLine);
-        Slice slice = sdg.slice(sc);
-
-        // Convert the slice to code and output the result to `outputDir`
-        NodeList<CompilationUnit> slicedUnits = slice.toAst();
-        assert slicedUnits.size() == 1;
-        if (!target.exists()) {
-            try (PrintWriter pw = new PrintWriter(target)) {
-                pw.print(slicedUnits.get(0).toString());
-            }
+    public void slicerRegressionTest(File source, File target, SlicingCriterion sc) throws FileNotFoundException {
+        if (!target.exists())
             return;
+        Slice slice = slice(source ,sc);
+        boolean equal = slicesMatch(slice, target);
+        assert equal: "The slice for " + source.toString() + " has changed, please fix the error or update the reference slice.";
+    }
+
+    @Test
+    public void generateDefaultSlices() {
+        File testFolder = new File("./sdg-core/src/test/res/", TEST_PKG);
+        findFiles(testFolder, DOT_JAVA, SlicerTest::createAndSaveSlice);
+    }
+
+    private static Optional<SlicingCriterion> findSDGCriterion(File javaFile) {
+        File criterionFile = new File(javaFile.getParentFile(), javaFile.getName() + SDG_CRITERION);
+        try (Scanner in = new Scanner(criterionFile)) {
+            return Optional.of(new FileLineSlicingCriterion(javaFile, in.nextInt()));
+        } catch (FileNotFoundException | NoSuchElementException e) {
+            return Optional.empty();
+        }
+    }
+
+    private static void createAndSaveSlice(File javaFile) {
+        try {
+            File sliceFile = new File(javaFile.getParent(), javaFile.getName() + SDG_SLICE);
+            Optional<SlicingCriterion> sc = findSDGCriterion(javaFile);
+            if (sc.isEmpty() || sliceFile.exists())
+                return;
+            Slice slice = slice(javaFile, sc.get());
+            var cus = slice.toAst();
+            assert cus.size() == 1;
+            try (PrintWriter pw = new PrintWriter(sliceFile)) {
+                pw.write(cus.getFirst().get().toString());
+            }
+        } catch (FileNotFoundException e) {
+            System.err.println("Could not save slice due to missing file or permissions");
+        } catch (Exception e) {
+            System.err.println("Error generating slice for " + javaFile.toString());
+            System.err.println(e.getMessage());
+            e.printStackTrace();
         }
-        String targetSlice;
-        {
+    }
+
+    private static boolean slicesMatch(Slice slice, File referenceSlice) {
+        NodeList<CompilationUnit> cus = slice.toAst();
+        assert cus.size() == 1;
+        return Objects.equals(cus.getFirst().get().toString(), readFile(referenceSlice));
+    }
+
+    private static String readFile(File file, Supplier<String> separator) {
+        try (Scanner in = new Scanner(file)) {
             StringBuilder builder = new StringBuilder();
-            Scanner in = new Scanner(target);
             while (in.hasNextLine())
-                builder.append(in.nextLine()).append('\n');
-            targetSlice = builder.toString();
+                builder.append(in.nextLine()).append(separator.get());
+            return builder.toString();
+        } catch (FileNotFoundException e) {
+            return "";
         }
-        String ourSlice = slicedUnits.get(0).toString();
-        boolean equal = targetSlice.equals(ourSlice);
-        assert equal;
+    }
+
+    private static String readFile(File file) {
+        return readFile(file, () -> "\n");
+    }
+
+    private static Slice slice(File javaFile, SlicingCriterion sc) throws FileNotFoundException {
+        SDG sdg = new ESSDG();
+        sdg.build(new NodeList<>(StaticJavaParser.parse(javaFile)));
+        return sdg.slice(sc);
+    }
+
+    public static void main(String[] args) {
+        Scanner in = new Scanner(System.in);
+        File testFolder = new File("./sdg-core/src/test/res/", TEST_PKG);
+        findFiles(testFolder, DOT_JAVA, file -> {
+           File sliceFile = new File(file.getParent(), file.getName() + SDG_CRITERION);
+           if (!sliceFile.exists()) {
+               int[] counter = new int[] { 1 };
+               System.out.printf("%3d", counter[0]++);
+               System.out.print(readFile(file, () -> String.format("\n%3d", counter[0]++)));
+               System.out.printf("No criterion found for this program (%s), please input one (-1 to skip)\nCriterion: ", file);
+               int line = in.nextInt();
+               if (line == -1)
+                   return;
+               while (line <= 0 || line >= counter[0] - 2) {
+                   System.out.printf("Your input is out-of-bounds, please try again [1-%d]: ", counter[0] - 2);
+                   line = in.nextInt();
+               }
+               System.out.printf("Saving line %d as slicing criterion for %s... ", line, file);
+               try (PrintWriter pw = new PrintWriter(sliceFile)) {
+                   pw.write(line + "");
+                   System.out.println("DONE");
+               } catch (FileNotFoundException e) {
+                   System.out.println("ERROR");
+               }
+           }
+        });
     }
 }