131 lines
5.1 KiB
Python
131 lines
5.1 KiB
Python
"""
|
|
Test lldb-dap stepInTargets request
|
|
"""
|
|
|
|
import dap_server
|
|
from lldbsuite.test.decorators import *
|
|
from lldbsuite.test.lldbtest import *
|
|
import lldbdap_testcase
|
|
from lldbsuite.test import lldbutil
|
|
|
|
|
|
class TestDAP_stepInTargets(lldbdap_testcase.DAPTestCaseBase):
|
|
@expectedFailureAll(oslist=["windows"])
|
|
@skipIf(archs=no_match(["x86_64"]))
|
|
# InstructionControlFlowKind for ARM is not supported yet.
|
|
# On Windows, lldb-dap seems to ignore targetId when stepping into functions.
|
|
# For more context, see https://github.com/llvm/llvm-project/issues/98509.
|
|
def test_basic(self):
|
|
"""
|
|
Tests the basic stepping in targets with directly calls.
|
|
"""
|
|
program = self.getBuildArtifact("a.out")
|
|
self.build_and_launch(program)
|
|
source = "main.cpp"
|
|
|
|
breakpoint_line = line_number(source, "// set breakpoint here")
|
|
lines = [breakpoint_line]
|
|
# Set breakpoint in the thread function so we can step the threads
|
|
breakpoint_ids = self.set_source_breakpoints(source, lines)
|
|
self.assertEqual(
|
|
len(breakpoint_ids), len(lines), "expect correct number of breakpoints"
|
|
)
|
|
self.continue_to_breakpoints(breakpoint_ids)
|
|
|
|
threads = self.dap_server.get_threads()
|
|
self.assertEqual(len(threads), 1, "expect one thread")
|
|
tid = threads[0]["id"]
|
|
|
|
leaf_frame = self.dap_server.get_stackFrame()
|
|
self.assertIsNotNone(leaf_frame, "expect a leaf frame")
|
|
|
|
# Request all step in targets list and verify the response.
|
|
step_in_targets_response = self.dap_server.request_stepInTargets(
|
|
leaf_frame["id"]
|
|
)
|
|
self.assertEqual(step_in_targets_response["success"], True, "expect success")
|
|
self.assertIn(
|
|
"body", step_in_targets_response, "expect body field in response body"
|
|
)
|
|
self.assertIn(
|
|
"targets",
|
|
step_in_targets_response["body"],
|
|
"expect targets field in response body",
|
|
)
|
|
|
|
step_in_targets = step_in_targets_response["body"]["targets"]
|
|
self.assertEqual(len(step_in_targets), 3, "expect 3 step in targets")
|
|
|
|
# Verify the target names are correct.
|
|
# The order of funcA and funcB may change depending on the compiler ABI.
|
|
funcA_target = None
|
|
funcB_target = None
|
|
for target in step_in_targets[0:2]:
|
|
if "funcB" in target["label"]:
|
|
funcB_target = target
|
|
elif "funcA" in target["label"]:
|
|
funcA_target = target
|
|
else:
|
|
self.fail(f"Unexpected step in target: {target}")
|
|
|
|
self.assertIsNotNone(funcA_target, "expect funcA")
|
|
self.assertIsNotNone(funcB_target, "expect funcB")
|
|
self.assertIn("foo", step_in_targets[2]["label"], "expect foo")
|
|
|
|
# Choose to step into second target and verify that we are in the second target,
|
|
# be it funcA or funcB.
|
|
self.stepIn(threadId=tid, targetId=step_in_targets[1]["id"], waitForStop=True)
|
|
leaf_frame = self.dap_server.get_stackFrame()
|
|
self.assertIsNotNone(leaf_frame, "expect a leaf frame")
|
|
self.assertEqual(step_in_targets[1]["label"], leaf_frame["name"])
|
|
|
|
@skipIf(archs=no_match(["x86", "x86_64"]))
|
|
def test_supported_capability_x86_arch(self):
|
|
program = self.getBuildArtifact("a.out")
|
|
self.build_and_launch(program)
|
|
source = "main.cpp"
|
|
bp_lines = [line_number(source, "// set breakpoint here")]
|
|
breakpoint_ids = self.set_source_breakpoints(source, bp_lines)
|
|
self.assertEqual(
|
|
len(breakpoint_ids), len(bp_lines), "expect correct number of breakpoints"
|
|
)
|
|
self.continue_to_breakpoints(breakpoint_ids)
|
|
is_supported = self.dap_server.get_capability("supportsStepInTargetsRequest")
|
|
|
|
self.assertEqual(
|
|
is_supported,
|
|
True,
|
|
f"expect capability `stepInTarget` is supported with architecture {self.getArchitecture()}",
|
|
)
|
|
# clear breakpoints.
|
|
self.set_source_breakpoints(source, [])
|
|
self.continue_to_exit()
|
|
|
|
@skipIf(archs=["x86", "x86_64"])
|
|
def test_supported_capability_other_archs(self):
|
|
program = self.getBuildArtifact("a.out")
|
|
self.build_and_launch(program)
|
|
source = "main.cpp"
|
|
bp_lines = [line_number(source, "// set breakpoint here")]
|
|
breakpoint_ids = self.set_source_breakpoints(source, bp_lines)
|
|
self.assertEqual(
|
|
len(breakpoint_ids), len(bp_lines), "expect correct number of breakpoints"
|
|
)
|
|
self.continue_to_breakpoints(breakpoint_ids)
|
|
|
|
try:
|
|
is_supported = self.dap_server.get_capability(
|
|
"supportsStepInTargetsRequest"
|
|
)
|
|
except dap_server.NotSupportedError:
|
|
is_supported = False
|
|
|
|
self.assertEqual(
|
|
is_supported,
|
|
False,
|
|
f"expect capability `stepInTarget` is not supported with architecture {self.getArchitecture()}",
|
|
)
|
|
# clear breakpoints.
|
|
self.set_source_breakpoints(source, [])
|
|
self.continue_to_exit()
|