Explorar el Código

Merge pull request #674 from jplag/submission-directories-arguments

Make directory arguments in JPlagOptions type-safe
Timur Sağlam hace 4 años
padre
commit
8e3b4d0325

+ 1 - 1
README.md

@@ -72,7 +72,7 @@ named arguments:
   -bc BC           Path of the directory containing the base code (common framework used in all submissions)
   -v               {quiet,long} Verbosity of the logging (default: quiet)
   -d               Debug parser. Non-parsable files will be stored (default: false)
-  -S S             Look in directories <root-dir>/*/<dir> for programs
+  -s S             Look in directories <root-dir>/*/<dir> for programs
   -p P             comma-separated list of all filename suffixes that are included
   -x X             All files named in this file will be ignored in the comparison (line-separated list)
   -t T             Tunes the comparison sensitivity by adjusting the minimum token  required  to be counted as a matching section. A smaller

+ 20 - 7
cli/src/main/java/de/jplag/CLI.java

@@ -29,11 +29,13 @@ import static de.jplag.CommandLineArgument.SUBDIRECTORY;
 import static de.jplag.CommandLineArgument.SUFFIXES;
 import static de.jplag.CommandLineArgument.VERBOSITY;
 
+import java.io.File;
 import java.security.SecureRandom;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Random;
+import java.util.stream.Collectors;
 
 import net.sourceforge.argparse4j.ArgumentParsers;
 import net.sourceforge.argparse4j.inf.ArgumentParser;
@@ -142,19 +144,30 @@ public final class CLI {
         }
 
         // Collect the root directories.
-        List<String> submissionDirectories = new ArrayList<>();
-        List<String> oldSubmissionDirectories = new ArrayList<>();
-        addAllMultiValueArgument(ROOT_DIRECTORY.getListFrom(namespace), submissionDirectories);
-        addAllMultiValueArgument(NEW_DIRECTORY.getListFrom(namespace), submissionDirectories);
-        addAllMultiValueArgument(OLD_DIRECTORY.getListFrom(namespace), oldSubmissionDirectories);
+        List<String> submissionDirectoryPaths = new ArrayList<>();
+        List<String> oldSubmissionDirectoryPaths = new ArrayList<>();
+        addAllMultiValueArgument(ROOT_DIRECTORY.getListFrom(namespace), submissionDirectoryPaths);
+        addAllMultiValueArgument(NEW_DIRECTORY.getListFrom(namespace), submissionDirectoryPaths);
+        addAllMultiValueArgument(OLD_DIRECTORY.getListFrom(namespace), oldSubmissionDirectoryPaths);
+        var submissionDirectories = submissionDirectoryPaths.stream().map(File::new).collect(Collectors.toSet());
+        var oldSubmissionDirectories = oldSubmissionDirectoryPaths.stream().map(File::new).collect(Collectors.toSet());
 
         var language = LanguageLoader.getLanguage(LANGUAGE.getFrom(namespace)).orElseThrow();
         ClusteringOptions clusteringOptions = getClusteringOptions(namespace);
 
