[lldb] Unify sleep and time outs in GDB remote testcases

[JDevlieghere]

Summary

Reduce sleep and time outs in GDB remote testcases to one default value for each. Stop passing these values around and always use the default instead.

[labath]

Sounds like a good idea.

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

63–64

unwrap this

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

 class _ConnectionRefused(IOError):
     pass
 
 
 class GdbRemoteTestCaseBase(TestBase):
 
     NO_DEBUG_INFO_TESTCASE = True
 
-    _TIMEOUT_SECONDS = 120 * (10 if ('ASAN_OPTIONS' in os.environ) else 1)
-    _DEFAULT_TIMEOUT =  10 * (10 if ('ASAN_OPTIONS' in os.environ) else 1)
-    _READ_TIMEOUT    =   5 * (10 if ('ASAN_OPTIONS' in os.environ) else 1)
-    _WAIT_TIMEOUT    =   5 * (10 if ('ASAN_OPTIONS' in os.environ) else 1)
+    # Default time out in seconds. The timeout is increased tenfold under Asan.
+    DEFAULT_TIMEOUT =  10 * (10 if ('ASAN_OPTIONS' in os.environ) else 1)
+    # Default sleep time in seconds. The sleep time is doubled under Asan.
+    DEFAULT_SLEEP   =  5  * (2  if ('ASAN_OPTIONS' in os.environ) else 1)
 
     _GDBREMOTE_KILL_PACKET = "$k#6b"
 
     # Start the inferior separately, attach to the inferior on the stub
     # command line.
     _STARTUP_ATTACH = "attach"
     # Start the inferior separately, start the stub without attaching, allow
     # the test to attach to the inferior however it wants (e.g. $vAttach;pid).
def create_named_pipe(self):
         # Add the shutdown hook to clean up the named pipe.
         self.addTearDownHook(shutdown_named_pipe)
 
         # Clear the port so the stub selects a port number.
         self.port = 0
 
         return (named_pipe_path, named_pipe, named_pipe_fd)
 
-    def get_stub_port_from_named_socket(self, read_timeout_seconds):
+    def get_stub_port_from_named_socket(self):
         # Wait for something to read with a max timeout.
         (ready_readers, _, _) = select.select(
-            [self.named_pipe_fd], [], [], read_timeout_seconds)
+            [self.named_pipe_fd], [], [], self.DEFAULT_TIMEOUT)
         self.assertIsNotNone(
             ready_readers,
             "write side of pipe has not written anything - stub isn't writing to pipe.")
         self.assertNotEqual(
             len(ready_readers),
             0,
             "write side of pipe has not written anything - stub isn't writing to pipe.")
 
def launch_debug_monitor(self, attach_pid=None, logfile=None):
             self.debug_monitor_exe,
             commandline_args,
             install_remote=False)
         self.assertIsNotNone(server)
 
         # If we're receiving the stub's listening port from the named pipe, do
         # that here.
         if self.named_pipe:
-            self.port = self.get_stub_port_from_named_socket(self._READ_TIMEOUT)
+            self.port = self.get_stub_port_from_named_socket()
 
         return server
 
     def connect_to_debug_monitor(self, attach_pid=None):
         if self.named_pipe:
             # Create the stub.
             server = self.launch_debug_monitor(attach_pid=attach_pid)
             self.assertIsNotNone(server)
def prep_debug_monitor_and_inferior(
         if self._inferior_startup == self._STARTUP_LAUNCH:
             self.add_verified_launch_packets(launch_args)
 
         return {"inferior": inferior, "server": server}
 
     def expect_socket_recv(
             self,
             sock,
-            expected_content_regex,
-            timeout_seconds):
+            expected_content_regex
+            ):
         response = ""
-        timeout_time = time.time() + timeout_seconds
+        timeout_time = time.time() + self.DEFAULT_TIMEOUT
 
         while not expected_content_regex.match(
                 response) and time.time() < timeout_time:
-            can_read, _, _ = select.select([sock], [], [], timeout_seconds)
+            can_read, _, _ = select.select([sock], [], [], self.DEFAULT_TIMEOUT)
             if can_read and sock in can_read:
                 recv_bytes = sock.recv(4096)
                 if recv_bytes:
                     response += seven.bitcast_to_string(recv_bytes)
 
         self.assertTrue(expected_content_regex.match(response))
 
