"""
Test breakpoint commands for a breakpoint ID with multiple locations.
"""
import lldb
from lldbsuite.test.decorators import *
from lldbsuite.test.lldbtest import *
from lldbsuite.test import lldbutil
class BreakpointLocationsTestCase(TestBase):
@expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24528")
def test_enable(self):
"""Test breakpoint enable/disable for a breakpoint ID with multiple locations."""
self.build()
self.breakpoint_locations_test()
def test_shadowed_cond_options(self):
"""Test that options set on the breakpoint and location behave correctly."""
self.build()
self.shadowed_bkpt_cond_test()
def test_shadowed_command_options(self):
"""Test that options set on the breakpoint and location behave correctly."""
self.build()
self.shadowed_bkpt_command_test()
def setUp(self):
# Call super's setUp().
TestBase.setUp(self)
# Find the line number to break inside main().
self.line = line_number("main.c", "// Set break point at this line.")
def set_breakpoint(self):
exe = self.getBuildArtifact("a.out")
target = self.dbg.CreateTarget(exe)
self.assertTrue(target, "Target %s is not valid" % (exe))
# This should create a breakpoint with 3 locations.
bkpt = target.BreakpointCreateByLocation("main.c", self.line)
# The breakpoint list should show 3 locations.
self.assertEqual(bkpt.GetNumLocations(), 3, "Wrong number of locations")
self.expect(
"breakpoint list -f",
"Breakpoint locations shown correctly",
substrs=[
"1: file = 'main.c', line = %d, exact_match = 0, locations = 3"
% self.line
],
patterns=[
"where = a.out`func_inlined .+unresolved, hit count = 0",
"where = a.out`main .+\[inlined\].+unresolved, hit count = 0",
],
)
return bkpt
def shadowed_bkpt_cond_test(self):
"""Test that options set on the breakpoint and location behave correctly."""
# Breakpoint option propagation from bkpt to loc used to be done the first time
# a breakpoint location option was specifically set. After that the other options
# on that location would stop tracking the breakpoint. That got fixed, and this test
# makes sure only the option touched is affected.
bkpt = self.set_breakpoint()
bkpt_cond = "1 == 0"
bkpt.SetCondition(bkpt_cond)
self.assertEqual(bkpt.GetCondition(), bkpt_cond, "Successfully set condition")
self.assertEqual(
bkpt.location[0].GetCondition(),
bkpt.GetCondition(),
"Conditions are the same",
)
# Now set a condition on the locations, make sure that this doesn't effect the bkpt:
bkpt_loc_1_cond = "1 == 1"
bkpt.location[0].SetCondition(bkpt_loc_1_cond)
self.assertEqual(
bkpt.location[0].GetCondition(),
bkpt_loc_1_cond,
"Successfully changed location condition",
)
self.assertNotEqual(
bkpt.GetCondition(),
bkpt_loc_1_cond,
"Changed location changed Breakpoint condition",
)
self.assertEqual(
bkpt.location[1].GetCondition(),
bkpt_cond,
"Changed another location's condition",
)
# Now make sure that setting one options doesn't fix the value of another:
bkpt.SetIgnoreCount(10)
self.assertEqual(bkpt.GetIgnoreCount(), 10, "Set the ignore count successfully")
self.assertEqual(
bkpt.location[0].GetIgnoreCount(),
10,
"Location doesn't track top-level bkpt.",
)
# Now make sure resetting the condition to "" resets the tracking:
bkpt.location[0].SetCondition("")
bkpt_new_cond = "1 == 3"
bkpt.SetCondition(bkpt_new_cond)
self.assertEqual(
bkpt.location[0].GetCondition(),
bkpt_new_cond,
"Didn't go back to tracking condition",
)
# Test that set/get accessor methods on BreakpointLocation behave correctly.
bkpt_loc = bkpt.GetLocationAtIndex(0)
value = "MyQueue"
bkpt_loc.SetQueueName(value)
self.assertEqual(
bkpt_loc.GetQueueName(), value, "Successfully set/get bp location QueueName"
)
value = 5
bkpt_loc.SetThreadID(value)
self.assertEqual(
bkpt_loc.GetThreadID(), value, "Successfully set/get bp location ThreadID"
)
value = "1 == 0"
bkpt_loc.SetCondition(value)
self.assertEqual(
bkpt_loc.GetCondition(), value, "Successfully set/get bp location Condition"
)
value = 6
bkpt_loc.SetThreadIndex(value)
self.assertEqual(
bkpt_loc.GetThreadIndex(),
value,
"Successfully set/get bp location ThreadIndex",
)
value = "MyThread"
bkpt_loc.SetThreadName(value)
self.assertEqual(
bkpt_loc.GetThreadName(),
value,
"Successfully set/get bp location ThreadName",
)
value = 5
bkpt_loc.SetIgnoreCount(value)
self.assertEqual(
bkpt_loc.GetIgnoreCount(),
value,
"Successfully set/get bp location IgnoreCount",
)
for value in [True, False]:
bkpt_loc.SetAutoContinue(value)
self.assertEqual(
bkpt_loc.GetAutoContinue(),
value,
"Successfully set/get bp location AutoContinue",
)
for value in [True, False]:
bkpt_loc.SetEnabled(value)
self.assertEqual(
bkpt_loc.IsEnabled(),
value,
"Successfully set/get bp location SetEnabled",
)
# test set/get CommandLineCommands
set_cmds = lldb.SBStringList()
set_cmds.AppendString("frame var")
set_cmds.AppendString("bt")
bkpt_loc.SetCommandLineCommands(set_cmds)
get_cmds = lldb.SBStringList()
bkpt_loc.GetCommandLineCommands(get_cmds)
self.assertEqual(
set_cmds.GetSize(), get_cmds.GetSize(), "Size of command line commands"
)
for idx, _ in enumerate(set_cmds):
self.assertEqual(
set_cmds.GetStringAtIndex(idx),
get_cmds.GetStringAtIndex(idx),
"Command %d" % (idx),
)
def shadowed_bkpt_command_test(self):
"""Test that options set on the breakpoint and location behave correctly."""
# Breakpoint option propagation from bkpt to loc used to be done the first time
# a breakpoint location option was specifically set. After that the other options
# on that location would stop tracking the breakpoint. That got fixed, and this test
# makes sure only the option touched is affected.
bkpt = self.set_breakpoint()
commands = ["AAAAAA", "BBBBBB", "CCCCCC"]
str_list = lldb.SBStringList()
str_list.AppendList(commands, len(commands))
bkpt.SetCommandLineCommands(str_list)
cmd_list = lldb.SBStringList()
bkpt.GetCommandLineCommands(cmd_list)
list_size = str_list.GetSize()
self.assertEqual(
cmd_list.GetSize(), list_size, "Added the right number of commands"
)
for i in range(0, list_size):
self.assertEqual(
str_list.GetStringAtIndex(i),
cmd_list.GetStringAtIndex(i),
"Mismatched commands.",
)
commands = ["DDDDDD", "EEEEEE", "FFFFFF", "GGGGGG"]
loc_list = lldb.SBStringList()
loc_list.AppendList(commands, len(commands))
bkpt.location[1].SetCommandLineCommands(loc_list)
loc_cmd_list = lldb.SBStringList()
bkpt.location[1].GetCommandLineCommands(loc_cmd_list)
loc_list_size = loc_list.GetSize()
# Check that the location has the right commands:
self.assertEqual(
loc_cmd_list.GetSize(),
loc_list_size,
"Added the right number of commands to location",
)
for i in range(0, loc_list_size):
self.assertEqual(
loc_list.GetStringAtIndex(i),
loc_cmd_list.GetStringAtIndex(i),
"Mismatched commands.",
)
# Check that we didn't mess up the breakpoint level commands:
self.assertEqual(
cmd_list.GetSize(), list_size, "Added the right number of commands"
)
for i in range(0, list_size):
self.assertEqual(
str_list.GetStringAtIndex(i),
cmd_list.GetStringAtIndex(i),
"Mismatched commands.",
)
# And check we didn't mess up another location:
untouched_loc_cmds = lldb.SBStringList()
bkpt.location[0].GetCommandLineCommands(untouched_loc_cmds)
self.assertEqual(untouched_loc_cmds.GetSize(), 0, "Changed the wrong location")
def breakpoint_locations_test(self):
"""Test breakpoint enable/disable for a breakpoint ID with multiple locations."""
self.set_breakpoint()
# The 'breakpoint disable 3.*' command should fail gracefully.
self.expect(
"breakpoint disable 3.*",
"Disabling an invalid breakpoint should fail gracefully",
error=True,
startstr="error: '3' is not a valid breakpoint ID.",
)
# The 'breakpoint disable 1.*' command should disable all 3 locations.
self.expect(
"breakpoint disable 1.*",
"All 3 breakpoint locatons disabled correctly",
startstr="3 breakpoints disabled.",
)
# Run the program.
self.runCmd("run", RUN_SUCCEEDED)
# We should not stopped on any breakpoint at all.
self.expect(
"process status",
"No stopping on any disabled breakpoint",
patterns=["^Process [0-9]+ exited with status = 0"],
)
# The 'breakpoint enable 1.*' command should enable all 3 breakpoints.
self.expect(
"breakpoint enable 1.*",
"All 3 breakpoint locatons enabled correctly",
startstr="3 breakpoints enabled.",
)
# The 'breakpoint enable 1.' command should not crash.
self.expect(
"breakpoint enable 1.",
startstr="0 breakpoints enabled.",
)
# The 'breakpoint disable 1.1' command should disable 1 location.
self.expect(
"breakpoint disable 1.1",
"1 breakpoint locatons disabled correctly",
startstr="1 breakpoints disabled.",
)
# Run the program again. We should stop on the two breakpoint
# locations.
self.runCmd("run", RUN_SUCCEEDED)
# Stopped once.
self.expect(
"thread backtrace",
STOPPED_DUE_TO_BREAKPOINT,
substrs=["stop reason = breakpoint 1."],
)
# Continue the program, there should be another stop.
self.runCmd("process continue")
# Stopped again.
self.expect(
"thread backtrace",
STOPPED_DUE_TO_BREAKPOINT,
substrs=["stop reason = breakpoint 1."],
)
# At this point, 1.1 has a hit count of 0 and the other a hit count of
# 1".
lldbutil.check_breakpoint(
self,
bpno=1,
expected_locations=3,
expected_resolved_count=2,
expected_hit_count=2,
)
lldbutil.check_breakpoint(
self,
bpno=1,
location_id=1,
expected_location_resolved=False,
expected_location_hit_count=0,
)
lldbutil.check_breakpoint(
self,
bpno=1,
location_id=2,
expected_location_resolved=True,
expected_location_hit_count=1,
)
lldbutil.check_breakpoint(
self,
bpno=1,
location_id=3,
expected_location_resolved=True,
expected_location_hit_count=1,
)
Codebase Browser
llvm