Rename timeoutval to DEFAULT_TIMEOUT and adjust the kwargs separator.

Author: ashgti

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

@@ -590,33 +590,30 @@ def replay_packets(self, replay_file_path):
 
     def request_attach(
         self,
-        /,
-        program=None,
-        pid=None,
-        waitFor=None,
-        trace=None,
-        initCommands=None,
-        preRunCommands=None,
-        stopCommands=None,
-        exitCommands=None,
-        attachCommands=None,
-        terminateCommands=None,
-        coreFile=None,
+        *,
+        program: Optional[str] = None,
+        pid: Optional[int] = None,
+        waitFor=False,
+        initCommands: Optional[list[str]] = None,
+        preRunCommands: Optional[list[str]] = None,
+        attachCommands: Optional[list[str]] = None,
+        postRunCommands: Optional[list[str]] = None,
+        stopCommands: Optional[list[str]] = None,
+        exitCommands: Optional[list[str]] = None,
+        terminateCommands: Optional[list[str]] = None,
+        coreFile: Optional[str] = None,
         stopOnAttach=True,
-        postRunCommands=None,
-        sourceMap=None,
-        gdbRemotePort=None,
-        gdbRemoteHostname=None,
+        sourceMap: Optional[Union[list[tuple[str, str]], dict[str, str]]] = None,
+        gdbRemotePort: Optional[int] = None,
+        gdbRemoteHostname: Optional[str] = None,
     ):
         args_dict = {}
         if pid is not None:
             args_dict["pid"] = pid
         if program is not None:
             args_dict["program"] = program
-        if waitFor is not None:
+        if waitFor:
             args_dict["waitFor"] = waitFor
-        if trace:
-            args_dict["trace"] = trace
         args_dict["initCommands"] = self.init_commands
         if initCommands:
             args_dict["initCommands"].extend(initCommands)
@@ -822,33 +819,32 @@ def request_initialize(self, sourceInitFile=False):
 
     def request_launch(
         self,
-        program: Optional[str],
-        /,
+        program: str,
+        *,
         args: Optional[list[str]] = None,
-        cwd=None,
-        env=None,
+        cwd: Optional[str] = None,
+        env: Optional[dict[str, str]] = None,
         stopOnEntry=True,
         disableASLR=True,
         disableSTDIO=False,
         shellExpandArguments=False,
-        trace=False,
-        initCommands=None,
-        preRunCommands=None,
-        stopCommands=None,
-        exitCommands=None,
-        terminateCommands=None,
-        sourcePath=None,
-        debuggerRoot=None,
-        launchCommands=None,
-        sourceMap=None,
         runInTerminal=False,
-        postRunCommands=None,
         enableAutoVariableSummaries=False,
         displayExtendedBacktrace=False,
         enableSyntheticChildDebugging=False,
-        commandEscapePrefix=None,
-        customFrameFormat=None,
-        customThreadFormat=None,
+        initCommands: Optional[list[str]] = None,
+        preRunCommands: Optional[list[str]] = None,
+        launchCommands: Optional[list[str]] = None,
+        postRunCommands: Optional[list[str]] = None,
+        stopCommands: Optional[list[str]] = None,
+        exitCommands: Optional[list[str]] = None,
+        terminateCommands: Optional[list[str]] = None,
+        sourceMap: Optional[Union[list[tuple[str, str]], dict[str, str]]] = None,
+        sourcePath: Optional[str] = None,
+        debuggerRoot: Optional[str] = None,
+        commandEscapePrefix: Optional[str] = None,
+        customFrameFormat: Optional[str] = None,
+        customThreadFormat: Optional[str] = None,
     ):
         args_dict = {"program": program}
         if args:
