build.gradle

import java.time.OffsetDateTime
import java.time.format.DateTimeFormatter

plugins {
	id 'com.gradle.build-scan' version '1.13.4'
	id 'net.nemerosa.versioning' version '2.6.1'
	id 'com.github.ben-manes.versions' version '0.17.0' apply false
	id 'com.diffplug.gradle.spotless' version '3.12.0' apply false
	id 'org.ajoberstar.git-publish' version '0.4.1' apply false
	id 'org.jetbrains.kotlin.jvm' version '1.2.41' apply false
	id 'com.github.johnrengelman.shadow' version '2.0.4' apply false
}

buildScan {
	licenseAgreementUrl = 'https://gradle.com/terms-of-service'
	licenseAgree = 'yes'
}

def buildTimeAndDate = OffsetDateTime.now()
ext {
	// Generate JAR manifest only if code was compiled or recompiled;
	// otherwise the junitPlatformTest task will always be executed even if
	// no code changes were made. The reason is that the generation of
	// the buildDate and buildTime causes JAR manifests to be modified
	// which triggers unnecessary rebuilding of the dependent JARs.
	generateManifest = false
	buildDate = DateTimeFormatter.ISO_LOCAL_DATE.format(buildTimeAndDate)
	buildTime = DateTimeFormatter.ofPattern('HH:mm:ss.SSSZ').format(buildTimeAndDate)
	buildRevision = versioning.info.commit
	builtByValue = project.hasProperty('builtBy') ? project.builtBy : project.defaultBuiltBy

	docsVersion = project.version.contains('SNAPSHOT') ? 'snapshot' : project.version

	platformProjects = [
		'junit-platform-commons',
		'junit-platform-console',
		'junit-platform-console-standalone',
		'junit-platform-engine',
		'junit-platform-launcher',
		'junit-platform-runner',
		'junit-platform-suite-api',
		'junit-platform-surefire-provider'
	]

	jupiterProjects = [
		'junit-jupiter-api',
		'junit-jupiter-engine',
		'junit-jupiter-migrationsupport',
		'junit-jupiter-params'
	]

	vintageProjects = [
		'junit-vintage-engine'
	]

	mavenizedProjects = platformProjects + jupiterProjects + vintageProjects

	licenses = [
		'EPL-2.0': [
			name: 'Eclipse Public License v2.0',
			url: 'http://www.eclipse.org/legal/epl-v20.html',
			headerFile: 'eclipse-public-license-2.0.java'
		],
		'Apache-2.0': [
			name: 'The Apache License, Version 2.0',
			url: 'http://www.apache.org/licenses/LICENSE-2.0.txt',
			headerFile: 'apache-license-2.0.java'
		]
	]

	licenseOf = { project -> licenses[
		project.name == 'junit-platform-surefire-provider'
			? 'Apache-2.0'
			: 'EPL-2.0'
		]
	}

	jacocoTestProjects = [
		'junit-jupiter-engine',
		'junit-jupiter-migrationsupport',
		'junit-jupiter-params',
		'junit-vintage-engine',
		'junit-platform-surefire-provider',
		'platform-tests'
	]
	jacocoCoveredProjects = mavenizedProjects - ['junit-platform-console-standalone']
	jacocoClassesDir = "$buildDir/jacoco/classes"
}

