[lldb][WIP-ish] Add a assertPacketResponse utility to lldb-server tests

[labath]

Summary

The goal is to replace the awkward add_log_lines dance.

[labath]

I was going to wait until this is fully functional, but since you're about to
write some lldb-server tests, I figured it's a good time to get some feedback.

The main part that's missing is the ability to wait for some output to be
produced. I'd like to replace that with something completely different as the
current mechanism relies on sleeps.

But if you find it useful in the current form, I could clean it up and check in pretty quickly.

lldb/packages/Python/lldbsuite/test/tools/lldb-server/gdbremote_testcase.py

class GdbRemoteTestCaseBase(Base):
 
     def getDebugServer(self):
         method = getattr(self, self.testMethodName)
         return getattr(method, "debug_server", None)
 
     def setUp(self):
         super(GdbRemoteTestCaseBase, self).setUp()
 
+        self.captures = {}
         self.setUpBaseLogging()
         self.debug_monitor_extra_args = []
 
         if self.isVerboseLoggingRequested():
             # If requested, full logs go to a log file
             self._verbose_log_handler = logging.FileHandler(
                 self.getLogBasenameForCurrentTest() + "-host.log")
             self._verbose_log_handler.setFormatter(self._log_formatter)
def prep_debug_monitor_and_inferior(
         self.do_handshake()
 
         # Build the expected protocol stream
         if inferior_env:
             for name, value in inferior_env.items():
                 self.add_set_environment_packets(name, value)
         if self._inferior_startup == self._STARTUP_LAUNCH:
             self.add_verified_launch_packets(launch_args)
+        self.expect_gdbremote_sequence()
 
         return {"inferior": inferior, "server": server}
 
     def do_handshake(self):
         server = self._server
         server.send_ack()
         server.send_packet(b"QStartNoAckMode")
         self.assertEqual(server.get_normal_packet(), b"+")
         self.assertEqual(server.get_normal_packet(), b"OK")
         server.send_ack()
 
+    def assertPacketResponse(self, packet, response_pattern):
+        self._server.send_packet(packet)
+        response = self._server.get_normal_packet()
+        if isinstance(response_pattern, re.Pattern):
+            match = response_pattern.match(response)
+            self.assertIsNotNone(match, "{!r} matches {!r}".format(response,
+                response_pattern))
+            self.captures.update(match.groupdict())
+        else:
+            self.assertEqual(response, response_pattern)
+        self.captures[0] = response
+
     def add_verified_launch_packets(self, launch_args):
         self.test_sequence.add_log_lines(
             ["read packet: %s" % build_gdbremote_A_packet(launch_args),
              "send packet: $OK#00",
              "read packet: $qLaunchSuccess#a5",
              "send packet: $OK#00"],
             True)
 
def single_step_only_steps_one_instruction(
                                                           args,
                                                           max_step_count=5,
                                                           use_Hc_packet=use_Hc_packet,
                                                           step_instruction=step_instruction)
         self.assertTrue(state_reached)
         self.assertEqual(step_count, expected_step_count)
 
     def maybe_strict_output_regex(self, regex):
-        return '.*' + regex + \
-            '.*' if lldbplatformutil.hasChattyStderr(self) else '^' + regex + '$'
+        if lldbplatformutil.hasChattyStderr(self):
+            prefix = b"^"
+            suffix = b"$"
+        else:
+            prefix = suffix = b".*"
+
+        if isinstance(regex, str):
+            prefix = prefix.decode()
+            suffix = suffix.decode()
+
+        return prefix + regex + suffix
 
     def install_and_create_launch_args(self):
         exe_path = self.getBuildArtifact("a.out")
         if not lldb.remote_platform:
             return [exe_path]
         remote_path = lldbutil.append_to_process_working_directory(self,
             os.path.basename(exe_path))
         remote_file_spec = lldb.SBFileSpec(remote_path, False)
         err = lldb.remote_platform.Install(lldb.SBFileSpec(exe_path, True),
                                            remote_file_spec)
         if err.Fail():
             raise Exception("remote_platform.Install('%s', '%s') failed: %s" %
                             (exe_path, remote_path, err))
         return [remote_path]

lldb/test/API/tools/lldb-server/TestLldbGdbServer.py

 from lldbsuite.test import lldbutil
 
 
 class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase, DwarfOpcodeParser):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def test_thread_suffix_supported(self):
