intel/llvm
1
0
Fork 0
mirror of https://github.com/intel/llvm.git synced 2026-01-27 06:06:34 +08:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
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.

Differential revision: https://reviews.llvm.org/D83904
This commit is contained in:
Jonas Devlieghere
2020-07-17 08:18:22 -07:00
parent 04713f8aa6
commit 0fbbf3a98c
7 changed files with 37 additions and 49 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -31,10 +31,10 @@ 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"
@@ -204,10 +204,10 @@ class GdbRemoteTestCaseBase(TestBase):
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.")
@@ -407,7 +407,7 @@ class GdbRemoteTestCaseBase(TestBase):
# 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
@@ -568,14 +568,14 @@ class GdbRemoteTestCaseBase(TestBase):
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:
@@ -583,24 +583,21 @@ class GdbRemoteTestCaseBase(TestBase):
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"
@@ -609,10 +606,10 @@ class GdbRemoteTestCaseBase(TestBase):
# 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(
@@ -700,15 +697,13 @@ class GdbRemoteTestCaseBase(TestBase):
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 = [
@@ -856,11 +851,9 @@ class GdbRemoteTestCaseBase(TestBase):
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:
@@ -878,7 +871,7 @@ class GdbRemoteTestCaseBase(TestBase):
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

2
lldb/test/API/tools/lldb-server/TestGdbRemoteKill.py
View File

@@ -31,7 +31,7 @@ class TestGdbRemoteKill(gdbremote_testcase.GdbRemoteTestCaseBase):
# 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.

2
lldb/test/API/tools/lldb-server/TestGdbRemoteProcessInfo.py
View File

@@ -52,7 +52,7 @@ class TestGdbRemoteProcessInfo(gdbremote_testcase.GdbRemoteTestCaseBase):
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

5
lldb/test/API/tools/lldb-server/TestGdbRemoteThreadsInStopReply.py
View File

@@ -42,7 +42,7 @@ class TestGdbRemoteThreadsInStopReply(
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(
[
@@ -60,8 +60,7 @@ class TestGdbRemoteThreadsInStopReply(
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)

5
lldb/test/API/tools/lldb-server/TestGdbRemote_qThreadStopInfo.py
View File

@@ -33,7 +33,7 @@ class TestGdbRemote_qThreadStopInfo(gdbremote_testcase.GdbRemoteTestCaseBase):
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(
[
@@ -51,8 +51,7 @@ class TestGdbRemote_qThreadStopInfo(gdbremote_testcase.GdbRemoteTestCaseBase):
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

11
lldb/test/API/tools/lldb-server/TestLldbGdbServer.py
View File

@@ -642,7 +642,7 @@ class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase, DwarfOpcod
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.
@@ -723,7 +723,7 @@ class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase, DwarfOpcod
# 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 = {}
@@ -739,7 +739,7 @@ class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase, DwarfOpcod
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)
@@ -775,8 +775,7 @@ class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase, DwarfOpcod
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.
@@ -1491,7 +1490,7 @@ class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase, DwarfOpcod
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 = []

8
lldb/test/API/tools/lldb-server/commandline/TestStubReverseConnect.py
View File

@@ -14,8 +14,6 @@ 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)
@@ -25,11 +23,11 @@ class TestStubReverseConnect(gdbremote_testcase.GdbRemoteTestCaseBase):
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)
@@ -77,7 +75,7 @@ class TestStubReverseConnect(gdbremote_testcase.GdbRemoteTestCaseBase):
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)