allprojects { subproj ->

	apply plugin: 'java-library'
	apply plugin: 'kotlin'
	apply plugin: 'eclipse'
	apply plugin: 'idea'
	apply plugin: 'com.diffplug.gradle.spotless'
	apply plugin: 'checkstyle'
	apply plugin: 'com.github.ben-manes.versions' // gradle dependencyUpdates
	apply from: "$rootDir/gradle/degraph.gradle"

	if (project.hasProperty('enableJaCoCo')) {
		apply plugin: "jacoco"
		jacoco {
			toolVersion = '0.8.1'
		}
	}

	repositories {
		// mavenLocal()
		mavenCentral()
		maven { url 'https://oss.sonatype.org/content/repositories/snapshots' }
	}

	dependencies {
		api("org.apiguardian:apiguardian-api:${apiGuardianVersion}")
	}

	tasks.withType(Test) { task ->
		task.testLogging.exceptionFormat = 'full'
	}

	// Declare "javacRelease" as a global property to make it overridable by
	// a sub-project.
	ext.javacRelease = rootProject.javacRelease

	subproj.afterEvaluate { evaluatedProject ->
		evaluatedProject.tasks.withType(JavaCompile) {
			sourceCompatibility = javacRelease
			targetCompatibility = javacRelease // needed by asm
			options.compilerArgs += ['--release', javacRelease]
			options.encoding = 'UTF-8'
		}
	}

	// See: https://docs.oracle.com/javase/9/tools/javac.htm#JSWOR627
	compileJava.options.compilerArgs += [
		'-Xlint:cast',
		'-Xlint:classfile',
		'-Xlint:deprecation',
		'-Xlint:dep-ann',
		'-Xlint:divzero',
		'-Xlint:empty',
		'-Xlint:fallthrough',
		'-Xlint:finally',
		'-Xlint:overrides',
		'-Xlint:path',
		'-Xlint:processing',
		'-Xlint:rawtypes',
		'-Xlint:serial',
		'-Xlint:static',
		'-Xlint:try',
		'-Xlint:unchecked',
		'-Xlint:varargs',
		'-Xlint:-options',
		'-Werror'
	]

	// See: https://docs.oracle.com/javase/9/tools/javac.htm#JSWOR627
	compileTestJava.options.compilerArgs += [
		'-Xlint:cast',
		'-Xlint:classfile',
		'-Xlint:deprecation',
		'-Xlint:dep-ann',
		'-Xlint:divzero',
		'-Xlint:empty',
		'-Xlint:fallthrough',
		'-Xlint:finally',
		'-Xlint:path',
		'-Xlint:processing',
		'-Xlint:rawtypes',
		'-Xlint:serial',
		'-Xlint:static',
		'-Xlint:try',
		'-Xlint:unchecked',
		'-Xlint:varargs',
		'-Xlint:-options',
		'-Xlint:-overrides'
	]

	compileTestJava {
		options.encoding = 'UTF-8'
		options.compilerArgs += '-parameters'
	}

	tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile) {
		kotlinOptions {
			jvmTarget = '1.8'
			apiVersion = '1.1'
			languageVersion = '1.1'
		}
	}

	checkstyle {
		toolVersion = '8.10'
		configDir = rootProject.file('src/checkstyle')
	}
	checkstyleMain {
		configFile = rootProject.file('src/checkstyle/checkstyleMain.xml')
	}
	checkstyleTest {
		configFile = rootProject.file('src/checkstyle/checkstyleTest.xml')
	}
}

