keep track of verified breakpoints in tests

Author: eronnen

lldb/packages/Python/lldbsuite/test/tools/lldb-dap/dap_server.py

@@ -166,6 +166,7 @@ def __init__(
         self.initialized = False
         self.frame_scopes = {}
         self.init_commands = init_commands
+        self.resolved_breakpoints = set([])
 
     @classmethod
     def encode_content(cls, s: str) -> bytes:
@@ -309,6 +310,14 @@ def _process_continued(self, all_threads_continued: bool):
         if all_threads_continued:
             self.thread_stop_reasons = {}
 
+    def _update_verified_breakpoints(self, breakpoints):
+        for breakpoint in breakpoints:
+            if "verified" in breakpoint:
+                if breakpoint["verified"]:
+                    self.resolved_breakpoints.add(str(breakpoint["id"]))
+                else:
+                    self.resolved_breakpoints.discard(str(breakpoint["id"]))
+
     def send_packet(self, command_dict: Request, set_sequence=True):
         """Take the "command_dict" python dictionary and encode it as a JSON
         string and send the contents as a packet to the VSCode debug
@@ -452,8 +461,27 @@ def wait_for_breakpoint_events(self, timeout: Optional[float] = None):
             if not event:
                 break
             breakpoint_events.append(event)
+
+        self._update_verified_breakpoints(
+            [event["body"]["breakpoint"] for event in breakpoint_events]
+        )
         return breakpoint_events
 
+    def wait_for_breakpoints_to_be_verified(
+        self, breakpoint_ids: list[str], timeout: Optional[float] = None
+    ):
+        """Wait for all breakpoints to be verified. Return all unverified breakpoints."""
+        unresolved_breakpoints = set(breakpoint_ids)
+        unresolved_breakpoints -= self.resolved_breakpoints
+        while len(unresolved_breakpoints) > 0:
+            breakpoint_event = self.wait_for_event("breakpoint", timeout=timeout)
+            if breakpoint_event is None:
+                break
+
+            self._update_verified_breakpoints([breakpoint_event["body"]["breakpoint"]])
+            unresolved_breakpoints -= self.resolved_breakpoints
+        return unresolved_breakpoints
+
     def wait_for_exited(self, timeout: Optional[float] = None):
         event_dict = self.wait_for_event("exited", timeout=timeout)
         if event_dict is None:
@@ -1013,7 +1041,10 @@ def request_setBreakpoints(self, source: Source, line_array, data=None):
             "type": "request",
             "arguments": args_dict,
         }
-        return self.send_recv(command_dict)
+        response = self.send_recv(command_dict)
+        breakpoints = response["body"]["breakpoints"]
+        self._update_verified_breakpoints(breakpoints)
+        return response
 
     def request_setExceptionBreakpoints(self, filters):
         args_dict = {"filters": filters}
@@ -1216,17 +1247,15 @@ def request_locations(self, locationReference):
         }
         return self.send_recv(command_dict)
 
-    def request_testGetTargetBreakpoints(self, only_resolved=False):
+    def request_testGetTargetBreakpoints(self):
         """A request packet used in the LLDB test suite to get all currently
         set breakpoint infos for all breakpoints currently set in the
         target.
         """
         command_dict = {
             "command": "_testGetTargetBreakpoints",
             "type": "request",
-            "arguments": {
-                "onlyResolved": only_resolved,
-            },
+            "arguments": {},
         }
         return self.send_recv(command_dict)
 

lldb/packages/Python/lldbsuite/test/tools/lldb-dap/lldbdap_testcase.py

@@ -106,29 +106,11 @@ def set_function_breakpoints(
         return breakpoint_ids
 
     def wait_for_breakpoints_to_resolve(
-        self, breakpoint_ids: list[str], timeout: Optional[float] = None
+        self, breakpoint_ids: list[str], timeout: Optional[float] = DEFAULT_TIMEOUT
     ):
-        unresolved_breakpoints = set(breakpoint_ids)
-
-        # Check already resolved breakpoints
-        resolved_breakpoints = self.dap_server.request_testGetTargetBreakpoints(
-            only_resolved=True
-        )["body"]["breakpoints"]
-        for resolved_breakpoint in resolved_breakpoints:
-            unresolved_breakpoints.discard(str(resolved_breakpoint["id"]))
-
-        while len(unresolved_breakpoints) > 0:
-            breakpoint_event = self.dap_server.wait_for_event(
-                "breakpoint", timeout=timeout
-            )
-            if breakpoint_event is None:
-                break
-
-            if breakpoint_event["body"]["reason"] in ["changed", "new"]:
-                unresolved_breakpoints.discard(
-                    str(breakpoint_event["body"]["breakpoint"]["id"])
-                )
-
+        unresolved_breakpoints = self.dap_server.wait_for_breakpoints_to_be_verified(
+            breakpoint_ids, timeout
+        )
         self.assertEqual(
             len(unresolved_breakpoints),
             0,

lldb/tools/lldb-dap/Handler/TestGetTargetBreakpointsRequestHandler.cpp

@@ -15,18 +15,12 @@ namespace lldb_dap {
 
 void TestGetTargetBreakpointsRequestHandler::operator()(
     const llvm::json::Object &request) const {
-  const auto *arguments = request.getObject("arguments");
-  bool only_resolved = GetBoolean(arguments, "onlyResolved").value_or(false);
-
   llvm::json::Object response;
   FillResponse(request, response);
   llvm::json::Array response_breakpoints;
   for (uint32_t i = 0; dap.target.GetBreakpointAtIndex(i).IsValid(); ++i) {
-    const auto target_bp = dap.target.GetBreakpointAtIndex(i);
-    if (!only_resolved || target_bp.GetNumResolvedLocations() > 0) {
-      auto bp = Breakpoint(dap, target_bp);
-      response_breakpoints.push_back(bp.ToProtocolBreakpoint());
-    }
+    auto bp = Breakpoint(dap, dap.target.GetBreakpointAtIndex(i));
+    response_breakpoints.push_back(bp.ToProtocolBreakpoint());
   }
   llvm::json::Object body;
   body.try_emplace("breakpoints", std::move(response_breakpoints));