--- old/test/java/lang/invoke/LFCaching/LFGarbageCollectedTest.java	2014-12-22 23:42:35.000000000 +0300
+++ new/test/java/lang/invoke/LFCaching/LFGarbageCollectedTest.java	2014-12-22 23:42:35.000000000 +0300
@@ -26,17 +26,19 @@
  * @bug 8046703
  * @summary Test verifies that lambda forms are garbage collected
  * @author kshefov
- * @ignore 8057020
  * @library /lib/testlibrary/jsr292 /lib/testlibrary
  * @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.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.util.EnumSet;
 import java.util.Map;
@@ -45,6 +47,7 @@
  * 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 +59,85 @@
         super(testMethod);
     }
 
+    PhantomReference ph;
+    ReferenceQueue rq = new ReferenceQueue();
+    MethodType mtype;
+
     @Override
     public void doTest() {
         try {
-            Map<String, Object> data = getTestMethod().getTestCaseData();
+            TestMethods testCase = getTestMethod();
+            if (testCase == TestMethods.EXACT_INVOKER || testCase == TestMethods.INVOKER) {
+                // Invokers aren't collected.
+                return;
+            }
+            Map<String, Object> data = testCase.getTestCaseData();
             MethodHandle adapter;
             try {
                 adapter = getTestMethod().getTestCaseMH(data, TestMethods.Kind.ONE);
             } catch (NoSuchMethodException ex) {
                 throw new Error("Unexpected exception: ", ex);
             }
+            mtype = adapter.type();
             Object lambdaForm = LambdaFormTestCase.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);
+            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 a reference hasn't been queued yet, trigger one more GC.
+        }
+
+        if (ref == null) {
+            dumpTestCase();
+            System.out.println("Method type: "+mtype);
+            System.out.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 static long[] val;
+    private static final Field REF_FIELD;
+    static {
+        try {
+            REF_FIELD = Reference.class.getDeclaredField("referent");
+            REF_FIELD.setAccessible(true);
+        } catch (Exception e) {
+            throw new Error(e);
+        }
+    }
+
     /**
      * Main routine for lambda forms garbage collection test.
      *
--- old/test/java/lang/invoke/LFCaching/LambdaFormTestCase.java	2014-12-22 23:42:37.000000000 +0300
+++ new/test/java/lang/invoke/LFCaching/LambdaFormTestCase.java	2014-12-22 23:42:36.000000000 +0300
@@ -26,6 +26,7 @@
 import java.lang.management.ManagementFactory;
 import java.lang.reflect.Method;
 import java.util.Collection;
+import java.util.Map;
 import java.util.function.Function;
 import jdk.testlibrary.Utils;
 
@@ -132,6 +133,10 @@
                             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");
@@ -157,4 +162,12 @@
             System.err.println(String.format("All %d test cases PASSED!", testCounter));
         }
     }
+
+    public void dumpTestCase() {
+        System.out.println("Test case: " + getTestMethod());
+        Map<String, Object> data = getTestMethod().getTestCaseData();
+        for (String s : data.keySet()) {
+            System.out.printf("\t%20s => %s\n", s, data.get(s));
+        }
+    }
 }