8067344: Adjust java/lang/invoke/LFCaching/LFGarbageCollectedTest.java for...

8067344: Adjust java/lang/invoke/LFCaching/LFGarbageCollectedTest.java for recent changes in java.lang.invoke
Reviewed-by: psandoz, coffeys

test/java/lang/invoke/LFCaching/LFGarbageCollectedTest.java

@@ -27,15 +27,16 @@
  * @summary Test verifies that lambda forms are garbage collected
  * @author kshefov
  * @library /lib/testlibrary/jsr292 /lib/testlibrary
- * @ignore 8057020
  * @build TestMethods
  * @build LambdaFormTestCase
  * @build LFGarbageCollectedTest
- * @run main/othervm LFGarbageCollectedTest
+ * @run main/othervm -Xmx64m -XX:SoftRefLRUPolicyMSPerMB=0 -XX:+HeapDumpOnOutOfMemoryError -DHEAP_DUMP=false LFGarbageCollectedTest
  */
 
 import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodType;
 import java.lang.ref.PhantomReference;
+import java.lang.ref.Reference;
 import java.lang.ref.ReferenceQueue;
 import java.lang.reflect.InvocationTargetException;
 import java.util.EnumSet;
@@ -45,6 +46,7 @@ import java.util.Map;
  * Lambda forms garbage collection test class.
  */
 public final class LFGarbageCollectedTest extends LambdaFormTestCase {
+    private static boolean HEAP_DUMP = Boolean.getBoolean("HEAP_DUMP");
 
     /**
      * Constructor for a lambda forms garbage collection test case.
@@ -56,37 +58,85 @@ public final class LFGarbageCollectedTest extends LambdaFormTestCase {
         super(testMethod);
     }
 
+     PhantomReference ph;
+     ReferenceQueue rq = new ReferenceQueue();
+     MethodType mtype;
+     Map<String, Object> data;
+
     @Override
     public void doTest() {
         try {
-            Map<String, Object> data = getTestMethod().getTestCaseData();
+            TestMethods testCase = getTestMethod();
+            data = testCase.getTestCaseData();
             MethodHandle adapter;
             try {
-                adapter = getTestMethod().getTestCaseMH(data, TestMethods.Kind.ONE);
+                adapter = testCase.getTestCaseMH(data, TestMethods.Kind.ONE);
             } catch (NoSuchMethodException ex) {
                 throw new Error("Unexpected exception: ", ex);
             }
-            Object lambdaForm = LambdaFormTestCase.INTERNAL_FORM.invoke(adapter);
+            mtype = adapter.type();
+            Object lambdaForm = INTERNAL_FORM.invoke(adapter);
             if (lambdaForm == null) {
                 throw new Error("Unexpected error: Lambda form of the method handle is null");
             }
-            ReferenceQueue rq = new ReferenceQueue();
-            PhantomReference ph = new PhantomReference(lambdaForm, rq);
+
+            String debugName = (String)DEBUG_NAME.get(lambdaForm);
+            if (debugName != null && debugName.startsWith("identity_")) {
+                // Ignore identity_* LambdaForms.
+                return;
+            }
+
+            ph = new PhantomReference(lambdaForm, rq);
             lambdaForm = null;
-            data = null;
             adapter = null;
-            for (int i = 0; i < 1000 && !ph.isEnqueued(); i++) {
-                System.gc();
-            }
-            if (!ph.isEnqueued()) {
-                throw new AssertionError("Error: Lambda form is not garbage collected");
-            }
+
+            collectLambdaForm();
         } catch (IllegalAccessException | IllegalArgumentException |
                 InvocationTargetException ex) {
             throw new Error("Unexpected exception: ", ex);
         }
     }
 
+    private void collectLambdaForm() throws IllegalAccessException {
+       // Usually, 2 System.GCs are necessary to enqueue a SoftReference.
+        System.gc();
+        System.gc();
+
+        Reference ref = null;
+        for (int i = 0; i < 10; i++) {
+            try {
+                ref = rq.remove(1000);
+            } catch (InterruptedException e) {
+                /* ignore */
+            }
+            if (ref != null) {
+                break;
+            }
+            System.gc(); // If the reference hasn't been queued yet, trigger one more GC.
+        }
+
+        if (ref == null) {
+            dumpTestData();
+            System.err.println("Method type: " + mtype);
+            System.err.println("LambdaForm:  " + REF_FIELD.get(ph));
+
+            if (HEAP_DUMP) {
+                // Trigger OOM to force heap dump for post-mortem analysis.
+                val = new long[1_000_000_000];
+            }
+            throw new AssertionError("Error: LambdaForm is not garbage collected");
+        };
+    }
+
+   private void dumpTestData() {
+        System.err.println("Test case: " + getTestMethod());
+        for (String s : data.keySet()) {
+            System.err.printf("\t%20s => %s\n", s, data.get(s));
+        }
+    }
+
+    private static long[] val;
+
     /**
      * Main routine for lambda forms garbage collection test.
      *
@@ -102,7 +152,9 @@ public final class LFGarbageCollectedTest extends LambdaFormTestCase {
                 TestMethods.IDENTITY,
                 TestMethods.CONSTANT,
                 TestMethods.ARRAY_ELEMENT_GETTER,
-                TestMethods.ARRAY_ELEMENT_SETTER));
+                TestMethods.ARRAY_ELEMENT_SETTER,
+                TestMethods.EXACT_INVOKER,
+                TestMethods.INVOKER));
         LambdaFormTestCase.runTests(LFGarbageCollectedTest::new, testMethods);
     }
 }

test/java/lang/invoke/LFCaching/LambdaFormTestCase.java

@@ -24,8 +24,11 @@
 import com.oracle.testlibrary.jsr292.Helper;
 import com.sun.management.HotSpotDiagnosticMXBean;
 
+import java.lang.invoke.MethodHandle;
 import java.lang.management.GarbageCollectorMXBean;
 import java.lang.management.ManagementFactory;
+import java.lang.ref.Reference;
+import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.util.Collection;
 import java.util.List;
@@ -42,8 +45,6 @@ import jdk.testlibrary.TimeLimitedRunner;
  */
 public abstract class LambdaFormTestCase {
 
-    private final static String METHOD_HANDLE_CLASS_NAME = "java.lang.invoke.MethodHandle";
-    private final static String INTERNAL_FORM_METHOD_NAME = "internalForm";
     private static final double ITERATIONS_TO_CODE_CACHE_SIZE_RATIO
             = 45 / (128.0 * 1024 * 1024);
     private static final long TIMEOUT = Helper.IS_THOROUGH ? 0L : (long) (Utils.adjustTimeout(Utils.DEFAULT_TEST_TIMEOUT) * 0.9);
@@ -53,6 +54,8 @@ public abstract class LambdaFormTestCase {
      * used to get a lambda form from a method handle.
      */
     protected final static Method INTERNAL_FORM;
+    protected final static Field DEBUG_NAME;
+    protected final static Field REF_FIELD;
     private static final List<GarbageCollectorMXBean> gcInfo;
 
     private static long gcCount() {
@@ -61,9 +64,14 @@ public abstract class LambdaFormTestCase {
 
     static {
         try {
-            Class mhClass = Class.forName(METHOD_HANDLE_CLASS_NAME);
-            INTERNAL_FORM = mhClass.getDeclaredMethod(INTERNAL_FORM_METHOD_NAME);
+            INTERNAL_FORM = MethodHandle.class.getDeclaredMethod("internalForm");
             INTERNAL_FORM.setAccessible(true);
+
+            DEBUG_NAME = Class.forName("java.lang.invoke.LambdaForm").getDeclaredField("debugName");
+            DEBUG_NAME.setAccessible(true);
+
+            REF_FIELD = Reference.class.getDeclaredField("referent");
+            REF_FIELD.setAccessible(true);
         } catch (Exception ex) {
             throw new Error("Unexpected exception: ", ex);
         }
@@ -146,6 +154,10 @@ public abstract class LambdaFormTestCase {
                                     testCase.getTestMethod().name);
                             testCase.doTest();
                             System.err.println("PASSED");
+                        } catch (OutOfMemoryError e) {
+                            // Don't swallow OOME so a heap dump can be created.
+                            System.err.println("FAILED");
+                            throw e;
                         } catch (Throwable t) {
                             t.printStackTrace();
                             System.err.println("FAILED");