This is an automated email from the ASF dual-hosted git repository.

emilles pushed a commit to branch GROOVY_4_0_X
in repository https://gitbox.apache.org/repos/asf/groovy.git


The following commit(s) were added to refs/heads/GROOVY_4_0_X by this push:
     new 0526cb7973 fix jdk8 with target executable
0526cb7973 is described below

commit 0526cb7973a8b34019b6bfb7d3e72fb0c3da9111
Author: Eric Milles <[email protected]>
AuthorDate: Fri Oct 3 15:19:23 2025 -0500

    fix jdk8 with target executable
---
 .../groovy/util/logging/vm9/PlatformLogTest.groovy | 297 +++++++++++----------
 .../groovy/vmplugin/v9/ClassFinderTest.groovy      |  12 +-
 .../groovy/text/StreamingTemplateEngineTest.groovy |  34 +--
 3 files changed, 185 insertions(+), 158 deletions(-)

diff --git a/src/test/groovy/groovy/util/logging/vm9/PlatformLogTest.groovy 
b/src/test/groovy/groovy/util/logging/vm9/PlatformLogTest.groovy
index 5b4a3a733c..8fd9744d96 100644
--- a/src/test/groovy/groovy/util/logging/vm9/PlatformLogTest.groovy
+++ b/src/test/groovy/groovy/util/logging/vm9/PlatformLogTest.groovy
@@ -18,161 +18,173 @@
  */
 package groovy.util.logging.vm9
 
-import groovy.test.GroovyTestCase
-import groovy.util.logging.PlatformLog
 import org.codehaus.groovy.control.MultipleCompilationErrorsException
+import org.junit.Before
+import org.junit.Test
 
 import java.lang.reflect.Field
 import java.lang.reflect.Modifier
 
+import static groovy.test.GroovyAssert.isAtLeastJdk
+import static groovy.test.GroovyAssert.shouldFail
+import static org.junit.Assume.assumeTrue
+
 /**
  * Test to make sure the @Log annotation is working correctly.
  */
