From 529102b37fca45137955b627944ee02b980b3df6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Yoann=20Rodi=C3=A8re?= Date: Tue, 17 Jun 2025 14:20:40 +0200 Subject: [PATCH 1/8] Fix Java launcher used in CI tests being downgraded by mistake --- .../java/org/hibernate/orm/toolchains/JdkVersionConfig.java | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/local-build-plugins/src/main/java/org/hibernate/orm/toolchains/JdkVersionConfig.java b/local-build-plugins/src/main/java/org/hibernate/orm/toolchains/JdkVersionConfig.java index 14f9eaba238f..64d6f1cebced 100644 --- a/local-build-plugins/src/main/java/org/hibernate/orm/toolchains/JdkVersionConfig.java +++ b/local-build-plugins/src/main/java/org/hibernate/orm/toolchains/JdkVersionConfig.java @@ -168,7 +168,10 @@ public static JdkVersionConfig createVersionConfig( testReleaseVersion = maxSupportedJdkVersion; } - testLauncherVersion = testReleaseVersion; + // This must not be downgraded like we do for the "release version", + // first because we don't need to, + // second because we don't necessarily have a lower version of the JDK available on the machine. + testLauncherVersion = testCompilerVersion; return new JdkVersionConfig( true, From 28557543bab96f82c06191e0bd02805050f55ebf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Yoann=20Rodi=C3=A8re?= Date: Tue, 17 Jun 2025 14:31:58 +0200 Subject: [PATCH 2/8] Fix tests being compiled to JDK 21 bytecode by default on CI --- .../java/org/hibernate/orm/toolchains/JavaModulePlugin.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/local-build-plugins/src/main/java/org/hibernate/orm/toolchains/JavaModulePlugin.java b/local-build-plugins/src/main/java/org/hibernate/orm/toolchains/JavaModulePlugin.java index 968adacc7484..f98f456dc26f 100644 --- a/local-build-plugins/src/main/java/org/hibernate/orm/toolchains/JavaModulePlugin.java +++ b/local-build-plugins/src/main/java/org/hibernate/orm/toolchains/JavaModulePlugin.java @@ -64,8 +64,8 @@ public void apply(Project project) { mainCompileTask.setSourceCompatibility( jdkVersionsConfig.getMainReleaseVersion().toString() ); mainCompileTask.setTargetCompatibility( jdkVersionsConfig.getMainReleaseVersion().toString() ); - testCompileTask.setSourceCompatibility( jdkVersionsConfig.getTestCompilerVersion().toString() ); - testCompileTask.setTargetCompatibility( jdkVersionsConfig.getTestCompilerVersion().toString() ); + testCompileTask.setSourceCompatibility( jdkVersionsConfig.getTestReleaseVersion().toString() ); + testCompileTask.setTargetCompatibility( jdkVersionsConfig.getTestReleaseVersion().toString() ); } else { javaPluginExtension.getToolchain().getLanguageVersion().set( jdkVersionsConfig.getMainCompilerVersion() ); From 555c0b0b20a08ce65b438b42924795b2c00fd267 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Yoann=20Rodi=C3=A8re?= Date: Tue, 17 Jun 2025 14:54:52 +0200 Subject: [PATCH 3/8] Compile main code with JDK 17 on JDK 17 CI runs --- Jenkinsfile | 22 ++++++++++++++++++---- 1 file changed, 18 insertions(+), 4 deletions(-) diff --git a/Jenkinsfile b/Jenkinsfile index 6314366e710c..a4a5b066f9c6 100644 --- a/Jenkinsfile +++ b/Jenkinsfile @@ -40,8 +40,9 @@ stage('Configure') { // Don't build with HANA by default, but only do it nightly until we receive a 3rd instance // new BuildEnvironment( dbName: 'hana_cloud', dbLockableResource: 'hana-cloud', dbLockResourceAsHost: true ), new BuildEnvironment( node: 's390x' ), - // We build with JDK 21, but produce Java 17 bytecode, so we test with JDK 17, to be sure everything works. - new BuildEnvironment( testJdkVersion: '17' ), + // We generally build with JDK 21, but our baseline is Java 17, so we test with JDK 17, to be sure everything works. + // Here we even compile the main code with JDK 17, to be sure no JDK 18+ classes are depended on. + new BuildEnvironment( mainJdkVersion: '17', testJdkVersion: '17' ), // We want to enable preview features when testing newer builds of OpenJDK: // even if we don't use these features, just enabling them can cause side effects // and it's useful to test that. @@ -109,6 +110,10 @@ stage('Build') { state[buildEnv.tag] = [:] executions.put(buildEnv.tag, { runBuildOnNode(buildEnv.node ?: NODE_PATTERN_BASE) { + def mainJavaHome + if ( buildEnv.mainJdkVersion ) { + mainJavaHome = tool(name: "OpenJDK ${buildEnv.mainJdkVersion} Latest", type: 'jdk') + } def testJavaHome if ( buildEnv.testJdkVersion ) { testJavaHome = tool(name: "OpenJDK ${buildEnv.testJdkVersion} Latest", type: 'jdk') @@ -118,9 +123,17 @@ stage('Build') { // See https://github.com/jenkinsci/pipeline-plugin/blob/master/TUTORIAL.md withEnv(["JAVA_HOME=${javaHome}", "PATH+JAVA=${javaHome}/bin"]) { state[buildEnv.tag]['additionalOptions'] = '-PmavenMirror=nexus-load-balancer-c4cf05fd92f43ef8.elb.us-east-1.amazonaws.com' - if ( testJavaHome ) { + if ( buildEnv.mainJdkVersion ) { + state[buildEnv.tag]['additionalOptions'] = state[buildEnv.tag]['additionalOptions'] + + " -Pmain.jdk.version=${buildEnv.mainJdkVersion}" + } + if ( buildEnv.testJdkVersion ) { + state[buildEnv.tag]['additionalOptions'] = state[buildEnv.tag]['additionalOptions'] + + " -Ptest.jdk.version=${buildEnv.testJdkVersion}" + } + if ( buildEnv.mainJdkVersion || buildEnv.testJdkVersion ) { state[buildEnv.tag]['additionalOptions'] = state[buildEnv.tag]['additionalOptions'] + - " -Ptest.jdk.version=${buildEnv.testJdkVersion} -Porg.gradle.java.installations.paths=${javaHome},${testJavaHome}" + " -Porg.gradle.java.installations.paths=${[javaHome, mainJavaHome, testJavaHome].findAll { it != null }.join(',')}" } if ( buildEnv.testJdkLauncherArgs ) { state[buildEnv.tag]['additionalOptions'] = state[buildEnv.tag]['additionalOptions'] + @@ -210,6 +223,7 @@ stage('Build') { // Job-specific helpers class BuildEnvironment { + String mainJdkVersion String testJdkVersion String testJdkLauncherArgs String dbName = 'h2' From 0135503c64162fa3086c3882aff6ff85f4043fcd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Yoann=20Rodi=C3=A8re?= Date: Tue, 17 Jun 2025 14:56:25 +0200 Subject: [PATCH 4/8] Remove obsolete workaround of a Gradle bug --- .../java/org/hibernate/orm/toolchains/JavaModulePlugin.java | 2 -- 1 file changed, 2 deletions(-) diff --git a/local-build-plugins/src/main/java/org/hibernate/orm/toolchains/JavaModulePlugin.java b/local-build-plugins/src/main/java/org/hibernate/orm/toolchains/JavaModulePlugin.java index f98f456dc26f..77732591d3b9 100644 --- a/local-build-plugins/src/main/java/org/hibernate/orm/toolchains/JavaModulePlugin.java +++ b/local-build-plugins/src/main/java/org/hibernate/orm/toolchains/JavaModulePlugin.java @@ -95,8 +95,6 @@ public void apply(Project project) { private void configureCompileTask(JavaCompile compileTask, JavaLanguageVersion releaseVersion) { final CompileOptions compileTaskOptions = compileTask.getOptions(); compileTaskOptions.getRelease().set( releaseVersion.asInt() ); - // Needs add-opens because of https://github.com/gradle/gradle/issues/15538 - addJvmArgs( compileTask, "--add-opens", "jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED" ); } private void configureCompileTasks(Project project) { From dd68c38e9709ec61772ff554a7f53ee294753442 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Yoann=20Rodi=C3=A8re?= Date: Tue, 17 Jun 2025 15:23:21 +0200 Subject: [PATCH 5/8] Unify configuration of tasks with explicit/implicit Java versions So that we always set the test release version, in particular. --- .../orm/toolchains/JavaModulePlugin.java | 145 +++++++++--------- .../orm/toolchains/JdkVersionConfig.java | 61 ++++---- .../toolchains/JdkVersionSettingsPlugin.java | 4 - .../hibernate-processor.gradle | 18 --- 4 files changed, 103 insertions(+), 125 deletions(-) diff --git a/local-build-plugins/src/main/java/org/hibernate/orm/toolchains/JavaModulePlugin.java b/local-build-plugins/src/main/java/org/hibernate/orm/toolchains/JavaModulePlugin.java index 77732591d3b9..ed7885deda4d 100644 --- a/local-build-plugins/src/main/java/org/hibernate/orm/toolchains/JavaModulePlugin.java +++ b/local-build-plugins/src/main/java/org/hibernate/orm/toolchains/JavaModulePlugin.java @@ -18,12 +18,10 @@ import org.gradle.api.plugins.JavaPluginExtension; import org.gradle.api.tasks.SourceSet; import org.gradle.api.tasks.SourceSetContainer; -import org.gradle.api.tasks.compile.CompileOptions; import org.gradle.api.tasks.compile.ForkOptions; 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.JavaToolchainService; /** @@ -54,72 +52,65 @@ public void apply(Project project) { final SourceSetContainer sourceSets = javaPluginExtension.getSourceSets(); final SourceSet mainSourceSet = sourceSets.getByName( SourceSet.MAIN_SOURCE_SET_NAME ); - final SourceSet testSourceSet = sourceSets.getByName( SourceSet.TEST_SOURCE_SET_NAME ); - final JavaCompile mainCompileTask = (JavaCompile) project.getTasks().getByName( mainSourceSet.getCompileJavaTaskName() ); - final JavaCompile testCompileTask = (JavaCompile) project.getTasks().getByName( testSourceSet.getCompileJavaTaskName() ); - final Test testTask = (Test) project.getTasks().findByName( testSourceSet.getName() ); - - if ( !jdkVersionsConfig.isExplicitlyConfigured() ) { - mainCompileTask.setSourceCompatibility( jdkVersionsConfig.getMainReleaseVersion().toString() ); - mainCompileTask.setTargetCompatibility( jdkVersionsConfig.getMainReleaseVersion().toString() ); - - testCompileTask.setSourceCompatibility( jdkVersionsConfig.getTestReleaseVersion().toString() ); - testCompileTask.setTargetCompatibility( jdkVersionsConfig.getTestReleaseVersion().toString() ); - } - else { + if ( jdkVersionsConfig.getMain().isExplicit() ) { javaPluginExtension.getToolchain().getLanguageVersion().set( jdkVersionsConfig.getMainCompilerVersion() ); - - configureCompileTasks( project ); - configureTestTasks( project ); - configureJavadocTasks( project, mainSourceSet ); - - configureCompileTask( mainCompileTask, jdkVersionsConfig.getMainReleaseVersion() ); - configureCompileTask( testCompileTask, jdkVersionsConfig.getTestReleaseVersion() ); - - testCompileTask.getJavaCompiler().set( - toolchainService.compilerFor( javaToolchainSpec -> { - javaToolchainSpec.getLanguageVersion().set( jdkVersionsConfig.getTestCompilerVersion() ); - } ) - ); - if ( testTask != null ) { - testTask.getJavaLauncher().set( - toolchainService.launcherFor( javaToolchainSpec -> { - javaToolchainSpec.getLanguageVersion().set( jdkVersionsConfig.getTestLauncherVersion() ); - } ) - ); - } } - } - private void configureCompileTask(JavaCompile compileTask, JavaLanguageVersion releaseVersion) { - final CompileOptions compileTaskOptions = compileTask.getOptions(); - compileTaskOptions.getRelease().set( releaseVersion.asInt() ); + configureCompileTasks( project, mainSourceSet, jdkVersionsConfig ); + configureTestTasks( project, jdkVersionsConfig ); + configureJavadocTasks( project, mainSourceSet, jdkVersionsConfig ); } - private void configureCompileTasks(Project project) { + private void configureCompileTasks(Project project, SourceSet mainSourceSet, JdkVersionConfig jdkVersionsConfig) { project.getTasks().withType( JavaCompile.class ).configureEach( new Action() { @Override public void execute(JavaCompile compileTask) { addJvmArgs( compileTask, project.property( "toolchain.compiler.jvmargs" ).toString().split( " " ) ); - compileTask.doFirst( - new Action() { - @Override - public void execute(Task task) { - project.getLogger().lifecycle( - "Compiling with '{}'", - compileTask.getJavaCompiler().get().getMetadata().getInstallationPath() - ); + if ( compileTask.getName().equals( mainSourceSet.getCompileJavaTaskName() ) ) { + compileTask.getOptions().getRelease().set( jdkVersionsConfig.getMainReleaseVersion().asInt() ); + if ( jdkVersionsConfig.getMain().isExplicit() ) { + compileTask.getJavaCompiler().set( + toolchainService.compilerFor( javaToolchainSpec -> { + javaToolchainSpec.getLanguageVersion() + .set( jdkVersionsConfig.getMainCompilerVersion() ); + } ) + ); + } + } + // Assume all non-main compile tasks are test compile tasks, + // because that's currently true, + // and there is no way to automatically determine whether a custom compile task if for main code or tests. + else { + compileTask.getOptions().getRelease().set( jdkVersionsConfig.getTestReleaseVersion().asInt() ); + if ( jdkVersionsConfig.getTest().isExplicit() ) { + compileTask.getJavaCompiler().set( + toolchainService.compilerFor( javaToolchainSpec -> { + javaToolchainSpec.getLanguageVersion().set( jdkVersionsConfig.getTestCompilerVersion() ); + } ) + ); + } + } + if ( jdkVersionsConfig.isExplicit() ) { + compileTask.doFirst( + new Action() { + @Override + public void execute(Task task) { + project.getLogger().lifecycle( + "Compiling with '{}'", + compileTask.getJavaCompiler().get().getMetadata().getInstallationPath() + ); + } } - } - ); + ); + } } } ); } - private void configureTestTasks(Project project) { + private void configureTestTasks(Project project, JdkVersionConfig jdkVersionsConfig) { project.getTasks().withType( Test.class ).configureEach( new Action() { @Override public void execute(Test testTask) { @@ -135,33 +126,45 @@ public void execute(Test testTask) { ) ); } - testTask.doFirst( - new Action() { - @Override - public void execute(Task task) { - project.getLogger().lifecycle( - "Testing with '{}'", - testTask.getJavaLauncher().get().getMetadata().getInstallationPath() - ); + if ( jdkVersionsConfig.getTest().isExplicit() ) { + testTask.getJavaLauncher().set( + toolchainService.launcherFor( javaToolchainSpec -> { + javaToolchainSpec.getLanguageVersion() + .set( jdkVersionsConfig.getTestLauncherVersion() ); + } ) + ); + } + if ( jdkVersionsConfig.isExplicit() ) { + testTask.doFirst( + new Action() { + @Override + public void execute(Task task) { + project.getLogger().lifecycle( + "Testing with '{}'", + testTask.getJavaLauncher().get().getMetadata().getInstallationPath() + ); + } } - } - ); + ); + } } } ); } - private void configureJavadocTasks(Project project, SourceSet mainSourceSet) { + private void configureJavadocTasks(Project project, SourceSet mainSourceSet, JdkVersionConfig jdkVersionsConfig) { project.getTasks().named( mainSourceSet.getJavadocTaskName(), Javadoc.class, (task) -> { task.getOptions().setJFlags( javadocFlags( project ) ); - task.doFirst( new Action() { - @Override - public void execute(Task t) { - project.getLogger().lifecycle( - "Generating javadoc with '{}'", - task.getJavadocTool().get().getMetadata().getInstallationPath() - ); - } - } ); + if ( jdkVersionsConfig.isExplicit() ) { + task.doFirst( new Action() { + @Override + public void execute(Task t) { + project.getLogger().lifecycle( + "Generating javadoc with '{}'", + task.getJavadocTool().get().getMetadata().getInstallationPath() + ); + } + } ); + } } ); } diff --git a/local-build-plugins/src/main/java/org/hibernate/orm/toolchains/JdkVersionConfig.java b/local-build-plugins/src/main/java/org/hibernate/orm/toolchains/JdkVersionConfig.java index 64d6f1cebced..c87b8e631fdb 100644 --- a/local-build-plugins/src/main/java/org/hibernate/orm/toolchains/JdkVersionConfig.java +++ b/local-build-plugins/src/main/java/org/hibernate/orm/toolchains/JdkVersionConfig.java @@ -31,7 +31,6 @@ public class JdkVersionConfig { public static final String MAIN_JDK_VERSION = "main.jdk.version"; public static final String TEST_JDK_VERSION = "test.jdk.version"; - private final boolean explicit; private final JavaLanguageVersion baseline; private final JavaLanguageVersion min; private final JavaLanguageVersion max; @@ -39,29 +38,20 @@ public class JdkVersionConfig { private final TestJdks test; public JdkVersionConfig( - boolean explicit, JavaLanguageVersion baseline, JavaLanguageVersion min, JavaLanguageVersion max, - JavaLanguageVersion mainCompilerVersion, - JavaLanguageVersion mainReleaseVersion, - JavaLanguageVersion testCompileVersion, - JavaLanguageVersion testReleaseVersion, - JavaLanguageVersion testLauncherVersion) { - this.explicit = explicit; + MainJdks main, + TestJdks test) { this.baseline = baseline; this.min = min; this.max = max; - this.main = new MainJdks( mainCompilerVersion, mainReleaseVersion ); - this.test = new TestJdks( testCompileVersion, testReleaseVersion, testLauncherVersion ); - } - - public boolean isExplicitlyConfigured() { - return explicit; + this.main = main; + this.test = test; } public boolean isExplicit() { - return explicit; + return main.isExplicit() || test.isExplicit(); } public JavaLanguageVersion getBaseline() { @@ -174,15 +164,11 @@ public static JdkVersionConfig createVersionConfig( testLauncherVersion = testCompilerVersion; return new JdkVersionConfig( - true, baselineJdkVersion, minSupportedJdkVersion, maxSupportedJdkVersion, - mainCompilerVersion, - mainReleaseVersion, - testCompilerVersion, - testReleaseVersion, - testLauncherVersion + new MainJdks( mainCompilerVersion, mainReleaseVersion, explicitMainVersion != null ), + new TestJdks( testCompilerVersion, testReleaseVersion, testLauncherVersion, explicitTestVersion != null ) ); } else { @@ -206,15 +192,11 @@ public static JdkVersionConfig createVersionConfig( } return new JdkVersionConfig( - false, baselineJdkVersion, minSupportedJdkVersion, maxSupportedJdkVersion, - gradleJdkVersion, - baselineJdkVersion, - gradleJdkVersion, - baselineJdkVersion, - gradleJdkVersion + new MainJdks( gradleJdkVersion, baselineJdkVersion, false ), + new TestJdks( gradleJdkVersion, baselineJdkVersion, gradleJdkVersion, false ) ); } } @@ -251,10 +233,12 @@ public static JavaLanguageVersion extractVersion(Project project, String propert public static class MainJdks implements JdkVersionCombo { private final JavaLanguageVersion compilerVersion; private final JavaLanguageVersion releaseVersion; + private final boolean explicit; - public MainJdks(JavaLanguageVersion compilerVersion, JavaLanguageVersion releaseVersion) { + public MainJdks(JavaLanguageVersion compilerVersion, JavaLanguageVersion releaseVersion, boolean explicit) { this.compilerVersion = compilerVersion; this.releaseVersion = releaseVersion; + this.explicit = explicit; } public JavaLanguageVersion getCompiler() { @@ -266,9 +250,14 @@ public JavaLanguageVersion getRelease() { return releaseVersion; } + @Override + public boolean isExplicit() { + return explicit; + } + @Override public String toString() { - return "[compiler: " + compilerVersion + ", release:" + releaseVersion + "]"; + return "[compiler: " + compilerVersion + ", release:" + releaseVersion + ", explicit: " + explicit + "]"; } } @@ -276,14 +265,16 @@ public static class TestJdks implements JdkVersionCombo { private final JavaLanguageVersion compilerVersion; private final JavaLanguageVersion releaseVersion; private final JavaLanguageVersion launcherVersion; + private final boolean explicit; public TestJdks( JavaLanguageVersion compilerVersion, JavaLanguageVersion releaseVersion, - JavaLanguageVersion launcherVersion) { + JavaLanguageVersion launcherVersion, boolean explicit) { this.compilerVersion = compilerVersion; this.releaseVersion = releaseVersion; this.launcherVersion = launcherVersion; + this.explicit = explicit; } @Override @@ -300,14 +291,20 @@ public JavaLanguageVersion getLauncher() { return launcherVersion; } + @Override + public boolean isExplicit() { + return explicit; + } + @Override public String toString() { - return "[compiler: " + compilerVersion + ", release:" + releaseVersion + ", launcher: " + launcherVersion + "]"; + return "[compiler: " + compilerVersion + ", release:" + releaseVersion + ", launcher: " + launcherVersion + ", explicit: " + explicit + "]"; } } - public interface JdkVersionCombo { + public interface JdkVersionCombo { JavaLanguageVersion getCompiler(); JavaLanguageVersion getRelease(); + boolean isExplicit(); } } diff --git a/local-build-plugins/src/main/java/org/hibernate/orm/toolchains/JdkVersionSettingsPlugin.java b/local-build-plugins/src/main/java/org/hibernate/orm/toolchains/JdkVersionSettingsPlugin.java index 4fa112b9bcd4..586d212b4ef1 100644 --- a/local-build-plugins/src/main/java/org/hibernate/orm/toolchains/JdkVersionSettingsPlugin.java +++ b/local-build-plugins/src/main/java/org/hibernate/orm/toolchains/JdkVersionSettingsPlugin.java @@ -56,15 +56,11 @@ public void apply(Settings settings) { settings.getGradle().projectsLoaded( new Action() { @Override public void execute(Gradle gradle) { - final String implicitExplicitString = jdkVersionConfig.isExplicit() ? "explicit" : "implicit"; - System.out.println( "Java versions for main code: " + jdkVersionConfig.getMain() - + " (" + implicitExplicitString + ")" ); System.out.println( "Java versions for test code: " + jdkVersionConfig.getTest() - + " (" + implicitExplicitString + ")" ); } } ); diff --git a/tooling/metamodel-generator/hibernate-processor.gradle b/tooling/metamodel-generator/hibernate-processor.gradle index f806892bc8a6..7570e319f331 100644 --- a/tooling/metamodel-generator/hibernate-processor.gradle +++ b/tooling/metamodel-generator/hibernate-processor.gradle @@ -83,14 +83,8 @@ def quarkusOrmPanacheTestTask = tasks.register( 'quarkusOrmPanacheTest', Test ) testClassesDirs = sourceSets.quarkusOrmPanache.output.classesDirs classpath = sourceSets.quarkusOrmPanache.runtimeClasspath - javaLauncher = tasks.test.javaLauncher shouldRunAfter test } -tasks.named( "compileQuarkusOrmPanacheJava", JavaCompile ) { - sourceCompatibility = tasks.compileTestJava.sourceCompatibility - targetCompatibility = tasks.compileTestJava.targetCompatibility - javaCompiler = tasks.compileTestJava.javaCompiler -} def quarkusHrPanacheTestTask = tasks.register( 'quarkusHrPanacheTest', Test ) { description = 'Runs the Quarkus HR Panache tests.' @@ -98,14 +92,8 @@ def quarkusHrPanacheTestTask = tasks.register( 'quarkusHrPanacheTest', Test ) { testClassesDirs = sourceSets.quarkusHrPanache.output.classesDirs classpath = sourceSets.quarkusHrPanache.runtimeClasspath - javaLauncher = tasks.test.javaLauncher shouldRunAfter test } -tasks.named( "compileQuarkusHrPanacheJava", JavaCompile ) { - sourceCompatibility = tasks.compileTestJava.sourceCompatibility - targetCompatibility = tasks.compileTestJava.targetCompatibility - javaCompiler = tasks.compileTestJava.javaCompiler -} def jakartaDataTestTask = tasks.register( 'jakartaDataTest', Test ) { description = 'Runs the Jakarta Data tests.' @@ -113,14 +101,8 @@ def jakartaDataTestTask = tasks.register( 'jakartaDataTest', Test ) { testClassesDirs = sourceSets.jakartaData.output.classesDirs classpath = sourceSets.jakartaData.runtimeClasspath - javaLauncher = tasks.test.javaLauncher shouldRunAfter test } -tasks.named( "compileJakartaDataJava", JavaCompile ) { - sourceCompatibility = tasks.compileTestJava.sourceCompatibility - targetCompatibility = tasks.compileTestJava.targetCompatibility - javaCompiler = tasks.compileTestJava.javaCompiler -} check.dependsOn quarkusHrPanacheTestTask check.dependsOn quarkusOrmPanacheTestTask From 8d11d9090a38112cc4a07795adfefaa8d38546d9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Yoann=20Rodi=C3=A8re?= Date: Tue, 17 Jun 2025 17:41:01 +0200 Subject: [PATCH 6/8] Use "additionalOptions" to skip Jacoco in Jenkinsfile --- Jenkinsfile | 11 +++-------- 1 file changed, 3 insertions(+), 8 deletions(-) diff --git a/Jenkinsfile b/Jenkinsfile index a4a5b066f9c6..1d0b86c90448 100644 --- a/Jenkinsfile +++ b/Jenkinsfile @@ -46,13 +46,13 @@ stage('Configure') { // We want to enable preview features when testing newer builds of OpenJDK: // even if we don't use these features, just enabling them can cause side effects // and it's useful to test that. - new BuildEnvironment( testJdkVersion: '23', testJdkLauncherArgs: '--enable-preview', skipJacoco: true ), - new BuildEnvironment( testJdkVersion: '24', testJdkLauncherArgs: '--enable-preview', skipJacoco: true ), + new BuildEnvironment( testJdkVersion: '23', testJdkLauncherArgs: '--enable-preview', additionalOptions: '-PskipJacoco=true' ), + new BuildEnvironment( testJdkVersion: '24', testJdkLauncherArgs: '--enable-preview', additionalOptions: '-PskipJacoco=true' ), // The following JDKs aren't supported by Hibernate ORM out-of-the box yet: // they require the use of -Dnet.bytebuddy.experimental=true. // Make sure to remove that argument as soon as possible // -- generally that requires upgrading bytebuddy after the JDK goes GA. - new BuildEnvironment( testJdkVersion: '25', testJdkLauncherArgs: '--enable-preview -Dnet.bytebuddy.experimental=true', skipJacoco: true ), + new BuildEnvironment( testJdkVersion: '25', testJdkLauncherArgs: '--enable-preview -Dnet.bytebuddy.experimental=true', additionalOptions: '-PskipJacoco=true' ), ]; if ( env.CHANGE_ID ) { @@ -143,10 +143,6 @@ stage('Build') { state[buildEnv.tag]['additionalOptions'] = state[buildEnv.tag]['additionalOptions'] + " -Pci.node=${buildEnv.node}" } - if ( buildEnv.skipJacoco ) { - state[buildEnv.tag]['additionalOptions'] = state[buildEnv.tag]['additionalOptions'] + - " -PskipJacoco=true" - } state[buildEnv.tag]['containerName'] = null; stage('Checkout') { checkout scm @@ -233,7 +229,6 @@ class BuildEnvironment { String additionalOptions String notificationRecipients boolean longRunning - boolean skipJacoco String toString() { getTag() } String getTag() { "${node ? node + "_" : ''}${testJdkVersion ? 'jdk_' + testJdkVersion + '_' : '' }${dbName}" } From a8def8b315a212017cfa10e2aa0adf8ac7c9184e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Yoann=20Rodi=C3=A8re?= Date: Wed, 18 Jun 2025 10:30:15 +0200 Subject: [PATCH 7/8] Enable JDK 17 testing even on PRs --- Jenkinsfile | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Jenkinsfile b/Jenkinsfile index 1d0b86c90448..1900d6032739 100644 --- a/Jenkinsfile +++ b/Jenkinsfile @@ -103,7 +103,8 @@ stage('Build') { Map> state = [:] environments.each { BuildEnvironment buildEnv -> // Don't build environments for newer JDKs when this is a PR, unless the PR is labelled with 'jdk' or 'jdk-' - if ( helper.scmSource.pullRequest && buildEnv.testJdkVersion && + if ( helper.scmSource.pullRequest && + buildEnv.testJdkVersion && buildEnv.testJdkVersion.toInteger() > DEFAULT_JDK_VERSION.toInteger() && !pullRequest.labels.contains( 'jdk' ) && !pullRequest.labels.contains( "jdk-${buildEnv.testJdkVersion}" ) ) { return } From 79eeec809ec2843eccb2a488a106efc338807f76 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Yoann=20Rodi=C3=A8re?= Date: Wed, 18 Jun 2025 11:41:01 +0200 Subject: [PATCH 8/8] Limit bytecode used in tests to Java 22, since we still use Gradle 8.8 --- gradle.properties | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/gradle.properties b/gradle.properties index f2cbbad8f9c9..bf09b28cd3f1 100644 --- a/gradle.properties +++ b/gradle.properties @@ -28,4 +28,5 @@ org.gradle.java.installations.auto-download=false # externalized definition of JDK versions so that they are available in both Project (build.gradle) and Settings (settings.gradle) orm.jdk.base=17 orm.jdk.min=21 -orm.jdk.max=24 \ No newline at end of file +# See gradlew/wrapper/gradle-wrapper.properties, https://docs.gradle.org/current/userguide/compatibility.html#java_runtime +orm.jdk.max=22 \ No newline at end of file