diff --git a/.gitattributes b/.gitattributes index 2651806..2a8fb4d 100644 --- a/.gitattributes +++ b/.gitattributes @@ -4,3 +4,5 @@ *.groovy text eol=lf *.properties text eol=lf *.scala text eol=lf +*.kt text eol=lf +*.kts text eol=lf diff --git a/build.gradle b/build.gradle deleted file mode 100644 index 8e122bd..0000000 --- a/build.gradle +++ /dev/null @@ -1,211 +0,0 @@ -plugins { - id 'java-gradle-plugin' - id "com.gradle.plugin-publish" version "0.15.0" - id "org.jetbrains.gradle.plugin.idea-ext" version "1.0" -} - -repositories { - mavenCentral() -} - -group 'org.scoverage' -description = 'gradle-scoverage is a Gradle plugin for calculating code coverage using Scoverage' -if (project.version == 'unspecified') { - version = '7.0.0-SNAPSHOT' -} -ext { - website = 'http://scoverage.org' - vcsUrl = 'https://github.com/scoverage/gradle-scoverage.git' - scmUrl = "scm:git:$vcsUrl" - sonatypeUser = System.env.SONATYPE_USER - sonatypePass = System.env.SONATYPE_PASS -} - -gradlePlugin { - plugins { - gradleScoverage { - id = 'org.scoverage' - implementationClass = 'org.scoverage.ScoveragePlugin' - displayName = 'Gradle Scoverage plugin' - } - } -} - -pluginBundle { - website = project.website - vcsUrl = ext.vcsUrl - description = project.description - tags = ['coverage', 'scala', 'scoverage'] -} - -apply plugin: 'maven-publish' -apply plugin: 'groovy' - -sourceCompatibility = '1.8' -targetCompatibility = '1.8' - - -dependencies { - compileOnly "org.scoverage:scalac-scoverage-plugin_2.13:1.4.2" - implementation group: 'commons-io', name: 'commons-io', version: '2.6' - - testImplementation 'junit:junit:4.12' - testImplementation 'org.junit.jupiter:junit-jupiter-api:5.5.2' - testRuntimeOnly 'org.junit.vintage:junit-vintage-engine:5.5.2' - - testImplementation 'org.hamcrest:hamcrest:2.2' -} - -sourceSets { - functionalTest { - java.srcDir file('src/functionalTest/java') - compileClasspath += sourceSets.main.output - runtimeClasspath += sourceSets.main.output - } - crossScalaVersionTest { - java.srcDir file('src/crossScalaVersionTest/java') - compileClasspath += sourceSets.main.output + sourceSets.functionalTest.output - runtimeClasspath += sourceSets.main.output + sourceSets.functionalTest.output - } -} - -configurations { - functionalTestImplementation.extendsFrom testImplementation - functionalTestRuntimeOnly.extendsFrom testRuntimeOnly - - crossScalaVersionTestImplementation.extendsFrom testImplementation - crossScalaVersionTestRuntimeOnly.extendsFrom testRuntimeOnly -} - -task crossScalaVersionTest(type: Test) { - description = 'Runs the cross scala version functional test.' - group = 'verification' - testClassesDirs = sourceSets.crossScalaVersionTest.output - classpath = sourceSets.crossScalaVersionTest.runtimeClasspath - forkEvery = 1 // crucial to run every test in its own JVM - - testLogging { - events 'passed', 'failed', 'skipped' - showStandardStreams = System.env.CI == 'true' - } - - mustRunAfter test -} -check.dependsOn crossScalaVersionTest - -task functionalTest(type: Test) { - description = 'Runs the functional tests.' - group = 'verification' - testClassesDirs = sourceSets.functionalTest.output - classpath = sourceSets.functionalTest.runtimeClasspath - - testLogging { - events 'passed', 'failed', 'skipped' - showStandardStreams = System.env.CI == 'true' - } - - systemProperty 'failOnWarning', project.hasProperty('failOnWarning') - - mustRunAfter crossScalaVersionTest -} -check.dependsOn functionalTest - -gradlePlugin { - testSourceSets sourceSets.functionalTest, sourceSets.crossScalaVersionTest -} - -task groovydocJar(type: Jar, dependsOn: groovydoc) { - from "$buildDir/docs/groovydoc" - classifier 'groovydoc' -} - -task sourcesJar(type: Jar) { - from sourceSets.main.allSource - classifier 'sources' -} - -def propOrDefault(String property) { - if (project.hasProperty(property)) { - return project.getProperty(property) - } else { - return '' - } -} - -publishing { - repositories { - maven { - url = "https://oss.sonatype.org/service/local/staging/deploy/maven2/" - credentials(PasswordCredentials) { - username = propOrDefault('sonatypeUser') - password = propOrDefault('sonatypePass') - } - } - } - publications { - mavenJava(MavenPublication) { - pom { - name = 'GradleScoverage' - description = project.description - url = project.website - - scm { - url = scmUrl - developerConnection = scmUrl - } - - licenses { - license { - name = 'The Apache Software License, Version 2.0' - url = 'http://www.apache.org/licenses/LICENSE-2.0.txt' - distribution = 'repo' - } - } - - developers { - developer { - id = 'maiflai' - } - developer { - id = 'ubourdon' - } - developer { - id = 'D-Roch' - } - developer { - id = 'eyalroth' - } - } - } - from components.java - artifact groovydocJar - artifact sourcesJar - } - } -} - -if (project.properties.containsKey('signing.keyId')) { - apply plugin: 'signing' - signing { - sign publishing.publications.mavenJava - } -} - -// see https://stackoverflow.com/questions/44679007 -task fixIdeaPluginClasspath { - doFirst { - configure(tasks.pluginUnderTestMetadata) { - def ideaClassesPath = project.buildDir.toPath().resolveSibling("out").resolve("production") - def newClasspath = pluginClasspath as List - newClasspath.add(0, ideaClassesPath) - pluginClasspath.setFrom(newClasspath) - } - } -} -pluginUnderTestMetadata.mustRunAfter(fixIdeaPluginClasspath) - -idea.project.settings { - taskTriggers { - beforeBuild fixIdeaPluginClasspath, pluginUnderTestMetadata - } -} diff --git a/build.gradle.kts b/build.gradle.kts new file mode 100644 index 0000000..3d11830 --- /dev/null +++ b/build.gradle.kts @@ -0,0 +1,232 @@ +plugins { + `java-gradle-plugin` + `kotlin-dsl` + id("com.gradle.plugin-publish") version "0.15.0" + id("org.jetbrains.gradle.plugin.idea-ext") version "1.0" + id("org.jetbrains.dokka") version "1.5.30" +} + +repositories { + mavenCentral() +} + +group = "org.scoverage" +description = "gradle-scoverage is a Gradle plugin for calculating code coverage using Scoverage" +if (project.version == "unspecified") { + version = "7.0.0-SNAPSHOT" +} + +val website by extra("http://scoverage.org") +val vcsUrl by extra("https://github.com/scoverage/gradle-scoverage.git") +val scmUrl by extra("scm:git:$vcsUrl") +val sonatypeUser by extra(System.getenv("SONATYPE_USER")) +val sonatypePass by extra(System.getenv("SONATYPE_PASS")) + +gradlePlugin { + plugins { + create("gradleScoverage") { + id = "org.scoverage" + implementationClass = "org.scoverage.ScoveragePlugin" + displayName = "Gradle Scoverage plugin" + } + } +} + +pluginBundle { + website = website + vcsUrl = vcsUrl + description = project.description + tags = listOf("coverage", "scala", "scoverage") +} + +apply(plugin = "maven-publish") + +java { + sourceCompatibility = JavaVersion.VERSION_1_8 + targetCompatibility = JavaVersion.VERSION_1_8 +} + +dependencies { + compileOnly("org.scoverage:scalac-scoverage-plugin_2.13:1.4.2") + implementation(group = "commons-io", name = "commons-io", version = "2.6") + + implementation(kotlin("script-runtime")) + testImplementation(kotlin("test")) + + testImplementation("junit:junit:4.12") + testImplementation("org.junit.jupiter:junit-jupiter-api:5.5.2") + testRuntimeOnly("org.junit.vintage:junit-vintage-engine:5.5.2") + + testImplementation("org.hamcrest:hamcrest:2.2") +} + +sourceSets { + create("functionalTest") { + java.srcDir(file("src/functionalTest/java")) + compileClasspath += sourceSets["main"].output + runtimeClasspath += sourceSets["main"].output + } + create("crossScalaVersionTest") { + java.srcDir(file("src/crossScalaVersionTest/java")) + compileClasspath += sourceSets["main"].output + sourceSets["functionalTest"].output + runtimeClasspath += sourceSets["main"].output + sourceSets["functionalTest"].output + } +} + +configurations { + named("functionalTestImplementation") { + extendsFrom(configurations["testImplementation"]) + } + named("functionalTestRuntimeOnly") { + extendsFrom(configurations["testRuntimeOnly"]) + } + + named("crossScalaVersionTestImplementation") { + extendsFrom(configurations["testImplementation"]) + } + named("crossScalaVersionTestRuntimeOnly") { + extendsFrom(configurations["testRuntimeOnly"]) + } +} + +val crossScalaVersionTest by tasks.registering(Test::class) { + description = "Runs the cross scala version functional test." + group = "verification" + testClassesDirs = sourceSets["crossScalaVersionTest"].output + classpath = sourceSets["crossScalaVersionTest"].runtimeClasspath + setForkEvery(1) // crucial to run every test in its own JVM + + testLogging { + events("passed", "failed", "skipped") + showStandardStreams = System.getenv("CI") == "true" + } + + mustRunAfter(tasks["test"]) +} +tasks["check"].dependsOn(crossScalaVersionTest) + +val functionalTest by tasks.registering(Test::class) { + description = "Runs the functional tests." + group = "verification" + testClassesDirs = sourceSets["functionalTest"].output + classpath = sourceSets["functionalTest"].runtimeClasspath + + testLogging { + events("passed", "failed", "skipped") + showStandardStreams = System.getenv("CI") == "true" + } + + systemProperty("failOnWarning", project.hasProperty("failOnWarning")) + + mustRunAfter(crossScalaVersionTest) +} +tasks["check"].dependsOn(functionalTest) + +gradlePlugin { + testSourceSets(sourceSets["functionalTest"], sourceSets["crossScalaVersionTest"]) +} + +val kotlindocJar by tasks.registering(Jar::class) { + from(tasks.dokkaHtml.get().outputDirectory) + archiveClassifier.set("kotlindoc") + dependsOn(tasks.dokkaHtml) +} + +val sourcesJar by tasks.registering(Jar::class) { + from(sourceSets["main"].allSource) + archiveClassifier.set("sources") +} + +fun propOrDefault(property: String): String { + if (project.hasProperty(property)) { + return project.property(property).toString() + } else { + return "" + } +} + +configure { + repositories { + maven { + url = uri("https://oss.sonatype.org/service/local/staging/deploy/maven2/") + credentials { + username = propOrDefault("sonatypeUser") + password = propOrDefault("sonatypePass") + } + } + } + publications { + create("mavenJava") { + pom { + name.set("GradleScoverage") + description.set(description) + url.set(website) + + scm { + url.set(scmUrl) + developerConnection.set(scmUrl) + } + + licenses { + license { + name.set("The Apache Software License, Version 2.0") + url.set("http://www.apache.org/licenses/LICENSE-2.0.txt") + distribution.set("repo") + } + } + + developers { + developer { + id.set("maiflai") + } + developer { + id.set("ubourdon") + } + developer { + id.set("D-Roch") + } + developer { + id.set("eyalroth") + } + } + } + from(components["java"]) + artifact(kotlindocJar) + artifact(sourcesJar) + } + } +} + +if (project.properties.containsKey("signing.keyId")) { + apply(plugin = "signing") + configure { + sign(the().publications["mavenJava"]) + } +} + +// see https://stackoverflow.com/questions/44679007 +val fixIdeaPluginClasspath by tasks.registering { + doFirst { + tasks { + named("pluginUnderTestMetadata") { + val ideaClassesPath = project.buildDir.toPath().resolveSibling("out").resolve("production") + val newClasspath = pluginClasspath.toMutableList() + newClasspath.add(0, file(ideaClassesPath)) + pluginClasspath.setFrom(newClasspath) + } + } + } +} +tasks["pluginUnderTestMetadata"].mustRunAfter(fixIdeaPluginClasspath) + +idea { + project { + this as ExtensionAware + configure { + this as ExtensionAware + configure { + beforeBuild(fixIdeaPluginClasspath, tasks["pluginUnderTestMetadata"]) + } + } + } +} diff --git a/settings.gradle b/settings.gradle deleted file mode 100644 index e1ccb34..0000000 --- a/settings.gradle +++ /dev/null @@ -1 +0,0 @@ -rootProject.name='gradle-scoverage' \ No newline at end of file diff --git a/settings.gradle.kts b/settings.gradle.kts new file mode 100644 index 0000000..cd7f355 --- /dev/null +++ b/settings.gradle.kts @@ -0,0 +1 @@ +rootProject.name="gradle-scoverage" diff --git a/src/crossScalaVersionTest/java/org/scoverage/ScalaCrossVersionAggregationTest.java b/src/crossScalaVersionTest/java/org/scoverage/ScalaCrossVersionAggregationTest.java index a7b7e5b..84bb49a 100644 --- a/src/crossScalaVersionTest/java/org/scoverage/ScalaCrossVersionAggregationTest.java +++ b/src/crossScalaVersionTest/java/org/scoverage/ScalaCrossVersionAggregationTest.java @@ -12,16 +12,16 @@ public ScalaCrossVersionAggregationTest() { @Test public void checkAndAggregateAll() throws Exception { - AssertableBuildResult result = run("clean", ScoveragePlugin.getCHECK_NAME(), - ScoveragePlugin.getAGGREGATE_NAME()); - - result.assertTaskSkipped(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded("2_12:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded("2_13:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded(ScoveragePlugin.getCHECK_NAME()); - result.assertTaskSucceeded("2_12:" + ScoveragePlugin.getCHECK_NAME()); - result.assertTaskSucceeded("2_13:" + ScoveragePlugin.getCHECK_NAME()); - result.assertTaskSucceeded(ScoveragePlugin.getAGGREGATE_NAME()); + AssertableBuildResult result = run("clean", ScoveragePlugin.CHECK_NAME, + ScoveragePlugin.AGGREGATE_NAME); + + result.assertTaskSkipped(ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded("2_12:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded("2_13:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded(ScoveragePlugin.CHECK_NAME); + result.assertTaskSucceeded("2_12:" + ScoveragePlugin.CHECK_NAME); + result.assertTaskSucceeded("2_13:" + ScoveragePlugin.CHECK_NAME); + result.assertTaskSucceeded(ScoveragePlugin.AGGREGATE_NAME); assertAggregationFilesExist(); assertCoverage(100.0); diff --git a/src/crossScalaVersionTest/java/org/scoverage/ScalaVersionTest.java b/src/crossScalaVersionTest/java/org/scoverage/ScalaVersionTest.java index 657ca8e..aa46399 100644 --- a/src/crossScalaVersionTest/java/org/scoverage/ScalaVersionTest.java +++ b/src/crossScalaVersionTest/java/org/scoverage/ScalaVersionTest.java @@ -22,8 +22,8 @@ public ScalaVersionTest(String scalaVersion) { @Test public void report() throws Exception { - AssertableBuildResult result = run("clean", ":" + scalaVersion + ":" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded(scalaVersion + ":" + ScoveragePlugin.getREPORT_NAME()); + AssertableBuildResult result = run("clean", ":" + scalaVersion + ":" + ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded(scalaVersion + ":" + ScoveragePlugin.REPORT_NAME); File reportDir = reportDir(projectDir().toPath().resolve(scalaVersion).toFile()); Assert.assertTrue(resolve(reportDir, "index.html").exists()); diff --git a/src/functionalTest/java/org/scoverage/CompositeBuildTest.java b/src/functionalTest/java/org/scoverage/CompositeBuildTest.java index 21a5c6d..516920a 100644 --- a/src/functionalTest/java/org/scoverage/CompositeBuildTest.java +++ b/src/functionalTest/java/org/scoverage/CompositeBuildTest.java @@ -29,7 +29,7 @@ public void buildComposite() { @Test public void reportComposite() { - runComposite("clean", ScoveragePlugin.getREPORT_NAME()); + runComposite("clean", ScoveragePlugin.REPORT_NAME); } private AssertableBuildResult runComposite(String... arguments) { diff --git a/src/functionalTest/java/org/scoverage/DetectScalaLibraryTest.java b/src/functionalTest/java/org/scoverage/DetectScalaLibraryTest.java index 26383b4..1bc15ba 100644 --- a/src/functionalTest/java/org/scoverage/DetectScalaLibraryTest.java +++ b/src/functionalTest/java/org/scoverage/DetectScalaLibraryTest.java @@ -33,10 +33,10 @@ public class DetectScalaLibraryTest extends ScoverageFunctionalTest { @Parameterized.Parameters(name = "{index}: Project {0} ") public static Collection data() { Object[][] data = new Object[][]{ - {"/compile", new String[] {".0", ".+"}, true, new String[0]}, - {"/compileOnly", new String[] {".0", ".+"}, true, new String[0]}, - {"/implementation", new String[] {".0", ".+"}, true, new String[0]}, - {"/dependency-management", new String[] {".0", ".+"}, true, new String[0]}, + {"/compile", new String[]{".0", ".+"}, true, new String[0]}, + {"/compileOnly", new String[]{".0", ".+"}, true, new String[0]}, + {"/implementation", new String[]{".0", ".+"}, true, new String[0]}, + {"/dependency-management", new String[]{".0", ".+"}, true, new String[0]}, // disabled until the consistent-versions plugin supports Gradle 7 // {"/gradle-consistent-versions", new String[] {"ignored"}, false, new String[] {"--write-locks"}}, }; diff --git a/src/functionalTest/java/org/scoverage/MultiModulePluginNotConfiguredForScalaTest.java b/src/functionalTest/java/org/scoverage/MultiModulePluginNotConfiguredForScalaTest.java index c3fdffa..4a751ba 100644 --- a/src/functionalTest/java/org/scoverage/MultiModulePluginNotConfiguredForScalaTest.java +++ b/src/functionalTest/java/org/scoverage/MultiModulePluginNotConfiguredForScalaTest.java @@ -12,16 +12,16 @@ public MultiModulePluginNotConfiguredForScalaTest() { @Test public void checkAndAggregateScoverage() throws Exception { - AssertableBuildResult result = run("clean", ScoveragePlugin.getCHECK_NAME(), - ScoveragePlugin.getAGGREGATE_NAME()); - - result.assertTaskSkipped(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSkipped("scala_only:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSkipped("java_only:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSkipped(ScoveragePlugin.getCHECK_NAME()); - result.assertTaskSkipped("scala_only:" + ScoveragePlugin.getCHECK_NAME()); - result.assertTaskSkipped("java_only:" + ScoveragePlugin.getCHECK_NAME()); - result.assertTaskSkipped(ScoveragePlugin.getAGGREGATE_NAME()); + AssertableBuildResult result = run("clean", ScoveragePlugin.CHECK_NAME, + ScoveragePlugin.AGGREGATE_NAME); + + result.assertTaskSkipped(ScoveragePlugin.REPORT_NAME); + result.assertTaskSkipped("scala_only:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskSkipped("java_only:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskSkipped(ScoveragePlugin.CHECK_NAME); + result.assertTaskSkipped("scala_only:" + ScoveragePlugin.CHECK_NAME); + result.assertTaskSkipped("java_only:" + ScoveragePlugin.CHECK_NAME); + result.assertTaskSkipped(ScoveragePlugin.AGGREGATE_NAME); assertReportDirsEmpty(); diff --git a/src/functionalTest/java/org/scoverage/MultipleCheckTasksTest.java b/src/functionalTest/java/org/scoverage/MultipleCheckTasksTest.java index 0980c4e..5c5f31a 100644 --- a/src/functionalTest/java/org/scoverage/MultipleCheckTasksTest.java +++ b/src/functionalTest/java/org/scoverage/MultipleCheckTasksTest.java @@ -28,9 +28,9 @@ protected void assertOutput(AssertableBuildResult result, CoverageType type, dou private AssertableBuildResult run() { if (shouldSucceed) { - return run("clean", ScoveragePlugin.getCHECK_NAME(), "--info"); + return run("clean", ScoveragePlugin.CHECK_NAME, "--info"); } else { - return runAndFail(ScoveragePlugin.getCHECK_NAME(), "--info"); + return runAndFail(ScoveragePlugin.CHECK_NAME, "--info"); } } @@ -40,52 +40,61 @@ public static class MultipleChecks extends MultipleCheckTasksTest { public MultipleChecks() { super("multiple-checks", true); } + @Override protected void assertResult(AssertableBuildResult result) { - result.assertTaskSucceeded(ScoveragePlugin.getCHECK_NAME()); + result.assertTaskSucceeded(ScoveragePlugin.CHECK_NAME); assertOutput(result, CoverageType.Line, 0.3); assertOutput(result, CoverageType.Branch, 0.1); assertOutput(result, CoverageType.Statement, 0.6); } } + public static class SingleCheckNewSyntax extends MultipleCheckTasksTest { public SingleCheckNewSyntax() { super("single-check-new-syntax", true); } + @Override protected void assertResult(AssertableBuildResult result) { - result.assertTaskSucceeded(ScoveragePlugin.getCHECK_NAME()); + result.assertTaskSucceeded(ScoveragePlugin.CHECK_NAME); assertOutput(result, CoverageType.Line, 0.3); } } + public static class SingleCheckOldSyntax extends MultipleCheckTasksTest { public SingleCheckOldSyntax() { super("single-check-old-syntax", true); } + @Override protected void assertResult(AssertableBuildResult result) { - result.assertTaskSucceeded(ScoveragePlugin.getCHECK_NAME()); + result.assertTaskSucceeded(ScoveragePlugin.CHECK_NAME); assertOutput(result, CoverageType.Line, 0.3); } } + public static class OldAndNewSyntax extends MultipleCheckTasksTest { public OldAndNewSyntax() { super("old-and-new-syntax", false); } + @Override protected void assertResult(AssertableBuildResult result) { } } + public static class NoCheck extends MultipleCheckTasksTest { public NoCheck() { super("no-check", true); } + @Override protected void assertResult(AssertableBuildResult result) { - result.assertTaskSucceeded(ScoveragePlugin.getCHECK_NAME()); + result.assertTaskSucceeded(ScoveragePlugin.CHECK_NAME); assertOutput(result, ScoverageExtension.DEFAULT_COVERAGE_TYPE, ScoverageExtension.DEFAULT_MINIMUM_RATE); } } -} \ No newline at end of file +} diff --git a/src/functionalTest/java/org/scoverage/ScalaJavaAnnotationProcessorTest.java b/src/functionalTest/java/org/scoverage/ScalaJavaAnnotationProcessorTest.java index c4c2e38..00838a3 100644 --- a/src/functionalTest/java/org/scoverage/ScalaJavaAnnotationProcessorTest.java +++ b/src/functionalTest/java/org/scoverage/ScalaJavaAnnotationProcessorTest.java @@ -15,20 +15,20 @@ public ScalaJavaAnnotationProcessorTest() { @Test public void checkAndAggregateScoverage() throws Exception { - AssertableBuildResult result = run("clean", ScoveragePlugin.getCHECK_NAME(), - ScoveragePlugin.getAGGREGATE_NAME()); + AssertableBuildResult result = run("clean", ScoveragePlugin.CHECK_NAME, + ScoveragePlugin.AGGREGATE_NAME); - result.assertTaskSkipped("java_only:" + ScoveragePlugin.getCOMPILE_NAME()); + result.assertTaskSkipped("java_only:" + ScoveragePlugin.COMPILE_NAME); - result.assertTaskSkipped(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded("mixed_scala_java:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSkipped("java_only:" + ScoveragePlugin.getREPORT_NAME()); + result.assertTaskSkipped(ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded("mixed_scala_java:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskSkipped("java_only:" + ScoveragePlugin.REPORT_NAME); - result.assertTaskSucceeded(ScoveragePlugin.getCHECK_NAME()); - result.assertTaskSucceeded("mixed_scala_java:" + ScoveragePlugin.getCHECK_NAME()); - result.assertTaskSkipped("java_only:" + ScoveragePlugin.getCHECK_NAME()); + result.assertTaskSucceeded(ScoveragePlugin.CHECK_NAME); + result.assertTaskSucceeded("mixed_scala_java:" + ScoveragePlugin.CHECK_NAME); + result.assertTaskSkipped("java_only:" + ScoveragePlugin.CHECK_NAME); - result.assertTaskSucceeded(ScoveragePlugin.getAGGREGATE_NAME()); + result.assertTaskSucceeded(ScoveragePlugin.AGGREGATE_NAME); assertAllReportFilesExist(); assertCoverage(100.0); diff --git a/src/functionalTest/java/org/scoverage/ScalaJavaMultiModuleTest.java b/src/functionalTest/java/org/scoverage/ScalaJavaMultiModuleTest.java index 2b09933..9f283b3 100644 --- a/src/functionalTest/java/org/scoverage/ScalaJavaMultiModuleTest.java +++ b/src/functionalTest/java/org/scoverage/ScalaJavaMultiModuleTest.java @@ -14,22 +14,22 @@ public ScalaJavaMultiModuleTest() { @Test public void checkAndAggregateScoverage() throws Exception { - AssertableBuildResult result = run("clean", ScoveragePlugin.getCHECK_NAME(), - ScoveragePlugin.getAGGREGATE_NAME()); + AssertableBuildResult result = run("clean", ScoveragePlugin.CHECK_NAME, + ScoveragePlugin.AGGREGATE_NAME); - result.assertTaskSkipped("java_only:" + ScoveragePlugin.getCOMPILE_NAME()); + result.assertTaskSkipped("java_only:" + ScoveragePlugin.COMPILE_NAME); - result.assertTaskSkipped(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded("scala_only:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded("mixed_scala_java:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSkipped("java_only:" + ScoveragePlugin.getREPORT_NAME()); + result.assertTaskSkipped(ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded("scala_only:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded("mixed_scala_java:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskSkipped("java_only:" + ScoveragePlugin.REPORT_NAME); - result.assertTaskSucceeded(ScoveragePlugin.getCHECK_NAME()); - result.assertTaskSucceeded("scala_only:" + ScoveragePlugin.getCHECK_NAME()); - result.assertTaskSucceeded("mixed_scala_java:" + ScoveragePlugin.getCHECK_NAME()); - result.assertTaskSkipped("java_only:" + ScoveragePlugin.getCHECK_NAME()); + result.assertTaskSucceeded(ScoveragePlugin.CHECK_NAME); + result.assertTaskSucceeded("scala_only:" + ScoveragePlugin.CHECK_NAME); + result.assertTaskSucceeded("mixed_scala_java:" + ScoveragePlugin.CHECK_NAME); + result.assertTaskSkipped("java_only:" + ScoveragePlugin.CHECK_NAME); - result.assertTaskSucceeded(ScoveragePlugin.getAGGREGATE_NAME()); + result.assertTaskSucceeded(ScoveragePlugin.AGGREGATE_NAME); assertAllReportFilesExist(); assertCoverage(100.0); diff --git a/src/functionalTest/java/org/scoverage/ScalaMultiModuleTest.java b/src/functionalTest/java/org/scoverage/ScalaMultiModuleTest.java index 5da6f60..5482700 100644 --- a/src/functionalTest/java/org/scoverage/ScalaMultiModuleTest.java +++ b/src/functionalTest/java/org/scoverage/ScalaMultiModuleTest.java @@ -14,47 +14,47 @@ public ScalaMultiModuleTest() { @Test public void reportScoverage() { - AssertableBuildResult result = dryRun("clean", ScoveragePlugin.getREPORT_NAME()); + AssertableBuildResult result = dryRun("clean", ScoveragePlugin.REPORT_NAME); - result.assertTaskExists(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskExists("a:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskExists("b:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskExists("common:" + ScoveragePlugin.getREPORT_NAME()); + result.assertTaskExists(ScoveragePlugin.REPORT_NAME); + result.assertTaskExists("a:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskExists("b:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskExists("common:" + ScoveragePlugin.REPORT_NAME); } @Test public void reportScoverageParallel() { - AssertableBuildResult result = dryRun("clean", ScoveragePlugin.getREPORT_NAME(), "--parallel"); + AssertableBuildResult result = dryRun("clean", ScoveragePlugin.REPORT_NAME, "--parallel"); - result.assertTaskExists(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskExists("a:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskExists("b:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskExists("common:" + ScoveragePlugin.getREPORT_NAME()); + result.assertTaskExists(ScoveragePlugin.REPORT_NAME); + result.assertTaskExists("a:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskExists("b:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskExists("common:" + ScoveragePlugin.REPORT_NAME); } @Test public void reportScoverageOnlyRoot() { - AssertableBuildResult result = dryRun("clean", ":" + ScoveragePlugin.getREPORT_NAME()); + AssertableBuildResult result = dryRun("clean", ":" + ScoveragePlugin.REPORT_NAME); - result.assertTaskExists(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskDoesntExist("a:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskDoesntExist("b:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskDoesntExist("common:" + ScoveragePlugin.getREPORT_NAME()); + result.assertTaskExists(ScoveragePlugin.REPORT_NAME); + result.assertTaskDoesntExist("a:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskDoesntExist("b:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskDoesntExist("common:" + ScoveragePlugin.REPORT_NAME); } @Test public void reportScoverageOnlyA() { - AssertableBuildResult result = run("clean", ":a:" + ScoveragePlugin.getREPORT_NAME()); + AssertableBuildResult result = run("clean", ":a:" + ScoveragePlugin.REPORT_NAME); - result.assertTaskDoesntExist(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskDoesntExist("b:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskDoesntExist("common:" + ScoveragePlugin.getREPORT_NAME()); + result.assertTaskDoesntExist(ScoveragePlugin.REPORT_NAME); + result.assertTaskDoesntExist("b:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskDoesntExist("common:" + ScoveragePlugin.REPORT_NAME); - result.assertTaskSucceeded("a:" + ScoveragePlugin.getCOMPILE_NAME()); - result.assertTaskSucceeded("a:" + ScoveragePlugin.getREPORT_NAME()); + result.assertTaskSucceeded("a:" + ScoveragePlugin.COMPILE_NAME); + result.assertTaskSucceeded("a:" + ScoveragePlugin.REPORT_NAME); assertAReportFilesExist(); } @@ -62,15 +62,15 @@ public void reportScoverageOnlyA() { @Test public void reportScoverageOnlyAWithoutNormalCompilation() { - AssertableBuildResult result = run("clean", ":a:" + ScoveragePlugin.getREPORT_NAME(), - "-P" + ScoveragePlugin.getSCOVERAGE_COMPILE_ONLY_PROPERTY()); + AssertableBuildResult result = run("clean", ":a:" + ScoveragePlugin.REPORT_NAME, + "-P" + ScoveragePlugin.SCOVERAGE_COMPILE_ONLY_PROPERTY); result.assertTaskSkipped("compileScala"); result.assertTaskSkipped("a:compileScala"); result.assertTaskSkipped("common:compileScala"); - result.assertTaskSucceeded("common:" + ScoveragePlugin.getCOMPILE_NAME()); - result.assertTaskSucceeded("a:" + ScoveragePlugin.getCOMPILE_NAME()); - result.assertTaskSucceeded("a:" + ScoveragePlugin.getREPORT_NAME()); + result.assertTaskSucceeded("common:" + ScoveragePlugin.COMPILE_NAME); + result.assertTaskSucceeded("a:" + ScoveragePlugin.COMPILE_NAME); + result.assertTaskSucceeded("a:" + ScoveragePlugin.REPORT_NAME); assertAReportFilesExist(); @@ -84,76 +84,76 @@ public void reportScoverageOnlyAWithoutNormalCompilation() { @Test public void aggregateScoverage() { - AssertableBuildResult result = dryRun("clean", ScoveragePlugin.getAGGREGATE_NAME()); + AssertableBuildResult result = dryRun("clean", ScoveragePlugin.AGGREGATE_NAME); - result.assertTaskExists(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskExists("a:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskExists("b:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskExists(ScoveragePlugin.getAGGREGATE_NAME()); - result.assertTaskExists("common:" + ScoveragePlugin.getREPORT_NAME()); + result.assertTaskExists(ScoveragePlugin.REPORT_NAME); + result.assertTaskExists("a:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskExists("b:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskExists(ScoveragePlugin.AGGREGATE_NAME); + result.assertTaskExists("common:" + ScoveragePlugin.REPORT_NAME); } @Test public void checkScoverage() { - AssertableBuildResult result = dryRun("clean", ScoveragePlugin.getCHECK_NAME()); - - result.assertTaskExists(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskExists("a:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskExists("b:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskExists("common:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskExists(ScoveragePlugin.getCHECK_NAME()); - result.assertTaskExists("a:" + ScoveragePlugin.getCHECK_NAME()); - result.assertTaskExists("b:" + ScoveragePlugin.getCHECK_NAME()); - result.assertTaskExists("common:" + ScoveragePlugin.getCHECK_NAME()); - result.assertTaskDoesntExist(ScoveragePlugin.getAGGREGATE_NAME()); + AssertableBuildResult result = dryRun("clean", ScoveragePlugin.CHECK_NAME); + + result.assertTaskExists(ScoveragePlugin.REPORT_NAME); + result.assertTaskExists("a:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskExists("b:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskExists("common:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskExists(ScoveragePlugin.CHECK_NAME); + result.assertTaskExists("a:" + ScoveragePlugin.CHECK_NAME); + result.assertTaskExists("b:" + ScoveragePlugin.CHECK_NAME); + result.assertTaskExists("common:" + ScoveragePlugin.CHECK_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.AGGREGATE_NAME); } @Test public void checkScoverageOnlyRoot() { - AssertableBuildResult result = dryRun("clean", ":" + ScoveragePlugin.getCHECK_NAME()); + AssertableBuildResult result = dryRun("clean", ":" + ScoveragePlugin.CHECK_NAME); - result.assertTaskExists(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskDoesntExist("a:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskDoesntExist("b:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskExists(ScoveragePlugin.getCHECK_NAME()); - result.assertTaskDoesntExist("a:" + ScoveragePlugin.getCHECK_NAME()); - result.assertTaskDoesntExist("b:" + ScoveragePlugin.getCHECK_NAME()); - result.assertTaskDoesntExist(ScoveragePlugin.getAGGREGATE_NAME()); + result.assertTaskExists(ScoveragePlugin.REPORT_NAME); + result.assertTaskDoesntExist("a:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskDoesntExist("b:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskExists(ScoveragePlugin.CHECK_NAME); + result.assertTaskDoesntExist("a:" + ScoveragePlugin.CHECK_NAME); + result.assertTaskDoesntExist("b:" + ScoveragePlugin.CHECK_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.AGGREGATE_NAME); } @Test public void checkScoverageOnlyA() { - AssertableBuildResult result = dryRun("clean", ":a:" + ScoveragePlugin.getCHECK_NAME()); - - result.assertTaskDoesntExist(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskExists("a:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskDoesntExist("b:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskDoesntExist("common:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskDoesntExist(ScoveragePlugin.getCHECK_NAME()); - result.assertTaskExists("a:" + ScoveragePlugin.getCHECK_NAME()); - result.assertTaskDoesntExist("b:" + ScoveragePlugin.getCHECK_NAME()); - result.assertTaskDoesntExist("common:" + ScoveragePlugin.getCHECK_NAME()); - result.assertTaskDoesntExist(ScoveragePlugin.getAGGREGATE_NAME()); + AssertableBuildResult result = dryRun("clean", ":a:" + ScoveragePlugin.CHECK_NAME); + + result.assertTaskDoesntExist(ScoveragePlugin.REPORT_NAME); + result.assertTaskExists("a:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskDoesntExist("b:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskDoesntExist("common:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.CHECK_NAME); + result.assertTaskExists("a:" + ScoveragePlugin.CHECK_NAME); + result.assertTaskDoesntExist("b:" + ScoveragePlugin.CHECK_NAME); + result.assertTaskDoesntExist("common:" + ScoveragePlugin.CHECK_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.AGGREGATE_NAME); } @Test public void checkAndAggregateScoverage() throws Exception { - AssertableBuildResult result = run("clean", ScoveragePlugin.getCHECK_NAME(), - ScoveragePlugin.getAGGREGATE_NAME()); + AssertableBuildResult result = run("clean", ScoveragePlugin.CHECK_NAME, + ScoveragePlugin.AGGREGATE_NAME); - result.assertTaskSucceeded(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded("a:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded("b:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded("common:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded(ScoveragePlugin.getCHECK_NAME()); - result.assertTaskSucceeded("a:" + ScoveragePlugin.getCHECK_NAME()); - result.assertTaskSucceeded("b:" + ScoveragePlugin.getCHECK_NAME()); - result.assertTaskSucceeded("common:" + ScoveragePlugin.getCHECK_NAME()); - result.assertTaskSucceeded(ScoveragePlugin.getAGGREGATE_NAME()); + result.assertTaskSucceeded(ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded("a:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded("b:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded("common:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded(ScoveragePlugin.CHECK_NAME); + result.assertTaskSucceeded("a:" + ScoveragePlugin.CHECK_NAME); + result.assertTaskSucceeded("b:" + ScoveragePlugin.CHECK_NAME); + result.assertTaskSucceeded("common:" + ScoveragePlugin.CHECK_NAME); + result.assertTaskSucceeded(ScoveragePlugin.AGGREGATE_NAME); assertAllReportFilesExist(); assertCoverage(100.0); @@ -162,14 +162,14 @@ public void checkAndAggregateScoverage() throws Exception { @Test public void checkScoverageWithoutCoverageInRoot() throws Exception { - AssertableBuildResult result = runAndFail("clean", ScoveragePlugin.getCHECK_NAME(), + AssertableBuildResult result = runAndFail("clean", ScoveragePlugin.CHECK_NAME, "test", "--tests", "org.hello.TestNothingSuite", "--tests", "org.hello.a.WorldASuite", "--tests", "org.hello.b.WorldBSuite", "--tests", "org.hello.common.WorldCommonSuite"); - result.assertTaskFailed(ScoveragePlugin.getCHECK_NAME()); + result.assertTaskFailed(ScoveragePlugin.CHECK_NAME); assertRootReportFilesExist(); assertCoverage(0.0); @@ -178,14 +178,14 @@ public void checkScoverageWithoutCoverageInRoot() throws Exception { @Test public void checkScoverageWithoutCoverageInA() throws Exception { - AssertableBuildResult result = runAndFail("clean", ScoveragePlugin.getCHECK_NAME(), + AssertableBuildResult result = runAndFail("clean", ScoveragePlugin.CHECK_NAME, "test", "--tests", "org.hello.a.TestNothingASuite", "--tests", "org.hello.WorldSuite", "--tests", "org.hello.b.WorldBSuite", "--tests", "org.hello.common.WorldCommonSuite"); - result.assertTaskFailed("a:" + ScoveragePlugin.getCHECK_NAME()); + result.assertTaskFailed("a:" + ScoveragePlugin.CHECK_NAME); assertAReportFilesExist(); assertCoverage(0.0, reportDir(projectDir().toPath().resolve("a").toFile())); @@ -197,10 +197,10 @@ public void checkScoverageWithoutNormalCompilationAndWithoutCoverageInCommon() t AssertableBuildResult result = runAndFail("clean", ":a:test", ":common:test", "--tests", "org.hello.common.TestNothingCommonSuite", - "-P" + ScoveragePlugin.getSCOVERAGE_COMPILE_ONLY_PROPERTY(), - ScoveragePlugin.getCHECK_NAME()); + "-P" + ScoveragePlugin.SCOVERAGE_COMPILE_ONLY_PROPERTY, + ScoveragePlugin.CHECK_NAME); - result.assertTaskFailed("common:" + ScoveragePlugin.getCHECK_NAME()); + result.assertTaskFailed("common:" + ScoveragePlugin.CHECK_NAME); assertCommonReportFilesExist(); assertCoverage(0.0, reportDir(projectDir().toPath().resolve("common").toFile())); @@ -211,22 +211,22 @@ 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", + AssertableBuildResult result = run("clean", ScoveragePlugin.CHECK_NAME, + ScoveragePlugin.AGGREGATE_NAME, "test", "--tests", "org.hello.TestNothingSuite", "--tests", "org.hello.a.WorldASuite", "--tests", "org.hello.b.WorldBSuite", "--tests", "org.hello.common.WorldCommonSuite"); - result.assertTaskSucceeded(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded("a:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded("b:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded("common:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded(ScoveragePlugin.getCHECK_NAME()); - result.assertTaskSucceeded("a:" + ScoveragePlugin.getCHECK_NAME()); - result.assertTaskSucceeded("b:" + ScoveragePlugin.getCHECK_NAME()); - result.assertTaskSucceeded("common:" + ScoveragePlugin.getCHECK_NAME()); - result.assertTaskSucceeded(ScoveragePlugin.getAGGREGATE_NAME()); + result.assertTaskSucceeded(ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded("a:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded("b:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded("common:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded(ScoveragePlugin.CHECK_NAME); + result.assertTaskSucceeded("a:" + ScoveragePlugin.CHECK_NAME); + result.assertTaskSucceeded("b:" + ScoveragePlugin.CHECK_NAME); + result.assertTaskSucceeded("common:" + ScoveragePlugin.CHECK_NAME); + result.assertTaskSucceeded(ScoveragePlugin.AGGREGATE_NAME); assertAllReportFilesExist(); assertCoverage(87.5); @@ -235,19 +235,19 @@ public void checkAndAggregateScoverageWithoutCoverageInRoot() throws Exception { @Test public void checkAndAggregateScoverageWithoutCoverageInAll() throws Exception { - AssertableBuildResult result = runAndFail("clean", ScoveragePlugin.getCHECK_NAME(), - ScoveragePlugin.getAGGREGATE_NAME(), "test", + AssertableBuildResult result = runAndFail("clean", ScoveragePlugin.CHECK_NAME, + ScoveragePlugin.AGGREGATE_NAME, "test", "--tests", "org.hello.TestNothingSuite", "--tests", "org.hello.a.TestNothingASuite", "--tests", "org.hello.b.TestNothingBSuite", "--tests", "org.hello.common.TestNothingCommonSuite"); - result.assertTaskSucceeded(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded("a:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded("b:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded("common:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded(ScoveragePlugin.getAGGREGATE_NAME()); - result.assertTaskFailed(ScoveragePlugin.getCHECK_NAME()); + result.assertTaskSucceeded(ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded("a:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded("b:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded("common:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded(ScoveragePlugin.AGGREGATE_NAME); + result.assertTaskFailed(ScoveragePlugin.CHECK_NAME); assertAllReportFilesExist(); assertCoverage(0.0); @@ -256,22 +256,22 @@ public void checkAndAggregateScoverageWithoutCoverageInAll() throws Exception { @Test public void aggregateScoverageWithoutNormalCompilation() throws Exception { - AssertableBuildResult result = run("clean", ScoveragePlugin.getAGGREGATE_NAME(), - "-P" + ScoveragePlugin.getSCOVERAGE_COMPILE_ONLY_PROPERTY()); + AssertableBuildResult result = run("clean", ScoveragePlugin.AGGREGATE_NAME, + "-P" + ScoveragePlugin.SCOVERAGE_COMPILE_ONLY_PROPERTY); result.assertTaskSkipped("compileScala"); result.assertTaskSkipped("a:compileScala"); result.assertTaskSkipped("b:compileScala"); result.assertTaskSkipped("common:compileScala"); - result.assertTaskSucceeded(ScoveragePlugin.getCOMPILE_NAME()); - result.assertTaskSucceeded("a:" + ScoveragePlugin.getCOMPILE_NAME()); - result.assertTaskSucceeded("b:" + ScoveragePlugin.getCOMPILE_NAME()); - result.assertTaskSucceeded("common:" + ScoveragePlugin.getCOMPILE_NAME()); - result.assertTaskSucceeded(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded("a:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded("b:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded("common:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded(ScoveragePlugin.getAGGREGATE_NAME()); + result.assertTaskSucceeded(ScoveragePlugin.COMPILE_NAME); + result.assertTaskSucceeded("a:" + ScoveragePlugin.COMPILE_NAME); + result.assertTaskSucceeded("b:" + ScoveragePlugin.COMPILE_NAME); + result.assertTaskSucceeded("common:" + ScoveragePlugin.COMPILE_NAME); + result.assertTaskSucceeded(ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded("a:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded("b:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded("common:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded(ScoveragePlugin.AGGREGATE_NAME); assertAllReportFilesExist(); assertCoverage(100.0); diff --git a/src/functionalTest/java/org/scoverage/ScalaMultiModuleWithMultipleTestTasksTest.java b/src/functionalTest/java/org/scoverage/ScalaMultiModuleWithMultipleTestTasksTest.java index dc84e1f..26a5d0a 100644 --- a/src/functionalTest/java/org/scoverage/ScalaMultiModuleWithMultipleTestTasksTest.java +++ b/src/functionalTest/java/org/scoverage/ScalaMultiModuleWithMultipleTestTasksTest.java @@ -17,12 +17,12 @@ public ScalaMultiModuleWithMultipleTestTasksTest() { @Test public void reportScoverage() { - AssertableBuildResult result = dryRun("clean", ScoveragePlugin.getREPORT_NAME()); + AssertableBuildResult result = dryRun("clean", ScoveragePlugin.REPORT_NAME); - result.assertTaskExists(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskExists("a:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskExists("b:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskExists("common:" + ScoveragePlugin.getREPORT_NAME()); + result.assertTaskExists(ScoveragePlugin.REPORT_NAME); + result.assertTaskExists("a:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskExists("b:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskExists("common:" + ScoveragePlugin.REPORT_NAME); result.assertTaskExists("intTest"); result.assertTaskExists("reportIntTestScoverage"); result.assertTaskExists("a:intTest"); @@ -31,98 +31,98 @@ public void reportScoverage() { result.assertTaskExists("a:reportIntTestScoverage"); result.assertTaskExists("b:reportIntTestScoverage"); result.assertTaskExists("common:reportIntTestScoverage"); - result.assertTaskExists(ScoveragePlugin.getREPORT_NAME()); + result.assertTaskExists(ScoveragePlugin.REPORT_NAME); } @Test public void reportScoverageOnlyRoot() { - AssertableBuildResult result = dryRun("clean", ":" + ScoveragePlugin.getREPORT_NAME()); + AssertableBuildResult result = dryRun("clean", ":" + ScoveragePlugin.REPORT_NAME); - result.assertTaskExists(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskDoesntExist("a:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskDoesntExist("b:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskDoesntExist("common:" + ScoveragePlugin.getREPORT_NAME()); + result.assertTaskExists(ScoveragePlugin.REPORT_NAME); + result.assertTaskDoesntExist("a:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskDoesntExist("b:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskDoesntExist("common:" + ScoveragePlugin.REPORT_NAME); } @Test public void reportScoverageOnlyA() { - AssertableBuildResult result = dryRun("clean", ":a:" + ScoveragePlugin.getREPORT_NAME()); + AssertableBuildResult result = dryRun("clean", ":a:" + ScoveragePlugin.REPORT_NAME); - result.assertTaskDoesntExist(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskExists("a:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskDoesntExist("b:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskDoesntExist("common:" + ScoveragePlugin.getREPORT_NAME()); + result.assertTaskDoesntExist(ScoveragePlugin.REPORT_NAME); + result.assertTaskExists("a:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskDoesntExist("b:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskDoesntExist("common:" + ScoveragePlugin.REPORT_NAME); } @Test public void aggregateScoverage() { - AssertableBuildResult result = dryRun("clean", ScoveragePlugin.getAGGREGATE_NAME()); + AssertableBuildResult result = dryRun("clean", ScoveragePlugin.AGGREGATE_NAME); - result.assertTaskExists(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskExists("a:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskExists("b:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskExists(ScoveragePlugin.getAGGREGATE_NAME()); - result.assertTaskExists("common:" + ScoveragePlugin.getREPORT_NAME()); + result.assertTaskExists(ScoveragePlugin.REPORT_NAME); + result.assertTaskExists("a:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskExists("b:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskExists(ScoveragePlugin.AGGREGATE_NAME); + result.assertTaskExists("common:" + ScoveragePlugin.REPORT_NAME); } @Test public void checkScoverage() { - AssertableBuildResult result = dryRun("clean", ScoveragePlugin.getCHECK_NAME()); - - result.assertTaskExists(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskExists("a:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskExists("b:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskExists("common:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskExists(ScoveragePlugin.getCHECK_NAME()); - result.assertTaskExists("a:" + ScoveragePlugin.getCHECK_NAME()); - result.assertTaskExists("b:" + ScoveragePlugin.getCHECK_NAME()); - result.assertTaskExists("common:" + ScoveragePlugin.getCHECK_NAME()); - result.assertTaskDoesntExist(ScoveragePlugin.getAGGREGATE_NAME()); + AssertableBuildResult result = dryRun("clean", ScoveragePlugin.CHECK_NAME); + + result.assertTaskExists(ScoveragePlugin.REPORT_NAME); + result.assertTaskExists("a:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskExists("b:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskExists("common:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskExists(ScoveragePlugin.CHECK_NAME); + result.assertTaskExists("a:" + ScoveragePlugin.CHECK_NAME); + result.assertTaskExists("b:" + ScoveragePlugin.CHECK_NAME); + result.assertTaskExists("common:" + ScoveragePlugin.CHECK_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.AGGREGATE_NAME); } @Test public void checkScoverageOnlyRoot() { - AssertableBuildResult result = dryRun("clean", ":" + ScoveragePlugin.getCHECK_NAME()); + AssertableBuildResult result = dryRun("clean", ":" + ScoveragePlugin.CHECK_NAME); - result.assertTaskExists(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskDoesntExist("a:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskDoesntExist("b:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskExists(ScoveragePlugin.getCHECK_NAME()); - result.assertTaskDoesntExist("a:" + ScoveragePlugin.getCHECK_NAME()); - result.assertTaskDoesntExist("b:" + ScoveragePlugin.getCHECK_NAME()); - result.assertTaskDoesntExist(ScoveragePlugin.getAGGREGATE_NAME()); + result.assertTaskExists(ScoveragePlugin.REPORT_NAME); + result.assertTaskDoesntExist("a:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskDoesntExist("b:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskExists(ScoveragePlugin.CHECK_NAME); + result.assertTaskDoesntExist("a:" + ScoveragePlugin.CHECK_NAME); + result.assertTaskDoesntExist("b:" + ScoveragePlugin.CHECK_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.AGGREGATE_NAME); } @Test public void checkScoverageOnlyA() { - AssertableBuildResult result = dryRun("clean", ":a:" + ScoveragePlugin.getCHECK_NAME()); - - result.assertTaskDoesntExist(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskExists("a:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskDoesntExist("b:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskDoesntExist("common:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskDoesntExist(ScoveragePlugin.getCHECK_NAME()); - result.assertTaskExists("a:" + ScoveragePlugin.getCHECK_NAME()); - result.assertTaskDoesntExist("b:" + ScoveragePlugin.getCHECK_NAME()); - result.assertTaskDoesntExist("common:" + ScoveragePlugin.getCHECK_NAME()); - result.assertTaskDoesntExist(ScoveragePlugin.getAGGREGATE_NAME()); + AssertableBuildResult result = dryRun("clean", ":a:" + ScoveragePlugin.CHECK_NAME); + + result.assertTaskDoesntExist(ScoveragePlugin.REPORT_NAME); + result.assertTaskExists("a:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskDoesntExist("b:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskDoesntExist("common:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.CHECK_NAME); + result.assertTaskExists("a:" + ScoveragePlugin.CHECK_NAME); + result.assertTaskDoesntExist("b:" + ScoveragePlugin.CHECK_NAME); + result.assertTaskDoesntExist("common:" + ScoveragePlugin.CHECK_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.AGGREGATE_NAME); } @Test public void checkScoverageWithoutIntTests() { - AssertableBuildResult result = dryRun("clean", ScoveragePlugin.getCHECK_NAME(), + AssertableBuildResult result = dryRun("clean", ScoveragePlugin.CHECK_NAME, "-x", "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.assertTaskExists(ScoveragePlugin.REPORT_NAME); + result.assertTaskExists("a:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskExists("b:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskExists("common:" + ScoveragePlugin.REPORT_NAME); result.assertTaskDoesntExist("intTest"); result.assertTaskExists("reportIntTestScoverage"); result.assertTaskDoesntExist("a:intTest"); @@ -136,18 +136,18 @@ public void checkScoverageWithoutIntTests() { @Test public void checkAndAggregateScoverage() throws Exception { - AssertableBuildResult result = run("clean", ScoveragePlugin.getCHECK_NAME(), - ScoveragePlugin.getAGGREGATE_NAME()); + AssertableBuildResult result = run("clean", ScoveragePlugin.CHECK_NAME, + ScoveragePlugin.AGGREGATE_NAME); - result.assertTaskSucceeded(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded("a:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded("b:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded("common:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded(ScoveragePlugin.getCHECK_NAME()); - result.assertTaskSucceeded("a:" + ScoveragePlugin.getCHECK_NAME()); - result.assertTaskSucceeded("b:" + ScoveragePlugin.getCHECK_NAME()); - result.assertTaskSucceeded("common:" + ScoveragePlugin.getCHECK_NAME()); - result.assertTaskSucceeded(ScoveragePlugin.getAGGREGATE_NAME()); + result.assertTaskSucceeded(ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded("a:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded("b:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded("common:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded(ScoveragePlugin.CHECK_NAME); + result.assertTaskSucceeded("a:" + ScoveragePlugin.CHECK_NAME); + result.assertTaskSucceeded("b:" + ScoveragePlugin.CHECK_NAME); + result.assertTaskSucceeded("common:" + ScoveragePlugin.CHECK_NAME); + result.assertTaskSucceeded(ScoveragePlugin.AGGREGATE_NAME); assertAllReportFilesExist(); assertCoverage(100.0); @@ -156,7 +156,7 @@ public void checkAndAggregateScoverage() throws Exception { @Test public void checkScoverageWithoutCoverageInRoot() throws Exception { - AssertableBuildResult result = runAndFail("clean", ScoveragePlugin.getCHECK_NAME(), + AssertableBuildResult result = runAndFail("clean", ScoveragePlugin.CHECK_NAME, "test", "--tests", "org.hello.TestNothingSuite", "--tests", "org.hello.a.WorldASuite", @@ -164,7 +164,7 @@ public void checkScoverageWithoutCoverageInRoot() throws Exception { "--tests", "org.hello.common.WorldCommonSuite", "-x", "intTest"); - result.assertTaskFailed(ScoveragePlugin.getCHECK_NAME()); + result.assertTaskFailed(ScoveragePlugin.CHECK_NAME); assertRootReportFilesExist(); assertCoverage(0.0); @@ -173,7 +173,7 @@ public void checkScoverageWithoutCoverageInRoot() throws Exception { @Test public void checkScoverageWithoutCoverageInA() throws Exception { - AssertableBuildResult result = runAndFail("clean", ScoveragePlugin.getCHECK_NAME(), + AssertableBuildResult result = runAndFail("clean", ScoveragePlugin.CHECK_NAME, "test", "--tests", "org.hello.a.TestNothingASuite", "--tests", "org.hello.WorldSuite", @@ -181,7 +181,7 @@ public void checkScoverageWithoutCoverageInA() throws Exception { "--tests", "org.hello.common.WorldCommonSuite", "-x", ":a:intTest"); - result.assertTaskFailed("a:" + ScoveragePlugin.getCHECK_NAME()); + result.assertTaskFailed("a:" + ScoveragePlugin.CHECK_NAME); assertAReportFilesExist(); assertCoverage(0.0, reportDir(projectDir().toPath().resolve("a").toFile())); @@ -193,10 +193,10 @@ public void checkScoverageWithoutNormalCompilationAndWithoutCoverageInCommon() t AssertableBuildResult result = runAndFail("clean", ":a:test", ":common:test", "--tests", "org.hello.common.TestNothingCommonSuite", - "-P" + ScoveragePlugin.getSCOVERAGE_COMPILE_ONLY_PROPERTY(), - ScoveragePlugin.getCHECK_NAME()); + "-P" + ScoveragePlugin.SCOVERAGE_COMPILE_ONLY_PROPERTY, + ScoveragePlugin.CHECK_NAME); - result.assertTaskFailed("common:" + ScoveragePlugin.getCHECK_NAME()); + result.assertTaskFailed("common:" + ScoveragePlugin.CHECK_NAME); assertCommonReportFilesExist(); assertCoverage(0.0, reportDir(projectDir().toPath().resolve("common").toFile())); @@ -207,22 +207,22 @@ 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", + AssertableBuildResult result = run("clean", ScoveragePlugin.CHECK_NAME, + ScoveragePlugin.AGGREGATE_NAME, "test", "--tests", "org.hello.TestNothingSuite", "--tests", "org.hello.a.WorldASuite", "--tests", "org.hello.b.WorldBSuite", "--tests", "org.hello.common.WorldCommonSuite"); - result.assertTaskSucceeded(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded("a:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded("b:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded("common:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded(ScoveragePlugin.getCHECK_NAME()); - result.assertTaskSucceeded("a:" + ScoveragePlugin.getCHECK_NAME()); - result.assertTaskSucceeded("b:" + ScoveragePlugin.getCHECK_NAME()); - result.assertTaskSucceeded("common:" + ScoveragePlugin.getCHECK_NAME()); - result.assertTaskSucceeded(ScoveragePlugin.getAGGREGATE_NAME()); + result.assertTaskSucceeded(ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded("a:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded("b:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded("common:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded(ScoveragePlugin.CHECK_NAME); + result.assertTaskSucceeded("a:" + ScoveragePlugin.CHECK_NAME); + result.assertTaskSucceeded("b:" + ScoveragePlugin.CHECK_NAME); + result.assertTaskSucceeded("common:" + ScoveragePlugin.CHECK_NAME); + result.assertTaskSucceeded(ScoveragePlugin.AGGREGATE_NAME); assertAllReportFilesExist(); assertCoverage(93.33); @@ -231,20 +231,20 @@ public void checkAndAggregateScoverageWithoutCoverageInRoot() throws Exception { @Test public void checkAndAggregateScoverageWithoutCoverageInAll() throws Exception { - AssertableBuildResult result = runAndFail("clean", ScoveragePlugin.getCHECK_NAME(), - ScoveragePlugin.getAGGREGATE_NAME(), "test", + AssertableBuildResult result = runAndFail("clean", ScoveragePlugin.CHECK_NAME, + ScoveragePlugin.AGGREGATE_NAME, "test", "--tests", "org.hello.TestNothingSuite", "--tests", "org.hello.a.TestNothingASuite", "--tests", "org.hello.b.TestNothingBSuite", "--tests", "org.hello.common.TestNothingCommonSuite", "-x", "intTest"); - result.assertTaskSucceeded(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded("a:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded("b:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded("common:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded(ScoveragePlugin.getAGGREGATE_NAME()); - result.assertTaskFailed(ScoveragePlugin.getCHECK_NAME()); + result.assertTaskSucceeded(ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded("a:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded("b:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded("common:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded(ScoveragePlugin.AGGREGATE_NAME); + result.assertTaskFailed(ScoveragePlugin.CHECK_NAME); assertAllReportFilesExist(); assertCoverage(0.0); @@ -253,22 +253,22 @@ public void checkAndAggregateScoverageWithoutCoverageInAll() throws Exception { @Test public void aggregateScoverageWithoutNormalCompilation() throws Exception { - AssertableBuildResult result = run("clean", ScoveragePlugin.getAGGREGATE_NAME(), - "-P" + ScoveragePlugin.getSCOVERAGE_COMPILE_ONLY_PROPERTY()); + AssertableBuildResult result = run("clean", ScoveragePlugin.AGGREGATE_NAME, + "-P" + ScoveragePlugin.SCOVERAGE_COMPILE_ONLY_PROPERTY); result.assertTaskSkipped("compileScala"); result.assertTaskSkipped("a:compileScala"); result.assertTaskSkipped("b:compileScala"); result.assertTaskSkipped("common:compileScala"); - result.assertTaskSucceeded(ScoveragePlugin.getCOMPILE_NAME()); - result.assertTaskSucceeded("a:" + ScoveragePlugin.getCOMPILE_NAME()); - result.assertTaskSucceeded("b:" + ScoveragePlugin.getCOMPILE_NAME()); - result.assertTaskSucceeded("common:" + ScoveragePlugin.getCOMPILE_NAME()); - result.assertTaskSucceeded(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded("a:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded("b:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded("common:" + ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded(ScoveragePlugin.getAGGREGATE_NAME()); + result.assertTaskSucceeded(ScoveragePlugin.COMPILE_NAME); + result.assertTaskSucceeded("a:" + ScoveragePlugin.COMPILE_NAME); + result.assertTaskSucceeded("b:" + ScoveragePlugin.COMPILE_NAME); + result.assertTaskSucceeded("common:" + ScoveragePlugin.COMPILE_NAME); + result.assertTaskSucceeded(ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded("a:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded("b:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded("common:" + ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded(ScoveragePlugin.AGGREGATE_NAME); assertAllReportFilesExist(); assertCoverage(100.0); diff --git a/src/functionalTest/java/org/scoverage/ScalaMultiModuleWithPartialScoverageUseTest.java b/src/functionalTest/java/org/scoverage/ScalaMultiModuleWithPartialScoverageUseTest.java index 53d469f..96d320a 100644 --- a/src/functionalTest/java/org/scoverage/ScalaMultiModuleWithPartialScoverageUseTest.java +++ b/src/functionalTest/java/org/scoverage/ScalaMultiModuleWithPartialScoverageUseTest.java @@ -11,10 +11,10 @@ public ScalaMultiModuleWithPartialScoverageUseTest() { @Test public void reportScoverage() { - AssertableBuildResult result = dryRun("clean", ScoveragePlugin.getREPORT_NAME()); + AssertableBuildResult result = dryRun("clean", ScoveragePlugin.REPORT_NAME); - result.assertTaskExists(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskExists("b:" + ScoveragePlugin.getREPORT_NAME()); + result.assertTaskExists(ScoveragePlugin.REPORT_NAME); + result.assertTaskExists("b:" + ScoveragePlugin.REPORT_NAME); } } diff --git a/src/functionalTest/java/org/scoverage/ScalaSingleModuleTest.java b/src/functionalTest/java/org/scoverage/ScalaSingleModuleTest.java index 19e0e82..b04e8f3 100644 --- a/src/functionalTest/java/org/scoverage/ScalaSingleModuleTest.java +++ b/src/functionalTest/java/org/scoverage/ScalaSingleModuleTest.java @@ -14,10 +14,10 @@ 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()); + result.assertTaskDoesntExist(ScoveragePlugin.COMPILE_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.REPORT_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.AGGREGATE_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.CHECK_NAME); } @Test @@ -25,27 +25,27 @@ 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()); + result.assertTaskDoesntExist(ScoveragePlugin.COMPILE_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.REPORT_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.AGGREGATE_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.CHECK_NAME); } @Test public void reportScoverage() { - AssertableBuildResult result = dryRun("clean", ScoveragePlugin.getREPORT_NAME()); + AssertableBuildResult result = dryRun("clean", ScoveragePlugin.REPORT_NAME); - result.assertTaskExists(ScoveragePlugin.getCOMPILE_NAME()); - result.assertTaskExists(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskDoesntExist(ScoveragePlugin.getAGGREGATE_NAME()); - result.assertTaskDoesntExist(ScoveragePlugin.getCHECK_NAME()); + result.assertTaskExists(ScoveragePlugin.COMPILE_NAME); + result.assertTaskExists(ScoveragePlugin.REPORT_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.AGGREGATE_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.CHECK_NAME); } @Test public void aggregateScoverage() { - AssertableBuildResult result = runAndFail("clean", ScoveragePlugin.getAGGREGATE_NAME()); + AssertableBuildResult result = runAndFail("clean", ScoveragePlugin.AGGREGATE_NAME); result.assertNoTasks(); } @@ -53,12 +53,12 @@ public void aggregateScoverage() { @Test public void checkScoverage() throws Exception { - AssertableBuildResult result = run("clean", ScoveragePlugin.getCHECK_NAME()); + AssertableBuildResult result = run("clean", ScoveragePlugin.CHECK_NAME); - result.assertTaskSucceeded(ScoveragePlugin.getCOMPILE_NAME()); - result.assertTaskSucceeded(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded(ScoveragePlugin.getCHECK_NAME()); - result.assertTaskDoesntExist(ScoveragePlugin.getAGGREGATE_NAME()); + result.assertTaskSucceeded(ScoveragePlugin.COMPILE_NAME); + result.assertTaskSucceeded(ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded(ScoveragePlugin.CHECK_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.AGGREGATE_NAME); assertReportFilesExist(); assertCoverage(50.0); @@ -67,13 +67,13 @@ public void checkScoverage() throws Exception { @Test public void checkScoverageFails() throws Exception { - AssertableBuildResult result = runAndFail("clean", ScoveragePlugin.getCHECK_NAME(), + AssertableBuildResult result = runAndFail("clean", ScoveragePlugin.CHECK_NAME, "test", "--tests", "org.hello.TestNothingSuite"); - result.assertTaskSucceeded(ScoveragePlugin.getCOMPILE_NAME()); - result.assertTaskSucceeded(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskFailed(ScoveragePlugin.getCHECK_NAME()); - result.assertTaskDoesntExist(ScoveragePlugin.getAGGREGATE_NAME()); + result.assertTaskSucceeded(ScoveragePlugin.COMPILE_NAME); + result.assertTaskSucceeded(ScoveragePlugin.REPORT_NAME); + result.assertTaskFailed(ScoveragePlugin.CHECK_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.AGGREGATE_NAME); assertReportFilesExist(); assertCoverage(0.0); @@ -82,13 +82,13 @@ public void checkScoverageFails() throws Exception { @Test public void reportScoverageWithExcludedClasses() throws Exception { - AssertableBuildResult result = run("clean", ScoveragePlugin.getREPORT_NAME(), + AssertableBuildResult result = run("clean", ScoveragePlugin.REPORT_NAME, "-PexcludedFile=.*"); - result.assertTaskSucceeded(ScoveragePlugin.getCOMPILE_NAME()); - result.assertTaskSucceeded(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskDoesntExist(ScoveragePlugin.getCHECK_NAME()); - result.assertTaskDoesntExist(ScoveragePlugin.getAGGREGATE_NAME()); + result.assertTaskSucceeded(ScoveragePlugin.COMPILE_NAME); + result.assertTaskSucceeded(ScoveragePlugin.REPORT_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.CHECK_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.AGGREGATE_NAME); Assert.assertTrue(resolve(reportDir(), "index.html").exists()); Assert.assertFalse(resolve(reportDir(), "org/hello/World.scala.html").exists()); @@ -102,14 +102,14 @@ public void reportScoverageWithExcludedClasses() throws Exception { @Test public void reportScoverageWithoutNormalCompilation() throws Exception { - AssertableBuildResult result = run("clean", ScoveragePlugin.getREPORT_NAME(), - "-P" + ScoveragePlugin.getSCOVERAGE_COMPILE_ONLY_PROPERTY()); + AssertableBuildResult result = run("clean", ScoveragePlugin.REPORT_NAME, + "-P" + ScoveragePlugin.SCOVERAGE_COMPILE_ONLY_PROPERTY); result.assertTaskSkipped("compileScala"); - result.assertTaskSucceeded(ScoveragePlugin.getCOMPILE_NAME()); - result.assertTaskSucceeded(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskDoesntExist(ScoveragePlugin.getCHECK_NAME()); - result.assertTaskDoesntExist(ScoveragePlugin.getAGGREGATE_NAME()); + result.assertTaskSucceeded(ScoveragePlugin.COMPILE_NAME); + result.assertTaskSucceeded(ScoveragePlugin.REPORT_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.CHECK_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.AGGREGATE_NAME); assertReportFilesExist(); assertCoverage(50.0); @@ -121,8 +121,8 @@ public void reportScoverageWithoutNormalCompilation() throws Exception { @Test public void reportScoverageWithoutNormalCompilationAndWithExcludedClasses() throws Exception { - AssertableBuildResult result = run("clean", ScoveragePlugin.getREPORT_NAME(), - "-PexcludedFile=.*", "-P" + ScoveragePlugin.getSCOVERAGE_COMPILE_ONLY_PROPERTY()); + AssertableBuildResult result = run("clean", ScoveragePlugin.REPORT_NAME, + "-PexcludedFile=.*", "-P" + ScoveragePlugin.SCOVERAGE_COMPILE_ONLY_PROPERTY); Assert.assertTrue(resolve(reportDir(), "index.html").exists()); Assert.assertFalse(resolve(reportDir(), "org/hello/World.scala.html").exists()); diff --git a/src/functionalTest/java/org/scoverage/ScalaSingleModuleWithDependencyManagerTest.java b/src/functionalTest/java/org/scoverage/ScalaSingleModuleWithDependencyManagerTest.java index 3ce3b63..ddc80ca 100644 --- a/src/functionalTest/java/org/scoverage/ScalaSingleModuleWithDependencyManagerTest.java +++ b/src/functionalTest/java/org/scoverage/ScalaSingleModuleWithDependencyManagerTest.java @@ -12,12 +12,12 @@ public ScalaSingleModuleWithDependencyManagerTest() { @Test public void checkScoverage() throws Exception { - AssertableBuildResult result = run("clean", ScoveragePlugin.getCHECK_NAME()); + AssertableBuildResult result = run("clean", ScoveragePlugin.CHECK_NAME); - result.assertTaskSucceeded(ScoveragePlugin.getCOMPILE_NAME()); - result.assertTaskSucceeded(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded(ScoveragePlugin.getCHECK_NAME()); - result.assertTaskDoesntExist(ScoveragePlugin.getAGGREGATE_NAME()); + result.assertTaskSucceeded(ScoveragePlugin.COMPILE_NAME); + result.assertTaskSucceeded(ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded(ScoveragePlugin.CHECK_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.AGGREGATE_NAME); assertReportFilesExist(); assertCoverage(100.0); diff --git a/src/functionalTest/java/org/scoverage/ScalaSingleModuleWithMultipleTestTasksTest.java b/src/functionalTest/java/org/scoverage/ScalaSingleModuleWithMultipleTestTasksTest.java index cba1c6a..ac197d1 100644 --- a/src/functionalTest/java/org/scoverage/ScalaSingleModuleWithMultipleTestTasksTest.java +++ b/src/functionalTest/java/org/scoverage/ScalaSingleModuleWithMultipleTestTasksTest.java @@ -13,10 +13,10 @@ 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()); + result.assertTaskDoesntExist(ScoveragePlugin.COMPILE_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.REPORT_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.AGGREGATE_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.CHECK_NAME); } @Test @@ -24,27 +24,27 @@ 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()); + result.assertTaskDoesntExist(ScoveragePlugin.COMPILE_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.REPORT_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.AGGREGATE_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.CHECK_NAME); } @Test public void reportScoverage() { - AssertableBuildResult result = dryRun("clean", ScoveragePlugin.getREPORT_NAME()); + AssertableBuildResult result = dryRun("clean", ScoveragePlugin.REPORT_NAME); - result.assertTaskExists(ScoveragePlugin.getCOMPILE_NAME()); - result.assertTaskExists(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskDoesntExist(ScoveragePlugin.getAGGREGATE_NAME()); - result.assertTaskDoesntExist(ScoveragePlugin.getCHECK_NAME()); + result.assertTaskExists(ScoveragePlugin.COMPILE_NAME); + result.assertTaskExists(ScoveragePlugin.REPORT_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.AGGREGATE_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.CHECK_NAME); } @Test public void aggregateScoverage() { - AssertableBuildResult result = runAndFail("clean", ScoveragePlugin.getAGGREGATE_NAME()); + AssertableBuildResult result = runAndFail("clean", ScoveragePlugin.AGGREGATE_NAME); result.assertNoTasks(); } @@ -53,14 +53,14 @@ public void aggregateScoverage() { @Test public void checkScoverage() throws Exception { - AssertableBuildResult result = run("clean", ScoveragePlugin.getCHECK_NAME()); + AssertableBuildResult result = run("clean", ScoveragePlugin.CHECK_NAME); - result.assertTaskSucceeded(ScoveragePlugin.getCOMPILE_NAME()); + result.assertTaskSucceeded(ScoveragePlugin.COMPILE_NAME); result.assertTaskSucceeded("reportTestScoverage"); result.assertTaskSucceeded("reportIntTestScoverage"); - result.assertTaskSucceeded(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskSucceeded(ScoveragePlugin.getCHECK_NAME()); - result.assertTaskDoesntExist(ScoveragePlugin.getAGGREGATE_NAME()); + result.assertTaskSucceeded(ScoveragePlugin.REPORT_NAME); + result.assertTaskSucceeded(ScoveragePlugin.CHECK_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.AGGREGATE_NAME); assertReportFilesExist(); assertCoverage(100.0); @@ -68,14 +68,14 @@ public void checkScoverage() throws Exception { @Test public void checkScoverageIntTest() throws Exception { - AssertableBuildResult result = runAndFail("clean", "-x", "reportTestScoverage", ScoveragePlugin.getCHECK_NAME()); + AssertableBuildResult result = runAndFail("clean", "-x", "reportTestScoverage", ScoveragePlugin.CHECK_NAME); - result.assertTaskSucceeded(ScoveragePlugin.getCOMPILE_NAME()); + result.assertTaskSucceeded(ScoveragePlugin.COMPILE_NAME); result.assertTaskDoesntExist("reportTestScoverage"); result.assertTaskSucceeded("reportIntTestScoverage"); - result.assertTaskSucceeded(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskFailed(ScoveragePlugin.getCHECK_NAME()); - result.assertTaskDoesntExist(ScoveragePlugin.getAGGREGATE_NAME()); + result.assertTaskSucceeded(ScoveragePlugin.REPORT_NAME); + result.assertTaskFailed(ScoveragePlugin.CHECK_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.AGGREGATE_NAME); assertReportFilesExist(); assertCoverage(50.0); @@ -85,14 +85,14 @@ public void checkScoverageIntTest() throws Exception { @Test public void checkScoverageFails() throws Exception { - AssertableBuildResult result = runAndFail("clean", ScoveragePlugin.getCHECK_NAME(), + AssertableBuildResult result = runAndFail("clean", ScoveragePlugin.CHECK_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()); + result.assertTaskSucceeded(ScoveragePlugin.COMPILE_NAME); + result.assertTaskSucceeded(ScoveragePlugin.REPORT_NAME); + result.assertTaskFailed(ScoveragePlugin.CHECK_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.AGGREGATE_NAME); assertReportFilesExist(); assertCoverage(0.0); @@ -101,12 +101,12 @@ public void checkScoverageFails() throws Exception { @Test public void reportScoverageWithExcludedClasses() throws Exception { - AssertableBuildResult result = run("clean", "-PexcludedFile=.*", ScoveragePlugin.getREPORT_NAME()); + AssertableBuildResult result = run("clean", "-PexcludedFile=.*", ScoveragePlugin.REPORT_NAME); - result.assertTaskSucceeded(ScoveragePlugin.getCOMPILE_NAME()); - result.assertTaskSucceeded(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskDoesntExist(ScoveragePlugin.getCHECK_NAME()); - result.assertTaskDoesntExist(ScoveragePlugin.getAGGREGATE_NAME()); + result.assertTaskSucceeded(ScoveragePlugin.COMPILE_NAME); + result.assertTaskSucceeded(ScoveragePlugin.REPORT_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.CHECK_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.AGGREGATE_NAME); Assert.assertTrue(resolve(reportDir(), "index.html").exists()); Assert.assertFalse(resolve(reportDir(), "org/hello/World.scala.html").exists()); @@ -120,14 +120,14 @@ public void reportScoverageWithExcludedClasses() throws Exception { @Test public void reportScoverageWithoutNormalCompilation() throws Exception { - AssertableBuildResult result = run("clean", ScoveragePlugin.getREPORT_NAME(), - "-P" + ScoveragePlugin.getSCOVERAGE_COMPILE_ONLY_PROPERTY()); + AssertableBuildResult result = run("clean", ScoveragePlugin.REPORT_NAME, + "-P" + ScoveragePlugin.SCOVERAGE_COMPILE_ONLY_PROPERTY); result.assertTaskSkipped("compileScala"); - result.assertTaskSucceeded(ScoveragePlugin.getCOMPILE_NAME()); - result.assertTaskSucceeded(ScoveragePlugin.getREPORT_NAME()); - result.assertTaskDoesntExist(ScoveragePlugin.getCHECK_NAME()); - result.assertTaskDoesntExist(ScoveragePlugin.getAGGREGATE_NAME()); + result.assertTaskSucceeded(ScoveragePlugin.COMPILE_NAME); + result.assertTaskSucceeded(ScoveragePlugin.REPORT_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.CHECK_NAME); + result.assertTaskDoesntExist(ScoveragePlugin.AGGREGATE_NAME); assertReportFilesExist(); assertCoverage(100.0); @@ -139,8 +139,8 @@ public void reportScoverageWithoutNormalCompilation() throws Exception { @Test public void reportScoverageWithoutNormalCompilationAndWithExcludedClasses() throws Exception { - AssertableBuildResult result = run("clean", ScoveragePlugin.getREPORT_NAME(), - "-PexcludedFile=.*", "-P" + ScoveragePlugin.getSCOVERAGE_COMPILE_ONLY_PROPERTY()); + AssertableBuildResult result = run("clean", ScoveragePlugin.REPORT_NAME, + "-PexcludedFile=.*", "-P" + ScoveragePlugin.SCOVERAGE_COMPILE_ONLY_PROPERTY); Assert.assertTrue(resolve(reportDir(), "index.html").exists()); Assert.assertFalse(resolve(reportDir(), "org/hello/World.scala.html").exists()); diff --git a/src/functionalTest/java/org/scoverage/ScoverageFunctionalTest.java b/src/functionalTest/java/org/scoverage/ScoverageFunctionalTest.java index 051b6bb..07ff0a7 100644 --- a/src/functionalTest/java/org/scoverage/ScoverageFunctionalTest.java +++ b/src/functionalTest/java/org/scoverage/ScoverageFunctionalTest.java @@ -70,7 +70,7 @@ protected File reportDir() { protected File reportDir(File projectDir) { - return buildDir(projectDir).toPath().resolve(ScoveragePlugin.getDEFAULT_REPORT_DIR()).toFile(); + return buildDir(projectDir).toPath().resolve(ScoveragePlugin.DEFAULT_REPORT_DIR).toFile(); } protected AssertableBuildResult run(String... arguments) { diff --git a/src/main/groovy/org/scoverage/CoverageChecker.groovy b/src/main/groovy/org/scoverage/CoverageChecker.groovy deleted file mode 100644 index 1af7b4e..0000000 --- a/src/main/groovy/org/scoverage/CoverageChecker.groovy +++ /dev/null @@ -1,98 +0,0 @@ -package org.scoverage - -import groovy.xml.XmlParser -import org.gradle.api.GradleException -import org.gradle.api.logging.Logger -import org.gradle.internal.impldep.com.google.common.annotations.VisibleForTesting - -import java.text.DecimalFormat -import java.text.NumberFormat - -/** - * Handles different types of coverage Scoverage can measure. - */ -enum CoverageType { - Line('Line', 'cobertura.xml', 'line-rate', 1.0), - Statement('Statement', 'scoverage.xml', 'statement-rate', 100.0), - Branch('Branch', 'scoverage.xml', 'branch-rate', 100.0) - - /** Name of enum option the way it appears in the build configuration */ - String configurationName - /** Name of file with coverage data */ - String fileName - /** Name of param in XML file with coverage value */ - String paramName - /** Used to normalize coverage value */ - private double factor - - private CoverageType(String configurationName, String fileName, String paramName, double factor) { - this.configurationName = configurationName - this.fileName = fileName - this.paramName = paramName - this.factor = factor - } - - /** Normalize coverage value to [0, 1] */ - Double normalize(Double value) { - return value / factor - } - - static CoverageType find(String configurationName) { - CoverageType.values().find { - it.configurationName.toLowerCase() == configurationName.toLowerCase() - } - } -} - -/** - * Throws a GradleException if overall coverage dips below the configured percentage. - */ -class CoverageChecker { - - final Logger logger - - CoverageChecker(Logger logger) { - this.logger = logger - } - - public void checkLineCoverage(File reportDir, CoverageType coverageType, double minimumRate) throws GradleException { - NumberFormat defaultNf = NumberFormat.getInstance(Locale.getDefault()) - checkLineCoverage(reportDir, coverageType, minimumRate, defaultNf) - } - - public void checkLineCoverage(File reportDir, CoverageType coverageType, double minimumRate, NumberFormat nf) throws GradleException { - logger.info("Checking coverage. Type: {}. Minimum rate: {}", coverageType, minimumRate) - - XmlParser parser = new XmlParser() - parser.setFeature('http://apache.org/xml/features/disallow-doctype-decl', false) - parser.setFeature('http://apache.org/xml/features/nonvalidating/load-external-dtd', false) - - DecimalFormat df = new DecimalFormat("#.##") - - try { - File reportFile = new File(reportDir, coverageType.fileName) - Node xml = parser.parse(reportFile) - Double coverageValue = nf.parse(xml.attribute(coverageType.paramName) as String).doubleValue() - Double overallRate = coverageType.normalize(coverageValue) - def difference = (minimumRate - overallRate) - - if (difference > 1e-7) { - String is = df.format(overallRate * 100) - String needed = df.format(minimumRate * 100) - throw new GradleException(errorMsg(is, needed, coverageType)) - } - } catch (FileNotFoundException fnfe) { - throw new GradleException(fileNotFoundErrorMsg(coverageType), fnfe) - } - } - - @VisibleForTesting - protected static String errorMsg(String actual, String expected, CoverageType type) { - "Only $actual% of project is covered by tests instead of $expected% (coverageType: $type)" - } - - @VisibleForTesting - protected static String fileNotFoundErrorMsg(CoverageType coverageType) { - "Coverage file (type: $coverageType) not found, check your configuration." - } -} diff --git a/src/main/groovy/org/scoverage/ScoverageAggregate.groovy b/src/main/groovy/org/scoverage/ScoverageAggregate.groovy deleted file mode 100644 index 9815dd1..0000000 --- a/src/main/groovy/org/scoverage/ScoverageAggregate.groovy +++ /dev/null @@ -1,76 +0,0 @@ -package org.scoverage - -import org.gradle.api.DefaultTask -import org.gradle.api.file.FileCollection -import org.gradle.api.provider.ListProperty -import org.gradle.api.provider.Property -import org.gradle.api.tasks.Input -import org.gradle.api.tasks.InputFiles -import org.gradle.api.tasks.Nested -import org.gradle.api.tasks.OutputDirectory -import org.gradle.api.tasks.PathSensitive -import org.gradle.api.tasks.TaskAction -import scoverage.report.CoverageAggregator - -import static org.gradle.api.tasks.PathSensitivity.RELATIVE - -class ScoverageAggregate extends DefaultTask { - - @Nested - ScoverageRunner runner - - @InputFiles - @PathSensitive(RELATIVE) - final Property sources = project.objects.property(FileCollection) - - @OutputDirectory - final Property reportDir = project.objects.property(File) - - @Input - final ListProperty dirsToAggregateFrom = project.objects.listProperty(File) - - @Input - final Property deleteReportsOnAggregation = project.objects.property(Boolean) - - @Input - final Property sourceEncoding = project.objects.property(String) - - // 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) - @Input - final Property coverageOutputHTML = project.objects.property(Boolean) - @Input - final Property coverageDebug = project.objects.property(Boolean) - - ScoverageAggregate() { - dirsToAggregateFrom.set([project.extensions.scoverage.dataDir.get()]) - } - - @TaskAction - def aggregate() { - runner.run { - reportDir.get().deleteDir() - reportDir.get().mkdirs() - - def dirs = [] - dirs.addAll(dirsToAggregateFrom.get()) - def coverage = CoverageAggregator.aggregate(dirs.unique() as File[]) - - if (coverage.nonEmpty()) { - new ScoverageWriter(project.logger).write( - sources.get().getFiles(), - reportDir.get(), - coverage.get(), - sourceEncoding.get(), - coverageOutputCobertura.get(), - coverageOutputXML.get(), - coverageOutputHTML.get(), - coverageDebug.get() - ) - } - } - } -} diff --git a/src/main/groovy/org/scoverage/ScoverageExtension.groovy b/src/main/groovy/org/scoverage/ScoverageExtension.groovy deleted file mode 100644 index 210a825..0000000 --- a/src/main/groovy/org/scoverage/ScoverageExtension.groovy +++ /dev/null @@ -1,108 +0,0 @@ -package org.scoverage - -import org.gradle.api.Project -import org.gradle.api.plugins.JavaPlugin -import org.gradle.api.plugins.scala.ScalaPlugin -import org.gradle.api.provider.ListProperty -import org.gradle.api.provider.Property - -/** - * Defines a new SourceSet for the code to be instrumented. - * Defines a new Test Task which executes normal tests with the instrumented classes. - * Defines a new Check Task which enforces an overall line coverage requirement. - */ -class ScoverageExtension { - - public static final CoverageType DEFAULT_COVERAGE_TYPE = CoverageType.Statement - public static final double DEFAULT_MINIMUM_RATE = 0.75 - - final Project project - - /** Version of scoverage to use for the scalac plugin */ - final Property scoverageVersion - - /** Version of scala to use for the scalac plugin */ - final Property scoverageScalaVersion - - /** a directory to write working files to */ - final Property dataDir - /** a directory to write final output to */ - final Property reportDir - /** range positioning for highlighting */ - final Property highlighting - /** regex for each excluded package */ - final ListProperty excludedPackages - /** regex for each excluded file */ - final ListProperty excludedFiles - - /** Options for enabling and disabling output */ - final Property coverageOutputCobertura - final Property coverageOutputXML - final Property coverageOutputHTML - final Property coverageDebug - - final Property deleteReportsOnAggregation - - final List checks = new ArrayList<>() - - final Property coverageType - final Property minimumRate - - ScoverageExtension(Project project) { - - this.project = project - project.plugins.apply(JavaPlugin.class) - project.plugins.apply(ScalaPlugin.class) - - scoverageVersion = project.objects.property(String) - scoverageVersion.set('1.4.8') - - scoverageScalaVersion = project.objects.property(String) - - dataDir = project.objects.property(File) - dataDir.set(new File(project.buildDir, 'scoverage')) - - reportDir = project.objects.property(File) - reportDir.set(new File(project.buildDir, ScoveragePlugin.DEFAULT_REPORT_DIR)) - - highlighting = project.objects.property(Boolean) - highlighting.set(true) - - excludedPackages = project.objects.listProperty(String) - excludedPackages.set([]) - - excludedFiles = project.objects.listProperty(String) - excludedFiles.set([]) - - coverageOutputCobertura = project.objects.property(Boolean) - coverageOutputCobertura.set(true) - - coverageOutputXML = project.objects.property(Boolean) - coverageOutputXML.set(true) - - coverageOutputHTML = project.objects.property(Boolean) - coverageOutputHTML.set(true) - - coverageDebug = project.objects.property(Boolean) - coverageDebug.set(false) - - deleteReportsOnAggregation = project.objects.property(Boolean) - deleteReportsOnAggregation.set(false) - - coverageType = project.objects.property(CoverageType) - minimumRate = project.objects.property(BigDecimal) - } - - void check(Closure closure) { - CheckConfig check = new CheckConfig() - project.configure(check, closure) - checks.add(check) - } - - static class CheckConfig { - CoverageType coverageType - BigDecimal minimumRate - CheckConfig() { - } - } -} diff --git a/src/main/groovy/org/scoverage/ScoveragePlugin.groovy b/src/main/groovy/org/scoverage/ScoveragePlugin.groovy deleted file mode 100644 index 4f1ba18..0000000 --- a/src/main/groovy/org/scoverage/ScoveragePlugin.groovy +++ /dev/null @@ -1,409 +0,0 @@ -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 -import org.gradle.api.tasks.SourceSet -import org.gradle.api.tasks.TaskProvider -import org.gradle.api.tasks.scala.ScalaCompile -import org.gradle.api.tasks.testing.Test - -import java.nio.file.Files -import java.util.concurrent.ConcurrentHashMap - -import static groovy.io.FileType.FILES - -class ScoveragePlugin implements Plugin { - - static final String CONFIGURATION_NAME = 'scoverage' - static final String REPORT_NAME = 'reportScoverage' - static final String CHECK_NAME = 'checkScoverage' - static final String COMPILE_NAME = 'compileScoverageScala' - static final String AGGREGATE_NAME = 'aggregateScoverage' - static final String DEFAULT_SCALA_VERSION = '2.13.6' - static final String SCOVERAGE_COMPILE_ONLY_PROPERTY = 'scoverageCompileOnly'; - - 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) { - applyProject(pluginAware) - } else if (pluginAware instanceof Gradle) { - pluginAware.allprojects { p -> - p.plugins.apply(ScoveragePlugin) - } - } else { - throw new IllegalArgumentException("${pluginAware.getClass()} is currently not supported as an apply target, please report if you need it") - } - } - - void applyProject(Project project) { - - if (project.plugins.hasPlugin(ScoveragePlugin)) { - project.logger.info("Project ${project.name} already has the scoverage plugin") - return - } - project.logger.info("Applying scoverage plugin to $project.name") - - def extension = project.extensions.create('scoverage', ScoverageExtension, project) - if (!project.configurations.asMap[CONFIGURATION_NAME]) { - project.configurations.create(CONFIGURATION_NAME) { - visible = false - transitive = true - description = 'Scoverage dependencies' - } - - project.afterEvaluate { - def scalaFullVersion = resolveScalaVersion(project) - def scalaBinaryVersion = scalaFullVersion.substring(0, scalaFullVersion.lastIndexOf('.')) - def scoverageVersion = project.extensions.scoverage.scoverageVersion.get() - - project.logger.info("Using scoverage scalac plugin $scoverageVersion for scala $scalaFullVersion") - - project.dependencies { - scoverage("org.scoverage:scalac-scoverage-plugin_$scalaFullVersion:$scoverageVersion") - scoverage("org.scoverage:scalac-scoverage-runtime_$scalaBinaryVersion:$scoverageVersion") - } - } - } - - createTasks(project, extension) - } - - private void createTasks(Project project, ScoverageExtension extension) { - - ScoverageRunner scoverageRunner = new ScoverageRunner(project.configurations.scoverage) - - def originalSourceSet = project.sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME) - def instrumentedSourceSet = project.sourceSets.create('scoverage') { - - resources.source(originalSourceSet.resources) - java.source(originalSourceSet.java) - scala.source(originalSourceSet.scala) - - annotationProcessorPath += originalSourceSet.annotationProcessorPath + project.configurations.scoverage - compileClasspath += originalSourceSet.compileClasspath + project.configurations.scoverage - runtimeClasspath = it.output + project.configurations.scoverage + originalSourceSet.runtimeClasspath - } - - def originalCompileTask = project.tasks[originalSourceSet.getCompileTaskName("scala")] - def originalJarTask = project.tasks[originalSourceSet.getJarTaskName()] - - def compileTask = project.tasks[instrumentedSourceSet.getCompileTaskName("scala")] - compileTask.mustRunAfter(originalCompileTask) - - def globalReportTask = project.tasks.register(REPORT_NAME, ScoverageAggregate) - def globalCheckTask = project.tasks.register(CHECK_NAME) - - project.afterEvaluate { - def detectedSourceEncoding = compileTask.scalaCompileOptions.encoding - if (detectedSourceEncoding == null) { - detectedSourceEncoding = "UTF-8" - } - - // calling toList() on TaskCollection is required - // to avoid potential ConcurrentModificationException in multi-project builds - def testTasks = project.tasks.withType(Test).toList() - - 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 originalJarTask, compileTask, testTask - onlyIf { extension.dataDir.get().list() } - group = 'verification' - runner = scoverageRunner - reportDir = taskReportDir - sources = originalSourceSet.scala.getSourceDirectories() - dataDir = extension.dataDir - sourceEncoding.set(detectedSourceEncoding) - coverageOutputCobertura = extension.coverageOutputCobertura - coverageOutputXML = extension.coverageOutputXML - coverageOutputHTML = extension.coverageOutputHTML - coverageDebug = extension.coverageDebug - } - } - - globalReportTask.configure { - def dataDirs = reportTasks.findResults { it.dataDir.get() } - - dependsOn reportTasks - onlyIf { dataDirs.any { it.list() } } - - group = 'verification' - runner = scoverageRunner - reportDir = extension.reportDir - sources = originalSourceSet.scala.getSourceDirectories() - dirsToAggregateFrom = dataDirs - sourceEncoding.set(detectedSourceEncoding) - deleteReportsOnAggregation = false - coverageOutputCobertura = extension.coverageOutputCobertura - coverageOutputXML = extension.coverageOutputXML - coverageOutputHTML = extension.coverageOutputHTML - coverageDebug = extension.coverageDebug - } - - configureCheckTask(project, extension, globalCheckTask, globalReportTask) - - compileTask.configure { - List parameters = [] - List 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') - } - scalaCompileOptions.additionalParameters = parameters - // the compile task creates a store of measured statements - outputs.file(new File(extension.dataDir.get(), 'scoverage.coverage')) - - dependsOn 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 pluginFile = project.configurations[CONFIGURATION_NAME].find { - it.name.startsWith("scalac-scoverage-plugin") - } - scalaCompileOptions.additionalParameters.add('-Xplugin:' + pluginFile.absolutePath) - } - } - - if (project.hasProperty(SCOVERAGE_COMPILE_ONLY_PROPERTY)) { - project.logger.info("Making scoverage compilation the primary compilation task (instead of compileScala)") - - originalCompileTask.enabled = false; - compileTask.destinationDirectory = originalCompileTask.destinationDirectory - - project.getTasks().each { - if (recursiveDependenciesOf(it, true).contains(originalCompileTask)) { - it.dependsOn(compileTask) - } - } - - // make this project's scoverage compilation depend on scoverage compilation of any other project - // which this project depends on its normal compilation - def originalCompilationDependencies = recursiveDependenciesOf(compileTask, false).findAll { - it instanceof ScalaCompile - } - originalCompilationDependencies.each { - def dependencyProjectCompileTask = it.project.tasks.findByName(COMPILE_NAME) - def dependencyProjectReportTask = it.project.tasks.findByName(REPORT_NAME) - if (dependencyProjectCompileTask != null) { - compileTask.dependsOn(dependencyProjectCompileTask) - // we don't want this project's tests to affect the other project's report - testTasks.each { - it.mustRunAfter(dependencyProjectReportTask) - } - } - } - } else { - compileTask.configure { - doFirst { - destinationDir.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)) - } - } - } - } - - 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 { - 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 = scoverageRunner - reportDir = extension.reportDir - sources = allSources - sourceEncoding.set(detectedSourceEncoding) - dirsToAggregateFrom = dataDirs - deleteReportsOnAggregation = extension.deleteReportsOnAggregation - coverageOutputCobertura = extension.coverageOutputCobertura - coverageOutputXML = extension.coverageOutputXML - coverageOutputHTML = extension.coverageOutputHTML - coverageDebug = extension.coverageDebug - } - project.tasks[CHECK_NAME].mustRunAfter(aggregationTask) - } - } - } - } - - private void configureCheckTask(Project project, ScoverageExtension extension, - TaskProvider globalCheckTask, - TaskProvider globalReportTask) { - - if (extension.checks.isEmpty()) { - extension.check { - minimumRate = extension.minimumRate.getOrElse(BigDecimal.valueOf(ScoverageExtension.DEFAULT_MINIMUM_RATE)) - coverageType = extension.coverageType.getOrElse(ScoverageExtension.DEFAULT_COVERAGE_TYPE) - } - } else if (extension.minimumRate.isPresent() || extension.coverageType.isPresent()) { - 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()) - } - } - } - } - - private String resolveScalaVersion(Project project) { - - def scalaVersionProperty = project.extensions.scoverage.scoverageScalaVersion - if (scalaVersionProperty.isPresent()) { - def configuredScalaVersion = scalaVersionProperty.get() - project.logger.info("Using configured Scala version: $configuredScalaVersion") - return configuredScalaVersion - } else { - project.logger.info("No Scala version configured. Detecting scala library...") - def components = project.configurations.compileClasspath.incoming.resolutionResult.getAllComponents() - def scalaLibrary = components.find { - it.moduleVersion.group == "org.scala-lang" && it.moduleVersion.name == "scala-library" - } - if (scalaLibrary != null) { - def scalaVersion = scalaLibrary.moduleVersion.version - project.logger.info("Detected scala library in compilation classpath. Scala version: $scalaVersion") - return scalaVersion - } else { - project.logger.info("No scala library detected. Using default Scala version: $DEFAULT_SCALA_VERSION") - return DEFAULT_SCALA_VERSION - } - } - } - - private Set recursiveDependenciesOf(Task task, boolean sameProjectOnly) { - def cache = sameProjectOnly ? sameProjectTaskDependencies : crossProjectTaskDependencies - if (!cache.containsKey(task)) { - def directDependencies = task.getTaskDependencies().getDependencies(task) - if (sameProjectOnly) { - directDependencies = directDependencies.findAll { - it.project == task.project - } - } - def nestedDependencies = directDependencies.collect { recursiveDependenciesOf(it, sameProjectOnly) }.flatten() - def dependencies = directDependencies + nestedDependencies - - cache.put(task, dependencies) - return dependencies - } else { - return cache.get(task) - } - } -} diff --git a/src/main/groovy/org/scoverage/ScoverageRunner.groovy b/src/main/groovy/org/scoverage/ScoverageRunner.groovy deleted file mode 100644 index a5dd552..0000000 --- a/src/main/groovy/org/scoverage/ScoverageRunner.groovy +++ /dev/null @@ -1,34 +0,0 @@ -package org.scoverage - -import org.gradle.api.file.FileCollection -import org.gradle.api.tasks.Classpath - -import java.lang.reflect.Method - -class ScoverageRunner { - - @Classpath - final FileCollection runtimeClasspath - - ScoverageRunner(FileCollection runtimeClasspath) { - - this.runtimeClasspath = runtimeClasspath - } - - def run(Closure action) { - - URLClassLoader cloader = (URLClassLoader) Thread.currentThread().getContextClassLoader() - - Method method = URLClassLoader.class.getDeclaredMethod("addURL", URL.class) - method.setAccessible(true) - - runtimeClasspath.files.each { f -> - def url = f.toURI().toURL() - if (!cloader.getURLs().contains(url)) { - method.invoke(cloader, url) - } - } - - action.call() - } -} diff --git a/src/main/groovy/org/scoverage/ScoverageWriter.java b/src/main/groovy/org/scoverage/ScoverageWriter.java deleted file mode 100644 index 1e09105..0000000 --- a/src/main/groovy/org/scoverage/ScoverageWriter.java +++ /dev/null @@ -1,120 +0,0 @@ -package org.scoverage; - -import org.gradle.api.logging.Logger; -import scala.Option; -import scala.Some; -import scala.collection.immutable.Seq; -import scala.collection.mutable.Buffer; -import scoverage.Constants; -import scoverage.Coverage; -import scoverage.report.CoberturaXmlWriter; -import scoverage.report.ScoverageHtmlWriter; -import scoverage.report.ScoverageXmlWriter; -import scala.collection.JavaConverters; - -import java.io.File; -import java.lang.reflect.Constructor; -import java.lang.reflect.InvocationTargetException; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Set; - -/** - * Util for generating and saving coverage files. - * Copied from sbt-scoverage and converted to Java to avoid dependency to Scala. - */ -public class ScoverageWriter { - - private final Logger logger; - - public ScoverageWriter(Logger logger) { - - this.logger = logger; - } - - /** - * Generates all reports from given data. - * - * @param sourceDirs directories with project sources - * @param reportDir directory for generate reports - * @param coverage coverage data - * @param sourceEncoding the encoding of the source files - * @param coverageOutputCobertura switch for Cobertura output - * @param coverageOutputXML switch for Scoverage XML output - * @param coverageOutputHTML switch for Scoverage HTML output - * @param coverageDebug switch for Scoverage Debug output - */ - public void write(Set sourceDirs, - File reportDir, - Coverage coverage, - String sourceEncoding, - Boolean coverageOutputCobertura, - Boolean coverageOutputXML, - Boolean coverageOutputHTML, - Boolean coverageDebug) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, InstantiationException { - - logger.info("[scoverage] Generating scoverage reports..."); - - reportDir.mkdirs(); - - Object scalaBuffer = Class.forName("scala.collection.JavaConverters") - .getMethod("asScalaBuffer", java.util.List.class) - .invoke(null, new ArrayList<>(sourceDirs)); - Object sourceDirsSeq = scalaBuffer.getClass().getMethod("toIndexedSeq").invoke(scalaBuffer); - - if (coverageOutputCobertura) { - Constructor cst; - try { - cst = CoberturaXmlWriter.class.getConstructor(Class.forName("scala.collection.immutable.Seq"), File.class); - } catch (NoSuchMethodException | ClassNotFoundException e) { - cst = CoberturaXmlWriter.class.getConstructor(Class.forName("scala.collection.Seq"), File.class); - } - CoberturaXmlWriter writer = cst.newInstance(sourceDirsSeq, reportDir); - writer.write(coverage); - logger.info("[scoverage] Written Cobertura XML report to " + - reportDir.getAbsolutePath() + - File.separator + - "cobertura.xml"); - } - - if (coverageOutputXML) { - Constructor cst; - try { - cst = ScoverageXmlWriter.class.getConstructor(Class.forName("scala.collection.immutable.Seq"), File.class, boolean.class); - } catch (NoSuchMethodException | ClassNotFoundException e) { - cst = ScoverageXmlWriter.class.getConstructor(Class.forName("scala.collection.Seq"), File.class, boolean.class); - } - ScoverageXmlWriter writer = cst.newInstance(sourceDirsSeq, reportDir, false); - writer.write(coverage); - logger.info("[scoverage] Written XML report to " + - reportDir.getAbsolutePath() + - File.separator + - Constants.XMLReportFilename()); - if (coverageDebug) { - ScoverageXmlWriter writerDebug = cst.newInstance(sourceDirsSeq, reportDir, true); - writerDebug.write(coverage); - logger.info("[scoverage] Written XML report with debug information to " + - reportDir.getAbsolutePath() + - File.separator + - Constants.XMLReportFilenameWithDebug()); - } - } - - if (coverageOutputHTML) { - Constructor cst; - try { - cst = ScoverageHtmlWriter.class.getConstructor(Class.forName("scala.collection.immutable.Seq"), File.class, Option.class); - } catch (NoSuchMethodException | ClassNotFoundException e) { - cst = ScoverageHtmlWriter.class.getConstructor(Class.forName("scala.collection.Seq"), File.class, Option.class); - } - ScoverageHtmlWriter writer = cst.newInstance(sourceDirsSeq, reportDir, new Some<>(sourceEncoding)); - writer.write(coverage); - logger.info("[scoverage] Written HTML report to " + - reportDir.getAbsolutePath() + - File.separator + - "index.html"); - } - - logger.info("[scoverage] Coverage reports completed"); - } -} diff --git a/src/main/kotlin/org/scoverage/CoverageChecker.kt b/src/main/kotlin/org/scoverage/CoverageChecker.kt new file mode 100644 index 0000000..51574a6 --- /dev/null +++ b/src/main/kotlin/org/scoverage/CoverageChecker.kt @@ -0,0 +1,94 @@ +package org.scoverage + +import groovy.xml.XmlParser +import org.gradle.api.GradleException +import org.gradle.internal.impldep.com.google.common.annotations.VisibleForTesting +import org.slf4j.Logger +import java.io.File +import java.io.FileNotFoundException + +import java.text.DecimalFormat +import java.text.NumberFormat +import java.util.* +import kotlin.jvm.Throws + +/** + * Handles different types of coverage Scoverage can measure. + * + * @param configurationName Name of enum option the way it appears in the build configuration. + * @param fileName Name of file with coverage data. + * @param paramName Name of param in XML file with coverage value. + * @param factor Used to normalize coverage value. + */ +enum class CoverageType( + private val configurationName: String, + val fileName: String, + val paramName: String, + private val factor: Double +) { + Line("Line", "cobertura.xml", "line-rate", 1.0), + Statement("Statement", "scoverage.xml", "statement-rate", 100.0), + Branch("Branch", "scoverage.xml", "branch-rate", 100.0); + + /** Normalize coverage value to [0, 1] */ + fun normalize(value: Double): Double = value / factor + + companion object { + fun find(configurationName: String): CoverageType? { + return values().find { it -> it.configurationName.equals(configurationName, ignoreCase = true) } + } + } +} + +/** + * Throws a GradleException if overall coverage dips below the configured percentage. + */ +class CoverageChecker(private val logger: Logger) { + + @JvmOverloads + @Throws(GradleException::class) + fun checkLineCoverage( + reportDir: File, + coverageType: CoverageType, + minimumRate: Double, + nf: NumberFormat = NumberFormat.getInstance(Locale.getDefault()) + ) { + logger.info("Checking coverage. Type: {}. Minimum rate: {}", coverageType, minimumRate) + + val parser = XmlParser() + parser.setFeature("http://apache.org/xml/features/disallow-doctype-decl", false) + parser.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false) + + val df = DecimalFormat("#.##") + + try { + val reportFile = File(reportDir, coverageType.fileName) + val xml = parser.parse(reportFile) + val coverageValue: Double = nf.parse(xml.attribute(coverageType.paramName) as String).toDouble() + val overallRate: Double = coverageType.normalize(coverageValue) + + val difference = minimumRate - overallRate + + if (difference > 1e-7) { + val iss = df.format(overallRate * 100) + val needed = df.format(minimumRate * 100) + throw GradleException(errorMsg(iss, needed, coverageType)) + } + } catch (fnfe: FileNotFoundException) { + throw GradleException(fileNotFoundErrorMsg(coverageType), fnfe) + } + } + + companion object { + @VisibleForTesting + internal fun errorMsg(actual: String, expected: String, type: CoverageType): String { + return "Only $actual% of project is covered by tests instead of $expected% (coverageType: $type)" + } + + @VisibleForTesting + internal fun fileNotFoundErrorMsg(coverageType: CoverageType): String { + return "Coverage file (type: $coverageType) not found, check your configuration." + } + } + +} diff --git a/src/main/kotlin/org/scoverage/ScoverageAggregate.kt b/src/main/kotlin/org/scoverage/ScoverageAggregate.kt new file mode 100644 index 0000000..d97ead0 --- /dev/null +++ b/src/main/kotlin/org/scoverage/ScoverageAggregate.kt @@ -0,0 +1,74 @@ +package org.scoverage + +import org.gradle.api.DefaultTask +import org.gradle.api.file.ConfigurableFileCollection +import org.gradle.api.file.FileCollection +import org.gradle.api.provider.ListProperty +import org.gradle.api.provider.Property +import org.gradle.api.tasks.Input +import org.gradle.api.tasks.InputFiles +import org.gradle.api.tasks.Nested +import org.gradle.api.tasks.OutputDirectory +import org.gradle.api.tasks.PathSensitive +import org.gradle.api.tasks.TaskAction +import scoverage.report.CoverageAggregator + +import org.gradle.api.tasks.PathSensitivity.RELATIVE +import java.io.File + +abstract class ScoverageAggregate: DefaultTask() { + + @Nested + var runner: ScoverageRunner? = null + + @InputFiles + @PathSensitive(RELATIVE) + val sources: ConfigurableFileCollection = project.objects.fileCollection() + + @OutputDirectory + val reportDir: Property = project.objects.property(File::class.java) + + @Input + val dirsToAggregateFrom: ListProperty = project.objects.listProperty(File::class.java) + + @Input + val deleteReportsOnAggregation: Property = project.objects.property(Boolean::class.java) + + @Input + val sourceEncoding: Property = project.objects.property(String::class.java) + + // TODO - consider separate options for `report` and `aggregate` tasks + @Input + val coverageOutputCobertura: Property = project.objects.property(Boolean::class.java) + @Input + val coverageOutputXML: Property = project.objects.property(Boolean::class.java) + @Input + val coverageOutputHTML: Property = project.objects.property(Boolean::class.java) + @Input + val coverageDebug: Property = project.objects.property(Boolean::class.java) + + @TaskAction + fun aggregate() { + runner?.run { + reportDir.get().deleteRecursively() + reportDir.get().mkdirs() + + val dirs = dirsToAggregateFrom.get() + val uniqueDirs = dirs.toSet() + val coverage = CoverageAggregator.aggregate(uniqueDirs.toTypedArray()) + + if (coverage.nonEmpty()) { + ScoverageWriter(project.logger).write( + sources.files, + reportDir.get(), + coverage.get(), + sourceEncoding.get(), + coverageOutputCobertura.get(), + coverageOutputXML.get(), + coverageOutputHTML.get(), + coverageDebug.get() + ) + } + } + } +} diff --git a/src/main/kotlin/org/scoverage/ScoverageExtension.kt b/src/main/kotlin/org/scoverage/ScoverageExtension.kt new file mode 100644 index 0000000..20d6ff5 --- /dev/null +++ b/src/main/kotlin/org/scoverage/ScoverageExtension.kt @@ -0,0 +1,86 @@ +package org.scoverage + +import groovy.lang.Closure +import org.gradle.api.Project +import org.gradle.api.plugins.JavaPlugin +import org.gradle.api.plugins.scala.ScalaPlugin +import org.gradle.api.provider.ListProperty +import org.gradle.api.provider.Property +import java.io.File +import java.math.BigDecimal + +/** + * Defines a new SourceSet for the code to be instrumented. + * Defines a new Test Task which executes normal tests with the instrumented classes. + * Defines a new Check Task which enforces an overall line coverage requirement. + */ +abstract class ScoverageExtension(val project: Project) { + + companion object { + @JvmField + val DEFAULT_REPORT_DIR = "reports" + File.separatorChar + "scoverage" + @JvmField + val DEFAULT_COVERAGE_TYPE: CoverageType = CoverageType.Statement + const val DEFAULT_MINIMUM_RATE: Double = 0.75 + } + + /** Version of scoverage to use for the scalac plugin */ + val scoverageVersion: Property = project.objects.property(String::class.java) + + /** Version of scala to use for the scalac plugin */ + val scoverageScalaVersion: Property = project.objects.property(String::class.java) + + /** a directory to write working files to */ + val dataDir: Property = project.objects.property(File::class.java) + /** a directory to write final output to */ + val reportDir: Property = project.objects.property(File::class.java) + /** range positioning for highlighting */ + val highlighting: Property = project.objects.property(Boolean::class.java) + /** regex for each excluded package */ + val excludedPackages: ListProperty = project.objects.listProperty(String::class.java) + /** regex for each excluded file */ + val excludedFiles: ListProperty = project.objects.listProperty(String::class.java) + + /** Options for enabling and disabling output */ + val coverageOutputCobertura: Property = project.objects.property(Boolean::class.java) + val coverageOutputXML: Property = project.objects.property(Boolean::class.java) + val coverageOutputHTML: Property = project.objects.property(Boolean::class.java) + val coverageDebug: Property = project.objects.property(Boolean::class.java) + + val deleteReportsOnAggregation: Property = project.objects.property(Boolean::class.java) + + val checks: MutableList = mutableListOf() + + val coverageType: Property = project.objects.property(CoverageType::class.java) + val minimumRate: Property = project.objects.property(BigDecimal::class.java) + + init { + project.plugins.apply(JavaPlugin::class.java) + project.plugins.apply(ScalaPlugin::class.java) + + scoverageVersion.set("1.4.8") + + dataDir.set(File(project.buildDir, "scoverage")) + reportDir.set(File(project.buildDir, DEFAULT_REPORT_DIR)) + + highlighting.set(true) + + excludedPackages.set(listOf()) + excludedFiles.set(listOf()) + + coverageOutputCobertura.set(true) + coverageOutputXML.set(true) + coverageOutputHTML.set(true) + coverageDebug.set(false) + + deleteReportsOnAggregation.set(false) + } + + fun check(closure: Closure<*>) { + val check = CheckConfig() + project.configure(check, closure) + checks.add(check) + } + + data class CheckConfig(var coverageType: CoverageType? = null, var minimumRate: BigDecimal? = null) +} diff --git a/src/main/kotlin/org/scoverage/ScoveragePlugin.kt b/src/main/kotlin/org/scoverage/ScoveragePlugin.kt new file mode 100644 index 0000000..ce67ca1 --- /dev/null +++ b/src/main/kotlin/org/scoverage/ScoveragePlugin.kt @@ -0,0 +1,414 @@ +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 +import org.gradle.api.tasks.scala.ScalaCompile +import org.gradle.api.tasks.testing.Test + +import java.nio.file.Files +import java.util.concurrent.ConcurrentHashMap + +import org.gradle.api.execution.TaskExecutionGraph +import org.gradle.api.file.SourceDirectorySet +import org.gradle.api.tasks.* +import org.gradle.kotlin.dsl.closureOf +import org.gradle.kotlin.dsl.getByType +import org.gradle.kotlin.dsl.the +import java.io.File +import java.math.BigDecimal +import java.nio.file.Path + +class ScoveragePlugin : Plugin { + + companion object { + const val CONFIGURATION_NAME = "scoverage" + const val REPORT_NAME = "reportScoverage" + const val CHECK_NAME = "checkScoverage" + const val COMPILE_NAME = "compileScoverageScala" + const val AGGREGATE_NAME = "aggregateScoverage" + const val DEFAULT_SCALA_VERSION = "2.13.6" + const val SCOVERAGE_COMPILE_ONLY_PROPERTY = "scoverageCompileOnly" + + @JvmField + val DEFAULT_REPORT_DIR = ScoverageExtension.DEFAULT_REPORT_DIR + } + + private val crossProjectTaskDependencies: ConcurrentHashMap> = ConcurrentHashMap() + private val sameProjectTaskDependencies: ConcurrentHashMap> = ConcurrentHashMap() + + override fun apply(pluginAware: PluginAware) { + if (pluginAware is Project) { + applyProject(pluginAware) + } else if (pluginAware is Gradle) { + pluginAware.allprojects { + plugins.apply(ScoveragePlugin::class.java) + } + } else { + throw IllegalArgumentException("${pluginAware.javaClass} is currently not supported as an apply target, please report if you need it") + } + } + + fun applyProject(project: Project) { + + if (project.plugins.hasPlugin(ScoveragePlugin::class.java)) { + project.logger.info("Project ${project.name} already has the scoverage plugin") + return + } + project.logger.info("Applying scoverage plugin to $project.name") + + val extension = project.extensions.create("scoverage", ScoverageExtension::class.java, project) + if (!project.configurations.asMap.containsKey(CONFIGURATION_NAME)) { + project.configurations.create(CONFIGURATION_NAME) { + setVisible(false) + setTransitive(true) + setDescription("Scoverage dependencies") + } + + project.afterEvaluate { + val scalaFullVersion = resolveScalaVersion(project) + val scalaBinaryVersion = scalaFullVersion.substring(0, scalaFullVersion.lastIndexOf('.')) + val scoverageVersion = + project.extensions.getByType(ScoverageExtension::class.java).scoverageVersion.get() + + project.logger.info("Using scoverage scalac plugin $scoverageVersion for scala $scalaFullVersion") + + project.dependencies.add( + CONFIGURATION_NAME, + "org.scoverage:scalac-scoverage-plugin_$scalaFullVersion:$scoverageVersion" + ) + project.dependencies.add( + CONFIGURATION_NAME, + "org.scoverage:scalac-scoverage-runtime_$scalaBinaryVersion:$scoverageVersion" + ) + } + } + + createTasks(project, extension) + } + + private fun createTasks(project: Project, extension: ScoverageExtension) { + + val scoverageRunner = ScoverageRunner(project.configurations.getByName(CONFIGURATION_NAME)) + + val sourceSets = project.the() + val originalSourceSet = sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME) + val originalScalaSourceSet = originalSourceSet.extensions.getByType() + val instrumentedSourceSet = sourceSets.create("scoverage") { + resources.source(originalSourceSet.resources) + java.source(originalSourceSet.java) + extensions.getByType().setSrcDirs(originalScalaSourceSet.sourceDirectories) + + annotationProcessorPath += originalSourceSet.annotationProcessorPath + project.configurations.getByName( + CONFIGURATION_NAME + ) + compileClasspath += originalSourceSet.compileClasspath + project.configurations.getByName(CONFIGURATION_NAME) + runtimeClasspath = + output + project.configurations.getByName(CONFIGURATION_NAME) + originalSourceSet.runtimeClasspath + } + + val originalCompileTask = + project.tasks.named(originalSourceSet.getCompileTaskName("scala"), ScalaCompile::class.java).get() + val originalJarTask = project.tasks.getByName(originalSourceSet.jarTaskName) + + val compileTask = + project.tasks.named(instrumentedSourceSet.getCompileTaskName("scala"), ScalaCompile::class.java).get() + compileTask.mustRunAfter(originalCompileTask) + + val globalReportTask = project.tasks.register(REPORT_NAME, ScoverageAggregate::class.java) + val globalCheckTask = project.tasks.register(CHECK_NAME) + + project.afterEvaluate { + val detectedSourceEncoding = compileTask.scalaCompileOptions.encoding ?: "UTF-8" + + // calling toList() on TaskCollection is required + // to avoid potential ConcurrentModificationException in multi-project builds + val testTasks = project.tasks.withType(Test::class.java).toList() + + val reportTasks: List = testTasks.map { testTask -> + testTask.mustRunAfter(compileTask) + + val reportTaskName = "report${testTask.name.capitalize()}Scoverage" + val taskReportDir = project.file("${project.buildDir}/reports/scoverage${testTask.name.capitalize()}") + + project.tasks.create(reportTaskName, ScoverageReport::class.java) { + dependsOn(originalJarTask, compileTask, testTask) + onlyIf { extension.dataDir.get().list()?.isNotEmpty() ?: false } + group = "verification" + runner = scoverageRunner + reportDir.set(taskReportDir) + sources.set(originalScalaSourceSet.sourceDirectories) + dataDir.set(extension.dataDir) + sourceEncoding.set(detectedSourceEncoding) + coverageOutputCobertura.set(extension.coverageOutputCobertura) + coverageOutputXML.set(extension.coverageOutputXML) + coverageOutputHTML.set(extension.coverageOutputHTML) + coverageDebug.set(extension.coverageDebug) + } + } + + globalReportTask.configure { + val dataDirs = reportTasks.map { it.dataDir.get() } + + dependsOn(reportTasks).onlyIf { dataDirs.any { it.list()?.isNotEmpty() ?: false } } + + group = "verification" + runner = scoverageRunner + reportDir.set(extension.reportDir) + sources.from(originalScalaSourceSet.sourceDirectories) + dirsToAggregateFrom.set(dataDirs) + sourceEncoding.set(detectedSourceEncoding) + deleteReportsOnAggregation.set(false) + coverageOutputCobertura.set(extension.coverageOutputCobertura) + coverageOutputXML.set(extension.coverageOutputXML) + coverageOutputHTML.set(extension.coverageOutputHTML) + coverageDebug.set(extension.coverageDebug) + } + + configureCheckTask(project, extension, globalCheckTask, globalReportTask) + + + compileTask.configure(closureOf { + val parameters = this.scalaCompileOptions.additionalParameters?.toMutableList() ?: mutableListOf() + + parameters.add("-P:scoverage:dataDir:${extension.dataDir.get().absolutePath}") + if (extension.excludedPackages.get().isNotEmpty()) { + val packages = extension.excludedPackages.get().joinToString(";") + parameters.add("-P:scoverage:excludedPackages:$packages") + } + if (extension.excludedFiles.get().isNotEmpty()) { + val packages = extension.excludedFiles.get().joinToString(";") + parameters.add("-P:scoverage:excludedFiles:$packages") + } + if (extension.highlighting.get()) { + parameters.add("-Yrangepos") + } + scalaCompileOptions.additionalParameters = parameters + // the compile task creates a store of measured statements + outputs.file(File(extension.dataDir.get(), "scoverage.coverage")) + + dependsOn(project.configurations.getByName(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). + */ + val pluginFile = project.configurations.getByName(CONFIGURATION_NAME).find { + it.name.startsWith("scalac-scoverage-plugin") + }!! + parameters.add("-Xplugin:" + pluginFile.absolutePath) + } + }) + + if (project.hasProperty(SCOVERAGE_COMPILE_ONLY_PROPERTY)) { + project.logger.info("Making scoverage compilation the primary compilation task (instead of compileScala)") + + originalCompileTask.enabled = false; + compileTask.destinationDirectory.set(originalCompileTask.destinationDirectory) + + project.tasks.forEach { + if (recursiveDependenciesOf(it, true).contains(originalCompileTask)) { + it.dependsOn(compileTask) + } + } + + // make this project's scoverage compilation depend on scoverage compilation of any other project + // which this project depends on its normal compilation + val originalCompilationDependencies = + recursiveDependenciesOf(compileTask, false).filterIsInstance() + originalCompilationDependencies.forEach { + val dependencyProjectCompileTask = it.project.tasks.findByName(COMPILE_NAME) + val dependencyProjectReportTask = it.project.tasks.findByName(REPORT_NAME) + if (dependencyProjectCompileTask != null) { + compileTask.dependsOn(dependencyProjectCompileTask) + // we don't want this project's tests to affect the other project's report + testTasks.forEach { + it.mustRunAfter(dependencyProjectReportTask) + } + } + } + } else { + compileTask.configure(closureOf { + doFirst { + destinationDirectory.get().asFile.deleteRecursively() + } + + // 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)") + val originalDestinationDir = originalCompileTask.destinationDirectory.get().asFile.toPath() + val destinationDir = destinationDirectory.get().asFile.toPath() + + fun findFiles(dir: Path, condition: (Path) -> Boolean = { _ -> true }): Sequence { + return dir.toFile().walk().filter { f -> + f.isFile && condition(f.toPath()) + }.map { f -> + dir.relativize(f.toPath()) + } + } + + fun isSameFile(relativePath: Path): Boolean { + val fileA = originalDestinationDir.resolve(relativePath) + val fileB = destinationDir.resolve(relativePath) + return FileUtils.contentEquals(fileA.toFile(), fileB.toFile()) + } + + val originalClasses = findFiles(originalDestinationDir) + val identicalInstrumentedClasses = findFiles(destinationDir) { + val relativePath = destinationDir.relativize(it) + originalClasses.contains(relativePath) && isSameFile(relativePath) + } + + identicalInstrumentedClasses.forEach { + Files.deleteIfExists(destinationDir.resolve(it)) + } + } + }) + } + + project.gradle.taskGraph.whenReady(closureOf { + val hasAnyReportTask = reportTasks.any { this.hasTask(it) } + + if (hasAnyReportTask) { + project.tasks.withType(Test::class.java).forEach { + it.configure(closureOf { + project.logger.info("Adding instrumented classes to '${path}' classpath") + + classpath = + project.configurations.getByName(CONFIGURATION_NAME) + instrumentedSourceSet.output + classpath + + outputs.upToDateWhen { + extension.dataDir.get().listFiles { _, name -> + name.startsWith("scoverage.measurements.") + }?.isNotEmpty() ?: false + } + }) + } + } + }) + + // define aggregation task + if (project.subprojects.isNotEmpty()) { + project.gradle.projectsEvaluated { + project.subprojects.forEach { + if (it.plugins.hasPlugin(ScalaPlugin::class.java) && !it.plugins.hasPlugin(ScoveragePlugin::class.java)) { + it.logger.warn("Scala sub-project '${it.name}' doesn't have Scoverage applied and will be ignored in parent project aggregation") + } + } + val childReportTasks = project.subprojects.flatMap { + it.tasks.filterIsInstance().filter { task -> + task.name == REPORT_NAME + } + } + val allReportTasks = childReportTasks + globalReportTask.get() + val allSources = project.objects.fileCollection() + allReportTasks.forEach { + allSources.from(it.sources) + } + val aggregationTask = project.tasks.create(AGGREGATE_NAME, ScoverageAggregate::class.java) { + val dataDirs = allReportTasks.map { it.dirsToAggregateFrom.get() }.flatten() + onlyIf { + childReportTasks.isNotEmpty() + } + dependsOn(allReportTasks) + group = "verification" + runner = scoverageRunner + reportDir.set(extension.reportDir) + sources.from(allSources) + sourceEncoding.set(detectedSourceEncoding) + dirsToAggregateFrom.set(dataDirs) + deleteReportsOnAggregation.set(extension.deleteReportsOnAggregation) + coverageOutputCobertura.set(extension.coverageOutputCobertura) + coverageOutputXML.set(extension.coverageOutputXML) + coverageOutputHTML.set(extension.coverageOutputHTML) + coverageDebug.set(extension.coverageDebug) + } + project.tasks.getByName(CHECK_NAME).mustRunAfter(aggregationTask) + } + } + } + } + + private fun configureCheckTask( + project: Project, extension: ScoverageExtension, + globalCheckTask: TaskProvider, + globalReportTask: TaskProvider + ) { + + if (extension.checks.isEmpty()) { + extension.check(closureOf { + minimumRate = + extension.minimumRate.getOrElse(BigDecimal.valueOf(ScoverageExtension.DEFAULT_MINIMUM_RATE)) + coverageType = extension.coverageType.getOrElse(ScoverageExtension.DEFAULT_COVERAGE_TYPE) + }) + } else if (extension.minimumRate.isPresent() || extension.coverageType.isPresent()) { + throw IllegalArgumentException("Check configuration should be defined in either the new or the old syntax exclusively, not together") + } + + val checker = CoverageChecker(project.logger) + + globalCheckTask.configure { + group = "verification" + dependsOn(globalReportTask).onlyIf { extension.reportDir.get().list()?.isNotEmpty() ?: false } + } + + extension.checks.forEach { config -> + globalCheckTask.configure { + doLast { + checker.checkLineCoverage( + extension.reportDir.get(), + config.coverageType!!, + config.minimumRate?.toDouble()!! + ) + } + } + } + } + + private fun resolveScalaVersion(project: Project): String { + + val scalaVersionProperty = project.extensions.getByType(ScoverageExtension::class.java).scoverageScalaVersion + if (scalaVersionProperty.isPresent) { + val configuredScalaVersion = scalaVersionProperty.get() + project.logger.info("Using configured Scala version: $configuredScalaVersion") + return configuredScalaVersion + } else { + project.logger.info("No Scala version configured. Detecting scala library...") + val components = + project.configurations.getByName("compileClasspath").incoming.resolutionResult.allComponents + val scalaLibrary = components.find { + it.moduleVersion?.group == "org.scala-lang" && it.moduleVersion?.name == "scala-library" + } + if (scalaLibrary != null) { + val scalaVersion = scalaLibrary.moduleVersion?.version!! + project.logger.info("Detected scala library in compilation classpath. Scala version: $scalaVersion") + return scalaVersion + } else { + project.logger.info("No scala library detected. Using default Scala version: $DEFAULT_SCALA_VERSION") + return DEFAULT_SCALA_VERSION + } + } + } + + private fun recursiveDependenciesOf(task: Task, sameProjectOnly: Boolean): Set { + val cache = if (sameProjectOnly) sameProjectTaskDependencies else crossProjectTaskDependencies + + return cache[task] ?: run { + var directDependencies: Set = task.taskDependencies.getDependencies(task) + if (sameProjectOnly) { + directDependencies = directDependencies.filter { + it.project == task.project + }.toSet() + } + val nestedDependencies = directDependencies.flatMap { recursiveDependenciesOf(it, sameProjectOnly) } + val dependencies = directDependencies + nestedDependencies + + cache.put(task, dependencies) + dependencies + } + } +} diff --git a/src/main/groovy/org/scoverage/ScoverageReport.groovy b/src/main/kotlin/org/scoverage/ScoverageReport.kt similarity index 54% rename from src/main/groovy/org/scoverage/ScoverageReport.groovy rename to src/main/kotlin/org/scoverage/ScoverageReport.kt index 8a15aab..b5dc260 100644 --- a/src/main/groovy/org/scoverage/ScoverageReport.groovy +++ b/src/main/kotlin/org/scoverage/ScoverageReport.kt @@ -13,49 +13,50 @@ import org.gradle.api.tasks.PathSensitive import org.gradle.api.tasks.TaskAction import scoverage.report.CoverageAggregator -import static org.gradle.api.tasks.PathSensitivity.RELATIVE +import org.gradle.api.tasks.PathSensitivity.RELATIVE +import java.io.File @CacheableTask -class ScoverageReport extends DefaultTask { +abstract class ScoverageReport: DefaultTask() { @Nested - ScoverageRunner runner + var runner: ScoverageRunner? = null @InputDirectory @PathSensitive(RELATIVE) - final Property dataDir = project.objects.property(File) + val dataDir: Property = project.objects.property(File::class.java) @InputFiles @PathSensitive(RELATIVE) - final Property sources = project.objects.property(FileCollection) + val sources: Property = project.objects.property(FileCollection::class.java) @OutputDirectory - final Property reportDir = project.objects.property(File) + val reportDir: Property = project.objects.property(File::class.java) @Input - final Property sourceEncoding = project.objects.property(String) + val sourceEncoding: Property = project.objects.property(String::class.java) @Input - final Property coverageOutputCobertura = project.objects.property(Boolean) + val coverageOutputCobertura: Property = project.objects.property(Boolean::class.java) @Input - final Property coverageOutputXML = project.objects.property(Boolean) + val coverageOutputXML: Property = project.objects.property(Boolean::class.java) @Input - final Property coverageOutputHTML = project.objects.property(Boolean) + val coverageOutputHTML: Property = project.objects.property(Boolean::class.java) @Input - final Property coverageDebug = project.objects.property(Boolean) + val coverageDebug: Property = project.objects.property(Boolean::class.java) @TaskAction - def report() { - runner.run { + fun report() { + runner?.run { reportDir.get().delete() reportDir.get().mkdirs() - def coverage = CoverageAggregator.aggregate([dataDir.get()] as File[]) + val coverage = CoverageAggregator.aggregate(arrayOf(dataDir.get())) - if (coverage.isEmpty()) { + if (coverage.isEmpty) { project.logger.info("[scoverage] Could not find coverage file, skipping...") } else { - new ScoverageWriter(project.logger).write( + ScoverageWriter(project.logger).write( sources.get().getFiles(), reportDir.get(), coverage.get(), diff --git a/src/main/kotlin/org/scoverage/ScoverageRunner.kt b/src/main/kotlin/org/scoverage/ScoverageRunner.kt new file mode 100644 index 0000000..4e9808a --- /dev/null +++ b/src/main/kotlin/org/scoverage/ScoverageRunner.kt @@ -0,0 +1,26 @@ +package org.scoverage + +import groovy.lang.Closure +import org.gradle.api.file.FileCollection +import org.gradle.api.tasks.Classpath +import java.net.URL +import java.net.URLClassLoader + +class ScoverageRunner(@Classpath val runtimeClasspath: FileCollection) { + + fun run(action: () -> Unit) { + val cloader = Thread.currentThread().getContextClassLoader() as URLClassLoader + + val method = URLClassLoader::class.java.getDeclaredMethod("addURL", URL::class.java) + method.isAccessible = true + + runtimeClasspath.files.forEach { f -> + val url = f.toURI().toURL() + if (!cloader.urLs.contains(url)) { + method.invoke(cloader, url) + } + } + + action() + } +} diff --git a/src/main/kotlin/org/scoverage/ScoverageWriter.kt b/src/main/kotlin/org/scoverage/ScoverageWriter.kt new file mode 100644 index 0000000..2426c90 --- /dev/null +++ b/src/main/kotlin/org/scoverage/ScoverageWriter.kt @@ -0,0 +1,137 @@ +package org.scoverage + +import org.gradle.api.logging.Logger +import scala.Option +import scala.Some +import scoverage.Constants +import scoverage.Coverage +import scoverage.report.CoberturaXmlWriter +import scoverage.report.ScoverageHtmlWriter +import scoverage.report.ScoverageXmlWriter +import java.io.File +import java.lang.reflect.Constructor + +/** + * Util for generating and saving coverage files. + * Copied from sbt-scoverage and converted to Java to avoid dependency to Scala. + */ +class ScoverageWriter(private val logger: Logger) { + + /** + * Generates all reports from given data. + * + * @param sourceDirs directories with project sources + * @param reportDir directory for generate reports + * @param coverage coverage data + * @param sourceEncoding the encoding of the source files + * @param coverageOutputCobertura switch for Cobertura output + * @param coverageOutputXML switch for Scoverage XML output + * @param coverageOutputHTML switch for Scoverage HTML output + * @param coverageDebug switch for Scoverage Debug output + */ + @Throws(ReflectiveOperationException::class) + fun write( + sourceDirs: Set, + reportDir: File, + coverage: Coverage, + sourceEncoding: String, + coverageOutputCobertura: Boolean, + coverageOutputXML: Boolean, + coverageOutputHTML: Boolean, + coverageDebug: Boolean + ) { + + logger.info("[scoverage] Generating scoverage reports...") + + reportDir.mkdirs() + + val scalaBuffer = Class.forName("scala.collection.JavaConverters") + .getMethod( + "asScalaBuffer", java.util.List::class.java + ) + .invoke(null, listOf(*sourceDirs.toTypedArray())) + val sourceDirsSeq = scalaBuffer.javaClass.getMethod("toIndexedSeq").invoke(scalaBuffer) + + if (coverageOutputCobertura) { + val cst: Constructor = try { + CoberturaXmlWriter::class.java.getConstructor( + Class.forName("scala.collection.immutable.Seq"), + File::class.java + ) + } catch (e: ReflectiveOperationException) { + CoberturaXmlWriter::class.java.getConstructor( + Class.forName("scala.collection.Seq"), + File::class.java + ) + } + val writer = cst.newInstance(sourceDirsSeq, reportDir) + writer.write(coverage) + logger.info( + "[scoverage] Written Cobertura XML report to " + + reportDir.absolutePath + + File.separator + + "cobertura.xml" + ) + } + + if (coverageOutputXML) { + val cst: Constructor = try { + ScoverageXmlWriter::class.java.getConstructor( + Class.forName("scala.collection.immutable.Seq"), + File::class.java, + Boolean::class.java + ) + } catch (e: ReflectiveOperationException) { + ScoverageXmlWriter::class.java.getConstructor( + Class.forName("scala.collection.Seq"), + File::class.java, + Boolean::class.java + ) + } + val writer = cst.newInstance(sourceDirsSeq, reportDir, false) + writer.write(coverage) + logger.info( + "[scoverage] Written XML report to " + + reportDir.absolutePath + + File.separator + + Constants.XMLReportFilename() + ) + if (coverageDebug) { + val writerDebug = cst.newInstance(sourceDirsSeq, reportDir, true) + writerDebug.write(coverage) + logger.info( + "[scoverage] Written XML report with debug information to " + + reportDir.absolutePath + + File.separator + + Constants.XMLReportFilenameWithDebug() + ) + } + } + + if (coverageOutputHTML) { + val cst: Constructor = try { + ScoverageHtmlWriter::class.java.getConstructor( + Class.forName("scala.collection.immutable.Seq"), + File::class.java, + Option::class.java + ) + } catch (e: ReflectiveOperationException) { + ScoverageHtmlWriter::class.java.getConstructor( + Class.forName("scala.collection.Seq"), + File::class.java, + Option::class.java + ) + } + val writer = cst.newInstance(sourceDirsSeq, reportDir, Some(sourceEncoding)) + writer.write(coverage) + logger.info( + "[scoverage] Written HTML report to " + + reportDir.absolutePath + + File.separator + + "index.html" + ) + } + + logger.info("[scoverage] Coverage reports completed") + } +} diff --git a/src/test/groovy/org/scoverage/CoverageCheckerTest.groovy b/src/test/kotlin/org/scoverage/CoverageCheckerTest.kt similarity index 57% rename from src/test/groovy/org/scoverage/CoverageCheckerTest.groovy rename to src/test/kotlin/org/scoverage/CoverageCheckerTest.kt index 04c695a..44b3030 100644 --- a/src/test/groovy/org/scoverage/CoverageCheckerTest.groovy +++ b/src/test/kotlin/org/scoverage/CoverageCheckerTest.kt @@ -11,25 +11,26 @@ import org.slf4j.LoggerFactory import java.nio.file.Paths import java.text.NumberFormat +import java.util.* -import static org.junit.Assert.assertThat -import static org.junit.jupiter.api.Assertions.assertThrows +import org.junit.Assert.assertThat +import org.junit.jupiter.api.Assertions.assertThrows class CoverageCheckerTest { - private NumberFormat numberFormat = NumberFormat.getInstance(Locale.US) + private val numberFormat = NumberFormat.getInstance(Locale.US) - private File reportDir = Paths.get(getClass().getClassLoader().getResource("checkTask").toURI()).toFile() + private val reportDir = Paths.get(javaClass.getClassLoader().getResource("checkTask").toURI()).toFile() - private CoverageChecker checker = new CoverageChecker(LoggerFactory.getLogger(CoverageCheckerTest.class)) + private val checker = CoverageChecker(LoggerFactory.getLogger(CoverageCheckerTest::class.java)) - @Rule - public TemporaryFolder tempDir = new TemporaryFolder() + @get:Rule + val tempDir = TemporaryFolder() // error when report file is not there @Test - void failsWhenReportFileIsNotFound() { + fun failsWhenReportFileIsNotFound() { assertFailure(CoverageChecker.fileNotFoundErrorMsg(CoverageType.Line), { checker.checkLineCoverage(tempDir.getRoot(), CoverageType.Line, 0.0, numberFormat) }) @@ -38,85 +39,78 @@ class CoverageCheckerTest { // line coverage @Test - void failsWhenLineRateIsBelowTarget() { + fun failsWhenLineRateIsBelowTarget() { assertFailure(CoverageChecker.errorMsg("66", "100", CoverageType.Line), { checker.checkLineCoverage(reportDir, CoverageType.Line, 1.0, numberFormat) }) } @Test - void doesNotFailWhenLineRateIsAtTarget() { + fun doesNotFailWhenLineRateIsAtTarget() { checker.checkLineCoverage(reportDir, CoverageType.Line, 0.66, numberFormat) } @Test - void doesNotFailWhenLineRateIsAboveTarget() { + fun doesNotFailWhenLineRateIsAboveTarget() { checker.checkLineCoverage(reportDir, CoverageType.Line, 0.6, numberFormat) } // Statement coverage @Test - void failsWhenStatementRateIsBelowTarget() { - assertFailure(CoverageChecker.errorMsg(numberFormat.format(new Double(33.33)), "100", CoverageType.Statement), { + fun failsWhenStatementRateIsBelowTarget() { + assertFailure(CoverageChecker.errorMsg(numberFormat.format(33.33), "100", CoverageType.Statement), { checker.checkLineCoverage(reportDir, CoverageType.Statement, 1.0, numberFormat) }) } @Test - void doesNotFailWhenStatementRateIsAtTarget() { + fun doesNotFailWhenStatementRateIsAtTarget() { checker.checkLineCoverage(reportDir, CoverageType.Statement, 0.33, numberFormat) } @Test - void doesNotFailWhenStatementRateIsAboveTarget() { + fun doesNotFailWhenStatementRateIsAboveTarget() { checker.checkLineCoverage(reportDir, CoverageType.Statement, 0.3, numberFormat) } // Branch coverage @Test - void failsWhenBranchRateIsBelowTarget() { + fun failsWhenBranchRateIsBelowTarget() { assertFailure(CoverageChecker.errorMsg("50", "100", CoverageType.Branch), { checker.checkLineCoverage(reportDir, CoverageType.Branch, 1.0, numberFormat) }) } @Test - void doesNotFailWhenBranchRateIsAtTarget() { + fun doesNotFailWhenBranchRateIsAtTarget() { checker.checkLineCoverage(reportDir, CoverageType.Branch, 0.5, numberFormat) } @Test - void doesNotFailWhenBranchRateIsAboveTarget() { + fun doesNotFailWhenBranchRateIsAboveTarget() { checker.checkLineCoverage(reportDir, CoverageType.Branch, 0.45, numberFormat) } - private void assertFailure(String message, Executable executable) { - GradleException e = assertThrows(GradleException.class, executable) - assertThat(e, new CauseMatcher(message)) + private fun assertFailure(message: String, executable: Executable) { + val e: GradleException = assertThrows(GradleException::class.java, executable) + assertThat(e, CauseMatcher(message)) } } /** * Copied from the Internet, just to check if we have correct exception thrown. */ -class CauseMatcher extends TypeSafeMatcher { - - private final String expectedMessage - - CauseMatcher(String expectedMessage) { - this.expectedMessage = expectedMessage - } +class CauseMatcher(private val expectedMessage: String): TypeSafeMatcher() { @Override - protected boolean matchesSafely(GradleException item) { - return item.getMessage().contains(expectedMessage) + protected override fun matchesSafely(item: GradleException): Boolean { + return item.message?.contains(expectedMessage) == true } - @Override - void describeTo(Description description) { + override fun describeTo(description: Description) { description.appendText("expects message ") .appendValue(expectedMessage) } -} \ No newline at end of file +}