Remove the "testScoverage" task and make "test" run the coverage (by adding the instrumented classes to its classpath)

Author: eyalroth

src/functionalTest/java/org.scoverage/ScalaMultiModuleTest.java

@@ -116,7 +116,7 @@ public void checkAndAggregateScoverage() throws Exception {
     public void checkScoverageWithoutCoverageInRoot() throws Exception {
 
         AssertableBuildResult result = runAndFail("clean", ScoveragePlugin.getCHECK_NAME(),
-                ScoveragePlugin.getTEST_NAME(),
+                "test",
                 "--tests", "org.hello.TestNothingSuite",
                 "--tests", "org.hello.a.WorldASuite",
                 "--tests", "org.hello.b.WorldBSuite");
@@ -131,7 +131,7 @@ public void checkScoverageWithoutCoverageInRoot() throws Exception {
     public void checkScoverageWithoutCoverageInA() throws Exception {
 
         AssertableBuildResult result = runAndFail("clean", ScoveragePlugin.getCHECK_NAME(),
-                ScoveragePlugin.getTEST_NAME(),
+                "test",
                 "--tests", "org.hello.a.TestNothingASuite",
                 "--tests", "org.hello.WorldSuite",
                 "--tests", "org.hello.b.WorldBSuite");
@@ -148,7 +148,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(), ScoveragePlugin.getTEST_NAME(),
+                ScoveragePlugin.getAGGREGATE_NAME(), "test",
                 "--tests", "org.hello.TestNothingSuite",
                 "--tests", "org.hello.a.WorldASuite",
                 "--tests", "org.hello.b.WorldBSuite");
@@ -169,7 +169,7 @@ public void checkAndAggregateScoverageWithoutCoverageInRoot() throws Exception {
     public void checkAndAggregateScoverageWithoutCoverageInAll() throws Exception {
 
         AssertableBuildResult result = runAndFail("clean", ScoveragePlugin.getCHECK_NAME(),
-                ScoveragePlugin.getAGGREGATE_NAME(), ScoveragePlugin.getTEST_NAME(),
+                ScoveragePlugin.getAGGREGATE_NAME(), "test",
                 "--tests", "org.hello.TestNothingSuite",
                 "--tests", "org.hello.a.TestNothingASuite",
                 "--tests", "org.hello.b.TestNothingBSuite");

src/functionalTest/java/org.scoverage/ScalaSingleModuleTest.java

@@ -15,7 +15,6 @@ public void test() {
         AssertableBuildResult result = dryRun("clean", "test");
 
         result.assertTaskDoesntExist(ScoveragePlugin.getCOMPILE_NAME());
-        result.assertTaskDoesntExist(ScoveragePlugin.getTEST_NAME());
         result.assertTaskDoesntExist(ScoveragePlugin.getREPORT_NAME());
         result.assertTaskDoesntExist(ScoveragePlugin.getAGGREGATE_NAME());
         result.assertTaskDoesntExist(ScoveragePlugin.getCHECK_NAME());
@@ -27,19 +26,6 @@ public void build() {
         AssertableBuildResult result = dryRun("clean", "build");
 
         result.assertTaskDoesntExist(ScoveragePlugin.getCOMPILE_NAME());
-        result.assertTaskDoesntExist(ScoveragePlugin.getTEST_NAME());
-        result.assertTaskDoesntExist(ScoveragePlugin.getREPORT_NAME());
-        result.assertTaskDoesntExist(ScoveragePlugin.getAGGREGATE_NAME());
-        result.assertTaskDoesntExist(ScoveragePlugin.getCHECK_NAME());
-    }
-
-    @Test
-    public void testScoverage() {
-
-        AssertableBuildResult result = dryRun("clean", ScoveragePlugin.getTEST_NAME());
-
-        result.assertTaskExists(ScoveragePlugin.getCOMPILE_NAME());
-        result.assertTaskExists(ScoveragePlugin.getTEST_NAME());
         result.assertTaskDoesntExist(ScoveragePlugin.getREPORT_NAME());
         result.assertTaskDoesntExist(ScoveragePlugin.getAGGREGATE_NAME());
         result.assertTaskDoesntExist(ScoveragePlugin.getCHECK_NAME());
@@ -51,7 +37,6 @@ public void reportScoverage() {
         AssertableBuildResult result = dryRun("clean", ScoveragePlugin.getREPORT_NAME());
 
         result.assertTaskExists(ScoveragePlugin.getCOMPILE_NAME());
-        result.assertTaskExists(ScoveragePlugin.getTEST_NAME());
         result.assertTaskExists(ScoveragePlugin.getREPORT_NAME());
         result.assertTaskDoesntExist(ScoveragePlugin.getAGGREGATE_NAME());
         result.assertTaskDoesntExist(ScoveragePlugin.getCHECK_NAME());
@@ -71,7 +56,6 @@ public void checkScoverage() throws Exception {
         AssertableBuildResult result = run("clean", ScoveragePlugin.getCHECK_NAME());
 
         result.assertTaskSucceeded(ScoveragePlugin.getCOMPILE_NAME());
-        result.assertTaskSucceeded(ScoveragePlugin.getTEST_NAME());
         result.assertTaskSucceeded(ScoveragePlugin.getREPORT_NAME());
         result.assertTaskSucceeded(ScoveragePlugin.getCHECK_NAME());
         result.assertTaskDoesntExist(ScoveragePlugin.getAGGREGATE_NAME());
@@ -84,10 +68,9 @@ public void checkScoverage() throws Exception {
     public void checkScoverageFails() throws Exception {
 
         AssertableBuildResult result = runAndFail("clean", ScoveragePlugin.getCHECK_NAME(),
-                ScoveragePlugin.getTEST_NAME(), "--tests", "org.hello.TestNothingSuite");
+                "test", "--tests", "org.hello.TestNothingSuite");
 
         result.assertTaskSucceeded(ScoveragePlugin.getCOMPILE_NAME());
-        result.assertTaskSucceeded(ScoveragePlugin.getTEST_NAME());
         result.assertTaskSucceeded(ScoveragePlugin.getREPORT_NAME());
         result.assertTaskFailed(ScoveragePlugin.getCHECK_NAME());
         result.assertTaskDoesntExist(ScoveragePlugin.getAGGREGATE_NAME());

src/main/groovy/org/scoverage/ScoveragePlugin.groovy

@@ -1,21 +1,16 @@
 package org.scoverage
 
-
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.invocation.Gradle
 import org.gradle.api.plugins.PluginAware
 import org.gradle.api.tasks.SourceSet
 import org.gradle.api.tasks.bundling.Jar
-import org.gradle.api.tasks.testing.Test
 import org.gradle.util.GFileUtils
 
-import java.util.concurrent.Callable
-
 class ScoveragePlugin implements Plugin<PluginAware> {
 
     static final String CONFIGURATION_NAME = 'scoverage'
-    static final String TEST_NAME = 'testScoverage'
     static final String REPORT_NAME = 'reportScoverage'
     static final String CHECK_NAME = 'checkScoverage'
     static final String COMPILE_NAME = 'compileScoverageScala'
@@ -80,17 +75,12 @@ class ScoveragePlugin implements Plugin<PluginAware> {
             }
         }
 
-        ScoverageRunner scoverageRunner = new ScoverageRunner(project.configurations.scoverage)
-
-        createTasks(project, extension, scoverageRunner)
-
-        project.afterEvaluate {
-            configureAfterEvaluation(project, extension, scoverageRunner)
-        }
+        createTasks(project, extension)
     }
 
-    private void createTasks(Project project, ScoverageExtension extension, ScoverageRunner scoverageRunner) {
+    private void createTasks(Project project, ScoverageExtension extension) {
 
+        ScoverageRunner scoverageRunner = new ScoverageRunner(project.configurations.scoverage)
 
         def instrumentedSourceSet = project.sourceSets.create('scoverage') {
             def original = project.sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME)
@@ -103,38 +93,20 @@ class ScoveragePlugin implements Plugin<PluginAware> {
             runtimeClasspath = it.output + project.configurations.scoverage + original.runtimeClasspath
         }
 
+        def compileTask = project.tasks[instrumentedSourceSet.getCompileTaskName("scala")]
+        project.test.mustRunAfter(compileTask)
+
         def scoverageJar = project.tasks.create('jarScoverage', Jar.class) {
-            dependsOn('scoverageClasses')
+            dependsOn(instrumentedSourceSet.classesTaskName)
             classifier = CONFIGURATION_NAME
             from instrumentedSourceSet.output
         }
         project.artifacts {
             scoverage scoverageJar
         }
 
-        project.tasks.create(TEST_NAME, Test.class) {
-            conventionMapping.map("classpath", new Callable<Object>() {
-                Object call() throws Exception {
-                    def testSourceSet = project.sourceSets.getByName(SourceSet.TEST_SOURCE_SET_NAME)
-                    return testSourceSet.output +
-                            instrumentedSourceSet.output +
-                            project.configurations.scoverage +
-                            testSourceSet.runtimeClasspath
-                }
-            })
-            group = 'verification'
-
-            FilenameFilter measurementFile = new FilenameFilter() {
-                @Override
-                boolean accept(File dir, String name) {
-                    return name.startsWith("scoverage.measurements.")
-                }
-            }
-            outputs.upToDateWhen { extension.dataDir.get().listFiles(measurementFile) }
-        }
-
-        project.tasks.create(REPORT_NAME, ScoverageReport.class) {
-            dependsOn(project.tasks[TEST_NAME])
+        def reportTask = project.tasks.create(REPORT_NAME, ScoverageReport.class) {
+            dependsOn compileTask, project.test
             onlyIf { extension.dataDir.get().list() }
             group = 'verification'
             runner = scoverageRunner
@@ -148,58 +120,77 @@ class ScoveragePlugin implements Plugin<PluginAware> {
         }
 
         project.tasks.create(CHECK_NAME, OverallCheckTask.class) {
-            dependsOn(project.tasks[REPORT_NAME])
+            dependsOn(reportTask)
             group = 'verification'
             reportDir = extension.reportDir
         }
 
-    }
+        project.gradle.taskGraph.whenReady { graph ->
+            if (graph.hasTask(reportTask)) {
 
-    private void configureAfterEvaluation(Project project, ScoverageExtension extension, ScoverageRunner scoverageRunner) {
-
-        if (project.childProjects.size() > 0) {
-            def reportTasks = project.getAllprojects().collect { it.tasks.withType(ScoverageReport) }
-            def aggregationTask = project.tasks.create(AGGREGATE_NAME, ScoverageAggregate.class) {
-                dependsOn(reportTasks)
-                group = 'verification'
-                runner = scoverageRunner
-                reportDir = extension.reportDir
-                deleteReportsOnAggregation = extension.deleteReportsOnAggregation
-                coverageOutputCobertura = extension.coverageOutputCobertura
-                coverageOutputXML = extension.coverageOutputXML
-                coverageOutputHTML = extension.coverageOutputHTML
-                coverageDebug = extension.coverageDebug
+                project.test.configure {
+                    project.logger.debug("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) {
+                                return name.startsWith("scoverage.measurements.")
+                            }
+                        })
+                    }
+                }
             }
-            project.tasks[CHECK_NAME].mustRunAfter(aggregationTask)
         }
 
-        project.tasks[COMPILE_NAME].configure {
-            File pluginFile = project.configurations[CONFIGURATION_NAME].find {
-                it.name.startsWith("scalac-scoverage-plugin")
-            }
-            List<String> parameters = ['-Xplugin:' + pluginFile.absolutePath]
-            List<String> existingParameters = scalaCompileOptions.additionalParameters
-            if (existingParameters) {
-                parameters.addAll(existingParameters)
-            }
-            parameters.add("-P:scoverage:dataDir:${extension.dataDir.get().absolutePath}".toString())
-            if (extension.excludedPackages.get()) {
-                def packages = extension.excludedPackages.get().join(';')
-                parameters.add("-P:scoverage:excludedPackages:$packages".toString())
-            }
-            if (extension.excludedFiles.get()) {
-                def packages = extension.excludedFiles.get().join(';')
-                parameters.add("-P:scoverage:excludedFiles:$packages".toString())
-            }
-            if (extension.highlighting.get()) {
-                parameters.add('-Yrangepos')
+        project.afterEvaluate {
+
+            if (project.childProjects.size() > 0) {
+                def reportTasks = project.getAllprojects().collect { it.tasks.withType(ScoverageReport) }
+                def aggregationTask = project.tasks.create(AGGREGATE_NAME, ScoverageAggregate.class) {
+                    dependsOn(reportTasks)
+                    group = 'verification'
+                    runner = scoverageRunner
+                    reportDir = extension.reportDir
+                    deleteReportsOnAggregation = extension.deleteReportsOnAggregation
+                    coverageOutputCobertura = extension.coverageOutputCobertura
+                    coverageOutputXML = extension.coverageOutputXML
+                    coverageOutputHTML = extension.coverageOutputHTML
+                    coverageDebug = extension.coverageDebug
+                }
+                project.tasks[CHECK_NAME].mustRunAfter(aggregationTask)
             }
-            doFirst {
-                GFileUtils.deleteDirectory(destinationDir)
+
+            compileTask.configure {
+                File pluginFile = project.configurations[CONFIGURATION_NAME].find {
+                    it.name.startsWith("scalac-scoverage-plugin")
+                }
+                List<String> parameters = ['-Xplugin:' + pluginFile.absolutePath]
+                List<String> existingParameters = scalaCompileOptions.additionalParameters
+                if (existingParameters) {
+                    parameters.addAll(existingParameters)
+                }
+                parameters.add("-P:scoverage:dataDir:${extension.dataDir.get().absolutePath}".toString())
+                if (extension.excludedPackages.get()) {
+                    def packages = extension.excludedPackages.get().join(';')
+                    parameters.add("-P:scoverage:excludedPackages:$packages".toString())
+                }
+                if (extension.excludedFiles.get()) {
+                    def packages = extension.excludedFiles.get().join(';')
+                    parameters.add("-P:scoverage:excludedFiles:$packages".toString())
+                }
+                if (extension.highlighting.get()) {
+                    parameters.add('-Yrangepos')
+                }
+                doFirst {
+                    GFileUtils.deleteDirectory(destinationDir)
+                }
+                scalaCompileOptions.additionalParameters = parameters
+                // the compile task creates a store of measured statements
+                outputs.file(new File(extension.dataDir.get(), 'scoverage.coverage.xml'))
             }
-            scalaCompileOptions.additionalParameters = parameters
-            // the compile task creates a store of measured statements
-            outputs.file(new File(extension.dataDir.get(), 'scoverage.coverage.xml'))
         }
     }
 }