Enable error-prone static analysis checks

build.gradle

@@ -1,5 +1,6 @@
 import java.time.OffsetDateTime
 import java.time.format.DateTimeFormatter
+import net.ltgt.gradle.errorprone.ErrorProneToolChain
 
 buildscript {
 	repositories {
@@ -10,6 +11,7 @@ buildscript {
 	dependencies {
 		classpath('com.diffplug.spotless:spotless-plugin-gradle:3.8.0')
 		classpath('com.github.ben-manes:gradle-versions-plugin:0.17.0')
+		classpath('net.ltgt.gradle:gradle-errorprone-plugin:0.0.13')
 		classpath('org.ajoberstar:gradle-git-publish:0.3.2')
 		classpath('org.ajoberstar:gradle-git:1.7.2')
 		classpath('org.junit.platform:junit-platform-gradle-plugin:1.0.1')
@@ -94,46 +96,9 @@ ext {
 		'junit-platform-surefire-provider',
 		'platform-tests'
 	]
-}
-
-allprojects { subproj ->
-
-	apply plugin: 'java-library'
-	if (Runtime.version().major() < 10) 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"
-
-	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
-
-	tasks.withType(JavaCompile) {
-		sourceCompatibility = javacRelease // needed by clover
-		targetCompatibility = javacRelease // needed by clover/asm
-		options.compilerArgs += ['--release', javacRelease]
-		options.encoding = 'UTF-8'
-	}
 
 	// See: https://docs.oracle.com/javase/9/tools/javac.htm#JSWOR627
-	compileJava.options*.compilerArgs = [
+	compileJavaBaseArgs = [
 		'-Xlint:cast',
 		'-Xlint:classfile',
 		'-Xlint:deprecation',
@@ -156,7 +121,7 @@ allprojects { subproj ->
 	]
 
 	// See: https://docs.oracle.com/javase/9/tools/javac.htm#JSWOR627
-	compileTestJava.options*.compilerArgs = [
+	compileTestJavaBaseArgs = [
 		'-Xlint:cast',
 		'-Xlint:classfile',
 		'-Xlint:deprecation',
@@ -176,6 +141,51 @@ allprojects { subproj ->
 		'-Xlint:-options',
 		'-Xlint:-overrides'
 	]
+}
+
+allprojects { subproj ->
+
+	apply plugin: 'java-library'
+	if (Runtime.version().major() < 10) 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"
+
+	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
+
+	tasks.withType(JavaCompile) {
+		sourceCompatibility = javacRelease // needed by clover
+		targetCompatibility = javacRelease // needed by clover/asm
+		options.compilerArgs += ['--release', javacRelease]
+		options.encoding = 'UTF-8'
+	}
+
+	// See: https://docs.oracle.com/javase/9/tools/javac.htm#JSWOR627
+	compileJava.options*.compilerArgs =
+			compileJavaBaseArgs + ['--release', rootProject.javacRelease]
+
+	// See: https://docs.oracle.com/javase/9/tools/javac.htm#JSWOR627
+	compileTestJava.options*.compilerArgs =
+			compileTestJavaBaseArgs + ['--release', rootProject.javacRelease]
 
 	compileTestJava {
 		options.encoding = 'UTF-8'
@@ -504,6 +514,111 @@ subprojects { subproj ->
 
 	}
 
+	if (
+		// error-prone doesn't work with Java 9 sources yet:
+		// https://github.com/google/error-prone/issues/448
+		// TODO: Try removing this check, since errorprone may support Java 9 now?
+		!subproj.name.endsWith('-java-9')
+				&& subproj.name != 'documentation') {
+
+		println(String.format("Currently setting up error-prone for subproject: %s", subproj.name))
+
+		apply plugin: 'net.ltgt.errorprone-base'
+
+		dependencies {
+			errorprone("com.google.errorprone:error_prone_core:${errorproneVersion}")
+			// TODO: JDK 9 fails to find any of the annotations from the package
+			// com.google.errorprone.annotations, even if they're applied to the JUnit 5 code base.
+			// Apply a select subset of them once they work properly with JDK 9.
+			compileOnly("com.google.errorprone:error_prone_annotations:${errorproneVersion}")
+		}
+
+		def errorproneBaseFlags = [
+			// enable experimental checks
+			'-XepAllDisabledChecksAsWarnings',
+
+			// generates too many false positives on constructors that call other constructors.
+			// TODO: see if constructors can be refactored more easily to not call each other.
+			'-Xep:ConstructorLeaksThis:OFF',
+
+			// we don't use @Nullable
+			'-Xep:FieldMissingNullable:OFF',
+
+			// adds a lot of churn for not a lot of gain
+			'-Xep:InconsistentOverloads:OFF',
+
+			// TODO: turning this check on and applying @com.google.errorprone.annotations.Immutable
+			// to immutable classes causes JDK 9 to fail to compile; investigate and consider
+			// turning it on when error-prone supports JDK 9
+			'-Xep:Immutable:OFF',
+
+			// adds a lot of churn for not a lot of gain
+			'-Xep:MethodCanBeStatic:OFF',
+
+			// we declare redundant `throws <general-exception>, <more-specific-exception>` for
+			// maintainability
+			'-Xep:RedundantThrows:OFF',
+
+			// we don't use @Nullable
+			'-Xep:ReturnMissingNullable:OFF',
+
+			// we do not use Guava, so we cannot import com.google.common.base.Splitter
+			'-Xep:StringSplitter:OFF',
+
+			// we target Java 8, not Android
+			'-Xep:StaticOrDefaultInterfaceMethod:OFF',
+
+			// we declare `throws <unchecked-exception>` for maintainability
+			'-Xep:ThrowsUncheckedException:OFF',
+
+			// we do not follow the Google Java Style Guide
+			'-Xep:UngroupedOverloads:OFF',
+
+			// TODO: turning this check on and applying @com.google.errorprone.annotations.Var to
+			// non-final variables causes JDK 9 to fail to compile; investigate and consider turning
+			// it on when error-prone supports JDK 9
+			'-Xep:Var:OFF'
+		]
+
+		def errorproneTestFlags = errorproneBaseFlags + [
+			'-Xep:ClassCanBeStatic:OFF',
+			'-Xep:ConstantField:OFF',
+			'-Xep:ConstructorInvokesOverridable:OFF',
+			'-Xep:EqualsHashCode:OFF',
+			'-Xep:MultipleTopLevelClasses:OFF',
+			'-Xep:PrivateConstructorForUtilityClass:OFF',
+			'-Xep:ReturnValueIgnored:OFF'
+		]
+
+		task compileJavaWithErrorProne(type: JavaCompile/*, dependsOn: compileKotlin*/) {
+			group = 'verification'
+			toolChain = ErrorProneToolChain.create(project)
+			classpath = compileJava.classpath + compileKotlin.classpath
+			//println("classpath = " + classpath.files)
+			source = compileJava.source + compileKotlin.source
+			//println("source = " + source.files)
+			options.compilerArgs =
+					compileJava.options.compilerArgs + compileJavaBaseArgs + errorproneBaseFlags
+			// println("compileJavaWithErrorProne.options.compilerArgs = $options.compilerArgs")
+			destinationDir = file("$buildDir/classes/error-prone-java/main")
+		}
+		check.dependsOn(compileJavaWithErrorProne)
+
+		task compileTestJavaWithErrorProne(type: JavaCompile/*, dependsOn: [compileKotlin, compileTestKotlin]*/) {
+			group = 'verification'
+			toolChain = ErrorProneToolChain.create(project)
+			classpath = compileTestJava.classpath + compileTestKotlin.classpath
+			//println("classpath = " + classpath.files)
+			source = compileTestJava.source + compileTestKotlin.source
+			//println("source = " + source.files)
+			options.compilerArgs +=
+					compileTestJava.options.compilerArgs + compileTestJavaBaseArgs + errorproneTestFlags
+			// println("compileTestJavaWithErrorProne.options.compilerArgs = $options.compilerArgs")
+			destinationDir = file("$buildDir/classes/error-prone-java/test")
+		}
+		check.dependsOn(compileTestJavaWithErrorProne)
+	}
+
 	spotless {
 		def headerFile = rootProject.file('src/spotless/' + licenseOf(project)['headerFile'])
 		def importOrderConfigFile = rootProject.file('src/eclipse/junit-eclipse.importorder')

gradle.properties

@@ -16,6 +16,7 @@ javacRelease = 8
 apiGuardianVersion  = 1.0.0
 assertJVersion      = 3.9.0
 degraphVersion      = 0.1.4
+errorproneVersion   = 2.2.0
 junit4Version       = 4.12
 kotlinVersion       = 1.2.10
 log4jVersion        = 2.10.0

junit-jupiter-api/src/main/java/org/junit/jupiter/api/AssertionUtils.java

@@ -119,6 +119,10 @@ static boolean floatsAreEqual(float value1, float value2, float delta) {
 		return floatsAreEqual(value1, value2) || Math.abs(value1 - value2) <= delta;
 	}
 
+	static boolean floatsAreEqual(float value1, float value2) {
+		return Float.floatToIntBits(value1) == Float.floatToIntBits(value2);
+	}
+
 	static void assertValidDelta(float delta) {
 		if (Float.isNaN(delta) || delta <= 0.0) {
 			failIllegalDelta(String.valueOf(delta));
@@ -131,10 +135,6 @@ static void assertValidDelta(double delta) {
 		}
 	}
 
-	static boolean floatsAreEqual(float value1, float value2) {
-		return Float.floatToIntBits(value1) == Float.floatToIntBits(value2);
-	}
-
 	static boolean doublesAreEqual(double value1, double value2, double delta) {
 		assertValidDelta(delta);
 		return doublesAreEqual(value1, value2) || Math.abs(value1 - value2) <= delta;

junit-jupiter-api/src/main/java/org/junit/jupiter/api/Assertions.java

@@ -58,6 +58,9 @@ private Assertions() {
 	 * <p>See Javadoc for {@link #fail(String, Throwable)} for an explanation of
 	 * this method's generic return type {@code V}.
 	 */
+	// we purposely return a V that has nothing to do with the parameters of this method; see
+	// the javadoc for details.
+	@SuppressWarnings("TypeParameterUnusedInFormals")
 	public static <V> V fail(String message) {
 		AssertionUtils.fail(message);
 		return null; // appeasing the compiler: this line will never be executed.
@@ -78,6 +81,9 @@ public static <V> V fail(String message) {
 	 * Stream.of().map(entry -> fail("should not be called"));
 	 * }</pre>
 	 */
+	// we purposely return a V that has nothing to do with the parameters of this method; see
+	// the javadoc for details.
+	@SuppressWarnings("TypeParameterUnusedInFormals")
 	public static <V> V fail(String message, Throwable cause) {
 		AssertionUtils.fail(message, cause);
 		return null; // appeasing the compiler: this line will never be executed.
@@ -89,6 +95,9 @@ public static <V> V fail(String message, Throwable cause) {
 	 * <p>See Javadoc for {@link #fail(String, Throwable)} for an explanation of
 	 * this method's generic return type {@code V}.
 	 */
+	// we purposely return a V that has nothing to do with the parameters of this method; see
+	// the javadoc for details.
+	@SuppressWarnings("TypeParameterUnusedInFormals")
 	public static <V> V fail(Throwable cause) {
 		AssertionUtils.fail(cause);
 		return null; // appeasing the compiler: this line will never be executed.
@@ -101,6 +110,9 @@ public static <V> V fail(Throwable cause) {
 	 * <p>See Javadoc for {@link #fail(String, Throwable)} for an explanation of
 	 * this method's generic return type {@code V}.
 	 */
+	// we purposely return a V that has nothing to do with the parameters of this method; see
+	// the javadoc for details.
+	@SuppressWarnings("TypeParameterUnusedInFormals")
 	public static <V> V fail(Supplier<String> messageSupplier) {
 		AssertionUtils.fail(messageSupplier);
 		return null; // appeasing the compiler: this line will never be executed.

junit-jupiter-engine/src/test/java/org/junit/jupiter/engine/MultipleTestableAnnotationsTests.java

@@ -37,7 +37,7 @@ void testAndRepeatedTest(LogRecordListener listener) {
 
 		// @formatter:off
 		assertThat(listener.stream()
-			.filter(logRecord -> logRecord.getLevel() == Level.WARNING)
+			.filter(logRecord -> logRecord.getLevel().equals(Level.WARNING))
 			.map(LogRecord::getMessage)
 			.filter(m -> m.matches("Possible configuration error: method .+ resulted in multiple TestDescriptors .+"))
 			.count()