Use jacoco-report-aggregation plugin (#3049)

Author: marcphilipp

build.gradle.kts

@@ -4,7 +4,7 @@ plugins {
 	`base-conventions`
 	`build-metadata`
 	`dependency-update-check`
-	`jacoco-conventions`
+	`jacoco-aggregation-conventions`
 	`temp-maven-repo`
 }
 
@@ -47,6 +47,12 @@ val vintageProjects by extra(listOf(
 val mavenizedProjects by extra(platformProjects + jupiterProjects + vintageProjects)
 val modularProjects by extra(mavenizedProjects - listOf(projects.junitPlatformConsoleStandalone.dependencyProject))
 
+dependencies {
+	(modularProjects + listOf(projects.platformTests.dependencyProject)).forEach {
+		jacocoAggregation(project(it.path))
+	}
+}
+
 nexusPublishing {
 	packageGroup.set("org.junit")
 	repositories {
@@ -57,36 +63,3 @@ nexusPublishing {
 nohttp {
 	source.exclude("buildSrc/build/generated-sources/**")
 }
-
-val jacocoTestProjects = listOf(
-	projects.junitJupiterEngine,
-	projects.junitJupiterMigrationsupport,
-	projects.junitJupiterParams,
-	projects.junitVintageEngine,
-	projects.platformTests
-).map { it.dependencyProject }
-val jacocoClassesDir by extra(file("$buildDir/jacoco/classes"))
-
-val jacocoRootReport by tasks.registering(JacocoReport::class) {
-	modularProjects.forEach {
-		dependsOn(it.tasks.named("extractJar"))
-		it.pluginManager.withPlugin("java") {
-			sourceDirectories.from(it.the<SourceSetContainer>()["main"].allSource.srcDirs)
-		}
-	}
-	classDirectories.from(files(jacocoClassesDir))
-	reports {
-		html.required.set(true)
-		xml.required.set(true)
-		csv.required.set(false)
-	}
-}
-
-afterEvaluate {
-	jacocoRootReport {
-		jacocoTestProjects.forEach {
-			executionData(it.tasks.withType<Test>().map { task -> task.the<JacocoTaskExtension>().destinationFile })
-			dependsOn(it.tasks.withType<Test>())
-		}
-	}
-}

buildSrc/src/main/kotlin/jacoco-aggregation-conventions.gradle.kts

@@ -0,0 +1,30 @@
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
+import org.gradle.api.attributes.LibraryElements
+import org.gradle.api.attributes.LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE
+import org.gradle.api.attributes.TestSuiteType
+import org.gradle.kotlin.dsl.invoke
+import org.gradle.kotlin.dsl.`jacoco-report-aggregation`
+import org.gradle.kotlin.dsl.named
+import org.gradle.testing.jacoco.plugins.JacocoCoverageReport
+import org.junit.gradle.jacoco.JacocoConventions.COVERAGE_CLASSES
+
+plugins {
+	id("jacoco-conventions")
+	`jacoco-report-aggregation`
+}
+
+configurations {
+	allCodeCoverageReportClassDirectories {
+		attributes {
+			attribute(LIBRARY_ELEMENTS_ATTRIBUTE, objects.named(LibraryElements::class, COVERAGE_CLASSES))
+		}
+	}
+}
+
+reporting {
+	reports {
+		create<JacocoCoverageReport>("jacocoRootReport") {
+			testType.set(TestSuiteType.UNIT_TEST)
+		}
+	}
+}

buildSrc/src/main/kotlin/jacoco-conventions.gradle.kts

@@ -1,5 +1,3 @@
-import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
-
 plugins {
 	jacoco
 }
@@ -10,51 +8,6 @@ jacoco {
 	toolVersion = requiredVersionFromLibs("jacoco")
 }
 
-tasks {
-	withType<Test>().configureEach {
-		configure<JacocoTaskExtension> {
-			isEnabled = enableJaCoCo
-		}
-	}
-	withType<JacocoReport>().configureEach {
-		enabled = enableJaCoCo
-	}
-}
-
-pluginManager.withPlugin("java") {
-
-	val jacocoClassesDir: File by rootProject.extra
-
-	val jar by tasks.existing(Jar::class)
-
-	val extractJar by tasks.registering(Copy::class) {
-		from(zipTree(jar.map { it.archiveFile }))
-		into(jacocoClassesDir)
-		include("**/*.class")
-		// don't version-specific classes of MR JARs
-		exclude("META-INF/versions/**")
-		includeEmptyDirs = false
-		onlyIf { jar.get().enabled }
-	}
-
-	jar {
-		finalizedBy(extractJar)
-	}
-
-	tasks.named<JacocoReport>("jacocoTestReport") {
-		enabled = false
-	}
-
-	pluginManager.withPlugin("com.github.johnrengelman.shadow") {
-
-		val shadowJar by tasks.existing(ShadowJar::class) {
-			finalizedBy(extractJar)
-		}
-		extractJar {
-			from(zipTree(shadowJar.map { it.archiveFile }))
-			// don't report coverage for shadowed classes
-			exclude("**/shadow/**")
-			onlyIf { shadowJar.get().enabled }
-		}
-	}
+tasks.withType<JacocoReport>().configureEach {
+	enabled = enableJaCoCo
 }

buildSrc/src/main/kotlin/jacoco-java-conventions.gradle.kts

@@ -0,0 +1,32 @@
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
+import org.gradle.api.attributes.LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE
+import org.junit.gradle.jacoco.JacocoConventions.COVERAGE_CLASSES
+
+plugins {
+	java
+	id("jacoco-conventions")
+}
+
+val mavenizedProjects: List<Project> by rootProject.extra
+val enableJaCoCo = project.hasProperty("enableJaCoCo")
+
+tasks.withType<Test>().configureEach {
+	configure<JacocoTaskExtension> {
+		isEnabled = enableJaCoCo
+	}
+}
+
+val codeCoverageClassesJar by tasks.registering(Jar::class) {
+	from(tasks.jar.map { zipTree(it.archiveFile) })
+	archiveClassifier.set("jacoco")
+	enabled = project in mavenizedProjects
+	duplicatesStrategy = DuplicatesStrategy.INCLUDE
+}
+
+configurations.create("codeCoverageReportClasses") {
+	isCanBeResolved = false
+	isCanBeConsumed = true
+	isTransitive = false
+	attributes.attribute(LIBRARY_ELEMENTS_ATTRIBUTE, objects.named(LibraryElements::class, COVERAGE_CLASSES))
+	outgoing.artifact(codeCoverageClassesJar)
+}

buildSrc/src/main/kotlin/java-library-conventions.gradle.kts

@@ -8,7 +8,7 @@ plugins {
 	idea
 	checkstyle
 	id("base-conventions")
-	id("jacoco-conventions")
+	id("jacoco-java-conventions")
 }
 
 val mavenizedProjects: List<Project> by rootProject.extra

buildSrc/src/main/kotlin/org/junit/gradle/jacoco/JacocoConventions.kt

@@ -0,0 +1,5 @@
+package org.junit.gradle.jacoco
+
+object JacocoConventions {
+    const val COVERAGE_CLASSES = "coverage-classes"
+}

buildSrc/src/main/kotlin/shadow-conventions.gradle.kts

@@ -5,12 +5,14 @@ plugins {
 
 val shadowed by configurations.creating
 
-configurations.forEach { configuration ->
-	configuration.outgoing.apply {
-		val removed = artifacts.removeIf { it.classifier.isNullOrEmpty() }
-		if (removed) {
-			artifact(tasks.shadowJar) {
-				classifier = ""
+configurations {
+	listOf(apiElements, runtimeElements).forEach {
+		it.configure {
+			outgoing {
+				artifacts.clear()
+				artifact(tasks.shadowJar) {
+					classifier = ""
+				}
 			}
 		}
 	}
@@ -54,6 +56,10 @@ tasks {
 		dependsOn(shadowJar)
 		enabled = false
 	}
+	named<Jar>("codeCoverageClassesJar") {
+		from(shadowJar.map { zipTree(it.archiveFile) })
+		exclude("**/shadow/**")
+	}
 	test {
 		dependsOn(shadowJar)
 		// in order to run the test against the shadowJar

junit-platform-commons/junit-platform-commons.gradle.kts

@@ -29,6 +29,10 @@ tasks.jar {
 	})
 }
 
+tasks.codeCoverageClassesJar {
+	exclude("org/junit/platform/commons/util/ModuleUtils.class")
+}
+
 eclipse {
 	classpath {
 		sourceSets -= project.sourceSets.mainRelease9.get()

junit-platform-console/junit-platform-console.gradle.kts

@@ -49,6 +49,9 @@ tasks {
 			)
 		})
 	}
+	codeCoverageClassesJar {
+		exclude("org/junit/platform/console/options/ConsoleUtils.class")
+	}
 	jar {
 		manifest {
 			attributes("Main-Class" to "org.junit.platform.console.ConsoleLauncher")