Feature/allow single submissions

.github/workflows/complete-e2e.yml

@@ -70,6 +70,7 @@ jobs:
           {zip: "folderMultiRoot.zip", name: "folderMultiRoot", folder: "f0", language: "java", cliArgs: "--new f1"},
           {zip: "mixedMultiRoot.zip", name: "mixedBaseFile", folder: "f0", language: "java", cliArgs: "--new f1"},
           {zip: "mixedMultiRoot.zip", name: "mixedBaseFolder", folder: "f1", language: "java", cliArgs: "--new f0"},
+          {zip: "singleNewSubmission.zip", name: "singleNewSubmission", folder: "2023", language: "java", cliArgs: "--old 2022,2021,2020"},
           {zip: "cpp.zip", name: "cpp", folder: "./cpp", language: "cpp", cliArgs: ""},
           {zip: "csharp.zip", name: "csharp", folder: "./csharp", language: "csharp", cliArgs: ""},
           {zip: "python.zip", name: "python", folder: "./python", language: "python3", cliArgs: ""}

core/src/main/java/de/jplag/JPlag.java

@@ -109,11 +109,11 @@ private static void logSkippedSubmissions(SubmissionSet submissionSet, JPlagOpti
 
     private static void checkForConfigurationConsistency(JPlagOptions options) throws RootDirectoryException {
         if (options.normalize() && !options.language().supportsNormalization()) {
-            logger.error(String.format("The language %s cannot be used with normalization.", options.language().getName()));
+            logger.error("The language {} cannot be used with normalization.", options.language().getName());
         }
 
         List<String> duplicateNames = getDuplicateSubmissionFolderNames(options);
-        if (duplicateNames.size() > 0) {
+        if (!duplicateNames.isEmpty()) {
             throw new RootDirectoryException(String.format("Duplicate root directory names found: %s", String.join(", ", duplicateNames)));
         }
     }

core/src/test/java/de/jplag/RootFolderTest.java

@@ -1,7 +1,6 @@
 package de.jplag;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.*;
 
 import java.io.File;
 import java.util.List;
@@ -84,4 +83,20 @@ void testBasecodeInOldDirectory() throws ExitException {
         int numberOfExpectedComparison = 1 + ROOT_COUNT_2 * (ROOT_COUNT_1 - 1); // -1 for basecode
         assertEquals(numberOfExpectedComparison, result.getAllComparisons().size());
     }
+
+    @Test
+    @DisplayName("test single new submission")
+    void testSingleNewSubmission() throws ExitException {
+        List<String> newSubmissionsNames = List.of("2023");
+        List<String> oldSubmissionsNames = List.of("2022", "2021", "2020");
+        List<String> newSubmissions = newSubmissionsNames.stream().map(it -> getBasePath("SingleNewSubmission" + File.separator + it)).toList();
+        List<String> oldSubmissions = oldSubmissionsNames.stream().map(it -> getBasePath("SingleNewSubmission" + File.separator + it)).toList();
+
+        JPlagResult result = runJPlag(newSubmissions, oldSubmissions, it -> it);
+
+        long numberOfNewSubmissions = result.getSubmissions().getSubmissions().stream().filter(Submission::isNew).count();
+        long numberOfOldSubmissions = result.getSubmissions().getSubmissions().stream().filter(it -> !it.isNew()).count();
+        assertEquals(1, numberOfNewSubmissions);
+        assertEquals(3, numberOfOldSubmissions);
+    }
 }

core/src/test/resources/de/jplag/samples/SingleNewSubmission/2020/QSort2020.java

@@ -0,0 +1,40 @@
+import java.util.ArrayList;
+import java.util.List;
+
+public class QSort2020 {
+    public String[] qsort(String[] array) {
+        if (array == null || array.length == 0) {
+            return array;
+        }
+        List<String> sortedList = quickSort(List.of(array));
+        return sortedList.toArray(new String[0]);
+    }
+
+    private List<String> quickSort(List<String> list) {
+        if (list.size() <= 1) {
+            return list;
+        }
+
+        String pivot = list.get(list.size() / 2);
+        List<String> less = new ArrayList<>();
+        List<String> equal = new ArrayList<>();
+        List<String> greater = new ArrayList<>();
+
+        for (String s : list) {
+            int comparison = s.compareTo(pivot);
+            if (comparison < 0) {
+                less.add(s);
+            } else if (comparison > 0) {
+                greater.add(s);
+            } else {
+                equal.add(s);
+            }
+        }
+
+        List<String> sorted = new ArrayList<>();
+        sorted.addAll(quickSort(less));
+        sorted.addAll(equal);
+        sorted.addAll(quickSort(greater));
+        return sorted;
+    }
+}

core/src/test/resources/de/jplag/samples/SingleNewSubmission/2021/QSort2021.java

@@ -0,0 +1,44 @@
+import java.util.Stack;
+
+public class QSort2021 {
+    public String[] qsort(String[] array) {
+        if (array == null || array.length == 0) {
+            return array;
+        }
+
+        Stack<int[]> stack = new Stack<>();
+        stack.push(new int[] { 0, array.length - 1 });
+
+        while (!stack.isEmpty()) {
+            int[] range = stack.pop();
+            int low = range[0], high = range[1];
+
+            if (low < high) {
+                int pivotIndex = partition(array, low, high);
+                stack.push(new int[] { low, pivotIndex - 1 });
+                stack.push(new int[] { pivotIndex + 1, high });
+            }
+        }
+
+        return array;
+    }
+
+    private int partition(String[] array, int low, int high) {
+        String pivot = array[high];
+        int i = low - 1;
+        for (int j = low; j < high; j++) {
+            if (array[j].compareTo(pivot) <= 0) {
+                i++;
+                swap(array, i, j);
+            }
+        }
+        swap(array, i + 1, high);
+        return i + 1;
+    }
+
+    private void swap(String[] array, int i, int j) {
+        String temp = array[i];
+        array[i] = array[j];
+        array[j] = temp;
+    }
+}

core/src/test/resources/de/jplag/samples/SingleNewSubmission/2022/QSort2022.java

@@ -0,0 +1,41 @@
+public class QSort2022 {
+    public String[] qsort(String[] array) {
+        if (array == null || array.length == 0) {
+            return array;
+        }
+        quickSort(array, 0, array.length - 1);
+        return array;
+    }
+
+    private void quickSort(String[] array, int low, int high) {
+        while (low < high) {
+            int pivotIndex = partition(array, low, high);
+            if (pivotIndex - low < high - pivotIndex) {
+                quickSort(array, low, pivotIndex - 1);
+                low = pivotIndex + 1;
+            } else {
+                quickSort(array, pivotIndex + 1, high);
+                high = pivotIndex - 1;
+            }
+        }
+    }
+
+    private int partition(String[] array, int low, int high) {
+        String pivot = array[high];
+        int i = low - 1;
+        for (int j = low; j < high; j++) {
+            if (array[j].compareTo(pivot) <= 0) {
+                i++;
+                swap(array, i, j);
+            }
+        }
+        swap(array, i + 1, high);
+        return i + 1;
+    }
+
+    private void swap(String[] array, int i, int j) {
+        String temp = array[i];
+        array[i] = array[j];
+        array[j] = temp;
+    }
+}

core/src/test/resources/de/jplag/samples/SingleNewSubmission/2023/QSort2023.java

@@ -0,0 +1,37 @@
+public class QSort2023 {
+    public String[] qsort(String[] array) {
+        if (array == null || array.length == 0) {
+            return array;
+        }
+        quickSort(array, 0, array.length - 1);
+        return array;
+    }
+
+    private void quickSort(String[] array, int low, int high) {
+        if (low < high) {
+            int pivotIndex = partition(array, low, high);
+            quickSort(array, low, pivotIndex - 1);
+            quickSort(array, pivotIndex + 1, high);
+        }
+    }
+
+    private int partition(String[] array, int low, int high) {
+        String pivot = array[high];
+        int i = low - 1;
+        for (int j = low; j < high; j++) {
+            if (array[j].compareTo(pivot) <= 0) {
+                i++;
+                swap(array, i, j);
+            }
+        }
+        swap(array, i + 1, high);
+        return i + 1;
+    }
+
+    private void swap(String[] array, int i, int j) {
+        String temp = array[i];
+        array[i] = array[j];
+        array[j] = temp;
+    }
+
+}

report-viewer/tests/e2e/OpenComparisonTest.spec.ts

@@ -8,6 +8,8 @@ interface DataSet {
   secondSubmissionName: string
 }
 
+const regexPathSeparator = '(\\\\|\\/)';
+
 const testSets: DataSet[] = [
   {
     datasetName: 'fileSingleRoot-report.zip',
@@ -39,6 +41,11 @@ const testSets: DataSet[] = [
     firstSubmissionName: 'f0\\\\|/0',
     secondSubmissionName: 'f1\\\\|/1'
   },
+  {
+    datasetName: 'singleNewSubmission-report.zip',
+    firstSubmissionName: `2023${regexPathSeparator}QSort2023.java`,
+    secondSubmissionName: `2022${regexPathSeparator}QSort2022.java`,
+  },
   {
     datasetName: 'python-report.zip',
     firstSubmissionName: '01.py',