Add api tests

Author: royitaqi

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

@@ -1528,6 +1528,7 @@ def launch(
         env: Optional[dict[str, str]] = None,
         log_file: Optional[TextIO] = None,
         connection: Optional[str] = None,
+        connection_timeout: Optional[int] = None,
     ) -> tuple[subprocess.Popen, Optional[str]]:
         adapter_env = os.environ.copy()
         if env is not None:
@@ -1541,6 +1542,10 @@ def launch(
             args.append("--connection")
             args.append(connection)
 
+        if connection_timeout is not None:
+            args.append("--connection-timeout")
+            args.append(str(connection_timeout))
+
         process = subprocess.Popen(
             args,
             stdin=subprocess.PIPE,

lldb/test/API/tools/lldb-dap/server/TestDAP_server.py

@@ -5,6 +5,7 @@
 import os
 import signal
 import tempfile
+import time
 
 import dap_server
 from lldbsuite.test.decorators import *
@@ -13,22 +14,28 @@
 
 
 class TestDAP_server(lldbdap_testcase.DAPTestCaseBase):
-    def start_server(self, connection):
+    def start_server(
+        self, connection, connection_timeout=None, wait_seconds_for_termination=None
+    ):
         log_file_path = self.getBuildArtifact("dap.txt")
         (process, connection) = dap_server.DebugAdapterServer.launch(
             executable=self.lldbDAPExec,
             connection=connection,
+            connection_timeout=connection_timeout,
             log_file=log_file_path,
         )
 
         def cleanup():
-            process.terminate()
+            if wait_seconds_for_termination is not None:
+                process.wait(wait_seconds_for_termination)
+            else:
+                process.terminate()
 
         self.addTearDownHook(cleanup)
 
         return (process, connection)
 
-    def run_debug_session(self, connection, name):
+    def run_debug_session(self, connection, name, sleep_seconds_in_middle=None):
         self.dap_server = dap_server.DebugAdapterServer(
             connection=connection,
         )
@@ -41,6 +48,8 @@ def run_debug_session(self, connection, name):
             args=[name],
             disconnectAutomatically=False,
         )
+        if sleep_seconds_in_middle is not None:
+            time.sleep(sleep_seconds_in_middle)
         self.set_source_breakpoints(source, [breakpoint_line])
         self.continue_to_next_stop()
         self.continue_to_exit()
@@ -108,3 +117,47 @@ def test_server_interrupt(self):
             self.dap_server.exit_status,
             "Process exited before interrupting lldb-dap server",
         )
+
+    @skipIfWindows
+    def test_connection_timeout_at_server_start(self):
+        """
+        Test launching lldb-dap in server mode with connection timeout and waiting for it to terminate automatically when no client connects.
+        """
+        self.build()
+        self.start_server(
+            connection="listen://localhost:0",
+            connection_timeout=1,
+            wait_seconds_for_termination=2,
+        )
+
+    @skipIfWindows
+    def test_connection_timeout_long_debug_session(self):
+        """
+        Test launching lldb-dap in server mode with connection timeout and terminating the server after the a long debug session.
+        """
+        self.build()
+        (_, connection) = self.start_server(
+            connection="listen://localhost:0",
+            connection_timeout=1,
+            wait_seconds_for_termination=2,
+        )
+        # The connection timeout should not cut off the debug session
+        self.run_debug_session(connection, "Alice", 1.5)
+
+    @skipIfWindows
+    def test_connection_timeout_multiple_sessions(self):
+        """
+        Test launching lldb-dap in server mode with connection timeout and terminating the server after the last debug session.
+        """
+        self.build()
+        (_, connection) = self.start_server(
+            connection="listen://localhost:0",
+            connection_timeout=1,
+            wait_seconds_for_termination=2,
+        )
+        time.sleep(0.5)
+        # Should be able to connect to the server.
+        self.run_debug_session(connection, "Alice")
+        time.sleep(0.5)
+        # Should be able to connect to the server, because it's still within the connection timeout.
+        self.run_debug_session(connection, "Bob")