store per class coverage

hcoles · Apr 28, 2021 · dbd10ef · dbd10ef
1 parent c3d75bc
commit dbd10ef
Show file tree

Hide file tree

Showing 2 changed files with 58 additions and 43 deletions.
diff --git a/pitest-entry/src/main/java/org/pitest/coverage/CoverageData.java b/pitest-entry/src/main/java/org/pitest/coverage/CoverageData.java
@@ -26,6 +26,7 @@
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
@@ -40,8 +41,6 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-import static java.util.stream.Collectors.toCollection;
-
 public class CoverageData implements CoverageDatabase {
 
   private static final Logger                                 LOG           = Log
@@ -51,6 +50,8 @@ public class CoverageData implements CoverageDatabase {
   // coverage. Ugly mess of maps below should go when
   // api changed to work via blocks
   private final Map<InstructionLocation, Set<TestInfo>>       instructionCoverage;
+  private final Map<ClassName, Set<TestInfo>>                 classCoverage = new LinkedHashMap<>();
+
   private final Map<BlockLocation, Set<Integer>>              blocksToLines = new LinkedHashMap<>();
   private final Map<ClassName, Map<ClassLine, Set<TestInfo>>> lineCoverage  = new LinkedHashMap<>();
   private final Map<String, Collection<ClassInfo>>            classesForFile;
@@ -74,6 +75,33 @@ public CoverageData(final CodeSource code, final LineMap lm, Map<InstructionLoca
         keyFromClassInfo());
   }
 
+  public void calculateClassCoverage(final CoverageResult cr) {
+
+    checkForFailedTest(cr);
+    final TestInfo ti = this.createTestInfo(cr.getTestUnitDescription(),
+            cr.getExecutionTime(), cr.getNumberOfCoveredBlocks());
+
+    addTestToClasses(ti,cr.getCoverage());
+
+    for (final BlockLocation each : cr.getCoverage()) {
+      for (int i = each.getFirstInsnInBlock();
+           i <= each.getLastInsnInBlock(); i++) {
+        addTestsToBlockMap(ti, new InstructionLocation(each, i));
+      }
+    }
+  }
+
+  private void addTestToClasses(TestInfo ti, Collection<BlockLocation> coverage) {
+    Set<ClassName> classes = coverage.stream()
+            .map(b -> b.getLocation().getClassName())
+            .collect(Collectors.toSet());
+    for (ClassName each : classes) {
+      Set<TestInfo> tests = classCoverage.computeIfAbsent(each, k -> new HashSet<>());
+      tests.add(ti);
+    }
+
+  }
+
   @Override
   public Collection<TestInfo> getTestsForInstructionLocation(InstructionLocation location) {
     return this.instructionCoverage.getOrDefault(location, Collections.emptySet());
@@ -117,23 +145,7 @@ public int getNumberOfCoveredLines(final Collection<ClassName> mutatedClass) {
 
   @Override
   public Collection<TestInfo> getTestsForClass(final ClassName clazz) {
-    return this.instructionCoverage.entrySet().stream()
-            .filter(isFor(clazz))
-            .flatMap(toTests())
-            .collect(toCollection(() -> new TreeSet<>(new TestInfoNameComparator())));
-  }
-
-  public void calculateClassCoverage(final CoverageResult cr) {
-
-    checkForFailedTest(cr);
-    final TestInfo ti = this.createTestInfo(cr.getTestUnitDescription(),
-        cr.getExecutionTime(), cr.getNumberOfCoveredBlocks());
-    for (final BlockLocation each : cr.getCoverage()) {
-      for (int i = each.getFirstInsnInBlock();
-           i <= each.getLastInsnInBlock(); i++) {
-        addTestsToBlockMap(ti, new InstructionLocation(each, i));
-      }
-    }
+    return classCoverage.getOrDefault(clazz, Collections.emptySet());
   }
 
   private void addTestsToBlockMap(final TestInfo ti, InstructionLocation each) {
@@ -272,8 +284,8 @@ private Map<ClassLine, Set<TestInfo>> convertInstructionCoverageToLineCoverageFo
   }
 
   private static Set<TestInfo> getLineTestSet(ClassName clazz,
-      Map<ClassLine, Set<TestInfo>> linesToTests,
-      Entry<InstructionLocation, Set<TestInfo>> each, int line) {
+                                              Map<ClassLine, Set<TestInfo>> linesToTests,
+                                              Entry<InstructionLocation, Set<TestInfo>> each, int line) {
     final ClassLine cl = new ClassLine(clazz, line);
     Set<TestInfo> tis = linesToTests.get(cl);
     if (tis == null) {

diff --git a/pitest-entry/src/test/java/org/pitest/coverage/CoverageDataTest.java b/pitest-entry/src/test/java/org/pitest/coverage/CoverageDataTest.java
@@ -15,25 +15,6 @@
 
 package org.pitest.coverage;
 
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-import static org.pitest.coverage.CoverageMother.aBlockLocation;
-import static org.pitest.coverage.CoverageMother.aCoverageResult;
-import static org.pitest.mutationtest.LocationMother.aLocation;
-
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Set;
-import java.util.function.Function;
-
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.Mock;
@@ -45,11 +26,31 @@
 import org.pitest.coverage.CoverageMother.BlockLocationBuilder;
 import org.pitest.coverage.CoverageMother.CoverageResultBuilder;
 import org.pitest.functional.FCollection;
-import java.util.Optional;
 import org.pitest.mutationtest.engine.Location;
 import org.pitest.mutationtest.engine.MethodName;
 import org.pitest.testapi.Description;
 
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Function;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import static org.pitest.coverage.CoverageMother.aBlockLocation;
+import static org.pitest.coverage.CoverageMother.aCoverageResult;
+import static org.pitest.mutationtest.LocationMother.aLocation;
+
 public class CoverageDataTest {
 
   private CoverageData    testee;
@@ -138,8 +139,10 @@ public void shouldReturnUniqueTestsForClassWhenSomeTestsCoverClass() {
         2));
     this.testee.calculateClassCoverage(makeCoverageResult("foo", "fooTest2", 0,
         2));
-    assertEquals(Arrays.asList("fooTest", "fooTest2"), FCollection.map(
-        this.testee.getTestsForClass(this.foo), testInfoToString()));
+
+    List<String> actual = FCollection.map(this.testee.getTestsForClass(this.foo), testInfoToString());
+
+    assertThat(actual).containsExactlyInAnyOrder("fooTest", "fooTest2");
   }
 
   @Test