blob: a272333f8d0c5a0c821937e30fc6a19d8f0a2bac [file]
"""
Test lldb-dap variables request
"""
import os
from typing import List, Optional
from lldbsuite.test import lldbplatformutil
from lldbsuite.test.decorators import *
from lldbsuite.test.lldbtest import line_number
from lldbsuite.test.tools.lldb_dap.types import (
EvaluateContext,
LaunchArgs,
VariablesArgs,
)
from lldbsuite.test.tools.lldb_dap import DAPTestCaseBase, ExpectEval, ExpectVar
def make_expected_buffer(start_idx, count, offset=0):
return {
f"[{i}]": ExpectVar(type="int", value=str(i + offset))
for i in range(start_idx, start_idx + count)
}
class TestDAP_variables(DAPTestCaseBase):
SHARED_BUILD_TESTCASE = False
def darwin_dwarf_missing_obj(self, initCommands: Optional[List[str]]):
self.build(debug_info="dwarf")
program = self.getBuildArtifact("a.out")
main_obj = self.getBuildArtifact("main.o")
self.assertTrue(os.path.exists(main_obj))
# Delete the main.o file that contains the debug info so we force an
# error when we run to main and try to get variables.
os.unlink(main_obj)
self.assertTrue(os.path.exists(program), "executable must exist")
session = self.create_session()
with session.configure(
LaunchArgs(program=program, initCommands=initCommands)
) as ctx:
breakpoint_ids = session.resolve_function_breakpoints(["main"])
self.assertEqual(len(breakpoint_ids), 1, "expect one breakpoint")
stop_event = session.verify_stopped_on_breakpoint(
breakpoint_ids, after=ctx.process_event
)
thread_id = self.expect_not_none(stop_event.body.threadId)
frame = session.thread_context_from(thread_id).top_frame()
var_args = VariablesArgs(variablesReference=frame.locals.variablesReference)
error_response = session.send_request(var_args).error()
error_body = self.expect_not_none(error_response.body)
error_message = self.expect_not_none(error_body.error)
self.assertEqual(
f'debug map object file "{main_obj}" containing debug info does not exist, debug info will not be loaded',
error_message.format,
)
self.assertTrue(error_message.showUser)
def do_test_scopes_variables_setVariable_evaluate(
self, enableAutoVariableSummaries: bool
):
"""Tests the "scopes", "variables", "setVariable", and "evaluate" packets."""
program = self.getBuildArtifact("a.out")
session = self.build_and_create_session()
source = "main.cpp"
breakpoint1_line = line_number(source, "// breakpoint 1")
breakpoint2_line = line_number(source, "// breakpoint 2")
breakpoint3_line = line_number(source, "// breakpoint 3")
launch_args = LaunchArgs(
program=program, enableAutoVariableSummaries=enableAutoVariableSummaries
)
with session.configure(launch_args) as ctx:
breakpoint_ids = session.resolve_source_breakpoints(
source, [breakpoint1_line, breakpoint2_line, breakpoint3_line]
)
bp1, bp2, bp3 = breakpoint_ids
stop_event = session.verify_stopped_on_breakpoint(bp1, after=ctx.process_event)
thread_id = self.expect_not_none(stop_event.body.threadId)
frame = session.top_frame_from(thread_id)
local_vars = session.get_variables(frame.locals.variablesReference)
global_vars = session.get_variables(frame.globals.variablesReference)
buffer_children = make_expected_buffer(0, 16)
expect_locals = {
"argc": ExpectVar(type="int", value="1"),
"argv": ExpectVar(type="const char **", startswith="0x", has_var_ref=True),
"pt": ExpectVar(
type="PointType",
has_var_ref=True,
read_only=True,
children={
"x": ExpectVar(type="int", value="11"),
"y": ExpectVar(type="int", value="22"),
"buffer": ExpectVar(read_only=True, children=buffer_children),
},
),
"valid_str": ExpectVar(),
"malformed_str": ExpectVar(),
"x": ExpectVar(type="int"),
}
s_global = ExpectVar(type="int", value="234")
g_global = ExpectVar(type="int", value="123")
expect_globals = {
"s_local": ExpectVar(type="float", value="2.25"),
}
if lldbplatformutil.getHostPlatform() == "windows":
expect_globals["::s_global"] = s_global
expect_globals["g_global"] = g_global
else:
expect_globals["s_global"] = s_global
expect_globals["::g_global"] = g_global
session.verify_variables(local_vars, expect_locals)
session.verify_variables(global_vars, expect_globals)
pt_var = frame.locals["pt"]
pt_buffer = pt_var["buffer"]
# We need to test the functionality of the "variables" request as it
# has optional parameters like "start" and "count" to limit the number
# of variables that are fetched.
var_ref = pt_buffer.variablesReference
children = session.get_variables(var_ref)
session.verify_variables(children, buffer_children)
# start=0 still gets all children.
children = session.get_variables(var_ref, start=0)
session.verify_variables(children, buffer_children)
# count=0 gets all children.
children = session.get_variables(var_ref, count=0)
session.verify_variables(children, buffer_children)
# An oversized count gets all children, no more.
children = session.get_variables(var_ref, count=1000)
session.verify_variables(children, buffer_children)
# start and count gets only the children we want.
children = session.get_variables(var_ref, start=5, count=5)
session.verify_variables(children, make_expected_buffer(5, 5))
# An out-of-range start gets an empty list.
children = session.get_variables(var_ref, start=32, count=1)
self.assertEqual(
len(children), 0, "verify we get no variables back for an invalid start"
)
# Test evaluate.
if enableAutoVariableSummaries:
pt_match = r"^\{x:11, y:22, buffer:\{\.\.\.\}\}"
buf_match = r"^\{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, \.\.\.\}"
else:
# Verify that without a summary the value is empty.
pt_match = "^$"
buf_match = "^$"
expressions = {
"pt.x": ExpectEval(type="int", result="11", has_var_ref=False),
"pt.buffer[2]": ExpectEval(type="int", result="2", has_var_ref=False),
"pt": ExpectEval(type="PointType", matches=pt_match, has_var_ref=True),
"pt.buffer": ExpectEval(
type="int[16]",
matches=buf_match,
has_var_ref=True,
),
"argv": ExpectEval(type="const char **", startswith="0x", has_var_ref=True),
"argv[0]": ExpectEval(
type="const char *", startswith="0x", has_var_ref=True
),
"2+3": ExpectEval(type="int", result="5", has_var_ref=False),
}
for expression, expected in expressions.items():
expr_result = frame.evaluate(expression)
session.verify_evaluate(expr_result, expected)
# Test setting variables.
self.expect_success(frame.locals.set("argc", 123))
argc = frame.locals["argc"].value_as_int
self.assertEqual(argc, 123, f"verify argc was set to 123 (123 != {argc})")
self.expect_success(frame.locals.set("argv", 0x1234))
argv = frame.locals["argv"].value_as_int
self.assertEqual(
argv, 0x1234, f"verify argv was set to 0x1234 (0x1234 != {argv:#x})"
)
# Test hexadecimal format.
hex_set = self.expect_success(frame.locals.set("argc", 42, is_hex=True))
self.assertEqual(hex_set.body.type, "int")
self.assertEqual(hex_set.body.value, "0x0000002a")
self.expect_success(frame.locals.set("argc", 123))
# Set a variable whose name is synthetic (an array index) and verify
# the value by reading it back.
variable_value = 100
set_result = self.expect_success(pt_buffer.set("[0]", variable_value))
self.assertEqual(set_result.body.type, "int")
self.assertEqual(set_result.body.value, str(variable_value))
pt_buffer_ref = pt_buffer.variablesReference
children = session.get_variables(pt_buffer_ref, start=0, count=1)
session.verify_variables(children, make_expected_buffer(0, 1, variable_value))
# Update the new value in the buffer expectations so subsequent
# verifications stay consistent.
buffer_children["[0]"].value = str(variable_value)
# Set a variable whose name is a real child value (e.g. "pt.x") and
# verify the value by reading it back.
pt_var_ref = pt_var.variablesReference
self.expect_success(pt_var.set("x", "g_global - 12"))
children = session.get_variables(pt_var_ref, start=0, count=1)
value = children[0].value
self.assertEqual(value, "111", f"verify pt.x got set to 111 (111 != {value})")
# Continue to the second breakpoint to check shadowed variables and the new
# local variables is update to the new values.
session.continue_to_breakpoint(bp2)
frame = session.top_frame_from(thread_id)
expect_locals["argc"].value = "123"
# Build a child dict with `pt.x` updated to its new value.
pt_children = self.expect_not_none(expect_locals["pt"].children)
pt_children["x"].value = "111"
expect_locals["x @ main.cpp:27"] = ExpectVar(type="int", value="89")
expect_locals["x @ main.cpp:29"] = ExpectVar(type="int", value="42")
expect_locals["x @ main.cpp:31"] = ExpectVar(type="int", value="72")
local_variables = session.get_variables(frame.locals.variablesReference)
session.verify_variables(local_variables, expect_locals)
# Renaming a variable with and without the differentiator suffix.
self.expect_error(frame.locals.set("x2", 9))
self.expect_error(frame.locals.set("x @ main.cpp:0", 9))
self.expect_success(frame.locals.set("x @ main.cpp:27", 19))
self.expect_success(frame.locals.set("x @ main.cpp:29", 21))
self.expect_success(frame.locals.set("x @ main.cpp:31", 23))
# An invalid value should have no effect.
self.expect_error(frame.locals.set("x @ main.cpp:31", "invalid"))
expect_locals["x @ main.cpp:27"].value = "19"
expect_locals["x @ main.cpp:29"].value = "21"
expect_locals["x @ main.cpp:31"].value = "23"
local_vars = session.get_variables(frame.locals.variablesReference)
session.verify_variables(local_vars, expect_locals)
# The plain `x` variable should refer to the innermost x.
self.expect_success(frame.locals.set("x", 22))
expect_locals["x @ main.cpp:31"].value = "22"
local_vars = session.get_variables(frame.locals.variablesReference)
session.verify_variables(local_vars, expect_locals)
# At breakpoint 3 there should be no shadowed variables.
session.continue_to_breakpoint(bp3)
frame = session.top_frame_from(thread_id)
local_vars = session.get_variables(frame.locals.variablesReference)
names = [var.name for var in local_vars]
# The first shadowed `x` shouldn't have a suffix anymore.
expect_locals["x"] = ExpectVar(type="int", value="19")
self.assertNotIn("x @ main.cpp:27", names)
self.assertNotIn("x @ main.cpp:29", names)
self.assertNotIn("x @ main.cpp:31", names)
session.verify_variables(local_vars, expect_locals)
session.continue_to_exit()
@skipIfWindows
def test_scopes_variables_setVariable_evaluate(self):
self.do_test_scopes_variables_setVariable_evaluate(
enableAutoVariableSummaries=False
)
@skipIfWindows
def test_scopes_variables_setVariable_evaluate_with_descriptive_summaries(
self,
):
self.do_test_scopes_variables_setVariable_evaluate(
enableAutoVariableSummaries=True
)
@skipIfWindows
def do_test_scopes_and_evaluate_expansion(self, enableAutoVariableSummaries: bool):
"""Test that an evaluated expression expands successfully after "scopes"
packets, and that permanent expressions persist across resumes."""
program = self.getBuildArtifact("a.out")
session = self.build_and_create_session()
source = "main.cpp"
launch_args = LaunchArgs(
program=program, enableAutoVariableSummaries=enableAutoVariableSummaries
)
with session.configure(launch_args) as ctx:
lines = [
line_number(source, "// breakpoint 1"),
line_number(source, "// breakpoint 3"),
line_number(source, "// breakpoint 6"),
line_number(source, "// breakpoint 7"),
line_number(source, "// breakpoint 8"),
]
breakpoint_ids = session.resolve_source_breakpoints(source, lines)
bp1, bp3, bp6, bp7, bp8 = breakpoint_ids
stop_event = session.verify_stopped_on_breakpoint(bp1, after=ctx.process_event)
thread_id = self.expect_not_none(stop_event.body.threadId)
frame = session.thread_context_from(thread_id).top_frame()
# Verify locals.
local_vars = session.get_variables(frame.locals.variablesReference)
buffer_children = make_expected_buffer(0, 32)
expect_locals: dict[str, ExpectVar] = {
"argc": ExpectVar(type="int", value="1", has_indexed_variables=False),
"argv": ExpectVar(
type="const char **",
startswith="0x",
has_var_ref=True,
has_indexed_variables=False,
),
"pt": ExpectVar(
type="PointType",
has_var_ref=True,
read_only=True,
has_indexed_variables=False,
children={
"x": ExpectVar(type="int", value="11", has_indexed_variables=False),
"y": ExpectVar(type="int", value="22", has_indexed_variables=False),
"buffer": ExpectVar(
indexed_variables=16,
read_only=True,
children=buffer_children,
),
},
),
"valid_str": ExpectVar(
type="const char *",
matches=r'0x\w+ "𐌶𐌰L𐌾𐍈 C𐍈𐌼𐌴𐍃"',
),
"malformed_str": ExpectVar(
type="const char *",
matches=r'0x\w+ "lone trailing \\x81\\x82 bytes"',
),
"x": ExpectVar(type="int", has_indexed_variables=False),
}
session.verify_variables(local_vars, expect_locals)
expandable_name = "pt"
if enableAutoVariableSummaries:
pt_match = r"^\{x:11, y:22, buffer:\{\.\.\.\}\}"
else:
pt_match = "^$"
repl_result = """(PointType) $0 = {
x = 11
y = 22
buffer = {
[0] = 0
[1] = 1
[2] = 2
[3] = 3
[4] = 4
[5] = 5
[6] = 6
[7] = 7
[8] = 8
[9] = 9
[10] = 10
[11] = 11
[12] = 12
[13] = 13
[14] = 14
[15] = 15
}
}"""
expandable_children: dict[str, ExpectVar] = {
"x": ExpectVar(type="int", value="11"),
"y": ExpectVar(type="int", value="22"),
"buffer": ExpectVar(read_only=True, children=buffer_children),
}
expected_contexts_evals: dict[EvaluateContext, ExpectEval] = {
"repl": ExpectEval(
type="PointType",
result=repl_result,
has_var_ref=True,
has_indexed_variables=False,
children=expandable_children,
),
"hover": ExpectEval(
type="PointType",
matches=pt_match,
has_var_ref=True,
has_indexed_variables=False,
children=expandable_children,
),
"watch": ExpectEval(
type="PointType",
matches=pt_match,
has_var_ref=True,
has_indexed_variables=False,
children=expandable_children,
),
"variables": ExpectEval(
type="PointType",
matches=pt_match,
has_var_ref=True,
has_indexed_variables=False,
children=expandable_children,
),
}
# Evaluate from each known context.
permanent_expandable_ref: Optional[int] = None
temporary_expandable_ref: Optional[int] = None
for context, expected_eval in expected_contexts_evals.items():
result = session.evaluate(
expandable_name, frameId=frame.id, context=context
)
if context == "repl": # Save the variablesReference.
permanent_expandable_ref = result.variablesReference
else:
temporary_expandable_ref = result.variablesReference
session.verify_evaluate(result, expected_eval)
# Evaluate locals again.
local_vars = session.get_variables(frame.locals.variablesReference)
session.verify_variables(local_vars, expect_locals)
# The previously evaluated expression should still expand.
var_ref = self.expect_not_none(temporary_expandable_ref)
session.verify_variables(session.get_variables(var_ref), expandable_children)
session.continue_to_breakpoint(bp6)
frame = session.top_frame_from(thread_id)
if enableAutoVariableSummaries:
my_var_value = '{name:"hello world!", x:42, y:7}'
else:
my_var_value = ""
session.verify_variable(
frame.locals["my_var"].variable,
ExpectVar(
type="(unnamed struct)",
value=my_var_value,
evaluate_name="my_var",
read_only=True,
),
)
session.continue_to_breakpoint(bp7)
frame = session.top_frame_from(thread_id)
home_var = frame.locals["home"]
session.verify_variable(
home_var.variable,
ExpectVar(
type="MySock",
value="",
evaluate_name="home",
read_only=True,
),
)
anon_var = home_var["(anonymous)"]
if enableAutoVariableSummaries:
anon_value_re = r"{ipv4:.*, ipv6:.*}"
else:
anon_value_re = r"^$"
session.verify_variable(
anon_var.variable,
ExpectVar(
type="MySock::(anonymous union)",
matches=anon_value_re,
read_only=True,
has_evaluate_name=False,
),
)
inner_union_vars = session.get_variables(anon_var.variablesReference)
session.verify_variables(
inner_union_vars,
{
"ipv4": ExpectVar(
type="unsigned char[4]",
evaluate_name="home.ipv4",
read_only=True,
),
"ipv6": ExpectVar(
type="unsigned char[6]",
evaluate_name="home.ipv6",
read_only=True,
),
},
)
session.continue_to_breakpoint(bp8)
frame = session.top_frame_from(thread_id)
if enableAutoVariableSummaries:
e_value = "{lo:10, hi:11}"
else:
e_value = ""
e_var = frame.locals["e"]
session.verify_variable(
e_var.variable,
ExpectVar(
type="example",
value=e_value,
evaluate_name="e",
read_only=True,
),
)
inner_bitfields_struct = session.get_variables(e_var.variablesReference)
session.verify_variables(
inner_bitfields_struct,
{
"lo": ExpectVar(
type="unsigned int",
value="10",
evaluate_name="e.lo",
variables_reference=0,
),
"(anonymous)": ExpectVar(type="int", value="0", variables_reference=0),
"hi": ExpectVar(
type="unsigned int",
value="11",
evaluate_name="e.hi",
variables_reference=0,
),
},
)
# Continue to breakpoint 3. The permanent variable should still exist after the resume.
session.continue_to_breakpoint(bp3)
frame = session.top_frame_from(thread_id)
permanent_ref = self.expect_not_none(permanent_expandable_ref)
permanent_ref_children = session.get_variables(permanent_ref)
session.verify_variables(permanent_ref_children, expandable_children)
# The frame's scopes should carry corresponding presentation hints.
self.assertEqual(frame.globals.scope.name, "Globals")
self.assertEqual(frame.locals.scope.name, "Locals")
self.assertEqual(frame.locals.scope.presentationHint, "locals")
self.assertEqual(frame.registers.scope.name, "Registers")
self.assertEqual(frame.registers.scope.presentationHint, "registers")
# An invalid variablesReference should produce a clear error.
for wrong_var_ref in (-6000, -1, 4000):
var_args = VariablesArgs(variablesReference=wrong_var_ref)
response = session.send_request(var_args).error()
error_body = self.expect_not_none(response.body)
error_msg = self.expect_not_none(error_body.error)
self.assertTrue(
error_msg.format.startswith("invalid variablesReference"),
f"seen error message: {error_msg.format}",
)
def test_scopes_and_evaluate_expansion(self):
self.do_test_scopes_and_evaluate_expansion(enableAutoVariableSummaries=False)
def test_scopes_and_evaluate_expansion_with_descriptive_summaries(self):
self.do_test_scopes_and_evaluate_expansion(enableAutoVariableSummaries=True)
def do_test_indexedVariables(self, enableSyntheticChildDebugging: bool):
"""Test that arrays and `lldb.SBValue` objects with synthetic child
providers expose `indexedVariables`. This lets the IDE avoid fetching
too many children at once."""
program = self.getBuildArtifact("a.out")
session = self.build_and_create_session()
source = "main.cpp"
breakpoint_line = line_number(source, "// breakpoint 4")
launch_args = LaunchArgs(
program=program,
enableSyntheticChildDebugging=enableSyntheticChildDebugging,
)
with session.configure(launch_args) as ctx:
breakpoint_ids = session.resolve_source_breakpoints(
source, [breakpoint_line]
)
stop_event = session.verify_stopped_on_breakpoint(
breakpoint_ids, after=ctx.process_event
)
thread_id = self.expect_not_none(stop_event.body.threadId)
frame = session.thread_context_from(thread_id).top_frame()
# Verify locals. Vector variables can have one extra entry from the
# fake "[raw]" child.
local_vars = session.get_variables(frame.locals.variablesReference)
raw_child_count = 1 if enableSyntheticChildDebugging else 0
expect_locals: dict[str, ExpectVar] = {
"small_array": ExpectVar(indexed_variables=5, read_only=True),
"large_array": ExpectVar(indexed_variables=200, read_only=True),
"small_vector": ExpectVar(
indexed_variables=5 + raw_child_count, read_only=True
),
"large_vector": ExpectVar(
indexed_variables=200 + raw_child_count, read_only=True
),
"pt": ExpectVar(read_only=True, has_indexed_variables=False),
}
session.verify_variables(local_vars, expect_locals)
# Verify we produce a "[raw]" fake child carrying the real SBValue
# for the synthetic type.
expect_children: dict[str, ExpectVar] = {
f"[{i}]": ExpectVar(type="int", value="0") for i in range(5)
}
if enableSyntheticChildDebugging:
expect_children["[raw]"] = ExpectVar(
type="std::vector<int>", value="size=5", read_only=True
)
small_vector = frame.locals["small_vector"]
children = session.get_variables(small_vector.variablesReference)
session.verify_variables(children, expect_children)
if enableSyntheticChildDebugging:
raw_child = next(c for c in children if c.name == "[raw]")
self.assertEqual(
raw_child.evaluateName,
"small_vector",
"'evaluateName' for '[raw]' field should be the original variable name.",
)
raw_children = session.get_variables(raw_child.variablesReference)
self.assertGreater(
len(raw_children),
0,
"Expected std::vector to contain a raw underlying value with internal properties.",
)
@skipIfWindows
def test_return_variables(self):
"""Stepping out of a function with a return value should expose the
returned value as a local."""
program = self.getBuildArtifact("a.out")
session = self.build_and_create_session()
function_name = "test_return_variable"
with session.configure(LaunchArgs(program=program)) as ctx:
[bp_id] = session.resolve_function_breakpoints([function_name])
stop_event = session.verify_stopped_on_breakpoint(
bp_id, after=ctx.process_event
)
thread_ctx = session.thread_context_from(stop_event)
thread_ctx.step_out()
frame = thread_ctx.top_frame()
local_vars = session.get_variables(frame.locals.variablesReference)
return_name = "(Return Value)"
expect_locals: dict[str, ExpectVar] = {
return_name: ExpectVar(type="int", value="300", read_only=True),
"argc": ExpectVar(),
"argv": ExpectVar(),
"pt": ExpectVar(read_only=True),
"valid_str": ExpectVar(),
"malformed_str": ExpectVar(),
"x": ExpectVar(),
"return_result": ExpectVar(type="int"),
}
session.verify_variables(local_vars, expect_locals)
self.expect_error(frame.locals.set("(Return Value)", 20))
@skipIfWindows
def test_indexedVariables(self):
self.do_test_indexedVariables(enableSyntheticChildDebugging=False)
@skipIfWindows
def test_indexedVariables_with_raw_child_for_synthetics(self):
self.do_test_indexedVariables(enableSyntheticChildDebugging=True)
@skipIfWindows
@skipIfAsan # FIXME this fails with a non-asan issue on green dragon.
def test_registers(self):
"""Test that registers whose byte size is the size of a pointer on
the current system get formatted as `lldb::eFormatAddressInfo`. The
formatted value should be a pointer followed by a description of the
address. To test this we look for the PC value in the general purpose
registers, and since we will be stopped in main.cpp, verify that its
value starts with a pointer and is followed by a description that
contains main.cpp."""
program = self.getBuildArtifact("a.out")
session = self.build_and_create_session()
with session.configure(LaunchArgs(program)) as ctx:
source = "main.cpp"
breakpoint1_line = line_number(source, "// breakpoint 1")
breakpoint_ids = session.resolve_source_breakpoints(
source, [breakpoint1_line]
)
stop_event = session.verify_stopped_on_breakpoint(
breakpoint_ids, after=ctx.process_event
)
pc_name: Optional[str] = None
arch = self.getArchitecture()
if arch in ("x86", "x86_64"):
pc_name = "rip"
elif arch.startswith("arm"):
pc_name = "pc"
if pc_name is None:
self.skipTest(f"unknown program counter name for architecture: {arch}")
# Verify locals.
top_frame = session.top_frame_from(stop_event)
gpr_reg_set = top_frame.registers["General Purpose Registers"]
self.assertEqual(gpr_reg_set.type, None)
pc_reg = gpr_reg_set[pc_name].variable
self.assertTrue(pc_reg.value.startswith("0x"))
self.assertIn("a.out`main + ", pc_reg.value)
self.assertIn("at main.cpp:", pc_reg.value)
@no_debug_info_test
@requireDarwin
def test_darwin_dwarf_missing_obj(self):
"""
Test that if we build a binary with DWARF in .o files and we remove
the .o file for main.cpp, that we get a variable named "<error>"
whose value matches the appropriate error. Errors when getting
variables are returned in the LLDB API when the user should be
notified of issues that can easily be solved by rebuilding or
changing compiler options and are designed to give better feedback
to the user.
"""
self.darwin_dwarf_missing_obj(None)
@no_debug_info_test
@requireDarwin
def test_darwin_dwarf_missing_obj_with_symbol_ondemand_enabled(self):
"""
Test that if we build a binary with DWARF in .o files and we remove
the .o file for main.cpp, that we get a variable named "<error>"
whose value matches the appropriate error. Test with symbol.load-on-demand enabled.
"""
initCommands = ["settings set symbols.load-on-demand true"]
self.darwin_dwarf_missing_obj(initCommands)
@no_debug_info_test
@skipIfWindows
def test_value_format(self):
"""Test that toggling a variable's value format between decimal and
hexadecimal works."""
program = self.getBuildArtifact("a.out")
session = self.build_and_create_session()
with session.configure(LaunchArgs(program)) as ctx:
source = "main.cpp"
breakpoint1_line = line_number(source, "// breakpoint 1")
breakpoint_ids = session.resolve_source_breakpoints(
source, [breakpoint1_line]
)
stop_event = session.verify_stopped_on_breakpoint(
breakpoint_ids, after=ctx.process_event
)
thread_ctx = session.thread_context_from(stop_event)
top_frame = thread_ctx.top_frame()
# Verify locals with decimal value format.
var_pt = top_frame.locals.with_format(is_hex=False)["pt"]
self.assertEqual(var_pt["x"].value, "11")
self.assertEqual(var_pt["y"].value, "22")
# Verify locals with hex value format.
var_pt = top_frame.locals.with_format(is_hex=True)["pt"]
self.assertEqual(var_pt["x"].value, "0x0000000b")
self.assertEqual(var_pt["y"].value, "0x00000016")
# Toggle back and verify decimal value format again.
var_pt = top_frame.locals.with_format(is_hex=False)["pt"]
self.assertEqual(var_pt["x"].value, "11")
self.assertEqual(var_pt["y"].value, "22")
@skipIfWindows
def test_variable_id_uniqueness_simple(self):
"""
Simple regression test for variable ID uniqueness across frames.
Ensures variable IDs are not reused between different scopes/frames.
"""
program = self.getBuildArtifact("a.out")
session = self.build_and_create_session()
with session.configure(LaunchArgs(program)) as ctx:
source = "main.cpp"
bp_line = line_number(source, "// breakpoint 3")
[bp_id] = session.resolve_source_breakpoints(source, [bp_line])
stop_event = session.verify_stopped_on_breakpoint(
bp_id, after=ctx.process_event
)
frames = session.thread_context_from(stop_event).frames()
self.assertGreaterEqual(len(frames), 2, "need at least 2 frames")
# Collect scope reference that has children.
scope_refs = [
scope.variablesReference
for frame in frames[:3]
for scope in frame.scopes()
if scope.variablesReference != 0
]
self.assertGreater(len(scope_refs), 0, "should have found variable references")
seen_refs: set[int] = set()
# Verify scope references are unique.
for scope_ref in scope_refs:
self.assertNotIn(scope_ref, seen_refs, f"{scope_ref=} was reused!")
seen_refs.add(scope_ref)
# Verify variable references are unique.
for scope_ref in scope_refs:
for var in session.get_variables(scope_ref):
var_ref = var.variablesReference
if var_ref != 0:
self.assertNotIn(
var_ref,
seen_refs,
f"variable {var.name} {var_ref=} was reused!",
)
seen_refs.add(var_ref)