FindTargetWithUniqueID -> FindTargetByGloballyUniqueID and test case cleanup

Author: qxy11

lldb/include/lldb/API/SBDebugger.h

@@ -360,7 +360,7 @@ class LLDB_API SBDebugger {
                                            const char *arch);
 
   /// Find a target with the specified unique ID
-  lldb::SBTarget FindTargetWithUniqueID(lldb::user_id_t id);
+  lldb::SBTarget FindTargetByGloballyUniqueID(lldb::user_id_t id);
 
   /// Get the number of targets in the debugger.
   uint32_t GetNumTargets();

lldb/include/lldb/API/SBTarget.h

@@ -357,11 +357,12 @@ class LLDB_API SBTarget {
 
   const char *GetLabel() const;
 
-  /// Get the globally unique ID for this target.
+  /// Get the globally unique ID for this target. This ID is unique
+  /// across all debugger instances within the same lldb process.
   ///
   /// \return
-  ///     The globally unique ID for this target, or LLDB_INVALID_TARGET_ID if
-  ///     the target is invalid.
+  ///     The globally unique ID for this target, or
+  ///     LLDB_INVALID_GLOBALLY_UNIQUE_TARGET_ID if the target is invalid.
   lldb::user_id_t GetGloballyUniqueID() const;
 
   SBError SetLabel(const char *label);

lldb/include/lldb/Target/Target.h

@@ -603,7 +603,7 @@ class Target : public std::enable_shared_from_this<Target>,
   /// Get the globally unique ID for this target.
   ///
   /// This ID is unique across all debugger instances and all targets,
-  /// not just within this debugger's target list. The ID is assigned
+  /// within the same lldb process. The ID is assigned
   /// during target construction and remains constant for the target's lifetime.
   /// The first target created (typically the dummy target) gets ID 1.
   ///
@@ -1663,7 +1663,8 @@ class Target : public std::enable_shared_from_this<Target>,
   bool m_is_dummy_target;
   unsigned m_next_persistent_variable_index = 0;
   lldb::user_id_t m_target_unique_id =
-      LLDB_INVALID_TARGET_ID; /// The unique ID assigned to this target
+      LLDB_INVALID_GLOBALLY_UNIQUE_TARGET_ID; /// The globally unique ID
+                                              /// assigned to this target
   /// An optional \a lldb_private::Trace object containing processor trace
   /// information of this target.
   lldb::TraceSP m_trace_sp;

lldb/include/lldb/Target/TargetList.h

@@ -168,7 +168,7 @@ class TargetList : public Broadcaster {
   ///     A shared pointer to a target object. The returned shared
   ///     pointer will contain nullptr if no target objects has a
   ///     matching target ID.
-  lldb::TargetSP FindTargetWithUniqueID(lldb::user_id_t id) const;
+  lldb::TargetSP FindTargetByGloballyUniqueID(lldb::user_id_t id) const;
 
   lldb::TargetSP GetTargetSP(Target *target) const;
 

lldb/include/lldb/lldb-defines.h

@@ -96,7 +96,7 @@
 #define LLDB_INVALID_QUEUE_ID 0
 #define LLDB_INVALID_CPU_ID UINT32_MAX
 #define LLDB_INVALID_WATCHPOINT_RESOURCE_ID UINT32_MAX
-#define LLDB_INVALID_TARGET_ID 0
+#define LLDB_INVALID_GLOBALLY_UNIQUE_TARGET_ID 0
 
 /// CPU Type definitions
 #define LLDB_ARCH_DEFAULT "systemArch"

lldb/source/API/SBDebugger.cpp

@@ -983,12 +983,13 @@ uint32_t SBDebugger::GetIndexOfTarget(lldb::SBTarget target) {
   return m_opaque_sp->GetTargetList().GetIndexOfTarget(target.GetSP());
 }
 
-SBTarget SBDebugger::FindTargetWithUniqueID(lldb::user_id_t id) {
+SBTarget SBDebugger::FindTargetByGloballyUniqueID(lldb::user_id_t id) {
   LLDB_INSTRUMENT_VA(this, id);
   SBTarget sb_target;
   if (m_opaque_sp) {
     // No need to lock, the target list is thread safe
-    sb_target.SetSP(m_opaque_sp->GetTargetList().FindTargetWithUniqueID(id));
+    sb_target.SetSP(
+        m_opaque_sp->GetTargetList().FindTargetByGloballyUniqueID(id));
   }
   return sb_target;
 }

lldb/source/API/SBTarget.cpp

@@ -1637,7 +1637,7 @@ lldb::user_id_t SBTarget::GetGloballyUniqueID() const {
 
   if (TargetSP target_sp = GetSP())
     return target_sp->GetGloballyUniqueID();
-  return LLDB_INVALID_TARGET_ID;
+  return LLDB_INVALID_GLOBALLY_UNIQUE_TARGET_ID;
 }
 
 SBError SBTarget::SetLabel(const char *label) {

lldb/source/Target/TargetList.cpp

@@ -428,7 +428,7 @@ TargetSP TargetList::FindTargetWithProcess(Process *process) const {
   return target_sp;
 }
 
-TargetSP TargetList::FindTargetWithUniqueID(lldb::user_id_t id) const {
+TargetSP TargetList::FindTargetByGloballyUniqueID(lldb::user_id_t id) const {
   std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
   auto it = llvm::find_if(m_target_list, [id](const TargetSP &item) {
     return item->GetGloballyUniqueID() == id;

lldb/test/API/python_api/debugger/TestDebuggerAPI.py

@@ -296,14 +296,14 @@ def test_version(self):
         self.assertEqual(class_str, property_str)
 
     def test_find_target_with_unique_id(self):
-        """Test SBDebugger.FindTargetWithUniqueID() functionality."""
+        """Test SBDebugger.FindTargetByGloballyUniqueID() functionality."""
 
         # Test with invalid ID - should return invalid target
-        invalid_target = self.dbg.FindTargetWithUniqueID(999999)
+        invalid_target = self.dbg.FindTargetByGloballyUniqueID(999999)
         self.assertFalse(invalid_target.IsValid())
 
         # Test with ID 0 - should return invalid target
-        zero_target = self.dbg.FindTargetWithUniqueID(0)
+        zero_target = self.dbg.FindTargetByGloballyUniqueID(0)
         self.assertFalse(zero_target.IsValid())
 
         # Build a real executable and create target with it
@@ -314,8 +314,8 @@ def test_find_target_with_unique_id(self):
 
         # Find the target using its unique ID
         unique_id = target.GetGloballyUniqueID()
-        self.assertNotEqual(unique_id, 0)
-        found_target = self.dbg.FindTargetWithUniqueID(unique_id)
+        self.assertNotEqual(unique_id, lldb.LLDB_INVALID_GLOBALLY_UNIQUE_TARGET_ID)
+        found_target = self.dbg.FindTargetByGloballyUniqueID(unique_id)
         self.assertTrue(found_target.IsValid())
         self.assertEqual(
             self.dbg.GetIndexOfTarget(target), self.dbg.GetIndexOfTarget(found_target)
@@ -349,7 +349,7 @@ def test_target_unique_id_uniqueness(self):
         # Verify all targets can still be found by their IDs
         for target in targets:
             unique_id = target.GetGloballyUniqueID()
-            found = self.dbg.FindTargetWithUniqueID(unique_id)
+            found = self.dbg.FindTargetByGloballyUniqueID(unique_id)
             self.assertTrue(found.IsValid())
             self.assertEqual(found.GetGloballyUniqueID(), unique_id)
 
@@ -370,8 +370,8 @@ def test_target_unique_id_uniqueness_after_deletion(self):
         self.assertNotEqual(unique_id1, unique_id2)
 
         # Verify we can find them initially
-        found_target1 = self.dbg.FindTargetWithUniqueID(unique_id1)
-        found_target2 = self.dbg.FindTargetWithUniqueID(unique_id2)
+        found_target1 = self.dbg.FindTargetByGloballyUniqueID(unique_id1)
+        found_target2 = self.dbg.FindTargetByGloballyUniqueID(unique_id2)
         self.assertTrue(found_target1.IsValid())
         self.assertTrue(found_target2.IsValid())
         target2_index = self.dbg.GetIndexOfTarget(target2)
@@ -381,7 +381,7 @@ def test_target_unique_id_uniqueness_after_deletion(self):
         self.assertTrue(deleted)
 
         # Try to find the deleted target - should not be found
-        not_found_target = self.dbg.FindTargetWithUniqueID(unique_id2)
+        not_found_target = self.dbg.FindTargetByGloballyUniqueID(unique_id2)
         self.assertFalse(not_found_target.IsValid())
 
         # Create a new target
@@ -395,7 +395,9 @@ def test_target_unique_id_uniqueness_after_deletion(self):
         self.assertNotEqual(unique_id3, unique_id2)
         self.assertNotEqual(unique_id3, unique_id1)
         # Make sure we can find the new target
-        found_target3 = self.dbg.FindTargetWithUniqueID(target3.GetGloballyUniqueID())
+        found_target3 = self.dbg.FindTargetByGloballyUniqueID(
+            target3.GetGloballyUniqueID()
+        )
         self.assertTrue(found_target3.IsValid())
 
     def test_target_globally_unique_id_across_debuggers(self):
@@ -406,6 +408,8 @@ def test_target_globally_unique_id_across_debuggers(self):
         # Create two debuggers with targets each
         debugger1 = lldb.SBDebugger.Create()
         debugger2 = lldb.SBDebugger.Create()
+        self.addTearDownHook(lambda: lldb.SBDebugger.Destroy(debugger1))
+        self.addTearDownHook(lambda: lldb.SBDebugger.Destroy(debugger2))
 
         # Create 2 targets per debugger
         targets_d1 = [debugger1.CreateTarget(exe), debugger1.CreateTarget(exe)]
@@ -417,22 +421,23 @@ def test_target_globally_unique_id_across_debuggers(self):
         self.assertEqual(
             len(set(ids)), len(ids), f"IDs should be globally unique: {ids}"
         )
-        self.assertTrue(all(uid > 0 for uid in ids), "All IDs should be non-zero")
+        self.assertTrue(
+            all(uid != lldb.LLDB_INVALID_GLOBALLY_UNIQUE_TARGET_ID for uid in ids),
+            "All IDs should be valid",
+        )
 
         # Verify targets can be found by their IDs in respective debuggers
         for debugger, target_pair in [
             (debugger1, targets[:2]),
             (debugger2, targets[2:]),
         ]:
             for target in target_pair:
-                found = debugger.FindTargetWithUniqueID(target.GetGloballyUniqueID())
+                found = debugger.FindTargetByGloballyUniqueID(
+                    target.GetGloballyUniqueID()
+                )
                 self.assertTrue(
                     found.IsValid(), "Target should be found by its unique ID"
                 )
                 self.assertEqual(
                     found.GetGloballyUniqueID(), target.GetGloballyUniqueID()
                 )
-
-        # Clean up
-        lldb.SBDebugger.Destroy(debugger1)
-        lldb.SBDebugger.Destroy(debugger2)