@@ -863,8 +859,6 @@ def request_launch(
             args_dict["disableSTDIO"] = disableSTDIO
         if shellExpandArguments:
             args_dict["shellExpandArguments"] = shellExpandArguments
-        if trace:
-            args_dict["trace"] = trace
         args_dict["initCommands"] = self.init_commands
         if initCommands:
             args_dict["initCommands"].extend(initCommands)
@@ -1271,7 +1265,7 @@ def __init__(
     @classmethod
     def launch(
         cls,
-        /,
+        *,
         executable: str,
         env: Optional[dict[str, str]] = None,
         log_file: Optional[TextIO] = None,

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

@@ -1,5 +1,6 @@
 import os
 import time
+from typing import Optional
 import uuid
 
 import dap_server
@@ -11,10 +12,14 @@
 class DAPTestCaseBase(TestBase):
     # set timeout based on whether ASAN was enabled or not. Increase
     # timeout by a factor of 10 if ASAN is enabled.
-    timeoutval = 10 * (10 if ("ASAN_OPTIONS" in os.environ) else 1)
+    DEFAULT_TIMEOUT = 10 * (10 if ("ASAN_OPTIONS" in os.environ) else 1)
     NO_DEBUG_INFO_TESTCASE = True
 
-    def create_debug_adapter(self, lldbDAPEnv=None, connection=None):
+    def create_debug_adapter(
+        self,
+        lldbDAPEnv: Optional[dict[str, str]] = None,
+        connection: Optional[str] = None,
+    ):
         """Create the Visual Studio Code debug adapter"""
         self.assertTrue(
             is_exe(self.lldbDAPExec), "lldb-dap must exist and be executable"
@@ -28,7 +33,11 @@ def create_debug_adapter(self, lldbDAPEnv=None, connection=None):
             env=lldbDAPEnv,
         )
 
-    def build_and_create_debug_adapter(self, lldbDAPEnv=None, dictionary=None):
+    def build_and_create_debug_adapter(
+        self,
+        lldbDAPEnv: Optional[dict[str, str]] = None,
+        dictionary: Optional[dict] = None,
+    ):
         self.build(dictionary=dictionary)
         self.create_debug_adapter(lldbDAPEnv)
 
@@ -78,7 +87,7 @@ def waitUntil(self, condition_callback):
             time.sleep(0.5)
         return False
 
-    def verify_breakpoint_hit(self, breakpoint_ids, timeout=timeoutval):
+    def verify_breakpoint_hit(self, breakpoint_ids, timeout=DEFAULT_TIMEOUT):
         """Wait for the process we are debugging to stop, and verify we hit
         any breakpoint location in the "breakpoint_ids" array.
         "breakpoint_ids" should be a list of breakpoint ID strings
@@ -112,7 +121,7 @@ def verify_breakpoint_hit(self, breakpoint_ids, timeout=timeoutval):
                         return
         self.assertTrue(False, f"breakpoint not hit, stopped_events={stopped_events}")
 
-    def verify_stop_exception_info(self, expected_description, timeout=timeoutval):
+    def verify_stop_exception_info(self, expected_description, timeout=DEFAULT_TIMEOUT):
         """Wait for the process we are debugging to stop, and verify the stop
         reason is 'exception' and that the description matches
         'expected_description'
@@ -267,7 +276,7 @@ def stepIn(
         targetId=None,
         waitForStop=True,
         granularity="statement",
-        timeout=timeoutval,
+        timeout=DEFAULT_TIMEOUT,
     ):
         response = self.dap_server.request_stepIn(
             threadId=threadId, targetId=targetId, granularity=granularity
@@ -282,40 +291,40 @@ def stepOver(
         threadId=None,
         waitForStop=True,
         granularity="statement",
-        timeout=timeoutval,
+        timeout=DEFAULT_TIMEOUT,
     ):
         self.dap_server.request_next(threadId=threadId, granularity=granularity)
         if waitForStop:
             return self.dap_server.wait_for_stopped(timeout)
         return None
 
-    def stepOut(self, threadId=None, waitForStop=True, timeout=timeoutval):
+    def stepOut(self, threadId=None, waitForStop=True, timeout=DEFAULT_TIMEOUT):
         self.dap_server.request_stepOut(threadId=threadId)
         if waitForStop:
             return self.dap_server.wait_for_stopped(timeout)
         return None
 
-    def verify_continue(self):
+    def do_continue(self):  # `continue` is a keyword.
         resp = self.dap_server.request_continue()
         self.assertTrue(resp["success"], f"continue request failed: {resp}")
 
-    def continue_to_next_stop(self, timeout=timeoutval):
-        self.verify_continue()
+    def continue_to_next_stop(self, timeout=DEFAULT_TIMEOUT):
+        self.do_continue()
         return self.dap_server.wait_for_stopped(timeout)
 
-    def continue_to_breakpoints(self, breakpoint_ids, timeout=timeoutval):
-        self.verify_continue()
+    def continue_to_breakpoints(self, breakpoint_ids, timeout=DEFAULT_TIMEOUT):
+        self.do_continue()
         self.verify_breakpoint_hit(breakpoint_ids, timeout)
 
-    def continue_to_exception_breakpoint(self, filter_label, timeout=timeoutval):
-        self.verify_continue()
+    def continue_to_exception_breakpoint(self, filter_label, timeout=DEFAULT_TIMEOUT):
+        self.do_continue()
         self.assertTrue(
             self.verify_stop_exception_info(filter_label, timeout),
             'verify we got "%s"' % (filter_label),
         )
 
-    def continue_to_exit(self, exitCode=0, timeout=timeoutval):
-        self.verify_continue()
+    def continue_to_exit(self, exitCode=0, timeout=DEFAULT_TIMEOUT):
+        self.do_continue()
         stopped_events = self.dap_server.wait_for_stopped(timeout)
         self.assertEqual(
             len(stopped_events), 1, "stopped_events = {}".format(stopped_events)
@@ -344,14 +353,14 @@ def disassemble(self, threadId=None, frameIndex=None):
 
     def attach(
         self,
-        /,
+        *,
         stopOnAttach=True,
         disconnectAutomatically=True,
         sourceInitFile=False,
         expectFailure=False,
         sourceBreakpoints=None,
         functionBreakpoints=None,
-        timeout=timeoutval,
+        timeout=DEFAULT_TIMEOUT,
         **kwargs,
     ):
         """Build the default Makefile target, create the DAP debug adapter,
@@ -404,14 +413,14 @@ def cleanup():
     def launch(
         self,
         program=None,
-        /,
+        *,
         sourceInitFile=False,
         disconnectAutomatically=True,
         sourceBreakpoints=None,
         functionBreakpoints=None,
         expectFailure=False,
         stopOnEntry=True,
-        timeout=timeoutval,
+        timeout=DEFAULT_TIMEOUT,
         **kwargs,
     ):
         """Sending launch request to dap"""
@@ -472,8 +481,8 @@ def cleanup():
     def build_and_launch(
         self,
         program,
-        /,
-        lldbDAPEnv=None,
+        *,
+        lldbDAPEnv: Optional[dict[str, str]] = None,
         **kwargs,
     ):
         """Build the default Makefile target, create the DAP debug adapter,

lldb/test/API/tools/lldb-dap/attach/TestDAP_attach.py

@@ -2,24 +2,18 @@
 Test lldb-dap attach request
 """
 
-import dap_server
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 import lldbdap_testcase
-import os
-import shutil
 import subprocess
-import tempfile
 import threading
 import time
 
 
 def spawn_and_wait(program, delay):
-    print("spawn_and_wait started...", time.time())
     if delay:
         time.sleep(delay)
-    print("starting process... ", time.time())
     process = subprocess.Popen(
         [program], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE
     )
@@ -40,7 +34,7 @@ def set_and_hit_breakpoint(self, continueToExit=True):
         # accordingly.
         timeout_offset = 10
         self.continue_to_breakpoints(
-            breakpoint_ids, timeout=timeout_offset + self.timeoutval
+            breakpoint_ids, timeout=timeout_offset + self.DEFAULT_TIMEOUT
         )
         if continueToExit:
             self.continue_to_exit()
@@ -165,7 +159,7 @@ def test_commands(self):
         # Continue after launch and hit the "pause()" call and stop the target.
         # Get output from the console. This should contain both the
         # "stopCommands" that were run after we stop.
-        self.verify_continue()
+        self.do_continue()
         time.sleep(0.5)
         self.dap_server.request_pause()
         self.dap_server.wait_for_stopped()

lldb/test/API/tools/lldb-dap/cancel/TestDAP_cancel.py

@@ -51,7 +51,7 @@ def test_pending_request(self):
         blocking_seq = self.async_blocking_request(duration=1.0)
         # Use a longer timeout to ensure we catch if the request was interrupted
         # properly.
-        pending_seq = self.async_blocking_request(duration=self.timeoutval / 2)
+        pending_seq = self.async_blocking_request(duration=self.DEFAULT_TIMEOUT / 2)
         cancel_seq = self.async_cancel(requestId=pending_seq)
 
         blocking_resp = self.dap_server.recv_packet(filter_type=["response"])
@@ -78,10 +78,10 @@ def test_inflight_request(self):
         program = self.getBuildArtifact("a.out")
         self.build_and_launch(program, stopOnEntry=True)
 
-        blocking_seq = self.async_blocking_request(duration=self.timeoutval / 2)
+        blocking_seq = self.async_blocking_request(duration=self.DEFAULT_TIMEOUT / 2)
         # Wait for the sleep to start to cancel the inflight request.
         self.collect_console(
-            timeout_secs=self.timeoutval,
+            timeout_secs=self.DEFAULT_TIMEOUT,
             pattern="starting sleep",
         )
         cancel_seq = self.async_cancel(requestId=blocking_seq)

lldb/test/API/tools/lldb-dap/console/TestDAP_console.py

@@ -177,7 +177,7 @@ def test_diagnositcs(self):
         )
 
         diagnostics = self.collect_important(
-            timeout_secs=self.timeoutval, pattern="minidump file"
+            timeout_secs=self.DEFAULT_TIMEOUT, pattern="minidump file"
         )
 
         self.assertIn(

lldb/test/API/tools/lldb-dap/exception/TestDAP_exception.py

@@ -16,7 +16,7 @@ def test_stopped_description(self):
         """
         program = self.getBuildArtifact("a.out")
         self.build_and_launch(program)
-        self.verify_continue()
+        self.do_continue()
 
         self.assertTrue(self.verify_stop_exception_info("signal SIGABRT"))
         exceptionInfo = self.get_exceptionInfo()