New extension points

Adds new extension points to allow post analysis modification of coverage and mutation analysis results. Extensions points have multiple potential uses, but first use case is supporting the 'un-inlining' of inlined kotlin functions. Change requires alteration of existing interfaces which may be incompatible with some third party plugins.
hcoles · Jan 25, 2023 · 76a7ef3 · 76a7ef3
1 parent 5e0fd2d
commit 76a7ef3
Show file tree

Hide file tree

Showing 37 changed files with 555 additions and 263 deletions.
diff --git a/README.md b/README.md
@@ -8,9 +8,12 @@ Read all about it at http://pitest.org
 
 ## Releases
 
-## 1.10.5 (unreleased)
+## 1.11.0 (unreleased)
 
 * #1138 Do not mutate redundant fall through to default switch cases
+* #1150 New extension points
+
+Note that #1150 includes breaking interface changes which may require updates to third party plugins.
 
 ## 1.10.4
 

diff --git a/pitest-aggregator/src/main/java/org/pitest/aggregate/CodeSourceAggregator.java b/pitest-aggregator/src/main/java/org/pitest/aggregate/CodeSourceAggregator.java
@@ -12,6 +12,7 @@
 import org.pitest.classpath.ClassPath;
 import org.pitest.classpath.ClassPathRoot;
 import org.pitest.classpath.CodeSource;
+import org.pitest.classpath.DefaultCodeSource;
 import org.pitest.classpath.DirectoryClassPathRoot;
 import org.pitest.classpath.PathFilter;
 import org.pitest.classpath.ProjectClassPaths;