-        server = self.connect_to_debug_monitor()
-        self.assertIsNotNone(server)
-
+        self.connect_to_debug_monitor()
         self.do_handshake()
-        self.test_sequence.add_log_lines(
-            ["lldb-server <  26> read packet: $QThreadSuffixSupported#e4",
-             "lldb-server <   6> send packet: $OK#9a"],
-            True)
-
-        self.expect_gdbremote_sequence()
-
+        self.assertPacketResponse(b"QThreadSuffixSupported", b"OK")
 
     def test_list_threads_in_stop_reply_supported(self):
-        server = self.connect_to_debug_monitor()
-        self.assertIsNotNone(server)
-
+        self.connect_to_debug_monitor()
         self.do_handshake()
-        self.test_sequence.add_log_lines(
-            ["lldb-server <  27> read packet: $QListThreadsInStopReply#21",
-             "lldb-server <   6> send packet: $OK#9a"],
-            True)
-        self.expect_gdbremote_sequence()
+        self.assertPacketResponse(b"QListThreadsInStopReply", b"OK")
 
     def test_c_packet_works(self):
         self.build()
-        procs = self.prep_debug_monitor_and_inferior()
-        self.test_sequence.add_log_lines(
-            ["read packet: $c#63",
-             "send packet: $W00#00"],
-            True)
-
-        self.expect_gdbremote_sequence()
+        self.prep_debug_monitor_and_inferior()
+        self.assertPacketResponse(b"c", b"W00")
 
     @skipIfWindows # No pty support to test any inferior output
     def test_inferior_print_exit(self):
         self.build()
-        procs = self.prep_debug_monitor_and_inferior(
-                inferior_args=["hello, world"])
-        self.test_sequence.add_log_lines(
-            ["read packet: $vCont;c#a8",
-             {"type": "output_match", "regex": self.maybe_strict_output_regex(r"hello, world\r\n")},
-             "send packet: $W00#00"],
-            True)
+        self.prep_debug_monitor_and_inferior(inferior_args=["hello, world"])
 
-        context = self.expect_gdbremote_sequence()
-        self.assertIsNotNone(context)
+        self.assertPacketResponse(b"vCont;c", b"W00")
+        self.assertRegex(self._server.consume_accumulated_output(),
+                self.maybe_strict_output_regex(br"hello, world\r\n"))
 
     def test_first_launch_stop_reply_thread_matches_first_qC(self):
         self.build()
-        procs = self.prep_debug_monitor_and_inferior()
-        self.test_sequence.add_log_lines(["read packet: $qC#00",
-                                          {"direction": "send",
-                                           "regex": r"^\$QC([0-9a-fA-F]+)#",
-                                           "capture": {1: "thread_id_QC"}},
-                                          "read packet: $?#00",
-                                          {"direction": "send",
-                                              "regex": r"^\$T[0-9a-fA-F]{2}thread:([0-9a-fA-F]+)",
-                                              "capture": {1: "thread_id_?"}}],
-                                         True)
-        context = self.expect_gdbremote_sequence()
-        self.assertEqual(context.get("thread_id_QC"), context.get("thread_id_?"))
+        self.prep_debug_monitor_and_inferior()
+
+        self.assertPacketResponse(b"qC", re.compile(b"QC(?P<QC>[0-9a-fA-F]+)"))
+        self.assertPacketResponse(b"?",
+                re.compile(b"T[0-9a-fA-F]{2}thread:(?P<q>[0-9a-fA-F]+)"))
+        self.assertEqual(self.captures["QC"], self.captures["q"])
 
     def test_attach_commandline_continue_app_exits(self):
         self.build()
         self.set_inferior_startup_attach()
         procs = self.prep_debug_monitor_and_inferior()