-    def expect_socket_send(self, sock, content, timeout_seconds):
+    def expect_socket_send(self, sock, content):
         request_bytes_remaining = content
-        timeout_time = time.time() + timeout_seconds
+        timeout_time = time.time() + self.DEFAULT_TIMEOUT
 
         while len(request_bytes_remaining) > 0 and time.time() < timeout_time:
-            _, can_write, _ = select.select([], [sock], [], timeout_seconds)
+            _, can_write, _ = select.select([], [sock], [], self.DEFAULT_TIMEOUT)
             if can_write and sock in can_write:
                 written_byte_count = sock.send(request_bytes_remaining.encode())
                 request_bytes_remaining = request_bytes_remaining[
                     written_byte_count:]
         self.assertEqual(len(request_bytes_remaining), 0)
 
-    def do_handshake(self, stub_socket, timeout_seconds=None):
-        if not timeout_seconds:
-            timeout_seconds = self._WAIT_TIMEOUT
-
+    def do_handshake(self, stub_socket):
         # Write the ack.
-        self.expect_socket_send(stub_socket, "+", timeout_seconds)
+        self.expect_socket_send(stub_socket, "+")
 
         # Send the start no ack mode packet.
         NO_ACK_MODE_REQUEST = "$QStartNoAckMode#b0"
         bytes_sent = stub_socket.send(NO_ACK_MODE_REQUEST.encode())
         self.assertEqual(bytes_sent, len(NO_ACK_MODE_REQUEST))
 
         # Receive the ack and "OK"
         self.expect_socket_recv(stub_socket, re.compile(
-            r"^\+\$OK#[0-9a-fA-F]{2}$"), timeout_seconds)
+            r"^\+\$OK#[0-9a-fA-F]{2}$"))
 
         # Send the final ack.
