Fix RefCountedTest; add test debug on visitor walk in Ref

Author: jmckenzie-dev

src/java/org/apache/cassandra/utils/concurrent/Ref.java

@@ -104,6 +104,10 @@ public final class Ref<T> implements RefCounted<T>
     public static final boolean DEBUG_EVENTS_ENABLED = TEST_DEBUG_REF_EVENTS.getBoolean();
     static OnLeak ON_LEAK;
 
+    /** NOT INTENDED FOR USE OUTSIDE TESTS AND DEBUGGING */
+    @VisibleForTesting
+    private static boolean TEST_TRACE_ENABLED = false;
+
     @Shared(scope = SIMULATION)
     public interface OnLeak
     {
@@ -125,6 +129,14 @@ public Ref(T referent, Tidy tidy)
         this.referent = referent;
     }
 
+    /**
+     * Generally don't go around mutating this willy-nilly in non-test code please.
+     */
+    @VisibleForTesting
+    public static void enableTestTracing() { TEST_TRACE_ENABLED = true; }
+    @VisibleForTesting
+    public static void disableTestTracing() { TEST_TRACE_ENABLED = false; }
+
     /**
      * Must be called exactly once, when the logical operation for which this Ref was created has terminated.
      * Failure to abide by this contract will result in an error (eventually) being reported, assuming a
@@ -608,7 +620,7 @@ void traverse(final RefCounted.Tidy rootObject)
             {
                 if (Thread.currentThread().isInterrupted())
                     throw new UncheckedInterruptedException(new InterruptedException());
-                //If necessary fetch the next object to start tracing
+                // If necessary fetch the next object to start tracing
                 if (inProgress == null)
                     inProgress = path.pollLast();
 
@@ -625,6 +637,25 @@ void traverse(final RefCounted.Tidy rootObject)
                         field = p.right;
                     }
 
+                    if (TEST_TRACE_ENABLED)
+                    {
+                        logger.debug("[Ref tracing for {}, Object: {}]", rootObject, child);
+                        if (field != null && child != null)
+                        {
+                            logger.debug(" - Visiting field '{}' of object {} -> value class {}",
+                                    field.getName(),
+                                    inProgress.o.getClass().getName(),
+                                    child.getClass().getName());
+                        }
+                        else if (field != null)
+                        {
+                            // Field exists but the next child is null – still useful to know the path.
+                            logger.debug(" - Visiting field '{}' of object {} -> value is null",
+                                    field.getName(),
+                                    inProgress.o.getClass().getName());
+                        }
+                    }
+
                     if (child != null && visited.add(child))
                     {
                         path.offer(inProgress);

test/unit/org/apache/cassandra/utils/concurrent/RefCountedTest.java

@@ -52,6 +52,8 @@
 import org.apache.cassandra.utils.concurrent.Ref.Visitor;
 import org.awaitility.Awaitility;
 
+import static org.apache.cassandra.config.CassandraRelevantProperties.JAVA_VERSION;
+import static org.apache.cassandra.utils.JavaUtils.parseJavaVersion;
 import static org.assertj.core.api.Assertions.assertThat;
 
 @SuppressWarnings({"unused", "unchecked", "rawtypes"})
@@ -468,10 +470,10 @@ Runnable getRunOnCloseLambdaWithThis()
     private Set<Ref.GlobalState> testCycles(Function<LambdaTestClass, Runnable> runOnCloseSupplier)
     {
         LambdaTestClass test = new LambdaTestClass();
-        Runnable weakRef = runOnCloseSupplier.apply(test);
+        Runnable supplierRef = runOnCloseSupplier.apply(test);
         RefCounted.Tidy tidier = new RefCounted.Tidy()
         {
-            Runnable ref = weakRef;
+            Runnable ref = supplierRef;
 
             public void tidy()
             {
@@ -505,7 +507,17 @@ public String name()
     public void testCycles()
     {
         assertThat(testCycles(LambdaTestClass::getRunOnCloseLambdaWithThis)).isNotEmpty(); // sanity test
-        assertThat(testCycles(LambdaTestClass::getRunOnCloseInner)).isNotEmpty(); // sanity test
+
+        // Behavior changed in JDK21; this was a sanity check to explore the way things worked but doesn't impact
+        // the correctness of the final actual check of the test.
+        int version = parseJavaVersion(JAVA_VERSION.getString());
+        boolean runOnCloseInnerState = version >= 21;
+
+        var result = testCycles(LambdaTestClass::getRunOnCloseInner);
+        if (runOnCloseInnerState)
+            assertThat(result).isEmpty();
+        else
+            assertThat(result).isNotEmpty();
 
         assertThat(testCycles(LambdaTestClass::getRunOnCloseLambda)).isEmpty();
     }