-        self.test_sequence.add_log_lines(
-            ["read packet: $vCont;c#a8",
-             "send packet: $W00#00"],
-            True)
-        self.expect_gdbremote_sequence()
+
+        self.assertPacketResponse(b"c", b"W00")
 
         # Wait a moment for completed and now-detached inferior process to
         # clear.
         time.sleep(1)
 
         if not lldb.remote_platform:
             # Process should be dead now. Reap results.
             poll_result = procs["inferior"].poll()
             self.assertIsNotNone(poll_result)
 
         # Where possible, verify at the system level that the process is not
         # running.
         self.assertFalse(
             lldbgdbserverutils.process_is_running(
                 procs["inferior"].pid, False))
 
     def test_qRegisterInfo_returns_one_valid_result(self):
         self.build()
         self.prep_debug_monitor_and_inferior()
-        self.test_sequence.add_log_lines(
-            ["read packet: $qRegisterInfo0#00",
-             {"direction": "send", "regex": r"^\$(.+);#[0-9A-Fa-f]{2}", "capture": {1: "reginfo_0"}}],
-            True)
 
-        # Run the stream
-        context = self.expect_gdbremote_sequence()
-        self.assertIsNotNone(context)
+        self.assertPacketResponse(b"qRegisterInfo0",
+                re.compile(br"(?P<reginfo_0>.+)"))
 
-        reg_info_packet = context.get("reginfo_0")
-        self.assertIsNotNone(reg_info_packet)
         self.assert_valid_reg_info(
-            lldbgdbserverutils.parse_reg_info_response(reg_info_packet))
+            lldbgdbserverutils.parse_reg_info_response(self.captures["reginfo_0"].decode()))
 
     def test_qRegisterInfo_returns_all_valid_results(self):
         self.build()
         self.prep_debug_monitor_and_inferior()
         self.add_register_info_collection_packets()
 
         # Run the stream.
         context = self.expect_gdbremote_sequence()
def test_qThreadInfo_contains_thread_attach(self):
         self.build()
         self.set_inferior_startup_attach()
         self.qThreadInfo_contains_thread()
 
     def qThreadInfo_matches_qC(self):
         procs = self.prep_debug_monitor_and_inferior()
 
         self.add_threadinfo_collection_packets()
-        self.test_sequence.add_log_lines(
-            ["read packet: $qC#00",
-             {"direction": "send", "regex": r"^\$QC([0-9a-fA-F]+)#", "capture": {1: "thread_id"}}
-             ], True)
-
-        # Run the packet stream.
         context = self.expect_gdbremote_sequence()
-        self.assertIsNotNone(context)
+
+        self.assertPacketResponse(b"qC", re.compile(b"QC(?P<QC>[0-9a-fA-F]+)"))
 
         # Gather threadinfo entries.
         threads = self.parse_threadinfo_packets(context)
         self.assertIsNotNone(threads)
 
         # We should have exactly one thread from threadinfo.
         self.assertEqual(len(threads), 1)
 
         # We should have a valid thread_id from $QC.
-        QC_thread_id_hex = context.get("thread_id")
+        QC_thread_id_hex = self.captures["QC"]
         self.assertIsNotNone(QC_thread_id_hex)
         QC_thread_id = int(QC_thread_id_hex, 16)
 
         # Those two should be the same.
         self.assertEqual(threads[0], QC_thread_id)
 
     def test_qThreadInfo_matches_qC_launch(self):
         self.build()
def test_p_returns_correct_data_size_for_each_qRegisterInfo_launch(self):
         for reg_info in reg_infos:
             # Skip registers that don't have a register set.  For x86, these are
             # the DRx registers, which have no LLDB-kind register number and thus
             # cannot be read via normal
             # NativeRegisterContext::ReadRegister(reg_info,...) calls.
             if not "set" in reg_info:
                 continue
 
-            # Clear existing packet expectations.
-            self.reset_test_sequence()
-
-            # Run the register query
-            self.test_sequence.add_log_lines(
-                ["read packet: $p{0:x}#00".format(reg_index),
-                 {"direction": "send", "regex": r"^\$([0-9a-fA-F]+)#", "capture": {1: "p_response"}}],
-                True)
-            context = self.expect_gdbremote_sequence()
-            self.assertIsNotNone(context)
+            self.assertPacketResponse(b"p%x"%reg_index,
+                    re.compile(b"^[0-9a-fA-F]+$"))
 
             # Verify the response length.
-            p_response = context.get("p_response")
-            self.assertIsNotNone(p_response)
+            p_response = self.captures[0]
 
             # Skip erraneous (unsupported) registers.
             # TODO: remove this once we make unsupported registers disappear.
