def data_formatter_commands(self):
"""Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_source_regexp (self, "Set break point at this line.")
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped',
'stop reason = breakpoint'])
# This is the function to remove the custom formats in order to have a
# clean slate for the next test case.
def cleanup():
self.runCmd('type format clear', check=False)
self.runCmd('type summary clear', check=False)
self.runCmd('type filter clear', check=False)
self.runCmd('type synth clear', check=False)
self.runCmd("settings set target.max-children-count 256", check=False)
# Execute the cleanup function during test case tear down.
self.addTearDownHook(cleanup)
self.expect('image list', substrs = self.getLibcPlusPlusLibs())
self.look_for_content_and_continue("map",['size=5 {,''hello','world','this','is','me'])
self.look_for_content_and_continue("mmap",['size=6 {','first = 3','second = "this"','first = 2','second = "hello"'])
self.look_for_content_and_continue("iset",['size=5 {','[0] = 5','[2] = 3','[3] = 2'])
self.look_for_content_and_continue("sset",['size=5 {','[0] = "is"','[1] = "world"','[4] = "hello"'])
self.look_for_content_and_continue("imset",['size=6 {','[0] = 3','[1] = 3','[2] = 3','[4] = 2','[5] = 1'])
self.look_for_content_and_continue("smset",['size=5 {','[0] = "is"','[1] = "is"','[2] = "world"','[3] = "world"'])
def data_formatter_commands(self):
"""Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_source_regexp (self, "Set break point at this line.")
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped',
'stop reason = breakpoint'])
# This is the function to remove the custom formats in order to have a
# clean slate for the next test case.
def cleanup():
self.runCmd('type format clear', check=False)
self.runCmd('type summary clear', check=False)
self.runCmd('type filter clear', check=False)
self.runCmd('type synth clear', check=False)
self.runCmd("settings set target.max-children-count 256", check=False)
# Execute the cleanup function during test case tear down.
self.addTearDownHook(cleanup)
self.expect('image list', substrs = self.getLibcPlusPlusLibs())
self.look_for_content_and_continue("map",['size=5 {,''hello','world','this','is','me'])
self.look_for_content_and_continue("mmap",['size=6 {','first = 3','second = "this"','first = 2','second = "hello"'])
self.look_for_content_and_continue("iset",['size=5 {','[0] = 5','[2] = 3','[3] = 2'])
self.look_for_content_and_continue("sset",['size=5 {','[0] = "is"','[1] = "world"','[4] = "hello"'])
self.look_for_content_and_continue("imset",['size=6 {','[0] = 3','[1] = 3','[2] = 3','[4] = 2','[5] = 1'])
self.look_for_content_and_continue("smset",['size=5 {','[0] = "is"','[1] = "is"','[2] = "world"','[3] = "world"'])
def test_and_run_command(self):
"""Test expressions on register values."""
self.build()
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the main.
lldbutil.run_break_set_by_source_regexp(self,
"break",
num_expected_locations=2)
####################
# First breakpoint
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint.
self.expect("thread list",
STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped', 'stop reason = breakpoint'])
# The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f",
BREAKPOINT_HIT_ONCE,
substrs=[' resolved, hit count = 1'])
# Try some variables that should be visible
self.expect("expr a",
VARIABLES_DISPLAYED_CORRECTLY,
substrs=['(int) $0 = 2'])
self.expect("expr b->m1",
VARIABLES_DISPLAYED_CORRECTLY,
substrs=['(int) $1 = 3'])
#####################
# Second breakpoint
self.runCmd("continue")
# The stop reason of the thread should be breakpoint.
self.expect("thread list",
STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped', 'stop reason = breakpoint'])
# The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f",
BREAKPOINT_HIT_ONCE,
substrs=[' resolved, hit count = 1'])
# Try some variables that should be visible
self.expect("expr b->m2",
VARIABLES_DISPLAYED_CORRECTLY,
substrs=['(int) $2 = 5'])
self.expect("expr c",
VARIABLES_DISPLAYED_CORRECTLY,
substrs=['(int) $3 = 5'])
self.runCmd("kill")
def run_python_os_funcionality(self):
"""Test that the Python operating system plugin works correctly"""
# Set debugger into synchronous mode
self.dbg.SetAsync(False)
# Create a target by the debugger.
cwd = os.getcwd()
exe = os.path.join(cwd, "a.out")
python_os_plugin_path = os.path.join(cwd, "operating_system.py")
target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET)
# Set breakpoints inside and outside methods that take pointers to the containing struct.
lldbutil.run_break_set_by_source_regexp (self, "// Set breakpoint here")
# Register our shared libraries for remote targets so they get automatically uploaded
arguments = None
environment = None
# Now launch the process, and do not stop at entry point.
process = target.LaunchSimple (arguments, environment, self.get_process_working_directory())
self.assertTrue(process, PROCESS_IS_VALID)
# Make sure there are no OS plug-in created thread when we first stop at our breakpoint in main
thread = process.GetThreadByID(0x111111111);
self.assertFalse (thread.IsValid(), "Make sure there is no thread 0x111111111 before we load the python OS plug-in");
thread = process.GetThreadByID(0x222222222);
self.assertFalse (thread.IsValid(), "Make sure there is no thread 0x222222222 before we load the python OS plug-in");
thread = process.GetThreadByID(0x333333333);
self.assertFalse (thread.IsValid(), "Make sure there is no thread 0x333333333 before we load the python OS plug-in");
# Now load the python OS plug-in which should update the thread list and we should have
# OS plug-in created threads with the IDs: 0x111111111, 0x222222222, 0x333333333
command = "settings set target.process.python-os-plugin-path '%s'" % python_os_plugin_path
self.dbg.HandleCommand(command)
# Verify our OS plug-in threads showed up
thread = process.GetThreadByID(0x111111111);
self.assertTrue (thread.IsValid(), "Make sure there is a thread 0x111111111 after we load the python OS plug-in");
self.verify_os_thread_registers(thread)
thread = process.GetThreadByID(0x222222222);
self.assertTrue (thread.IsValid(), "Make sure there is a thread 0x222222222 after we load the python OS plug-in");
self.verify_os_thread_registers(thread)
thread = process.GetThreadByID(0x333333333);
self.assertTrue (thread.IsValid(), "Make sure there is a thread 0x333333333 after we load the python OS plug-in");
self.verify_os_thread_registers(thread)
# Now clear the OS plug-in path to make the OS plug-in created threads dissappear
self.dbg.HandleCommand("settings clear target.process.python-os-plugin-path")
# Verify the threads are gone after unloading the python OS plug-in
thread = process.GetThreadByID(0x111111111);
self.assertFalse (thread.IsValid(), "Make sure there is no thread 0x111111111 after we unload the python OS plug-in");
thread = process.GetThreadByID(0x222222222);
self.assertFalse (thread.IsValid(), "Make sure there is no thread 0x222222222 after we unload the python OS plug-in");
thread = process.GetThreadByID(0x333333333);
self.assertFalse (thread.IsValid(), "Make sure there is no thread 0x333333333 after we unload the python OS plug-in");
def doTest(self):
"""Test SBValue::Persist"""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_source_regexp(self, "break here")
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint.
self.expect("thread list",
STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped', 'stop reason = breakpoint'])
# This is the function to remove the custom formats in order to have a
# clean slate for the next test case.
def cleanup():
self.runCmd('type format clear', check=False)
self.runCmd('type summary clear', check=False)
self.runCmd('type filter clear', check=False)
self.runCmd('type synthetic clear', check=False)
# Execute the cleanup function during test case tear down.
self.addTearDownHook(cleanup)
foo = self.frame().FindVariable("foo")
bar = self.frame().FindVariable("bar")
baz = self.frame().FindVariable("baz")
self.assertTrue(foo.IsValid(), "foo is not valid")
self.assertTrue(bar.IsValid(), "bar is not valid")
self.assertTrue(baz.IsValid(), "baz is not valid")
fooPersist = foo.Persist()
barPersist = bar.Persist()
bazPersist = baz.Persist()
self.assertTrue(fooPersist.IsValid(), "fooPersist is not valid")
self.assertTrue(barPersist.IsValid(), "barPersist is not valid")
self.assertTrue(bazPersist.IsValid(), "bazPersist is not valid")
self.assertTrue(
fooPersist.GetValueAsUnsigned(0) == 10, "fooPersist != 10")
self.assertTrue(barPersist.GetPointeeData().sint32[0] == 4,
"barPersist != 4")
self.assertTrue(bazPersist.GetSummary() == '"85"', "bazPersist != 85")
self.runCmd("continue")
self.assertTrue(fooPersist.IsValid(), "fooPersist is not valid")
self.assertTrue(barPersist.IsValid(), "barPersist is not valid")
self.assertTrue(bazPersist.IsValid(), "bazPersist is not valid")
self.assertTrue(
fooPersist.GetValueAsUnsigned(0) == 10, "fooPersist != 10")
self.assertTrue(barPersist.GetPointeeData().sint32[0] == 4,
"barPersist != 4")
self.assertTrue(bazPersist.GetSummary() == '"85"', "bazPersist != 85")
self.expect("expr *(%s)" % (barPersist.GetName()), substrs=['= 4'])
def run_python_os_funcionality(self):
"""Test that the Python operating system plugin works correctly"""
# Set debugger into synchronous mode
self.dbg.SetAsync(False)
# Create a target by the debugger.
cwd = os.getcwd()
exe = os.path.join(cwd, "a.out")
python_os_plugin_path = os.path.join(cwd, "operating_system.py")
target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET)
# Set breakpoints inside and outside methods that take pointers to the containing struct.
lldbutil.run_break_set_by_source_regexp (self, "// Set breakpoint here")
# Register our shared libraries for remote targets so they get automatically uploaded
arguments = None
environment = None
# Now launch the process, and do not stop at entry point.
process = target.LaunchSimple (arguments, environment, self.get_process_working_directory())
self.assertTrue(process, PROCESS_IS_VALID)
# Make sure there are no OS plug-in created thread when we first stop at our breakpoint in main
thread = process.GetThreadByID(0x111111111);
self.assertFalse (thread.IsValid(), "Make sure there is no thread 0x111111111 before we load the python OS plug-in");
thread = process.GetThreadByID(0x222222222);
self.assertFalse (thread.IsValid(), "Make sure there is no thread 0x222222222 before we load the python OS plug-in");
thread = process.GetThreadByID(0x333333333);
self.assertFalse (thread.IsValid(), "Make sure there is no thread 0x333333333 before we load the python OS plug-in");
# Now load the python OS plug-in which should update the thread list and we should have
# OS plug-in created threads with the IDs: 0x111111111, 0x222222222, 0x333333333
command = "settings set target.process.python-os-plugin-path '%s'" % python_os_plugin_path
self.dbg.HandleCommand(command)
# Verify our OS plug-in threads showed up
thread = process.GetThreadByID(0x111111111);
self.assertTrue (thread.IsValid(), "Make sure there is a thread 0x111111111 after we load the python OS plug-in");
self.verify_os_thread_registers(thread)
thread = process.GetThreadByID(0x222222222);
self.assertTrue (thread.IsValid(), "Make sure there is a thread 0x222222222 after we load the python OS plug-in");
self.verify_os_thread_registers(thread)
thread = process.GetThreadByID(0x333333333);
self.assertTrue (thread.IsValid(), "Make sure there is a thread 0x333333333 after we load the python OS plug-in");
self.verify_os_thread_registers(thread)
# Now clear the OS plug-in path to make the OS plug-in created threads dissappear
self.dbg.HandleCommand("settings clear target.process.python-os-plugin-path")
# Verify the threads are gone after unloading the python OS plug-in
thread = process.GetThreadByID(0x111111111);
self.assertFalse (thread.IsValid(), "Make sure there is no thread 0x111111111 after we unload the python OS plug-in");
thread = process.GetThreadByID(0x222222222);
self.assertFalse (thread.IsValid(), "Make sure there is no thread 0x222222222 after we unload the python OS plug-in");
thread = process.GetThreadByID(0x333333333);
self.assertFalse (thread.IsValid(), "Make sure there is no thread 0x333333333 after we unload the python OS plug-in");
def test(self):
"""Test SBValue::Persist"""
self.build()
self.setTearDownCleanup()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_source_regexp (self, "break here")
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped',
'stop reason = breakpoint'])
# This is the function to remove the custom formats in order to have a
# clean slate for the next test case.
def cleanup():
self.runCmd('type format clear', check=False)
self.runCmd('type summary clear', check=False)
self.runCmd('type filter clear', check=False)
self.runCmd('type synthetic clear', check=False)
# Execute the cleanup function during test case tear down.
self.addTearDownHook(cleanup)
foo = self.frame().FindVariable("foo")
bar = self.frame().FindVariable("bar")
baz = self.frame().FindVariable("baz")
self.assertTrue(foo.IsValid(), "foo is not valid")
self.assertTrue(bar.IsValid(), "bar is not valid")
self.assertTrue(baz.IsValid(), "baz is not valid")
fooPersist = foo.Persist()
barPersist = bar.Persist()
bazPersist = baz.Persist()
self.assertTrue(fooPersist.IsValid(), "fooPersist is not valid")
self.assertTrue(barPersist.IsValid(), "barPersist is not valid")
self.assertTrue(bazPersist.IsValid(), "bazPersist is not valid")
self.assertTrue(fooPersist.GetValueAsUnsigned(0) == 10, "fooPersist != 10")
self.assertTrue(barPersist.GetPointeeData().sint32[0] == 4, "barPersist != 4")
self.assertTrue(bazPersist.GetSummary() == '"85"', "bazPersist != 85")
self.runCmd("continue")
self.assertTrue(fooPersist.IsValid(), "fooPersist is not valid")
self.assertTrue(barPersist.IsValid(), "barPersist is not valid")
self.assertTrue(bazPersist.IsValid(), "bazPersist is not valid")
self.assertTrue(fooPersist.GetValueAsUnsigned(0) == 10, "fooPersist != 10")
self.assertTrue(barPersist.GetPointeeData().sint32[0] == 4, "barPersist != 4")
self.assertTrue(bazPersist.GetSummary() == '"85"', "bazPersist != 85")
self.expect("expr *(%s)" % (barPersist.GetName()), substrs = ['= 4'])
def data_formatter_commands(self):
"""Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_source_regexp(self, "Set break point at this line.")
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, substrs=["stopped", "stop reason = breakpoint"])
# This is the function to remove the custom formats in order to have a
# clean slate for the next test case.
def cleanup():
self.runCmd("type format clear", check=False)
self.runCmd("type summary clear", check=False)
self.runCmd("type filter clear", check=False)
self.runCmd("type synth clear", check=False)
self.runCmd("settings set target.max-children-count 256", check=False)
# Execute the cleanup function during test case tear down.
self.addTearDownHook(cleanup)
self.expect("image list", substrs=["libc++.1.dylib", "libc++abi.dylib"])
self.expect("frame variable ii", substrs=["size=0", "{}"])
self.runCmd("continue")
self.expect(
"frame variable ii", substrs=["size=6", "[0] = 0", "[1] = 1", "[2] = 2", "[3] = 3", "[4] = 4", "[5] = 5"]
)
self.runCmd("continue")
self.expect("frame variable ii", substrs=["size=7", "[2] = 2", "[3] = 3", "[6] = 6"])
self.expect("p ii", substrs=["size=7", "[2] = 2", "[3] = 3", "[6] = 6"])
self.expect("frame variable ii[2]", substrs=[" = 2"])
self.runCmd("continue")
self.expect("frame variable ii", substrs=["size=0", "{}"])
self.runCmd("continue")
self.expect("frame variable ii", substrs=["size=0", "{}"])
self.expect("frame variable ss", substrs=["size=0", "{}"])
self.runCmd("continue")
self.expect("frame variable ss", substrs=["size=2", '[0] = "a"', '[1] = "a very long string is right here"'])
self.runCmd("continue")
self.expect(
"frame variable ss",
substrs=["size=4", '[2] = "b"', '[3] = "c"', '[0] = "a"', '[1] = "a very long string is right here"'],
)
self.expect(
"p ss",
substrs=["size=4", '[2] = "b"', '[3] = "c"', '[0] = "a"', '[1] = "a very long string is right here"'],
)
self.expect("frame variable ss[2]", substrs=[' = "b"'])
self.runCmd("continue")
self.expect(
"frame variable ss",
substrs=["size=3", '[0] = "a"', '[1] = "a very long string is right here"', '[2] = "c"'],
)
def do_testObjCXXClasses(self):
"""Test ivars of Objective-C++ classes"""
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_source_regexp(self, "breakpoint 1", num_expected_locations=1)
self.runCmd("run", RUN_SUCCEEDED)
self.expect("expr f->f", "Found ivar in class", substrs=["= 3"])
def do_testObjCXXClasses(self):
"""Test ivars of Objective-C++ classes"""
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_source_regexp (self, 'breakpoint 1', num_expected_locations=1)
self.runCmd("run", RUN_SUCCEEDED)
self.expect("expr f->f", "Found ivar in class",
substrs = ["= 3"])
def run_python_os_step(self):
"""Test that the Python operating system plugin works correctly and allows single stepping of a virtual thread that is backed by a real thread"""
# Set debugger into synchronous mode
self.dbg.SetAsync(False)
# Create a target by the debugger.
cwd = os.getcwd()
exe = os.path.join(cwd, "a.out")
python_os_plugin_path = os.path.join(cwd, "operating_system2.py")
target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET)
# Set breakpoints inside and outside methods that take pointers to the containing struct.
lldbutil.run_break_set_by_source_regexp (self, "// Set breakpoint here")
# Register our shared libraries for remote targets so they get automatically uploaded
arguments = None
environment = None
# Now launch the process, and do not stop at entry point.
process = target.LaunchSimple (arguments, environment, self.get_process_working_directory())
self.assertTrue(process, PROCESS_IS_VALID)
# Make sure there are no OS plug-in created thread when we first stop at our breakpoint in main
thread = process.GetThreadByID(0x111111111);
self.assertFalse (thread.IsValid(), "Make sure there is no thread 0x111111111 before we load the python OS plug-in");
# Now load the python OS plug-in which should update the thread list and we should have
# OS plug-in created threads with the IDs: 0x111111111, 0x222222222, 0x333333333
command = "settings set target.process.python-os-plugin-path '%s'" % python_os_plugin_path
self.dbg.HandleCommand(command)
# Verify our OS plug-in threads showed up
thread = process.GetThreadByID(0x111111111);
self.assertTrue (thread.IsValid(), "Make sure there is a thread 0x111111111 after we load the python OS plug-in");
frame = thread.GetFrameAtIndex(0)
self.assertTrue(frame.IsValid(), "Make sure we get a frame from thread 0x111111111")
line_entry = frame.GetLineEntry()
self.assertTrue(line_entry.GetFileSpec().GetFilename() == 'main.c', "Make sure we stopped on line 5 in main.c")
self.assertTrue(line_entry.GetLine() == 5, "Make sure we stopped on line 5 in main.c")
# Now single step thread 0x111111111 and make sure it does what we need it to
thread.StepOver()
frame = thread.GetFrameAtIndex(0)
self.assertTrue(frame.IsValid(), "Make sure we get a frame from thread 0x111111111")
line_entry = frame.GetLineEntry()
self.assertTrue(line_entry.GetFileSpec().GetFilename() == 'main.c', "Make sure we stepped from line 5 to line 6 in main.c")
self.assertTrue(line_entry.GetLine() == 6, "Make sure we stepped from line 5 to line 6 in main.c")
def run_python_os_step(self):
"""Test that the Python operating system plugin works correctly and allows single stepping of a virtual thread that is backed by a real thread"""
# Set debugger into synchronous mode
self.dbg.SetAsync(False)
# Create a target by the debugger.
cwd = os.getcwd()
exe = os.path.join(cwd, "a.out")
python_os_plugin_path = os.path.join(cwd, "operating_system2.py")
target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET)
# Set breakpoints inside and outside methods that take pointers to the containing struct.
lldbutil.run_break_set_by_source_regexp (self, "// Set breakpoint here")
# Register our shared libraries for remote targets so they get automatically uploaded
arguments = None
environment = None
# Now launch the process, and do not stop at entry point.
process = target.LaunchSimple (arguments, environment, self.get_process_working_directory())
self.assertTrue(process, PROCESS_IS_VALID)
# Make sure there are no OS plug-in created thread when we first stop at our breakpoint in main
thread = process.GetThreadByID(0x111111111);
self.assertFalse (thread.IsValid(), "Make sure there is no thread 0x111111111 before we load the python OS plug-in");
# Now load the python OS plug-in which should update the thread list and we should have
# OS plug-in created threads with the IDs: 0x111111111, 0x222222222, 0x333333333
command = "settings set target.process.python-os-plugin-path '%s'" % python_os_plugin_path
self.dbg.HandleCommand(command)
# Verify our OS plug-in threads showed up
thread = process.GetThreadByID(0x111111111);
self.assertTrue (thread.IsValid(), "Make sure there is a thread 0x111111111 after we load the python OS plug-in");
frame = thread.GetFrameAtIndex(0)
self.assertTrue(frame.IsValid(), "Make sure we get a frame from thread 0x111111111")
line_entry = frame.GetLineEntry()
self.assertTrue(line_entry.GetFileSpec().GetFilename() == 'main.c', "Make sure we stopped on line 5 in main.c")
self.assertTrue(line_entry.GetLine() == 5, "Make sure we stopped on line 5 in main.c")
# Now single step thread 0x111111111 and make sure it does what we need it to
thread.StepOver()
frame = thread.GetFrameAtIndex(0)
self.assertTrue(frame.IsValid(), "Make sure we get a frame from thread 0x111111111")
line_entry = frame.GetLineEntry()
self.assertTrue(line_entry.GetFileSpec().GetFilename() == 'main.c', "Make sure we stepped from line 5 to line 6 in main.c")
self.assertTrue(line_entry.GetLine() == 6, "Make sure we stepped from line 5 to line 6 in main.c")
def test_and_run_command(self):
"""Test expressions on register values."""
self.build()
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Break inside the main.
lldbutil.run_break_set_by_source_regexp(self, "break", num_expected_locations=2)
####################
# First breakpoint
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped',
'stop reason = breakpoint'])
# The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
substrs = [' resolved, hit count = 1'])
# Try some variables that should be visible
self.expect("expr a", VARIABLES_DISPLAYED_CORRECTLY,
substrs = ['(int) $0 = 2'])
self.expect("expr b->m1", VARIABLES_DISPLAYED_CORRECTLY,
substrs = ['(int) $1 = 3'])
#####################
# Second breakpoint
self.runCmd("continue")
# The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped',
'stop reason = breakpoint'])
# The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
substrs = [' resolved, hit count = 1'])
# Try some variables that should be visible
self.expect("expr b->m2", VARIABLES_DISPLAYED_CORRECTLY,
substrs = ['(int) $2 = 5'])
self.expect("expr c", VARIABLES_DISPLAYED_CORRECTLY,
substrs = ['(int) $3 = 5'])
self.runCmd("kill")
def test_break(self):
"""Test ivars of Objective-C++ classes"""
if self.getArchitecture() == "i386":
self.skipTest("requires Objective-C 2.0 runtime")
self.build()
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_source_regexp(self, "breakpoint 1", num_expected_locations=1)
self.runCmd("run", RUN_SUCCEEDED)
self.expect("expr f->f", "Found ivar in class", substrs=["= 3"])
def test_break(self):
"""Test ivars of Objective-C++ classes"""
if self.getArchitecture() == 'i386':
self.skipTest("requires Objective-C 2.0 runtime")
self.build()
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_source_regexp (self, 'breakpoint 1', num_expected_locations=1)
self.runCmd("run", RUN_SUCCEEDED)
self.expect("expr f->f", "Found ivar in class",
substrs = ["= 3"])
def runTheTest(self):
"""MakeTest that dynamically discovered ivars of type IMP do not crash LLDB"""
def cleanup():
execute_command("make cleanup")
self.addTearDownHook(cleanup)
exe = os.path.join(os.getcwd(), "a.out")
# Create a target from the debugger.
target = self.dbg.CreateTarget (exe)
self.assertTrue(target, VALID_TARGET)
# Set up our breakpoint
bkpt = lldbutil.run_break_set_by_source_regexp (self, "break here")
# Now launch the process, and do not stop at the entry point.
process = target.LaunchSimple (None, None, self.get_process_working_directory())
self.assertTrue(process.GetState() == lldb.eStateStopped,
PROCESS_STOPPED)
self.expect('frame variable --ptr-depth=1 --show-types -d run -- object', substrs=[
'(MyClass *) object = 0x',
'(void *) myImp = 0x'
])
self.expect('disassemble --start-address `((MyClass*)object)->myImp`', substrs=[
'-[MyClass init]'
])
def test_imp_ivar_type(self):
"""Test that dynamically discovered ivars of type IMP do not crash LLDB"""
if self.getArchitecture() == "i386":
# rdar://problem/9946499
self.skipTest("Dynamic types for ObjC V1 runtime not implemented")
execute_command("make repro")
def cleanup():
execute_command("make cleanup")
self.addTearDownHook(cleanup)
exe = os.path.join(os.getcwd(), "a.out")
# Create a target from the debugger.
target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET)
# Set up our breakpoint
bkpt = lldbutil.run_break_set_by_source_regexp(self, "break here")
# Now launch the process, and do not stop at the entry point.
process = target.LaunchSimple(None, None, self.get_process_working_directory())
self.assertTrue(process.GetState() == lldb.eStateStopped, PROCESS_STOPPED)
self.expect(
"frame variable --ptr-depth=1 --show-types -d run -- object",
substrs=["(MyClass *) object = 0x", "(void *) myImp = 0x"],
)
self.expect("disassemble --start-address `((MyClass*)object)->myImp`", substrs=["-[MyClass init]"])
def test_imp_ivar_type(self):
"""Test that dynamically discovered ivars of type IMP do not crash LLDB"""
if self.getArchitecture() == 'i386':
# rdar://problem/9946499
self.skipTest("Dynamic types for ObjC V1 runtime not implemented")
execute_command("make repro")
def cleanup():
execute_command("make cleanup")
self.addTearDownHook(cleanup)
exe = os.path.join(os.getcwd(), "a.out")
# Create a target from the debugger.
target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET)
# Set up our breakpoint
bkpt = lldbutil.run_break_set_by_source_regexp(self, "break here")
# Now launch the process, and do not stop at the entry point.
process = target.LaunchSimple(None, None,
self.get_process_working_directory())
self.assertTrue(process.GetState() == lldb.eStateStopped,
PROCESS_STOPPED)
self.expect(
'frame variable --ptr-depth=1 --show-types -d run -- object',
substrs=['(MyClass *) object = 0x', '(void *) myImp = 0x'])
self.expect('disassemble --start-address `((MyClass*)object)->myImp`',
substrs=['-[MyClass init]'])
def data_formatter_commands(self):
"""Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_source_regexp (self, "Set break point at this line.")
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped',
'stop reason = breakpoint'])
# This is the function to remove the custom formats in order to have a
# clean slate for the next test case.
def cleanup():
self.runCmd('type format clear', check=False)
self.runCmd('type summary clear', check=False)
self.runCmd('type filter clear', check=False)
self.runCmd('type synth clear', check=False)
self.runCmd("settings set target.max-children-count 256", check=False)
# Execute the cleanup function during test case tear down.
self.addTearDownHook(cleanup)
self.expect('image list',substrs=['libc++.1.dylib','libc++abi.dylib'])
self.expect("frame variable ii",substrs = ["size=0","{}"])
self.runCmd("continue")
self.expect("frame variable ii",substrs = ["size=6","[0] = 0","[1] = 1", "[2] = 2", "[3] = 3", "[4] = 4", "[5] = 5"])
self.runCmd("continue")
self.expect("frame variable ii",substrs = ["size=7","[2] = 2", "[3] = 3", "[6] = 6"])
self.expect("p ii",substrs = ["size=7","[2] = 2", "[3] = 3", "[6] = 6"])
self.expect("frame variable ii[2]",substrs = [" = 2"])
self.runCmd("continue")
self.expect("frame variable ii",substrs = ["size=0","{}"])
self.runCmd("continue")
self.expect("frame variable ii",substrs = ["size=0","{}"])
self.expect("frame variable ss",substrs = ["size=0","{}"])
self.runCmd("continue")
self.expect("frame variable ss",substrs = ["size=2",'[0] = "a"','[1] = "a very long string is right here"'])
self.runCmd("continue")
self.expect("frame variable ss",substrs = ["size=4",'[2] = "b"','[3] = "c"','[0] = "a"','[1] = "a very long string is right here"'])
self.expect("p ss",substrs = ["size=4",'[2] = "b"','[3] = "c"','[0] = "a"','[1] = "a very long string is right here"'])
self.expect("frame variable ss[2]",substrs = [' = "b"'])
self.runCmd("continue")
self.expect("frame variable ss",substrs = ["size=3",'[0] = "a"','[1] = "a very long string is right here"','[2] = "c"'])
def test_with_run_command(self):
"""Test that that file and class static variables display correctly."""
self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.skip_if_library_missing(self, self.target(), lldbutil.PrintableRegex("libc\+\+"))
bkpt = self.target().FindBreakpointByID(lldbutil.run_break_set_by_source_regexp (self, "Set break point at this line."))
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped',
'stop reason = breakpoint'])
# This is the function to remove the custom formats in order to have a
# clean slate for the next test case.
def cleanup():
self.runCmd('type format clear', check=False)
self.runCmd('type summary clear', check=False)
self.runCmd('type filter clear', check=False)
self.runCmd('type synth clear', check=False)
self.runCmd("settings set target.max-children-count 256", check=False)
# Execute the cleanup function during test case tear down.
self.addTearDownHook(cleanup)
self.expect('image list', substrs = self.getLibcPlusPlusLibs())
self.expect("frame variable ii",substrs = ["size=0","{}"])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect("frame variable ii",substrs = ["size=6","[0] = 0","[1] = 1", "[2] = 2", "[3] = 3", "[4] = 4", "[5] = 5"])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect("frame variable ii",substrs = ["size=7","[2] = 2", "[3] = 3", "[6] = 6"])
self.expect("p ii",substrs = ["size=7","[2] = 2", "[3] = 3", "[6] = 6"])
self.expect("frame variable ii[2]",substrs = [" = 2"])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect("frame variable ii",substrs = ["size=0","{}"])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect("frame variable ii",substrs = ["size=0","{}"])
self.expect("frame variable ss",substrs = ["size=0","{}"])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect("frame variable ss",substrs = ["size=2",'[0] = "a"','[1] = "a very long string is right here"'])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect("frame variable ss",substrs = ["size=4",'[2] = "b"','[3] = "c"','[0] = "a"','[1] = "a very long string is right here"'])
self.expect("p ss",substrs = ["size=4",'[2] = "b"','[3] = "c"','[0] = "a"','[1] = "a very long string is right here"'])
self.expect("frame variable ss[2]",substrs = [' = "b"'])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect("frame variable ss",substrs = ["size=3",'[0] = "a"','[1] = "a very long string is right here"','[2] = "c"'])
def data_formatter_commands(self):
"""Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
bkpt = self.target().FindBreakpointByID(lldbutil.run_break_set_by_source_regexp (self, "Set break point at this line."))
self.runCmd("run", RUN_FAILED)
# The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped',
'stop reason = breakpoint'])
self.expect("frame variable ili", substrs = ['[1] = 2','[4] = 5'])
self.expect("frame variable ils", substrs = ['[4] = "surprise it is a long string!! yay!!"'])
self.expect('image list', substrs = self.getLibcPlusPlusLibs())
def test(self):
"""Test that that file and class static variables display correctly."""
self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.skip_if_library_missing(self, self.target(), lldbutil.PrintableRegex("libc\+\+"))
bkpt = self.target().FindBreakpointByID(
lldbutil.run_break_set_by_source_regexp(self, "Set break point at this line.")
)
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, substrs=["stopped", "stop reason = breakpoint"])
self.expect("frame variable ili", substrs=["[1] = 2", "[4] = 5"])
self.expect("frame variable ils", substrs=['[4] = "surprise it is a long string!! yay!!"'])
self.expect("image list", substrs=self.getLibcPlusPlusLibs())
def test(self):
"""Test that that file and class static variables display correctly."""
self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.skip_if_library_missing(self, self.target(), lldbutil.PrintableRegex("libc\+\+"))
bkpt = self.target().FindBreakpointByID(lldbutil.run_break_set_by_source_regexp (self, "Set break point at this line."))
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped',
'stop reason = breakpoint'])
self.expect("frame variable ili", substrs = ['[1] = 2','[4] = 5'])
self.expect("frame variable ils", substrs = ['[4] = "surprise it is a long string!! yay!!"'])
self.expect('image list', substrs = self.getLibcPlusPlusLibs())
def data_formatter_commands(self):
"""Benchmark different ways to continue a process"""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
bkpt = self.target().FindBreakpointByID(
lldbutil.run_break_set_by_source_regexp(self, "// break here"))
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint.
self.expect("thread list",
STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped', 'stop reason = breakpoint'])
# This is the function to remove the custom formats in order to have a
# clean slate for the next test case.
def cleanup():
self.runCmd('type format clear', check=False)
self.runCmd('type summary clear', check=False)
self.runCmd('type filter clear', check=False)
self.runCmd('type synth clear', check=False)
self.runCmd("settings set target.max-children-count 256",
check=False)
# Execute the cleanup function during test case tear down.
self.addTearDownHook(cleanup)
runCmd_sw = Stopwatch()
lldbutil_sw = Stopwatch()
for i in range(0, 15):
runCmd_sw.start()
self.runCmd("continue")
runCmd_sw.stop()
for i in range(0, 15):
lldbutil_sw.start()
lldbutil.continue_to_breakpoint(self.process(), bkpt)
lldbutil_sw.stop()
print "runCmd: %s\nlldbutil: %s" % (runCmd_sw, lldbutil_sw)
def data_formatter_commands(self):
"""Benchmark different ways to continue a process"""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
bkpt = self.target().FindBreakpointByID(lldbutil.run_break_set_by_source_regexp (self, "// break here"))
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped',
'stop reason = breakpoint'])
# This is the function to remove the custom formats in order to have a
# clean slate for the next test case.
def cleanup():
self.runCmd('type format clear', check=False)
self.runCmd('type summary clear', check=False)
self.runCmd('type filter clear', check=False)
self.runCmd('type synth clear', check=False)
self.runCmd("settings set target.max-children-count 256", check=False)
# Execute the cleanup function during test case tear down.
self.addTearDownHook(cleanup)
runCmd_sw = Stopwatch()
lldbutil_sw = Stopwatch()
for i in range(0,15):
runCmd_sw.start()
self.runCmd("continue")
runCmd_sw.stop()
for i in range(0,15):
lldbutil_sw.start()
lldbutil.continue_to_breakpoint(self.process(), bkpt)
lldbutil_sw.stop()
print "runCmd: %s\nlldbutil: %s" % (runCmd_sw,lldbutil_sw)
def breakpoint_command_sequence(self):
"""Test a sequence of breakpoint command add, list, and delete."""
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add three breakpoints on the same line. The first time we don't specify the file,
# since the default file is the one containing main:
lldbutil.run_break_set_by_file_and_line(self,
None,
self.line,
num_expected_locations=1,
loc_exact=True)
lldbutil.run_break_set_by_file_and_line(self,
"main.c",
self.line,
num_expected_locations=1,
loc_exact=True)
lldbutil.run_break_set_by_file_and_line(self,
"main.c",
self.line,
num_expected_locations=1,
loc_exact=True)
# Breakpoint 4 - set at the same location as breakpoint 1 to test setting breakpoint commands on two breakpoints at a time
lldbutil.run_break_set_by_file_and_line(self,
None,
self.line,
num_expected_locations=1,
loc_exact=True)
# Now add callbacks for the breakpoints just created.
self.runCmd(
"breakpoint command add -s command -o 'frame variable --show-types --scope' 1 4"
)
self.runCmd(
"breakpoint command add -s python -o 'here = open(\"output.txt\", \"w\"); print >> here, \"lldb\"; here.close()' 2"
)
self.runCmd(
"breakpoint command add --python-function bktptcmd.function 3")
# Check that the breakpoint commands are correctly set.
# The breakpoint list now only contains breakpoint 1.
self.expect(
"breakpoint list",
"Breakpoints 1 & 2 created",
substrs=[
"2: file = 'main.c', line = %d, locations = 1" % self.line
],
patterns=[
"1: file = '.*main.c', line = %d, locations = 1" % self.line
])
self.expect(
"breakpoint list -f",
"Breakpoints 1 & 2 created",
substrs=[
"2: file = 'main.c', line = %d, locations = 1" % self.line
],
patterns=[
"1: file = '.*main.c', line = %d, locations = 1" % self.line,
"1.1: .+at main.c:%d, .+unresolved, hit count = 0" % self.line,
"2.1: .+at main.c:%d, .+unresolved, hit count = 0" % self.line
])
self.expect("breakpoint command list 1",
"Breakpoint 1 command ok",
substrs=[
"Breakpoint commands:",
"frame variable --show-types --scope"
])
self.expect("breakpoint command list 2",
"Breakpoint 2 command ok",
substrs=[
"Breakpoint commands:", "here = open", "print >> here",
"here.close()"
])
self.expect("breakpoint command list 3",
"Breakpoint 3 command ok",
substrs=[
"Breakpoint commands:",
"bktptcmd.function(frame, bp_loc, internal_dict)"
])
self.expect("breakpoint command list 4",
"Breakpoint 4 command ok",
substrs=[
"Breakpoint commands:",
"frame variable --show-types --scope"
])
self.runCmd("breakpoint delete 4")
self.runCmd("command script import --allow-reload ./bktptcmd.py")
# Next lets try some other breakpoint kinds. First break with a regular expression
# and then specify only one file. The first time we should get two locations,
# the second time only one:
lldbutil.run_break_set_by_regexp(self,
r"._MyFunction",
num_expected_locations=2)
lldbutil.run_break_set_by_regexp(self,
r"._MyFunction",
extra_options="-f a.c",
num_expected_locations=1)
lldbutil.run_break_set_by_regexp(self,
r"._MyFunction",
extra_options="-f a.c -f b.c",
num_expected_locations=2)
# Now try a source regex breakpoint:
lldbutil.run_break_set_by_source_regexp(self,
r"is about to return [12]0",
extra_options="-f a.c -f b.c",
num_expected_locations=2)
lldbutil.run_break_set_by_source_regexp(self,
r"is about to return [12]0",
extra_options="-f a.c",
num_expected_locations=1)
# Run the program. Remove 'output.txt' if it exists.
self.RemoveTempFile("output.txt")
self.RemoveTempFile("output2.txt")
self.runCmd("run", RUN_SUCCEEDED)
# Check that the file 'output.txt' exists and contains the string "lldb".
# The 'output.txt' file should now exist.
self.assertTrue(
os.path.isfile("output.txt"),
"'output.txt' exists due to breakpoint command for breakpoint 2.")
self.assertTrue(
os.path.isfile("output2.txt"),
"'output2.txt' exists due to breakpoint command for breakpoint 3.")
# Read the output file produced by running the program.
with open('output.txt', 'r') as f:
output = f.read()
self.expect(output,
"File 'output.txt' and the content matches",
exe=False,
startstr="lldb")
with open('output2.txt', 'r') as f:
output = f.read()
self.expect(output,
"File 'output2.txt' and the content matches",
exe=False,
startstr="lldb")
# Finish the program.
self.runCmd("process continue")
# Remove the breakpoint command associated with breakpoint 1.
self.runCmd("breakpoint command delete 1")
# Remove breakpoint 2.
self.runCmd("breakpoint delete 2")
self.expect(
"breakpoint command list 1",
startstr="Breakpoint 1 does not have an associated command.")
self.expect(
"breakpoint command list 2",
error=True,
startstr="error: '2' is not a currently valid breakpoint id.")
# The breakpoint list now only contains breakpoint 1.
self.expect(
"breakpoint list -f",
"Breakpoint 1 exists",
patterns=[
"1: file = '.*main.c', line = %d, locations = 1, resolved = 1"
% self.line, "hit count = 1"
])
# Not breakpoint 2.
self.expect(
"breakpoint list -f",
"No more breakpoint 2",
matching=False,
substrs=[
"2: file = 'main.c', line = %d, locations = 1, resolved = 1" %
self.line
])
# Run the program again, with breakpoint 1 remaining.
self.runCmd("run", RUN_SUCCEEDED)
# We should be stopped again due to breakpoint 1.
# The stop reason of the thread should be breakpoint.
self.expect("thread list",
STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped', 'stop reason = breakpoint'])
# The breakpoint should have a hit count of 2.
self.expect("breakpoint list -f",
BREAKPOINT_HIT_TWICE,
substrs=['resolved, hit count = 2'])
def data_formatter_commands(self):
"""Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
bkpt = self.target().FindBreakpointByID(lldbutil.run_break_set_by_source_regexp (self, "Set break point at this line."))
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped',
'stop reason = breakpoint'])
# This is the function to remove the custom formats in order to have a
# clean slate for the next test case.
def cleanup():
self.runCmd('type format clear', check=False)
self.runCmd('type summary clear', check=False)
self.runCmd('type filter clear', check=False)
self.runCmd('type synth clear', check=False)
self.runCmd("settings set target.max-children-count 256", check=False)
# Execute the cleanup function during test case tear down.
self.addTearDownHook(cleanup)
self.expect('image list', substrs = self.getLibcPlusPlusLibs())
self.expect('frame variable ii',
substrs = ['size=0',
'{}'])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect('frame variable ii',
substrs = ['size=2',
'[0] = ',
'first = 0',
'second = 0',
'[1] = ',
'first = 1',
'second = 1'])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect('frame variable ii',
substrs = ['size=4',
'[2] = ',
'first = 2',
'second = 0',
'[3] = ',
'first = 3',
'second = 1'])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect("frame variable ii",
substrs = ['size=8',
'[5] = ',
'first = 5',
'second = 0',
'[7] = ',
'first = 7',
'second = 1'])
self.expect("p ii",
substrs = ['size=8',
'[5] = ',
'first = 5',
'second = 0',
'[7] = ',
'first = 7',
'second = 1'])
# check access-by-index
self.expect("frame variable ii[0]",
substrs = ['first = 0',
'second = 0']);
self.expect("frame variable ii[3]",
substrs = ['first =',
'second =']);
# check that MightHaveChildren() gets it right
self.assertTrue(self.frame().FindVariable("ii").MightHaveChildren(), "ii.MightHaveChildren() says False for non empty!")
# check that the expression parser does not make use of
# synthetic children instead of running code
# TOT clang has a fix for this, which makes the expression command here succeed
# since this would make the test fail or succeed depending on clang version in use
# this is safer commented for the time being
#self.expect("expression ii[8]", matching=False, error=True,
# substrs = ['1234567'])
self.runCmd("continue");
self.expect('frame variable ii',
substrs = ['size=0',
'{}'])
self.expect('frame variable si',
substrs = ['size=0',
'{}'])
self.runCmd("continue");
self.expect('frame variable si',
substrs = ['size=1',
'[0] = ',
'first = \"zero\"',
'second = 0'])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect("frame variable si",
substrs = ['size=4',
'[0] = ',
'first = \"zero\"',
'second = 0',
'[1] = ',
'first = \"one\"',
'second = 1',
'[2] = ',
'first = \"two\"',
'second = 2',
'[3] = ',
'first = \"three\"',
'second = 3'])
self.expect("p si",
substrs = ['size=4',
'[0] = ',
'first = \"zero\"',
'second = 0',
'[1] = ',
'first = \"one\"',
'second = 1',
'[2] = ',
'first = \"two\"',
'second = 2',
'[3] = ',
'first = \"three\"',
'second = 3'])
# check that MightHaveChildren() gets it right
self.assertTrue(self.frame().FindVariable("si").MightHaveChildren(), "si.MightHaveChildren() says False for non empty!")
# check access-by-index
self.expect("frame variable si[0]",
substrs = ['first = ', 'one',
'second = 1']);
# check that the expression parser does not make use of
# synthetic children instead of running code
# TOT clang has a fix for this, which makes the expression command here succeed
# since this would make the test fail or succeed depending on clang version in use
# this is safer commented for the time being
#self.expect("expression si[0]", matching=False, error=True,
# substrs = ['first = ', 'zero'])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect('frame variable si',
substrs = ['size=0',
'{}'])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect('frame variable is',
substrs = ['size=0',
'{}'])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect("frame variable is",
substrs = ['size=4',
'[0] = ',
'second = \"goofy\"',
'first = 85',
'[1] = ',
'second = \"is\"',
'first = 1',
'[2] = ',
'second = \"smart\"',
'first = 2',
'[3] = ',
'second = \"!!!\"',
'first = 3'])
self.expect("p is",
substrs = ['size=4',
'[0] = ',
'second = \"goofy\"',
'first = 85',
'[1] = ',
'second = \"is\"',
'first = 1',
'[2] = ',
'second = \"smart\"',
'first = 2',
'[3] = ',
'second = \"!!!\"',
'first = 3'])
# check that MightHaveChildren() gets it right
self.assertTrue(self.frame().FindVariable("is").MightHaveChildren(), "is.MightHaveChildren() says False for non empty!")
# check access-by-index
self.expect("frame variable is[0]",
substrs = ['first = ',
'second =']);
# check that the expression parser does not make use of
# synthetic children instead of running code
# TOT clang has a fix for this, which makes the expression command here succeed
# since this would make the test fail or succeed depending on clang version in use
# this is safer commented for the time being
#self.expect("expression is[0]", matching=False, error=True,
# substrs = ['first = ', 'goofy'])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect('frame variable is',
substrs = ['size=0',
'{}'])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect('frame variable ss',
substrs = ['size=0',
'{}'])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect("frame variable ss",
substrs = ['size=3',
'[0] = ',
'second = \"hello\"',
'first = \"ciao\"',
'[1] = ',
'second = \"house\"',
'first = \"casa\"',
'[2] = ',
'second = \"cat\"',
'first = \"gatto\"'])
self.expect("p ss",
substrs = ['size=3',
'[0] = ',
'second = \"hello\"',
'first = \"ciao\"',
'[1] = ',
'second = \"house\"',
'first = \"casa\"',
'[2] = ',
'second = \"cat\"',
'first = \"gatto\"'])
# check that MightHaveChildren() gets it right
self.assertTrue(self.frame().FindVariable("ss").MightHaveChildren(), "ss.MightHaveChildren() says False for non empty!")
# check access-by-index
self.expect("frame variable ss[2]",
substrs = ['gatto', 'cat']);
# check that the expression parser does not make use of
# synthetic children instead of running code
# TOT clang has a fix for this, which makes the expression command here succeed
# since this would make the test fail or succeed depending on clang version in use
# this is safer commented for the time being
#self.expect("expression ss[3]", matching=False, error=True,
# substrs = ['gatto'])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect('frame variable ss',
substrs = ['size=0',
'{}'])
def test_with_run_command(self):
"""Test that that file and class static variables display correctly."""
self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.skip_if_library_missing(self, self.target(),
lldbutil.PrintableRegex("libc\+\+"))
bkpt = self.target().FindBreakpointByID(
lldbutil.run_break_set_by_source_regexp(
self, "Set break point at this line."))
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint.
self.expect("thread list",
STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped', 'stop reason = breakpoint'])
# This is the function to remove the custom formats in order to have a
# clean slate for the next test case.
def cleanup():
self.runCmd('type format clear', check=False)
self.runCmd('type summary clear', check=False)
self.runCmd('type filter clear', check=False)
self.runCmd('type synth clear', check=False)
self.runCmd("settings set target.max-children-count 256",
check=False)
# Execute the cleanup function during test case tear down.
self.addTearDownHook(cleanup)
self.expect('image list', substrs=self.getLibcPlusPlusLibs())
self.expect("frame variable ii", substrs=["size=0", "{}"])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect("frame variable ii",
substrs=[
"size=6", "[0] = 0", "[1] = 1", "[2] = 2", "[3] = 3",
"[4] = 4", "[5] = 5"
])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect("frame variable ii",
substrs=["size=7", "[2] = 2", "[3] = 3", "[6] = 6"])
self.expect("frame variable ii[2]", substrs=[" = 2"])
self.expect("p ii",
substrs=["size=7", "[2] = 2", "[3] = 3", "[6] = 6"])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect("frame variable ii", substrs=["size=0", "{}"])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect("frame variable ii", substrs=["size=0", "{}"])
self.expect("frame variable ss", substrs=["size=0", "{}"])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect("frame variable ss",
substrs=[
"size=2", '[0] = "a"',
'[1] = "a very long string is right here"'
])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect("frame variable ss",
substrs=[
"size=4", '[2] = "b"', '[3] = "c"', '[0] = "a"',
'[1] = "a very long string is right here"'
])
self.expect("p ss",
substrs=[
"size=4", '[2] = "b"', '[3] = "c"', '[0] = "a"',
'[1] = "a very long string is right here"'
])
self.expect("frame variable ss[2]", substrs=[' = "b"'])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect("frame variable ss",
substrs=[
"size=3", '[0] = "a"',
'[1] = "a very long string is right here"', '[2] = "c"'
])
def data_formatter_commands(self):
"""Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_source_regexp(
self, "Set break point at this line.")
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint.
self.expect("thread list",
STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped', 'stop reason = breakpoint'])
# This is the function to remove the custom formats in order to have a
# clean slate for the next test case.
def cleanup():
self.runCmd('type format clear', check=False)
self.runCmd('type summary clear', check=False)
self.runCmd('type filter clear', check=False)
self.runCmd('type synth clear', check=False)
self.runCmd("settings set target.max-children-count 256",
check=False)
# Execute the cleanup function during test case tear down.
self.addTearDownHook(cleanup)
# empty vectors (and storage pointers SHOULD BOTH BE NULL..)
self.expect("frame variable numbers", substrs=['numbers = size=0'])
self.runCmd("c")
# first value added
self.expect("frame variable numbers",
substrs=['numbers = size=1', '[0] = 1', '}'])
# add some more data
self.runCmd("c")
self.expect("frame variable numbers",
substrs=[
'numbers = size=4', '[0] = 1', '[1] = 12', '[2] = 123',
'[3] = 1234', '}'
])
self.expect("p numbers",
substrs=[
'$', 'size=4', '[0] = 1', '[1] = 12', '[2] = 123',
'[3] = 1234', '}'
])
# check access to synthetic children
self.runCmd(
"type summary add --summary-string \"item 0 is ${var[0]}\" std::int_vect int_vect"
)
self.expect('frame variable numbers', substrs=['item 0 is 1'])
self.runCmd(
"type summary add --summary-string \"item 0 is ${svar[0]}\" std::int_vect int_vect"
)
#import time
#time.sleep(19)
self.expect('frame variable numbers', substrs=['item 0 is 1'])
# move on with synths
self.runCmd("type summary delete std::int_vect")
self.runCmd("type summary delete int_vect")
# add some more data
self.runCmd("c")
self.expect("frame variable numbers",
substrs=[
'numbers = size=7', '[0] = 1', '[1] = 12', '[2] = 123',
'[3] = 1234', '[4] = 12345', '[5] = 123456',
'[6] = 1234567', '}'
])
self.expect("p numbers",
substrs=[
'$', 'size=7', '[0] = 1', '[1] = 12', '[2] = 123',
'[3] = 1234', '[4] = 12345', '[5] = 123456',
'[6] = 1234567', '}'
])
# check access-by-index
self.expect("frame variable numbers[0]", substrs=['1'])
self.expect("frame variable numbers[1]", substrs=['12'])
self.expect("frame variable numbers[2]", substrs=['123'])
self.expect("frame variable numbers[3]", substrs=['1234'])
# but check that expression does not rely on us
# (when expression gets to call into STL code correctly, we will have to find
# another way to check this)
self.expect("expression numbers[6]",
matching=False,
error=True,
substrs=['1234567'])
# check that MightHaveChildren() gets it right
self.assertTrue(
self.frame().FindVariable("numbers").MightHaveChildren(),
"numbers.MightHaveChildren() says False for non empty!")
# clear out the vector and see that we do the right thing once again
self.runCmd("c")
self.expect("frame variable numbers", substrs=['numbers = size=0'])
self.runCmd("c")
# first value added
self.expect("frame variable numbers",
substrs=['numbers = size=1', '[0] = 7', '}'])
# check if we can display strings
self.runCmd("c")
self.expect("frame variable strings", substrs=['goofy', 'is', 'smart'])
self.expect("p strings", substrs=['goofy', 'is', 'smart'])
# test summaries based on synthetic children
self.runCmd(
"type summary add std::string_vect string_vect --summary-string \"vector has ${svar%#} items\" -e"
)
self.expect("frame variable strings",
substrs=['vector has 3 items', 'goofy', 'is', 'smart'])
self.expect("p strings",
substrs=['vector has 3 items', 'goofy', 'is', 'smart'])
self.runCmd("c")
self.expect("frame variable strings", substrs=['vector has 4 items'])
# check access-by-index
self.expect("frame variable strings[0]", substrs=['goofy'])
self.expect("frame variable strings[1]", substrs=['is'])
# but check that expression does not rely on us
# (when expression gets to call into STL code correctly, we will have to find
# another way to check this)
self.expect("expression strings[0]",
matching=False,
error=True,
substrs=['goofy'])
# check that MightHaveChildren() gets it right
self.assertTrue(
self.frame().FindVariable("strings").MightHaveChildren(),
"strings.MightHaveChildren() says False for non empty!")
self.runCmd("c")
self.expect("frame variable strings", substrs=['vector has 0 items'])
def data_formatter_commands(self):
"""Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
bkpt = self.target().FindBreakpointByID(lldbutil.run_break_set_by_source_regexp (self, "break here"))
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped',
'stop reason = breakpoint'])
# This is the function to remove the custom formats in order to have a
# clean slate for the next test case.
def cleanup():
self.runCmd('type format clear', check=False)
self.runCmd('type summary clear', check=False)
self.runCmd('type filter clear', check=False)
self.runCmd('type synth clear', check=False)
self.runCmd("settings set target.max-children-count 256", check=False)
# Execute the cleanup function during test case tear down.
self.addTearDownHook(cleanup)
# empty vectors (and storage pointers SHOULD BOTH BE NULL..)
self.expect("frame variable numbers",
substrs = ['numbers = size=0'])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
# first value added
self.expect("frame variable numbers",
substrs = ['numbers = size=1',
'[0] = 1',
'}'])
# add some more data
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect("frame variable numbers",
substrs = ['numbers = size=4',
'[0] = 1',
'[1] = 12',
'[2] = 123',
'[3] = 1234',
'}'])
self.expect("p numbers",
substrs = ['$', 'size=4',
'[0] = 1',
'[1] = 12',
'[2] = 123',
'[3] = 1234',
'}'])
# check access to synthetic children
self.runCmd("type summary add --summary-string \"item 0 is ${var[0]}\" std::int_vect int_vect")
self.expect('frame variable numbers',
substrs = ['item 0 is 1']);
self.runCmd("type summary add --summary-string \"item 0 is ${svar[0]}\" std::int_vect int_vect")
self.expect('frame variable numbers',
substrs = ['item 0 is 1']);
# move on with synths
self.runCmd("type summary delete std::int_vect")
self.runCmd("type summary delete int_vect")
# add some more data
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect("frame variable numbers",
substrs = ['numbers = size=7',
'[0] = 1',
'[1] = 12',
'[2] = 123',
'[3] = 1234',
'[4] = 12345',
'[5] = 123456',
'[6] = 1234567',
'}'])
self.expect("p numbers",
substrs = ['$', 'size=7',
'[0] = 1',
'[1] = 12',
'[2] = 123',
'[3] = 1234',
'[4] = 12345',
'[5] = 123456',
'[6] = 1234567',
'}'])
# check access-by-index
self.expect("frame variable numbers[0]",
substrs = ['1']);
self.expect("frame variable numbers[1]",
substrs = ['12']);
self.expect("frame variable numbers[2]",
substrs = ['123']);
self.expect("frame variable numbers[3]",
substrs = ['1234']);
# clear out the vector and see that we do the right thing once again
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect("frame variable numbers",
substrs = ['numbers = size=0'])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
# first value added
self.expect("frame variable numbers",
substrs = ['numbers = size=1',
'[0] = 7',
'}'])
# check if we can display strings
self.expect("frame variable strings",
substrs = ['goofy',
'is',
'smart'])
self.expect("p strings",
substrs = ['goofy',
'is',
'smart'])
# test summaries based on synthetic children
self.runCmd("type summary add std::string_vect string_vect --summary-string \"vector has ${svar%#} items\" -e")
self.expect("frame variable strings",
substrs = ['vector has 3 items',
'goofy',
'is',
'smart'])
self.expect("p strings",
substrs = ['vector has 3 items',
'goofy',
'is',
'smart'])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect("frame variable strings",
substrs = ['vector has 4 items'])
# check access-by-index
self.expect("frame variable strings[0]",
substrs = ['goofy']);
self.expect("frame variable strings[1]",
substrs = ['is']);
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect("frame variable strings",
substrs = ['vector has 0 items'])
def data_formatter_commands(self):
"""Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_source_regexp (self, "Set break point at this line.")
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped',
'stop reason = breakpoint'])
# This is the function to remove the custom formats in order to have a
# clean slate for the next test case.
def cleanup():
self.runCmd('type format clear', check=False)
self.runCmd('type summary clear', check=False)
self.runCmd('type filter clear', check=False)
self.runCmd('type synth clear', check=False)
self.runCmd("settings set target.max-children-count 256", check=False)
# Execute the cleanup function during test case tear down.
self.addTearDownHook(cleanup)
# empty vectors (and storage pointers SHOULD BOTH BE NULL..)
self.expect("frame variable numbers",
substrs = ['numbers = size=0'])
self.runCmd("c")
# first value added
self.expect("frame variable numbers",
substrs = ['numbers = size=1',
'[0] = 1',
'}'])
# add some more data
self.runCmd("c");
self.expect("frame variable numbers",
substrs = ['numbers = size=4',
'[0] = 1',
'[1] = 12',
'[2] = 123',
'[3] = 1234',
'}'])
self.expect("p numbers",
substrs = ['$', 'size=4',
'[0] = 1',
'[1] = 12',
'[2] = 123',
'[3] = 1234',
'}'])
# check access to synthetic children
self.runCmd("type summary add --summary-string \"item 0 is ${var[0]}\" std::int_vect int_vect")
self.expect('frame variable numbers',
substrs = ['item 0 is 1']);
self.runCmd("type summary add --summary-string \"item 0 is ${svar[0]}\" std::int_vect int_vect")
#import time
#time.sleep(19)
self.expect('frame variable numbers',
substrs = ['item 0 is 1']);
# move on with synths
self.runCmd("type summary delete std::int_vect")
self.runCmd("type summary delete int_vect")
# add some more data
self.runCmd("c");
self.expect("frame variable numbers",
substrs = ['numbers = size=7',
'[0] = 1',
'[1] = 12',
'[2] = 123',
'[3] = 1234',
'[4] = 12345',
'[5] = 123456',
'[6] = 1234567',
'}'])
self.expect("p numbers",
substrs = ['$', 'size=7',
'[0] = 1',
'[1] = 12',
'[2] = 123',
'[3] = 1234',
'[4] = 12345',
'[5] = 123456',
'[6] = 1234567',
'}'])
# check access-by-index
self.expect("frame variable numbers[0]",
substrs = ['1']);
self.expect("frame variable numbers[1]",
substrs = ['12']);
self.expect("frame variable numbers[2]",
substrs = ['123']);
self.expect("frame variable numbers[3]",
substrs = ['1234']);
# but check that expression does not rely on us
# (when expression gets to call into STL code correctly, we will have to find
# another way to check this)
self.expect("expression numbers[6]", matching=False, error=True,
substrs = ['1234567'])
# check that MightHaveChildren() gets it right
self.assertTrue(self.frame().FindVariable("numbers").MightHaveChildren(), "numbers.MightHaveChildren() says False for non empty!")
# clear out the vector and see that we do the right thing once again
self.runCmd("c")
self.expect("frame variable numbers",
substrs = ['numbers = size=0'])
self.runCmd("c")
# first value added
self.expect("frame variable numbers",
substrs = ['numbers = size=1',
'[0] = 7',
'}'])
# check if we can display strings
self.runCmd("c")
self.expect("frame variable strings",
substrs = ['goofy',
'is',
'smart'])
self.expect("p strings",
substrs = ['goofy',
'is',
'smart'])
# test summaries based on synthetic children
self.runCmd("type summary add std::string_vect string_vect --summary-string \"vector has ${svar%#} items\" -e")
self.expect("frame variable strings",
substrs = ['vector has 3 items',
'goofy',
'is',
'smart'])
self.expect("p strings",
substrs = ['vector has 3 items',
'goofy',
'is',
'smart'])
self.runCmd("c");
self.expect("frame variable strings",
substrs = ['vector has 4 items'])
# check access-by-index
self.expect("frame variable strings[0]",
substrs = ['goofy']);
self.expect("frame variable strings[1]",
substrs = ['is']);
# but check that expression does not rely on us
# (when expression gets to call into STL code correctly, we will have to find
# another way to check this)
self.expect("expression strings[0]", matching=False, error=True,
substrs = ['goofy'])
# check that MightHaveChildren() gets it right
self.assertTrue(self.frame().FindVariable("strings").MightHaveChildren(), "strings.MightHaveChildren() says False for non empty!")
self.runCmd("c")
self.expect("frame variable strings",
substrs = ['vector has 0 items'])
def data_formatter_commands(self):
"""Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_source_regexp(
self, "Set break point at this line.")
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint.
self.expect("thread list",
STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped', 'stop reason = breakpoint'])
# This is the function to remove the custom formats in order to have a
# clean slate for the next test case.
def cleanup():
self.runCmd('type format clear', check=False)
self.runCmd('type summary clear', check=False)
self.runCmd('type filter clear', check=False)
self.runCmd('type synth clear', check=False)
self.runCmd("settings set target.max-children-count 256",
check=False)
# Execute the cleanup function during test case tear down.
self.addTearDownHook(cleanup)
self.expect('image list', substrs=self.getLibcPlusPlusLibs())
self.runCmd("frame variable ii --show-types")
self.expect('frame variable ii', substrs=['size=0', '{}'])
self.runCmd("continue")
self.expect('frame variable ii',
substrs=[
'size=2', '[0] = ', 'first = 0', 'second = 0',
'[1] = ', 'first = 1', 'second = 1'
])
self.runCmd("continue")
self.expect('frame variable ii',
substrs=[
'size=4', '[2] = ', 'first = 2', 'second = 0',
'[3] = ', 'first = 3', 'second = 1'
])
self.runCmd("continue")
self.expect("frame variable ii",
substrs=[
'size=8', '[5] = ', 'first = 5', 'second = 0',
'[7] = ', 'first = 7', 'second = 1'
])
self.expect("p ii",
substrs=[
'size=8', '[5] = ', 'first = 5', 'second = 0',
'[7] = ', 'first = 7', 'second = 1'
])
# check access-by-index
self.expect("frame variable ii[0]",
substrs=['first = 0', 'second = 0'])
self.expect("frame variable ii[3]", substrs=['first =', 'second ='])
# check that MightHaveChildren() gets it right
self.assertTrue(self.frame().FindVariable("ii").MightHaveChildren(),
"ii.MightHaveChildren() says False for non empty!")
# check that the expression parser does not make use of
# synthetic children instead of running code
# TOT clang has a fix for this, which makes the expression command here succeed
# since this would make the test fail or succeed depending on clang version in use
# this is safer commented for the time being
#self.expect("expression ii[8]", matching=False, error=True,
# substrs = ['1234567'])
self.runCmd("continue")
self.expect('frame variable ii', substrs=['size=0', '{}'])
self.runCmd("frame variable si --show-types")
self.expect('frame variable si', substrs=['size=0', '{}'])
self.runCmd("continue")
self.expect(
'frame variable si',
substrs=['size=1', '[0] = ', 'first = \"zero\"', 'second = 0'])
self.runCmd("continue")
self.expect("frame variable si",
substrs=[
'size=4', '[0] = ', 'first = \"zero\"', 'second = 0',
'[1] = ', 'first = \"one\"', 'second = 1', '[2] = ',
'first = \"two\"', 'second = 2', '[3] = ',
'first = \"three\"', 'second = 3'
])
self.expect("p si",
substrs=[
'size=4', '[0] = ', 'first = \"zero\"', 'second = 0',
'[1] = ', 'first = \"one\"', 'second = 1', '[2] = ',
'first = \"two\"', 'second = 2', '[3] = ',
'first = \"three\"', 'second = 3'
])
# check that MightHaveChildren() gets it right
self.assertTrue(self.frame().FindVariable("si").MightHaveChildren(),
"si.MightHaveChildren() says False for non empty!")
# check access-by-index
self.expect("frame variable si[0]",
substrs=['first = ', 'one', 'second = 1'])
# check that the expression parser does not make use of
# synthetic children instead of running code
# TOT clang has a fix for this, which makes the expression command here succeed
# since this would make the test fail or succeed depending on clang version in use
# this is safer commented for the time being
#self.expect("expression si[0]", matching=False, error=True,
# substrs = ['first = ', 'zero'])
self.runCmd("continue")
self.expect('frame variable si', substrs=['size=0', '{}'])
self.runCmd("continue")
self.runCmd("frame variable is --show-types")
self.expect('frame variable is', substrs=['size=0', '{}'])
self.runCmd("continue")
self.expect("frame variable is",
substrs=[
'size=4', '[0] = ', 'second = \"goofy\"', 'first = 85',
'[1] = ', 'second = \"is\"', 'first = 1', '[2] = ',
'second = \"smart\"', 'first = 2', '[3] = ',
'second = \"!!!\"', 'first = 3'
])
self.expect("p is",
substrs=[
'size=4', '[0] = ', 'second = \"goofy\"', 'first = 85',
'[1] = ', 'second = \"is\"', 'first = 1', '[2] = ',
'second = \"smart\"', 'first = 2', '[3] = ',
'second = \"!!!\"', 'first = 3'
])
# check that MightHaveChildren() gets it right
self.assertTrue(self.frame().FindVariable("is").MightHaveChildren(),
"is.MightHaveChildren() says False for non empty!")
# check access-by-index
self.expect("frame variable is[0]", substrs=['first = ', 'second ='])
# check that the expression parser does not make use of
# synthetic children instead of running code
# TOT clang has a fix for this, which makes the expression command here succeed
# since this would make the test fail or succeed depending on clang version in use
# this is safer commented for the time being
#self.expect("expression is[0]", matching=False, error=True,
# substrs = ['first = ', 'goofy'])
self.runCmd("continue")
self.expect('frame variable is', substrs=['size=0', '{}'])
self.runCmd("continue")
self.runCmd("frame variable ss --show-types")
self.expect('frame variable ss', substrs=['size=0', '{}'])
self.runCmd("continue")
self.expect("frame variable ss",
substrs=[
'size=3', '[0] = ', 'second = \"hello\"',
'first = \"ciao\"', '[1] = ', 'second = \"house\"',
'first = \"casa\"', '[2] = ', 'second = \"cat\"',
'first = \"gatto\"'
])
self.expect("p ss",
substrs=[
'size=3', '[0] = ', 'second = \"hello\"',
'first = \"ciao\"', '[1] = ', 'second = \"house\"',
'first = \"casa\"', '[2] = ', 'second = \"cat\"',
'first = \"gatto\"'
])
# check that MightHaveChildren() gets it right
self.assertTrue(self.frame().FindVariable("ss").MightHaveChildren(),
"ss.MightHaveChildren() says False for non empty!")
# check access-by-index
self.expect("frame variable ss[2]", substrs=['gatto', 'cat'])
# check that the expression parser does not make use of
# synthetic children instead of running code
# TOT clang has a fix for this, which makes the expression command here succeed
# since this would make the test fail or succeed depending on clang version in use
# this is safer commented for the time being
#self.expect("expression ss[3]", matching=False, error=True,
# substrs = ['gatto'])
self.runCmd("continue")
self.expect('frame variable ss', substrs=['size=0', '{}'])
def breakpoint_command_sequence(self):
"""Test a sequence of breakpoint command add, list, and delete."""
exe = os.path.join(os.getcwd(), "a.out")
self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
# Add three breakpoints on the same line. The first time we don't specify the file,
# since the default file is the one containing main:
lldbutil.run_break_set_by_file_and_line(self, None, self.line, num_expected_locations=1, loc_exact=True)
lldbutil.run_break_set_by_file_and_line(self, "main.c", self.line, num_expected_locations=1, loc_exact=True)
lldbutil.run_break_set_by_file_and_line(self, "main.c", self.line, num_expected_locations=1, loc_exact=True)
# Now add callbacks for the breakpoints just created.
self.runCmd("breakpoint command add -s command -o 'frame variable --show-types --scope' 1")
self.runCmd(
'breakpoint command add -s python -o \'here = open("output.txt", "w"); print >> here, "lldb"; here.close()\' 2'
)
self.runCmd("breakpoint command add --python-function bktptcmd.function 3")
# Check that the breakpoint commands are correctly set.
# The breakpoint list now only contains breakpoint 1.
self.expect(
"breakpoint list",
"Breakpoints 1 & 2 created",
substrs=[
"1: file ='main.c', line = %d, locations = 1" % self.line,
"2: file ='main.c', line = %d, locations = 1" % self.line,
],
)
self.expect(
"breakpoint list -f",
"Breakpoints 1 & 2 created",
substrs=[
"1: file ='main.c', line = %d, locations = 1" % self.line,
"2: file ='main.c', line = %d, locations = 1" % self.line,
],
patterns=[
"1.1: .+at main.c:%d, .+unresolved, hit count = 0" % self.line,
"2.1: .+at main.c:%d, .+unresolved, hit count = 0" % self.line,
],
)
self.expect(
"breakpoint command list 1",
"Breakpoint 1 command ok",
substrs=["Breakpoint commands:", "frame variable --show-types --scope"],
)
self.expect(
"breakpoint command list 2",
"Breakpoint 2 command ok",
substrs=["Breakpoint commands:", "here = open", "print >> here", "here.close()"],
)
self.expect(
"breakpoint command list 3",
"Breakpoint 3 command ok",
substrs=["Breakpoint commands:", "bktptcmd.function(frame, bp_loc, internal_dict)"],
)
self.runCmd("command script import --allow-reload ./bktptcmd.py")
# Next lets try some other breakpoint kinds. First break with a regular expression
# and then specify only one file. The first time we should get two locations,
# the second time only one:
lldbutil.run_break_set_by_regexp(self, r"._MyFunction", num_expected_locations=2)
lldbutil.run_break_set_by_regexp(self, r"._MyFunction", extra_options="-f a.c", num_expected_locations=1)
lldbutil.run_break_set_by_regexp(self, r"._MyFunction", extra_options="-f a.c -f b.c", num_expected_locations=2)
# Now try a source regex breakpoint:
lldbutil.run_break_set_by_source_regexp(
self, r"is about to return [12]0", extra_options="-f a.c -f b.c", num_expected_locations=2
)
lldbutil.run_break_set_by_source_regexp(
self, r"is about to return [12]0", extra_options="-f a.c", num_expected_locations=1
)
# Run the program. Remove 'output.txt' if it exists.
self.RemoveTempFile("output.txt")
self.RemoveTempFile("output2.txt")
self.runCmd("run", RUN_SUCCEEDED)
# Check that the file 'output.txt' exists and contains the string "lldb".
# The 'output.txt' file should now exist.
self.assertTrue(os.path.isfile("output.txt"), "'output.txt' exists due to breakpoint command for breakpoint 2.")
self.assertTrue(
os.path.isfile("output2.txt"), "'output2.txt' exists due to breakpoint command for breakpoint 3."
)
# Read the output file produced by running the program.
with open("output.txt", "r") as f:
output = f.read()
self.expect(output, "File 'output.txt' and the content matches", exe=False, startstr="lldb")
with open("output2.txt", "r") as f:
output = f.read()
self.expect(output, "File 'output2.txt' and the content matches", exe=False, startstr="lldb")
# Finish the program.
self.runCmd("process continue")
# Remove the breakpoint command associated with breakpoint 1.
self.runCmd("breakpoint command delete 1")
# Remove breakpoint 2.
self.runCmd("breakpoint delete 2")
self.expect("breakpoint command list 1", startstr="Breakpoint 1 does not have an associated command.")
self.expect(
"breakpoint command list 2", error=True, startstr="error: '2' is not a currently valid breakpoint id."
)
# The breakpoint list now only contains breakpoint 1.
self.expect(
"breakpoint list -f",
"Breakpoint 1 exists",
substrs=["1: file ='main.c', line = %d, locations = 1, resolved = 1" % self.line, "hit count = 1"],
)
# Not breakpoint 2.
self.expect(
"breakpoint list -f",
"No more breakpoint 2",
matching=False,
substrs=["2: file ='main.c', line = %d, locations = 1, resolved = 1" % self.line],
)
# Run the program again, with breakpoint 1 remaining.
self.runCmd("run", RUN_SUCCEEDED)
# We should be stopped again due to breakpoint 1.
# The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, substrs=["stopped", "stop reason = breakpoint"])
# The breakpoint should have a hit count of 2.
self.expect("breakpoint list -f", BREAKPOINT_HIT_TWICE, substrs=["resolved, hit count = 2"])
def test_with_run_command(self):
"""Check that types only get completed when necessary."""
self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_source_regexp (self, "// Set break point at this line.")
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped',
'stop reason = breakpoint'])
# This is the function to remove the custom formats in order to have a
# clean slate for the next test case.
def cleanup():
self.runCmd('type category enable -l c++', check=False)
self.runCmd('type category disable -l c++', check=False)
# Execute the cleanup function during test case tear down.
self.addTearDownHook(cleanup)
p_vector = self.dbg.GetSelectedTarget().GetProcess().GetSelectedThread().GetSelectedFrame().FindVariable('p')
p_type = p_vector.GetType()
self.assertFalse(p_type.IsTypeComplete(), 'vector<T> complete but it should not be')
self.runCmd("continue")
p_vector = self.dbg.GetSelectedTarget().GetProcess().GetSelectedThread().GetSelectedFrame().FindVariable('p')
p_type = p_vector.GetType()
self.assertFalse(p_type.IsTypeComplete(), 'vector<T> complete but it should not be')
self.runCmd("continue")
self.runCmd("frame variable p --show-types")
p_vector = self.dbg.GetSelectedTarget().GetProcess().GetSelectedThread().GetSelectedFrame().FindVariable('p')
p_type = p_vector.GetType()
self.assertTrue(p_type.IsTypeComplete(), 'vector<T> should now be complete')
name_address_type = p_type.GetTemplateArgumentType(0)
self.assertTrue(name_address_type.IsValid(), 'NameAndAddress should be valid')
self.assertFalse(name_address_type.IsTypeComplete(), 'NameAndAddress complete but it should not be')
self.runCmd("continue")
self.runCmd("frame variable guy --show-types")
p_vector = self.dbg.GetSelectedTarget().GetProcess().GetSelectedThread().GetSelectedFrame().FindVariable('p')
p_type = p_vector.GetType()
self.assertTrue(p_type.IsTypeComplete(), 'vector<T> should now be complete')
name_address_type = p_type.GetTemplateArgumentType(0)
self.assertTrue(name_address_type.IsValid(), 'NameAndAddress should be valid')
self.assertTrue(name_address_type.IsTypeComplete(), 'NameAndAddress should now be complete')
field0 = name_address_type.GetFieldAtIndex(0)
if self.TraceOn():
print('field0: ' + str(field0))
self.assertTrue(field0.IsValid(), 'NameAndAddress::m_name should be valid')
string = field0.GetType().GetPointeeType()
if self.TraceOn():
print('string: ' + str(string))
self.assertTrue(string.IsValid(), 'std::string should be valid')
self.assertFalse(string.IsTypeComplete(), 'std::string complete but it should not be')
self.runCmd("continue")
p_vector = self.dbg.GetSelectedTarget().GetProcess().GetSelectedThread().GetSelectedFrame().FindVariable('p')
p_type = p_vector.GetType()
self.assertTrue(p_type.IsTypeComplete(), 'vector<T> should now be complete')
name_address_type = p_type.GetTemplateArgumentType(0)
self.assertTrue(name_address_type.IsValid(), 'NameAndAddress should be valid')
self.assertTrue(name_address_type.IsTypeComplete(), 'NameAndAddress should now be complete')
field0 = name_address_type.GetFieldAtIndex(0)
if self.TraceOn():
print('field0: ' + str(field0))
self.assertTrue(field0.IsValid(), 'NameAndAddress::m_name should be valid')
string = field0.GetType().GetPointeeType()
if self.TraceOn():
print('string: ' + str(string))
self.assertTrue(string.IsValid(), 'std::string should be valid')
self.assertFalse(string.IsTypeComplete(), 'std::string complete but it should not be')
self.runCmd('type category enable -l c++', check=False)
self.runCmd('frame variable guy --show-types')
p_vector = self.dbg.GetSelectedTarget().GetProcess().GetSelectedThread().GetSelectedFrame().FindVariable('p')
p_type = p_vector.GetType()
self.assertTrue(p_type.IsTypeComplete(), 'vector<T> should now be complete')
name_address_type = p_type.GetTemplateArgumentType(0)
self.assertTrue(name_address_type.IsValid(), 'NameAndAddress should be valid')
self.assertTrue(name_address_type.IsTypeComplete(), 'NameAndAddress should now be complete')
field0 = name_address_type.GetFieldAtIndex(0)
self.assertTrue(field0.IsValid(), 'NameAndAddress::m_name should be valid')
string = field0.GetType().GetPointeeType()
self.assertTrue(string.IsValid(), 'std::string should be valid')
self.assertTrue(string.IsTypeComplete(), 'std::string should now be complete')
def type_completion_commands(self):
"""Check that types only get completed when necessary."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_source_regexp(
self, "// Set break point at this line.")
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint.
self.expect("thread list",
STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped', 'stop reason = breakpoint'])
# This is the function to remove the custom formats in order to have a
# clean slate for the next test case.
def cleanup():
self.runCmd('type category enable gnu-libstdc++', check=False)
self.runCmd('type category enable libcxx', check=False)
self.runCmd('type category disable gnu-libstdc++', check=False)
self.runCmd('type category disable libcxx', check=False)
# Execute the cleanup function during test case tear down.
self.addTearDownHook(cleanup)
p_vector = self.dbg.GetSelectedTarget().GetProcess().GetSelectedThread(
).GetSelectedFrame().FindVariable('p')
p_type = p_vector.GetType()
self.assertFalse(p_type.IsTypeComplete(),
'vector<T> complete but it should not be')
self.runCmd("continue")
p_vector = self.dbg.GetSelectedTarget().GetProcess().GetSelectedThread(
).GetSelectedFrame().FindVariable('p')
p_type = p_vector.GetType()
self.assertFalse(p_type.IsTypeComplete(),
'vector<T> complete but it should not be')
self.runCmd("continue")
self.runCmd("frame variable p --show-types")
p_vector = self.dbg.GetSelectedTarget().GetProcess().GetSelectedThread(
).GetSelectedFrame().FindVariable('p')
p_type = p_vector.GetType()
self.assertTrue(p_type.IsTypeComplete(),
'vector<T> should now be complete')
name_address_type = p_type.GetTemplateArgumentType(0)
self.assertTrue(name_address_type.IsValid(),
'NameAndAddress should be valid')
self.assertFalse(name_address_type.IsTypeComplete(),
'NameAndAddress complete but it should not be')
self.runCmd("continue")
self.runCmd("frame variable guy --show-types")
p_vector = self.dbg.GetSelectedTarget().GetProcess().GetSelectedThread(
).GetSelectedFrame().FindVariable('p')
p_type = p_vector.GetType()
self.assertTrue(p_type.IsTypeComplete(),
'vector<T> should now be complete')
name_address_type = p_type.GetTemplateArgumentType(0)
self.assertTrue(name_address_type.IsValid(),
'NameAndAddress should be valid')
self.assertTrue(name_address_type.IsTypeComplete(),
'NameAndAddress should now be complete')
field0 = name_address_type.GetFieldAtIndex(0)
if self.TraceOn():
print 'field0: ' + str(field0)
self.assertTrue(field0.IsValid(),
'NameAndAddress::m_name should be valid')
string = field0.GetType().GetPointeeType()
if self.TraceOn():
print 'string: ' + str(string)
self.assertTrue(string.IsValid(), 'std::string should be valid')
self.assertFalse(string.IsTypeComplete(),
'std::string complete but it should not be')
self.runCmd("continue")
p_vector = self.dbg.GetSelectedTarget().GetProcess().GetSelectedThread(
).GetSelectedFrame().FindVariable('p')
p_type = p_vector.GetType()
self.assertTrue(p_type.IsTypeComplete(),
'vector<T> should now be complete')
name_address_type = p_type.GetTemplateArgumentType(0)
self.assertTrue(name_address_type.IsValid(),
'NameAndAddress should be valid')
self.assertTrue(name_address_type.IsTypeComplete(),
'NameAndAddress should now be complete')
field0 = name_address_type.GetFieldAtIndex(0)
if self.TraceOn():
print 'field0: ' + str(field0)
self.assertTrue(field0.IsValid(),
'NameAndAddress::m_name should be valid')
string = field0.GetType().GetPointeeType()
if self.TraceOn():
print 'string: ' + str(string)
self.assertTrue(string.IsValid(), 'std::string should be valid')
self.assertFalse(string.IsTypeComplete(),
'std::string complete but it should not be')
self.runCmd('type category enable gnu-libstdc++', check=False)
self.runCmd('type category enable libcxx', check=False)
self.runCmd('frame variable guy --show-types')
p_vector = self.dbg.GetSelectedTarget().GetProcess().GetSelectedThread(
).GetSelectedFrame().FindVariable('p')
p_type = p_vector.GetType()
self.assertTrue(p_type.IsTypeComplete(),
'vector<T> should now be complete')
name_address_type = p_type.GetTemplateArgumentType(0)
self.assertTrue(name_address_type.IsValid(),
'NameAndAddress should be valid')
self.assertTrue(name_address_type.IsTypeComplete(),
'NameAndAddress should now be complete')
field0 = name_address_type.GetFieldAtIndex(0)
self.assertTrue(field0.IsValid(),
'NameAndAddress::m_name should be valid')
string = field0.GetType().GetPointeeType()
self.assertTrue(string.IsValid(), 'std::string should be valid')
self.assertTrue(string.IsTypeComplete(),
'std::string should now be complete')
def data_formatter_commands(self):
"""Test that that file and class static variables display correctly."""
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
bkpt = self.target().FindBreakpointByID(
lldbutil.run_break_set_by_source_regexp(self, "break here"))
self.runCmd("run", RUN_SUCCEEDED)
# The stop reason of the thread should be breakpoint.
self.expect("thread list",
STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped', 'stop reason = breakpoint'])
# This is the function to remove the custom formats in order to have a
# clean slate for the next test case.
def cleanup():
self.runCmd('type format clear', check=False)
self.runCmd('type summary clear', check=False)
self.runCmd('type filter clear', check=False)
self.runCmd('type synth clear', check=False)
self.runCmd("settings set target.max-children-count 256",
check=False)
# Execute the cleanup function during test case tear down.
self.addTearDownHook(cleanup)
# empty vectors (and storage pointers SHOULD BOTH BE NULL..)
self.expect("frame variable numbers", substrs=['numbers = size=0'])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
# first value added
self.expect("frame variable numbers",
substrs=['numbers = size=1', '[0] = 1', '}'])
# add some more data
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect("frame variable numbers",
substrs=[
'numbers = size=4', '[0] = 1', '[1] = 12', '[2] = 123',
'[3] = 1234', '}'
])
self.expect("p numbers",
substrs=[
'$', 'size=4', '[0] = 1', '[1] = 12', '[2] = 123',
'[3] = 1234', '}'
])
# check access to synthetic children
self.runCmd(
"type summary add --summary-string \"item 0 is ${var[0]}\" std::int_vect int_vect"
)
self.expect('frame variable numbers', substrs=['item 0 is 1'])
self.runCmd(
"type summary add --summary-string \"item 0 is ${svar[0]}\" std::int_vect int_vect"
)
self.expect('frame variable numbers', substrs=['item 0 is 1'])
# move on with synths
self.runCmd("type summary delete std::int_vect")
self.runCmd("type summary delete int_vect")
# add some more data
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect("frame variable numbers",
substrs=[
'numbers = size=7', '[0] = 1', '[1] = 12', '[2] = 123',
'[3] = 1234', '[4] = 12345', '[5] = 123456',
'[6] = 1234567', '}'
])
self.expect("p numbers",
substrs=[
'$', 'size=7', '[0] = 1', '[1] = 12', '[2] = 123',
'[3] = 1234', '[4] = 12345', '[5] = 123456',
'[6] = 1234567', '}'
])
# check access-by-index
self.expect("frame variable numbers[0]", substrs=['1'])
self.expect("frame variable numbers[1]", substrs=['12'])
self.expect("frame variable numbers[2]", substrs=['123'])
self.expect("frame variable numbers[3]", substrs=['1234'])
# clear out the vector and see that we do the right thing once again
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect("frame variable numbers", substrs=['numbers = size=0'])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
# first value added
self.expect("frame variable numbers",
substrs=['numbers = size=1', '[0] = 7', '}'])
# check if we can display strings
self.expect("frame variable strings", substrs=['goofy', 'is', 'smart'])
self.expect("p strings", substrs=['goofy', 'is', 'smart'])
# test summaries based on synthetic children
self.runCmd(
"type summary add std::string_vect string_vect --summary-string \"vector has ${svar%#} items\" -e"
)
self.expect("frame variable strings",
substrs=['vector has 3 items', 'goofy', 'is', 'smart'])
self.expect("p strings",
substrs=['vector has 3 items', 'goofy', 'is', 'smart'])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect("frame variable strings", substrs=['vector has 4 items'])
# check access-by-index
self.expect("frame variable strings[0]", substrs=['goofy'])
self.expect("frame variable strings[1]", substrs=['is'])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect("frame variable strings", substrs=['vector has 0 items'])