-        return new JPlagOptions(language, MIN_TOKEN_MATCH.getFrom(namespace), submissionDirectories, oldSubmissionDirectories,
-                BASE_CODE.getFrom(namespace), SUBDIRECTORY.getFrom(namespace), Arrays.stream(fileSuffixes).toList(), EXCLUDE_FILE.getFrom(namespace),
+        JPlagOptions options = new JPlagOptions(language, MIN_TOKEN_MATCH.getFrom(namespace), submissionDirectories, oldSubmissionDirectories, null,
+                SUBDIRECTORY.getFrom(namespace), Arrays.stream(fileSuffixes).toList(), EXCLUDE_FILE.getFrom(namespace),
                 JPlagOptions.DEFAULT_SIMILARITY_METRIC, SIMILARITY_THRESHOLD.getFrom(namespace), SHOWN_COMPARISONS.getFrom(namespace),
                 clusteringOptions, Verbosity.fromOption(VERBOSITY.getFrom(namespace)), DEBUG.getFrom(namespace));
+
+        String baseCodePath = BASE_CODE.getFrom(namespace);
+        File baseCodeDirectory = baseCodePath == null ? null : new File(baseCodePath);
+        if (baseCodeDirectory == null || baseCodeDirectory.exists()) {
+            return options.withBaseCodeSubmissionDirectory(baseCodeDirectory);
+        } else {
+            logger.warn("Using legacy partial base code API. Please migrate to new full path base code API.");
+            return options.withBaseCodeSubmissionName(baseCodePath);
+        }
     }
 
     private static ClusteringOptions getClusteringOptions(Namespace namespace) {

+ 1 - 1
cli/src/main/java/de/jplag/CommandLineArgument.java

@@ -42,7 +42,7 @@ public enum CommandLineArgument {
                                                                                                                            // integrating a
     // real logging library
     DEBUG(new Builder("-d", Boolean.class).argumentGroup(ADVANCED_GROUP)),
-    SUBDIRECTORY(new Builder("-S", String.class).argumentGroup(ADVANCED_GROUP)),
+    SUBDIRECTORY(new Builder("-s", String.class).argumentGroup(ADVANCED_GROUP)),
     SUFFIXES(new Builder("-p", String.class).argumentGroup(ADVANCED_GROUP)),
     EXCLUDE_FILE(new Builder("-x", String.class).argumentGroup(ADVANCED_GROUP)),
     MIN_TOKEN_MATCH("-t", Integer.class),

+ 2 - 2
cli/src/test/java/de/jplag/cli/BaseCodeOptionTest.java

@@ -14,13 +14,13 @@ class BaseCodeOptionTest extends CommandLineInterfaceTest {
     @Test
     void testDefaultValue() {
         buildOptionsFromCLI(CURRENT_DIRECTORY);
-        assertNull(options.baseCodeSubmissionName());
+        assertNull(options.baseCodeSubmissionDirectory());
     }
 
     @Test
     void testCustomName() {
         String argument = buildArgument(CommandLineArgument.BASE_CODE, NAME);
         buildOptionsFromCLI(argument, CURRENT_DIRECTORY);
-        assertEquals(NAME, options.baseCodeSubmissionName());
+        assertEquals(NAME, options.baseCodeSubmissionDirectory().getName());
     }
 }

+ 18 - 98
core/src/main/java/de/jplag/SubmissionSetBuilder.java

@@ -70,37 +70,36 @@ public class SubmissionSetBuilder {
             processRootDirectoryEntries(oldDirectory, multipleRoots, foundSubmissions, false);
         }
 
-        Optional<Submission> baseCodeSubmission = loadBaseCode(submissionDirectories, oldSubmissionDirectories, foundSubmissions);
+        Optional<Submission> baseCodeSubmission = loadBaseCode();
+        baseCodeSubmission.ifPresent(baseSubmission -> foundSubmissions.remove(baseSubmission.getRoot()));
 
         // Merge everything in a submission set.
         List<Submission> submissions = new ArrayList<>(foundSubmissions.values());
-
         return new SubmissionSet(submissions, baseCodeSubmission.orElse(null), options);
     }
 
     /**
      * Verify that the given root directories exist and have no duplicate entries.
      */
-    private Set<File> verifyRootDirectories(List<String> rootDirectoryNames, boolean areNewDirectories) throws ExitException {
+    private Set<File> verifyRootDirectories(Set<File> rootDirectoryNames, boolean areNewDirectories) throws ExitException {
         if (areNewDirectories && rootDirectoryNames.isEmpty()) {
             throw new RootDirectoryException("No root directories specified with submissions to check for plagiarism!");
         }
 
         Set<File> canonicalRootDirectories = new HashSet<>(rootDirectoryNames.size());
-        for (String rootDirectoryName : rootDirectoryNames) {
-            File rootDirectory = new File(rootDirectoryName);
-
+        for (final File rootDirectory : rootDirectoryNames) {
             if (!rootDirectory.exists()) {
-                throw new RootDirectoryException(String.format("Root directory \"%s\" does not exist!", rootDirectoryName));
+                throw new RootDirectoryException(String.format("Root directory \"%s\" does not exist!", rootDirectory));
             }
             if (!rootDirectory.isDirectory()) {
-                throw new RootDirectoryException(String.format("Root directory \"%s\" is not a directory!", rootDirectoryName));
+                throw new RootDirectoryException(String.format("Root directory \"%s\" is not a directory!", rootDirectory));
             }
 
-            rootDirectory = makeCanonical(rootDirectory, it -> new RootDirectoryException("Cannot read root directory: " + rootDirectoryName, it));
-            if (!canonicalRootDirectories.add(rootDirectory)) {
+            File canonicalRootDirectory = makeCanonical(rootDirectory,
+                    it -> new RootDirectoryException("Cannot read root directory: " + rootDirectory, it));
+            if (!canonicalRootDirectories.add(canonicalRootDirectory)) {
                 // Root directory was already added, report a warning.
-                logger.warn("Root directory \"{}\" was specified more than once, duplicates will be ignored.", rootDirectoryName);
+                logger.warn("Root directory \"{}\" was specified more than once, duplicates will be ignored.", canonicalRootDirectory);
             }
         }
         return canonicalRootDirectories;
@@ -127,102 +126,23 @@ public class SubmissionSetBuilder {
         }
     }
 
-    private Optional<Submission> loadBaseCode(Set<File> submissionDirectories, Set<File> oldSubmissionDirectories,
-            Map<File, Submission> foundSubmissions) throws ExitException {
+    private Optional<Submission> loadBaseCode() throws ExitException {
         if (!options.hasBaseCode()) {
             return Optional.empty();
         }
 
-        String baseCodeName = Optional.ofNullable(options.baseCodeSubmissionName()).orElseThrow();
-        Submission baseCode = loadBaseCodeAsPath(baseCodeName);
-        if (baseCode == null) {
-            int numberOfRootDirectories = submissionDirectories.size() + oldSubmissionDirectories.size();
-            if (numberOfRootDirectories > 1) {
-                throw new BasecodeException("The base code submission needs to be specified by path instead of by name!");
-            }
-
-            // There is one root directory, and the submissionDirectories variable has been checked to be non-empty.
-            // That set thus contains the one and only root directory.
-            File rootDirectory = submissionDirectories.iterator().next();
-
-            // Single root-directory, try the legacy way of specifying basecode.
-            baseCode = loadBaseCodeViaName(baseCodeName, rootDirectory, foundSubmissions);
+        File baseCodeSubmissionDirectory = options.baseCodeSubmissionDirectory();
+        if (!baseCodeSubmissionDirectory.exists()) {
+            throw new BasecodeException("Basecode directory \"%s\" does not exist".formatted(baseCodeSubmissionDirectory));
         }
-
-        if (baseCode != null) {
-            logger.info("Basecode directory \"{}\" will be used.", baseCode.getName());
-
-            // Basecode may also be registered as a user submission. If so, remove the latter.
-            Submission removed = foundSubmissions.remove(baseCode.getRoot());
-            if (removed != null) {
-                logger.info("Submission \"{}\" is the specified basecode, it will be skipped during comparison.", removed.getName());
-            }
-        }
-        return Optional.ofNullable(baseCode);
-    }
-
-    /**
-     * Try to load the basecode under the assumption of being a path.
-     * @return Base code submission if the option value can be interpreted as global path, else {@code null}.
-     * @throws ExitException when the option value is a path with errors.
-     */
-    private Submission loadBaseCodeAsPath(String baseCodeName) throws ExitException {
-        File basecodeSubmission = new File(baseCodeName);
-        if (!basecodeSubmission.exists()) {
-            return null;
-        }
-
-        String errorMessage = isExcludedEntry(basecodeSubmission);
+        String errorMessage = isExcludedEntry(baseCodeSubmissionDirectory);
         if (errorMessage != null) {
             throw new BasecodeException(errorMessage); // Stating an excluded path as basecode isn't very useful.
         }
 
-        try {
-            // Use an unlikely short name for the base code. If all is well, this name should not appear
-            // in the output since basecode matches are removed from it
-            return processSubmission(basecodeSubmission.getName(), basecodeSubmission, false);
-        } catch (SubmissionException exception) {
-            throw new BasecodeException(exception.getMessage(), exception); // Change thrown exception to basecode exception.
-        }
-    }
-
-    /**
-     * Try to load the basecode by looking up the basecode name in the root directory.
-     * @return the base code submission if a fitting subdirectory was found, else {@code null}.
-     * @throws ExitException when the option value is a sub-directory with errors.
-     */
-    private Submission loadBaseCodeViaName(String baseCodeName, File rootDirectory, Map<File, Submission> foundSubmissions) throws ExitException {
-        // Is the option value a single name after trimming spurious separators?
-        String name = baseCodeName;
-        while (name.startsWith(File.separator)) {
-            name = name.substring(1);
-        }
-        while (name.endsWith(File.separator)) {
-            name = name.substring(0, name.length() - 1);
-        }
-
-        // If it is not a name of a single sub-directory, bail out.
-        if (name.isEmpty() || name.contains(File.separator)) {
-            return null;
-        }
-
-        if (name.contains(".")) {
-            throw new BasecodeException("The basecode directory name \"" + name + "\" cannot contain dots!");
-        }
-
-        // Grab the basecode submission from the regular submissions.
-        File basecodePath = new File(rootDirectory, baseCodeName);
-
-        Submission baseCode = foundSubmissions
-                .get(makeCanonical(basecodePath, it -> new BasecodeException("Cannot compute canonical file path: " + basecodePath, it)));
-        if (baseCode == null) {
-            // No base code found at all, report an error.
-            throw new BasecodeException(String.format("Basecode path \"%s\" relative to the working directory could not be found.", baseCodeName));
-        } else {
-            // Found a base code as a submission, warn about legacy usage.
-            logger.warn("Legacy use of the base code option found, please specify the basecode by path instead of by name!");
-        }
-        return baseCode;
+        Submission baseCodeSubmission = processSubmission(baseCodeSubmissionDirectory.getName(), baseCodeSubmissionDirectory, false);
+        logger.info("Basecode directory \"{}\" will be used.", baseCodeSubmission.getName());
+        return Optional.ofNullable(baseCodeSubmission);
     }
 
     /**

+ 123 - 44
core/src/main/java/de/jplag/options/JPlagOptions.java

@@ -3,6 +3,7 @@ package de.jplag.options;
 import static de.jplag.options.Verbosity.LONG;
 
 import java.io.BufferedReader;
+import java.io.File;
 import java.io.FileReader;
 import java.io.IOException;
 import java.nio.charset.Charset;
@@ -20,6 +21,7 @@ import org.slf4j.LoggerFactory;
 import de.jplag.JPlag;
 import de.jplag.Language;
 import de.jplag.clustering.ClusteringOptions;
+import de.jplag.exceptions.BasecodeException;
 
 /**
  * This record defines the options to configure {@link JPlag}.
@@ -28,7 +30,7 @@ import de.jplag.clustering.ClusteringOptions;
  * matching section. A smaller {@code <n>} increases the sensitivity but might lead to more false-positives.
  * @param submissionDirectories Directories with new submissions. These must be checked for plagiarism.
  * @param oldSubmissionDirectories Directories with old submissions to check against.
- * @param baseCodeSubmissionName Path name of the directory containing the base code.
+ * @param baseCodeSubmissionDirectory Directory containing the base code.
  * @param subdirectoryName Example: If the subdirectoryName is 'src', only the code inside submissionDir/src of each
  * submission will be used for comparison.
  * @param fileSuffixes List of file suffixes that should be included.
@@ -45,8 +47,8 @@ import de.jplag.clustering.ClusteringOptions;
  * @param verbosity Level of output verbosity.
  * @param debugParser If true, submissions that cannot be parsed will be stored in a separate directory.
  */
-public record JPlagOptions(Language language, Integer minimumTokenMatch, List<String> submissionDirectories, List<String> oldSubmissionDirectories,
-        String baseCodeSubmissionName, String subdirectoryName, List<String> fileSuffixes, String exclusionFileName,
+public record JPlagOptions(Language language, Integer minimumTokenMatch, Set<File> submissionDirectories, Set<File> oldSubmissionDirectories,
+        File baseCodeSubmissionDirectory, String subdirectoryName, List<String> fileSuffixes, String exclusionFileName,
         SimilarityMetric similarityMetric, double similarityThreshold, int maximumNumberOfComparisons, ClusteringOptions clusteringOptions,
         Verbosity verbosity, boolean debugParser) {
 
@@ -58,13 +60,13 @@ public record JPlagOptions(Language language, Integer minimumTokenMatch, List<St
 
     private static final Logger logger = LoggerFactory.getLogger(JPlag.class);
 
-    public JPlagOptions(Language language, List<String> submissionDirectories, List<String> oldSubmissionDirectories) {
+    public JPlagOptions(Language language, Set<File> submissionDirectories, Set<File> oldSubmissionDirectories) {
         this(language, null, submissionDirectories, oldSubmissionDirectories, null, null, null, null, DEFAULT_SIMILARITY_METRIC,
                 DEFAULT_SIMILARITY_THRESHOLD, DEFAULT_SHOWN_COMPARISONS, new ClusteringOptions(), null, false);
     }
 
-    public JPlagOptions(Language language, Integer minimumTokenMatch, List<String> submissionDirectories, List<String> oldSubmissionDirectories,
-            String baseCodeSubmissionName, String subdirectoryName, List<String> fileSuffixes, String exclusionFileName,
+    public JPlagOptions(Language language, Integer minimumTokenMatch, Set<File> submissionDirectories, Set<File> oldSubmissionDirectories,
+            File baseCodeSubmissionDirectory, String subdirectoryName, List<String> fileSuffixes, String exclusionFileName,
             SimilarityMetric similarityMetric, double similarityThreshold, int maximumNumberOfComparisons, ClusteringOptions clusteringOptions,
             Verbosity verbosity, boolean debugParser) {
         this.language = language;
@@ -75,100 +77,100 @@ public record JPlagOptions(Language language, Integer minimumTokenMatch, List<St
         this.similarityMetric = similarityMetric;
         this.minimumTokenMatch = normalizeMinimumTokenMatch(minimumTokenMatch);
         this.exclusionFileName = exclusionFileName;
-        this.submissionDirectories = submissionDirectories == null ? null : Collections.unmodifiableList(submissionDirectories);
-        this.oldSubmissionDirectories = oldSubmissionDirectories == null ? null : Collections.unmodifiableList(oldSubmissionDirectories);
-        this.baseCodeSubmissionName = (baseCodeSubmissionName == null || baseCodeSubmissionName.isBlank()) ? null : baseCodeSubmissionName;
+        this.submissionDirectories = submissionDirectories == null ? null : Collections.unmodifiableSet(submissionDirectories);
+        this.oldSubmissionDirectories = oldSubmissionDirectories == null ? null : Collections.unmodifiableSet(oldSubmissionDirectories);
+        this.baseCodeSubmissionDirectory = baseCodeSubmissionDirectory;
         this.subdirectoryName = subdirectoryName;
         this.verbosity = verbosity;
         this.clusteringOptions = clusteringOptions;
     }
 
     public JPlagOptions withLanguageOption(Language language) {
-        return new JPlagOptions(language, minimumTokenMatch, submissionDirectories, oldSubmissionDirectories, baseCodeSubmissionName,
+        return new JPlagOptions(language, minimumTokenMatch, submissionDirectories, oldSubmissionDirectories, baseCodeSubmissionDirectory,
                 subdirectoryName, fileSuffixes, exclusionFileName, similarityMetric, similarityThreshold, maximumNumberOfComparisons,
                 clusteringOptions, verbosity, debugParser);
     }
 
     public JPlagOptions withDebugParser(boolean debugParser) {
-        return new JPlagOptions(language, minimumTokenMatch, submissionDirectories, oldSubmissionDirectories, baseCodeSubmissionName,
+        return new JPlagOptions(language, minimumTokenMatch, submissionDirectories, oldSubmissionDirectories, baseCodeSubmissionDirectory,
                 subdirectoryName, fileSuffixes, exclusionFileName, similarityMetric, similarityThreshold, maximumNumberOfComparisons,
                 clusteringOptions, verbosity, debugParser);
     }
 
     public JPlagOptions withFileSuffixes(List<String> fileSuffixes) {
-        return new JPlagOptions(language, minimumTokenMatch, submissionDirectories, oldSubmissionDirectories, baseCodeSubmissionName,
+        return new JPlagOptions(language, minimumTokenMatch, submissionDirectories, oldSubmissionDirectories, baseCodeSubmissionDirectory,
                 subdirectoryName, fileSuffixes, exclusionFileName, similarityMetric, similarityThreshold, maximumNumberOfComparisons,
                 clusteringOptions, verbosity, debugParser);
     }
 
     public JPlagOptions withSimilarityThreshold(double similarityThreshold) {
-        return new JPlagOptions(language, minimumTokenMatch, submissionDirectories, oldSubmissionDirectories, baseCodeSubmissionName,
+        return new JPlagOptions(language, minimumTokenMatch, submissionDirectories, oldSubmissionDirectories, baseCodeSubmissionDirectory,
                 subdirectoryName, fileSuffixes, exclusionFileName, similarityMetric, similarityThreshold, maximumNumberOfComparisons,
                 clusteringOptions, verbosity, debugParser);
     }
 
     public JPlagOptions withMaximumNumberOfComparisons(int maximumNumberOfComparisons) {
-        return new JPlagOptions(language, minimumTokenMatch, submissionDirectories, oldSubmissionDirectories, baseCodeSubmissionName,
+        return new JPlagOptions(language, minimumTokenMatch, submissionDirectories, oldSubmissionDirectories, baseCodeSubmissionDirectory,
                 subdirectoryName, fileSuffixes, exclusionFileName, similarityMetric, similarityThreshold, maximumNumberOfComparisons,
                 clusteringOptions, verbosity, debugParser);
     }
 
     public JPlagOptions withSimilarityMetric(SimilarityMetric similarityMetric) {
-        return new JPlagOptions(language, minimumTokenMatch, submissionDirectories, oldSubmissionDirectories, baseCodeSubmissionName,
+        return new JPlagOptions(language, minimumTokenMatch, submissionDirectories, oldSubmissionDirectories, baseCodeSubmissionDirectory,
                 subdirectoryName, fileSuffixes, exclusionFileName, similarityMetric, similarityThreshold, maximumNumberOfComparisons,
                 clusteringOptions, verbosity, debugParser);
     }
 
     public JPlagOptions withMinimumTokenMatch(Integer minimumTokenMatch) {
-        return new JPlagOptions(language, minimumTokenMatch, submissionDirectories, oldSubmissionDirectories, baseCodeSubmissionName,
+        return new JPlagOptions(language, minimumTokenMatch, submissionDirectories, oldSubmissionDirectories, baseCodeSubmissionDirectory,
                 subdirectoryName, fileSuffixes, exclusionFileName, similarityMetric, similarityThreshold, maximumNumberOfComparisons,
                 clusteringOptions, verbosity, debugParser);
     }
 
     public JPlagOptions withExclusionFileName(String exclusionFileName) {
-        return new JPlagOptions(language, minimumTokenMatch, submissionDirectories, oldSubmissionDirectories, baseCodeSubmissionName,
+        return new JPlagOptions(language, minimumTokenMatch, submissionDirectories, oldSubmissionDirectories, baseCodeSubmissionDirectory,
                 subdirectoryName, fileSuffixes, exclusionFileName, similarityMetric, similarityThreshold, maximumNumberOfComparisons,
                 clusteringOptions, verbosity, debugParser);
     }
 
-    public JPlagOptions withSubmissionDirectories(List<String> submissionDirectories) {
-        return new JPlagOptions(language, minimumTokenMatch, submissionDirectories, oldSubmissionDirectories, baseCodeSubmissionName,
+    public JPlagOptions withSubmissionDirectories(Set<File> submissionDirectories) {
+        return new JPlagOptions(language, minimumTokenMatch, submissionDirectories, oldSubmissionDirectories, baseCodeSubmissionDirectory,
                 subdirectoryName, fileSuffixes, exclusionFileName, similarityMetric, similarityThreshold, maximumNumberOfComparisons,
                 clusteringOptions, verbosity, debugParser);
     }
 
-    public JPlagOptions withOldSubmissionDirectories(List<String> oldSubmissionDirectories) {
-        return new JPlagOptions(language, minimumTokenMatch, submissionDirectories, oldSubmissionDirectories, baseCodeSubmissionName,
+    public JPlagOptions withOldSubmissionDirectories(Set<File> oldSubmissionDirectories) {
+        return new JPlagOptions(language, minimumTokenMatch, submissionDirectories, oldSubmissionDirectories, baseCodeSubmissionDirectory,
                 subdirectoryName, fileSuffixes, exclusionFileName, similarityMetric, similarityThreshold, maximumNumberOfComparisons,
                 clusteringOptions, verbosity, debugParser);
     }
 
-    public JPlagOptions withBaseCodeSubmissionName(String baseCodeSubmissionName) {
-        return new JPlagOptions(language, minimumTokenMatch, submissionDirectories, oldSubmissionDirectories, baseCodeSubmissionName,
+    public JPlagOptions withBaseCodeSubmissionDirectory(File baseCodeSubmissionDirectory) {
+        return new JPlagOptions(language, minimumTokenMatch, submissionDirectories, oldSubmissionDirectories, baseCodeSubmissionDirectory,
                 subdirectoryName, fileSuffixes, exclusionFileName, similarityMetric, similarityThreshold, maximumNumberOfComparisons,
                 clusteringOptions, verbosity, debugParser);
     }
 
     public JPlagOptions withSubdirectoryName(String subdirectoryName) {
-        return new JPlagOptions(language, minimumTokenMatch, submissionDirectories, oldSubmissionDirectories, baseCodeSubmissionName,
+        return new JPlagOptions(language, minimumTokenMatch, submissionDirectories, oldSubmissionDirectories, baseCodeSubmissionDirectory,
                 subdirectoryName, fileSuffixes, exclusionFileName, similarityMetric, similarityThreshold, maximumNumberOfComparisons,
                 clusteringOptions, verbosity, debugParser);
     }
 
     public JPlagOptions withVerbosity(Verbosity verbosity) {
-        return new JPlagOptions(language, minimumTokenMatch, submissionDirectories, oldSubmissionDirectories, baseCodeSubmissionName,
+        return new JPlagOptions(language, minimumTokenMatch, submissionDirectories, oldSubmissionDirectories, baseCodeSubmissionDirectory,
                 subdirectoryName, fileSuffixes, exclusionFileName, similarityMetric, similarityThreshold, maximumNumberOfComparisons,
                 clusteringOptions, verbosity, debugParser);
     }
 
     public JPlagOptions withClusteringOptions(ClusteringOptions clusteringOptions) {
-        return new JPlagOptions(language, minimumTokenMatch, submissionDirectories, oldSubmissionDirectories, baseCodeSubmissionName,
+        return new JPlagOptions(language, minimumTokenMatch, submissionDirectories, oldSubmissionDirectories, baseCodeSubmissionDirectory,
                 subdirectoryName, fileSuffixes, exclusionFileName, similarityMetric, similarityThreshold, maximumNumberOfComparisons,
                 clusteringOptions, verbosity, debugParser);
     }
 
     public boolean hasBaseCode() {
-        return baseCodeSubmissionName != null;
+        return baseCodeSubmissionDirectory != null;
     }
 
     public Set<String> excludedFiles() {
@@ -183,23 +185,6 @@ public record JPlagOptions(Language language, Integer minimumTokenMatch, List<St
         return fileSuffixes == null ? null : Collections.unmodifiableList(fileSuffixes);
     }
 
-    /**
-     * Path name of the directory containing the base code.<br>
-     * For backwards compatibility it may also be a directory name inside the root directory. Condition for the latter is
-     * <ul>
-     * <li>Specified path does not exist.</li>
-     * <li>Name has not have a separator character after trimming them from both ends (leaving at least a one-character
-     * name).</li>
-     * <li>A submission with the specified name exists in the root directory.</li>
-     * </ul>
-     * It's an error if a string has been provided, but it is neither an existing path nor does it fulfill all the
-     * conditions of the compatibility fallback listed above.
-     */
-    @Override
-    public String baseCodeSubmissionName() {
-        return baseCodeSubmissionName;
-    }
-
     @Override
     public Integer minimumTokenMatch() {
         var language = language();
@@ -240,4 +225,98 @@ public record JPlagOptions(Language language, Integer minimumTokenMatch, List<St
     private Integer normalizeMinimumTokenMatch(Integer minimumTokenMatch) {
         return (minimumTokenMatch != null && minimumTokenMatch < 1) ? Integer.valueOf(1) : minimumTokenMatch;
     }
+
+    /**
+     * Creates new options to configure {@link JPlag}.
+     * @param language Language to use when parsing the submissions.
+     * @param minimumTokenMatch Tunes the comparison sensitivity by adjusting the minimum token required to be counted as
+     * matching section. A smaller {@code <n>} increases the sensitivity but might lead to more false-positives.
+     * @param submissionDirectory Directory with new submissions. These must be checked for plagiarism. To check more than
+     * one submission directory, use the default initializer.
+     * @param oldSubmissionDirectories Directories with old submissions to check against.
+     * @param baseCodeSubmissionName Path name of the directory containing the base code.
+     * @param subdirectoryName Example: If the subdirectoryName is 'src', only the code inside submissionDir/src of each
+     * submission will be used for comparison.
+     * @param fileSuffixes List of file suffixes that should be included.
+     * @param exclusionFileName Name of the file that contains the names of files to exclude from comparison.
+     * @param similarityMetric The similarity metric determines how the minimum similarity threshold required for a
+     * comparison (of two submissions) is calculated. This affects which comparisons are stored and thus make it into the
+     * result object.
+     * @param similarityThreshold Percentage value (must be between 0 and 100). Comparisons (of submissions pairs) with a
+     * similarity below this threshold will be ignored. The default value of 0 allows all matches to be stored. This affects
+     * which comparisons are stored and thus make it into the result object. See also {@link #similarityMetric()}.
+     * @param maximumNumberOfComparisons The maximum number of comparisons that will be shown in the generated report. If
+     * set to {@link #SHOW_ALL_COMPARISONS} all comparisons will be shown.
+     * @param clusteringOptions Clustering options
+     * @param verbosity Level of output verbosity.
+     * @param debugParser If true, submissions that cannot be parsed will be stored in a separate directory.
+     * @deprecated Use the default initializer with @{{@link #baseCodeSubmissionDirectory} instead.
+     */
+    @Deprecated(since = "4.0.0", forRemoval = true)
+    public JPlagOptions(Language language, Integer minimumTokenMatch, File submissionDirectory, Set<File> oldSubmissionDirectories,
+            String baseCodeSubmissionName, String subdirectoryName, List<String> fileSuffixes, String exclusionFileName,
+            SimilarityMetric similarityMetric, double similarityThreshold, int maximumNumberOfComparisons, ClusteringOptions clusteringOptions,
+            Verbosity verbosity, boolean debugParser) throws BasecodeException {
+        this(language, minimumTokenMatch, Set.of(submissionDirectory), oldSubmissionDirectories,
+                convertLegacyBaseCodeToFile(baseCodeSubmissionName, submissionDirectory), subdirectoryName, fileSuffixes, exclusionFileName,
+                similarityMetric, similarityThreshold, maximumNumberOfComparisons, clusteringOptions, verbosity, debugParser);
+    }
+
+    /**
+     * Creates a new options instance with the provided base code submission name
+     * @param baseCodeSubmissionName the path or name of the base code submission
+     * @return a new options instance with the provided base code submission name
+     * @deprecated Use @{{@link #withBaseCodeSubmissionDirectory} instead.
+     */
+    @Deprecated(since = "4.0.0", forRemoval = true)
+    public JPlagOptions withBaseCodeSubmissionName(String baseCodeSubmissionName) {
+        File baseCodeDirectory = new File(baseCodeSubmissionName);
+        if (baseCodeDirectory.exists()) {
+            return this.withBaseCodeSubmissionDirectory(baseCodeDirectory);
+        }
+
+        if (submissionDirectories.size() != 1) {
+            throw new IllegalArgumentException("Partial path based base code requires exactly one submission directory");
+        }
+        File submissionDirectory = submissionDirectories.iterator().next();
+        try {
+            return new JPlagOptions(language, minimumTokenMatch, submissionDirectory, oldSubmissionDirectories, baseCodeSubmissionName,
+                    subdirectoryName, fileSuffixes, exclusionFileName, similarityMetric, similarityThreshold, maximumNumberOfComparisons,
+                    clusteringOptions, verbosity, debugParser);
+        } catch (BasecodeException e) {
+            throw new IllegalArgumentException(e.getMessage(), e.getCause());
+        }
+    }
+
+    /**
+     * Converts a legacy base code submission name to a directory path.
+     * @deprecated Use the default initializer with @{{@link #baseCodeSubmissionDirectory} instead.
+     */
+    @Deprecated(since = "4.0.0", forRemoval = true)
+    private static File convertLegacyBaseCodeToFile(String baseCodeSubmissionName, File submissionDirectory) throws BasecodeException {
+        if (baseCodeSubmissionName == null) {
+            return null;
+        }
+        File baseCodeAsAbsolutePath = new File(baseCodeSubmissionName);
+        if (baseCodeAsAbsolutePath.exists()) {
+            return baseCodeAsAbsolutePath;
+        } else {
+            String normalizedName = baseCodeSubmissionName;
+            while (normalizedName.startsWith(File.separator)) {
+                normalizedName = normalizedName.substring(1);
+            }
+            while (normalizedName.endsWith(File.separator)) {
+                normalizedName = normalizedName.substring(0, normalizedName.length() - 1);
+            }
+            if (normalizedName.isEmpty() || normalizedName.contains(File.separator)) {
+                throw new BasecodeException(
+                        "The basecode directory name \"" + normalizedName + "\" cannot contain dots! Please migrate to the path-based API.");
+            }
+            if (normalizedName.contains(".")) {
+                throw new BasecodeException(
+                        "The basecode directory name \"" + normalizedName + "\" cannot contain dots! Please migrate to the path-based API.");
+            }
+            return new File(submissionDirectory, baseCodeSubmissionName);
+        }
+    }
 }

+ 3 - 3
core/src/main/java/de/jplag/reporting/reportobject/ReportObjectFactory.java

@@ -134,14 +134,14 @@ public class ReportObjectFactory {
 
     private void writeOverview(JPlagResult result, String path) {
 
-        List<String> folders = new ArrayList<>();
+        List<File> folders = new ArrayList<>();
         folders.addAll(result.getOptions().submissionDirectories());
         folders.addAll(result.getOptions().oldSubmissionDirectories());
 
-        String baseCodePath = result.getOptions().hasBaseCode() ? result.getOptions().baseCodeSubmissionName() : "";
+        String baseCodePath = result.getOptions().hasBaseCode() ? result.getOptions().baseCodeSubmissionDirectory().getName() : "";
         ClusteringResultMapper clusteringResultMapper = new ClusteringResultMapper(submissionToIdFunction);
 
-        OverviewReport overviewReport = new OverviewReport(folders, // submissionFolderPath
+        OverviewReport overviewReport = new OverviewReport(folders.stream().map(File::getPath).toList(), // submissionFolderPath
                 baseCodePath, // baseCodeFolderPath
                 result.getOptions().language().getName(), // language
                 result.getOptions().fileSuffixes(), // fileExtensions

+ 45 - 16
core/src/test/java/de/jplag/BaseCodeTest.java

@@ -4,7 +4,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import java.io.File;
-import java.util.List;
+import java.util.Set;
 
 import org.junit.jupiter.api.Test;
 
@@ -16,28 +16,25 @@ public class BaseCodeTest extends TestBase {
 
     @Test
     void testBasecodeUserSubmissionComparison() throws ExitException {
-        JPlagResult result = runJPlag("basecode", it -> it.withBaseCodeSubmissionName("base"));
+        JPlagResult result = runJPlag("basecode",
+                it -> it.withBaseCodeSubmissionDirectory(new File(it.submissionDirectories().iterator().next(), "base")));
         verifyResults(result);
     }
 
     @Test
     void testTinyBasecode() {
-        assertThrows(BasecodeException.class, () -> runJPlag("TinyBasecode", it -> it.withBaseCodeSubmissionName("base")));
+        assertThrows(BasecodeException.class, () -> runJPlag("TinyBasecode",
+                it -> it.withBaseCodeSubmissionDirectory(new File(it.submissionDirectories().iterator().next(), "base"))));
     }
 
     @Test
     void testEmptySubmission() throws ExitException {
-        JPlagResult result = runJPlag("emptysubmission", it -> it.withBaseCodeSubmissionName("base"));
+        JPlagResult result = runJPlag("emptysubmission",
+                it -> it.withBaseCodeSubmissionDirectory(new File(it.submissionDirectories().iterator().next(), "base")));
         verifyResults(result);
     }
 
-    @Test
-    void testAutoTrimFileSeparators() throws ExitException {
-        JPlagResult result = runJPlag("basecode", it -> it.withBaseCodeSubmissionName(File.separator + "base" + File.separator));
-        verifyResults(result);
-    }
-
-    private void verifyResults(JPlagResult result) {
+    protected void verifyResults(JPlagResult result) {
         assertEquals(2, result.getNumberOfSubmissions());
         assertEquals(1, result.getAllComparisons().size());
         assertEquals(1, result.getAllComparisons().get(0).matches().size());
@@ -47,22 +44,54 @@ public class BaseCodeTest extends TestBase {
 
     @Test
     void testBasecodePathComparison() throws ExitException {
-        JPlagResult result = runJPlag("basecode", it -> it.withBaseCodeSubmissionName(getBasePath("basecode-base")));
+        JPlagResult result = runJPlag("basecode", it -> it.withBaseCodeSubmissionDirectory(new File(BASE_PATH, "basecode-base")));
         assertEquals(3, result.getNumberOfSubmissions()); // "basecode/base" is now a user submission.
     }
 
     @Test
     void testInvalidRoot() {
-        assertThrows(RootDirectoryException.class, () -> runJPlag("basecode", it -> it.withSubmissionDirectories(List.of("WrongRoot"))));
+        assertThrows(RootDirectoryException.class, () -> runJPlag("basecode", it -> it.withSubmissionDirectories(Set.of(new File("WrongRoot")))));
     }
 
     @Test
     void testInvalidBasecode() {
-        assertThrows(BasecodeException.class, () -> runJPlag("basecode", it -> it.withBaseCodeSubmissionName("WrongBasecode")));
+        assertThrows(BasecodeException.class, () -> runJPlag("basecode",
+                it -> it.withBaseCodeSubmissionDirectory(new File(it.submissionDirectories().iterator().next(), "WrongBasecode"))));
+    }
+
+    /**
+     * The simple duplicate contains obvious plagiarism.
+     */
+    @Test
+    void testSubdirectoryGlobalBasecode() throws ExitException {
+        String basecode = getBasePath("SubdirectoryBase");
+        JPlagResult result = runJPlag("SubdirectoryDuplicate",
+                it -> it.withSubdirectoryName("src").withBaseCodeSubmissionDirectory(new File(basecode)));
+        verifySimpleSubdirectoryDuplicate(result, 3, 3);
     }
 
+    /**
+     * The simple duplicate contains obvious plagiarism.
+     */
     @Test
-    void testBasecodeUserSubmissionWithDots() {
-        assertThrows(BasecodeException.class, () -> runJPlag("basecode", it -> it.withBaseCodeSubmissionName("base.ext")));
+    void testSubdirectoryLocalBasecode() throws ExitException {
+        JPlagResult result = runJPlag("SubdirectoryDuplicate",
+                it -> it.withSubdirectoryName("src").withBaseCodeSubmissionDirectory(new File(it.submissionDirectories().iterator().next(), "Base")));
+        verifySimpleSubdirectoryDuplicate(result, 2, 1);
+    }
+
+    protected void verifySimpleSubdirectoryDuplicate(JPlagResult result, int submissions, int comparisons) {
+        result.getSubmissions().getSubmissions().forEach(this::hasSubdirectoryRoot);
+        hasSubdirectoryRoot(result.getSubmissions().getBaseCode());
+
+        assertEquals(submissions, result.getNumberOfSubmissions());
+        assertEquals(comparisons, result.getAllComparisons().size());
+        assertEquals(1, result.getAllComparisons().get(0).matches().size());
+        assertEquals(1, result.getSimilarityDistribution()[3]);
+        assertEquals(0.6207, result.getAllComparisons().get(0).similarity(), DELTA);
+    }
+
+    private void hasSubdirectoryRoot(Submission submission) {
+        assertEquals("src", submission.getRoot().getName());
     }
 }

+ 49 - 0
core/src/test/java/de/jplag/LegacyBaseCodeParallelComparisonTest.java

@@ -0,0 +1,49 @@
+package de.jplag;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+
+import de.jplag.exceptions.ExitException;
+
+/**
+ * Tests for the legacy behaviour of the String-based base code initializer.
+ */
+@Deprecated(since = "4.0.0", forRemoval = true)
+class LegacyBaseCodeParallelComparisonTest extends ParallelComparisonTest {
+    @Test
+    void testMultiRootDirSeparateBasecode() throws ExitException {
+        String basecodePath = getBasePath("basecode-base");
+        List<String> paths = List.of(getBasePath("basecode"), getBasePath("SimpleDuplicate")); // 3 + 2 submissions.
+        JPlagResult result = runJPlag(paths, it -> it.withBaseCodeSubmissionName(basecodePath));
+        assertEquals(5, result.getNumberOfSubmissions());
+    }
+
+    @Test
+    void testMultiRootDirBasecodeInSubmissionDir() throws ExitException {
+        String basecodePath = getBasePath("basecode", "base");
+        List<String> paths = List.of(getBasePath("basecode"), getBasePath("SimpleDuplicate")); // 2 + 2 submissions.
+        JPlagResult result = runJPlag(paths, it -> it.withBaseCodeSubmissionName(basecodePath));
+        assertEquals(4, result.getNumberOfSubmissions());
+    }
+
+    @Test
+    void testMultiRootDirBasecodeName() {
+        List<String> paths = List.of(getBasePath("basecode"), getBasePath("SimpleDuplicate"));
+        String basecodePath = "base"; // Should *not* find basecode/base
+        assertThrows(IllegalArgumentException.class, () -> runJPlag(paths, it -> it.withBaseCodeSubmissionName(basecodePath)));
+    }
+
+    @Test
+    void testBasecodeInOldDirectory() throws ExitException {
+        String basecodePath = getBasePath("basecode", "base");
+        List<String> newDirectories = List.of(getBasePath("SimpleDuplicate")); // 2 submissions
+        List<String> oldDirectories = List.of(getBasePath("basecode")); // 3 - 1 submissions
+        JPlagResult result = runJPlag(newDirectories, oldDirectories, it -> it.withBaseCodeSubmissionName(basecodePath));
+        int numberOfExpectedComparison = 1 + 2 * 2;
+        assertEquals(numberOfExpectedComparison, result.getAllComparisons().size());
+    }
+}

+ 75 - 0
core/src/test/java/de/jplag/LegacyBaseCodeTest.java

@@ -0,0 +1,75 @@
+package de.jplag;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.io.File;
+
+import org.junit.jupiter.api.Test;
+
+import de.jplag.exceptions.BasecodeException;
+import de.jplag.exceptions.ExitException;
+
+/**
+ * Tests for the legacy behaviour of the String-based base code initializer.
+ */
+@Deprecated(since = "4.0.0", forRemoval = true)
+class LegacyBaseCodeTest extends BaseCodeTest {
+    @Test
+    void testBasecodeUserSubmissionComparison() throws ExitException {
+        JPlagResult result = runJPlag("basecode", it -> it.withBaseCodeSubmissionName("base"));
+        verifyResults(result);
+    }
+
+    @Test
+    void testTinyBasecode() {
+        assertThrows(BasecodeException.class, () -> runJPlag("TinyBasecode", it -> it.withBaseCodeSubmissionName("base")));
+    }
+
+    @Test
+    void testEmptySubmission() throws ExitException {
+        JPlagResult result = runJPlag("emptysubmission", it -> it.withBaseCodeSubmissionName("base"));
+        verifyResults(result);
+    }
+
+    @Test
+    void testAutoTrimFileSeparators() throws ExitException {
+        JPlagResult result = runJPlag("basecode", it -> it.withBaseCodeSubmissionName(File.separator + "base" + File.separator));
+        verifyResults(result);
+    }
+
+    @Test
+    void testBasecodePathComparison() throws ExitException {
+        JPlagResult result = runJPlag("basecode", it -> it.withBaseCodeSubmissionName(getBasePath("basecode-base")));
+        assertEquals(3, result.getNumberOfSubmissions()); // "basecode/base" is now a user submission.
+    }
+
+    @Test
+    void testInvalidBasecode() {
+        assertThrows(BasecodeException.class, () -> runJPlag("basecode", it -> it.withBaseCodeSubmissionName("WrongBasecode")));
+    }
+
+    @Test
+    void testBasecodeUserSubmissionWithDots() {
+        assertThrows(IllegalArgumentException.class, () -> runJPlag("basecode", it -> it.withBaseCodeSubmissionName("base.ext")));
+    }
+
+    /**
+     * The simple duplicate contains obvious plagiarism.
+     */
+    @Test
+    void testSubdirectoryGlobalBasecode() throws ExitException {
+        String basecode = getBasePath("SubdirectoryBase");
+        JPlagResult result = runJPlag("SubdirectoryDuplicate", it -> it.withSubdirectoryName("src").withBaseCodeSubmissionName(basecode));
+        verifySimpleSubdirectoryDuplicate(result, 3, 3);
+    }
+
+    /**
+     * The simple duplicate contains obvious plagiarism.
+     */
+    @Test
+    void testSubdirectoryLocalBasecode() throws ExitException {
+        JPlagResult result = runJPlag("SubdirectoryDuplicate", it -> it.withSubdirectoryName("src").withBaseCodeSubmissionName("Base"));
+        verifySimpleSubdirectoryDuplicate(result, 2, 1);
+    }
+}

+ 5 - 13
core/src/test/java/de/jplag/ParallelComparisonTest.java

@@ -2,17 +2,16 @@ package de.jplag;
 
 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertThrows;
 
+import java.io.File;
 import java.util.List;
 import java.util.Optional;
 
 import org.junit.jupiter.api.Test;
 
-import de.jplag.exceptions.BasecodeException;
 import de.jplag.exceptions.ExitException;
 
-public class ParallelComparisonTest extends TestBase {
+class ParallelComparisonTest extends TestBase {
 
     /**
      * The simple duplicate contains obvious plagiarism.
@@ -111,7 +110,7 @@ public class ParallelComparisonTest extends TestBase {
     void testMultiRootDirSeparateBasecode() throws ExitException {
         String basecodePath = getBasePath("basecode-base");
         List<String> paths = List.of(getBasePath("basecode"), getBasePath("SimpleDuplicate")); // 3 + 2 submissions.
-        JPlagResult result = runJPlag(paths, it -> it.withBaseCodeSubmissionName(basecodePath));
+        JPlagResult result = runJPlag(paths, it -> it.withBaseCodeSubmissionDirectory(new File(basecodePath)));
         assertEquals(5, result.getNumberOfSubmissions());
     }
 
@@ -119,17 +118,10 @@ public class ParallelComparisonTest extends TestBase {
     void testMultiRootDirBasecodeInSubmissionDir() throws ExitException {
         String basecodePath = getBasePath("basecode", "base");
         List<String> paths = List.of(getBasePath("basecode"), getBasePath("SimpleDuplicate")); // 2 + 2 submissions.
-        JPlagResult result = runJPlag(paths, it -> it.withBaseCodeSubmissionName(basecodePath));
+        JPlagResult result = runJPlag(paths, it -> it.withBaseCodeSubmissionDirectory(new File(basecodePath)));
         assertEquals(4, result.getNumberOfSubmissions());
     }
 
-    @Test
-    void testMultiRootDirBasecodeName() {
-        List<String> paths = List.of(getBasePath("basecode"), getBasePath("SimpleDuplicate"));
-        String basecodePath = "base"; // Should *not* find basecode/base
-        assertThrows(BasecodeException.class, () -> runJPlag(paths, it -> it.withBaseCodeSubmissionName(basecodePath)));
-    }
-
     @Test
     void testDisjunctNewAndOldRootDirectories() throws ExitException {
         List<String> newDirectories = List.of(getBasePath("SimpleDuplicate")); // 2 submissions
@@ -153,7 +145,7 @@ public class ParallelComparisonTest extends TestBase {
         String basecodePath = getBasePath("basecode", "base");
         List<String> newDirectories = List.of(getBasePath("SimpleDuplicate")); // 2 submissions
         List<String> oldDirectories = List.of(getBasePath("basecode")); // 3 - 1 submissions
-        JPlagResult result = runJPlag(newDirectories, oldDirectories, it -> it.withBaseCodeSubmissionName(basecodePath));
+        JPlagResult result = runJPlag(newDirectories, oldDirectories, it -> it.withBaseCodeSubmissionDirectory(new File(basecodePath)));
         int numberOfExpectedComparison = 1 + 2 * 2;
         assertEquals(numberOfExpectedComparison, result.getAllComparisons().size());
     }

+ 4 - 1
core/src/test/java/de/jplag/TestBase.java

@@ -5,6 +5,7 @@ import java.nio.file.Path;
 import java.util.List;
 import java.util.StringJoiner;
 import java.util.function.Function;
+import java.util.stream.Collectors;
 
 import de.jplag.exceptions.ExitException;
 import de.jplag.java.Language;
@@ -48,7 +49,9 @@ public abstract class TestBase {
 
     protected JPlagResult runJPlag(List<String> newPaths, List<String> oldPaths, Function<JPlagOptions, JPlagOptions> customization)
             throws ExitException {
-        JPlagOptions options = new JPlagOptions(LanguageLoader.getLanguage(Language.IDENTIFIER).orElseThrow(), newPaths, oldPaths);
+        var newFiles = newPaths.stream().map(path -> new File(path)).collect(Collectors.toSet());
+        var oldFiles = oldPaths.stream().map(path -> new File(path)).collect(Collectors.toSet());
+        JPlagOptions options = new JPlagOptions(LanguageLoader.getLanguage(Language.IDENTIFIER).orElseThrow(), newFiles, oldFiles);
         options = customization.apply(options);
         options = options.withVerbosity(Verbosity.LONG);
         JPlag jplag = new JPlag(options);

+ 7 - 0
core/src/test/resources/de/jplag/samples/SubdirectoryBase/src/SimpleDuplicate.java

@@ -0,0 +1,7 @@
+public class SimpleDuplicate {
+
+    public static void main(String[] args) {
+        System.out.println("Hello World!");
+    }
+
+}

+ 11 - 0
core/src/test/resources/de/jplag/samples/SubdirectoryDuplicate/A/src/SimpleDuplicate.java

@@ -0,0 +1,11 @@
+public class SimpleDuplicate {
+
+    public static void main(String[] args) {
+        System.out.println("Hello World!");
+
+        for(int i = 0; i < 10; i++) {
+            System.out.println("Number is " + i);
+        }
+    }
+
+}

+ 12 - 0
core/src/test/resources/de/jplag/samples/SubdirectoryDuplicate/B/src/SimpleDuplicate.java

@@ -0,0 +1,12 @@
+public class SimpleDuplicate {
+
+    public static void main(String[] args) {
+        System.out.println("Hello Plagiarism!");
+
+        int max = 10;
+        for(int j = 0; j < max; j++) {
+            System.out.println("Number is " + j);
+        }
+    }
+
+}

+ 7 - 0
core/src/test/resources/de/jplag/samples/SubdirectoryDuplicate/Base/src/SimpleDuplicate.java

@@ -0,0 +1,7 @@
+public class SimpleDuplicate {
+
+    public static void main(String[] args) {
+        System.out.println("Hello World!");
+    }
+
+}

+ 5 - 2
endtoend-testing/src/test/java/de/jplag/endtoend/EndToEndSuiteTest.java

@@ -3,6 +3,7 @@ package de.jplag.endtoend;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
+import java.io.File;
 import java.io.IOException;
 import java.nio.file.Path;
 import java.util.ArrayList;
@@ -13,7 +14,9 @@ import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Optional;
+import java.util.Set;
 import java.util.StringJoiner;
+import java.util.stream.Collectors;
 
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.DynamicTest;
@@ -147,8 +150,8 @@ public class EndToEndSuiteTest {
         String[] submissionPath = FileHelper.createNewTestCaseDirectory(testFiles);
 
         var language = LanguageLoader.getLanguage(languageIdentifier).orElseThrow();
-        JPlagOptions jplagOptions = new JPlagOptions(language, Arrays.asList(submissionPath), new ArrayList<>())
-                .withMinimumTokenMatch(options.minimumTokenMatch());
+        JPlagOptions jplagOptions = new JPlagOptions(language, Arrays.stream(submissionPath).map(path -> new File(path)).collect(Collectors.toSet()),
+                Set.of()).withMinimumTokenMatch(options.minimumTokenMatch());
         JPlagResult jplagResult = new JPlag(jplagOptions).run();
 
         List<JPlagComparison> currentJPlagComparison = jplagResult.getAllComparisons();