@@ -30,7 +31,7 @@ class CodeSourceAggregator {
   }
 
   public CodeSource createCodeSource() {
-    return new CodeSource(createProjectClassPaths());
+    return new DefaultCodeSource(createProjectClassPaths());
   }
 
   private ProjectClassPaths createProjectClassPaths() {

diff --git a/pitest-entry/src/main/java/org/pitest/classpath/CodeSource.java b/pitest-entry/src/main/java/org/pitest/classpath/CodeSource.java
@@ -3,89 +3,35 @@
 import java.util.Collection;
 import java.util.Optional;
 import java.util.Set;
-import java.util.function.Function;
-import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import org.pitest.bytecode.analysis.ClassTree;
 import org.pitest.classinfo.ClassByteArraySource;
 import org.pitest.classinfo.ClassInfo;
 import org.pitest.classinfo.ClassInfoSource;
 import org.pitest.classinfo.ClassName;
-import org.pitest.classinfo.NameToClassInfo;
-import org.pitest.classinfo.Repository;
-import org.pitest.classinfo.TestToClassMapper;
-import org.pitest.functional.Streams;
 
 /**
  * Provides access to code and tests on the classpath
  */
-public class CodeSource implements ClassInfoSource, ClassByteArraySource {
+public interface CodeSource extends ClassInfoSource, ClassByteArraySource {
 
-  private final ProjectClassPaths   classPath;
-  private final Repository          classRepository;
+  Stream<ClassTree> codeTrees();
 
-  public CodeSource(final ProjectClassPaths classPath) {
-    this(classPath, new Repository(new ClassPathByteArraySource(
-        classPath.getClassPath())));
-  }
+  Set<ClassName> getCodeUnderTestNames();
 
-  CodeSource(final ProjectClassPaths classPath,
-      final Repository classRepository) {
-    this.classPath = classPath;
-    this.classRepository = classRepository;
-  }
+  Stream<ClassTree> testTrees();
 
-  public Stream<ClassTree> codeTrees() {
-    return this.classPath.code().stream()
-            .map(c -> this.getBytes(c.asJavaName()))
-            .filter(Optional::isPresent)
-            .map(maybe -> ClassTree.fromBytes(maybe.get()));
-  }
+  ClassPath getClassPath();
 
-  public Set<ClassName> getCodeUnderTestNames() {
-    return this.classPath.code().stream().collect(Collectors.toSet());
-  }
+  Optional<ClassName> findTestee(String className);
 
-  public Stream<ClassTree> testTrees() {
-    return this.classPath.test().stream()
-            .map(c -> this.getBytes(c.asJavaName()))
-            .filter(Optional::isPresent)
-            .map(maybe -> ClassTree.fromBytes(maybe.get()))
-            .filter(t -> !t.isAbstract());
-  }
-
-  public ClassPath getClassPath() {
-    return this.classPath.getClassPath();
-  }
-
-  public Optional<ClassName> findTestee(final String className) {
-    final TestToClassMapper mapper = new TestToClassMapper(this.classRepository);
-    return mapper.findTestee(className);
-  }
-
-  public Collection<ClassInfo> getClassInfo(final Collection<ClassName> classes) {
-    return classes.stream()
-        .flatMap(nameToClassInfo())
-        .collect(Collectors.toList());
-  }
-
-  public Optional<byte[]> fetchClassBytes(final ClassName clazz) {
-    return this.classRepository.querySource(clazz);
-  }
+  Optional<byte[]> fetchClassBytes(ClassName clazz);
 
   @Override
-  public Optional<ClassInfo> fetchClass(final ClassName clazz) {
-    return this.classRepository.fetchClass(clazz);
-  }
-
-  private Function<ClassName, Stream<ClassInfo>> nameToClassInfo() {
-    return new NameToClassInfo(this.classRepository)
-        .andThen(Streams::fromOptional);
-  }
+  Optional<ClassInfo> fetchClass(ClassName clazz);
+  Collection<ClassInfo> getClassInfo(Collection<ClassName> classes);
 
   @Override
-  public Optional<byte[]> getBytes(String clazz) {
-    return fetchClassBytes(ClassName.fromString(clazz));
-  }
+  Optional<byte[]> getBytes(String clazz);
 }
diff --git a/pitest-entry/src/main/java/org/pitest/classpath/CodeSourceFactory.java b/pitest-entry/src/main/java/org/pitest/classpath/CodeSourceFactory.java
@@ -0,0 +1,7 @@
+package org.pitest.classpath;
+
+import org.pitest.plugin.ToolClasspathPlugin;
+
+public interface CodeSourceFactory extends ToolClasspathPlugin {
+    CodeSource createCodeSource(ProjectClassPaths classPath);
+}
diff --git a/pitest-entry/src/main/java/org/pitest/classpath/DefaultCodeSource.java b/pitest-entry/src/main/java/org/pitest/classpath/DefaultCodeSource.java
@@ -0,0 +1,85 @@
+package org.pitest.classpath;
+
+import org.pitest.bytecode.analysis.ClassTree;
+import org.pitest.classinfo.ClassInfo;
+import org.pitest.classinfo.ClassName;
+import org.pitest.classinfo.NameToClassInfo;
+import org.pitest.classinfo.Repository;
+import org.pitest.classinfo.TestToClassMapper;
+import org.pitest.functional.Streams;
+
+import java.util.Collection;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class DefaultCodeSource implements CodeSource {
+    private final ProjectClassPaths   classPath;
+    private final Repository classRepository;
+
+    public DefaultCodeSource(final ProjectClassPaths classPath) {
+        this(classPath, new Repository(new ClassPathByteArraySource(
+                classPath.getClassPath())));
+    }
+
+    DefaultCodeSource(final ProjectClassPaths classPath,
+               final Repository classRepository) {
+        this.classPath = classPath;
+        this.classRepository = classRepository;
+    }
+
+    public Stream<ClassTree> codeTrees() {
+        return this.classPath.code().stream()
+                .map(c -> this.getBytes(c.asJavaName()))
+                .filter(Optional::isPresent)
+                .map(maybe -> ClassTree.fromBytes(maybe.get()));
+    }
+
+    public Set<ClassName> getCodeUnderTestNames() {
+        return this.classPath.code().stream().collect(Collectors.toSet());
+    }
+
+    public Stream<ClassTree> testTrees() {
+        return this.classPath.test().stream()
+                .map(c -> this.getBytes(c.asJavaName()))
+                .filter(Optional::isPresent)
+                .map(maybe -> ClassTree.fromBytes(maybe.get()))
+                .filter(t -> !t.isAbstract());
+    }
+
+    public ClassPath getClassPath() {
+        return this.classPath.getClassPath();
+    }
+
+    public Optional<ClassName> findTestee(final String className) {
+        final TestToClassMapper mapper = new TestToClassMapper(this.classRepository);
+        return mapper.findTestee(className);
+    }
+
+    public Collection<ClassInfo> getClassInfo(final Collection<ClassName> classes) {
+        return classes.stream()
+                .flatMap(nameToClassInfo())
+                .collect(Collectors.toList());
+    }
+
+    public Optional<byte[]> fetchClassBytes(final ClassName clazz) {
+        return this.classRepository.querySource(clazz);
+    }
+
+    @Override
+    public Optional<ClassInfo> fetchClass(final ClassName clazz) {
+        return this.classRepository.fetchClass(clazz);
+    }
+
+    private Function<ClassName, Stream<ClassInfo>> nameToClassInfo() {
+        return new NameToClassInfo(this.classRepository)
+                .andThen(Streams::fromOptional);
+    }
+
+    @Override
+    public Optional<byte[]> getBytes(String clazz) {
+        return fetchClassBytes(ClassName.fromString(clazz));
+    }
+}
diff --git a/pitest-entry/src/main/java/org/pitest/coverage/ClassLines.java b/pitest-entry/src/main/java/org/pitest/coverage/ClassLines.java
@@ -3,8 +3,11 @@
 import org.pitest.bytecode.analysis.ClassTree;
 import org.pitest.classinfo.ClassName;
 
+import java.util.List;
 import java.util.Objects;
 import java.util.Set;
+import java.util.StringJoiner;
+import java.util.stream.Collectors;
 
 public final class ClassLines {
     private final ClassName name;
@@ -23,6 +26,16 @@ public ClassName name() {
         return name;
     }
 
+    public ClassLines relocate(ClassName name) {
+        return new ClassLines(name, codeLines);
+    }
+
+    public List<ClassLine> asList() {
+        return codeLines.stream()
+                .map(l -> new ClassLine(name, l))
+                .collect(Collectors.toList());
+    }
+
     public int getNumberOfCodeLines() {
         return this.codeLines.size();
     }
@@ -47,4 +60,12 @@ public boolean equals(Object o) {
     public int hashCode() {
         return Objects.hash(name);
     }
+
+    @Override
+    public String toString() {
+        return new StringJoiner(", ", ClassLines.class.getSimpleName() + "[", "]")
+                .add("name=" + name)
+                .add("codeLines=" + codeLines)
+                .toString();
+    }
 }
diff --git a/pitest-entry/src/main/java/org/pitest/coverage/CoverageData.java b/pitest-entry/src/main/java/org/pitest/coverage/CoverageData.java
@@ -15,7 +15,6 @@
 
 package org.pitest.coverage;
 
-import org.pitest.bytecode.analysis.ClassTree;
 import org.pitest.classinfo.ClassInfo;
 import org.pitest.classinfo.ClassName;
 import org.pitest.classpath.CodeSource;
@@ -78,11 +77,6 @@ public Collection<TestInfo> getTestsForBlockLocation(BlockLocation location) {
     return this.blockCoverage.getOrDefault(location, Collections.emptySet());
   }
 
-  @Override
-  public Collection<TestInfo> getTestsForClassLine(final ClassLine classLine) {
-    return legacyClassCoverage.getTestsForClassLine(classLine);
-  }
-
   public boolean allTestsGreen() {
     return this.failingTestDescriptions.isEmpty();
   }
@@ -96,13 +90,13 @@ public List<Description> getFailingTestDescriptions() {
   }
 
   @Override
-  public Optional<ClassLines> getCoveredLinesForClass(ClassName clazz) {
-    return legacyClassCoverage.getCoveredLinesForClass(clazz);
+  public ClassLines getCodeLinesForClass(ClassName clazz) {
+    return legacyClassCoverage.getCodeLinesForClass(clazz);
   }
 
   @Override
-  public int getNumberOfCoveredLines(final Collection<ClassName> mutatedClass) {
-    return legacyClassCoverage.getNumberOfCoveredLines(mutatedClass);
+  public Set<ClassLine> getCoveredLines(ClassName clazz) {
+    return legacyClassCoverage.getCoveredLines(clazz);
   }
 
   @Override
@@ -144,11 +138,6 @@ public Collection<ClassLines> getClassesForFile(final String sourceFile,
     return legacyClassCoverage.getClassesForFile(sourceFile, packageName);
   }
 
-  @Override
-  public CoverageSummary createSummary() {
-    return new CoverageSummary(numberOfLines(), coveredLines());
-  }
-
   private BigInteger generateCoverageNumber(Collection<TestInfo> coverage) {
     BigInteger coverageNumber = BigInteger.ZERO;
     Set<ClassName> testClasses = coverage.stream()
@@ -162,20 +151,6 @@ private BigInteger generateCoverageNumber(Collection<TestInfo> coverage) {
     return coverageNumber;
   }
 
-  private Collection<ClassName> allClasses() {
-    return this.code.getCodeUnderTestNames();
-  }
-
-  private int numberOfLines() {
-    return this.code.codeTrees()
-            .map(ClassTree::numberOfCodeLines)
-            .reduce(0, Integer::sum);
-  }
-
-  private int coveredLines() {
-    return getNumberOfCoveredLines(allClasses());
-  }
-
   private void checkForFailedTest(final CoverageResult cr) {
     if (!cr.isGreenTest()) {
       recordTestFailure(cr.getTestUnitDescription());

diff --git a/pitest-entry/src/main/java/org/pitest/coverage/CoverageDatabase.java b/pitest-entry/src/main/java/org/pitest/coverage/CoverageDatabase.java
@@ -13,6 +13,4 @@ public interface CoverageDatabase extends ReportCoverage {
 
   BigInteger getCoverageIdForClass(ClassName clazz);
 
-  CoverageSummary createSummary();
-
 }
diff --git a/pitest-entry/src/main/java/org/pitest/coverage/LegacyClassCoverage.java b/pitest-entry/src/main/java/org/pitest/coverage/LegacyClassCoverage.java
@@ -14,6 +14,7 @@
 import java.util.TreeSet;
 import java.util.function.Function;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 /**
  * Line based coverage data, used by html report and the history system
@@ -41,29 +42,20 @@ public void loadBlockDataOnly(Collection<BlockLocation> coverageData) {
     }
 
     @Override
-    public Optional<ClassLines> getCoveredLinesForClass(final ClassName clazz) {
+    public ClassLines getCodeLinesForClass(final ClassName clazz) {
         return code.fetchClassBytes(clazz)
                 .map(ClassTree::fromBytes)
-                .map(ClassLines::fromTree);
+                .map(ClassLines::fromTree)
+                .orElse(new ClassLines(clazz, Collections.emptySet()));
     }
 
     @Override
-    public int getNumberOfCoveredLines(Collection<ClassName> mutatedClass) {
-        return mutatedClass.stream()
-                .map(this::getLineCoverageForClassName)
-                .mapToInt(Map::size)
-                .sum();
-    }
-
-    @Override
-    public Collection<TestInfo> getTestsForClassLine(final ClassLine classLine) {
-        final Collection<TestInfo> result = getLineCoverageForClassName(
-                classLine.getClassName()).get(classLine);
-        if (result == null) {
-            return Collections.emptyList();
-        } else {
-            return result;
-        }
+    public Set<ClassLine> getCoveredLines(ClassName mutatedClass) {
+        return  Stream.of(mutatedClass)
+                .flatMap(m -> getLineCoverageForClassName(m).entrySet().stream())
+                .filter(e -> !e.getValue().isEmpty())
+                .map( e -> e.getKey())
+                .collect(Collectors.toSet());
     }
 
     @Override
Original file line number	Diff line number	Diff line change
Expand Up		@@ -13,6 +13,4 @@ public interface CoverageDatabase extends ReportCoverage {

		BigInteger getCoverageIdForClass(ClassName clazz);

		CoverageSummary createSummary();

		}