diff --git a/build.gradle b/build.gradle index 56c261c..0cebe0f 100644 --- a/build.gradle +++ b/build.gradle @@ -41,8 +41,8 @@ pluginBundle { apply plugin: 'maven' apply plugin: 'groovy' -sourceCompatibility = '1.6' -targetCompatibility = '1.6' +sourceCompatibility = '1.8' +targetCompatibility = '1.8' dependencies { compileOnly "org.scoverage:scalac-scoverage-plugin_2.12:1.3.1" diff --git a/src/functionalTest/java/org.scoverage/ScalaSingleModuleWithMultipleTestTasksTest.java b/src/functionalTest/java/org.scoverage/ScalaSingleModuleWithMultipleTestTasksTest.java new file mode 100644 index 0000000..3d09d61 --- /dev/null +++ b/src/functionalTest/java/org.scoverage/ScalaSingleModuleWithMultipleTestTasksTest.java @@ -0,0 +1,160 @@ +package org.scoverage; + +import org.junit.Assert; +import org.junit.Test; + +public class ScalaSingleModuleWithMultipleTestTasksTest extends ScoverageFunctionalTest { + public ScalaSingleModuleWithMultipleTestTasksTest() { + super("scala-single-module-multiple-test-tasks"); + } + + @Test + public void test() { + + AssertableBuildResult result = dryRun("clean", "test"); + + result.assertTaskDoesntExist(ScoveragePlugin.getCOMPILE_NAME()); + result.assertTaskDoesntExist(ScoveragePlugin.getREPORT_NAME()); + result.assertTaskDoesntExist(ScoveragePlugin.getAGGREGATE_NAME()); + result.assertTaskDoesntExist(ScoveragePlugin.getCHECK_NAME()); + } + + @Test + public void build() { + + AssertableBuildResult result = dryRun("clean", "build"); + + result.assertTaskDoesntExist(ScoveragePlugin.getCOMPILE_NAME()); + result.assertTaskDoesntExist(ScoveragePlugin.getREPORT_NAME()); + result.assertTaskDoesntExist(ScoveragePlugin.getAGGREGATE_NAME()); + result.assertTaskDoesntExist(ScoveragePlugin.getCHECK_NAME()); + } + + @Test + public void reportScoverage() { + + AssertableBuildResult result = dryRun("clean", ScoveragePlugin.getREPORT_NAME()); + + result.assertTaskExists(ScoveragePlugin.getCOMPILE_NAME()); + result.assertTaskExists(ScoveragePlugin.getREPORT_NAME()); + result.assertTaskDoesntExist(ScoveragePlugin.getAGGREGATE_NAME()); + result.assertTaskDoesntExist(ScoveragePlugin.getCHECK_NAME()); + } + + @Test + public void aggregateScoverage() { + + AssertableBuildResult result = runAndFail("clean", ScoveragePlugin.getAGGREGATE_NAME()); + + result.assertNoTasks(); + } + + + @Test + public void checkScoverage() throws Exception { + + AssertableBuildResult result = run("clean", ScoveragePlugin.getCHECK_NAME()); + + result.assertTaskSucceeded(ScoveragePlugin.getCOMPILE_NAME()); + result.assertTaskSucceeded("reportTestScoverage"); + result.assertTaskSucceeded("reportIntTestScoverage"); + result.assertTaskSucceeded(ScoveragePlugin.getREPORT_NAME()); + result.assertTaskSucceeded(ScoveragePlugin.getCHECK_NAME()); + result.assertTaskDoesntExist(ScoveragePlugin.getAGGREGATE_NAME()); + + assertReportFilesExist(); + assertCoverage(100.0); + } + + @Test + public void checkScoverageIntTest() throws Exception { + AssertableBuildResult result = runAndFail("clean", "-x", "reportTestScoverage", ScoveragePlugin.getCHECK_NAME()); + + result.assertTaskSucceeded(ScoveragePlugin.getCOMPILE_NAME()); + result.assertTaskDoesntExist("reportTestScoverage"); + result.assertTaskSucceeded("reportIntTestScoverage"); + result.assertTaskSucceeded(ScoveragePlugin.getREPORT_NAME()); + result.assertTaskFailed(ScoveragePlugin.getCHECK_NAME()); + result.assertTaskDoesntExist(ScoveragePlugin.getAGGREGATE_NAME()); + + assertReportFilesExist(); + assertCoverage(50.0); + } + + + @Test + public void checkScoverageFails() throws Exception { + + AssertableBuildResult result = runAndFail("clean", ScoveragePlugin.getCHECK_NAME(), + "intTest", "--tests", "org.hello.TestNothingSuite", + "-x", "test"); + + result.assertTaskSucceeded(ScoveragePlugin.getCOMPILE_NAME()); + result.assertTaskSucceeded(ScoveragePlugin.getREPORT_NAME()); + result.assertTaskFailed(ScoveragePlugin.getCHECK_NAME()); + result.assertTaskDoesntExist(ScoveragePlugin.getAGGREGATE_NAME()); + + assertReportFilesExist(); + assertCoverage(0.0); + } + + @Test + public void reportScoverageWithExcludedClasses() throws Exception { + + AssertableBuildResult result = run("clean", "-PexcludedFile=.*", ScoveragePlugin.getREPORT_NAME()); + + result.assertTaskSucceeded(ScoveragePlugin.getCOMPILE_NAME()); + result.assertTaskSucceeded(ScoveragePlugin.getREPORT_NAME()); + result.assertTaskDoesntExist(ScoveragePlugin.getCHECK_NAME()); + result.assertTaskDoesntExist(ScoveragePlugin.getAGGREGATE_NAME()); + + Assert.assertTrue(resolve(reportDir(), "index.html").exists()); + Assert.assertFalse(resolve(reportDir(), "src/main/scala/org/hello/World.scala.html").exists()); + assertCoverage(100.0); // coverage is 100 since no classes are covered + + // compiled class should exist in the default classes directory, but not in scoverage + Assert.assertTrue(resolve(buildDir(), "classes/scala/main/org/hello/World.class").exists()); + Assert.assertFalse(resolve(buildDir(), "classes/scala/scoverage/org/hello/World.class").exists()); + } + + @Test + public void reportScoverageWithoutNormalCompilation() throws Exception { + + AssertableBuildResult result = run("clean", ScoveragePlugin.getREPORT_NAME(), + "-x", "compileScala"); + + result.assertTaskSkipped("compileScala"); + result.assertTaskSucceeded(ScoveragePlugin.getCOMPILE_NAME()); + result.assertTaskSucceeded(ScoveragePlugin.getREPORT_NAME()); + result.assertTaskDoesntExist(ScoveragePlugin.getCHECK_NAME()); + result.assertTaskDoesntExist(ScoveragePlugin.getAGGREGATE_NAME()); + + assertReportFilesExist(); + assertCoverage(100.0); + + Assert.assertTrue(resolve(buildDir(), "classes/scala/main/org/hello/World.class").exists()); + Assert.assertFalse(resolve(buildDir(), "classes/scala/scoverage/org/hello/World.class").exists()); + } + + @Test + public void reportScoverageWithoutNormalCompilationAndWithExcludedClasses() throws Exception { + + AssertableBuildResult result = run("clean", ScoveragePlugin.getREPORT_NAME(), + "-PexcludedFile=.*", "-x", "compileScala"); + + Assert.assertTrue(resolve(reportDir(), "index.html").exists()); + Assert.assertFalse(resolve(reportDir(), "src/main/scala/org/hello/World.scala.html").exists()); + assertCoverage(100.0); // coverage is 100 since no classes are covered + + // compiled class should exist in the default classes directory, but not in scoverage + Assert.assertTrue(resolve(buildDir(), "classes/scala/main/org/hello/World.class").exists()); + Assert.assertFalse(resolve(buildDir(), "classes/scala/scoverage/org/hello/World.class").exists()); + } + + + private void assertReportFilesExist() { + + Assert.assertTrue(resolve(reportDir(), "index.html").exists()); + Assert.assertTrue(resolve(reportDir(), "src/main/scala/org/hello/World.scala.html").exists()); + } +} diff --git a/src/functionalTest/resources/projects/scala-single-module-multiple-test-tasks/build.gradle b/src/functionalTest/resources/projects/scala-single-module-multiple-test-tasks/build.gradle new file mode 100644 index 0000000..c0e0e6d --- /dev/null +++ b/src/functionalTest/resources/projects/scala-single-module-multiple-test-tasks/build.gradle @@ -0,0 +1,74 @@ +plugins { + id 'io.spring.dependency-management' version "1.0.4.RELEASE" + id 'org.scoverage' +} + +repositories { + jcenter() +} + +description = 'a single-module Scala project with dependency manager that builds successfully with 100% coverage' + +apply plugin: 'scala' + + +dependencyManagement { + dependencies { + dependency group: 'org.scala-lang', name: 'scala-library', version: "${scalaVersionMajor}.${scalaVersionMinor}.${scalaVersionBuild}" + } +} + +dependencies { + compile group: 'org.scala-lang', name: 'scala-library' + + // scala compilation with the dependency management plugin needs this (otherwise compilation will fail) + zinc group: 'com.typesafe.zinc', name: 'zinc', version: '0.3.15' + zinc group: 'org.scala-lang', name: 'scala-library', version: '2.10.5' + + testRuntime group: 'org.junit.vintage', name: 'junit-vintage-engine', version: junitVersion + testCompile group: 'org.junit.platform', name: 'junit-platform-runner', version: junitPlatformVersion + + testCompile group: 'org.scalatest', name: "scalatest_${scalaVersionMajor}.${scalaVersionMinor}", version: scalatestVersion +} + +test { + useJUnitPlatform() +} + + +configurations { + intTestCompile.extendsFrom testCompile + intTestRuntime.extendsFrom testRuntime +} +sourceSets { + intTest { + resources.srcDir file('src/intTest/resources') + scala { + compileClasspath += main.output + test.output + runtimeClasspath += main.output + test.output + srcDir file("${projectDir}/src/intTest/scala") + } + } +} + +test { + maxParallelForks = 1 +} + +task intTest(type: Test) { + testClassesDirs = sourceSets.intTest.output.classesDirs + classpath = sourceSets.intTest.runtimeClasspath + outputs.upToDateWhen { false } + + maxParallelForks = 1 +} +check.dependsOn(intTest) +intTest.mustRunAfter(test) + +scoverage { + minimumRate = 0.6 +} + +if (hasProperty("excludedFile")) { + scoverage.excludedFiles = [excludedFile] +} diff --git a/src/functionalTest/resources/projects/scala-single-module-multiple-test-tasks/settings.gradle b/src/functionalTest/resources/projects/scala-single-module-multiple-test-tasks/settings.gradle new file mode 100644 index 0000000..e69de29 diff --git a/src/functionalTest/resources/projects/scala-single-module-multiple-test-tasks/src/intTest/scala/org/hello/TestNothingSuite.scala b/src/functionalTest/resources/projects/scala-single-module-multiple-test-tasks/src/intTest/scala/org/hello/TestNothingSuite.scala new file mode 100644 index 0000000..1ac25b5 --- /dev/null +++ b/src/functionalTest/resources/projects/scala-single-module-multiple-test-tasks/src/intTest/scala/org/hello/TestNothingSuite.scala @@ -0,0 +1,12 @@ +package org.hello + +import org.junit.runner.RunWith +import org.scalatest.FunSuite +import org.scalatest.junit.JUnitRunner + +@RunWith(classOf[JUnitRunner]) +class TestNothingSuite extends FunSuite { + + test("nothing") { + } +} \ No newline at end of file diff --git a/src/functionalTest/resources/projects/scala-single-module-multiple-test-tasks/src/intTest/scala/org/hello/WorldIntSuite.scala b/src/functionalTest/resources/projects/scala-single-module-multiple-test-tasks/src/intTest/scala/org/hello/WorldIntSuite.scala new file mode 100644 index 0000000..31458d8 --- /dev/null +++ b/src/functionalTest/resources/projects/scala-single-module-multiple-test-tasks/src/intTest/scala/org/hello/WorldIntSuite.scala @@ -0,0 +1,13 @@ +package org.hello + +import org.junit.runner.RunWith +import org.scalatest.FunSuite +import org.scalatest.junit.JUnitRunner + +@RunWith(classOf[JUnitRunner]) +class WorldIntSuite extends FunSuite { + + test("bar") { + new World().bar() + } +} \ No newline at end of file diff --git a/src/functionalTest/resources/projects/scala-single-module-multiple-test-tasks/src/main/scala/org/hello/World.scala b/src/functionalTest/resources/projects/scala-single-module-multiple-test-tasks/src/main/scala/org/hello/World.scala new file mode 100644 index 0000000..c9edf98 --- /dev/null +++ b/src/functionalTest/resources/projects/scala-single-module-multiple-test-tasks/src/main/scala/org/hello/World.scala @@ -0,0 +1,11 @@ +package org.hello + +class World { + + def foo(): String = { + val s = "a" + "b" + s + } + + def bar(): String = "bar" +} \ No newline at end of file diff --git a/src/functionalTest/resources/projects/scala-single-module-multiple-test-tasks/src/test/scala/org/hello/WorldSuite.scala b/src/functionalTest/resources/projects/scala-single-module-multiple-test-tasks/src/test/scala/org/hello/WorldSuite.scala new file mode 100644 index 0000000..7281a12 --- /dev/null +++ b/src/functionalTest/resources/projects/scala-single-module-multiple-test-tasks/src/test/scala/org/hello/WorldSuite.scala @@ -0,0 +1,13 @@ +package org.hello + +import org.junit.runner.RunWith +import org.scalatest.FunSuite +import org.scalatest.junit.JUnitRunner + +@RunWith(classOf[JUnitRunner]) +class WorldSuite extends FunSuite { + + test("foo") { + new World().foo() + } +} \ No newline at end of file diff --git a/src/main/groovy/org/scoverage/OverallCheckTask.groovy b/src/main/groovy/org/scoverage/OverallCheckTask.groovy index 6c3687f..da83c12 100644 --- a/src/main/groovy/org/scoverage/OverallCheckTask.groovy +++ b/src/main/groovy/org/scoverage/OverallCheckTask.groovy @@ -1,6 +1,5 @@ package org.scoverage -import org.apache.tools.ant.taskdefs.Local import org.gradle.api.DefaultTask import org.gradle.api.GradleException import org.gradle.api.provider.Property @@ -69,12 +68,12 @@ class OverallCheckTask extends DefaultTask { @VisibleForTesting protected static String errorMsg(String actual, String expected, CoverageType type) { - return "Only $actual% of project is covered by tests instead of $expected% (coverageType: $type)" + "Only $actual% of project is covered by tests instead of $expected% (coverageType: $type)" } @VisibleForTesting protected static String fileNotFoundErrorMsg(CoverageType coverageType) { - return "Coverage file (type: $coverageType) not found, check your configuration." + "Coverage file (type: $coverageType) not found, check your configuration." } @VisibleForTesting @@ -100,6 +99,6 @@ class OverallCheckTask extends DefaultTask { } catch (FileNotFoundException fnfe) { return new GradleException(fileNotFoundErrorMsg(coverageType), fnfe) } - return null + null } } diff --git a/src/main/groovy/org/scoverage/ScoverageAggregate.groovy b/src/main/groovy/org/scoverage/ScoverageAggregate.groovy index 43abd73..89de7de 100644 --- a/src/main/groovy/org/scoverage/ScoverageAggregate.groovy +++ b/src/main/groovy/org/scoverage/ScoverageAggregate.groovy @@ -1,10 +1,13 @@ 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.Input import org.gradle.api.tasks.OutputDirectory import org.gradle.api.tasks.TaskAction +import scala.collection.JavaConverters +import scoverage.IOUtils import scoverage.report.CoverageAggregator class ScoverageAggregate extends DefaultTask { @@ -14,6 +17,9 @@ class ScoverageAggregate extends DefaultTask { @OutputDirectory final Property reportDir = project.objects.property(File) + @Input + final ListProperty dirsToAggregateFrom = project.objects.listProperty(File) + @Input final Property deleteReportsOnAggregation = project.objects.property(Boolean) @@ -27,12 +33,24 @@ class ScoverageAggregate extends DefaultTask { @Input final Property coverageDebug = project.objects.property(Boolean) + ScoverageAggregate() { + dirsToAggregateFrom.set([]) + } + @TaskAction def aggregate() { runner.run { def rootDir = project.projectDir - def coverage = CoverageAggregator.aggregate(rootDir, deleteReportsOnAggregation.get()) + def coverage + if (dirsToAggregateFrom.get().isEmpty()) { + coverage = CoverageAggregator.aggregate(rootDir, deleteReportsOnAggregation.get()) + } else { + def reportFiles = dirsToAggregateFrom.get().collectMany { + JavaConverters.seqAsJavaList(IOUtils.reportFileSearch(it, IOUtils.isReportFile())) + } + coverage = CoverageAggregator.aggregate(JavaConverters.asScalaBuffer(reportFiles), deleteReportsOnAggregation.get()) + } reportDir.get().deleteDir() diff --git a/src/main/groovy/org/scoverage/ScoveragePlugin.groovy b/src/main/groovy/org/scoverage/ScoveragePlugin.groovy index 7c6ac63..6f04391 100644 --- a/src/main/groovy/org/scoverage/ScoveragePlugin.groovy +++ b/src/main/groovy/org/scoverage/ScoveragePlugin.groovy @@ -8,6 +8,7 @@ import org.gradle.api.invocation.Gradle import org.gradle.api.plugins.PluginAware import org.gradle.api.tasks.SourceSet import org.gradle.api.tasks.scala.ScalaCompile +import org.gradle.api.tasks.testing.Test import java.nio.file.Files @@ -112,39 +113,73 @@ class ScoveragePlugin implements Plugin { def compileTask = project.tasks[instrumentedSourceSet.getCompileTaskName("scala")] compileTask.mustRunAfter(originalCompileTask) - project.test.mustRunAfter(compileTask) originalJarTask.mustRunAfter(compileTask) - def reportTask = project.tasks.create(REPORT_NAME, ScoverageReport.class) { - dependsOn compileTask, project.test - onlyIf { extension.dataDir.get().list() } - group = 'verification' - runner = scoverageRunner - reportDir = extension.reportDir - sources = extension.sources - dataDir = extension.dataDir - coverageOutputCobertura = extension.coverageOutputCobertura - coverageOutputXML = extension.coverageOutputXML - coverageOutputHTML = extension.coverageOutputHTML - coverageDebug = extension.coverageDebug - } - - project.tasks.create(CHECK_NAME, OverallCheckTask.class) { - dependsOn(reportTask) - onlyIf { extension.reportDir.get().list() } - group = 'verification' - coverageType = extension.coverageType - minimumRate = extension.minimumRate - reportDir = extension.reportDir - } + def globalReportTask = project.tasks.register(REPORT_NAME, ScoverageAggregate) + def globalCheckTask = project.tasks.register(CHECK_NAME, OverallCheckTask) project.afterEvaluate { + def testTasks = project.tasks.withType(Test) + + List reportTasks = testTasks.collect { testTask -> + testTask.mustRunAfter(compileTask) + + def reportTaskName = "report${testTask.name.capitalize()}Scoverage" + def taskReportDir = project.file("${project.buildDir}/reports/scoverage${testTask.name.capitalize()}") + + project.tasks.create(reportTaskName, ScoverageReport) { + dependsOn compileTask, testTask + onlyIf { extension.dataDir.get().list() } + group = 'verification' + runner = scoverageRunner + reportDir = taskReportDir + sources = extension.sources + dataDir = extension.dataDir + coverageOutputCobertura = extension.coverageOutputCobertura + coverageOutputXML = extension.coverageOutputXML + coverageOutputHTML = extension.coverageOutputHTML + coverageDebug = extension.coverageDebug + } + } + + globalReportTask.configure { + def reportDirs = reportTasks.findResults { it.reportDir.get() } + + dependsOn reportTasks + onlyIf { reportDirs.any { it.list() } } + + group = 'verification' + runner = scoverageRunner + reportDir = extension.reportDir + dirsToAggregateFrom = reportDirs + deleteReportsOnAggregation = false + coverageOutputCobertura = extension.coverageOutputCobertura + coverageOutputXML = extension.coverageOutputXML + coverageOutputHTML = extension.coverageOutputHTML + coverageDebug = extension.coverageDebug + } + + + globalCheckTask.configure { + dependsOn globalReportTask + + onlyIf { extension.reportDir.get().list() } + group = 'verification' + coverageType = extension.coverageType + minimumRate = extension.minimumRate + reportDir = extension.reportDir + } // define aggregation task 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) + def allReportTasks = project.getAllprojects().findResults { + it.tasks.find { task -> + task.name == REPORT_NAME && task instanceof ScoverageAggregate + } + } + + def aggregationTask = project.tasks.create(AGGREGATE_NAME, ScoverageAggregate) { + dependsOn(allReportTasks) group = 'verification' runner = scoverageRunner reportDir = extension.reportDir @@ -168,8 +203,10 @@ class ScoveragePlugin implements Plugin { def dependencyProjectReportTask = it.project.tasks[REPORT_NAME] if (dependencyProjectCompileTask != null) { compileTask.dependsOn(dependencyProjectCompileTask) - // we don't want this project's test to affect the other project's report - project.test.mustRunAfter(dependencyProjectReportTask) + // we don't want this project's tests to affect the other project's report + testTasks.each { + it.mustRunAfter(dependencyProjectReportTask) + } } } @@ -198,68 +235,72 @@ class ScoveragePlugin implements Plugin { // the compile task creates a store of measured statements outputs.file(new File(extension.dataDir.get(), 'scoverage.coverage.xml')) } - } - project.gradle.taskGraph.whenReady { graph -> - if (graph.hasTask(reportTask)) { - project.test.configure { - project.logger.debug("Adding instrumented classes to '${path}' classpath") + project.gradle.taskGraph.whenReady { graph -> + def hasAnyReportTask = reportTasks.any { graph.hasTask(it) } - classpath = project.configurations.scoverage + instrumentedSourceSet.output + classpath + if (hasAnyReportTask) { + project.tasks.withType(Test).each { testTask -> + testTask.configure { + project.logger.info("Adding instrumented classes to '${path}' classpath") - outputs.upToDateWhen { - extension.dataDir.get().listFiles(new FilenameFilter() { - @Override - boolean accept(File dir, String name) { - return name.startsWith("scoverage.measurements.") - } - }) - } - } + classpath = project.configurations.scoverage + instrumentedSourceSet.output + classpath - compileTask.configure { - if (!graph.hasTask(originalCompileTask)) { - destinationDir = originalCompileTask.destinationDir - } else { - doFirst { - destinationDir.deleteDir() + outputs.upToDateWhen { + extension.dataDir.get().listFiles(new FilenameFilter() { + @Override + boolean accept(File dir, String name) { + name.startsWith("scoverage.measurements.") + } + }) + } } + } - // delete non-instrumented classes by comparing normally compiled classes to those compiled with scoverage - doLast { - def originalCompileTaskName = project.sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME) - .getCompileTaskName("scala") - def originalDestinationDir = project.tasks[originalCompileTaskName].destinationDir - - def findFiles = { File dir, Closure condition = null -> - def files = [] + compileTask.configure { + if (!graph.hasTask(originalCompileTask)) { + destinationDir = originalCompileTask.destinationDir + } else { + doFirst { + destinationDir.deleteDir() + } - if (dir.exists()) { - dir.eachFileRecurse(FILES) { f -> - if (condition == null || condition(f)) { - def relativePath = dir.relativePath(f) - files << relativePath + // delete non-instrumented classes by comparing normally compiled classes to those compiled with scoverage + doLast { + def originalCompileTaskName = project.sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME) + .getCompileTaskName("scala") + def originalDestinationDir = project.tasks[originalCompileTaskName].destinationDir + + 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 + } } } - } - return files - } + files + } - def isSameFile = { String relativePath -> - def fileA = new File(originalDestinationDir, relativePath) - def fileB = new File(destinationDir, relativePath) - return FileUtils.contentEquals(fileA, fileB) - } + 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) - return originalClasses.contains(relativePath) && isSameFile(relativePath) - }) + 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)) + identicalInstrumentedClasses.each { f -> + Files.deleteIfExists(destinationDir.toPath().resolve(f)) + } } } } @@ -271,7 +312,7 @@ class ScoveragePlugin implements Plugin { private Set recursiveDependenciesOf(Task task) { def directDependencies = task.getTaskDependencies().getDependencies(task) - def nestedDependencies = directDependencies.collect {recursiveDependenciesOf(it) }.flatten() - return directDependencies + nestedDependencies + def nestedDependencies = directDependencies.collect { recursiveDependenciesOf(it) }.flatten() + directDependencies + nestedDependencies } } \ No newline at end of file diff --git a/src/main/groovy/org/scoverage/ScoverageReport.groovy b/src/main/groovy/org/scoverage/ScoverageReport.groovy index e0d1d8b..252cd59 100644 --- a/src/main/groovy/org/scoverage/ScoverageReport.groovy +++ b/src/main/groovy/org/scoverage/ScoverageReport.groovy @@ -6,6 +6,7 @@ import org.gradle.api.tasks.CacheableTask import org.gradle.api.tasks.Input import org.gradle.api.tasks.OutputDirectory import org.gradle.api.tasks.TaskAction +import scala.collection.JavaConverters import scala.collection.Seq import scala.collection.Set import scoverage.Coverage @@ -46,8 +47,7 @@ class ScoverageReport extends DefaultTask { project.logger.info("[scoverage] Could not find coverage file, skipping...") } else { File[] array = IOUtils.findMeasurementFiles(dataDir.get()) - // TODO: patch scoverage core to use a consistent collection type? - Seq measurementFiles = scala.collection.JavaConversions.asScalaBuffer(Arrays.asList(array)) + Seq measurementFiles = JavaConverters.asScalaBuffer(Arrays.asList(array)) Coverage coverage = Serializer.deserialize(coverageFile)