refactor: for a cleaner runtime classpath, keep logging related tests in a separate subproject

Author: paulk-asert

.github/workflows/groovy-build-test.yml

@@ -54,7 +54,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        java: [18, 19, 20, 22, 23, 24]
+        java: [18, 19, 20, 22, 23, 24, 26]
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v6

build-logic/src/main/groovy/org.apache.groovy-tested.gradle

@@ -18,6 +18,7 @@
  */
 
 import org.apache.groovy.gradle.ConcurrentExecutionControlBuildService
+import org.apache.groovy.gradle.TargetJavaHomeSupport
 
 // TODO: Instead of adding to the test sources, these should be a
 // separate source set so that we can run spec tests in isolation
@@ -44,15 +45,9 @@ dependencies {
 tasks.withType(Test).configureEach {
     def fs = objects.newInstance(TestServices).fileSystemOperations
     def grapeDirectory = new File(temporaryDir, 'grape')
-    def jdk8 = ['-XX:+UseConcMarkSweepGC']
-    def jdk9 = ['-Djava.locale.providers=COMPAT,SPI']
-    def common = ['-ea', "-Xms${groovyJUnit_ms}", "-Xmx${groovyJUnit_mx}", '-Duser.language=en']
-    if (JavaVersion.current().isJava9Compatible()) {
-        jvmArgs(*common, *jdk9)
-        systemProperty 'groovy.force.illegal.access', findProperty('groovy.force.illegal.access')
-    } else {
-        jvmArgs(*common, *jdk8)
-    }
+    def options = ['-ea', "-Xms${groovyJUnit_ms}", "-Xmx${groovyJUnit_mx}", '-Duser.language=en', '-Djava.locale.providers=COMPAT,SPI']
+    jvmArgs(*options)
+    systemProperty 'groovy.force.illegal.access', findProperty('groovy.force.illegal.access')
     def testdb = System.properties['groovy.testdb.props']
     if (testdb) {
         systemProperty 'groovy.testdb.props', testdb
@@ -70,12 +65,10 @@ tasks.withType(Test).configureEach {
         userHome: temporaryDir // make sure tests are isolated from real user home or tests using Grape may fail
     ))
 
-    if (rootProject.hasProperty('target.java.home')) {
-        String targetJavaHome = rootProject.property('target.java.home')?.trim()
-        if (targetJavaHome) {
-            executable = "${targetJavaHome}/bin/java"
-            println "Using ${executable} to run tests"
-        }
+    String targetJavaHome = TargetJavaHomeSupport.targetJavaHome(project)
+    if (targetJavaHome) {
+        executable = TargetJavaHomeSupport.javaExecutable(targetJavaHome)
+        println "Using ${executable} to run tests"
     }
 
     forkEvery = 50
@@ -109,6 +102,17 @@ tasks.withType(Test).configureEach {
     }
 }
 
+tasks.withType(GroovyCompile).configureEach {
+    if (name == 'compileTestGroovy') {
+        Integer feature = TargetJavaHomeSupport.featureVersionFromReleaseFile(TargetJavaHomeSupport.targetJavaHome(project))
+        if (feature != null) {
+            javaLauncher = javaToolchains.launcherFor {
+                languageVersion = JavaLanguageVersion.of(feature)
+            }
+        }
+    }
+}
+
 class TestCommandLineArgumentProvider implements CommandLineArgumentProvider {
 
     @Internal

build-logic/src/main/groovy/org/apache/groovy/gradle/TargetJavaHomeSupport.groovy

@@ -0,0 +1,56 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you 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
+ *
+ *    http://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.apache.groovy.gradle
+
+import groovy.transform.CompileStatic
+import org.gradle.api.Project
+
+@CompileStatic
+final class TargetJavaHomeSupport {
+
+    private TargetJavaHomeSupport() {}
+
+    /** Returns the trimmed value of the {@code target.java.home} Gradle property, or {@code null} if absent/blank. */
+    static String targetJavaHome(Project project) {
+        if (!project.rootProject.hasProperty('target.java.home')) return null
+        String value = project.rootProject.property('target.java.home')?.toString()?.trim()
+        return value ?: null
+    }
+
+    /** Returns the {@code java} executable path for the given Java home directory. */
+    static String javaExecutable(String javaHome) {
+        return javaHome ? "${javaHome}/bin/java" : null
+    }
+
+    /**
+     * Reads the {@code release} file inside the given Java home and returns the
+     * feature release number (e.g. 17 for "17.0.2", 21 for "21"), or {@code null}
+     * if the file is absent or unparseable.
+     */
+    static Integer featureVersionFromReleaseFile(String javaHome) {
+        if (!javaHome) return null
+        File releaseFile = new File(javaHome, 'release')
+        if (!releaseFile.exists()) return null
+        String line = releaseFile.readLines().find { it.startsWith('JAVA_VERSION=') }
+        if (!line) return null
+        def matcher = (line =~ /\"(\d+)(?:\.\d+)*\"/)
+        return matcher.find() ? (matcher.group(1) as Integer) : null
+    }
+}
+

build.gradle

@@ -115,10 +115,6 @@ dependencies {
     testImplementation projects.groovyMacro
     testImplementation projects.groovyDateutil
     testImplementation "net.jcip:jcip-annotations:${versions.jcipAnnotations}"
-    testImplementation "ch.qos.logback:logback-classic:${versions.logback}"
-    testImplementation "log4j:log4j:${versions.log4j}"
-    testImplementation "org.apache.logging.log4j:log4j-core:${versions.log4j2}"
-    testImplementation "org.slf4j:jcl-over-slf4j:${versions.slf4j}"
     testImplementation "com.thoughtworks.qdox:qdox:${versions.qdox}"
     testImplementation "com.fasterxml.jackson.core:jackson-databind:${versions.jackson}"
     testImplementation "com.fasterxml.jackson.dataformat:jackson-dataformat-yaml:${versions.jackson}"

settings.gradle

@@ -61,6 +61,7 @@ def subprojects = [
         'groovy-jmx',
         'groovy-json',
         'groovy-jsr223',
+        'groovy-logging-test',
         'groovy-ginq',
         'groovy-macro',
         'groovy-macro-library',

src/spec/doc/core-metaprogramming.adoc

@@ -2115,159 +2115,7 @@ In this example, we also set the `strict` parameter to false, which allows us to
 
 Deprecated. Consider using traits instead.
 
-==== Logging improvements
-
-Groovy provides a family of AST transformations that help with integration of the most widely
-used logging frameworks. There is a transform and associated annotation for each of the common frameworks.
-These transforms provide a streamlined declarative approach to using the logging framework.
-In each case, the transform will:
-
-* add a static final `log` field to the annotated class corresponding to the logger
-* wrap all calls to `log.level()` into the appropriate `log.isLevelEnabled` guard, depending on the underlying framework
-
-Those transformations support two parameters:
-
-* `value` (default `log`) corresponds to the name of the logger field
-* `category` (defaults to the class name) is the name of the logger category
-
-It's worth noting that annotating a class with one of those annotations doesn't
-prevent you from using the logging framework using the normal long-hand approach.
-
-[[xform-Log]]
-===== `@groovy.util.logging.Log`
-
-The first logging AST transformation available is the `@Log` annotation which relies on the JDK logging framework. Writing:
-
-[source,groovy]
-----
-include::../test/LogImprovementsASTTransformsTest.groovy[tags=log_spec,indent=0]
-----
-
-is equivalent to writing:
-
-[source,groovy]
-----
-include::../test/LogImprovementsASTTransformsTest.groovy[tags=log_equiv,indent=0]
-----
-
-[[xform-Commons]]
-===== `@groovy.util.logging.Commons`
-
-Groovy supports the http://commons.apache.org/proper/commons-logging/[Apache Commons Logging] framework using the
-`@Commons` annotation. Writing:
-
-[source,groovy]
-----
-include::../test/LogImprovementsASTTransformsTest.groovy[tags=commons_spec,indent=0]
-----
-
-is equivalent to writing:
-
-[source,groovy]
-----
-include::../test/LogImprovementsASTTransformsTest.groovy[tags=commons_equiv,indent=0]
-----
-
-You still need to add the appropriate commons-logging jar to your classpath.
-
-[[xform-Log4j]]
-===== `@groovy.util.logging.Log4j`
-
-Groovy supports the http://logging.apache.org/log4j/1.2/[Apache Log4j 1.x] framework using the
-`@Log4j` annotation. Writing:
-
-[source,groovy]
-----
-include::../test/LogImprovementsASTTransformsTest.groovy[tags=log4j_spec,indent=0]
-----
-
-is equivalent to writing:
-
-[source,groovy]
-----
-include::../test/LogImprovementsASTTransformsTest.groovy[tags=log4j_equiv,indent=0]
-----
-
-You still need to add the appropriate log4j jar to your classpath.
-This annotation can also be used with the compatible https://reload4j.qos.ch/[reload4j] log4j
-drop-in replacement, just use the jar from that project instead of a log4j jar.
-
-[[xform-Log4j2]]
-===== `@groovy.util.logging.Log4j2`
-
-Groovy supports the http://logging.apache.org/log4j/2.x/[Apache Log4j 2.x] framework using the
-`@Log4j2` annotation. Writing:
-
-[source,groovy]
-----
-include::../test/LogImprovementsASTTransformsTest.groovy[tags=log4j2_spec,indent=0]
-----
-
-is equivalent to writing:
-
-[source,groovy]
-----
-include::../test/LogImprovementsASTTransformsTest.groovy[tags=log4j2_equiv,indent=0]
-----
-
-You still need to add the appropriate log4j2 jar to your classpath.
-
-[[xform-Slf4j]]
-===== `@groovy.util.logging.Slf4j`
-
-Groovy supports the http://www.slf4j.org/[Simple Logging Facade for Java (SLF4J)] framework using the
-`@Slf4j` annotation. Writing:
-
-[source,groovy]
-----
-include::../test/LogImprovementsASTTransformsTest.groovy[tags=slf4j_spec,indent=0]
-----
-
-is equivalent to writing:
-
-[source,groovy]
-----
-include::../test/LogImprovementsASTTransformsTest.groovy[tags=slf4j_equiv,indent=0]
-----
-
-You still need to add the appropriate slf4j jar(s) to your classpath.
-
-[[xform-PlatformLog]]
-===== `@groovy.util.logging.PlatformLog`
-
-Groovy supports the https://openjdk.org/jeps/264[Java Platform Logging API and Service]
-framework using the `@PlatformLog` annotation. Writing:
-
-[source,groovy]
-----
-@groovy.util.logging.PlatformLog
-class Greeter {
-    void greet() {
-        log.info 'Called greeter'
-        println 'Hello, world!'
-    }
-}
-----
-
-is equivalent to writing:
-
-[source,groovy]
-----
-import java.lang.System.Logger
-import java.lang.System.LoggerFinder
-import static java.lang.System.Logger.Level.INFO
-
-class Greeter {
-    private static final transient Logger log =
-        LoggerFinder.loggerFinder.getLogger(Greeter.class.name, Greeter.class.module)
-    void greet() {
-        log.log INFO, 'Called greeter'
-        println 'Hello, world!'
-    }
-}
-----
-
-You need to be using JDK 9+ to use this capability.
+include::../../../subprojects/groovy-logging-test/src/spec/doc/logging-transforms.adoc[]
 
 ==== Declarative concurrency
 

src/test/groovy/org/codehaus/groovy/reflection/SecurityTest.java

@@ -102,6 +102,9 @@ public void setUp() {
          *         at java.base/java.lang.invoke.BootstrapMethodInvoker.invoke(BootstrapMethodInvoker.java:127)
          */
         VMPluginFactory.getPlugin();
+        // ReflectionUtils initializes StackWalker, which can trigger reflective access checks.
+        // Warm it up before the restrictive manager is active.
+        ReflectionUtils.getCallingClass();
 
         forbidden = new Permissions();
         forbidden.add(new ReflectPermission("suppressAccessChecks"));