[Lldb-commits] [lldb] [lldb-dap] Migrate threads and disassemble DAP test (PR #211277)

[Sergei Druzhkov via lldb-commits]

================
@@ -2,80 +2,86 @@
 Test lldb-dap threads request
 """
 
-from lldbsuite.test.decorators import *
-from lldbsuite.test.lldbtest import *
-from lldbsuite.test import lldbutil
-import lldbdap_testcase
+from lldbsuite.test.decorators import skipIfTargetDoesNotSupportThreads
+from lldbsuite.test.lldbtest import line_number
+from lldbsuite.test.tools.lldb_dap import DAPTestCaseBase
+from lldbsuite.test.tools.lldb_dap.types import LaunchArgs, StoppedReason, ThreadsArgs
 
 
 @skipIfTargetDoesNotSupportThreads()
-class TestDAP_threads(lldbdap_testcase.DAPTestCaseBase):
+class TestDAP_threads(DAPTestCaseBase):
     def test_correct_thread(self):
         """
         Tests that the correct thread is selected if we continue from
         a thread that goes away and hit a breakpoint in another thread.
         In this case, the selected thread should be the thread that
         just hit the breakpoint, and not the first thread in the list.
         """
+        session = self.build_and_create_session()
         program = self.getBuildArtifact("a.out")
-        self.build_and_launch(program)
         source = "main.cpp"
         breakpoint_line = line_number(source, "// break here")
-        lines = [breakpoint_line]
-        # Set breakpoint in the thread function
-        breakpoint_ids = self.set_source_breakpoints(source, lines)
-        self.assertEqual(
-            len(breakpoint_ids), len(lines), "expect correct number of breakpoints"
-        )
-        self.continue_to_breakpoints(breakpoint_ids)
+
+        with session.configure(LaunchArgs(program)) as ctx:
+            breakpoint_ids = session.resolve_source_breakpoints(
+                source, [breakpoint_line]
+            )
+        first_stop = session.verify_stopped_on_breakpoint(after=ctx.process_event)
+
         # We're now stopped at the breakpoint in the first thread, thread #2.
         # Continue to join the first thread and hit the breakpoint in the
         # second thread, thread #3.
-        self.dap_server.request_continue()
-        stopped_event = self.dap_server.wait_for_stopped()
-        # Verify that the description is the relevant breakpoint,
-        # preserveFocusHint is False and threadCausedFocus is True
-        self.assertTrue(
-            stopped_event[0]["body"]["description"].startswith(
-                "breakpoint %s." % breakpoint_ids[0]
-            )
+        second_stop = session.continue_to_next_stop(exp_reason=StoppedReason.BREAKPOINT)
+        self.assertNotEqual(
+            first_stop.body.threadId,
+            second_stop.body.threadId,
+            "the stopped events should be on different threads.",
         )
-        self.assertNotIn("preserveFocusHint", stopped_event[0]["body"])
-        # All threads should be named Thread {index}
-        threads = self.dap_server.get_threads()
-        self.assertTrue(all(len(t["name"]) > 0 for t in threads))
+
+        # Verify that the description is the relevant breakpoint,
+        # preserveFocusHint is False and threadCausedFocus is True.
+        stop_description = self.expect_not_none(second_stop.body.description)
+        self.assertTrue(stop_description.startswith(f"breakpoint {breakpoint_ids[0]}"))
+        self.assertIsNone(second_stop.body.preserveFocusHint)
+
+        # All threads should have a name.
+        threads = session.send_request(ThreadsArgs()).result().body.threads
+        for t in threads:
+            self.assertTrue(t.name, "thread name should be non-empty")
+
+        session.continue_to_exit()
 
     def test_thread_format(self):
-        """
-        Tests the support for custom thread formats.
-        """
+        """Tests the support for custom thread formats."""
+        session = self.build_and_create_session()
         program = self.getBuildArtifact("a.out")
-        self.build_and_launch(
-            program,
-            customThreadFormat="This is thread index #${thread.index}",
-            stopCommands=["thread list"],
-        )
         source = "main.cpp"
         breakpoint_line = line_number(source, "// break here")
-        lines = [breakpoint_line]
-        # Set breakpoint in the thread function
-        breakpoint_ids = self.set_source_breakpoints(source, lines)
-        self.assertEqual(
-            len(breakpoint_ids), len(lines), "expect correct number of breakpoints"
-        )
-        self.continue_to_breakpoints(breakpoint_ids)
-        # We are stopped at the first thread
-        threads = self.dap_server.get_threads()
-        print("got thread", threads)
+
+        with session.configure(
+            LaunchArgs(
+                program,
+                customThreadFormat="This is thread index #${thread.index}",
+                stopCommands=["thread list"],
+            )
+        ) as ctx:
+            bp_ids = session.resolve_source_breakpoints(source, [breakpoint_line])
+        session.verify_stopped_on_breakpoint(bp_ids, after=ctx.process_event)
+
+        threads = session.send_request(ThreadsArgs()).result().body.threads
----------------
DrSergei wrote:

Maybe we can extend `ThreadContext` to store thread name and use `session.get_threads()`. I think we can assume that the thread name is set only once when the thread is created, at least in the tests


https://github.com/llvm/llvm-project/pull/211277