test/hotspot/jtreg/vmTestbase/nsk/jdi/ReferenceType/instances/instances003/instances003.java

*** 60,69 ****
--- 60,70 ----
  package nsk.jdi.ReferenceType.instances.instances003;
  
  import java.io.PrintStream;
  import java.util.*;
  
+ import com.sun.jdi.ObjectCollectedException;
  import com.sun.jdi.ObjectReference;
  import com.sun.jdi.ReferenceType;
  
  import nsk.share.Consts;
  import nsk.share.ObjectInstancesManager;
*** 120,150 ****
  
          // create 'createInstanceCount' instances of test class
  
          // create temporary strong references to prevent the weakly referred instances being GCed
          // during the time between creating them and disabling collection on them
          pipe.println(HeapwalkingDebuggee.COMMAND_CREATE_INSTANCES + ":" + className + ":" + createInstanceCount +
              ":" + referrerCount + ":" + referrerType +
!             (referrerType.equals(ObjectInstancesManager.WEAK_REFERENCE) ? "|" + ObjectInstancesManager.STRONG_REFERENCE : ""));
  
          // Note! This test is broken, in the sense that it incorrectly assumes
          // that no GC can happen before it walks the heap. In practice, it seems
          // to only affect this test when using ZGC. However, this test will also
          // fail when using other GCs if an explicit GC is done here.
  
          // the instance counts should not be affected by creating multiple references
          checkDebugeeAnswer_instanceCounts(className, createInstanceCount, objectsToFilter);
  
          ReferenceType referenceType = debuggee.classByName(className);
!         List<ObjectReference> instances = HeapwalkingDebugger.filterObjectReferrence(objectsToFilter, referenceType.instances(0));
  
!         for (ObjectReference or : instances) {
!             or.disableCollection();
          }
  
          // remove the temporary strong references so the weak references can be properly tested
!         if (referrerType.equals(ObjectInstancesManager.WEAK_REFERENCE)) {
              pipe.println(HeapwalkingDebuggee.COMMAND_DELETE_REFERRERS + ":" + className + ":" + referrerCount + ":" + ObjectInstancesManager.STRONG_REFERENCE);
              if (!isDebuggeeReady()) {
                  return;
              }
          }
--- 121,162 ----
  
          // create 'createInstanceCount' instances of test class
  
          // create temporary strong references to prevent the weakly referred instances being GCed
          // during the time between creating them and disabling collection on them
+         boolean useTempStrongReference = needTempStongReference(referrerType);
          pipe.println(HeapwalkingDebuggee.COMMAND_CREATE_INSTANCES + ":" + className + ":" + createInstanceCount +
                  ":" + referrerCount + ":" + referrerType +
!                 (useTempStrongReference ? "|" + ObjectInstancesManager.STRONG_REFERENCE : ""));
  
          // Note! This test is broken, in the sense that it incorrectly assumes
          // that no GC can happen before it walks the heap. In practice, it seems
          // to only affect this test when using ZGC. However, this test will also
          // fail when using other GCs if an explicit GC is done here.
  
          // the instance counts should not be affected by creating multiple references
          checkDebugeeAnswer_instanceCounts(className, createInstanceCount, objectsToFilter);
  
          ReferenceType referenceType = debuggee.classByName(className);
!         List<ObjectReference> allInstances = HeapwalkingDebugger.filterObjectReferrence(objectsToFilter, referenceType.instances(0));
  
!         // There are potentially other non-test Java threads allocating objects and triggering GC's.
!         // We need to call disableCollection() on each object returned by referenceType.instances()
!         // to deal with the case when GC was triggered. Otherwise, these objects can
!         // be potentially collected.
!         List<ObjectReference> instances = new LinkedList<>();
!         for (ObjectReference objRef : allInstances) {
!             try {
!                 objRef.disableCollection();
!                 instances.add(objRef);
!             } catch (ObjectCollectedException ex) {
!                 // skip this references
!             }
          }
  
          // remove the temporary strong references so the weak references can be properly tested
!         if (useTempStrongReference) {
              pipe.println(HeapwalkingDebuggee.COMMAND_DELETE_REFERRERS + ":" + className + ":" + referrerCount + ":" + ObjectInstancesManager.STRONG_REFERENCE);
              if (!isDebuggeeReady()) {
                  return;
              }
          }
*** 155,164 ****
--- 167,177 ----
  
          for (int i = 0; i < preventGCCount; i++) {
              instances.get(i).enableCollection();
          }
  
+ 
          pipe.println(HeapwalkingDebuggee.COMMAND_DELETE_INSTANCES + ":" + className + ":" + createInstanceCount);
  
          if (!isDebuggeeReady())
              return;
  
*** 181,186 ****
--- 194,208 ----
          for (String referenceType : HeapwalkingDebuggee.includedIntoInstancesCountTypes) {
              for (String className : testClasses)
                  testClass(className, referenceType);
          }
      }
+ 
+ 
+     private static boolean needTempStongReference(String referenceType) {
+         return ObjectInstancesManager.WEAK_REFERENCE.equals(referenceType) ||
+                 ObjectInstancesManager.JNI_WEAK_REFERENCE.equals(referenceType) ||
+                 ObjectInstancesManager.PHANTOM_REFERENCE.equals(referenceType) ||
+                 ObjectInstancesManager.SOFT_REFERENCE.equals(referenceType);
+ 
+     }
  }