def test(self):
"""Test that std::function as defined by libc++ is correctly printed by LLDB"""
self.build()
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)
lldbutil.skip_if_library_missing(
self, self.target(), lldbutil.PrintableRegex("libc\+\+"))
# The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped',
'stop reason = breakpoint'])
f1 = self.get_variable('f1')
f2 = self.get_variable('f2')
if self.TraceOn():
print(f1)
if self.TraceOn():
print(f2)
self.assertTrue(f1.GetValueAsUnsigned(0) != 0, 'f1 has a valid value')
self.assertTrue(f2.GetValueAsUnsigned(0) != 0, 'f2 has a valid value')
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.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1)
self.runCmd("run", RUN_SUCCEEDED)
lldbutil.skip_if_library_missing(self, self.target(), lldbutil.PrintableRegex("libc\+\+"))
# 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("frame variable",
substrs = ['(std::__1::wstring) s = L"hello world! מזל טוב!"',
'(std::__1::wstring) S = L"!!!!"',
'(const wchar_t *) mazeltov = 0x','L"מזל טוב"',
'(std::__1::string) q = "hello world"',
'(std::__1::string) Q = "quite a long std::strin with lots of info inside it"',
'(std::__1::string) IHaveEmbeddedZeros = "a\\0b\\0c\\0d"',
'(std::__1::wstring) IHaveEmbeddedZerosToo = L"hello world!\\0てざ ル゜䋨ミ㠧槊 きゅへ狦穤襩 じゃ馩リョ 䤦監"'])
self.runCmd("n")
TheVeryLongOne = self.frame().FindVariable("TheVeryLongOne");
summaryOptions = lldb.SBTypeSummaryOptions()
summaryOptions.SetCapping(lldb.eTypeSummaryUncapped)
uncappedSummaryStream = lldb.SBStream()
TheVeryLongOne.GetSummary(uncappedSummaryStream,summaryOptions)
uncappedSummary = uncappedSummaryStream.GetData()
self.assertTrue(uncappedSummary.find("someText") > 0, "uncappedSummary does not include the full string")
summaryOptions.SetCapping(lldb.eTypeSummaryCapped)
cappedSummaryStream = lldb.SBStream()
TheVeryLongOne.GetSummary(cappedSummaryStream,summaryOptions)
cappedSummary = cappedSummaryStream.GetData()
self.assertTrue(cappedSummary.find("someText") <= 0, "cappedSummary includes the full string")
self.expect("frame variable",
substrs = ['(std::__1::wstring) s = L"hello world! מזל טוב!"',
'(std::__1::wstring) S = L"!!!!!"',
'(const wchar_t *) mazeltov = 0x','L"מזל טוב"',
'(std::__1::string) q = "hello world"',
'(std::__1::string) Q = "quite a long std::strin with lots of info inside it"',
'(std::__1::string) IHaveEmbeddedZeros = "a\\0b\\0c\\0d"',
'(std::__1::wstring) IHaveEmbeddedZerosToo = L"hello world!\\0てざ ル゜䋨ミ㠧槊 きゅへ狦穤襩 じゃ馩リョ 䤦監"'])
def test(self):
"""Test that std::function as defined by libc++ is correctly printed by LLDB"""
self.build()
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)
lldbutil.skip_if_library_missing(self, self.target(),
lldbutil.PrintableRegex("libc\+\+"))
# The stop reason of the thread should be breakpoint.
self.expect("thread list",
STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped', 'stop reason = breakpoint'])
f1 = self.get_variable('f1')
f2 = self.get_variable('f2')
if self.TraceOn():
print(f1)
if self.TraceOn():
print(f2)
self.assertTrue(f1.GetValueAsUnsigned(0) != 0, 'f1 has a valid value')
self.assertTrue(f2.GetValueAsUnsigned(0) != 0, 'f2 has a valid value')
def test(self):
"""Test that that file and class static variables display correctly."""
self.build()
self.runCmd("file " + self.getBuildArtifact("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)
lldbutil.skip_if_library_missing(self, self.target(),
lldbutil.PrintableRegex("libc\+\+"))
# 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_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\+\+"))
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1)
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("frame variable vBool",
substrs = ['size=49','[0] = false','[1] = true','[18] = false','[27] = true','[36] = false','[47] = true','[48] = true'])
self.expect("expr vBool",
substrs = ['size=49','[0] = false','[1] = true','[18] = false','[27] = true','[36] = false','[47] = true','[48] = true'])
def test_with_run_command(self):
self.build()
exe = os.path.join(os.getcwd(), "a.out")
target = self.dbg.CreateTarget(exe)
self.assertTrue(target and target.IsValid(), "Target is valid")
file_spec = lldb.SBFileSpec ("main.cpp", False)
breakpoint1 = target.BreakpointCreateBySourceRegex('// Set break point at this line.', file_spec)
self.assertTrue(breakpoint1 and breakpoint1.IsValid())
breakpoint2 = target.BreakpointCreateBySourceRegex('// Set second break point at this line.', file_spec)
self.assertTrue(breakpoint2 and breakpoint2.IsValid())
# Run the program, it should stop at breakpoint 1.
process = target.LaunchSimple(None, None, self.get_process_working_directory())
lldbutil.skip_if_library_missing(self, target, lldbutil.PrintableRegex("libc\+\+"))
self.assertTrue(process and process.IsValid(), PROCESS_IS_VALID)
self.assertEqual(len(lldbutil.get_threads_stopped_at_breakpoint(process, breakpoint1)), 1)
# verify our list is displayed correctly
self.expect("frame variable *numbers_list", substrs=['[0] = 1', '[1] = 2', '[2] = 3', '[3] = 4', '[5] = 6'])
# Continue to breakpoint 2.
process.Continue()
self.assertTrue(process and process.IsValid(), PROCESS_IS_VALID)
self.assertEqual(len(lldbutil.get_threads_stopped_at_breakpoint(process, breakpoint2)), 1)
# The list is now inconsistent. However, we should be able to get the first three
# elements at least (and most importantly, not crash).
self.expect("frame variable *numbers_list", substrs=['[0] = 1', '[1] = 2', '[2] = 3'])
# Run to completion.
process.Continue()
self.assertEqual(process.GetState(), lldb.eStateExited, PROCESS_EXITED)
def test_with_run_command(self):
self.build()
exe = os.path.join(os.getcwd(), "a.out")
target = self.dbg.CreateTarget(exe)
self.assertTrue(target and target.IsValid(), "Target is valid")
file_spec = lldb.SBFileSpec ("main.cpp", False)
breakpoint1 = target.BreakpointCreateBySourceRegex('// Set break point at this line.', file_spec)
self.assertTrue(breakpoint1 and breakpoint1.IsValid())
breakpoint2 = target.BreakpointCreateBySourceRegex('// Set second break point at this line.', file_spec)
self.assertTrue(breakpoint2 and breakpoint2.IsValid())
# Run the program, it should stop at breakpoint 1.
process = target.LaunchSimple(None, None, self.get_process_working_directory())
lldbutil.skip_if_library_missing(self, target, lldbutil.PrintableRegex("libc\+\+"))
self.assertTrue(process and process.IsValid(), PROCESS_IS_VALID)
self.assertEqual(len(lldbutil.get_threads_stopped_at_breakpoint(process, breakpoint1)), 1)
# verify our list is displayed correctly
self.expect("frame variable *numbers_list", substrs=['[0] = 1', '[1] = 2', '[2] = 3', '[3] = 4', '[5] = 6'])
# Continue to breakpoint 2.
process.Continue()
self.assertTrue(process and process.IsValid(), PROCESS_IS_VALID)
self.assertEqual(len(lldbutil.get_threads_stopped_at_breakpoint(process, breakpoint2)), 1)
# The list is now inconsistent. However, we should be able to get the first three
# elements at least (and most importantly, not crash).
self.expect("frame variable *numbers_list", substrs=['[0] = 1', '[1] = 2', '[2] = 3'])
# Run to completion.
process.Continue()
self.assertEqual(process.GetState(), lldb.eStateExited, PROCESS_EXITED)
def test(self):
"""Test that std::atomic as defined by libc++ is correctly printed by LLDB"""
self.build()
self.runCmd("file " + self.getBuildArtifact("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)
lldbutil.skip_if_library_missing(
self, self.target(), lldbutil.PrintableRegex("libc\+\+"))
# The stop reason of the thread should be breakpoint.
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped',
'stop reason = breakpoint'])
s = self.get_variable('s')
i = self.get_variable('i')
if self.TraceOn():
print(s)
if self.TraceOn():
print(i)
self.assertTrue(i.GetValueAsUnsigned(0) == 5, "i == 5")
self.assertTrue(s.GetNumChildren() == 2, "s has two children")
self.assertTrue(
s.GetChildAtIndex(0).GetValueAsUnsigned(0) == 1,
"s.x == 1")
self.assertTrue(
s.GetChildAtIndex(1).GetValueAsUnsigned(0) == 2,
"s.y == 2")
def test(self):
"""Test that std::atomic as defined by libc++ is correctly printed by LLDB"""
self.build()
self.runCmd("file " + self.getBuildArtifact("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)
lldbutil.skip_if_library_missing(self, self.target(),
lldbutil.PrintableRegex("libc\+\+"))
# The stop reason of the thread should be breakpoint.
self.expect("thread list",
STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped', 'stop reason = breakpoint'])
s = self.get_variable('s')
i = self.get_variable('i')
if self.TraceOn():
print(s)
if self.TraceOn():
print(i)
self.assertTrue(i.GetValueAsUnsigned(0) == 5, "i == 5")
self.assertTrue(s.GetNumChildren() == 2, "s has two children")
self.assertTrue(
s.GetChildAtIndex(0).GetValueAsUnsigned(0) == 1, "s.x == 1")
self.assertTrue(
s.GetChildAtIndex(1).GetValueAsUnsigned(0) == 2, "s.y == 2")
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.run_break_set_by_source_regexp(
self, "Set break point at this line.")
self.runCmd("run", RUN_SUCCEEDED)
lldbutil.skip_if_library_missing(self, self.target(),
lldbutil.PrintableRegex("libc\+\+"))
# 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 {', '\[\d\] = 5', '\[\d\] = 3', '\[\d\] = 2'])
self.look_for_content_and_continue("sset", [
'size=5 {', '\[\d\] = "is"', '\[\d\] = "world"', '\[\d\] = "hello"'
])
self.look_for_content_and_continue("imset", [
'size=6 {', '(\[\d\] = 3(\\n|.)+){3}', '\[\d\] = 2', '\[\d\] = 1'
])
self.look_for_content_and_continue("smset", [
'size=5 {', '(\[\d\] = "is"(\\n|.)+){2}',
'(\[\d\] = "world"(\\n|.)+){2}'
])
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.run_break_set_by_source_regexp(
self, "Set break point at this line.")
self.runCmd("run", RUN_SUCCEEDED)
lldbutil.skip_if_library_missing(
self, self.target(), lldbutil.PrintableRegex("libc\+\+"))
# 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 {', '\[\d\] = 5', '\[\d\] = 3', '\[\d\] = 2'])
self.look_for_content_and_continue(
"sset", ['size=5 {', '\[\d\] = "is"', '\[\d\] = "world"',
'\[\d\] = "hello"'])
self.look_for_content_and_continue(
"imset", ['size=6 {', '(\[\d\] = 3(\\n|.)+){3}',
'\[\d\] = 2', '\[\d\] = 1'])
self.look_for_content_and_continue(
"smset",
['size=5 {', '(\[\d\] = "is"(\\n|.)+){2}',
'(\[\d\] = "world"(\\n|.)+){2}'])
def test_with_run_command(self):
"""Test that libc++ iterators format properly."""
self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.line, num_expected_locations=-1)
self.runCmd("run", RUN_SUCCEEDED)
lldbutil.skip_if_library_missing(
self, self.target(), lldbutil.PrintableRegex("libc\+\+"))
# 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 ivI', substrs=['item = 3'])
self.expect('expr ivI', substrs=['item = 3'])
self.expect(
'frame variable iimI',
substrs=[
'first = 0',
'second = 12'])
self.expect('expr iimI', substrs=['first = 0', 'second = 12'])
self.expect(
'frame variable simI',
substrs=[
'first = "world"',
'second = 42'])
self.expect('expr simI', substrs=['first = "world"', 'second = 42'])
self.expect('frame variable svI', substrs=['item = "hello"'])
self.expect('expr svI', substrs=['item = "hello"'])
def test(self):
"""Test that std::atomic as defined by libc++ is correctly printed by LLDB"""
self.build()
self.runCmd("file " + self.getBuildArtifact("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)
lldbutil.skip_if_library_missing(self, self.target(),
lldbutil.PrintableRegex("libc\+\+"))
# The stop reason of the thread should be breakpoint.
self.expect("thread list",
STOPPED_DUE_TO_BREAKPOINT,
substrs=['stopped', 'stop reason = breakpoint'])
s_atomic = self.get_variable('s')
i_atomic = self.get_variable('i')
if self.TraceOn():
print(s_atomic)
if self.TraceOn():
print(i_atomic)
# Extract the content of the std::atomic wrappers.
self.assertEqual(s_atomic.GetNumChildren(), 1)
s = s_atomic.GetChildAtIndex(0)
self.assertEqual(i_atomic.GetNumChildren(), 1)
i = i_atomic.GetChildAtIndex(0)
if self.TraceOn():
print(s)
if self.TraceOn():
print(i)
self.assertTrue(i.GetValueAsUnsigned(0) == 5, "i == 5")
self.assertTrue(s.GetNumChildren() == 2, "s has two children")
self.assertTrue(
s.GetChildAtIndex(0).GetValueAsUnsigned(0) == 1, "s.x == 1")
self.assertTrue(
s.GetChildAtIndex(1).GetValueAsUnsigned(0) == 2, "s.y == 2")
# Try printing the child that points to its own parent object.
# This should just treat the atomic pointer as a normal pointer.
self.expect("frame var p.child", substrs=["Value = 0x"])
self.expect("frame var p", substrs=["parent = {", "Value = 0x", "}"])
self.expect("frame var p.child.parent",
substrs=["p.child.parent = {\n Value = 0x"])
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)
bkpt = self.target().FindBreakpointByID(lldbutil.run_break_set_by_source_regexp (self, "Set break point at this line."))
self.runCmd("run", RUN_SUCCEEDED)
lldbutil.skip_if_library_missing(self, self.target(), lldbutil.PrintableRegex("libc\+\+"))
# 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 test_with_run_command(self):
"""Test that libc++ iterators format properly."""
self.build()
self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line(self,
"main.cpp",
self.line,
num_expected_locations=-1)
self.runCmd("run", RUN_SUCCEEDED)
lldbutil.skip_if_library_missing(self, self.target(),
lldbutil.PrintableRegex("libc\+\+"))
# 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 ivI', substrs=['item = 3'])
self.expect('expr ivI', substrs=['item = 3'])
self.expect('frame variable iimI',
substrs=['first = 0', 'second = 12'])
self.expect('expr iimI', substrs=['first = 0', 'second = 12'])
self.expect('frame variable simI',
substrs=['first = "world"', 'second = 42'])
self.expect('expr simI', substrs=['first = "world"', 'second = 42'])
self.expect('frame variable svI', substrs=['item = "hello"'])
self.expect('expr svI', substrs=['item = "hello"'])
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\+\+"))
lldbutil.run_break_set_by_file_and_line(self,
"main.cpp",
self.line,
num_expected_locations=-1)
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("frame variable vBool",
substrs=[
'size=49', '[0] = false', '[1] = true', '[18] = false',
'[27] = true', '[36] = false', '[47] = true',
'[48] = true'
])
self.expect("expr vBool",
substrs=[
'size=49', '[0] = false', '[1] = true', '[18] = false',
'[27] = true', '[36] = false', '[47] = true',
'[48] = true'
])
def test(self):
"""Test that that file and class static variables display correctly."""
self.build()
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)
lldbutil.skip_if_library_missing(self, self.target(), lldbutil.PrintableRegex("libc\+\+"))
# 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_with_run_command(self):
"""Test that that file and class static variables display correctly."""
self.build()
self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.line, num_expected_locations=-1)
lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.line2, num_expected_locations=-1)
lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.line3, num_expected_locations=-1)
lldbutil.run_break_set_by_file_and_line(
self, "main.cpp", self.line4, num_expected_locations=-1)
self.runCmd("run", RUN_SUCCEEDED)
lldbutil.skip_if_library_missing(
self, self.target(), lldbutil.PrintableRegex("libc\+\+"))
# 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.runCmd("frame variable numbers_list --show-types")
self.runCmd(
"type summary add std::int_list std::string_list int_list string_list --summary-string \"list has ${svar%#} items\" -e")
self.runCmd("type format add -f hex int")
self.expect("frame variable numbers_list --raw", matching=False,
substrs=['list has 0 items',
'{}'])
self.expect("frame variable numbers_list",
substrs=['list has 0 items',
'{}'])
self.expect("p numbers_list",
substrs=['list has 0 items',
'{}'])
self.runCmd("n") # This gets up past the printf
self.runCmd("n") # Now advance over the first push_back.
self.expect("frame variable numbers_list",
substrs=['list has 1 items',
'[0] = ',
'0x12345678'])
self.runCmd("n")
self.runCmd("n")
self.runCmd("n")
self.expect("frame variable numbers_list",
substrs=['list has 4 items',
'[0] = ',
'0x12345678',
'[1] =',
'0x11223344',
'[2] =',
'0xbeeffeed',
'[3] =',
'0x00abba00'])
self.runCmd("n")
self.runCmd("n")
self.expect("frame variable numbers_list",
substrs=['list has 6 items',
'[0] = ',
'0x12345678',
'0x11223344',
'0xbeeffeed',
'0x00abba00',
'[4] =',
'0x0abcdef0',
'[5] =',
'0x0cab0cab'])
self.expect("p numbers_list",
substrs=['list has 6 items',
'[0] = ',
'0x12345678',
'0x11223344',
'0xbeeffeed',
'0x00abba00',
'[4] =',
'0x0abcdef0',
'[5] =',
'0x0cab0cab'])
# check access-by-index
self.expect("frame variable numbers_list[0]",
substrs=['0x12345678'])
self.expect("frame variable numbers_list[1]",
substrs=['0x11223344'])
self.runCmd("n")
self.expect("frame variable numbers_list",
substrs=['list has 0 items',
'{}'])
self.runCmd("n")
self.runCmd("n")
self.runCmd("n")
self.runCmd("n")
self.expect("frame variable numbers_list",
substrs=['list has 4 items',
'[0] = ', '1',
'[1] = ', '2',
'[2] = ', '3',
'[3] = ', '4'])
ListPtr = self.frame().FindVariable("list_ptr")
self.assertTrue(ListPtr.GetChildAtIndex(
0).GetValueAsUnsigned(0) == 1, "[0] = 1")
# check that MightHaveChildren() gets it right
self.assertTrue(
self.frame().FindVariable("numbers_list").MightHaveChildren(),
"numbers_list.MightHaveChildren() says False for non empty!")
self.runCmd("type format delete int")
self.runCmd("c")
self.expect("frame variable text_list",
substrs=['list has 3 items',
'[0]', 'goofy',
'[1]', 'is',
'[2]', 'smart'])
# check that MightHaveChildren() gets it right
self.assertTrue(
self.frame().FindVariable("text_list").MightHaveChildren(),
"text_list.MightHaveChildren() says False for non empty!")
self.expect("p text_list",
substrs=['list has 3 items',
'\"goofy\"',
'\"is\"',
'\"smart\"'])
self.runCmd("n") # This gets us past the printf
self.runCmd("n")
self.runCmd("n")
# check access-by-index
self.expect("frame variable text_list[0]",
substrs=['goofy'])
self.expect("frame variable text_list[3]",
substrs=['!!!'])
self.runCmd("continue")
# check that the list provider correctly updates if elements move
countingList = self.frame().FindVariable("countingList")
countingList.SetPreferDynamicValue(True)
countingList.SetPreferSyntheticValue(True)
self.assertTrue(countingList.GetChildAtIndex(
0).GetValueAsUnsigned(0) == 3141, "list[0] == 3141")
self.assertTrue(countingList.GetChildAtIndex(
1).GetValueAsUnsigned(0) == 3141, "list[1] == 3141")
self.runCmd("continue")
self.assertEqual(
countingList.GetChildAtIndex(0).GetValueAsUnsigned(0), 3141,
"uniqued list[0] == 3141")
self.assertEqual(
countingList.GetChildAtIndex(1).GetValueAsUnsigned(0), 3142,
"uniqued list[1] == 3142")
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, "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 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)
bkpt = self.target().FindBreakpointByID(
lldbutil.run_break_set_by_source_regexp(
self, "Set break point at this line."))
self.runCmd("run", RUN_SUCCEEDED)
lldbutil.skip_if_library_missing(self, self.target(),
lldbutil.PrintableRegex("libc\+\+"))
# 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'])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect('frame variable ii', substrs=['size=0', '{}'])
self.expect('frame variable si', substrs=['size=0', '{}'])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
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.run_break_set_by_file_and_line(self,
"main.cpp",
self.line,
num_expected_locations=-1)
self.runCmd("run", RUN_SUCCEEDED)
lldbutil.skip_if_library_missing(self, self.target(),
lldbutil.PrintableRegex("libc\+\+"))
# 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(
"frame variable",
substrs=[
'(std::__1::wstring) s = L"hello world! מזל טוב!"',
'(std::__1::wstring) S = L"!!!!"',
'(const wchar_t *) mazeltov = 0x', 'L"מזל טוב"',
'(std::__1::string) q = "hello world"',
'(std::__1::string) Q = "quite a long std::strin with lots of info inside it"',
'(std::__1::string) IHaveEmbeddedZeros = "a\\0b\\0c\\0d"',
'(std::__1::wstring) IHaveEmbeddedZerosToo = L"hello world!\\0てざ ル゜䋨ミ㠧槊 きゅへ狦穤襩 じゃ馩リョ 䤦監"'
])
self.runCmd("n")
TheVeryLongOne = self.frame().FindVariable("TheVeryLongOne")
summaryOptions = lldb.SBTypeSummaryOptions()
summaryOptions.SetCapping(lldb.eTypeSummaryUncapped)
uncappedSummaryStream = lldb.SBStream()
TheVeryLongOne.GetSummary(uncappedSummaryStream, summaryOptions)
uncappedSummary = uncappedSummaryStream.GetData()
self.assertTrue(
uncappedSummary.find("someText") > 0,
"uncappedSummary does not include the full string")
summaryOptions.SetCapping(lldb.eTypeSummaryCapped)
cappedSummaryStream = lldb.SBStream()
TheVeryLongOne.GetSummary(cappedSummaryStream, summaryOptions)
cappedSummary = cappedSummaryStream.GetData()
self.assertTrue(
cappedSummary.find("someText") <= 0,
"cappedSummary includes the full string")
self.expect(
"frame variable",
substrs=[
'(std::__1::wstring) s = L"hello world! מזל טוב!"',
'(std::__1::wstring) S = L"!!!!!"',
'(const wchar_t *) mazeltov = 0x', 'L"מזל טוב"',
'(std::__1::string) q = "hello world"',
'(std::__1::string) Q = "quite a long std::strin with lots of info inside it"',
'(std::__1::string) IHaveEmbeddedZeros = "a\\0b\\0c\\0d"',
'(std::__1::wstring) IHaveEmbeddedZerosToo = L"hello world!\\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)
bkpt = self.target().FindBreakpointByID(
lldbutil.run_break_set_by_source_regexp(
self, "Set break point at this line."))
self.runCmd("run", RUN_SUCCEEDED)
lldbutil.skip_if_library_missing(
self, self.target(), lldbutil.PrintableRegex("libc\+\+"))
# 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, "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 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.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line2, num_expected_locations=-1)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line3, num_expected_locations=-1)
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line4, num_expected_locations=-1)
self.runCmd("run", RUN_SUCCEEDED)
lldbutil.skip_if_library_missing(self, self.target(), lldbutil.PrintableRegex("libc\+\+"))
# 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.runCmd("frame variable numbers_list --show-types")
self.runCmd("type summary add std::int_list std::string_list int_list string_list --summary-string \"list has ${svar%#} items\" -e")
self.runCmd("type format add -f hex int")
self.expect("frame variable numbers_list --raw", matching=False,
substrs = ['list has 0 items',
'{}'])
self.expect("frame variable numbers_list",
substrs = ['list has 0 items',
'{}'])
self.expect("p numbers_list",
substrs = ['list has 0 items',
'{}'])
self.runCmd("n")
self.expect("frame variable numbers_list",
substrs = ['list has 1 items',
'[0] = ',
'0x12345678'])
self.runCmd("n");self.runCmd("n");self.runCmd("n");
self.expect("frame variable numbers_list",
substrs = ['list has 4 items',
'[0] = ',
'0x12345678',
'[1] =',
'0x11223344',
'[2] =',
'0xbeeffeed',
'[3] =',
'0x00abba00'])
self.runCmd("n");self.runCmd("n");
self.expect("frame variable numbers_list",
substrs = ['list has 6 items',
'[0] = ',
'0x12345678',
'0x11223344',
'0xbeeffeed',
'0x00abba00',
'[4] =',
'0x0abcdef0',
'[5] =',
'0x0cab0cab'])
self.expect("p numbers_list",
substrs = ['list has 6 items',
'[0] = ',
'0x12345678',
'0x11223344',
'0xbeeffeed',
'0x00abba00',
'[4] =',
'0x0abcdef0',
'[5] =',
'0x0cab0cab'])
# check access-by-index
self.expect("frame variable numbers_list[0]",
substrs = ['0x12345678']);
self.expect("frame variable numbers_list[1]",
substrs = ['0x11223344']);
self.runCmd("n")
self.expect("frame variable numbers_list",
substrs = ['list has 0 items',
'{}'])
self.runCmd("n");self.runCmd("n");self.runCmd("n");self.runCmd("n");
self.expect("frame variable numbers_list",
substrs = ['list has 4 items',
'[0] = ', '1',
'[1] = ', '2',
'[2] = ', '3',
'[3] = ', '4'])
# check that MightHaveChildren() gets it right
self.assertTrue(self.frame().FindVariable("numbers_list").MightHaveChildren(), "numbers_list.MightHaveChildren() says False for non empty!")
self.runCmd("type format delete int")
self.runCmd("c")
self.expect("frame variable text_list",
substrs = ['list has 3 items',
'[0]', 'goofy',
'[1]', 'is',
'[2]', 'smart'])
# check that MightHaveChildren() gets it right
self.assertTrue(self.frame().FindVariable("text_list").MightHaveChildren(), "text_list.MightHaveChildren() says False for non empty!")
self.expect("p text_list",
substrs = ['list has 3 items',
'\"goofy\"',
'\"is\"',
'\"smart\"'])
self.runCmd("n")
# check access-by-index
self.expect("frame variable text_list[0]",
substrs = ['goofy']);
self.expect("frame variable text_list[3]",
substrs = ['!!!']);
self.runCmd("continue")
# check that the list provider correctly updates if elements move
countingList = self.frame().FindVariable("countingList")
countingList.SetPreferDynamicValue(True)
countingList.SetPreferSyntheticValue(True)
self.assertTrue(countingList.GetChildAtIndex(0).GetValueAsUnsigned(0) == 3141, "list[0] == 3141")
self.assertTrue(countingList.GetChildAtIndex(1).GetValueAsUnsigned(0) == 3141, "list[1] == 3141")
self.runCmd("continue")
self.assertTrue(countingList.GetChildAtIndex(0).GetValueAsUnsigned(0) == 3141, "uniqued list[0] == 3141")
self.assertTrue(countingList.GetChildAtIndex(1).GetValueAsUnsigned(0) == 3142, "uniqued list[1] == 3142")