-        self.expect_socket_send(stub_socket, "+", timeout_seconds)
+        self.expect_socket_send(stub_socket, "+")
 
     def add_no_ack_remote_stream(self):
         self.test_sequence.add_log_lines(
             ["read packet: +",
              "read packet: $QStartNoAckMode#b0",
              "send packet: +",
              "send packet: $OK#9a",
              "read packet: +"],
def parse_register_info_packets(self, context):
         """Return an array of register info dictionaries, one per register info."""
         reg_info_responses = context.get("reg_info_responses")
         self.assertIsNotNone(reg_info_responses)
 
         # Parse register infos.
         return [parse_reg_info_response(reg_info_response)
                 for reg_info_response in reg_info_responses]
 
-    def expect_gdbremote_sequence(self, timeout_seconds=None):
-        if not timeout_seconds:
-            timeout_seconds = self._TIMEOUT_SECONDS
+    def expect_gdbremote_sequence(self):
         return expect_lldb_gdbserver_replay(
             self,
             self.sock,
             self.test_sequence,
             self._pump_queues,
-            timeout_seconds,
+            self.DEFAULT_TIMEOUT,
             self.logger)
 
     _KNOWN_REGINFO_KEYS = [
         "name",
         "alt-name",
         "bitsize",
         "offset",
         "encoding",
def parse_threadinfo_packets(self, context):
         self.assertIsNotNone(threadinfo_responses)
 
         thread_ids = []
         for threadinfo_response in threadinfo_responses:
             new_thread_infos = parse_threadinfo_response(threadinfo_response)
             thread_ids.extend(new_thread_infos)
         return thread_ids
 
-    def wait_for_thread_count(self, thread_count, timeout_seconds=None):
-        if not timeout_seconds:
-            timeout_seconds = self._WAIT_TIMEOUT
+    def wait_for_thread_count(self, thread_count):
         start_time = time.time()
-        timeout_time = start_time + timeout_seconds
+        timeout_time = start_time + self.DEFAULT_TIMEOUT
 
         actual_thread_count = 0
         while actual_thread_count < thread_count:
             self.reset_test_sequence()
             self.add_threadinfo_collection_packets()
 
             context = self.expect_gdbremote_sequence()
             self.assertIsNotNone(context)
 
             threads = self.parse_threadinfo_packets(context)
             self.assertIsNotNone(threads)
 
             actual_thread_count = len(threads)
 
             if time.time() > timeout_time:
                 raise Exception(
                     'timed out after {} seconds while waiting for theads: waiting for at least {} threads, found {}'.format(
-                        timeout_seconds, thread_count, actual_thread_count))
+                        self.DEFAULT_TIMEOUT, thread_count, actual_thread_count))
 
         return threads
 
     def add_set_breakpoint_packets(
             self,
             address,
             z_packet_type=0,
             do_continue=True,

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

def attach_commandline_kill_after_initial_stop(self):
             self.test_sequence.add_log_lines([
                 {"direction": "send", "regex": reg_expr},
             ], True)
 
         self.expect_gdbremote_sequence()
 
         # Wait a moment for completed and now-detached inferior process to
         # clear.
-        time.sleep(self._WAIT_TIMEOUT)
+        time.sleep(self.DEFAULT_SLEEP)
 
         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.

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

def test_qProcessInfo_returns_running_process_llgs(self):
         self.qProcessInfo_returns_running_process()
 
     def attach_commandline_qProcessInfo_reports_correct_pid(self):
         procs = self.prep_debug_monitor_and_inferior()
         self.assertIsNotNone(procs)
         self.add_process_info_collection_packets()
 
         # Run the stream
-        context = self.expect_gdbremote_sequence(timeout_seconds=self._DEFAULT_TIMEOUT)
+        context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
 
         # Gather process info response
         process_info = self.parse_process_info_response(context)
         self.assertIsNotNone(process_info)
 
         # Ensure the process id matches what we expected.
         pid_text = process_info.get('pid', None)

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

def gather_stop_reply_fields(self, post_startup_log_lines, thread_count,
         self.test_sequence.add_log_lines([
             "read packet: $c#63"
         ], True)
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
         hw_info = self.parse_hw_info(context)
 
         # Give threads time to start up, then break.
-        time.sleep(self._WAIT_TIMEOUT)
+        time.sleep(self.DEFAULT_SLEEP)
         self.reset_test_sequence()
         self.test_sequence.add_log_lines(
             [
                 "read packet: {}".format(
                     chr(3)),
                 {
                     "direction": "send",
                     "regex": r"^\$T([0-9a-fA-F]+)([^#]+)#[0-9a-fA-F]{2}$",
                     "capture": {
                         1: "stop_result",
                         2: "key_vals_text"}},
             ],
             True)
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
 
         # Wait until all threads have started.
-        threads = self.wait_for_thread_count(thread_count,
-                                             timeout_seconds=self._WAIT_TIMEOUT)
+        threads = self.wait_for_thread_count(thread_count
+                                             )
         self.assertIsNotNone(threads)
         self.assertEqual(len(threads), thread_count)
 
         # Run, then stop the process, grab the stop reply content.
         self.reset_test_sequence()
         self.test_sequence.add_log_lines(["read packet: $c#63",
                                           "read packet: {}".format(chr(3)),
                                           {"direction": "send",

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

def gather_stop_replies_via_qThreadStopInfo(self, thread_count):
         # (Like optionally enabling QThreadsInStopReply.)
         self.test_sequence.add_log_lines([
             "read packet: $c#63"
         ], True)
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
 
         # Give threads time to start up, then break.
-        time.sleep(self._WAIT_TIMEOUT)
+        time.sleep(self.DEFAULT_SLEEP)
         self.reset_test_sequence()
         self.test_sequence.add_log_lines(
             [
                 "read packet: {}".format(
                     chr(3)),
                 {
                     "direction": "send",
                     "regex": r"^\$T([0-9a-fA-F]+)([^#]+)#[0-9a-fA-F]{2}$",
                     "capture": {
                         1: "stop_result",
                         2: "key_vals_text"}},
             ],
             True)
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
 
         # Wait until all threads have started.
-        threads = self.wait_for_thread_count(thread_count,
-                                             timeout_seconds=self._WAIT_TIMEOUT)
+        threads = self.wait_for_thread_count(thread_count)
         self.assertIsNotNone(threads)
 
         # On Windows, there could be more threads spawned. For example, DebugBreakProcess will
         # create a new thread from the debugged process to handle an exception event. So here we
         # assert 'GreaterEqual' condition.
         triple = self.dbg.GetSelectedPlatform().GetTriple()
         if re.match(".*-.*-windows", triple):
             self.assertGreaterEqual(len(threads), thread_count)

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

def Hg_switches_to_3_threads(self):
             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, timeout_seconds=self._WAIT_TIMEOUT)
+        threads = self.wait_for_thread_count(3)
         self.assertEqual(len(threads), 3)
 
         # 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:x}#00".format(thread),  # Set current thread.
def Hc_then_Csignal_signals_correct_thread(self, segfault_signo):
             inferior_args=inferior_args)
         self.test_sequence.add_log_lines(["read packet: $c#63"], True)
         context = self.expect_gdbremote_sequence()
 
         # 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, timeout_seconds=5)
+        # threads = self.wait_for_thread_count(NUM_THREADS)
         # self.assertEquals(len(threads), NUM_THREADS)
 
         signaled_tids = {}
         print_thread_ids = {}
 
         # 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(timeout_seconds=self._DEFAULT_TIMEOUT)
+            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)
             self.assertFalse(thread_id in signaled_tids)
             signaled_tids[thread_id] = 1
def Hc_then_Csignal_signals_correct_thread(self, segfault_signo):
                     # 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(
-                timeout_seconds=self._DEFAULT_TIMEOUT)
+            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.
def P_and_p_thread_suffix_work(self):
         self.assertTrue(reg_byte_size > 0)
 
         # Run the process a bit so threads can start up, and collect register
         # info.
         context = self.run_process_then_stop(run_seconds=1)
         self.assertIsNotNone(context)
 
         # Wait for 3 threads to be present.
-        threads = self.wait_for_thread_count(3, timeout_seconds=self._WAIT_TIMEOUT)
+        threads = self.wait_for_thread_count(3)
         self.assertEqual(len(threads), 3)
 
         expected_reg_values = []
         register_increment = 1
         next_value = None
 
         # Set the same register in each of 3 threads to a different value.
         # Verify each one has the unique value.

lldb/test/API/tools/lldb-server/commandline/TestStubReverseConnect.py

 from __future__ import print_function
 
 import gdbremote_testcase
 import lldbgdbserverutils
 import re
 import select
 import socket
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestStubReverseConnect(gdbremote_testcase.GdbRemoteTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    _DEFAULT_TIMEOUT = 20 * (10 if ('ASAN_OPTIONS' in os.environ) else 1)
-
     def setUp(self):
         # Set up the test.
         gdbremote_testcase.GdbRemoteTestCaseBase.setUp(self)
 
         # Create a listener on a local port.
         self.listener_socket = self.create_listener_socket()
         self.assertIsNotNone(self.listener_socket)
         self.listener_port = self.listener_socket.getsockname()[1]
 
-    def create_listener_socket(self, timeout_seconds=_DEFAULT_TIMEOUT):
+    def create_listener_socket(self):
         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         self.assertIsNotNone(sock)
 
-        sock.settimeout(timeout_seconds)
+        sock.settimeout(self.DEFAULT_TIMEOUT)
         sock.bind(("127.0.0.1", 0))
         sock.listen(1)
 
         def tear_down_listener():
             try:
                 sock.shutdown(socket.SHUT_RDWR)
             except:
                 # ignore
def reverse_connect_works(self):
         # Listen for the stub's connection to us.
         (stub_socket, address) = self.listener_socket.accept()
         self.assertIsNotNone(stub_socket)
         self.assertIsNotNone(address)
         print("connected to stub {} on {}".format(
             address, stub_socket.getsockname()))
 
         # Verify we can do the handshake.  If that works, we'll call it good.
-        self.do_handshake(stub_socket, timeout_seconds=self._DEFAULT_TIMEOUT)
+        self.do_handshake(stub_socket)
 
         # Clean up.
         stub_socket.shutdown(socket.SHUT_RDWR)
 
     @debugserver_test
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
     def test_reverse_connect_works_debugserver(self):
         self.init_debugserver_test(use_named_pipe=False)