-            if p_response.startswith("E") and len(p_response) == 3:
+            if p_response[0:1] == b"E" and len(p_response) == 3:
                 continue
 
             if "dynamic_size_dwarf_expr_bytes" in reg_info:
                 self.updateRegInfoBitsize(reg_info, byte_order)
             self.assertEqual(len(p_response), 2 * int(reg_info["bitsize"]) / 8,
                              reg_info)
 
             # Increment loop
             reg_index += 1
 
     def Hg_switches_to_3_threads(self, pass_pid=False):
         # Startup the inferior with three threads (main + 2 new ones).
         procs = self.prep_debug_monitor_and_inferior(
             inferior_args=["thread:new", "thread:new"])
 
         # Let the inferior process have a few moments to start up the thread
         # when launched.  (The launch scenario has no time to run, so threads
         # won't be there yet.)
         self.run_process_then_stop(run_seconds=1)
 
         # Wait at most x seconds for 3 threads to be present.
         threads = self.wait_for_thread_count(3)
         self.assertEqual(len(threads), 3)
 
-        pid_str = ""
+        pid_str = b""
         if pass_pid:
-            pid_str = "p{0:x}.".format(procs["inferior"].pid)
+            pid_str = b"p%x."%procs["inferior"].pid
 
         # verify we can $H to each thead, and $qC matches the thread we set.
         for thread in threads:
             # Change to each thread, verify current thread id.
-            self.reset_test_sequence()
-            self.test_sequence.add_log_lines(
-                ["read packet: $Hg{0}{1:x}#00".format(pid_str, thread),  # Set current thread.
-                 "send packet: $OK#00",
-                 "read packet: $qC#00",
-                 {"direction": "send", "regex": r"^\$QC([0-9a-fA-F]+)#", "capture": {1: "thread_id"}}],
-                True)
-
-            context = self.expect_gdbremote_sequence()
-            self.assertIsNotNone(context)
-
-            # Verify the thread id.
-            self.assertIsNotNone(context.get("thread_id"))
-            self.assertEqual(int(context.get("thread_id"), 16), thread)
+            self.assertPacketResponse(b"Hg%s%x"%(pid_str, thread), b"OK")
+            self.assertPacketResponse(b"qC", b"QC%x"%thread)
 
     @expectedFailureAll(oslist=["windows"]) # expect 4 threads
     def test_Hg_switches_to_3_threads_launch(self):
         self.build()
         self.set_inferior_startup_launch()
         self.Hg_switches_to_3_threads()
 
     @expectedFailureAll(oslist=["windows"]) # expecting one more thread
def Hg_fails_on_pid(self, pass_pid):
             inferior_args=["thread:new"])
 
         self.run_process_then_stop(run_seconds=1)
 
         threads = self.wait_for_thread_count(2)
         self.assertEqual(len(threads), 2)
 
         if pass_pid == -1:
-            pid_str = "p-1."
+            pid_str = b"p-1."
         else:
-            pid_str = "p{0:x}.".format(pass_pid)
+            pid_str = b"p%x."%pass_pid
         thread = threads[1]
 
-        self.test_sequence.add_log_lines(
-            ["read packet: $Hg{0}{1:x}#00".format(pid_str, thread),  # Set current thread.
-             "send packet: $Eff#00"],
-            True)
-
-        self.expect_gdbremote_sequence()
+        self.assertPacketResponse(b"Hg%s%x"%(pid_str, thread), b"Eff")
 
     @expectedFailureAll(oslist=["windows"])
     @add_test_categories(["llgs"])
     def test_Hg_fails_on_another_pid(self):
         self.build()
         self.set_inferior_startup_launch()
         self.Hg_fails_on_pid(1)
 
def Hc_then_Csignal_signals_correct_thread(self, segfault_signo):
         # Startup the inferior with three threads (main + NUM_THREADS-1 worker threads).
         # inferior_args=["thread:print-ids"]
         inferior_args = ["thread:segfault"]
         for i in range(NUM_THREADS - 1):
             # if i > 0:
                 # Give time between thread creation/segfaulting for the handler to work.
                 # inferior_args.append("sleep:1")
             inferior_args.append("thread:new")