subprojects { subproj ->

	if (subproj.name in jupiterProjects) {
		subproj.group = jupiterGroup
	}
	else if (subproj.name in platformProjects) {
		subproj.group = platformGroup
		subproj.version = platformVersion
	}
	else if (subproj.name in vintageProjects) {
		subproj.group = vintageGroup
		subproj.version = vintageVersion
	}

	configurations {
		shadowed
	}

	sourceSets {
		main.compileClasspath += configurations.shadowed
		test.runtimeClasspath += configurations.shadowed
	}

	eclipse {
		classpath {
			plusConfigurations += [ configurations.shadowed ]
		}
	}

	idea {
		module {
			scopes.PROVIDED.plus += [ configurations.shadowed ]
		}
	}

	javadoc {
		classpath = project.sourceSets.main.compileClasspath + configurations.shadowed
	}

	if (subproj.name in mavenizedProjects) {

		apply from: "$rootDir/gradle/publishing.gradle"
		apply from: "$rootDir/gradle/japicc.gradle"

		javadoc {
			options {
				memberLevel = JavadocMemberLevel.PROTECTED
				author = true
				header = project.name
				use = true
				addBooleanOption('Xdoclint:html,syntax', true)
				addBooleanOption('html5', true)
				addMultilineStringsOption('tag').value = [
					'apiNote:a:API Note:',
					'implNote:a:Implementation Note:'
				]
				encoding = 'UTF-8'
				noTimestamp = true
			}
		}

		task sourcesJar(type: Jar, dependsOn: classes) {
			classifier = 'sources'
			from sourceSets.main.allSource
			duplicatesStrategy = DuplicatesStrategy.EXCLUDE
		}

		task javadocJar(type: Jar) {
			classifier = 'javadoc'
			from javadoc
		}

		tasks.withType(Jar) {
			from(project.projectDir) {
				include 'LICENSE.md'
				into 'META-INF'
			}
			from(project.rootDir) {
				include 'LICENSE-notice.md'
				into 'META-INF'
			}
		}

		publishing.publications.maven {
			from components.java
			artifact sourcesJar
			artifact javadocJar
			pom {
				description = "Module \"${project.name}\" of JUnit 5." as String
			}
		}

	} else {
		jar.enabled = false
		javadoc.enabled = false
	}

	def normalizeVersion = { versionLiteral ->
		try {
			(versionLiteral =~ /(\d+)\.(\d+)\.(\d+).*/)[0][1..3].join('.')
		} catch(x) {
			throw new GradleException("Version '$versionLiteral' does not match version pattern, e.g. 5.0.0-QUALIFIER", x)
		}
	}

	compileJava.doLast {
		// Enable JAR manifest generation
		generateManifest = true
	}

	jar {
		onlyIf {
			project.generateManifest
		}
		manifest {
			attributes(
				'Created-By': "${System.properties['java.version']} (${System.properties['java.vendor']} ${System.properties['java.vm.version']})".toString(),
				'Built-By': builtByValue,
				'Build-Date': buildDate,
				'Build-Time': buildTime,
				'Build-Revision': buildRevision,
				'Specification-Title': project.name,
				'Specification-Version': normalizeVersion(project.version),
				'Specification-Vendor': 'junit.org',
				'Implementation-Title': project.name,
				'Implementation-Version': project.version,
				'Implementation-Vendor': 'junit.org'
			)
		}

		// If available, compile and include classes for other Java versions.
		['9'].each { version ->
			def versionedName = project.name + '-java-' + version
			def versionedProject = findProject(':' + versionedName)
			if (versionedProject == null) {
				return
			}

			// We're only interested in the compiled classes. So we depend
			// on the classes task and change (-C) to the destination
			// directory of the version-aware project later.
			dependsOn = [versionedProject.classes]
			doLast {
				// The following two external "project.exec" commands should be replaced by:
				// 		ToolProvider.findFirst("jar").get().run(System.out, System.err,
				//				'--update',
				//				'--file', archivePath,
				//				'--release', version,
				//				'-C', versionedProject.compileJava.destinationDir,
				//				'.')
				// Blocked by: https://github.com/gradle/gradle/issues/721
				project.exec {
					executable "${System.properties['java.home']}/bin/jar"
					args = ['--version']
				}
				project.exec {
					executable "${System.properties['java.home']}/bin/jar"
					args = ['--update','--file', archivePath,
							'--release', version,
							'-C', versionedProject.compileJava.destinationDir,
							'.'
					]
				}
			}
		}

	}

	spotless {
		def headerFile = rootProject.file('src/spotless/' + licenseOf(project)['headerFile'])
		def importOrderConfigFile = rootProject.file('src/eclipse/junit-eclipse.importorder')
		def javaFormatterConfigFile = rootProject.file('src/eclipse/junit-eclipse-formatter-settings.xml')

		java {
			licenseHeaderFile headerFile, '(package|import|open|module) '
			importOrderFile importOrderConfigFile
			eclipse().configFile javaFormatterConfigFile
			if (JavaVersion.current() == JavaVersion.VERSION_1_8) {
				removeUnusedImports()
			}

			trimTrailingWhitespace()
			endWithNewline()
		}

		kotlin {
			ktlint("0.9.0")
			licenseHeaderFile headerFile
			trimTrailingWhitespace()
			endWithNewline()
		}
	}

	afterEvaluate {

		if (project.hasProperty('enableJaCoCo')) {

			if (subproj.name in jacocoTestProjects) {
				jacoco {
					applyTo subproj.tasks.matching { it.name == 'junitPlatformTest' }
				}
			}

			if (subproj.name in jacocoCoveredProjects) {
				def jarTask = subproj.tasks.findByName('shadowJar') ?: subproj.jar
				task extractJar(type: Copy) {
					from zipTree(jarTask.archivePath)
					into jacocoClassesDir
					include '**/*.class'
					// don't report coverage for shadowed classes
					exclude '**/shadow/**'
					// don't version-specific classes of MR JARs
					exclude 'META-INF/versions/**'
					includeEmptyDirs = false
					onlyIf { jarTask.enabled }
				}
				jarTask.finalizedBy(extractJar)
			}
		}
	}

}

