HHH-13682 Generate Java 11/13/14 bytecode for tests when building with JDK11/13/14

build.gradle

@@ -58,7 +58,7 @@ task release {
 	// Force to release with JDK 8. Releasing with JDK 11 is not supported yet:
 	// - the hibernate-orm-modules tests do not run due to an issue with the ASM version currently used by Gradle
 	doFirst {
-		if ( !JavaVersion.current().isJava8() ) {
+		if ( !JavaVersion.current().isJava8() || !gradle.ext.testedJavaVersionAsEnum.isJava8() ) {
 			throw new IllegalStateException( "Please use JDK 8 to perform the release." )
 		}
 	}

documentation/documentation.gradle

@@ -140,9 +140,7 @@ task aggregateJavadocs(type: Javadoc) {
 			options.source = project.baselineJavaVersion
 		}
 
-		if ( JavaVersion.current().isJava8Compatible() ) {
-			options.addStringOption( 'Xdoclint:none', '-quiet' )
-		}
+		options.addStringOption( 'Xdoclint:none', '-quiet' )
 	}
 
     // process each project, building up:

gradle/java-module.gradle

@@ -10,7 +10,7 @@ buildscript {
 		mavenCentral()
 	}
 	dependencies {
-		classpath 'de.thetaphi:forbiddenapis:2.6'
+		classpath 'de.thetaphi:forbiddenapis:2.7'
 	}
 }
 
@@ -38,10 +38,6 @@ ext {
 	forbiddenAPITargetJDKCompatibility = '11'
 }
 
-
-sourceCompatibility = project.baselineJavaVersion
-targetCompatibility = project.baselineJavaVersion
-
 if ( !project.description ) {
 	project.description = "The Hibernate ORM $project.name module"
 }
@@ -115,8 +111,20 @@ dependencies {
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 // Compilation
 
-tasks.withType(JavaCompile) {
+tasks.withType( JavaCompile ) {
 	options.encoding = 'UTF-8'
+	sourceCompatibility = project.baselineJavaVersion
+	targetCompatibility = project.baselineJavaVersion
+}
+
+if ( project.baselineJavaVersion != gradle.ext.testedJavaVersion ) {
+	logger.info( "Forcing the target bytecode version for test classes to '$gradle.ext.testedJavaVersion'" )
+
+	tasks.compileTestJava {
+		// For *tests only*, generate bytecode matching the Java version currently in use.
+		// This allows testing bytecode enhancement on the latest Java versions (13, 14, ...).
+		targetCompatibility = gradle.ext.testedJavaVersion
+	}
 }
 
 task compile(dependsOn: [compileJava, processResources, compileTestJava, processTestResources] )
@@ -200,18 +208,6 @@ processTestResources {
 	}
 }
 
-// Enable the experimental features of ByteBuddy with JDK 12+
-test {
-	//Only safe to attempt to parse the version as an integer since JDK11
-	if ( JavaVersion.current().isJava11Compatible() ) {
-		int majorJVMVersionInt = Integer.valueOf(JavaVersion.current().toString());
-		//Set the -Dnet.bytebuddy.experimental=true property only when we need it:
-		if (majorJVMVersionInt >= 12) {
-			systemProperty 'net.bytebuddy.experimental', true
-		}
-	}
-}
-
 test {
 	if ( project.findProperty( 'log-test-progress' )?.toString()?.toBoolean() ) {
 		// Log a statement for each test.

gradle/published-java-module.gradle

@@ -131,9 +131,7 @@ javadoc {
 			options.source = project.baselineJavaVersion
 		}
 
-		if ( JavaVersion.current().isJava8Compatible() ) {
-			options.addStringOption( 'Xdoclint:none', '-quiet' )
-		}
+		options.addStringOption( 'Xdoclint:none', '-quiet' )
 
 		doFirst {
 			// ordering problems if we try to do this during config phase :(

hibernate-core/src/test/java/org/hibernate/test/bytecode/enhancement/lazy/NaturalIdInUninitializedAssociationTest.java

@@ -39,7 +39,7 @@
 @SuppressWarnings({"unused", "WeakerAccess","ResultOfMethodCallIgnored"})
 @TestForIssue( jiraKey = "HHH-13607" )
 @RunWith( BytecodeEnhancerRunner.class )
-@EnhancementOptions( lazyLoading = true )
+@EnhancementOptions( lazyLoading = true, extendedEnhancement = true )
 public class NaturalIdInUninitializedAssociationTest extends BaseNonConfigCoreFunctionalTestCase {
 
 	@Test

hibernate-integrationtest-java-modules/hibernate-integrationtest-java-modules.gradle

@@ -24,10 +24,12 @@ apply from: rootProject.file( 'gradle/java-module.gradle' )
 // so we have to use https://github.com/java9-modularity/gradle-modules-plugin
 apply plugin: "org.javamodularity.moduleplugin"
 
-// Override -source and -target
-ext.baselineJavaVersion = 11
-sourceCompatibility = project.baselineJavaVersion
-targetCompatibility = project.baselineJavaVersion
+// Override -source and -target to the version being tested (11+, since this module is enabled)
+ext.baselineJavaVersion = gradle.ext.testedJavaVersion
+tasks.withType( JavaCompile ) {
+	sourceCompatibility = project.baselineJavaVersion
+	targetCompatibility = project.baselineJavaVersion
+}
 
 // Checkstyle fails for module-info
 checkstyleMain.exclude '**/module-info.java'

settings.gradle

@@ -10,7 +10,36 @@ plugins {
 }
 
 if ( !JavaVersion.current().java8Compatible ) {
-    throw new GradleException( "Gradle must be run with Java 8" )
+    throw new GradleException( "Gradle must be run with Java 8 or later" )
+}
+
+// Consume the property 'testedJavaVersion' here and
+// set it on gradle.ext so that we can inspect the result in build.gradle.
+// We wouldn't be able to do that if we consumed
+// the property in base-information.gradle and set it on project.ext.
+
+if ( hasProperty( 'testedJavaVersion' ) ) {
+    logger.warn( "[WARN] Targeting Java version '$testedJavaVersion' in tests." )
+    gradle.ext.testedJavaVersion = testedJavaVersion
+    gradle.ext.testedJavaVersionAsEnum = JavaVersion.toVersion( testedJavaVersion )
+}
+else {
+    // We will simply use Gradle's JDK for compilation, tests and javadoc generation.
+    def major
+    if ( JavaVersion.current() == JavaVersion.VERSION_HIGHER) {
+        logger.warn( "Gradle does not support this JDK, because it is too recent; build is likely to fail." +
+                " To avoid failures, you should specify an older Java version in the 'testedJavaVersion' parameter." +
+                " Just append the following to your gradle command:" +
+                " '-PtestedJavaVersion=<major version of your newer JDK, e.g. 14>'" )
+        // Use a hack to retrieve the major as a string.
+        // This only works for Java 9+ (we're at least on Java 18 here).
+        gradle.ext.testedJavaVersion = System.getProperty( 'java.specification.version' )
+    }
+    else {
+        gradle.ext.testedJavaVersion = JavaVersion.current().getMajorVersion()
+    }
+
+    gradle.ext.testedJavaVersionAsEnum = JavaVersion.current()
 }
 
 include 'hibernate-core'