Limit line coverage to only mutated classes

The line coverage data displayed on the console includes all targetted
code, while the figures shown in the report are implicitly limited to
mutated classes. These causes constant confusion.

This change limits the console coverage to also include only mutated
classes.

pitest-entry/src/main/java/org/pitest/mutationtest/statistics/MutationStatistics.java

@@ -14,10 +14,13 @@
  */
 package org.pitest.mutationtest.statistics;
 
+import org.pitest.classinfo.ClassName;
+
 import java.io.PrintStream;
 import java.text.DecimalFormat;
 import java.text.DecimalFormatSymbols;
 import java.util.Locale;
+import java.util.Set;
 
 public final class MutationStatistics {
   private final Iterable<Score> scores;
@@ -26,13 +29,20 @@ public final class MutationStatistics {
   private final long totalDetected;
   private final long totalWithCoverage;
 
-  public MutationStatistics(Iterable<Score> scores, long totalMutations,
-                            long totalDetected, long totalWithCoverage, long numberOfTestsRun) {
+  private final Set<ClassName> mutatedClasses;
+
+  public MutationStatistics(Iterable<Score> scores,
+                            long totalMutations,
+                            long totalDetected,
+                            long totalWithCoverage,
+                            long numberOfTestsRun,
+                            Set<ClassName> mutatedClasses) {
     this.scores = scores;
     this.totalMutations = totalMutations;
     this.totalDetected = totalDetected;
     this.numberOfTestsRun = numberOfTestsRun;
     this.totalWithCoverage = totalWithCoverage;
+    this.mutatedClasses = mutatedClasses;
   }
 
   public Iterable<Score> getScores() {
@@ -59,6 +69,10 @@ public long getTotalSurvivingMutations() {
     return getTotalMutations() - getTotalDetectedMutations();
   }
 
+  public Set<ClassName> mutatedClasses() {
+    return mutatedClasses;
+  }
+
   public long getPercentageDetected() {
     if (getTotalMutations() == 0) {
       return 100;

pitest-entry/src/main/java/org/pitest/mutationtest/statistics/MutationStatisticsListener.java

@@ -43,6 +43,7 @@ public void runEnd() {
   }
 
   private void processMetaData(final ClassMutationResults value) {
+    this.mutatorScores.registerClass(value.getMutatedClass());
     this.mutatorScores.registerResults(value.getMutations());
   }
 }

pitest-entry/src/main/java/org/pitest/mutationtest/statistics/MutationStatisticsPrecursor.java

@@ -2,21 +2,33 @@
 
 import java.util.Collection;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Map;
+import java.util.Set;
 import java.util.function.BiFunction;
 import java.util.function.Consumer;
 
+import org.pitest.classinfo.ClassName;
 import org.pitest.functional.FCollection;
 import org.pitest.mutationtest.MutationResult;
 
 class MutationStatisticsPrecursor {
   private final Map<String, ScorePrecursor> mutatorTotalMap  = new HashMap<>();
+  private final Set<ClassName> mutatedClasses = new HashSet<>();
   private long                              numberOfTestsRun = 0;
 
   public void registerResults(final Collection<MutationResult> results) {
     results.forEach(register());
   }
 
+  public void registerClass(ClassName mutatedClass) {
+    mutatedClasses.add(mutatedClass);
+  }
+
+  public Set<ClassName> mutatedClasses() {
+    return mutatedClasses;
+  }
+
   private Consumer<MutationResult> register() {
     return mr -> {
       MutationStatisticsPrecursor.this.numberOfTestsRun = MutationStatisticsPrecursor.this.numberOfTestsRun
@@ -39,7 +51,7 @@ public MutationStatistics toStatistics() {
         .fold(addDetectedTotals(), 0L, scores);
     final long totalWithCoverage = FCollection.fold(addCoveredTotals(), 0L, scores);
     return new MutationStatistics(scores, totalMutations, totalDetected, totalWithCoverage,
-        this.numberOfTestsRun);
+        this.numberOfTestsRun, mutatedClasses());
   }
 
   Iterable<Score> getScores() {
@@ -58,4 +70,6 @@ private static BiFunction<Long, Score, Long> addDetectedTotals() {
   private static BiFunction<Long, Score, Long> addCoveredTotals() {
     return (a, b) -> a + b.getTotalWithCoverage();
   }
+
+
 }

pitest-entry/src/main/java/org/pitest/mutationtest/tooling/MutationCoverage.java

@@ -74,8 +74,10 @@
 import java.util.function.Predicate;
 import java.util.logging.Level;
 import java.util.logging.Logger;
+import java.util.stream.Collectors;
 
 import static java.util.Collections.emptyList;
+import static java.util.Collections.emptySet;
 
 public class MutationCoverage {
 
@@ -143,7 +145,7 @@ public CombinedStatistics runReport() throws IOException {
   }
 
   private CombinedStatistics emptyStatistics() {
-    MutationStatistics mutationStatistics = new MutationStatistics(emptyList(),0,0,0,0);
+    MutationStatistics mutationStatistics = new MutationStatistics(emptyList(),0,0,0,0, emptySet());
     return new CombinedStatistics(mutationStatistics, new CoverageSummary(0,0), Collections.emptyList());
   }
 
@@ -185,8 +187,9 @@ private CombinedStatistics runAnalysis(Runtime runtime, long t0, EngineArguments
 
     LOG.info("Completed in " + timeSpan(t0));
 
-    CombinedStatistics combined = new CombinedStatistics(stats.getStatistics(),
-            createSummary(modifiedCoverage), issues);
+    MutationStatistics mutationStats = stats.getStatistics();
+    CombinedStatistics combined = new CombinedStatistics(mutationStats,
+            createSummary(modifiedCoverage, mutationStats.mutatedClasses()), issues);
 
     printStats(combined);
 
@@ -199,12 +202,17 @@ private ReportCoverage transformCoverage(ReportCoverage coverageData) {
     return strategies.coverageTransformer().transform(coverageData);
   }
 
-  private CoverageSummary createSummary(ReportCoverage modifiedCoverage) {
-    int numberOfCodeLines = this.code.getCodeUnderTestNames().stream()
-            .map(c -> modifiedCoverage.getCodeLinesForClass(c).getNumberOfCodeLines())
+  private CoverageSummary createSummary(ReportCoverage modifiedCoverage, Set<ClassName> mutatedClasses) {
+    List<ClassName> examinedClasses = this.code.getCodeUnderTestNames().stream()
+            .filter(mutatedClasses::contains)
+            .collect(Collectors.toList());
+
+    int numberOfCodeLines = examinedClasses.stream()
+            .map(c -> modifiedCoverage.getCodeLinesForClass(c))
+            .map(c -> c.getNumberOfCodeLines())
             .reduce(0, Integer::sum);
 
-    int coveredLines = this.code.getCodeUnderTestNames().stream()
+    int coveredLines = examinedClasses.stream()
             .mapToInt(c -> modifiedCoverage.getCoveredLines(c).size())
             .sum();
 
@@ -324,7 +332,7 @@ private void printStats(CombinedStatistics combinedStatistics) {
 
     final CoverageSummary coverage = combinedStatistics.getCoverageSummary();
     if (coverage != null) {
-      ps.println(String.format(">> Line Coverage: %d/%d (%d%%)", coverage.getNumberOfCoveredLines(),
+      ps.println(String.format(">> Line Coverage (for mutated classes only): %d/%d (%d%%)", coverage.getNumberOfCoveredLines(),
               coverage.getNumberOfLines(), coverage.getCoverage()));
     }
 

pitest-maven/src/test/java/org/pitest/maven/PitMojoTest.java

@@ -396,7 +396,7 @@ public void testEmptyFeatureIsIgnored() throws Exception {
   private void setupCoverage(long mutationScore, int lines, int linesCovered)
       throws MojoExecutionException {
     Iterable<Score> scores = Collections.<Score>emptyList();
-    final MutationStatistics stats = new MutationStatistics(scores, 100, mutationScore, 100, 0);
+    final MutationStatistics stats = new MutationStatistics(scores, 100, mutationScore, 100, 0, Collections.emptySet());
     CoverageSummary sum = new CoverageSummary(lines, linesCovered);
     final CombinedStatistics cs = new CombinedStatistics(stats, sum, Collections.emptyList());
     when(
@@ -408,7 +408,7 @@ private void setupCoverage(long mutationScore, int lines, int linesCovered)
   private void setupTestStrength(long totalMutations, long mutationDetected, long mutationsWithCoverage)
           throws MojoExecutionException {
     Iterable<Score> scores = Collections.<Score>emptyList();
-    final MutationStatistics stats = new MutationStatistics(scores, totalMutations, mutationDetected, mutationsWithCoverage, 0);
+    final MutationStatistics stats = new MutationStatistics(scores, totalMutations, mutationDetected, mutationsWithCoverage, 0, Collections.emptySet());
     CoverageSummary sum = new CoverageSummary(0, 0);
     final CombinedStatistics cs = new CombinedStatistics(stats, sum, Collections.emptyList());
     when(
@@ -421,7 +421,7 @@ private void setupSuvivingMutants(long survivors)
       throws MojoExecutionException {
     Iterable<Score> scores = Collections.<Score>emptyList();
     int detected = 100;
-    final MutationStatistics stats = new MutationStatistics(scores, detected + survivors, detected, detected + survivors, 0);
+    final MutationStatistics stats = new MutationStatistics(scores, detected + survivors, detected, detected + survivors, 0, Collections.emptySet());
     CoverageSummary sum = new CoverageSummary(0, 0);
     final CombinedStatistics cs = new CombinedStatistics(stats, sum, Collections.emptyList());
     when(