configure(rootProject) {
	description = 'JUnit 5'

	apply from: "$rootDir/gradle/gh-pages.gradle"

	jar.enabled = false

	def ota4jDocVersion = ota4jVersion.contains('SNAPSHOT') ? 'snapshot' : ota4jVersion
	def apiGuardianDocVersion = apiGuardianVersion.contains('SNAPSHOT') ? 'snapshot' : apiGuardianVersion

	task aggregateJavadocs(type: Javadoc) {
		group = "Documentation"
		description = "Generates aggregated Javadocs"
		dependsOn subprojects.collect { it.tasks.getByName("jar") }

		title = "JUnit ${version} API"

		options {
			memberLevel = JavadocMemberLevel.PROTECTED
			author = true
			header = rootProject.description
			use = true
			splitIndex = true
			addBooleanOption('Xdoclint:none', true)
			addBooleanOption('html5', true)
			addMultilineStringsOption('tag').value = [
				'apiNote:a:API Note:',
				'implNote:a:Implementation Note:'
			]
			encoding = 'UTF-8'
			noTimestamp = true
			JFlags = ['-Xmx1g']
			links('https://docs.oracle.com/javase/8/docs/api/')
			links("https://ota4j-team.github.io/opentest4j/docs/${ota4jDocVersion}/api/")
			links("https://apiguardian-team.github.io/apiguardian/docs/${apiGuardianDocVersion}/api/")
			stylesheetFile = rootProject.file('src/javadoc/stylesheet.css')
			groups = [
				Jupiter: ['org.junit.jupiter.*'],
				Vintage: ['org.junit.vintage.*'],
				Platform: ['org.junit.platform.*']
			]
		}

		// Only generate JavaDoc for 'main' sources in Mavenized projects
		source = subprojects.findAll { mavenizedProjects.contains(it.name) }.collect { it.sourceSets.main.allJava }

		maxMemory = "1024m"
		destinationDir = new File(buildDir, "docs/javadoc")
		classpath = files(subprojects.collect { it.sourceSets.main.compileClasspath })
			// Remove Kotlin classes from classpath due to "bad" class file
			// see https://bugs.openjdk.java.net/browse/JDK-8187422
			.filter { !it.path.contains('kotlin') }
			// Remove subproject JARs so Kotlin classes don't get picked up
			.filter { it.isDirectory() || !it.absolutePath.startsWith(projectDir.absolutePath) }
	}

	spotless {
		format 'misc', {
			target '**/*.gradle', '**/*.gitignore'
			indentWithTabs()
			trimTrailingWhitespace()
			endWithNewline()
		}
		format 'documentation', {
			target '**/*.adoc', '**/*.md'
			trimTrailingWhitespace()
			endWithNewline()
		}
	}

	if (project.hasProperty('enableJaCoCo')) {

		task jacocoMerge(type: JacocoMerge) {
			subprojects.findAll { it.name in jacocoTestProjects }
				.each { subproj ->
				executionData fileTree(dir: "${subproj.buildDir}/jacoco", include: '*.exec')
				dependsOn subproj.tasks.withType(Test)
			}
		}

		task jacocoRootReport(type: JacocoReport, dependsOn: jacocoMerge) {
			sourceDirectories = files(subprojects
				.findAll { it.name in jacocoCoveredProjects }
				.sourceSets.main.allSource.srcDirs)
			classDirectories = files(jacocoClassesDir)
			executionData jacocoMerge.destinationFile
			reports {
				html.enabled = true
				xml.enabled = true
				csv.enabled = false
			}
		}
	}
}

wrapper {
	description = 'Generates gradlew and gradlew.bat scripts'
	gradleVersion = '4.8'
	/*
	* Reasoning for using BIN:
	* https://github.com/junit-team/junit5/pull/1012#discussion_r132061924
	*/
	distributionType = Wrapper.DistributionType.BIN
}