Merge tests

Author: daniellansun

src/test/groovy/groovy/lang/GroovySystemTest.groovy

@@ -18,19 +18,105 @@
  */
 package groovy.lang
 
-import groovy.test.GroovyTestCase
+
+import org.junit.jupiter.api.Test
 
 /**
  * Tests for the GroovySystem class
  */
-class GroovySystemTest extends GroovyTestCase {
-
+class GroovySystemTest {
+    @Test
     void testGetMetaClassRegistry() {
-        assert GroovySystem.metaClassRegistry
-        assert GroovySystem.getMetaClassRegistry()
+        def registry = GroovySystem.getMetaClassRegistry()
+        assert registry != null
     }
 
+    @Test
     void testGroovyVersion() {
         assert GroovySystem.getVersion()
     }
+
+    // --- Merged from GroovySystemJUnit5Test ---
+    @Test
+    void testGetMetaClassRegistryReturnsSameInstance() {
+        def registry1 = GroovySystem.getMetaClassRegistry()
+        def registry2 = GroovySystem.getMetaClassRegistry()
+        assert registry1.is(registry2)
+    }
+
+    @Test
+    void testGetVersion() {
+        def version = GroovySystem.getVersion()
+        assert version != null
+        assert !version.isEmpty()
+    }
+
+    @Test
+    void testGetShortVersion() {
+        def shortVersion = GroovySystem.getShortVersion()
+        assert shortVersion != null
+
+        // Short version should contain exactly one dot
+        def dotCount = shortVersion.length() - shortVersion.replace(".", "").length()
+        assert 1 == dotCount
+
+        // Should start with a number
+        assert Character.isDigit(shortVersion.charAt(0))
+    }
+
+    @Test
+    void testShortVersionIsPartOfFullVersion() {
+        def fullVersion = GroovySystem.getVersion()
+        def shortVersion = GroovySystem.getShortVersion()
+
+        assert fullVersion.startsWith(shortVersion)
+    }
+
+    @Test
+    void testIsKeepJavaMetaClassesDefault() {
+        def original = GroovySystem.isKeepJavaMetaClasses()
+        try {
+            assert !original
+        } finally {
+            GroovySystem.setKeepJavaMetaClasses(original)
+        }
+    }
+
+    @Test
+    void testSetKeepJavaMetaClasses() {
+        def original = GroovySystem.isKeepJavaMetaClasses()
+        try {
+            GroovySystem.setKeepJavaMetaClasses(true)
+            assert GroovySystem.isKeepJavaMetaClasses()
+
+            GroovySystem.setKeepJavaMetaClasses(false)
+            assert !GroovySystem.isKeepJavaMetaClasses()
+        } finally {
+            GroovySystem.setKeepJavaMetaClasses(original)
+        }
+    }
+
+    @Test
+    @SuppressWarnings("deprecation")
+    void testIsUseReflection() {
+        assert GroovySystem.isUseReflection()
+    }
+
+    @Test
+    @SuppressWarnings("deprecation")
+    void testRunnerRegistry() {
+        assert GroovySystem.RUNNER_REGISTRY != null
+    }
+
+    @Test
+    void testVersionFormat() {
+        def version = GroovySystem.getVersion()
+        assert version.matches("\\d+\\.\\d+\\.\\d+.*") : "Version should match pattern X.Y.Z[suffix], got: " + version
+    }
+
+    @Test
+    void testStopThreadedReferenceManager() {
+        // This should not throw any exception
+        GroovySystem.stopThreadedReferenceManager()
+    }
 }

src/test/groovy/groovy/lang/ReferenceTest.groovy

@@ -0,0 +1,157 @@
+/*
+ *  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 groovy.lang
+
+import org.junit.jupiter.api.Test
+
+import static org.junit.jupiter.api.Assertions.*
+
+/**
+ * JUnit 5 tests for Reference class.
+ */
+class ReferenceTest {
+
+    @Test
+    void testDefaultConstructor() {
+        def ref = new Reference<String>()
+        assertNull(ref.get())
+    }
+
+    @Test
+    void testConstructorWithValue() {
+        def ref = new Reference<String>("hello")
+        assertEquals("hello", ref.get())
+    }
+
+    @Test
+    void testGetAndSet() {
+        def ref = new Reference<Integer>()
+        assertNull(ref.get())
+
+        ref.set(42)
+        assertEquals(42, ref.get())
+
+        ref.set(100)
+        assertEquals(100, ref.get())
+    }
+
+    @Test
+    void testSetNull() {
+        def ref = new Reference<String>("initial")
+        assertEquals("initial", ref.get())
+
+        ref.set(null)
+        assertNull(ref.get())
+    }
+
+    @Test
+    void testWithDifferentTypes() {
+        def doubleRef = new Reference<Double>(3.14)
+        assertEquals(3.14, doubleRef.get())
+
+        def boolRef = new Reference<Boolean>(true)
+        assertTrue(boolRef.get())
+
+        def objRef = new Reference<Object>([1, 2, 3] as int[])
+        assertArrayEquals([1, 2, 3] as int[], (int[]) objRef.get())
+    }
+
+    @Test
+    void testGetPropertyOnNullValue() {
+        def ref = new Reference<String>()
+        // When value is null, getProperty should delegate to super
+        assertThrows(MissingPropertyException, { ->
+            ref.getProperty("length")
+        })
+    }
+
+    @Test
+    void testSetPropertyOnNullValue() {
+        def ref = new Reference<Object>()
+        // When value is null, setProperty should delegate to super
+        assertThrows(MissingPropertyException, { ->
+            ref.setProperty("someProp", "value")
+        })
+    }
+
+    @Test
+    void testInvokeMethodOnNullValue() {
+        def ref = new Reference<String>()
+        // When value is null, invokeMethod delegates to super (GroovyObjectSupport)
+        // It throws MissingMethodException for undefined methods
+        assertThrows(MissingMethodException, { ->
+            ref.invokeMethod("someUndefinedMethod", null)
+        })
+    }
+
+    @Test
+    void testReferenceIsSerializable() {
+        def ref = new Reference<String>("test")
+        assertTrue(ref instanceof java.io.Serializable)
+    }
+
+    @Test
+    void testReferenceExtendsGroovyObjectSupport() {
+        def ref = new Reference<String>()
+        assertTrue(ref instanceof GroovyObjectSupport)
+    }
+
+    @Test
+    void testMultipleReferences() {
+        def ref1 = new Reference<String>("one")
+        def ref2 = new Reference<String>("two")
+
+        assertNotEquals(ref1.get(), ref2.get())
+
+        ref1.set("same")
+        ref2.set("same")
+        assertEquals(ref1.get(), ref2.get())
+    }
+
+    @Test
+    void testReferenceWithComplexObject() {
+        def person = new PersonForTest("John", 30)
+        def ref = new Reference<PersonForTest>(person)
+
+        assertSame(person, ref.get())
+        assertEquals("John", ref.get().name)
+        assertEquals(30, ref.get().age)
+    }
+
+    @Test
+    void testReferenceValueMutation() {
+        def sb = new StringBuilder("initial")
+        def ref = new Reference<StringBuilder>(sb)
+
+        sb.append(" modified")
+
+        // Since Reference holds the same object, mutation is visible
+        assertEquals("initial modified", ref.get().toString())
+    }
+
+    // Helper class moved to class level for Groovy compatibility
+    static class PersonForTest {
+        String name
+        int age
+        PersonForTest(String name, int age) {
+            this.name = name
+            this.age = age
+        }
+    }
+}