mirror of
https://github.com/llvm/llvm-project.git
synced 2025-04-18 21:06:50 +00:00
c15c296521
Nearly all of our lldb-server tests have two flavours (lldb-server and debugserver). Each of them is tagged with an appropriate decorator, and each of them starts with a call to a matching "init" method. The init calls are mandatory, and it's not possible to meaningfully combine them with a different decorator. This patch leverages the existing decorators to also tag the tests with the appropriate debug server tag, similar to how we do with debug info flavours. This allows us to make the "init" calls from inside the common setUp method.
198 lines
7.8 KiB
Python
198 lines
7.8 KiB
Python
|
|
|
|
|
|
import unittest2
|
|
import gdbremote_testcase
|
|
from lldbsuite.test.decorators import *
|
|
from lldbsuite.test.lldbtest import *
|
|
from lldbsuite.test import lldbutil
|
|
|
|
|
|
class TestGdbRemote_qThreadStopInfo(gdbremote_testcase.GdbRemoteTestCaseBase):
|
|
|
|
mydir = TestBase.compute_mydir(__file__)
|
|
THREAD_COUNT = 5
|
|
|
|
@skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
|
|
@skipIfDarwinEmbedded # <rdar://problem/27005337>
|
|
def gather_stop_replies_via_qThreadStopInfo(self, thread_count):
|
|
# Set up the inferior args.
|
|
inferior_args = []
|
|
for i in range(thread_count - 1):
|
|
inferior_args.append("thread:new")
|
|
inferior_args.append("sleep:10")
|
|
procs = self.prep_debug_monitor_and_inferior(
|
|
inferior_args=inferior_args)
|
|
|
|
# Assumes test_sequence has anything added needed to setup the initial state.
|
|
# (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.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)
|
|
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)
|
|
else:
|
|
self.assertEqual(len(threads), thread_count)
|
|
|
|
# Grab stop reply for each thread via qThreadStopInfo{tid:hex}.
|
|
stop_replies = {}
|
|
thread_dicts = {}
|
|
for thread in threads:
|
|
# Run the qThreadStopInfo command.
|
|
self.reset_test_sequence()
|
|
self.test_sequence.add_log_lines(
|
|
[
|
|
"read packet: $qThreadStopInfo{:x}#00".format(thread),
|
|
{
|
|
"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)
|
|
|
|
# Parse stop reply contents.
|
|
key_vals_text = context.get("key_vals_text")
|
|
self.assertIsNotNone(key_vals_text)
|
|
kv_dict = self.parse_key_val_dict(key_vals_text)
|
|
self.assertIsNotNone(kv_dict)
|
|
|
|
# Verify there is a thread and that it matches the expected thread
|
|
# id.
|
|
kv_thread = kv_dict.get("thread")
|
|
self.assertIsNotNone(kv_thread)
|
|
kv_thread_id = int(kv_thread, 16)
|
|
self.assertEqual(kv_thread_id, thread)
|
|
|
|
# Grab the stop id reported.
|
|
stop_result_text = context.get("stop_result")
|
|
self.assertIsNotNone(stop_result_text)
|
|
stop_replies[kv_thread_id] = int(stop_result_text, 16)
|
|
|
|
# Hang on to the key-val dictionary for the thread.
|
|
thread_dicts[kv_thread_id] = kv_dict
|
|
|
|
return (stop_replies, thread_dicts)
|
|
|
|
def qThreadStopInfo_works_for_multiple_threads(self, thread_count):
|
|
(stop_replies, _) = self.gather_stop_replies_via_qThreadStopInfo(thread_count)
|
|
triple = self.dbg.GetSelectedPlatform().GetTriple()
|
|
# Consider one more thread created by calling DebugBreakProcess.
|
|
if re.match(".*-.*-windows", triple):
|
|
self.assertGreaterEqual(len(stop_replies), thread_count)
|
|
else:
|
|
self.assertEqual(len(stop_replies), thread_count)
|
|
|
|
@debugserver_test
|
|
def test_qThreadStopInfo_works_for_multiple_threads_debugserver(self):
|
|
self.build()
|
|
self.set_inferior_startup_launch()
|
|
self.qThreadStopInfo_works_for_multiple_threads(self.THREAD_COUNT)
|
|
|
|
@llgs_test
|
|
@skipIfNetBSD
|
|
def test_qThreadStopInfo_works_for_multiple_threads_llgs(self):
|
|
self.build()
|
|
self.set_inferior_startup_launch()
|
|
self.qThreadStopInfo_works_for_multiple_threads(self.THREAD_COUNT)
|
|
|
|
def qThreadStopInfo_only_reports_one_thread_stop_reason_during_interrupt(
|
|
self, thread_count):
|
|
(stop_replies, _) = self.gather_stop_replies_via_qThreadStopInfo(thread_count)
|
|
self.assertIsNotNone(stop_replies)
|
|
|
|
no_stop_reason_count = sum(
|
|
1 for stop_reason in list(
|
|
stop_replies.values()) if stop_reason == 0)
|
|
with_stop_reason_count = sum(
|
|
1 for stop_reason in list(
|
|
stop_replies.values()) if stop_reason != 0)
|
|
|
|
# All but one thread should report no stop reason.
|
|
triple = self.dbg.GetSelectedPlatform().GetTriple()
|
|
|
|
# Consider one more thread created by calling DebugBreakProcess.
|
|
if re.match(".*-.*-windows", triple):
|
|
self.assertGreaterEqual(no_stop_reason_count, thread_count - 1)
|
|
else:
|
|
self.assertEqual(no_stop_reason_count, thread_count - 1)
|
|
|
|
# Only one thread should should indicate a stop reason.
|
|
self.assertEqual(with_stop_reason_count, 1)
|
|
|
|
@debugserver_test
|
|
def test_qThreadStopInfo_only_reports_one_thread_stop_reason_during_interrupt_debugserver(
|
|
self):
|
|
self.build()
|
|
self.set_inferior_startup_launch()
|
|
self.qThreadStopInfo_only_reports_one_thread_stop_reason_during_interrupt(
|
|
self.THREAD_COUNT)
|
|
|
|
@expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr48418")
|
|
@expectedFailureNetBSD
|
|
@llgs_test
|
|
def test_qThreadStopInfo_only_reports_one_thread_stop_reason_during_interrupt_llgs(
|
|
self):
|
|
self.build()
|
|
self.set_inferior_startup_launch()
|
|
self.qThreadStopInfo_only_reports_one_thread_stop_reason_during_interrupt(
|
|
self.THREAD_COUNT)
|
|
|
|
def qThreadStopInfo_has_valid_thread_names(
|
|
self, thread_count, expected_thread_name):
|
|
(_, thread_dicts) = self.gather_stop_replies_via_qThreadStopInfo(thread_count)
|
|
self.assertIsNotNone(thread_dicts)
|
|
|
|
for thread_dict in list(thread_dicts.values()):
|
|
name = thread_dict.get("name")
|
|
self.assertIsNotNone(name)
|
|
self.assertEqual(name, expected_thread_name)
|
|
|
|
@unittest2.skip("MacOSX doesn't have a default thread name")
|
|
@debugserver_test
|
|
def test_qThreadStopInfo_has_valid_thread_names_debugserver(self):
|
|
self.build()
|
|
self.set_inferior_startup_launch()
|
|
self.qThreadStopInfo_has_valid_thread_names(self.THREAD_COUNT, "a.out")
|
|
|
|
# test requires OS with set, equal thread names by default.
|
|
# Windows thread does not have name property, equal names as the process's by default.
|
|
@skipUnlessPlatform(["linux", "windows"])
|
|
@llgs_test
|
|
def test_qThreadStopInfo_has_valid_thread_names_llgs(self):
|
|
self.build()
|
|
self.set_inferior_startup_launch()
|
|
self.qThreadStopInfo_has_valid_thread_names(self.THREAD_COUNT, "a.out")
|