-class PlatformLogTest extends GroovyTestCase {
+final class PlatformLogTest {
+
+    @Before
+    void setUp() {
+        assumeTrue(isAtLeastJdk('9'))
+    }
+
+    @Test
     void testPrivateFinalStaticLogFieldAppears() {
-        Class clazz = new GroovyClassLoader().parseClass('''
+        Class clazz = new GroovyClassLoader().parseClass '''
             @groovy.util.logging.PlatformLog
             class MyClassPrivateFinalStaticLogFieldAppears { }
-        ''')
-
+        '''
         assert clazz.declaredFields.find { Field field ->
-            field.name == 'log' &&
-                    Modifier.isPrivate(field.getModifiers()) &&
-                    Modifier.isStatic(field.getModifiers()) &&
-                    Modifier.isTransient(field.getModifiers()) &&
-                    Modifier.isFinal(field.getModifiers())
+            field.name == 'log'
+                && Modifier.isFinal(field.getModifiers())
+                && Modifier.isStatic(field.getModifiers())
+                && Modifier.isPrivate(field.getModifiers())
+                && Modifier.isTransient(field.getModifiers())
         }
     }
 
+    @Test
     void testPrivateFinalStaticNamedLogFieldAppears() {
-        Class clazz = new GroovyClassLoader().parseClass('''
+        Class clazz = new GroovyClassLoader().parseClass '''
             @groovy.util.logging.PlatformLog('logger')
             class MyClassPrivateFinalStaticNamedLogFieldAppears { }
-        ''')
-
+        '''
         assert clazz.declaredFields.find { Field field ->
-            field.name == 'logger' &&
-                    Modifier.isPrivate(field.getModifiers()) &&
-                    Modifier.isStatic(field.getModifiers()) &&
-                    Modifier.isTransient(field.getModifiers()) &&
-                    Modifier.isFinal(field.getModifiers())
+            field.name == 'logger'
+                && Modifier.isFinal(field.getModifiers())
+                && Modifier.isStatic(field.getModifiers())
+                && Modifier.isPrivate(field.getModifiers())
+                && Modifier.isTransient(field.getModifiers())
         }
     }
 
+    @Test
     void testExplicitPrivateFinalStaticLogFieldAppears() {
-        Class clazz = new GroovyClassLoader().parseClass('''
+        Class clazz = new GroovyClassLoader().parseClass '''
             import static groovy.transform.options.Visibility.*
             @groovy.transform.VisibilityOptions(value = PRIVATE)
             @groovy.util.logging.PlatformLog
             class MyClassExplicitPrivateFinalStaticLogFieldAppears { }
-        ''')
-
+        '''
         assert clazz.declaredFields.find { Field field ->
-            field.name == 'log' &&
-                    Modifier.isPrivate(field.getModifiers()) &&
-                    Modifier.isStatic(field.getModifiers()) &&
-                    Modifier.isTransient(field.getModifiers()) &&
-                    Modifier.isFinal(field.getModifiers())
+            field.name == 'log'
+                && Modifier.isFinal(field.getModifiers())
+                && Modifier.isStatic(field.getModifiers())
+                && Modifier.isPrivate(field.getModifiers())
+                && Modifier.isTransient(field.getModifiers())
         }
     }
 
+    @Test
     void testPackagePrivateFinalStaticLogFieldAppears() {
-        Class clazz = new GroovyClassLoader().parseClass('''
+        Class clazz = new GroovyClassLoader().parseClass '''
             import static groovy.transform.options.Visibility.*
             @groovy.transform.VisibilityOptions(value = PACKAGE_PRIVATE)
             @groovy.util.logging.PlatformLog
             class MyClassPackagePrivateFinalStaticLogFieldAppears { }
-        ''')
-
+        '''
         assert clazz.declaredFields.find { Field field ->
-            field.name == 'log' &&
-                    !Modifier.isPrivate(field.getModifiers()) &&
-                    !Modifier.isProtected(field.getModifiers()) &&
-                    !Modifier.isPublic(field.getModifiers()) &&
-                    Modifier.isStatic(field.getModifiers()) &&
-                    Modifier.isTransient(field.getModifiers()) &&
-                    Modifier.isFinal(field.getModifiers())
+            field.name == 'log'
+                &&  Modifier.isFinal(field.getModifiers())
+                &&  Modifier.isStatic(field.getModifiers())
+                && !Modifier.isPublic(field.getModifiers())
+                && !Modifier.isPrivate(field.getModifiers())
+                && !Modifier.isProtected(field.getModifiers())
+                &&  Modifier.isTransient(field.getModifiers())
         }
     }
 
+    @Test
     void testProtectedFinalStaticLogFieldAppears() {
-        Class clazz = new GroovyClassLoader().parseClass('''
+        Class clazz = new GroovyClassLoader().parseClass '''
             import static groovy.transform.options.Visibility.*
             @groovy.transform.VisibilityOptions(value = PROTECTED)
             @groovy.util.logging.PlatformLog
             class MyClassProtectedFinalStaticLogFieldAppears { }
-        ''')
-
+        '''
         assert clazz.declaredFields.find { Field field ->
-            field.name == 'log' &&
-                    Modifier.isProtected(field.getModifiers()) &&
-                    Modifier.isStatic(field.getModifiers()) &&
-                    Modifier.isTransient(field.getModifiers()) &&
-                    Modifier.isFinal(field.getModifiers())
+            field.name == 'log'
+                && Modifier.isFinal(field.getModifiers())
+                && Modifier.isStatic(field.getModifiers())
+                && Modifier.isProtected(field.getModifiers())
+                && Modifier.isTransient(field.getModifiers())
         }
     }
 
+    @Test
     void testPublicFinalStaticLogFieldAppears() {
-        Class clazz = new GroovyClassLoader().parseClass('''
+        Class clazz = new GroovyClassLoader().parseClass '''
             import static groovy.transform.options.Visibility.*
             @groovy.transform.VisibilityOptions(value = PUBLIC)
             @groovy.util.logging.PlatformLog
             class MyClassPublicFinalStaticLogFieldAppears { }
-        ''')
-
+        '''
         assert clazz.declaredFields.find { Field field ->
-            field.name == 'log' &&
-                    Modifier.isPublic(field.getModifiers()) &&
-                    Modifier.isStatic(field.getModifiers()) &&
-                    Modifier.isTransient(field.getModifiers()) &&
-                    Modifier.isFinal(field.getModifiers())
+            field.name == 'log'
+                && Modifier.isFinal(field.getModifiers())
+                && Modifier.isStatic(field.getModifiers())
+                && Modifier.isPublic(field.getModifiers())
+                && Modifier.isTransient(field.getModifiers())
         }
     }
 
+    @Test
     void testClassAlreadyHasLogField() {
-        def msg = shouldFail {
-            Class clazz = new GroovyClassLoader().parseClass('''
-                @groovy.util.logging.PlatformLog
-                class MyClassAlreadyHasLogField {
-                    String log
-                }
-            ''')
-
-            assert clazz.getConstructor().newInstance()
-        }
-        assert msg.contains('cannot have log field declared')
+        def err = shouldFail '''
+            @groovy.util.logging.PlatformLog
+            class MyClassAlreadyHasLogField {
+                String log
+            }
+        '''
+        assert err.message.contains('cannot have log field declared')
     }
 
+    @Test
     void testClassAlreadyHasNamedLogField() {
-        def msg = shouldFail {
-            Class clazz = new GroovyClassLoader().parseClass('''
-                @groovy.util.logging.PlatformLog('logger')
-                class MyClassAlreadyHasNamedLogField {
-                    String logger
-                }
-            ''')
-            assert clazz.getConstructor().newInstance()
-        }
-        assert msg.contains('cannot have log field declared')
-    }
-
-    @PlatformLog
-    static class MyClassLogFromStaticMethods {
-        static loggingMethod() {
-            log.info ('info    called')
-        }
+        def err = shouldFail '''
+            @groovy.util.logging.PlatformLog('logger')
+            class MyClassAlreadyHasNamedLogField {
+                String logger
+            }
+        '''
+        assert err.message.contains('cannot have log field declared')
     }
 
+    @Test
     void testLogFromStaticMethods() {
-        MyClassLogFromStaticMethods.loggingMethod()
+        Class clazz = new GroovyClassLoader().parseClass '''
+            @groovy.util.logging.PlatformLog
+            class MyClassLogFromStaticMethods {
+                static loggingMethod() {
+                    log.info('info called')
+                }
+            }
+        '''
+        clazz.loggingMethod()
         def finder = System.LoggerFinder.getLoggerFinder()
         assert finder instanceof LoggerSpyFinder
         def logSpy = finder.spy
-        assert logSpy.infoParameter    == 'info    called'
+        try {
+            assert logSpy.infoParameter == 'info called'
+        } finally {
+            logSpy.reset()
+        }
     }
 
+    @Test
     void testLogInfo() {
-        Class clazz = new GroovyClassLoader().parseClass('''
+        Class clazz = new GroovyClassLoader().parseClass '''
             @groovy.util.logging.PlatformLog
             class MyClassLogInfo {
                 def loggingMethod() {
@@ -183,45 +195,54 @@ class PlatformLogTest extends GroovyTestCase {
                     log.trace('trace   called')
                 }
             }
-        ''')
-        def s = clazz.getConstructor().newInstance()
-        s.loggingMethod()
+        '''
+        clazz.getConstructor().newInstance().loggingMethod()
         def finder = System.LoggerFinder.getLoggerFinder()
         assert finder instanceof LoggerSpyFinder
         def logSpy = finder.spy
-        assert logSpy.warningParameter == 'warning called'
-        assert logSpy.infoParameter    == 'info    called'
-        assert logSpy.debugParameter   == 'debug   called'
-        assert logSpy.traceParameter   == 'trace   called'
-        assert logSpy.errorParameter   == 'error   called'
-        logSpy.reset()
-    }
-
-    @PlatformLog('logger')
-    static class MyClassLogInfoWithName {
-        def loggingMethod() {
-            logger.error('error   called')
-            logger.warn ('warning called')
-            logger.info ('info    called')
-            logger.debug('debug   called')
-            logger.trace('trace   called')
+        try {
+            assert logSpy.warningParameter == 'warning called'
+            assert logSpy.infoParameter    == 'info    called'
+            assert logSpy.debugParameter   == 'debug   called'
+            assert logSpy.traceParameter   == 'trace   called'
+            assert logSpy.errorParameter   == 'error   called'
+        } finally {
+            logSpy.reset()
         }
     }
 
+    @Test
     void testLogInfoWithName() {
-        new MyClassLogInfoWithName().loggingMethod()
+        Class clazz = new GroovyClassLoader().parseClass '''
+            @groovy.util.logging.PlatformLog('logger')
+            class MyClassLogInfoWithName {
+                def loggingMethod() {
+                    logger.error('error   called')
+                    logger.warn ('warning called')
+                    logger.info ('info    called')
+                    logger.debug('debug   called')
+                    logger.trace('trace   called')
+                }
+            }
+        '''
+        clazz.getConstructor().newInstance().loggingMethod()
         def finder = System.LoggerFinder.getLoggerFinder()
         assert finder instanceof LoggerSpyFinder
         def logSpy = finder.spy
-        assert logSpy.warningParameter == 'warning called'
-        assert logSpy.infoParameter    == 'info    called'
-        assert logSpy.debugParameter   == 'debug   called'
-        assert logSpy.traceParameter   == 'trace   called'
-        assert logSpy.errorParameter   == 'error   called'
+        try {
+            assert logSpy.warningParameter == 'warning called'
+            assert logSpy.infoParameter    == 'info    called'
+            assert logSpy.debugParameter   == 'debug   called'
+            assert logSpy.traceParameter   == 'trace   called'
+            assert logSpy.errorParameter   == 'error   called'
+        } finally {
+            logSpy.reset()
+        }
     }
 
+    @Test
     void testInheritancePrivateNoShadowingIssue() {
-        def clazz = new GroovyShell().evaluate('''
+        Class clazz = new GroovyShell().evaluate '''
             class MyParentTestInheritance {
                 private log
             }
@@ -229,7 +250,7 @@ class PlatformLogTest extends GroovyTestCase {
             @groovy.util.logging.PlatformLog
             class MyClassTestInheritance extends MyParentTestInheritance {
                 def loggingMethod() {
-                    log.info   (prepareLogMessage())
+                    log.info(prepareLogMessage())
                 }
                 def prepareLogMessage() {
                     'formatted log message'
@@ -237,44 +258,40 @@ class PlatformLogTest extends GroovyTestCase {
             }
 
             return MyClassTestInheritance
-        ''')
-
+        '''
         assert clazz.declaredFields.find { Field field ->
-            field.name == 'log' &&
-                    Modifier.isPrivate(field.getModifiers()) &&
-                    Modifier.isStatic(field.getModifiers()) &&
-                    Modifier.isTransient(field.getModifiers()) &&
-                    Modifier.isFinal(field.getModifiers())
+            field.name == 'log'
+                && Modifier.isFinal(field.getModifiers())
+                && Modifier.isStatic(field.getModifiers())
+                && Modifier.isPrivate(field.getModifiers())
+                && Modifier.isTransient(field.getModifiers())
         }
     }
 
+    @Test
     void testInheritanceProtectedShadowing() {
-        def msg = shouldFail(MultipleCompilationErrorsException) {
-            new GroovyClassLoader().parseClass('''
-                class MyParentProtectedShadowing {
-                    protected log
-                }
+        def err = shouldFail MultipleCompilationErrorsException, '''
+            class MyParentProtectedShadowing {
+                protected log
+            }
 
-                @groovy.util.logging.PlatformLog
-                class MyClassProtectedShadowing extends 
MyParentProtectedShadowing { }
-            ''')
-        }
-        assert msg.contains('cannot have log field declared because the field 
exists in the parent class')
+            @groovy.util.logging.PlatformLog
+            class MyClassProtectedShadowing extends MyParentProtectedShadowing 
{ }
+        '''
+        assert err.message.contains('cannot have log field declared because 
the field exists in the parent class')
     }
 
+    @Test
     void testInheritancePublicShadowing() {
-        def msg = shouldFail(MultipleCompilationErrorsException) {
-            new GroovyClassLoader().parseClass('''
-                class MyParentPublicShadowing {
-                    public log
-                }
+        def err = shouldFail MultipleCompilationErrorsException, '''
+            class MyParentPublicShadowing {
+                public log
+            }
 
-                @groovy.util.logging.PlatformLog
-                class MyClassPublicShadowing extends MyParentPublicShadowing {
-                }
-            ''')
-        }
-        assert msg.contains('cannot have log field declared because the field 
exists in the parent class')
+            @groovy.util.logging.PlatformLog
+            class MyClassPublicShadowing extends MyParentPublicShadowing {
+            }
+        '''
+        assert err.message.contains('cannot have log field declared because 
the field exists in the parent class')
     }
 }
-
diff --git 
a/src/test/groovy/org/codehaus/groovy/vmplugin/v9/ClassFinderTest.groovy 
b/src/test/groovy/org/codehaus/groovy/vmplugin/v9/ClassFinderTest.groovy
index 824d5ff5a5..16d8615c7d 100644
--- a/src/test/groovy/org/codehaus/groovy/vmplugin/v9/ClassFinderTest.groovy
+++ b/src/test/groovy/org/codehaus/groovy/vmplugin/v9/ClassFinderTest.groovy
@@ -20,11 +20,21 @@ package org.codehaus.groovy.vmplugin.v9
 
 import org.codehaus.groovy.control.ResolveVisitor
 import org.codehaus.groovy.vmplugin.VMPluginFactory
+import org.junit.Before
 import org.junit.Test
 
 import java.util.stream.Collectors
 
-class ClassFinderTest {
+import static groovy.test.GroovyAssert.isAtLeastJdk
+import static org.junit.Assume.assumeTrue
+
+final class ClassFinderTest {
+
+    @Before
+    void setUp() {
+        assumeTrue(isAtLeastJdk('9'))
+    }
+
     @Test
     void findGroovyClass() {
         Map<String, Set<String>> result = 
ClassFinder.find(GroovySystem.location.toURI(), "groovy/lang")
diff --git 
a/subprojects/groovy-templates/src/test/groovy/groovy/text/StreamingTemplateEngineTest.groovy
 
b/subprojects/groovy-templates/src/test/groovy/groovy/text/StreamingTemplateEngineTest.groovy
index 94e1273ac4..c77f82ad9e 100644
--- 
a/subprojects/groovy-templates/src/test/groovy/groovy/text/StreamingTemplateEngineTest.groovy
+++ 
b/subprojects/groovy-templates/src/test/groovy/groovy/text/StreamingTemplateEngineTest.groovy
@@ -25,7 +25,8 @@ import java.util.concurrent.ConcurrentHashMap
 
 import static groovy.test.GroovyAssert.assertScript
 
-class StreamingTemplateEngineTest {
+final class StreamingTemplateEngineTest {
+
   TemplateEngine engine
   Map binding
   private static final String SIXTY_FOUR_K_OF_A
@@ -510,22 +511,21 @@ class StreamingTemplateEngineTest {
     '''
   }
 
+  @groovy.transform.CompileStatic
   static Class reloadClass(String className) {
-    def clazz =
-            new GroovyClassLoader() {
-              private final Map<String, Class> loadedClasses = new 
ConcurrentHashMap<String, Class>()
-
-              @Override
-              Class loadClass(String name) {
-                if (name ==~ ('^' + className + '([$].+)?$')) {
-                  return loadedClasses.computeIfAbsent(name, n -> {
-                    def clazz = defineClass(n, 
GroovyClassLoader.class.getResourceAsStream('/' + n.replace('.', '/') + 
'.class').bytes)
-                    return clazz
-                  })
-                }
-                return super.loadClass(name)
-              }
-            }.loadClass(className)
-    return clazz
+    def loader = new GroovyClassLoader() {
+      private final Map<String, Class> loadedClasses = new 
ConcurrentHashMap<>()
+
+      @Override
+      Class<?> loadClass(String name) {
+        if (name ==~ ('^' + className + '([$].+)?$')) {
+          return loadedClasses.computeIfAbsent(name, n -> {
+            defineClass(n, GroovyClassLoader.class.getResourceAsStream('/' + 
n.replace('.', '/') + '.class').getBytes())
+          })
+        }
+        return super.loadClass(name)
+      }
+    }
+    return loader.loadClass(className)
   }
 }

Reply via email to