Add Java 21 support for running tests (#622)

This commit adds a Gradle property 'testToolchain' that when set will
configure the Java toolchain plugin accordingly.

Additionally:
-------------
* Replace the custom toolchain plugin with the vanilla one provided by
  Gradle

* Move the Java conventions from Java plugin to Groovy script

* [CI] Add Java 21 to check-samples.yml

.github/workflows/check-samples.yml

@@ -39,7 +39,11 @@ jobs:
     needs: [prerequisites]
     strategy:
       matrix:
-        springBootVersion: [ "${{ needs.prerequisites.outputs.boot_version }}" ]
+        include:
+          - javaVersion: 17
+            springBootVersion: "${{ needs.prerequisites.outputs.boot_version }}"
+          - javaVersion: 21
+            springBootVersion: "${{ needs.prerequisites.outputs.boot_version }}"
     runs-on: ubuntu-latest
     if: needs.prerequisites.outputs.runjobs
     steps:
@@ -50,6 +54,7 @@ jobs:
           LOCAL_REPOSITORY_PATH: ${{ github.workspace }}/build/publications/repos
           VERSION: ${{ needs.prerequisites.outputs.project_version }}
           BOOT_VERSION: ${{ matrix.springBootVersion }}
+          JAVA_VERSION: ${{ matrix.javaVersion }}
         run: |
           ./gradlew publishMavenJavaPublicationToLocalRepository
           ./gradlew \
@@ -57,5 +62,6 @@ jobs:
             -PlocalRepositoryPath="$LOCAL_REPOSITORY_PATH" \
             -PspringPulsarVersion="$VERSION" \
             -PspringBootVersion="$BOOT_VERSION" \
+            -PtestToolchain="$JAVA_VERSION" \
             -PsampleTests \
             :runAllSampleTests

build.gradle

@@ -13,6 +13,7 @@ apply from: 'gradle/jacoco-conventions.gradle'
 apply from: 'gradle/aggregate-jacoco-report.gradle'
 apply from: 'gradle/update-copyrights.gradle'
 apply from: 'gradle/version-catalog-update.gradle'
+apply from: 'gradle/java-conventions.gradle'
 
 allprojects {
 	group = 'org.springframework.pulsar'

buildSrc/src/main/java/org/springframework/pulsar/gradle/JavaConventionsPlugin.java

@@ -18,13 +18,11 @@ package org.springframework.pulsar.gradle;
 
 import java.util.Arrays;
 import java.util.Collections;
-import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.TreeMap;
 import java.util.stream.Collectors;
 
-import org.gradle.api.JavaVersion;
 import org.gradle.api.Plugin;
 import org.gradle.api.Project;
 import org.gradle.api.artifacts.Configuration;
@@ -33,7 +31,6 @@ import org.gradle.api.artifacts.Dependency;
 import org.gradle.api.artifacts.DependencySet;
 import org.gradle.api.plugins.JavaBasePlugin;
 import org.gradle.api.plugins.JavaPlugin;
-import org.gradle.api.plugins.JavaPluginExtension;
 import org.gradle.api.plugins.quality.Checkstyle;
 import org.gradle.api.plugins.quality.CheckstyleExtension;
 import org.gradle.api.plugins.quality.CheckstylePlugin;
@@ -49,7 +46,6 @@ import org.gradle.external.javadoc.CoreJavadocOptions;
 
 import org.springframework.pulsar.gradle.optional.OptionalDependenciesPlugin;
 import org.springframework.pulsar.gradle.testing.TestFailuresPlugin;
-import org.springframework.pulsar.gradle.toolchain.ToolchainPlugin;
 
 import io.spring.javaformat.gradle.SpringJavaFormatPlugin;
 import io.spring.javaformat.gradle.tasks.CheckFormat;
@@ -109,12 +105,10 @@ public class JavaConventionsPlugin implements Plugin<Project> {
 	public void apply(Project project) {
 		project.getPlugins().withType(JavaBasePlugin.class, (java) -> {
 			configureSpringJavaFormat(project);
-			configureJavaConventions(project);
 			configureJavadocConventions(project);
 			configureTestConventions(project);
 			configureJarManifestConventions(project);
 			configureDependencyManagement(project);
-			configureToolchain(project);
 		});
 	}
 
@@ -131,32 +125,6 @@ public class JavaConventionsPlugin implements Plugin<Project> {
 				.add(project.getDependencies().create("io.spring.javaformat:spring-javaformat-checkstyle:" + version));
 	}
 
-	private void configureJavaConventions(Project project) {
-		if (!project.hasProperty("toolchainVersion")) {
-			JavaPluginExtension javaPluginExtension = project.getExtensions().getByType(JavaPluginExtension.class);
-			javaPluginExtension.setSourceCompatibility(JavaVersion.toVersion(SOURCE_AND_TARGET_COMPATIBILITY));
-		}
-		project.getTasks().withType(JavaCompile.class, (compile) -> {
-			compile.getOptions().setEncoding("UTF-8");
-			List<String> args = compile.getOptions().getCompilerArgs();
-			if (!args.contains("-parameters")) {
-				args.add("-parameters");
-			}
-			if (project.hasProperty("toolchainVersion")) {
-				compile.setSourceCompatibility(SOURCE_AND_TARGET_COMPATIBILITY);
-				compile.setTargetCompatibility(SOURCE_AND_TARGET_COMPATIBILITY);
-			}
-			else if (buildingWithJava17(project)) {
-				args.addAll(Arrays.asList("-Werror", "-Xlint:unchecked", "-Xlint:deprecation", "-Xlint:rawtypes",
-						"-Xlint:varargs"));
-			}
-		});
-	}
-
-	private boolean buildingWithJava17(Project project) {
-		return !project.hasProperty("toolchainVersion") && JavaVersion.current() == JavaVersion.VERSION_17;
-	}
-
 	private void configureJavadocConventions(Project project) {
 		project.getTasks().withType(Javadoc.class, (javadoc) -> {
 			CoreJavadocOptions options = (CoreJavadocOptions) javadoc.getOptions();
@@ -245,8 +213,4 @@ public class JavaConventionsPlugin implements Plugin<Project> {
 				.getByName(OptionalDependenciesPlugin.OPTIONAL_CONFIGURATION_NAME).extendsFrom(dependencyManagement));
 	}
 
-	private void configureToolchain(Project project) {
-		project.getPlugins().apply(ToolchainPlugin.class);
-	}
-
 }

buildSrc/src/main/java/org/springframework/pulsar/gradle/RootProjectPlugin.java

@@ -16,8 +16,6 @@
 
 package org.springframework.pulsar.gradle;
 
-import io.spring.gradle.convention.ArtifactoryPlugin;
-
 import org.gradle.api.Plugin;
 import org.gradle.api.Project;
 import org.gradle.api.Task;
@@ -27,7 +25,10 @@ import org.gradle.api.plugins.PluginManager;
 import org.springframework.pulsar.gradle.check.SonarQubeConventionsPlugin;
 import org.springframework.pulsar.gradle.publish.SpringNexusPublishPlugin;
 
+import io.spring.gradle.convention.ArtifactoryPlugin;
+
 /**
+ * Plugin for the root project.
  * @author Chris Bono
  */
 public class RootProjectPlugin implements Plugin<Project> {

buildSrc/src/main/java/org/springframework/pulsar/gradle/toolchain/ToolchainExtension.java

@@ -1,56 +0,0 @@
-/*
- * Copyright 2012-2021 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.pulsar.gradle.toolchain;
-
-import org.gradle.api.Project;
-import org.gradle.api.provider.ListProperty;
-import org.gradle.api.provider.Property;
-import org.gradle.jvm.toolchain.JavaLanguageVersion;
-
-/**
- * DSL extension for {@link ToolchainPlugin}.
- *
- * @author Christoph Dreis
- */
-public class ToolchainExtension {
-
-	private final Property<JavaLanguageVersion> maximumCompatibleJavaVersion;
-
-	private final ListProperty<String> testJvmArgs;
-
-	private final JavaLanguageVersion javaVersion;
-
-	public ToolchainExtension(Project project) {
-		this.maximumCompatibleJavaVersion = project.getObjects().property(JavaLanguageVersion.class);
-		this.testJvmArgs = project.getObjects().listProperty(String.class);
-		String toolchainVersion = (String) project.findProperty("toolchainVersion");
-		this.javaVersion = (toolchainVersion != null) ? JavaLanguageVersion.of(toolchainVersion) : null;
-	}
-
-	public Property<JavaLanguageVersion> getMaximumCompatibleJavaVersion() {
-		return this.maximumCompatibleJavaVersion;
-	}
-
-	public ListProperty<String> getTestJvmArgs() {
-		return this.testJvmArgs;
-	}
-
-	JavaLanguageVersion getJavaVersion() {
-		return this.javaVersion;
-	}
-
-}

buildSrc/src/main/java/org/springframework/pulsar/gradle/toolchain/ToolchainPlugin.java

@@ -1,81 +0,0 @@
-/*
- * Copyright 2012-2022 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.springframework.pulsar.gradle.toolchain;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
-import org.gradle.api.Plugin;
-import org.gradle.api.Project;
-import org.gradle.api.plugins.JavaPluginExtension;
-import org.gradle.api.tasks.compile.JavaCompile;
-import org.gradle.api.tasks.javadoc.Javadoc;
-import org.gradle.api.tasks.testing.Test;
-import org.gradle.jvm.toolchain.JavaLanguageVersion;
-import org.gradle.jvm.toolchain.JavaToolchainSpec;
-
-/**
- * {@link Plugin} for customizing Gradle's toolchain support.
- *
- * @author Christoph Dreis
- */
-public class ToolchainPlugin implements Plugin<Project> {
-
-	@Override
-	public void apply(Project project) {
-		configureToolchain(project);
-	}
-
-	private void configureToolchain(Project project) {
-		ToolchainExtension toolchain = project.getExtensions().create("toolchain", ToolchainExtension.class, project);
-		JavaLanguageVersion toolchainVersion = toolchain.getJavaVersion();
-		if (toolchainVersion != null) {
-			project.afterEvaluate((evaluated) -> configure(evaluated, toolchain));
-		}
-	}
-
-	private void configure(Project project, ToolchainExtension toolchain) {
-		if (!isJavaVersionSupported(toolchain, toolchain.getJavaVersion())) {
-			disableToolchainTasks(project);
-		}
-		else {
-			JavaToolchainSpec toolchainSpec = project.getExtensions().getByType(JavaPluginExtension.class)
-					.getToolchain();
-			toolchainSpec.getLanguageVersion().set(toolchain.getJavaVersion());
-			configureTestToolchain(project, toolchain);
-		}
-	}
-
-	private boolean isJavaVersionSupported(ToolchainExtension toolchain, JavaLanguageVersion toolchainVersion) {
-		return toolchain.getMaximumCompatibleJavaVersion().map((version) -> version.canCompileOrRun(toolchainVersion))
-				.getOrElse(true);
-	}
-
-	private void disableToolchainTasks(Project project) {
-		project.getTasks().withType(JavaCompile.class, (task) -> task.setEnabled(false));
-		project.getTasks().withType(Javadoc.class, (task) -> task.setEnabled(false));
-		project.getTasks().withType(Test.class, (task) -> task.setEnabled(false));
-	}
-
-	private void configureTestToolchain(Project project, ToolchainExtension toolchain) {
-		List<String> jvmArgs = new ArrayList<>();
-		jvmArgs.addAll(toolchain.getTestJvmArgs().getOrElse(Collections.emptyList()));
-		project.getTasks().withType(Test.class, (test) -> test.jvmArgs(jvmArgs));
-	}
-
-}

gradle/java-conventions.gradle

@@ -0,0 +1,26 @@
+def toolchainVersion() {
+	if (project.hasProperty('testToolchain')) {
+		return project.property('testToolchain').toString().toInteger()
+	}
+	return 17
+}
+
+project.afterEvaluate {
+	subprojects { subproject ->
+		afterEvaluate {
+			if (subproject.plugins.hasPlugin(JavaPlugin.class)) {
+				java {
+					toolchain {
+						languageVersion = JavaLanguageVersion.of(toolchainVersion())
+					}
+				}
+				tasks.withType(JavaCompile).configureEach {
+					options.encoding = "UTF-8"
+					options.compilerArgs.add("-parameters")
+					options.compilerArgs.addAll(["-Werror", "-Xlint:unchecked", "-Xlint:deprecation", "-Xlint:rawtypes", "-Xlint:varargs"]);
+					options.release.set(17)
+				}
+			}
+		}
+	}
+}