Add parallel comparison test cases based on the existing tests.

jplag/src/test/java/jplag/NormalComparisonTest.java

@@ -46,7 +46,7 @@ public class NormalComparisonTest extends TestBase {
      * E is just a Hello World Java program
      */
     @Test
-    public void partialPlagiarism() throws ExitException {
+    public void testPartialPlagiarism() throws ExitException {
         JPlagResult result = runJPlagWithDefaultOptions("PartialPlagiarism");
 
         assertEquals(5, result.getNumberOfSubmissions());

jplag/src/test/java/jplag/ParallelComparisonTest.java

@@ -0,0 +1,91 @@
+package jplag;
+
+import static jplag.strategy.ComparisonMode.PARALLEL;
+import static org.junit.Assert.assertEquals;
+
+import java.util.Optional;
+
+import org.junit.Test;
+
+import jplag.strategy.ParallelComparisonStrategy;
+
+/**
+ * Currently just a copy of {@link NormalComparisonTest} but for the {@link ParallelComparisonStrategy}.
+ * @author Timur Saglam
+ */
+public class ParallelComparisonTest extends TestBase {
+
+    /**
+     * The simple duplicate contains obvious plagiarism.
+     */
+    @Test
+    public void testSimpleDuplicate() throws ExitException {
+        JPlagResult result = runJPlag("SimpleDuplicate", it -> it.setComparisonMode(PARALLEL));
+
+        assertEquals(2, result.getNumberOfSubmissions());
+        assertEquals(1, result.getComparisons().size());
+        assertEquals(1, result.getComparisons().get(0).matches.size());
+        assertEquals(1, result.getSimilarityDistribution()[6]);
+        assertEquals(62.07f, result.getComparisons().get(0).percent(), 0.1f);
+    }
+
+    /**
+     * The classes in no duplicate have nearly nothing in common.
+     */
+    @Test
+    public void testNoDuplicate() throws ExitException {
+        JPlagResult result = runJPlag("NoDuplicate", it -> it.setComparisonMode(PARALLEL));
+
+        assertEquals(3, result.getNumberOfSubmissions());
+        assertEquals(3, result.getComparisons().size());
+
+        result.getAllComparisons().forEach(comparison -> {
+            assertEquals(0f, comparison.percent(), 0.1f);
+        });
+    }
+
+    /**
+     * This case is more complex and consists out of 5 submissions with different plagiarism. A is the original code (coming
+     * from an older JPlag version) B is a partial copy of that code C is a full copy of that code D is dumb plagiarism,
+     * e.g., changed variable names, additional unneeded code, ... E is just a Hello World Java program
+     */
+    @Test
+    public void testPartialPlagiarism() throws ExitException {
+        JPlagResult result = runJPlag("PartialPlagiarism", it -> it.setComparisonMode(PARALLEL));
+
+        assertEquals(5, result.getNumberOfSubmissions());
+        assertEquals(10, result.getAllComparisons().size());
+
+        // All comparisons with E shall have no matches
+        result.getAllComparisons().stream()
+                .filter(comparison -> comparison.secondSubmission.name.equals("E") || comparison.firstSubmission.name.equals("E"))
+                .forEach(comparison -> assertEquals(0f, comparison.percent(), 0.1f));
+
+        // Hard coded assertions on selected comparisons
+        assertEquals(24.6f, getSelectedPercent(result, "A", "B"), 0.1f);
+        assertEquals(99.7f, getSelectedPercent(result, "A", "C"), 0.1f);
+        assertEquals(77.9f, getSelectedPercent(result, "A", "D"), 0.1f);
+        assertEquals(24.6f, getSelectedPercent(result, "B", "C"), 0.1f);
+        assertEquals(28.3f, getSelectedPercent(result, "B", "D"), 0.1f);
+        assertEquals(77.9f, getSelectedPercent(result, "C", "D"), 0.1f);
+
+        // More detailed assertions for the plagiarism in A-D
+        var biggestMatch = getSelectedComparison(result, "A", "D");
+        assertEquals(96.4f, biggestMatch.get().percentMaxAB(), 0.1f);
+        assertEquals(65.3f, biggestMatch.get().percentMinAB(), 0.1f);
+        assertEquals(12, biggestMatch.get().matches.size());
+
+    }
+
+    // TODO SH: Methods like this should be moved to the API and also should accept wildcards
+    private float getSelectedPercent(JPlagResult result, String nameA, String nameB) {
+        return getSelectedComparison(result, nameA, nameB).map(JPlagComparison::percent).orElse(-1f);
+    }
+
+    private Optional<JPlagComparison> getSelectedComparison(JPlagResult result, String nameA, String nameB) {
+        return result.getAllComparisons().stream()
+                .filter(comparison -> comparison.firstSubmission.name.equals(nameA) && comparison.secondSubmission.name.equals(nameB)
+                        || comparison.firstSubmission.name.equals(nameB) && comparison.secondSubmission.name.equals(nameA))
+                .findFirst();
+    }
+}

jplag/src/test/java/jplag/TestBase.java

@@ -15,14 +15,14 @@ public abstract class TestBase {
 
     protected JPlagResult runJPlagWithExclusionFile(String testSampleName, String exclusionFileName) throws ExitException {
         String blackList = String.format(getBasePath() + "/%s/%s", testSampleName, exclusionFileName);
-        return runJPlagWithOptions(testSampleName, options -> options.setExclusionFileName(blackList));
+        return runJPlag(testSampleName, options -> options.setExclusionFileName(blackList));
     }
 
     protected JPlagResult runJPlagWithDefaultOptions(String testSampleName) throws ExitException {
-        return runJPlagWithOptions(testSampleName, options -> {});
+        return runJPlag(testSampleName, options -> {});
     }
 
-    protected JPlagResult runJPlagWithOptions(String testSampleName, Consumer<JPlagOptions> customization) throws ExitException {
+    protected JPlagResult runJPlag(String testSampleName, Consumer<JPlagOptions> customization) throws ExitException {
         JPlagOptions options = new JPlagOptions(String.format(getBasePath() + "/%s", testSampleName), LanguageOption.JAVA_1_9);
         options.setDebugParser(true);
         customization.accept(options);

jplag/src/test/java/jplag/VolumeTest.java

@@ -1,6 +1,7 @@
 package jplag;
 
-import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
 
 import java.io.File;
 import java.io.IOException;
@@ -9,10 +10,8 @@ import java.nio.file.Path;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.stream.Collectors;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import org.junit.Test;
 
 /**
  * These tests are not intended to be used automatically but rather manually prior to releases.
@@ -42,7 +41,7 @@ public class VolumeTest extends TestBase {
             return;
         }
 
-        var results = runJPlagWithOptions("data",
+        var results = runJPlag("data",
                 jPlagOptions -> jPlagOptions.setMaxNumberOfMatches(-1));
 
         var csv = readCSVResults(String.format("%s/%s", this.getBasePath(), "matches_avg.csv"));