-        inferior_args.append("sleep:10")
 
         # Launch/attach.  (In our case, this should only ever be launched since
         # we need inferior stdout/stderr).
-        procs = self.prep_debug_monitor_and_inferior(
-            inferior_args=inferior_args)
-        self.test_sequence.add_log_lines(["read packet: $c#63"], True)
-        context = self.expect_gdbremote_sequence()
+        self.prep_debug_monitor_and_inferior(inferior_args=inferior_args)
+
+        stop_regex = re.compile(b"T%02xthread:(?P<tid>[0-9a-fA-F]+);"%segfault_signo)
+        # Run until SIGSEGV comes in.
+        self.assertPacketResponse(b"c", stop_regex)
 
         # Let the inferior process have a few moments to start up the thread when launched.
         # context = self.run_process_then_stop(run_seconds=1)
 
         # Wait at most x seconds for all threads to be present.
         # threads = self.wait_for_thread_count(NUM_THREADS)
         # self.assertEquals(len(threads), NUM_THREADS)
 
         signaled_tids = {}
         print_thread_ids = {}
 
+        sigusr_signo = lldbutil.get_signal_number('SIGUSR1')
         # Switch to each thread, deliver a signal, and verify signal delivery
         for i in range(NUM_THREADS - 1):
-            # Run until SIGSEGV comes in.
-            self.reset_test_sequence()
-            self.test_sequence.add_log_lines([{"direction": "send",
-                                               "regex": r"^\$T([0-9a-fA-F]{2})thread:([0-9a-fA-F]+);",
-                                               "capture": {1: "signo",
-                                                            2: "thread_id"}}],
-                                             True)
-
-            context = self.expect_gdbremote_sequence()
-            self.assertIsNotNone(context)
-            signo = context.get("signo")
-            self.assertEqual(int(signo, 16), segfault_signo)
-
             # Ensure we haven't seen this tid yet.
-            thread_id = int(context.get("thread_id"), 16)
+            thread_id = int(self.captures["tid"], 16)
             self.assertNotIn(thread_id, signaled_tids)
             signaled_tids[thread_id] = 1
 
             # Send SIGUSR1 to the thread that signaled the SIGSEGV.
-            self.reset_test_sequence()
-            self.test_sequence.add_log_lines(
-                [
-                    # Set the continue thread.
-                    # Set current thread.
-                    "read packet: $Hc{0:x}#00".format(thread_id),
-                    "send packet: $OK#00",
+            self.assertPacketResponse(b"Hc%x"%thread_id, b"OK")
 
-                    # Continue sending the signal number to the continue thread.
-                    # The commented out packet is a way to do this same operation without using
-                    # a $Hc (but this test is testing $Hc, so we'll stick with the former).
-                    "read packet: $C{0:x}#00".format(lldbutil.get_signal_number('SIGUSR1')),
-                    # "read packet: $vCont;C{0:x}:{1:x};c#00".format(lldbutil.get_signal_number('SIGUSR1'), thread_id),
-
-                    # FIXME: Linux does not report the thread stop on the delivered signal (SIGUSR1 here).  MacOSX debugserver does.
-                    # But MacOSX debugserver isn't guaranteeing the thread the signal handler runs on, so currently its an XFAIL.
-                    # Need to rectify behavior here.  The linux behavior is more intuitive to me since we're essentially swapping out
-                    # an about-to-be-delivered signal (for which we already sent a stop packet) to a different signal.
-                    # {"direction":"send", "regex":r"^\$T([0-9a-fA-F]{2})thread:([0-9a-fA-F]+);", "capture":{1:"stop_signo", 2:"stop_thread_id"} },
-                    #  "read packet: $c#63",
-                    {"type": "output_match", "regex": r"^received SIGUSR1 on thread id: ([0-9a-fA-F]+)\r\nthread ([0-9a-fA-F]+): past SIGSEGV\r\n", "capture": {1: "print_thread_id", 2: "post_handle_thread_id"}},
-                ],
-                True)
-
-            # Run the sequence.
-            context = self.expect_gdbremote_sequence()
-            self.assertIsNotNone(context)
-
-            # Ensure the stop signal is the signal we delivered.
-            # stop_signo = context.get("stop_signo")
-            # self.assertIsNotNone(stop_signo)
-            # self.assertEquals(int(stop_signo,16), lldbutil.get_signal_number('SIGUSR1'))
-
-            # Ensure the stop thread is the thread to which we delivered the signal.
-            # stop_thread_id = context.get("stop_thread_id")
-            # self.assertIsNotNone(stop_thread_id)
-            # self.assertEquals(int(stop_thread_id,16), thread_id)
+            # FIXME: Linux does not report the thread stop on the delivered
+            # signal (SIGUSR1 here).  MacOSX debugserver does.  But MacOSX
+            # debugserver isn't guaranteeing the thread the signal handler runs
+            # on, so currently its an XFAIL.  Need to rectify behavior here.
+            # The linux behavior is more intuitive to me since we're essentially
+            # swapping out an about-to-be-delivered signal (for which we already
+            # sent a stop packet) to a different signal.
+            self.assertPacketResponse(b"C%x"%sigusr_signo,
+                    stop_regex if i < NUM_THREADS-2 else b"W00")
+
+            output = self._server.consume_accumulated_output()
+            match = re.match(rb"^received SIGUSR1 on thread id: (?P<ptid>[0-9a-fA-F]+)\r\nthread (?P=ptid): past SIGSEGV\r\n", output)
+            self.assertIsNotNone(match, "{!r} did not match".format(output))
 
             # Ensure we haven't seen this thread id yet.  The inferior's
             # self-obtained thread ids are not guaranteed to match the stub
             # tids (at least on MacOSX).
