From abe6e0b84d93e944ba80459d91a4cdfc1b87ba87 Mon Sep 17 00:00:00 2001 From: Pakanon Pantisawat Date: Wed, 1 Jul 2026 10:50:49 +0700 Subject: [PATCH 1/7] test: add configuration cache functional test harness Add helpers to run Gradle TestKit with --configuration-cache and assert store/reuse. The acceptance test stays @Ignore until the plugin is CC-safe. --- .../org/scoverage/ConfigurationCacheTest.java | 30 +++++++++++++++ .../scoverage/ScoverageFunctionalTest.java | 38 +++++++++++++++++++ 2 files changed, 68 insertions(+) create mode 100644 src/functionalTest/java/org/scoverage/ConfigurationCacheTest.java diff --git a/src/functionalTest/java/org/scoverage/ConfigurationCacheTest.java b/src/functionalTest/java/org/scoverage/ConfigurationCacheTest.java new file mode 100644 index 0000000..38df22e --- /dev/null +++ b/src/functionalTest/java/org/scoverage/ConfigurationCacheTest.java @@ -0,0 +1,30 @@ +package org.scoverage; + +import org.junit.Ignore; +import org.junit.Test; + +import java.util.List; + +public class ConfigurationCacheTest extends ScoverageFunctionalTest { + + public ConfigurationCacheTest() { + super("scala-single-module"); + } + + @Override + protected List getVersionAgruments() { + return ScalaVersionArguments.version2; + } + + @Test + @Ignore("Enabled once configuration cache support is implemented") + public void checkScoverageStoresAndReusesConfigurationCache() throws Exception { + + runWithConfigurationCache("clean", ScoveragePlugin.getCHECK_NAME()); + AssertableBuildResult secondRun = runWithConfigurationCache(ScoveragePlugin.getCHECK_NAME()); + + secondRun.assertConfigurationCacheReused(); + secondRun.assertTaskSucceeded(ScoveragePlugin.getCHECK_NAME()); + assertCoverage(50.0); + } +} diff --git a/src/functionalTest/java/org/scoverage/ScoverageFunctionalTest.java b/src/functionalTest/java/org/scoverage/ScoverageFunctionalTest.java index c1992d8..17233f0 100644 --- a/src/functionalTest/java/org/scoverage/ScoverageFunctionalTest.java +++ b/src/functionalTest/java/org/scoverage/ScoverageFunctionalTest.java @@ -77,6 +77,12 @@ protected AssertableBuildResult run(String... arguments) { return new AssertableBuildResult(runner.build()); } + protected AssertableBuildResult runWithConfigurationCache(String... arguments) { + + configureConfigurationCacheArguments(arguments); + return new AssertableBuildResult(runner.build()); + } + protected AssertableBuildResult runAndFail(String... arguments) { configureArguments(arguments); @@ -121,8 +127,23 @@ protected List getVersionAgruments() { private void configureArguments(String... arguments) { + configureArguments(false, arguments); + } + + private void configureConfigurationCacheArguments(String... arguments) { + + configureArguments(true, arguments); + } + + private void configureArguments(boolean configurationCache, String... arguments) { + List fullArguments = new ArrayList<>(getVersionAgruments()); + if (configurationCache) { + fullArguments.add("--configuration-cache"); + fullArguments.add("--configuration-cache-problems=fail"); + } + if (Boolean.parseBoolean(System.getProperty("failOnWarning"))) { fullArguments.add("--warning-mode=fail"); } else { @@ -201,6 +222,23 @@ private boolean taskExists(String taskName) { Pattern regex = Pattern.compile("^(> Task )?" + fullTaskName(taskName), Pattern.MULTILINE); return regex.matcher(result.getOutput()).find(); } + + public void assertConfigurationCacheStored() { + + Assert.assertTrue( + "Expected configuration cache to be stored", + result.getOutput().contains("Configuration cache entry stored") + || result.getOutput().contains("Calculating task graph as no cached configuration is available") + ); + } + + public void assertConfigurationCacheReused() { + + Assert.assertTrue( + "Expected configuration cache to be reused", + result.getOutput().contains("Reusing configuration cache") + ); + } } } From caa4bcb075a754e463164d3d0932facc985b3fcc Mon Sep 17 00:00:00 2001 From: Pakanon Pantisawat Date: Wed, 1 Jul 2026 10:55:23 +0700 Subject: [PATCH 2/7] refactor: use abstract properties on scoverage tasks Convert ScoverageReport and ScoverageAggregate to abstract task types with Property getters so task state is wired explicitly from the plugin. --- .../org/scoverage/ScoverageAggregate.groovy | 33 ++++++------ .../org/scoverage/ScoveragePlugin.groovy | 52 +++++++++---------- .../org/scoverage/ScoverageReport.groovy | 27 +++++----- 3 files changed, 57 insertions(+), 55 deletions(-) diff --git a/src/main/groovy/org/scoverage/ScoverageAggregate.groovy b/src/main/groovy/org/scoverage/ScoverageAggregate.groovy index ac1ded1..58a3cf8 100644 --- a/src/main/groovy/org/scoverage/ScoverageAggregate.groovy +++ b/src/main/groovy/org/scoverage/ScoverageAggregate.groovy @@ -16,47 +16,46 @@ import scoverage.reporter.CoverageAggregator import static org.gradle.api.tasks.PathSensitivity.RELATIVE @CacheableTask -class ScoverageAggregate extends DefaultTask { +abstract class ScoverageAggregate extends DefaultTask { @Nested - ScoverageRunner runner + abstract Property getRunner() @InputFiles @PathSensitive(RELATIVE) - final Property sources = project.objects.property(FileCollection) + abstract Property getSources() @OutputDirectory - final Property reportDir = project.objects.property(File) + abstract Property getReportDir() @Input - final ListProperty dirsToAggregateFrom = project.objects.listProperty(File) + abstract ListProperty getDirsToAggregateFrom() @Input - final Property deleteReportsOnAggregation = project.objects.property(Boolean) + abstract Property getDeleteReportsOnAggregation() @Input - final Property sourceEncoding = project.objects.property(String) + abstract Property getSourceEncoding() // TODO - consider separate options for `report` and `aggregate` tasks @Input - final Property coverageOutputCobertura = project.objects.property(Boolean) - @Input - final Property coverageOutputXML = project.objects.property(Boolean) + abstract Property getCoverageOutputCobertura() + @Input - final Property coverageOutputHTML = project.objects.property(Boolean) + abstract Property getCoverageOutputXML() + @Input - final Property coverageDebug = project.objects.property(Boolean) + abstract Property getCoverageOutputHTML() @Input - final Property sourceRoot = project.objects.property(File) + abstract Property getCoverageDebug() - ScoverageAggregate() { - dirsToAggregateFrom.set([project.extensions.scoverage.dataDir.get()]) - } + @Input + abstract Property getSourceRoot() @TaskAction def aggregate() { - runner.run { + runner.get().run { reportDir.get().deleteDir() reportDir.get().mkdirs() diff --git a/src/main/groovy/org/scoverage/ScoveragePlugin.groovy b/src/main/groovy/org/scoverage/ScoveragePlugin.groovy index a65d99e..3739ec2 100644 --- a/src/main/groovy/org/scoverage/ScoveragePlugin.groovy +++ b/src/main/groovy/org/scoverage/ScoveragePlugin.groovy @@ -130,16 +130,16 @@ class ScoveragePlugin implements Plugin { dependsOn originalJarTask, compileTask, testTask onlyIf { extension.dataDir.get().list() } group = 'verification' - runner = scoverageRunner - reportDir = taskReportDir - sources = originalSourceSet.scala.getSourceDirectories() - dataDir = extension.dataDir + runner.set(scoverageRunner) + reportDir.set(taskReportDir) + sources.set(originalSourceSet.scala.getSourceDirectories()) + dataDir.set(extension.dataDir.get()) sourceEncoding.set(detectedSourceEncoding) sourceRoot.set(project.rootDir) - coverageOutputCobertura = extension.coverageOutputCobertura - coverageOutputXML = extension.coverageOutputXML - coverageOutputHTML = extension.coverageOutputHTML - coverageDebug = extension.coverageDebug + coverageOutputCobertura.set(extension.coverageOutputCobertura.get()) + coverageOutputXML.set(extension.coverageOutputXML.get()) + coverageOutputHTML.set(extension.coverageOutputHTML.get()) + coverageDebug.set(extension.coverageDebug.get()) } } @@ -150,17 +150,17 @@ class ScoveragePlugin implements Plugin { onlyIf { dataDirs.any { it.list() } } group = 'verification' - runner = scoverageRunner - reportDir = extension.reportDir - sources = originalSourceSet.scala.getSourceDirectories() - dirsToAggregateFrom = dataDirs + runner.set(scoverageRunner) + reportDir.set(extension.reportDir.get()) + sources.set(originalSourceSet.scala.getSourceDirectories()) + dirsToAggregateFrom.set(dataDirs) sourceEncoding.set(detectedSourceEncoding) sourceRoot.set(project.rootDir) - deleteReportsOnAggregation = false - coverageOutputCobertura = extension.coverageOutputCobertura - coverageOutputXML = extension.coverageOutputXML - coverageOutputHTML = extension.coverageOutputHTML - coverageDebug = extension.coverageDebug + deleteReportsOnAggregation.set(false) + coverageOutputCobertura.set(extension.coverageOutputCobertura.get()) + coverageOutputXML.set(extension.coverageOutputXML.get()) + coverageOutputHTML.set(extension.coverageOutputHTML.get()) + coverageDebug.set(extension.coverageDebug.get()) } configureCheckTask(project, extension, globalCheckTask, globalReportTask) @@ -317,17 +317,17 @@ class ScoveragePlugin implements Plugin { } dependsOn(allReportTasks) group = 'verification' - runner = scoverageRunner - reportDir = extension.reportDir - sources = allSources + runner.set(scoverageRunner) + reportDir.set(extension.reportDir.get()) + sources.set(allSources) sourceEncoding.set(detectedSourceEncoding) sourceRoot.set(project.rootDir) - dirsToAggregateFrom = dataDirs - deleteReportsOnAggregation = extension.deleteReportsOnAggregation - coverageOutputCobertura = extension.coverageOutputCobertura - coverageOutputXML = extension.coverageOutputXML - coverageOutputHTML = extension.coverageOutputHTML - coverageDebug = extension.coverageDebug + dirsToAggregateFrom.set(dataDirs) + deleteReportsOnAggregation.set(extension.deleteReportsOnAggregation.get()) + coverageOutputCobertura.set(extension.coverageOutputCobertura.get()) + coverageOutputXML.set(extension.coverageOutputXML.get()) + coverageOutputHTML.set(extension.coverageOutputHTML.get()) + coverageDebug.set(extension.coverageDebug.get()) } project.tasks[CHECK_NAME].mustRunAfter(aggregationTask) } diff --git a/src/main/groovy/org/scoverage/ScoverageReport.groovy b/src/main/groovy/org/scoverage/ScoverageReport.groovy index d880035..eed0411 100644 --- a/src/main/groovy/org/scoverage/ScoverageReport.groovy +++ b/src/main/groovy/org/scoverage/ScoverageReport.groovy @@ -16,40 +16,43 @@ import scoverage.reporter.CoverageAggregator import static org.gradle.api.tasks.PathSensitivity.RELATIVE @CacheableTask -class ScoverageReport extends DefaultTask { +abstract class ScoverageReport extends DefaultTask { @Nested - ScoverageRunner runner + abstract Property getRunner() @InputDirectory @PathSensitive(RELATIVE) - final Property dataDir = project.objects.property(File) + abstract Property getDataDir() @InputFiles @PathSensitive(RELATIVE) - final Property sources = project.objects.property(FileCollection) + abstract Property getSources() @OutputDirectory - final Property reportDir = project.objects.property(File) + abstract Property getReportDir() @Input - final Property sourceEncoding = project.objects.property(String) + abstract Property getSourceEncoding() @Input - final Property coverageOutputCobertura = project.objects.property(Boolean) + abstract Property getCoverageOutputCobertura() + @Input - final Property coverageOutputXML = project.objects.property(Boolean) + abstract Property getCoverageOutputXML() + @Input - final Property coverageOutputHTML = project.objects.property(Boolean) + abstract Property getCoverageOutputHTML() + @Input - final Property coverageDebug = project.objects.property(Boolean) + abstract Property getCoverageDebug() @Input - final Property sourceRoot = project.objects.property(File) + abstract Property getSourceRoot() @TaskAction def report() { - runner.run { + runner.get().run { reportDir.get().delete() reportDir.get().mkdirs() From 9dd17d235a466a8a2fa8ed4332032e5d872a007c Mon Sep 17 00:00:00 2001 From: Pakanon Pantisawat Date: Wed, 1 Jul 2026 11:04:10 +0700 Subject: [PATCH 3/7] refactor: extract check and prune tasks for configuration cache Move coverage verification into CheckScoverageTask and identical-class cleanup into PruneIdenticalScoverageClassesTask. Resolve scalac plugin jars in compileScoverageScala doFirst without referencing Project. --- .../org/scoverage/CheckScoverageTask.groovy | 45 ++++++++ .../PruneIdenticalScoverageClassesTask.groovy | 65 +++++++++++ .../org/scoverage/ScoveragePlugin.groovy | 102 +++++------------- 3 files changed, 138 insertions(+), 74 deletions(-) create mode 100644 src/main/groovy/org/scoverage/CheckScoverageTask.groovy create mode 100644 src/main/groovy/org/scoverage/PruneIdenticalScoverageClassesTask.groovy diff --git a/src/main/groovy/org/scoverage/CheckScoverageTask.groovy b/src/main/groovy/org/scoverage/CheckScoverageTask.groovy new file mode 100644 index 0000000..1b578f6 --- /dev/null +++ b/src/main/groovy/org/scoverage/CheckScoverageTask.groovy @@ -0,0 +1,45 @@ +package org.scoverage + +import org.gradle.api.DefaultTask +import org.gradle.api.provider.ListProperty +import org.gradle.api.provider.Property +import org.gradle.api.tasks.CacheableTask +import org.gradle.api.tasks.Input +import org.gradle.api.tasks.InputDirectory +import org.gradle.api.tasks.PathSensitive +import org.gradle.api.tasks.TaskAction + +import static org.gradle.api.tasks.PathSensitivity.RELATIVE + +@CacheableTask +abstract class CheckScoverageTask extends DefaultTask { + + static class CheckSpec implements Serializable { + final String coverageTypeName + final BigDecimal minimumRate + + CheckSpec(String coverageTypeName, BigDecimal minimumRate) { + this.coverageTypeName = coverageTypeName + this.minimumRate = minimumRate + } + } + + @InputDirectory + @PathSensitive(RELATIVE) + abstract Property getReportDir() + + @Input + abstract ListProperty getChecks() + + @TaskAction + void checkCoverage() { + def checker = new CoverageChecker(logger) + checks.get().each { config -> + def coverageType = CoverageType.find(config.coverageTypeName) + if (coverageType == null) { + throw new IllegalArgumentException("Unknown coverage type: ${config.coverageTypeName}") + } + checker.checkLineCoverage(reportDir.get(), coverageType, config.minimumRate.doubleValue()) + } + } +} diff --git a/src/main/groovy/org/scoverage/PruneIdenticalScoverageClassesTask.groovy b/src/main/groovy/org/scoverage/PruneIdenticalScoverageClassesTask.groovy new file mode 100644 index 0000000..dcad488 --- /dev/null +++ b/src/main/groovy/org/scoverage/PruneIdenticalScoverageClassesTask.groovy @@ -0,0 +1,65 @@ +package org.scoverage + +import org.apache.commons.io.FileUtils +import org.gradle.api.DefaultTask +import org.gradle.api.file.DirectoryProperty +import org.gradle.api.tasks.InputDirectory +import org.gradle.api.tasks.PathSensitive +import org.gradle.api.tasks.PathSensitivity +import org.gradle.api.tasks.TaskAction +import org.gradle.api.tasks.UntrackedTask + +import java.nio.file.Files + +import static groovy.io.FileType.FILES + +@UntrackedTask(because = "Removes identical class files from the instrumented output in place") +abstract class PruneIdenticalScoverageClassesTask extends DefaultTask { + + @InputDirectory + @PathSensitive(PathSensitivity.RELATIVE) + abstract DirectoryProperty getOriginalClassesDirectory() + + @InputDirectory + @PathSensitive(PathSensitivity.RELATIVE) + abstract DirectoryProperty getInstrumentedClassesDirectory() + + @TaskAction + void prune() { + logger.info("Deleting classes compiled by scoverage but non-instrumented (identical to normal compilation)") + + def originalDestinationDir = originalClassesDirectory.get().asFile + def destinationDir = instrumentedClassesDirectory.get().asFile + + def findFiles = { File dir, Closure condition = null -> + def files = [] + + if (dir.exists()) { + dir.eachFileRecurse(FILES) { f -> + if (condition == null || condition(f)) { + def relativePath = dir.relativePath(f) + files << relativePath + } + } + } + + files + } + + def isSameFile = { String relativePath -> + def fileA = new File(originalDestinationDir, relativePath) + def fileB = new File(destinationDir, relativePath) + FileUtils.contentEquals(fileA, fileB) + } + + def originalClasses = findFiles(originalDestinationDir) + def identicalInstrumentedClasses = findFiles(destinationDir, { f -> + def relativePath = destinationDir.relativePath(f) + originalClasses.contains(relativePath) && isSameFile(relativePath) + }) + + identicalInstrumentedClasses.each { f -> + Files.deleteIfExists(destinationDir.toPath().resolve(f)) + } + } +} diff --git a/src/main/groovy/org/scoverage/ScoveragePlugin.groovy b/src/main/groovy/org/scoverage/ScoveragePlugin.groovy index 3739ec2..3b25852 100644 --- a/src/main/groovy/org/scoverage/ScoveragePlugin.groovy +++ b/src/main/groovy/org/scoverage/ScoveragePlugin.groovy @@ -1,9 +1,7 @@ package org.scoverage -import org.apache.commons.io.FileUtils import org.gradle.api.Plugin import org.gradle.api.Project -import org.gradle.api.Task import org.gradle.api.invocation.Gradle import org.gradle.api.plugins.PluginAware import org.gradle.api.plugins.scala.ScalaPlugin @@ -11,10 +9,7 @@ import org.gradle.api.tasks.SourceSet import org.gradle.api.tasks.TaskProvider import org.gradle.api.tasks.testing.Test -import java.nio.file.Files -import java.util.concurrent.ConcurrentHashMap - -import static groovy.io.FileType.FILES +import java.util.Optional class ScoveragePlugin implements Plugin { @@ -28,9 +23,6 @@ class ScoveragePlugin implements Plugin { static final String DEFAULT_REPORT_DIR = 'reports' + File.separatorChar + 'scoverage' - private final ConcurrentHashMap> crossProjectTaskDependencies = new ConcurrentHashMap<>() - private final ConcurrentHashMap> sameProjectTaskDependencies = new ConcurrentHashMap<>() - @Override void apply(PluginAware pluginAware) { if (pluginAware instanceof Project) { @@ -108,7 +100,7 @@ class ScoveragePlugin implements Plugin { compileTask.mustRunAfter(originalCompileTask) def globalReportTask = project.tasks.register(REPORT_NAME, ScoverageAggregate) - def globalCheckTask = project.tasks.register(CHECK_NAME) + def globalCheckTask = project.tasks.register(CHECK_NAME, CheckScoverageTask) project.afterEvaluate { def detectedSourceEncoding = compileTask.scalaCompileOptions.encoding @@ -192,19 +184,19 @@ class ScoveragePlugin implements Plugin { outputs.file(new File(extension.dataDir.get(), 'scoverage.coverage')) dependsOn project.configurations[CONFIGURATION_NAME] + def scoverageClasspath = project.configurations[CONFIGURATION_NAME] doFirst { - /* - It is crucial that this would run in `doFirst`, as this resolves the (dependencies of the) - configuration, which we do not want to do at configuration time (but only at execution time). - */ - def pluginFiles = project.configurations[CONFIGURATION_NAME].findAll { - it.name.startsWith("scalac-scoverage-plugin") || - it.name.startsWith("scalac-scoverage-domain") || - it.name.startsWith("scalac-scoverage-serializer") - }.collect { - it.absolutePath + def pluginFiles = scoverageClasspath.files.findAll { file -> + def name = file.name + name.startsWith('scalac-scoverage-plugin') || + name.startsWith('scalac-scoverage-domain') || + name.startsWith('scalac-scoverage-serializer') + }.collect { it.absolutePath } + if (!pluginFiles.isEmpty()) { + scalaCompileOptions.additionalParameters.add( + '-Xplugin:' + pluginFiles.join(File.pathSeparator) + ) } - scalaCompileOptions.additionalParameters.add('-Xplugin:' + pluginFiles.join(File.pathSeparator)) } } else { parameters.add("-sourceroot:${project.rootDir.absolutePath}".toString()) @@ -221,52 +213,20 @@ class ScoveragePlugin implements Plugin { } } + def pruneIdenticalScoverageClasses = project.tasks.register('pruneIdenticalScoverageClasses', PruneIdenticalScoverageClassesTask) { + dependsOn compileTask + onlyIf { + resolveScalaVersions(project).majorVersion < 3 + } + originalClassesDirectory.set(originalCompileTask.destinationDirectory) + instrumentedClassesDirectory.set(compileTask.destinationDirectory) + } + compileTask.configure { doFirst { destinationDirectory.get().getAsFile().deleteDir() } - - // delete non-instrumented classes by comparing normally compiled classes to those compiled with scoverage - doLast { - project.logger.info("Deleting classes compiled by scoverage but non-instrumented (identical to normal compilation)") - def originalCompileTaskName = project.sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME) - .getCompileTaskName("scala") - def originalDestinationDirectory = project.tasks[originalCompileTaskName].destinationDirectory - def originalDestinationDir = originalDestinationDirectory.get().asFile - def destinationDir = destinationDirectory.get().asFile - - - def findFiles = { File dir, Closure condition = null -> - def files = [] - - if (dir.exists()) { - dir.eachFileRecurse(FILES) { f -> - if (condition == null || condition(f)) { - def relativePath = dir.relativePath(f) - files << relativePath - } - } - } - - files - } - - def isSameFile = { String relativePath -> - def fileA = new File(originalDestinationDir, relativePath) - def fileB = new File(destinationDir, relativePath) - FileUtils.contentEquals(fileA, fileB) - } - - def originalClasses = findFiles(originalDestinationDir) - def identicalInstrumentedClasses = findFiles(destinationDir, { f -> - def relativePath = destinationDir.relativePath(f) - originalClasses.contains(relativePath) && isSameFile(relativePath) - }) - - identicalInstrumentedClasses.each { f -> - Files.deleteIfExists(destinationDir.toPath().resolve(f)) - } - } + finalizedBy(pruneIdenticalScoverageClasses) } project.gradle.taskGraph.whenReady { graph -> @@ -336,7 +296,7 @@ class ScoveragePlugin implements Plugin { } private void configureCheckTask(Project project, ScoverageExtension extension, - TaskProvider globalCheckTask, + TaskProvider globalCheckTask, TaskProvider globalReportTask) { if (extension.checks.isEmpty()) { @@ -348,20 +308,14 @@ class ScoveragePlugin implements Plugin { throw new IllegalArgumentException("Check configuration should be defined in either the new or the old syntax exclusively, not together") } - def checker = new CoverageChecker(project.logger) - globalCheckTask.configure { group = 'verification' dependsOn globalReportTask onlyIf { extension.reportDir.get().list() } - } - - extension.checks.each { config -> - globalCheckTask.configure { - doLast { - checker.checkLineCoverage(extension.reportDir.get(), config.coverageType, config.minimumRate.doubleValue()) - } - } + reportDir.set(extension.reportDir.get()) + checks.set(extension.checks.collect { config -> + new CheckScoverageTask.CheckSpec(config.coverageType.configurationName, config.minimumRate) + }) } } From 3db818e64b94afde0ff43f4b4fa2dda55e1d4cbb Mon Sep 17 00:00:00 2001 From: Pakanon Pantisawat Date: Wed, 1 Jul 2026 11:18:11 +0700 Subject: [PATCH 4/7] refactor: run coverage via scoverageTest companion tasks Register instrumented test tasks instead of mutating test classpath in taskGraph.whenReady. Report tasks depend on scoverageTest; functional tests that filter coverage measurement target scoverageTest explicitly. --- .../org/scoverage/ScalaMultiModuleTest.java | 12 ++-- ...aMultiModuleWithMultipleTestTasksTest.java | 28 ++++----- .../org/scoverage/ScalaSingleModuleTest.java | 2 +- ...SingleModuleWithMultipleTestTasksTest.java | 4 +- .../org/scoverage/ScoveragePlugin.groovy | 52 ++++++++-------- .../org/scoverage/ScoverageTestSupport.groovy | 60 +++++++++++++++++++ 6 files changed, 109 insertions(+), 49 deletions(-) create mode 100644 src/main/groovy/org/scoverage/ScoverageTestSupport.groovy diff --git a/src/functionalTest/java/org/scoverage/ScalaMultiModuleTest.java b/src/functionalTest/java/org/scoverage/ScalaMultiModuleTest.java index fa85c16..7b2edb0 100644 --- a/src/functionalTest/java/org/scoverage/ScalaMultiModuleTest.java +++ b/src/functionalTest/java/org/scoverage/ScalaMultiModuleTest.java @@ -165,7 +165,7 @@ public void checkAndAggregateScoverage() throws Exception { public void checkScoverageWithoutCoverageInRoot() throws Exception { AssertableBuildResult result = runAndFail("clean", ScoveragePlugin.getCHECK_NAME(), - "test", + ScoveragePlugin.scoverageTestTaskName("test"), "--tests", "org.hello.TestNothingSuite", "--tests", "org.hello.a.WorldASuite", "--tests", "org.hello.b.WorldBSuite", @@ -181,7 +181,7 @@ public void checkScoverageWithoutCoverageInRoot() throws Exception { public void checkScoverageWithoutCoverageInA() throws Exception { AssertableBuildResult result = runAndFail("clean", ScoveragePlugin.getCHECK_NAME(), - "test", + ScoveragePlugin.scoverageTestTaskName("test"), "--tests", "org.hello.a.TestNothingASuite", "--tests", "org.hello.WorldSuite", "--tests", "org.hello.b.WorldBSuite", @@ -198,8 +198,8 @@ public void checkScoverageWithoutCoverageInA() throws Exception { public void checkScoverageWithoutNormalCompilationAndWithoutCoverageInCommon() throws Exception { AssertableBuildResult result = runAndFail("clean", - ":a:test", - ":common:test", "--tests", "org.hello.common.TestNothingCommonSuite", + ":a:" + ScoveragePlugin.scoverageTestTaskName("test"), + ":common:" + ScoveragePlugin.scoverageTestTaskName("test"), "--tests", "org.hello.common.TestNothingCommonSuite", "-P" + ScoveragePlugin.getSCOVERAGE_COMPILE_ONLY_PROPERTY(), ScoveragePlugin.getCHECK_NAME()); @@ -215,7 +215,7 @@ public void checkAndAggregateScoverageWithoutCoverageInRoot() throws Exception { // should pass as the check on the root is for the aggregation (which covers > 50%) AssertableBuildResult result = run("clean", ScoveragePlugin.getCHECK_NAME(), - ScoveragePlugin.getAGGREGATE_NAME(), "test", + ScoveragePlugin.getAGGREGATE_NAME(), ScoveragePlugin.scoverageTestTaskName("test"), "--tests", "org.hello.TestNothingSuite", "--tests", "org.hello.a.WorldASuite", "--tests", "org.hello.b.WorldBSuite", @@ -239,7 +239,7 @@ public void checkAndAggregateScoverageWithoutCoverageInRoot() throws Exception { public void checkAndAggregateScoverageWithoutCoverageInAll() throws Exception { AssertableBuildResult result = runAndFail("clean", ScoveragePlugin.getCHECK_NAME(), - ScoveragePlugin.getAGGREGATE_NAME(), "test", + ScoveragePlugin.getAGGREGATE_NAME(), ScoveragePlugin.scoverageTestTaskName("test"), "--tests", "org.hello.TestNothingSuite", "--tests", "org.hello.a.TestNothingASuite", "--tests", "org.hello.b.TestNothingBSuite", diff --git a/src/functionalTest/java/org/scoverage/ScalaMultiModuleWithMultipleTestTasksTest.java b/src/functionalTest/java/org/scoverage/ScalaMultiModuleWithMultipleTestTasksTest.java index 8d9982b..8476157 100644 --- a/src/functionalTest/java/org/scoverage/ScalaMultiModuleWithMultipleTestTasksTest.java +++ b/src/functionalTest/java/org/scoverage/ScalaMultiModuleWithMultipleTestTasksTest.java @@ -118,17 +118,17 @@ public void checkScoverageOnlyA() { @Test public void checkScoverageWithoutIntTests() { AssertableBuildResult result = dryRun("clean", ScoveragePlugin.getCHECK_NAME(), - "-x", "intTest"); + "-x", ScoveragePlugin.scoverageTestTaskName("intTest")); result.assertTaskExists(ScoveragePlugin.getREPORT_NAME()); result.assertTaskExists("a:" + ScoveragePlugin.getREPORT_NAME()); result.assertTaskExists("b:" + ScoveragePlugin.getREPORT_NAME()); result.assertTaskExists("common:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskDoesntExist("intTest"); + result.assertTaskDoesntExist(ScoveragePlugin.scoverageTestTaskName("intTest")); result.assertTaskExists("reportIntTestScoverage"); - result.assertTaskDoesntExist("a:intTest"); - result.assertTaskDoesntExist("b:intTest"); - result.assertTaskDoesntExist("common:intTest"); + result.assertTaskDoesntExist("a:" + ScoveragePlugin.scoverageTestTaskName("intTest")); + result.assertTaskDoesntExist("b:" + ScoveragePlugin.scoverageTestTaskName("intTest")); + result.assertTaskDoesntExist("common:" + ScoveragePlugin.scoverageTestTaskName("intTest")); result.assertTaskExists("a:reportIntTestScoverage"); result.assertTaskExists("b:reportIntTestScoverage"); result.assertTaskExists("common:reportIntTestScoverage"); @@ -158,12 +158,12 @@ public void checkAndAggregateScoverage() throws Exception { public void checkScoverageWithoutCoverageInRoot() throws Exception { AssertableBuildResult result = runAndFail("clean", ScoveragePlugin.getCHECK_NAME(), - "test", + ScoveragePlugin.scoverageTestTaskName("test"), "--tests", "org.hello.TestNothingSuite", "--tests", "org.hello.a.WorldASuite", "--tests", "org.hello.b.WorldBSuite", "--tests", "org.hello.common.WorldCommonSuite", - "-x", "intTest"); + "-x", ScoveragePlugin.scoverageTestTaskName("intTest")); result.assertTaskFailed(ScoveragePlugin.getCHECK_NAME()); @@ -175,12 +175,12 @@ public void checkScoverageWithoutCoverageInRoot() throws Exception { public void checkScoverageWithoutCoverageInA() throws Exception { AssertableBuildResult result = runAndFail("clean", ScoveragePlugin.getCHECK_NAME(), - "test", + ScoveragePlugin.scoverageTestTaskName("test"), "--tests", "org.hello.a.TestNothingASuite", "--tests", "org.hello.WorldSuite", "--tests", "org.hello.b.WorldBSuite", "--tests", "org.hello.common.WorldCommonSuite", - "-x", ":a:intTest"); + "-x", ":a:" + ScoveragePlugin.scoverageTestTaskName("intTest")); result.assertTaskFailed("a:" + ScoveragePlugin.getCHECK_NAME()); @@ -193,8 +193,8 @@ public void checkScoverageWithoutCoverageInA() throws Exception { public void checkScoverageWithoutNormalCompilationAndWithoutCoverageInCommon() throws Exception { AssertableBuildResult result = runAndFail("clean", - ":a:test", - ":common:test", "--tests", "org.hello.common.TestNothingCommonSuite", + ":a:" + ScoveragePlugin.scoverageTestTaskName("test"), + ":common:" + ScoveragePlugin.scoverageTestTaskName("test"), "--tests", "org.hello.common.TestNothingCommonSuite", "-P" + ScoveragePlugin.getSCOVERAGE_COMPILE_ONLY_PROPERTY(), ScoveragePlugin.getCHECK_NAME()); @@ -210,7 +210,7 @@ public void checkAndAggregateScoverageWithoutCoverageInRoot() throws Exception { // should pass as the check on the root is for the aggregation (which covers > 50%) AssertableBuildResult result = run("clean", ScoveragePlugin.getCHECK_NAME(), - ScoveragePlugin.getAGGREGATE_NAME(), "test", + ScoveragePlugin.getAGGREGATE_NAME(), ScoveragePlugin.scoverageTestTaskName("test"), "--tests", "org.hello.TestNothingSuite", "--tests", "org.hello.a.WorldASuite", "--tests", "org.hello.b.WorldBSuite", @@ -234,12 +234,12 @@ public void checkAndAggregateScoverageWithoutCoverageInRoot() throws Exception { public void checkAndAggregateScoverageWithoutCoverageInAll() throws Exception { AssertableBuildResult result = runAndFail("clean", ScoveragePlugin.getCHECK_NAME(), - ScoveragePlugin.getAGGREGATE_NAME(), "test", + ScoveragePlugin.getAGGREGATE_NAME(), ScoveragePlugin.scoverageTestTaskName("test"), "--tests", "org.hello.TestNothingSuite", "--tests", "org.hello.a.TestNothingASuite", "--tests", "org.hello.b.TestNothingBSuite", "--tests", "org.hello.common.TestNothingCommonSuite", - "-x", "intTest"); + "-x", ScoveragePlugin.scoverageTestTaskName("intTest")); result.assertTaskSucceeded(ScoveragePlugin.getREPORT_NAME()); result.assertTaskSucceeded("a:" + ScoveragePlugin.getREPORT_NAME()); diff --git a/src/functionalTest/java/org/scoverage/ScalaSingleModuleTest.java b/src/functionalTest/java/org/scoverage/ScalaSingleModuleTest.java index dd74b13..a02672f 100644 --- a/src/functionalTest/java/org/scoverage/ScalaSingleModuleTest.java +++ b/src/functionalTest/java/org/scoverage/ScalaSingleModuleTest.java @@ -76,7 +76,7 @@ public void checkScoverage() throws Exception { public void checkScoverageFails() throws Exception { AssertableBuildResult result = runAndFail("clean", ScoveragePlugin.getCHECK_NAME(), - "test", "--tests", "org.hello.TestNothingSuite"); + ScoveragePlugin.scoverageTestTaskName("test"), "--tests", "org.hello.TestNothingSuite"); result.assertTaskSucceeded(ScoveragePlugin.getCOMPILE_NAME()); result.assertTaskSucceeded(ScoveragePlugin.getREPORT_NAME()); diff --git a/src/functionalTest/java/org/scoverage/ScalaSingleModuleWithMultipleTestTasksTest.java b/src/functionalTest/java/org/scoverage/ScalaSingleModuleWithMultipleTestTasksTest.java index 6b485b6..daf2ca1 100644 --- a/src/functionalTest/java/org/scoverage/ScalaSingleModuleWithMultipleTestTasksTest.java +++ b/src/functionalTest/java/org/scoverage/ScalaSingleModuleWithMultipleTestTasksTest.java @@ -87,8 +87,8 @@ public void checkScoverageIntTest() throws Exception { public void checkScoverageFails() throws Exception { AssertableBuildResult result = runAndFail("clean", ScoveragePlugin.getCHECK_NAME(), - "intTest", "--tests", "org.hello.TestNothingSuite", - "-x", "test"); + ScoveragePlugin.scoverageTestTaskName("intTest"), "--tests", "org.hello.TestNothingSuite", + "-x", ScoveragePlugin.scoverageTestTaskName("test")); result.assertTaskSucceeded(ScoveragePlugin.getCOMPILE_NAME()); result.assertTaskSucceeded(ScoveragePlugin.getREPORT_NAME()); diff --git a/src/main/groovy/org/scoverage/ScoveragePlugin.groovy b/src/main/groovy/org/scoverage/ScoveragePlugin.groovy index 3b25852..6c20cbf 100644 --- a/src/main/groovy/org/scoverage/ScoveragePlugin.groovy +++ b/src/main/groovy/org/scoverage/ScoveragePlugin.groovy @@ -23,6 +23,10 @@ class ScoveragePlugin implements Plugin { static final String DEFAULT_REPORT_DIR = 'reports' + File.separatorChar + 'scoverage' + static String scoverageTestTaskName(String testTaskName) { + return ScoverageTestSupport.scoverageTestTaskName(testTaskName) + } + @Override void apply(PluginAware pluginAware) { if (pluginAware instanceof Project) { @@ -110,16 +114,33 @@ class ScoveragePlugin implements Plugin { // calling toList() on TaskCollection is required // to avoid potential ConcurrentModificationException in multi-project builds - def testTasks = project.tasks.withType(Test).toList() + def testTasks = project.tasks.withType(Test).matching { testTask -> + !ScoverageTestSupport.isScoverageTestTask(testTask.name) + }.toList() + + testTasks.each { testTask -> + ScoverageTestSupport.registerScoverageTest( + project, + testTask, + instrumentedSourceSet, + CONFIGURATION_NAME, + compileTask, + extension + ) + } List reportTasks = testTasks.collect { testTask -> testTask.mustRunAfter(compileTask) def reportTaskName = "report${testTask.name.capitalize()}Scoverage" def taskReportDir = project.layout.buildDirectory.dir("reports/scoverage${testTask.name.capitalize()}").get().asFile + def scoverageTestTask = project.tasks.named( + ScoverageTestSupport.scoverageTestTaskName(testTask.name), + Test + ) project.tasks.create(reportTaskName, ScoverageReport) { - dependsOn originalJarTask, compileTask, testTask + dependsOn originalJarTask, compileTask, scoverageTestTask onlyIf { extension.dataDir.get().list() } group = 'verification' runner.set(scoverageRunner) @@ -216,7 +237,9 @@ class ScoveragePlugin implements Plugin { def pruneIdenticalScoverageClasses = project.tasks.register('pruneIdenticalScoverageClasses', PruneIdenticalScoverageClassesTask) { dependsOn compileTask onlyIf { - resolveScalaVersions(project).majorVersion < 3 + resolveScalaVersions(project).majorVersion < 3 && + originalCompileTask.destinationDirectory.get().asFile.exists() && + compileTask.destinationDirectory.get().asFile.exists() } originalClassesDirectory.set(originalCompileTask.destinationDirectory) instrumentedClassesDirectory.set(compileTask.destinationDirectory) @@ -229,29 +252,6 @@ class ScoveragePlugin implements Plugin { finalizedBy(pruneIdenticalScoverageClasses) } - project.gradle.taskGraph.whenReady { graph -> - def hasAnyReportTask = reportTasks.any { graph.hasTask(it) } - - if (hasAnyReportTask) { - project.tasks.withType(Test).each { testTask -> - testTask.configure { - project.logger.info("Adding instrumented classes to '${path}' classpath") - - classpath = project.configurations.scoverage + instrumentedSourceSet.output + classpath - - outputs.upToDateWhen { - extension.dataDir.get().listFiles(new FilenameFilter() { - @Override - boolean accept(File dir, String name) { - name.startsWith("scoverage.measurements.") - } - }) - } - } - } - } - } - // define aggregation task if (!project.subprojects.empty) { project.gradle.projectsEvaluated { diff --git a/src/main/groovy/org/scoverage/ScoverageTestSupport.groovy b/src/main/groovy/org/scoverage/ScoverageTestSupport.groovy new file mode 100644 index 0000000..23a9935 --- /dev/null +++ b/src/main/groovy/org/scoverage/ScoverageTestSupport.groovy @@ -0,0 +1,60 @@ +package org.scoverage + +import org.gradle.api.Project +import org.gradle.api.tasks.SourceSet +import org.gradle.api.tasks.testing.Test + +class ScoverageTestSupport { + + static String scoverageTestTaskName(String testTaskName) { + return "scoverage${testTaskName.capitalize()}" + } + + static boolean isScoverageTestTask(String taskName) { + return taskName.startsWith('scoverage') && taskName.length() > 'scoverage'.length() + } + + static void registerScoverageTest(Project project, + Test testTask, + SourceSet instrumentedSourceSet, + String scoverageConfigurationName, + def compileTask, + ScoverageExtension extension) { + def scoverageTestName = scoverageTestTaskName(testTask.name) + if (project.tasks.names.contains(scoverageTestName)) { + return + } + + project.tasks.register(scoverageTestName, Test) { scoverageTest -> + scoverageTest.group = 'verification' + scoverageTest.description = "Runs ${testTask.name} with scoverage instrumented classes." + scoverageTest.testClassesDirs.from(testTask.testClassesDirs) + scoverageTest.classpath.from( + project.configurations.named(scoverageConfigurationName), + instrumentedSourceSet.output, + testTask.classpath + ) + scoverageTest.javaLauncher.convention(testTask.javaLauncher) + scoverageTest.jvmArgs.addAll(testTask.jvmArgs) + scoverageTest.systemProperties.putAll(testTask.systemProperties) + scoverageTest.environment.putAll(testTask.environment) + scoverageTest.maxParallelForks = testTask.maxParallelForks + scoverageTest.forkEvery = testTask.forkEvery + scoverageTest.maxHeapSize = testTask.maxHeapSize + scoverageTest.debug = testTask.debug + scoverageTest.enableAssertions = testTask.enableAssertions + if (testTask.options instanceof org.gradle.api.tasks.testing.junitplatform.JUnitPlatformOptions) { + scoverageTest.useJUnitPlatform() + } + scoverageTest.mustRunAfter(compileTask) + scoverageTest.outputs.upToDateWhen { + extension.dataDir.get().listFiles(new FilenameFilter() { + @Override + boolean accept(File dir, String name) { + return name.startsWith("scoverage.measurements.") + } + }) + } + } + } +} From ae15625195003842a8be8544aabc7f1ffe56a0ba Mon Sep 17 00:00:00 2001 From: Pakanon Pantisawat Date: Wed, 1 Jul 2026 11:27:42 +0700 Subject: [PATCH 5/7] refactor: wire aggregateScoverage at configuration time Register root aggregateScoverage when the plugin is applied to a parent project and connect subprojects via plugins.withId instead of projectsEvaluated. --- .../org/scoverage/ScoveragePlugin.groovy | 95 +++++++++++-------- 1 file changed, 58 insertions(+), 37 deletions(-) diff --git a/src/main/groovy/org/scoverage/ScoveragePlugin.groovy b/src/main/groovy/org/scoverage/ScoveragePlugin.groovy index 6c20cbf..61ce13f 100644 --- a/src/main/groovy/org/scoverage/ScoveragePlugin.groovy +++ b/src/main/groovy/org/scoverage/ScoveragePlugin.groovy @@ -252,44 +252,65 @@ class ScoveragePlugin implements Plugin { finalizedBy(pruneIdenticalScoverageClasses) } - // define aggregation task if (!project.subprojects.empty) { - project.gradle.projectsEvaluated { - project.subprojects.each { - if (it.plugins.hasPlugin(ScalaPlugin) && !it.plugins.hasPlugin(ScoveragePlugin)) { - it.logger.warn("Scala sub-project '${it.name}' doesn't have Scoverage applied and will be ignored in parent project aggregation") - } - } - def childReportTasks = project.subprojects.findResults { - it.tasks.find { task -> - task.name == REPORT_NAME && task instanceof ScoverageAggregate - } - } - def allReportTasks = childReportTasks + globalReportTask.get() - def allSources = project.objects.fileCollection() - allReportTasks.each { - allSources = allSources.plus(it.sources.get()) - } - def aggregationTask = project.tasks.create(AGGREGATE_NAME, ScoverageAggregate) { - def dataDirs = allReportTasks.findResults { it.dirsToAggregateFrom.get() }.flatten() - onlyIf { - !childReportTasks.empty - } - dependsOn(allReportTasks) - group = 'verification' - runner.set(scoverageRunner) - reportDir.set(extension.reportDir.get()) - sources.set(allSources) - sourceEncoding.set(detectedSourceEncoding) - sourceRoot.set(project.rootDir) - dirsToAggregateFrom.set(dataDirs) - deleteReportsOnAggregation.set(extension.deleteReportsOnAggregation.get()) - coverageOutputCobertura.set(extension.coverageOutputCobertura.get()) - coverageOutputXML.set(extension.coverageOutputXML.get()) - coverageOutputHTML.set(extension.coverageOutputHTML.get()) - coverageDebug.set(extension.coverageDebug.get()) - } - project.tasks[CHECK_NAME].mustRunAfter(aggregationTask) + configureRootAggregation( + project, + extension, + scoverageRunner, + detectedSourceEncoding, + globalReportTask, + globalCheckTask + ) + } + } + } + + private void configureRootAggregation(Project project, + ScoverageExtension extension, + ScoverageRunner scoverageRunner, + String detectedSourceEncoding, + TaskProvider globalReportTask, + TaskProvider globalCheckTask) { + def aggregatedSources = project.objects.fileCollection() + if (project.plugins.hasPlugin(ScalaPlugin)) { + aggregatedSources.from(project.sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME).scala.sourceDirectories) + } + def aggregateTask = project.tasks.register(AGGREGATE_NAME, ScoverageAggregate) { + dependsOn(globalReportTask) + group = 'verification' + runner.set(scoverageRunner) + reportDir.set(extension.reportDir.get()) + sources.set(aggregatedSources) + sourceEncoding.set(detectedSourceEncoding) + sourceRoot.set(project.rootDir) + deleteReportsOnAggregation.set(extension.deleteReportsOnAggregation.get()) + coverageOutputCobertura.set(extension.coverageOutputCobertura.get()) + coverageOutputXML.set(extension.coverageOutputXML.get()) + coverageOutputHTML.set(extension.coverageOutputHTML.get()) + coverageDebug.set(extension.coverageDebug.get()) + dirsToAggregateFrom.add(extension.dataDir.get()) + onlyIf { + project.subprojects.any { it.plugins.hasPlugin(ScoveragePlugin) } + } + } + + globalCheckTask.configure { + mustRunAfter(aggregateTask) + } + + project.subprojects.each { sub -> + sub.plugins.withId('scala') { + if (!sub.plugins.hasPlugin(ScoveragePlugin)) { + sub.logger.warn("Scala sub-project '${sub.name}' doesn't have Scoverage applied and will be ignored in parent project aggregation") + } + } + sub.plugins.withId('org.scoverage') { + aggregateTask.configure { aggregationTask -> + aggregationTask.dependsOn(sub.tasks.named(REPORT_NAME)) + aggregatedSources.from( + sub.sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME).scala.sourceDirectories + ) + aggregationTask.dirsToAggregateFrom.add(sub.extensions.scoverage.dataDir.get()) } } } From f560fe330fd584d96ccbc0f617ce301b4f72fe3f Mon Sep 17 00:00:00 2001 From: Pakanon Pantisawat Date: Wed, 1 Jul 2026 11:33:33 +0700 Subject: [PATCH 6/7] refactor: extract scoverage dependency configuration Move scoverage artifact wiring into configureScoverageDependencies so dependency resolution stays isolated from task graph configuration. --- .../org/scoverage/ScoveragePlugin.groovy | 36 ++++++++++--------- 1 file changed, 20 insertions(+), 16 deletions(-) diff --git a/src/main/groovy/org/scoverage/ScoveragePlugin.groovy b/src/main/groovy/org/scoverage/ScoveragePlugin.groovy index 61ce13f..802db02 100644 --- a/src/main/groovy/org/scoverage/ScoveragePlugin.groovy +++ b/src/main/groovy/org/scoverage/ScoveragePlugin.groovy @@ -59,28 +59,32 @@ class ScoveragePlugin implements Plugin { } project.afterEvaluate { - def scalaVersion = resolveScalaVersions(project) - - def scoverageVersion = project.extensions.scoverage.scoverageVersion.get() - project.logger.info("Using scoverage scalac plugin $scoverageVersion for scala $scalaVersion") - - def scalacScoverageVersion = scalaVersion.scalacScoverageVersion - def scalacScoveragePluginVersion = scalaVersion.scalacScoveragePluginVersion - def scalacScoverageRuntimeVersion = scalaVersion.scalacScoverageRuntimeVersion - - project.dependencies { - scoverage("org.scoverage:scalac-scoverage-domain_$scalacScoverageVersion:$scoverageVersion") - scoverage("org.scoverage:scalac-scoverage-reporter_$scalacScoverageVersion:$scoverageVersion") - scoverage("org.scoverage:scalac-scoverage-serializer_$scalacScoverageVersion:$scoverageVersion") - scoverage("org.scoverage:scalac-scoverage-runtime_$scalacScoverageRuntimeVersion:$scoverageVersion") - scoverage("org.scoverage:scalac-scoverage-plugin_$scalacScoveragePluginVersion:$scoverageVersion") - } + configureScoverageDependencies(project) } } createTasks(project, extension) } + private void configureScoverageDependencies(Project project) { + def scalaVersion = resolveScalaVersions(project) + + def scoverageVersion = project.extensions.scoverage.scoverageVersion.get() + project.logger.info("Using scoverage scalac plugin $scoverageVersion for scala $scalaVersion") + + def scalacScoverageVersion = scalaVersion.scalacScoverageVersion + def scalacScoveragePluginVersion = scalaVersion.scalacScoveragePluginVersion + def scalacScoverageRuntimeVersion = scalaVersion.scalacScoverageRuntimeVersion + + project.dependencies { + scoverage("org.scoverage:scalac-scoverage-domain_$scalacScoverageVersion:$scoverageVersion") + scoverage("org.scoverage:scalac-scoverage-reporter_$scalacScoverageVersion:$scoverageVersion") + scoverage("org.scoverage:scalac-scoverage-serializer_$scalacScoverageVersion:$scoverageVersion") + scoverage("org.scoverage:scalac-scoverage-runtime_$scalacScoverageRuntimeVersion:$scoverageVersion") + scoverage("org.scoverage:scalac-scoverage-plugin_$scalacScoveragePluginVersion:$scoverageVersion") + } + } + private void createTasks(Project project, ScoverageExtension extension) { ScoverageRunner scoverageRunner = new ScoverageRunner(project.configurations.scoverage) From ca56b372559efd9b46575283af1ca76556a9e002 Mon Sep 17 00:00:00 2001 From: Pakanon Pantisawat Date: Wed, 1 Jul 2026 13:51:24 +0700 Subject: [PATCH 7/7] feat: enable configuration cache and CI Enable CC functional tests with stable store/reuse assertions, document scoverageTest companions and CC support, harden plugin closures for CC serialization, and run CI with --configuration-cache. --- .github/workflows/gradle.yml | 2 +- README.md | 10 ++- build.gradle | 5 ++ .../ConfigurationCacheMultiModuleTest.java | 27 +++++++ .../org/scoverage/ConfigurationCacheTest.java | 12 ++-- .../scoverage/ScoverageFunctionalTest.java | 41 ++++++++++- .../PruneIdenticalScoverageClassesTask.groovy | 19 ++--- .../org/scoverage/ScoveragePlugin.groovy | 70 +++++++++++-------- .../org/scoverage/ScoverageTestSupport.groovy | 4 +- 9 files changed, 142 insertions(+), 48 deletions(-) create mode 100644 src/functionalTest/java/org/scoverage/ConfigurationCacheMultiModuleTest.java diff --git a/.github/workflows/gradle.yml b/.github/workflows/gradle.yml index 2a34817..6f9db18 100644 --- a/.github/workflows/gradle.yml +++ b/.github/workflows/gradle.yml @@ -35,4 +35,4 @@ jobs: - name: Grant execute permission for gradlew run: chmod +x gradlew - name: Build with Gradle - run: ./gradlew --info --stacktrace check ${{ matrix.additional-check-args }} + run: ./gradlew --info --stacktrace --configuration-cache check ${{ matrix.additional-check-args }} diff --git a/README.md b/README.md index f5fd7b1..2df805b 100644 --- a/README.md +++ b/README.md @@ -14,8 +14,9 @@ You can find instructions on how to apply the plugin at http://plugins.gradle.or 1. `reportScoverage`: Produces XML and HTML reports for analysing test code coverage. The plugin automatically creates a `report{Task name}Scoverage` task for each test task in your - Gradle build. The `reportScoverage` task will run all test tasks and you can use the individual - tasks to run only the desired tests. For example, to run only the unit tests and no other test + Gradle build. Coverage measurement runs via a companion `scoverage{Task name}` task so normal `test` + tasks are left unchanged. The `reportScoverage` task will run all scoverage test tasks and you can use + the individual tasks to run only the desired tests. For example, to run only the unit tests and no other test tasks (e.g., integration tests), you can run `reportTestScoverage`. 2. `aggregateScoverage`: Aggregates coverage statistics in composite builds. @@ -37,6 +38,11 @@ You can find instructions on how to apply the plugin at http://plugins.gradle.or In order to check coverage of aggregated reports one should use `gradle checkScoverage aggregateScoverage`. **Note:** The plugin is not compatible with composite builds. For more information, see [the relevant issue](https://github.com/scoverage/gradle-scoverage/issues/98). + +### Configuration cache + +The plugin supports Gradle's [configuration cache](https://docs.gradle.org/current/userguide/configuration_cache.html) on Gradle 9+. +Enable it with `--configuration-cache` or in `gradle.properties`. ### Configuration diff --git a/build.gradle b/build.gradle index cdfeec1..be543d4 100644 --- a/build.gradle +++ b/build.gradle @@ -101,6 +101,11 @@ task functionalTest(type: Test) { group = 'verification' testClassesDirs = sourceSets.functionalTest.output classpath = sourceSets.functionalTest.runtimeClasspath + forkEvery = 1 + + filter { + includeTestsMatching 'org.scoverage.*' + } testLogging { events 'passed', 'failed', 'skipped' diff --git a/src/functionalTest/java/org/scoverage/ConfigurationCacheMultiModuleTest.java b/src/functionalTest/java/org/scoverage/ConfigurationCacheMultiModuleTest.java new file mode 100644 index 0000000..fd813ec --- /dev/null +++ b/src/functionalTest/java/org/scoverage/ConfigurationCacheMultiModuleTest.java @@ -0,0 +1,27 @@ +package org.scoverage; + +import org.junit.Test; + +public class ConfigurationCacheMultiModuleTest extends ScoverageFunctionalTest { + + public ConfigurationCacheMultiModuleTest() { + super("scala-multi-module"); + } + + @Test + public void checkScoverageStoresAndReusesConfigurationCache() throws Exception { + + cleanProjectForConfigurationCache(); + + prepareConfigurationCacheRun(ScoveragePlugin.getCHECK_NAME()); + AssertableBuildResult firstRun = buildPreparedConfigurationCacheRun(); + firstRun.assertConfigurationCacheStored(); + + prepareConfigurationCacheRun(ScoveragePlugin.getCHECK_NAME()); + AssertableBuildResult secondRun = buildPreparedConfigurationCacheRun(); + + secondRun.assertConfigurationCacheReused(); + secondRun.assertTaskSucceeded(ScoveragePlugin.getCHECK_NAME()); + secondRun.assertTaskSucceeded("a:" + ScoveragePlugin.getCHECK_NAME()); + } +} diff --git a/src/functionalTest/java/org/scoverage/ConfigurationCacheTest.java b/src/functionalTest/java/org/scoverage/ConfigurationCacheTest.java index 38df22e..ab04201 100644 --- a/src/functionalTest/java/org/scoverage/ConfigurationCacheTest.java +++ b/src/functionalTest/java/org/scoverage/ConfigurationCacheTest.java @@ -1,6 +1,5 @@ package org.scoverage; -import org.junit.Ignore; import org.junit.Test; import java.util.List; @@ -17,11 +16,16 @@ protected List getVersionAgruments() { } @Test - @Ignore("Enabled once configuration cache support is implemented") public void checkScoverageStoresAndReusesConfigurationCache() throws Exception { - runWithConfigurationCache("clean", ScoveragePlugin.getCHECK_NAME()); - AssertableBuildResult secondRun = runWithConfigurationCache(ScoveragePlugin.getCHECK_NAME()); + cleanProjectForConfigurationCache(); + + prepareConfigurationCacheRun(ScoveragePlugin.getCHECK_NAME()); + AssertableBuildResult firstRun = buildPreparedConfigurationCacheRun(); + firstRun.assertConfigurationCacheStored(); + + prepareConfigurationCacheRun(ScoveragePlugin.getCHECK_NAME()); + AssertableBuildResult secondRun = buildPreparedConfigurationCacheRun(); secondRun.assertConfigurationCacheReused(); secondRun.assertTaskSucceeded(ScoveragePlugin.getCHECK_NAME()); diff --git a/src/functionalTest/java/org/scoverage/ScoverageFunctionalTest.java b/src/functionalTest/java/org/scoverage/ScoverageFunctionalTest.java index 17233f0..1dd00c1 100644 --- a/src/functionalTest/java/org/scoverage/ScoverageFunctionalTest.java +++ b/src/functionalTest/java/org/scoverage/ScoverageFunctionalTest.java @@ -11,8 +11,11 @@ import java.io.File; import java.io.IOException; +import java.io.UncheckedIOException; +import java.nio.file.Files; import java.util.ArrayList; import java.util.Arrays; +import java.util.Comparator; import java.util.List; import java.util.regex.Pattern; @@ -83,6 +86,39 @@ protected AssertableBuildResult runWithConfigurationCache(String... arguments) { return new AssertableBuildResult(runner.build()); } + protected void prepareConfigurationCacheRun(String... arguments) { + + configureConfigurationCacheArguments(arguments); + } + + protected AssertableBuildResult buildPreparedConfigurationCacheRun() { + + return new AssertableBuildResult(runner.build()); + } + + protected void cleanProjectForConfigurationCache() throws IOException { + + deleteRecursively(buildDir()); + deleteRecursively(new File(projectDir(), ".gradle")); + } + + private void deleteRecursively(File directory) throws IOException { + + if (!directory.exists()) { + return; + } + + Files.walk(directory.toPath()) + .sorted(Comparator.reverseOrder()) + .forEach(path -> { + try { + Files.delete(path); + } catch (IOException e) { + throw new UncheckedIOException(e); + } + }); + } + protected AssertableBuildResult runAndFail(String... arguments) { configureArguments(arguments); @@ -234,9 +270,12 @@ public void assertConfigurationCacheStored() { public void assertConfigurationCacheReused() { + String output = result.getOutput(); Assert.assertTrue( "Expected configuration cache to be reused", - result.getOutput().contains("Reusing configuration cache") + output.contains("Reusing configuration cache") + || output.contains("Configuration cache entry reused") + || output.contains("from configuration cache") ); } } diff --git a/src/main/groovy/org/scoverage/PruneIdenticalScoverageClassesTask.groovy b/src/main/groovy/org/scoverage/PruneIdenticalScoverageClassesTask.groovy index dcad488..8e52835 100644 --- a/src/main/groovy/org/scoverage/PruneIdenticalScoverageClassesTask.groovy +++ b/src/main/groovy/org/scoverage/PruneIdenticalScoverageClassesTask.groovy @@ -3,9 +3,7 @@ package org.scoverage import org.apache.commons.io.FileUtils import org.gradle.api.DefaultTask import org.gradle.api.file.DirectoryProperty -import org.gradle.api.tasks.InputDirectory -import org.gradle.api.tasks.PathSensitive -import org.gradle.api.tasks.PathSensitivity +import org.gradle.api.tasks.Internal import org.gradle.api.tasks.TaskAction import org.gradle.api.tasks.UntrackedTask @@ -16,20 +14,25 @@ import static groovy.io.FileType.FILES @UntrackedTask(because = "Removes identical class files from the instrumented output in place") abstract class PruneIdenticalScoverageClassesTask extends DefaultTask { - @InputDirectory - @PathSensitive(PathSensitivity.RELATIVE) + @Internal abstract DirectoryProperty getOriginalClassesDirectory() - @InputDirectory - @PathSensitive(PathSensitivity.RELATIVE) + @Internal abstract DirectoryProperty getInstrumentedClassesDirectory() @TaskAction void prune() { - logger.info("Deleting classes compiled by scoverage but non-instrumented (identical to normal compilation)") + if (!originalClassesDirectory.present || !instrumentedClassesDirectory.present) { + return + } def originalDestinationDir = originalClassesDirectory.get().asFile def destinationDir = instrumentedClassesDirectory.get().asFile + if (!originalDestinationDir.exists() || !destinationDir.exists()) { + return + } + + logger.info("Deleting classes compiled by scoverage but non-instrumented (identical to normal compilation)") def findFiles = { File dir, Closure condition = null -> def files = [] diff --git a/src/main/groovy/org/scoverage/ScoveragePlugin.groovy b/src/main/groovy/org/scoverage/ScoveragePlugin.groovy index 802db02..ffab7cf 100644 --- a/src/main/groovy/org/scoverage/ScoveragePlugin.groovy +++ b/src/main/groovy/org/scoverage/ScoveragePlugin.groovy @@ -111,11 +111,19 @@ class ScoveragePlugin implements Plugin { def globalCheckTask = project.tasks.register(CHECK_NAME, CheckScoverageTask) project.afterEvaluate { + def scoverageDataDir = extension.dataDir + def scoverageReportDir = extension.reportDir + def projectRootDir = project.rootDir + def hasScoverageSubproject = project.objects.property(Boolean) + hasScoverageSubproject.set(false) + def detectedSourceEncoding = compileTask.scalaCompileOptions.encoding if (detectedSourceEncoding == null) { detectedSourceEncoding = "UTF-8" } + def scalaVersion = resolveScalaVersions(project) + // calling toList() on TaskCollection is required // to avoid potential ConcurrentModificationException in multi-project builds def testTasks = project.tasks.withType(Test).matching { testTask -> @@ -129,7 +137,7 @@ class ScoveragePlugin implements Plugin { instrumentedSourceSet, CONFIGURATION_NAME, compileTask, - extension + scoverageDataDir ) } @@ -145,14 +153,14 @@ class ScoveragePlugin implements Plugin { project.tasks.create(reportTaskName, ScoverageReport) { dependsOn originalJarTask, compileTask, scoverageTestTask - onlyIf { extension.dataDir.get().list() } + onlyIf { scoverageDataDir.get().list() } group = 'verification' runner.set(scoverageRunner) reportDir.set(taskReportDir) sources.set(originalSourceSet.scala.getSourceDirectories()) - dataDir.set(extension.dataDir.get()) + dataDir.set(scoverageDataDir.get()) sourceEncoding.set(detectedSourceEncoding) - sourceRoot.set(project.rootDir) + sourceRoot.set(projectRootDir) coverageOutputCobertura.set(extension.coverageOutputCobertura.get()) coverageOutputXML.set(extension.coverageOutputXML.get()) coverageOutputHTML.set(extension.coverageOutputHTML.get()) @@ -168,11 +176,11 @@ class ScoveragePlugin implements Plugin { group = 'verification' runner.set(scoverageRunner) - reportDir.set(extension.reportDir.get()) + reportDir.set(scoverageReportDir.get()) sources.set(originalSourceSet.scala.getSourceDirectories()) dirsToAggregateFrom.set(dataDirs) sourceEncoding.set(detectedSourceEncoding) - sourceRoot.set(project.rootDir) + sourceRoot.set(projectRootDir) deleteReportsOnAggregation.set(false) coverageOutputCobertura.set(extension.coverageOutputCobertura.get()) coverageOutputXML.set(extension.coverageOutputXML.get()) @@ -180,7 +188,7 @@ class ScoveragePlugin implements Plugin { coverageDebug.set(extension.coverageDebug.get()) } - configureCheckTask(project, extension, globalCheckTask, globalReportTask) + configureCheckTask(extension, globalCheckTask, globalReportTask, scoverageReportDir) compileTask.configure { List parameters = [] @@ -189,10 +197,9 @@ class ScoveragePlugin implements Plugin { parameters.addAll(existingParameters) } - def scalaVersion = resolveScalaVersions(project) if (scalaVersion.majorVersion < 3) { - parameters.add("-P:scoverage:dataDir:${extension.dataDir.get().absolutePath}".toString()) - parameters.add("-P:scoverage:sourceRoot:${extension.project.getRootDir().absolutePath}".toString()) + parameters.add("-P:scoverage:dataDir:${scoverageDataDir.get().absolutePath}".toString()) + parameters.add("-P:scoverage:sourceRoot:${projectRootDir.absolutePath}".toString()) if (extension.excludedPackages.get()) { def packages = extension.excludedPackages.get().join(';') parameters.add("-P:scoverage:excludedPackages:$packages".toString()) @@ -206,7 +213,7 @@ class ScoveragePlugin implements Plugin { } scalaCompileOptions.additionalParameters = parameters // the compile task creates a store of measured statements - outputs.file(new File(extension.dataDir.get(), 'scoverage.coverage')) + outputs.file(new File(scoverageDataDir.get(), 'scoverage.coverage')) dependsOn project.configurations[CONFIGURATION_NAME] def scoverageClasspath = project.configurations[CONFIGURATION_NAME] @@ -224,8 +231,8 @@ class ScoveragePlugin implements Plugin { } } } else { - parameters.add("-sourceroot:${project.rootDir.absolutePath}".toString()) - parameters.add("-coverage-out:${extension.dataDir.get().absolutePath}".toString()) + parameters.add("-sourceroot:${projectRootDir.absolutePath}".toString()) + parameters.add("-coverage-out:${scoverageDataDir.get().absolutePath}".toString()) if (extension.excludedPackages.get()) { def packages = extension.excludedPackages.get().join(',') parameters.add("-coverage-exclude-classlikes:$packages".toString()) @@ -240,11 +247,6 @@ class ScoveragePlugin implements Plugin { def pruneIdenticalScoverageClasses = project.tasks.register('pruneIdenticalScoverageClasses', PruneIdenticalScoverageClassesTask) { dependsOn compileTask - onlyIf { - resolveScalaVersions(project).majorVersion < 3 && - originalCompileTask.destinationDirectory.get().asFile.exists() && - compileTask.destinationDirectory.get().asFile.exists() - } originalClassesDirectory.set(originalCompileTask.destinationDirectory) instrumentedClassesDirectory.set(compileTask.destinationDirectory) } @@ -253,7 +255,9 @@ class ScoveragePlugin implements Plugin { doFirst { destinationDirectory.get().getAsFile().deleteDir() } - finalizedBy(pruneIdenticalScoverageClasses) + if (scalaVersion.majorVersion < 3) { + finalizedBy(pruneIdenticalScoverageClasses) + } } if (!project.subprojects.empty) { @@ -263,7 +267,10 @@ class ScoveragePlugin implements Plugin { scoverageRunner, detectedSourceEncoding, globalReportTask, - globalCheckTask + globalCheckTask, + scoverageDataDir, + projectRootDir, + hasScoverageSubproject ) } } @@ -274,7 +281,10 @@ class ScoveragePlugin implements Plugin { ScoverageRunner scoverageRunner, String detectedSourceEncoding, TaskProvider globalReportTask, - TaskProvider globalCheckTask) { + TaskProvider globalCheckTask, + org.gradle.api.provider.Property scoverageDataDir, + File projectRootDir, + org.gradle.api.provider.Property hasScoverageSubproject) { def aggregatedSources = project.objects.fileCollection() if (project.plugins.hasPlugin(ScalaPlugin)) { aggregatedSources.from(project.sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME).scala.sourceDirectories) @@ -286,16 +296,14 @@ class ScoveragePlugin implements Plugin { reportDir.set(extension.reportDir.get()) sources.set(aggregatedSources) sourceEncoding.set(detectedSourceEncoding) - sourceRoot.set(project.rootDir) + sourceRoot.set(projectRootDir) deleteReportsOnAggregation.set(extension.deleteReportsOnAggregation.get()) coverageOutputCobertura.set(extension.coverageOutputCobertura.get()) coverageOutputXML.set(extension.coverageOutputXML.get()) coverageOutputHTML.set(extension.coverageOutputHTML.get()) coverageDebug.set(extension.coverageDebug.get()) - dirsToAggregateFrom.add(extension.dataDir.get()) - onlyIf { - project.subprojects.any { it.plugins.hasPlugin(ScoveragePlugin) } - } + dirsToAggregateFrom.add(scoverageDataDir.get()) + onlyIf { hasScoverageSubproject.get() } } globalCheckTask.configure { @@ -309,6 +317,7 @@ class ScoveragePlugin implements Plugin { } } sub.plugins.withId('org.scoverage') { + hasScoverageSubproject.set(true) aggregateTask.configure { aggregationTask -> aggregationTask.dependsOn(sub.tasks.named(REPORT_NAME)) aggregatedSources.from( @@ -320,9 +329,10 @@ class ScoveragePlugin implements Plugin { } } - private void configureCheckTask(Project project, ScoverageExtension extension, + private void configureCheckTask(ScoverageExtension extension, TaskProvider globalCheckTask, - TaskProvider globalReportTask) { + TaskProvider globalReportTask, + org.gradle.api.provider.Property scoverageReportDir) { if (extension.checks.isEmpty()) { extension.check { @@ -336,8 +346,8 @@ class ScoveragePlugin implements Plugin { globalCheckTask.configure { group = 'verification' dependsOn globalReportTask - onlyIf { extension.reportDir.get().list() } - reportDir.set(extension.reportDir.get()) + onlyIf { scoverageReportDir.get().list() } + reportDir.set(scoverageReportDir.get()) checks.set(extension.checks.collect { config -> new CheckScoverageTask.CheckSpec(config.coverageType.configurationName, config.minimumRate) }) diff --git a/src/main/groovy/org/scoverage/ScoverageTestSupport.groovy b/src/main/groovy/org/scoverage/ScoverageTestSupport.groovy index 23a9935..685b637 100644 --- a/src/main/groovy/org/scoverage/ScoverageTestSupport.groovy +++ b/src/main/groovy/org/scoverage/ScoverageTestSupport.groovy @@ -19,7 +19,7 @@ class ScoverageTestSupport { SourceSet instrumentedSourceSet, String scoverageConfigurationName, def compileTask, - ScoverageExtension extension) { + org.gradle.api.provider.Property dataDir) { def scoverageTestName = scoverageTestTaskName(testTask.name) if (project.tasks.names.contains(scoverageTestName)) { return @@ -48,7 +48,7 @@ class ScoverageTestSupport { } scoverageTest.mustRunAfter(compileTask) scoverageTest.outputs.upToDateWhen { - extension.dataDir.get().listFiles(new FilenameFilter() { + dataDir.get().listFiles(new FilenameFilter() { @Override boolean accept(File dir, String name) { return name.startsWith("scoverage.measurements.")