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

rev 11011 : 8067344: Adjust java/lang/invoke/LFCaching/LFGarbageCollectedTest.java for recent changes in java.lang.invoke
Reviewed-by: ?

*** 24,52 ****
  /*
   * @test LFGarbageCollectedTest
   * @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
   */
  
  import java.lang.invoke.MethodHandle;
  import java.lang.ref.PhantomReference;
  import java.lang.ref.ReferenceQueue;
  import java.lang.reflect.InvocationTargetException;
  import java.util.EnumSet;
  import java.util.Map;
  
  /**
   * Lambda forms garbage collection test class.
   */
  public final class LFGarbageCollectedTest extends LambdaFormTestCase {
  
      /**
       * Constructor for a lambda forms garbage collection test case.
       *
       * @param testMethod A method from {@code j.l.i.MethodHandles} class that
--- 24,55 ----
  /*
   * @test LFGarbageCollectedTest
   * @bug 8046703
   * @summary Test verifies that lambda forms are garbage collected
   * @author kshefov
   * @library /lib/testlibrary/jsr292 /lib/testlibrary
   * @build TestMethods
   * @build LambdaFormTestCase
   * @build 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;
  
  /**
   * 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.
       *
       * @param testMethod A method from {@code j.l.i.MethodHandles} class that
*** 54,94 ****
       */
      public LFGarbageCollectedTest(TestMethods testMethod) {
          super(testMethod);
      }
  
      @Override
      public void doTest() {
          try {
!             Map<String, Object> data = getTestMethod().getTestCaseData();
              MethodHandle adapter;
              try {
                  adapter = getTestMethod().getTestCaseMH(data, TestMethods.Kind.ONE);
              } catch (NoSuchMethodException ex) {
                  throw new Error("Unexpected exception: ", ex);
              }
              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);
              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");
!             }
          } catch (IllegalAccessException | IllegalArgumentException |
                  InvocationTargetException ex) {
              throw new Error("Unexpected exception: ", ex);
          }
      }
  
      /**
       * Main routine for lambda forms garbage collection test.
       *
       * @param args Accepts no arguments.
       */
--- 57,156 ----
       */
      public LFGarbageCollectedTest(TestMethods testMethod) {
          super(testMethod);
      }
  
+     PhantomReference ph;
+     ReferenceQueue rq = new ReferenceQueue();
+     MethodType mtype;
+     Map<String, Object> data;
+ 
      @Override
      public void doTest() {
          try {
!             TestMethods testCase = getTestMethod();
!             if (testCase == TestMethods.EXACT_INVOKER || testCase == TestMethods.INVOKER) {
!                 // Invokers aren't collected.
!                 return;
!             }
!             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();
+             if (mtype.parameterCount() == 0) {
+                 // Ignore identity_* LambdaForms.
+                 return;
+             }
              Object lambdaForm = LambdaFormTestCase.INTERNAL_FORM.invoke(adapter);
              if (lambdaForm == null) {
                  throw new Error("Unexpected error: Lambda form of the method handle is null");
              }
!             ph = new PhantomReference(lambdaForm, rq);
              lambdaForm = null;
              adapter = null;
! 
!             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;
+     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.
       *
       * @param args Accepts no arguments.
       */