-            print_thread_id = context.get("print_thread_id")
-            self.assertIsNotNone(print_thread_id)
+            # The regex ensures the post signal-handle thread id matches the
+            # thread that initially raised the SIGSEGV.
+            print_thread_id = match["ptid"]
             print_thread_id = int(print_thread_id, 16)
             self.assertNotIn(print_thread_id, print_thread_ids)
 
             # Now remember this print (i.e. inferior-reflected) thread id and
             # ensure we don't hit it again.
             print_thread_ids[print_thread_id] = 1
 
-            # Ensure post signal-handle thread id matches the thread that
-            # initially raised the SIGSEGV.
-            post_handle_thread_id = context.get("post_handle_thread_id")
-            self.assertIsNotNone(post_handle_thread_id)
-            post_handle_thread_id = int(post_handle_thread_id, 16)
-            self.assertEqual(post_handle_thread_id, print_thread_id)
-
     @expectedFailureDarwin
     @skipIfWindows # no SIGSEGV support
     @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr48419")
     @expectedFailureNetBSD
     def test_Hc_then_Csignal_signals_correct_thread_launch(self):
         self.build()
         self.set_inferior_startup_launch()
 
def test_m_packet_reads_memory(self):
 
         # Ensure what we read from inferior memory is what we wrote.
         self.assertIsNotNone(context.get("read_contents"))
         read_contents = seven.unhexlify(context.get("read_contents"))
         self.assertEqual(read_contents, MEMORY_CONTENTS)
 
     def test_qMemoryRegionInfo_is_supported(self):
         self.build()
-        self.set_inferior_startup_launch()
-        # Start up the inferior.
         procs = self.prep_debug_monitor_and_inferior()
