Add Unique Id for all test class instances

Closes #3079

Author: krmahadevan

CHANGES.txt

@@ -1,5 +1,6 @@
 Current (7.10.0)
 Fixed: GITHUB:3084: Document project's PGP artifact signing keys (Krishnan Mahadevan)
+Fixed: GITHUB-3079: Associate a unique id with every test class object instantiated by TestNG (Krishnan Mahadevan)
 Fixed: GITHUB:3040: replace the usages of synchronized with ReentrantLock (Krishnan Mahadevan)
 Fixed: GITHUB-3041: TestNG 7.x DataProvider works in opposite to TestNG 6.x when retrying tests. (Krishnan Mahadevan)
 Fixed: GITHUB-3066: How to dynamically adjust the number of TestNG threads after IExecutorFactory is deprecated? (Krishnan Mahadevan)

testng-core-api/src/main/java/org/testng/IClass.java

@@ -27,14 +27,30 @@ public interface IClass {
    *
    * @param create flag if a new set of instances must be returned (if set to <code>false</code>)
    * @return All the instances the methods will be invoked upon.
+   * @deprecated - As of TestNG <code>v7.10.0</code>
    */
+  @Deprecated
   Object[] getInstances(boolean create);
 
+  /**
+   * Returns all the instances the methods will be invoked upon. This will typically be an array of
+   * one object in the absence of a @Factory annotation.
+   *
+   * @param create flag if a new set of instances must be returned (if set to <code>false</code>)
+   * @param errorMsgPrefix - Text that should be prefixed to the error message when there are
+   *     issues. Can be empty.
+   * @return All the instances the methods will be invoked upon.
+   * @deprecated - As of TestNG <code>v7.10.0</code>
+   */
+  @Deprecated
   default Object[] getInstances(boolean create, String errorMsgPrefix) {
     return getInstances(create);
   }
 
-  long[] getInstanceHashCodes();
-
+  /**
+   * @param instance - The instance to be added.
+   * @deprecated - As of TestNG <code>v7.10.0</code>
+   */
+  @Deprecated
   void addInstance(Object instance);
 }

testng-core-api/src/main/java/org/testng/ITestNGMethod.java

@@ -3,6 +3,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.UUID;
 import java.util.concurrent.Callable;
 import org.testng.annotations.CustomAttribute;
 import org.testng.internal.ConstructorOrMethod;
