Просмотр исходного кода

Use Lookup Table to Associate ComparisonFileName to SubmissionFileNames

Nesta Bentum 4 лет назад
Родитель
Сommit
9754c93e55

+ 2 - 1
jplag.cli/src/main/java/de/jplag/CLI.java

@@ -64,7 +64,8 @@ public final class CLI {
             JPlag program = new JPlag(options);
             logger.info("JPlag initialized");
             JPlagResult result = program.run();
-            ReportObjectFactory.createAndSaveReport(result, arguments.getString(RESULT_FOLDER.flagWithoutDash()));
+            ReportObjectFactory reportObjectFactory = new ReportObjectFactory();
+            reportObjectFactory.createAndSaveReport(result, arguments.getString(RESULT_FOLDER.flagWithoutDash()));
 
         } catch (ExitException exception) {
             logger.error(exception.getMessage(), exception);

+ 42 - 7
jplag/src/main/java/de/jplag/reporting/reportobject/mapper/ComparisonReportMapper.java → jplag/src/main/java/de/jplag/reporting/jsonfactory/ComparisonReportWriter.java

@@ -1,38 +1,73 @@
-package de.jplag.reporting.reportobject.mapper;
+package de.jplag.reporting.jsonfactory;
 
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
 
 import de.jplag.*;
-import de.jplag.reporting.jsonfactory.FileWriter;
 import de.jplag.reporting.reportobject.model.ComparisonReport;
 import de.jplag.reporting.reportobject.model.Match;
 
-public class ComparisonReportMapper {
+public class ComparisonReportWriter {
 
     private static final FileWriter FILE_WRITER = new FileWriter();
+    private final Function<Submission, String> submissionToIdFunction;
+    private final Map<String, Map<String, String>> submissionIdToComparisonFileName = new HashMap<>();
+
+    public ComparisonReportWriter(Function<Submission, String> submissionToIdFunction) {
+        this.submissionToIdFunction = submissionToIdFunction;
+    }
 
     /**
      * Generates detailed ComparisonReport DTO for each comparison in a JPlagResult.
      * @param jPlagResult The JPlagResult to generate the comparison reports from. contains information about a comparison
      * between two submission. The JPlagResult is used to extract the information on matches between two submissions.
+     * @return
      */
-    public void writeComparisonReports(JPlagResult jPlagResult, String path) {
+    public Map<String, Map<String, String>> writeComparisonReports(JPlagResult jPlagResult, String path) {
         int numberOfComparisons = jPlagResult.getOptions().getMaximumNumberOfComparisons();
         List<JPlagComparison> comparisons = jPlagResult.getComparisons(numberOfComparisons);
         writeComparisons(jPlagResult, path, comparisons);
+        return submissionIdToComparisonFileName;
     }
 
     private void writeComparisons(JPlagResult jPlagResult, String path, List<JPlagComparison> comparisons) {
         for (JPlagComparison comparison : comparisons) {
-            String firstSubmissionId = comparison.getFirstSubmission().getNameSanitized();
-            String secondSubmissionId = comparison.getSecondSubmission().getNameSanitized();
+            String firstSubmissionId = getId(comparison.getFirstSubmission());
+            String secondSubmissionId = getId(comparison.getSecondSubmission());
+            String fileName = generateComparisonName(firstSubmissionId, secondSubmissionId);
+            addToLookUp(firstSubmissionId, secondSubmissionId, fileName);
             var comparisonReport = new ComparisonReport(firstSubmissionId, secondSubmissionId, comparison.similarity(),
                     convertMatchesToReportMatches(jPlagResult, comparison));
-            String fileName = comparisonReport.firstSubmissionId().concat("-").concat(comparisonReport.secondSubmissionId()).concat(".json");
             FILE_WRITER.saveAsJSON(comparisonReport, path, fileName);
         }
     }
 
+    private void addToLookUp(String firstSubmissionId, String secondSubmissionId, String fileName) {
+        writeToMap(secondSubmissionId, firstSubmissionId, fileName);
+        writeToMap(firstSubmissionId, secondSubmissionId, fileName);
+    }
+
+    private void writeToMap(String id1, String id2, String comparisonFileName) {
+        if (submissionIdToComparisonFileName.containsKey(id1)) {
+            submissionIdToComparisonFileName.get(id1).put(id2, comparisonFileName);
+        } else {
+            HashMap<String, String> map = new HashMap<>();
+            map.put(id2, comparisonFileName);
+            submissionIdToComparisonFileName.put(id1, map);
+        }
+    }
+
+    private String generateComparisonName(String firstSubmissionId, String secondSubmissionId) {
+        return firstSubmissionId.concat("-").concat(secondSubmissionId).concat(".json");
+
+    }
+
+    private String getId(Submission submission) {
+        return submissionToIdFunction.apply(submission);
+    }
+
     private List<Match> convertMatchesToReportMatches(JPlagResult result, JPlagComparison comparison) {
         return comparison.getMatches().stream()
                 .map(match -> convertMatchToReportMatch(comparison, match, result.getOptions().getLanguage().supportsColumns())).toList();

+ 22 - 0
jplag/src/main/java/de/jplag/reporting/jsonfactory/DirectoryCreator.java

@@ -0,0 +1,22 @@
+package de.jplag.reporting.jsonfactory;
+
+import java.io.File;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class DirectoryCreator {
+    private static final Logger logger = LoggerFactory.getLogger(DirectoryCreator.class);
+
+    public static File createDirectory(String path, String name) {
+        File directory = new File(path.concat("/").concat(name));
+        if (!directory.exists() && !directory.mkdirs()) {
+            logger.error("Failed to create dir.");
+        }
+        return directory;
+    }
+
+    public static void createDirectory(String path) {
+        createDirectory(path, "");
+    }
+}

+ 46 - 70
jplag/src/main/java/de/jplag/reporting/reportobject/ReportObjectFactory.java

@@ -1,18 +1,17 @@
 package de.jplag.reporting.reportobject;
 
+import static de.jplag.reporting.jsonfactory.DirectoryCreator.createDirectory;
+import static de.jplag.reporting.reportobject.mapper.SubmissionNameToIdMapper.buildSubmissionNameToIdMap;
+
 import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.StandardCopyOption;
 import java.text.SimpleDateFormat;
-import java.util.ArrayList;
-import java.util.Date;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
+import java.util.*;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 
-import de.jplag.reporting.reportobject.model.SubmissionName;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -20,81 +19,80 @@ import de.jplag.JPlagComparison;
 import de.jplag.JPlagResult;
 import de.jplag.Language;
 import de.jplag.Submission;
+import de.jplag.reporting.jsonfactory.ComparisonReportWriter;
 import de.jplag.reporting.jsonfactory.FileWriter;
 import de.jplag.reporting.reportobject.mapper.ClusteringResultMapper;
-import de.jplag.reporting.reportobject.mapper.ComparisonReportMapper;
 import de.jplag.reporting.reportobject.mapper.MetricMapper;
 import de.jplag.reporting.reportobject.model.Metric;
 import de.jplag.reporting.reportobject.model.OverviewReport;
 
-import static de.jplag.reporting.reportobject.mapper.SubmissionNameMapper.submissionNameOf;
-
 /**
  * Factory class, responsible for converting a JPlagResult object to Overview and Comparison DTO classes.
  */
 public class ReportObjectFactory {
     private static final Logger logger = LoggerFactory.getLogger(ReportObjectFactory.class);
 
-    private static final ClusteringResultMapper clusteringResultMapper = new ClusteringResultMapper();
-    private static final MetricMapper metricMapper = new MetricMapper();
-    private static final ComparisonReportMapper comparisonReportMapper = new ComparisonReportMapper();
     private static final FileWriter fileWriter = new FileWriter();
     public static final String OVERVIEW_FILE_NAME = "overview.json";
     public static final String SUBMISSIONS_FOLDER = "submissions";
+    private Map<String, String> submissionNameToIdMap;
+    private Function<Submission, String> submissionToIdFunction;
+    private Map<String, Map<String, String>> submissionNameToNameToComparisonFileName;
 
     /**
      * @param result The JPlagResult to be converted into a report.
      * @param path The Path to save the report to
      */
-    public static void createAndSaveReport(JPlagResult result, String path) {
+    public void createAndSaveReport(JPlagResult result, String path) {
         createDirectory(path);
-        writeOverview(result, path);
         copySubmissionFilesToReport(path, result);
-        comparisonReportMapper.writeComparisonReports(result, path);
+
+        buildSubmissionToIdMap(result);
+
+        writeComparisons(result, path);
+        writeOverview(result, path);
+
     }
 
-    private static File createDirectory(String path, String name) {
-        File directory = new File(path.concat("/").concat(name));
-        if (!directory.exists() && !directory.mkdirs()) {
-            logger.error("Failed to create dir.");
-        }
-        return directory;
+    private void writeComparisons(JPlagResult result, String path) {
+        ComparisonReportWriter comparisonReportWriter = new ComparisonReportWriter(submissionToIdFunction);
+        submissionNameToNameToComparisonFileName = comparisonReportWriter.writeComparisonReports(result, path);
     }
 
-    private static void createDirectory(String path) {
-        createDirectory(path, "");
+    private void buildSubmissionToIdMap(JPlagResult result) {
+        submissionNameToIdMap = buildSubmissionNameToIdMap(result);
+        submissionToIdFunction = (Submission submission) -> submissionNameToIdMap.get(submission.getName());
     }
 
-    private static void writeOverview(JPlagResult result, String path) {
-        List<JPlagComparison> comparisons = getComparisons(result);
-        OverviewReport overviewReport = new OverviewReport();
+    private void writeOverview(JPlagResult result, String path) {
 
-        // TODO: Consider to treat entries that were checked differently from old entries with prior work.
         List<String> folders = new ArrayList<>();
         folders.addAll(result.getOptions().getSubmissionDirectories());
         folders.addAll(result.getOptions().getOldSubmissionDirectories());
-        overviewReport.setSubmissionFolderPath(folders);
 
         String baseCodePath = result.getOptions().hasBaseCode() ? result.getOptions().getBaseCodeSubmissionName().orElse("") : "";
-        overviewReport.setBaseCodeFolderPath(baseCodePath);
-
-        overviewReport.setLanguage(result.getOptions().getLanguage().getName());
-        overviewReport.setFileExtensions(List.of(result.getOptions().getFileSuffixes()));
-        overviewReport.setSubmissionIds(extractSubmissionNames(comparisons));
-        overviewReport.setFailedSubmissionNames(List.of());  // No number of failed submissions
-        overviewReport.setExcludedFiles(result.getOptions().getExcludedFiles());
-        overviewReport.setMatchSensitivity(result.getOptions().getMinimumTokenMatch());
-        overviewReport.setDateOfExecution(getDate());
-        overviewReport.setExecutionTime(result.getDuration());
-        overviewReport.setComparisonNames(getComparisonNames(comparisons));
-        overviewReport.setMetrics(getMetrics(result));
-        overviewReport.setClusters(clusteringResultMapper.map(result));
+        ClusteringResultMapper clusteringResultMapper = new ClusteringResultMapper(submissionToIdFunction);
+
+        OverviewReport overviewReport = new OverviewReport(folders, // submissionFolderPath
+                baseCodePath, // baseCodeFolderPath
+                result.getOptions().getLanguage().getName(), // language
+                List.of(result.getOptions().getFileSuffixes()), // fileExtensions
+                submissionNameToIdMap.entrySet().stream().collect(Collectors.toMap(Map.Entry::getValue, Map.Entry::getKey)), // submissionIds
+                submissionNameToNameToComparisonFileName, // result.getOptions().getMinimumTokenMatch(),
+                List.of(), // failedSubmissionNames
+                result.getOptions().getExcludedFiles(), // excludedFiles
+                result.getOptions().getMinimumTokenMatch(), // matchSensitivity
+                getDate(),// dateOfExecution
+                result.getDuration(), // executionTime
+                getComparisonNames(submissionNameToNameToComparisonFileName), // comparisonNames
+                getMetrics(result),// metrics
+                clusteringResultMapper.map(result)); // clusters
 
         fileWriter.saveAsJSON(overviewReport, path, OVERVIEW_FILE_NAME);
 
     }
 
-    private static void copySubmissionFilesToReport(String path, JPlagResult result) {
+    private void copySubmissionFilesToReport(String path, JPlagResult result) {
         List<JPlagComparison> comparisons = result.getComparisons(result.getOptions().getMaximumNumberOfComparisons());
         var submissions = getSubmissions(comparisons);
         var submissionsPath = createDirectory(path, SUBMISSIONS_FOLDER);
@@ -112,42 +110,19 @@ public class ReportObjectFactory {
         }
     }
 
-    private static Set<Submission> getSubmissions(List<JPlagComparison> comparisons) {
+    private Set<Submission> getSubmissions(List<JPlagComparison> comparisons) {
         var submissions = comparisons.stream().map(JPlagComparison::getFirstSubmission).collect(Collectors.toSet());
         Set<Submission> secondSubmissions = comparisons.stream().map(JPlagComparison::getSecondSubmission).collect(Collectors.toSet());
         submissions.addAll(secondSubmissions);
         return submissions;
     }
 
-    private static List<JPlagComparison> getComparisons(JPlagResult result) {
-        int numberOfComparisons = result.getOptions().getMaximumNumberOfComparisons();
-        return result.getComparisons(numberOfComparisons);
-    }
-
-    /**
-     * Gets the names of all submissions.
-     * @return A list containing all submission names.
-     */
-    private static List<SubmissionName> extractSubmissionNames(List<JPlagComparison> comparisons) {
-        HashSet<SubmissionName> names = new HashSet<>();
-        comparisons.forEach(comparison -> {
-            names.add(submissionNameOf(comparison.getFirstSubmission()));
-            names.add(submissionNameOf(comparison.getSecondSubmission()));
-        });
-        return new ArrayList<>(names);
-    }
-
-
-
     /**
      * Gets the names of all comparison.
      * @return A list containing all comparisons.
      */
-    private static List<String> getComparisonNames(List<JPlagComparison> comparisons) {
-        List<String> names = new ArrayList<>();
-        comparisons.forEach(comparison -> names
-                .add(String.join("-", comparison.getFirstSubmission().getNameSanitized(), comparison.getSecondSubmission().getNameSanitized())));
-        return names;
+    private Collection<String> getComparisonNames(Map<String, Map<String, String>> submissionNameToNameToComparisonFileName) {
+        return submissionNameToNameToComparisonFileName.values().stream().flatMap(map -> map.values().stream()).collect(Collectors.toSet());
     }
 
     /**
@@ -155,11 +130,12 @@ public class ReportObjectFactory {
      * Metric.
      * @return A list contains Metric DTOs.
      */
-    private static List<Metric> getMetrics(JPlagResult result) {
+    private List<Metric> getMetrics(JPlagResult result) {
+        MetricMapper metricMapper = new MetricMapper(submissionToIdFunction);
         return List.of(metricMapper.getAverageMetric(result), metricMapper.getMaxMetric(result));
     }
 
-    private static String getDate() {
+    private String getDate() {
         SimpleDateFormat dateFormat = new SimpleDateFormat("dd/MM/yy");
         Date date = new Date();
         return dateFormat.format(date);

+ 8 - 1
jplag/src/main/java/de/jplag/reporting/reportobject/mapper/ClusteringResultMapper.java

@@ -2,6 +2,7 @@ package de.jplag.reporting.reportobject.mapper;
 
 import java.util.Collection;
 import java.util.List;
+import java.util.function.Function;
 
 import de.jplag.JPlagResult;
 import de.jplag.Submission;
@@ -12,6 +13,12 @@ import de.jplag.reporting.reportobject.model.Cluster;
  * Extracts and maps the clusters from the JPlagResult to the corresponding JSON DTO
  */
 public class ClusteringResultMapper {
+    private final Function<Submission, String> submissionToIdFunction;
+
+    public ClusteringResultMapper(Function<Submission, String> submissionToIdFunction) {
+        this.submissionToIdFunction = submissionToIdFunction;
+    }
+
     public List<Cluster> map(JPlagResult result) {
         var clusteringResult = result.getClusteringResult();
         return clusteringResult.stream().map(ClusteringResult::getClusters).flatMap(Collection::stream).map(this::convertCluster).toList();
@@ -20,7 +27,7 @@ public class ClusteringResultMapper {
     private Cluster convertCluster(de.jplag.clustering.Cluster<Submission> from) {
         var strength = from.getCommunityStrength();
         var avgSimilarity = from.getAverageSimilarity();
-        var member = from.getMembers().stream().map(Submission::getNameSanitized).toList();
+        var member = from.getMembers().stream().map(submissionToIdFunction).toList();
         return new Cluster(avgSimilarity, strength, member);
     }
 }

+ 13 - 6
jplag/src/main/java/de/jplag/reporting/reportobject/mapper/MetricMapper.java

@@ -9,6 +9,7 @@ import java.util.stream.Collectors;
 import de.jplag.JPlagComparison;
 import de.jplag.JPlagResult;
 import de.jplag.Messages;
+import de.jplag.Submission;
 import de.jplag.options.SimilarityMetric;
 import de.jplag.reporting.reportobject.model.Metric;
 import de.jplag.reporting.reportobject.model.TopComparison;
@@ -17,6 +18,12 @@ import de.jplag.reporting.reportobject.model.TopComparison;
  * Extracts and maps metrics from the JPlagResult to the corresponding JSON DTO
  */
 public class MetricMapper {
+    private final Function<Submission, String> submissionToIdFunction;
+
+    public MetricMapper(Function<Submission, String> submissionToIdFunction) {
+        this.submissionToIdFunction = submissionToIdFunction;
+    }
+
     public Metric getAverageMetric(JPlagResult result) {
         return new Metric(SimilarityMetric.AVG.name(), intArrayToList(result.getSimilarityDistribution()), getTopComparisons(getComparisons(result)),
                 Messages.getString("SimilarityMetric.Avg.Description"));
@@ -32,22 +39,22 @@ public class MetricMapper {
         return result.getComparisons(maxNumberOfComparisons);
     }
 
-    private static List<Integer> intArrayToList(int[] array) {
+    private List<Integer> intArrayToList(int[] array) {
         return Arrays.stream(array).boxed().collect(Collectors.toList());
     }
 
-    private static List<TopComparison> getTopComparisons(List<JPlagComparison> comparisons, Function<JPlagComparison, Float> similarityExtractor) {
+    private List<TopComparison> getTopComparisons(List<JPlagComparison> comparisons, Function<JPlagComparison, Float> similarityExtractor) {
         return comparisons.stream().sorted(Comparator.comparing(similarityExtractor).reversed())
-                .map(comparison -> new TopComparison(comparison.getFirstSubmission().getNameSanitized(),
-                        comparison.getSecondSubmission().getNameSanitized(), similarityExtractor.apply(comparison)))
+                .map(comparison -> new TopComparison(submissionToIdFunction.apply(comparison.getFirstSubmission()),
+                        submissionToIdFunction.apply(comparison.getSecondSubmission()), similarityExtractor.apply(comparison)))
                 .toList();
     }
 
-    private static List<TopComparison> getTopComparisons(List<JPlagComparison> comparisons) {
+    private List<TopComparison> getTopComparisons(List<JPlagComparison> comparisons) {
         return getTopComparisons(comparisons, JPlagComparison::similarity);
     }
 
-    private static List<TopComparison> getMaxSimilarityTopComparisons(List<JPlagComparison> comparisons) {
+    private List<TopComparison> getMaxSimilarityTopComparisons(List<JPlagComparison> comparisons) {
         return getTopComparisons(comparisons, JPlagComparison::maximalSimilarity);
     }
 

+ 0 - 11
jplag/src/main/java/de/jplag/reporting/reportobject/mapper/SubmissionNameMapper.java

@@ -1,11 +0,0 @@
-package de.jplag.reporting.reportobject.mapper;
-
-import de.jplag.Submission;
-import de.jplag.reporting.reportobject.model.SubmissionName;
-
-
-public class SubmissionNameMapper {
-    public static SubmissionName submissionNameOf(Submission submission){
-        return new SubmissionName(submission.getNameSanitized(), submission.getName());
-    }
-}

+ 28 - 0
jplag/src/main/java/de/jplag/reporting/reportobject/mapper/SubmissionNameToIdMapper.java

@@ -0,0 +1,28 @@
+package de.jplag.reporting.reportobject.mapper;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import de.jplag.JPlagComparison;
+import de.jplag.JPlagResult;
+
+public class SubmissionNameToIdMapper {
+    /**
+     * Gets the names of all submissions.
+     * @return A list containing all submission names.
+     */
+    public static Map<String, String> buildSubmissionNameToIdMap(JPlagResult result) {
+        HashMap<String, String> idToName = new HashMap<>();
+        getComparisons(result).forEach(comparison -> {
+            idToName.put(comparison.getFirstSubmission().getName(), comparison.getFirstSubmission().getNameSanitized());
+            idToName.put(comparison.getSecondSubmission().getName(), comparison.getSecondSubmission().getNameSanitized());
+        });
+        return idToName;
+    }
+
+    private static List<JPlagComparison> getComparisons(JPlagResult result) {
+        int numberOfComparisons = result.getOptions().getMaximumNumberOfComparisons();
+        return result.getComparisons(numberOfComparisons);
+    }
+}

+ 17 - 153
jplag/src/main/java/de/jplag/reporting/reportobject/model/OverviewReport.java

@@ -1,174 +1,38 @@
 package de.jplag.reporting.reportobject.model;
 
+import java.util.Collection;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
 import com.fasterxml.jackson.annotation.JsonProperty;
 
-public class OverviewReport {
+public record OverviewReport(
 
-    @JsonProperty("submission_folder_path")
-    private List<String> submissionFolderPath;
+        @JsonProperty("submission_folder_path") List<String> submissionFolderPath,
 
-    @JsonProperty("base_code_folder_path")
-    private String baseCodeFolderPath;
+        @JsonProperty("base_code_folder_path") String baseCodeFolderPath,
 
-    @JsonProperty("language")
-    private String language;
+        @JsonProperty("language") String language,
 
-    @JsonProperty("file_extensions")
-    private List<String> fileExtensions;
+        @JsonProperty("file_extensions") List<String> fileExtensions,
 
-    @JsonProperty("submission_ids")
-    private List<SubmissionName> submissionIds;
+        @JsonProperty("submission_ids") Map<String, String> submissionIds,
+        @JsonProperty("submissionIdsToComparisonFileName") Map<String, Map<String, String>> submissionIdsToComparisonFileName,
 
-    @JsonProperty("failed_submission_names")
-    private List<String> failedSubmissionNames;
+        @JsonProperty("failed_submission_names") List<String> failedSubmissionNames,
 
-    @JsonProperty("excluded_files")
-    private Set<String> excludedFiles;
+        @JsonProperty("excluded_files") Set<String> excludedFiles,
 
-    @JsonProperty("match_sensitivity")
-    private int matchSensitivity;
+        @JsonProperty("match_sensitivity") int matchSensitivity,
 
-    @JsonProperty("date_of_execution")
-    private String dateOfExecution;
+        @JsonProperty("date_of_execution") String dateOfExecution,
 
-    @JsonProperty("execution_time")
-    private long executionTime;
+        @JsonProperty("execution_time") long executionTime,
 
-    @JsonProperty("comparison_names")
-    private List<String> comparisonNames;
+        @JsonProperty("comparison_names") Collection<String> comparisonNames,
 
-    @JsonProperty("metrics")
-    private List<Metric> metrics;
+        @JsonProperty("metrics") List<Metric> metrics,
 
-    @JsonProperty("clusters")
-    private List<Cluster> clusters;
-
-    public OverviewReport() {
-        submissionFolderPath = List.of();
-        baseCodeFolderPath = "";
-        language = "";
-        fileExtensions = List.of();
-        submissionIds = List.of();
-        failedSubmissionNames = List.of();
-        excludedFiles = Set.of();
-        matchSensitivity = 0;
-        dateOfExecution = "";
-        executionTime = 0;
-        clusters = List.of();
-    }
-
-    /*******************************
-     * GETTERS
-     *******************************/
-
-    public List<String> getSubmissionFolderPath() {
-        return submissionFolderPath;
-    }
-
-    public String getBaseCodeFolderPath() {
-        return baseCodeFolderPath;
-    }
-
-    public String getLanguage() {
-        return language;
-    }
-
-    public List<String> getFileExtensions() {
-        return fileExtensions;
-    }
-
-    public List<SubmissionName> getSubmissionIds() {
-        return submissionIds;
-    }
-
-    public List<String> getFailedSubmissionNames() {
-        return failedSubmissionNames;
-    }
-
-    public Set<String> getExcludedFiles() {
-        return excludedFiles;
-    }
-
-    public int getMatchSensitivity() {
-        return matchSensitivity;
-    }
-
-    public String getDateOfExecution() {
-        return dateOfExecution;
-    }
-
-    public long getExecutionTime() {
-        return executionTime;
-    }
-
-    public List<String> getComparisonNames() {
-        return comparisonNames;
-    }
-
-    public List<Metric> getMetrics() {
-        return metrics;
-    }
-
-    public List<Cluster> getClusters() {
-        return clusters;
-    }
-
-    /*******************************
-     * SETTERS
-     *******************************/
-
-    public void setSubmissionFolderPath(List<String> submissionFolderPath) {
-        this.submissionFolderPath = submissionFolderPath;
-    }
-
-    public void setBaseCodeFolderPath(String baseCodeFolderPath) {
-        this.baseCodeFolderPath = baseCodeFolderPath;
-    }
-
-    public void setLanguage(String language) {
-        this.language = language;
-    }
-
-    public void setFileExtensions(List<String> fileExtensions) {
-        this.fileExtensions = List.copyOf(fileExtensions);
-    }
-
-    public void setSubmissionIds(List<SubmissionName> submissionIds) {
-        this.submissionIds = List.copyOf(submissionIds);
-    }
-
-    public void setFailedSubmissionNames(List<String> failedSubmissionNames) {
-        this.failedSubmissionNames = List.copyOf(failedSubmissionNames);
-    }
-
-    public void setExcludedFiles(Set<String> excludedFiles) {
-        this.excludedFiles = Set.copyOf(excludedFiles);
-    }
-
-    public void setMatchSensitivity(int matchSensitivity) {
-        this.matchSensitivity = matchSensitivity;
-    }
-
-    public void setDateOfExecution(String dateOfExecution) {
-        this.dateOfExecution = dateOfExecution;
-    }
-
-    public void setExecutionTime(long executionTime) {
-        this.executionTime = executionTime;
-    }
-
-    public void setComparisonNames(List<String> comparisonNames) {
-        this.comparisonNames = List.copyOf(comparisonNames);
-    }
-
-    public void setMetrics(List<Metric> metrics) {
-        this.metrics = List.copyOf(metrics);
-    }
-
-    public void setClusters(List<Cluster> clusters) {
-        this.clusters = List.copyOf(clusters);
-    }
+        @JsonProperty("clusters") List<Cluster> clusters) {
 }

+ 1 - 1
jplag/src/test/java/de/jplag/reporting/reportobject/mapper/ClusteringResultMapperTest.java

@@ -15,7 +15,7 @@ import de.jplag.clustering.Cluster;
 import de.jplag.clustering.ClusteringResult;
 
 public class ClusteringResultMapperTest {
-    private final ClusteringResultMapper clusteringResultMapper = new ClusteringResultMapper();
+    private final ClusteringResultMapper clusteringResultMapper = new ClusteringResultMapper(Submission::getName);
 
     @Test
     public void test() {

+ 31 - 0
jplag/src/test/java/de/jplag/reporting/reportobject/mapper/ComparisonReportWriterTest.java

@@ -0,0 +1,31 @@
+package de.jplag.reporting.reportobject.mapper;
+
+import java.util.Map;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import de.jplag.JPlagResult;
+import de.jplag.Submission;
+import de.jplag.TestBase;
+import de.jplag.exceptions.ExitException;
+import de.jplag.reporting.jsonfactory.ComparisonReportWriter;
+
+public class ComparisonReportWriterTest extends TestBase {
+
+    @Test
+    public void test() throws ExitException {
+        JPlagResult result = runJPlagWithDefaultOptions("PartialPlagiarism");
+        var mapper = new ComparisonReportWriter(Submission::getName);
+
+        Map<String, Map<String, String>> stringMapMap = mapper.writeComparisonReports(result, "");
+
+        firstLevelOfMapContains(stringMapMap, "A", "B", "C", "D", "E");
+    }
+
+    private void firstLevelOfMapContains(Map<String, Map<String, String>> stringMapMap, String... names) {
+        for (String name : names) {
+            Assertions.assertNotNull(stringMapMap.get(name));
+        }
+    }
+}

+ 1 - 1
jplag/src/test/java/de/jplag/reporting/reportobject/mapper/MetricMapperTest.java

@@ -15,7 +15,7 @@ import de.jplag.options.JPlagOptions;
 import de.jplag.reporting.reportobject.model.TopComparison;
 
 public class MetricMapperTest {
-    private final MetricMapper metricMapper = new MetricMapper();
+    private final MetricMapper metricMapper = new MetricMapper(Submission::getName);
 
     @Test
     public void test_getAverageMetric() {