-
-        # Ask if it supports $qMemoryRegionInfo.
-        self.test_sequence.add_log_lines(
-            ["read packet: $qMemoryRegionInfo#00",
-             "send packet: $OK#00"
-             ], True)
-        self.expect_gdbremote_sequence()
+        self.assertPacketResponse(b"qMemoryRegionInfo", b"OK")
 
     @skipIfWindows # No pty support to test any inferior output
     def test_qMemoryRegionInfo_reports_code_address_as_executable(self):
         self.build()
         self.set_inferior_startup_launch()
 
         # Start up the inferior.
         procs = self.prep_debug_monitor_and_inferior(
def test_P_writes_all_gpr_registers(self):
         self.trace("successful writes: {}, failed writes: {}".format(successful_writes, failed_writes))
         self.assertTrue(successful_writes > 0)
 
     # Note: as of this moment, a hefty number of the GPR writes are failing
     # with E32 (everything except rax-rdx, rdi, rsi, rbp).
     @skipIfWindows
     def test_P_and_p_thread_suffix_work(self):
         self.build()
-        self.set_inferior_startup_launch()
 
         # Startup the inferior with three threads.
-        procs = self.prep_debug_monitor_and_inferior(
+        self.prep_debug_monitor_and_inferior(
             inferior_args=["thread:new", "thread:new"])
         self.add_thread_suffix_request_packets()
         self.add_register_info_collection_packets()
         self.add_process_info_collection_packets()
 
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
 
def test_P_and_p_thread_suffix_work(self):
         next_value = None
 
         # Set the same register in each of 3 threads to a different value.
         # Verify each one has the unique value.
         for thread in threads:
             # If we don't have a next value yet, start it with the initial read
             # value + 1
             if not next_value:
-                # Read pre-existing register value.
-                self.reset_test_sequence()
-                self.test_sequence.add_log_lines(
-                    ["read packet: $p{0:x};thread:{1:x}#00".format(reg_index, thread),
-                     {"direction": "send", "regex": r"^\$([0-9a-fA-F]+)#", "capture": {1: "p_response"}},
-                     ], True)
-                context = self.expect_gdbremote_sequence()
-                self.assertIsNotNone(context)
+                self.assertPacketResponse(b"p%x;thread:%x"%(reg_index, thread),
+                        re.compile(b"^[0-9a-fA-F]+$"))
 
                 # Set the next value to use for writing as the increment plus
                 # current value.
-                p_response = context.get("p_response")
-                self.assertIsNotNone(p_response)
                 next_value = lldbgdbserverutils.unpack_register_hex_unsigned(
-                    endian, p_response)
+                    endian, self.captures[0])
 
             # Set new value using P and thread suffix.
-            self.reset_test_sequence()
-            self.test_sequence.add_log_lines(
-                [
-                    "read packet: $P{0:x}={1};thread:{2:x}#00".format(
-                        reg_index,
-                        lldbgdbserverutils.pack_register_hex(
-                            endian,
-                            next_value,
-                            byte_size=reg_byte_size),
-                        thread),
-                    "send packet: $OK#00",
-                ],
-                True)
-            context = self.expect_gdbremote_sequence()
-            self.assertIsNotNone(context)
+            value_str = lldbgdbserverutils.pack_register_hex(
+                    byte_size=reg_byte_size).encode()
+            self.assertPacketResponse(b"P%x=%s;thread:%x"%(reg_index, value_str, thread), b"OK")
 
             # Save the value we set.
-            expected_reg_values.append(next_value)
+            expected_reg_values.append(value_str)
 
             # Increment value for next thread to use (we want them all
             # different so we can verify they wrote to each thread correctly
             # next.)
             next_value += register_increment
 
         # Revisit each thread and verify they have the expected value set for
         # the register we wrote.
         thread_index = 0
         for thread in threads:
-            # Read pre-existing register value.
-            self.reset_test_sequence()
-            self.test_sequence.add_log_lines(
-                ["read packet: $p{0:x};thread:{1:x}#00".format(reg_index, thread),
-                 {"direction": "send", "regex": r"^\$([0-9a-fA-F]+)#", "capture": {1: "p_response"}},
-                 ], True)
-            context = self.expect_gdbremote_sequence()
-            self.assertIsNotNone(context)
-
-            # Get the register value.
-            p_response = context.get("p_response")
-            self.assertIsNotNone(p_response)
-            read_value = lldbgdbserverutils.unpack_register_hex_unsigned(
-                endian, p_response)
-
-            # Make sure we read back what we wrote.
-            self.assertEqual(read_value, expected_reg_values[thread_index])
+            self.assertPacketResponse(b"p%x;thread:%x"%(reg_index, thread),
+                    expected_reg_values[thread_index])
             thread_index += 1

lldb/test/API/tools/lldb-server/main.cpp

// Test creating a SEGV.
         g_is_segfaulting = false;
       }
     }
 
     {
       std::lock_guard<std::mutex> lock(g_print_mutex);
       printf("thread %" PRIx64 ": past SIGSEGV\n", get_thread_id());
     }
+    return nullptr;
   }
 
   int sleep_seconds_remaining = 60;
   std::this_thread::sleep_for(std::chrono::seconds(sleep_seconds_remaining));
 
   return nullptr;
 }