@@ -279,7 +280,7 @@ default CustomAttribute[] getAttributes() {
 
   /**
    * @return - An {@link IDataProviderMethod} for a data provider powered test method and <code>null
-   *     </code> otherwise.
+   * </code> otherwise.
    */
   default IDataProviderMethod getDataProviderMethod() {
     return null;
@@ -296,4 +297,12 @@ default Class<?>[] getParameterTypes() {
   default boolean isIgnoreFailure() {
     return false;
   }
+
+  /**
+   * @return - A <code>{@link UUID}</code> that represents a unique id which is associated with
+   *     every test class object.
+   */
+  default UUID getInstanceId() {
+    return null;
+  }
 }

testng-core-api/src/main/java/org/testng/internal/IObject.java

@@ -0,0 +1,116 @@
+package org.testng.internal;
+
+import java.util.Objects;
+import java.util.Optional;
+import java.util.UUID;
+
+/**
+ * Represents the associations of a class with one or more instances. Relevant with <code>@Factory
+ * </code> annotation.
+ */
+public interface IObject {
+
+  /**
+   * Returns all the instances the methods will be invoked upon. This will typically be an array of
+   * one object in the absence of a @Factory annotation.
+   *
+   * @param create - <code>true</code> if objects should be created before returning.
+   * @param errorMsgPrefix - Text that should be prefixed to the error message when there are
+   *     issues. Can be empty.
+   * @return - An array of {@link IdentifiableObject} objects
+   */
+  IdentifiableObject[] getObjects(boolean create, String errorMsgPrefix);
+
+  /** @return - An array representing the hash codes of the corresponding instances. */
+  long[] getInstanceHashCodes();
+
+  /** @param instance - The instance that should be added to the list of instances. */
+  void addObject(IdentifiableObject instance);
+
+  /**
+   * @param object - The object that should be inspected for its compatibility with {@link IObject}.
+   * @return - An array representing the hash codes of the corresponding instances.
+   */
+  static long[] instanceHashCodes(Object object) {
+    return cast(object).map(IObject::getInstanceHashCodes).orElse(new long[] {});
+  }
+
+  /**
+   * @param object - The object that should be inspected for its compatibility with {@link IObject}.
+   * @param create - <code>true</code> if objects should be created before returning.
+   * @return - An array (can be empty is instance compatibility fails) of {@link IdentifiableObject}
+   *     objects.
+   */
+  static IdentifiableObject[] objects(Object object, boolean create) {
+    return objects(object, create, "");
+  }
+
+  /**
+   * @param object - The object that should be inspected for its compatibility with {@link IObject}.
+   * @param create - <code>true</code> if objects should be created before returning.
+   * @param errorMsgPrefix - Text that should be prefixed to the error message when there are
+   *     issues. Can be empty.
+   * @return - An array (can be empty is instance compatibility fails) of {@link IdentifiableObject}
+   *     objects.
+   */
+  static IdentifiableObject[] objects(Object object, boolean create, String errorMsgPrefix) {
+    return cast(object)
+        .map(it -> it.getObjects(create, errorMsgPrefix))
+        .orElse(new IdentifiableObject[] {});
+  }
+
+  /**
+   * @param object - The object that should be inspected for its compatibility with {@link IObject}.
+   * @return - If the incoming object is an instance of {@link IObject} then the cast instance is
+   *     wrapped within {@link Optional} else it would be an {@link Optional#empty()}
+   */
+  static Optional<IObject> cast(Object object) {
+    if (object instanceof IObject) {
+      return Optional.of((IObject) object);
+    }
+    return Optional.empty();
+  }
+
+  /** A wrapper object that associates a unique id to every unique test class object. */
+  class IdentifiableObject {
+    private final Object instance;
+    private final UUID instanceId;
+
+    public IdentifiableObject(Object instance) {
+      this(instance, UUID.randomUUID());
+    }
+
+    public IdentifiableObject(Object instance, UUID instanceId) {
+      this.instance = instance;
+      this.instanceId = instanceId;
+    }
+
+    public static Object unwrap(IdentifiableObject object) {
+      if (object == null) {
+        return null;
+      }
+      return object.getInstance();
+    }
+
+    public UUID getInstanceId() {
+      return instanceId;
+    }
+
+    public Object getInstance() {
+      return instance;
+    }
+
+    @Override
+    public boolean equals(Object object) {
+      if (this == object) return true;
+      if (object == null || getClass() != object.getClass()) return false;
+      IdentifiableObject that = (IdentifiableObject) object;
+      return Objects.equals(instanceId, that.instanceId);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(instanceId);
+    }
+  }
+}

testng-core/src/main/java/org/testng/TestClass.java

@@ -16,7 +16,7 @@
  * This class represents a test class: - The test methods - The configuration methods (test and
  * method) - The class file
  */
-class TestClass extends NoOpTestClass implements ITestClass, ITestClassConfigInfo {
+class TestClass extends NoOpTestClass implements ITestClass, ITestClassConfigInfo, IObject {
 
   private IAnnotationFinder annotationFinder = null;
   // The Strategy used to locate test methods (TestNG, JUnit, etc...)
@@ -106,14 +106,13 @@ private void initTestClassesAndInstances() {
     //
     // TestClasses and instances
     //
-    Object[] instances = getInstances(true, this.m_errorMsgPrefix);
-    for (Object instance : instances) {
-      instance = IParameterInfo.embeddedInstance(instance);
-      if (instance instanceof ITest) {
-        testName = ((ITest) instance).getTestName();
-        break;
-      }
-    }
+    IObject.IdentifiableObject[] instances = getObjects(true, this.m_errorMsgPrefix);
+    Arrays.stream(instances)
+        .map(IdentifiableObject::getInstance)
+        .map(IParameterInfo::embeddedInstance)
+        .filter(it -> it instanceof ITest)
+        .findFirst()
+        .ifPresent(it -> testName = ((ITest) it).getTestName());
     if (testName == null) {
       testName = iClass.getTestName();
     }
@@ -129,21 +128,31 @@ public Object[] getInstances(boolean create, String errorMsgPrefix) {
     return iClass.getInstances(create, this.m_errorMsgPrefix);
   }
 
+  @Override
+  public IObject.IdentifiableObject[] getObjects(boolean create, String errorMsgPrefix) {
+    return IObject.objects(iClass, create, errorMsgPrefix);
+  }
+
   @Override
   public long[] getInstanceHashCodes() {
-    return iClass.getInstanceHashCodes();
+    return IObject.instanceHashCodes(iClass);
   }
 
   @Override
   public void addInstance(Object instance) {
     iClass.addInstance(instance);
   }
 
+  @Override
+  public void addObject(IObject.IdentifiableObject instance) {
+    IObject.cast(iClass).ifPresent(it -> it.addObject(instance));
+  }
+
   private void initMethods() {
     ITestNGMethod[] methods = testMethodFinder.getTestMethods(m_testClass, xmlTest);
     m_testMethods = createTestMethods(methods);
 
-    for (Object eachInstance : iClass.getInstances(false)) {
+    for (IdentifiableObject eachInstance : IObject.objects(iClass, false)) {
       m_beforeSuiteMethods =
           ConfigurationMethod.createSuiteConfigurationMethods(
               objectFactory,
@@ -182,7 +191,7 @@ private void initMethods() {
               true,
               xmlTest,
               eachInstance);
-      Object instance = IParameterInfo.embeddedInstance(eachInstance);
+      Object instance = IParameterInfo.embeddedInstance(eachInstance.getInstance());
       beforeClassConfig.put(instance, Arrays.asList(m_beforeClassMethods));
       m_afterClassMethods =
           ConfigurationMethod.createClassConfigurationMethods(
@@ -234,7 +243,7 @@ private ITestNGMethod[] createTestMethods(ITestNGMethod[] methods) {
     for (ITestNGMethod tm : methods) {
       ConstructorOrMethod m = tm.getConstructorOrMethod();
       if (m.getDeclaringClass().isAssignableFrom(m_testClass)) {
-        for (Object o : iClass.getInstances(false)) {
+        for (IdentifiableObject o : IObject.objects(iClass, false)) {
           log(4, "Adding method " + tm + " on TestClass " + m_testClass);
           vResult.add(new TestNGMethod(objectFactory, m.getMethod(), annotationFinder, xmlTest, o));
         }

testng-core/src/main/java/org/testng/internal/BaseClassFinder.java

@@ -32,7 +32,7 @@ protected IClass findOrCreateIClass(
       ITestContext context,
       Class<?> cls,
       XmlClass xmlClass,
-      Object instance,
+      IObject.IdentifiableObject instance,
       IAnnotationFinder annotationFinder,
       ITestObjectFactory objectFactory) {
 

testng-core/src/main/java/org/testng/internal/BaseTestMethod.java

@@ -9,6 +9,7 @@
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
+import java.util.UUID;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -81,7 +82,7 @@ public abstract class BaseTestMethod implements ITestNGMethod, IInvocationStatus
   private int m_interceptedPriority;
 
   private XmlTest m_xmlTest;
-  private final Object m_instance;
+  private final IObject.IdentifiableObject m_instance;
 
   private final Map<String, IRetryAnalyzer> m_testMethodToRetryAnalyzer = Maps.newConcurrentMap();
   protected final ITestObjectFactory m_objectFactory;
@@ -91,7 +92,7 @@ public BaseTestMethod(
       String methodName,
       ConstructorOrMethod com,
       IAnnotationFinder annotationFinder,
-      Object instance) {
+      IObject.IdentifiableObject instance) {
     m_objectFactory = objectFactory;
     m_methodClass = com.getDeclaringClass();
     m_method = com;
@@ -148,13 +149,21 @@ public String getMethodName() {
 
   @Override
   public Object getInstance() {
-    return IParameterInfo.embeddedInstance(m_instance);
+    return Optional.ofNullable(m_instance)
+        .map(IObject.IdentifiableObject::getInstance)
+        .map(IParameterInfo::embeddedInstance)
+        .orElse(null);
+  }
+
+  @Override
+  public UUID getInstanceId() {
+    return m_instance.getInstanceId();
   }
 
   /** {@inheritDoc} */
   @Override
   public long[] getInstanceHashCodes() {
-    return m_testClass.getInstanceHashCodes();
+    return IObject.instanceHashCodes(m_testClass);
   }
 
   /**
@@ -379,8 +388,8 @@ public boolean equals(Object obj) {
   @Override
   public int hashCode() {
     int hash = m_method.hashCode();
-    if (m_instance != null) {
-      hash = hash * 31 + System.identityHashCode(m_instance);
+    if (getInstance() != null) {
+      hash = hash * 31 + System.identityHashCode(getInstance());
     }
     return hash;
   }
@@ -790,8 +799,11 @@ public String getQualifiedName() {
 
   @Override
   public IParameterInfo getFactoryMethodParamsInfo() {
-    if (m_instance instanceof IParameterInfo) {
-      return (IParameterInfo) m_instance;
+    if (m_instance == null) {
+      return null;
+    }
+    if (m_instance.getInstance() instanceof IParameterInfo) {
+      return (IParameterInfo) m_instance.getInstance();
     }
     return null;
   }