def test_with_run_command(self): self.build() self.runCmd("file " + self.getBuildArtifact("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']) frame = self.frame() self.assertTrue(frame.IsValid()) self.expect("frame variable ti", substrs=['[0] = 1']) self.expect("frame variable ts", substrs=['[0] = "foobar"']) self.expect("frame variable tt", substrs=['[0] = 1', '[1] = "baz"', '[2] = 2']) self.assertEqual(1, frame.GetValueForVariablePath("ti[0]").GetValueAsUnsigned()) self.assertFalse(frame.GetValueForVariablePath("ti[1]").IsValid()) self.assertEqual('"foobar"', frame.GetValueForVariablePath("ts[0]").GetSummary()) self.assertFalse(frame.GetValueForVariablePath("ts[1]").IsValid()) self.assertEqual(1, frame.GetValueForVariablePath("tt[0]").GetValueAsUnsigned()) self.assertEqual('"baz"', frame.GetValueForVariablePath("tt[1]").GetSummary()) self.assertEqual(2, frame.GetValueForVariablePath("tt[2]").GetValueAsUnsigned()) self.assertFalse(frame.GetValueForVariablePath("tt[3]").IsValid())
def test_shadowed(self): self.build() exe = self.getBuildArtifact("a.out") target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) # Register our shared libraries for remote targets so they get # automatically uploaded environment = self.registerSharedLibrariesWithTarget( target, ['One', 'Two']) lldbutil.run_break_set_by_source_regexp(self, '// break here', extra_options='-f main.c', num_expected_locations=1) process = target.LaunchSimple( None, environment, self.get_process_working_directory()) self.assertTrue(process, PROCESS_IS_VALID) # The stop reason of the thread should be breakpoint. self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, substrs=['stopped', 'stop reason = breakpoint']) # As we are shadowing the conflicting symbol, there should be no # ambiguity in this expression. self.expect( "expr int conflicting_symbol = 474747; conflicting_symbol", substrs=[ "474747"])
def test_runtime_types(self): """Test commands that require runtime types""" self.build() exe = self.getBuildArtifact("a.out") self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) # Break inside Test_NSString: line = self.lines[2] lldbutil.run_break_set_by_source_regexp( self, "NSString tests") self.runCmd("run", RUN_SUCCEEDED) # Test_NSString: self.runCmd("thread backtrace") self.expect("expression [str length]", patterns=["\(NSUInteger\) \$.* ="]) self.expect("expression str.length") self.expect('expression str = [NSString stringWithCString: "new"]') self.expect( 'po [NSError errorWithDomain:@"Hello" code:35 userInfo:@{@"NSDescription" : @"be completed."}]', substrs=[ "Error Domain=Hello", "Code=35", "be completed."]) self.runCmd("process continue")
def test_recursive_unique_ptr(self): # Tests that LLDB can handle when we have a loop in the unique_ptr # reference chain and that it correctly handles the different options # for the frame variable command in this case. 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) self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, substrs=['stopped', 'stop reason = breakpoint']) self.expect("frame variable f1->fp", substrs=['fp = 0x']) self.expect("frame variable --ptr-depth=1 f1->fp", substrs=['data = 2', 'fp = 0x']) self.expect("frame variable --ptr-depth=2 f1->fp", substrs=['data = 2', 'fp = 0x', 'data = 1']) frame = self.frame() self.assertTrue(frame.IsValid()) self.assertEqual(2, frame.GetValueForVariablePath("f1->fp.object.data").GetValueAsUnsigned()) self.assertEqual(2, frame.GetValueForVariablePath("f1->fp->data").GetValueAsUnsigned()) self.assertEqual(1, frame.GetValueForVariablePath("f1->fp.object.fp.object.data").GetValueAsUnsigned()) self.assertEqual(1, frame.GetValueForVariablePath("f1->fp->fp->data").GetValueAsUnsigned())
def test_recursive_unique_ptr(self): # Tests that LLDB can handle when we have a loop in the unique_ptr # reference chain and that it correctly handles the different options # for the frame variable command in this case. self.build() self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) lldbutil.run_break_set_by_source_regexp( self, "Set break point at this line.") self.runCmd("run", RUN_SUCCEEDED) self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, substrs=['stopped', 'stop reason = breakpoint']) self.expect("frame variable f1->fp", substrs=['fp = 0x']) self.expect("frame variable --ptr-depth=1 f1->fp", substrs=['data = 2', 'fp = 0x']) self.expect("frame variable --ptr-depth=2 f1->fp", substrs=['data = 2', 'fp = 0x', 'data = 1']) frame = self.frame() self.assertTrue(frame.IsValid()) self.assertEqual(2, frame.GetValueForVariablePath("f1->fp.object.data").GetValueAsUnsigned()) self.assertEqual(2, frame.GetValueForVariablePath("f1->fp->data").GetValueAsUnsigned()) self.assertEqual(1, frame.GetValueForVariablePath("f1->fp.object.fp.object.data").GetValueAsUnsigned()) self.assertEqual(1, frame.GetValueForVariablePath("f1->fp->fp->data").GetValueAsUnsigned())
def getvalue_commands(self): """Tests that the SBValue::GetValueAsUnsigned() API works for Swift types""" self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) lldbutil.run_break_set_by_source_regexp(self,r"break here",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']) frame = self.frame() string = frame.FindVariable("aString") number = frame.FindVariable("aNumber") number.SetPreferSyntheticValue(True) classobject = frame.FindVariable("aClassObject") numberValue = number.GetValueAsUnsigned() self.assertTrue(numberValue == 123456, "Swift.Int does not have a valid value") builtinPointerValue = string.GetChildMemberWithName("str_value").GetChildMemberWithName("base").GetChildMemberWithName("value") self.assertTrue(builtinPointerValue != 0, "Builtin.RawPointer does not have a valid value") objectPointerValue = string.GetChildMemberWithName("str_value").GetChildMemberWithName("value") self.assertTrue(objectPointerValue != 0, "Builtin.RawPointer does not have a valid value") classValue = classobject.GetValueAsUnsigned() self.assertTrue(classValue != 0, "Class types are aggregates with pointer values")
def test_runtime_types(self): """Test commands that require runtime types""" self.build() exe = os.path.join(os.getcwd(), "a.out") self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) # Break inside Test_NSString: line = self.lines[2] lldbutil.run_break_set_by_source_regexp( self, "NSString tests") self.runCmd("run", RUN_SUCCEEDED) # Test_NSString: self.runCmd("thread backtrace") self.expect("expression [str length]", patterns=["\(NSUInteger\) \$.* ="]) self.expect("expression str.length") self.expect('expression str = [NSString stringWithCString: "new"]') self.expect( 'po [NSError errorWithDomain:@"Hello" code:35 userInfo:@{@"NSDescription" : @"be completed."}]', substrs=[ "Error Domain=Hello", "Code=35", "be completed."]) self.runCmd("process continue")
def test_shadowed(self): self.build() exe = self.getBuildArtifact("a.out") target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) # Register our shared libraries for remote targets so they get # automatically uploaded environment = self.registerSharedLibrariesWithTarget( target, ['One', 'Two']) lldbutil.run_break_set_by_source_regexp(self, '// break here', extra_options='-f main.c', num_expected_locations=1) process = target.LaunchSimple(None, environment, self.get_process_working_directory()) self.assertTrue(process, PROCESS_IS_VALID) # The stop reason of the thread should be breakpoint. self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, substrs=['stopped', 'stop reason = breakpoint']) # As we are shadowing the conflicting symbol, there should be no # ambiguity in this expression. self.expect("expr int conflicting_symbol = 474747; conflicting_symbol", substrs=["474747"])
def test_with_run_command(self): 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"]) self.expect("frame variable nsp", substrs=["nsp = nullptr"]) self.expect("frame variable isp", substrs=["isp = 123"]) self.expect("frame variable ssp", substrs=['ssp = "foobar"']) self.expect("frame variable nwp", substrs=["nwp = nullptr"]) self.expect("frame variable iwp", substrs=["iwp = 123"]) self.expect("frame variable swp", substrs=['swp = "foobar"']) self.runCmd("continue") self.expect("frame variable nsp", substrs=["nsp = nullptr"]) self.expect("frame variable isp", substrs=["isp = nullptr"]) self.expect("frame variable ssp", substrs=["ssp = nullptr"]) self.expect("frame variable nwp", substrs=["nwp = nullptr"]) self.expect("frame variable iwp", substrs=["iwp = nullptr"]) self.expect("frame variable swp", substrs=["swp = nullptr"])
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 '{0!s}'".format(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_with_run_command(self): self.build() self.runCmd("file " + self.getBuildArtifact("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) ns = self.namespace self.look_for_content_and_continue("map", [ '%s::unordered_map' % ns, 'size=5 {', 'hello', 'world', 'this', 'is', 'me' ]) self.look_for_content_and_continue("mmap", [ '%s::unordered_multimap' % ns, 'size=6 {', 'first = 3', 'second = "this"', 'first = 2', 'second = "hello"' ]) self.look_for_content_and_continue("iset", [ '%s::unordered_set' % ns, 'size=5 {', '\[\d\] = 5', '\[\d\] = 3', '\[\d\] = 2' ]) self.look_for_content_and_continue("sset", [ '%s::unordered_set' % ns, 'size=5 {', '\[\d\] = "is"', '\[\d\] = "world"', '\[\d\] = "hello"' ]) self.look_for_content_and_continue("imset", [ '%s::unordered_multiset' % ns, 'size=6 {', '(\[\d\] = 3(\\n|.)+){3}', '\[\d\] = 2', '\[\d\] = 1' ]) self.look_for_content_and_continue("smset", [ '%s::unordered_multiset' % ns, 'size=5 {', '(\[\d\] = "is"(\\n|.)+){2}', '(\[\d\] = "world"(\\n|.)+){2}' ])
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 dynamic_val_commands(self): """Tests that dynamic values work correctly for Swift""" self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) lldbutil.run_break_set_by_source_regexp( self, "// Set a breakpoint 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']) self.expect( "frame variable", substrs=[ "AWrapperClass) aWrapper", "SomeClass) anItem = ", "x = ", "Base<Int>) aBase = 0x", "v = 449493530"]) self.expect( "frame variable -d run --show-types", substrs=[ "AWrapperClass) aWrapper", "YetAnotherClass) anItem = ", "x = ", "y = ", "z = ", "Derived<Int>) aBase = 0x", "Base<Int>)", ".Base = {", "v = 449493530", "q = 3735928559"]) self.runCmd("continue") self.expect( "frame variable", substrs=[ "AWrapperClass) aWrapper", "SomeClass) anItem = ", "x = ", "Base<Int>) aBase = 0x", "v = 449493530"]) self.expect( "frame variable -d run --show-types", substrs=[ "AWrapperClass) aWrapper", "YetAnotherClass) anItem = ", "x = ", "y = ", "z = ", "Derived<Int>) aBase = 0x", "Base<Int>)", ".Base = {", "v = 449493530", "q = 3735928559"])
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 genericresolution_commands(self): """Check that we can correctly figure out the dynamic type of generic things""" 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']) self.expect( "frame variable -d run", substrs=[ "(Int) x = 123", "(a.OtherClass<Int>) self = 0x", "a.AClass = {}", "v = 1234567"]) self.runCmd("continue") self.expect( "frame variable -d run", substrs=[ '(String) x = "hello world again"', '(Int) v = 1']) self.runCmd("continue") self.expect( "frame variable -d run", substrs=[ '(a.Pair<a.Generic<Int>, a.Pair<String, a.Generic<String>>>) self = 0x', 'one = ', 'v = 193627', 'two = 0x', 'one = "hello"', 'two = (v = "world")']) self.runCmd("continue") self.expect( "frame variable -d run", substrs=[ '(a.Pair<a.Generic<Double>, a.Generic<a.Pair<String, String>>>) self = 0', 'one = ', 'v = 3.1', 'two = {', 'v = 0x', '(one = "this is", two = "a good thing")']) self.runCmd("continue") self.expect( "frame variable -d run", substrs=[ "(Int) x = 5", '(String) y = "hello world"', "(a.OtherClass<Int>) self = 0x", "a.AClass = {}", "v = 1234567"])
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 '{0!s}'".format(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_with_run_command(self): 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 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) ns = self.namespace self.look_for_content_and_continue( "map", ['%s::unordered_map' % ns, 'size=5 {', 'hello', 'world', 'this', 'is', 'me']) self.look_for_content_and_continue( "mmap", ['%s::unordered_multimap' % ns, 'size=6 {', 'first = 3', 'second = "this"', 'first = 2', 'second = "hello"']) self.look_for_content_and_continue( "iset", ['%s::unordered_set' % ns, 'size=5 {', '\[\d\] = 5', '\[\d\] = 3', '\[\d\] = 2']) self.look_for_content_and_continue( "sset", ['%s::unordered_set' % ns, 'size=5 {', '\[\d\] = "is"', '\[\d\] = "world"', '\[\d\] = "hello"']) self.look_for_content_and_continue( "imset", ['%s::unordered_multiset' % ns, 'size=6 {', '(\[\d\] = 3(\\n|.)+){3}', '\[\d\] = 2', '\[\d\] = 1']) self.look_for_content_and_continue( "smset", ['%s::unordered_multiset' % ns, 'size=5 {', '(\[\d\] = "is"(\\n|.)+){2}', '(\[\d\] = "world"(\\n|.)+){2}'])
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 var_commands(self): """Test that LLDB can effectively use the type metadata to reconstruct dynamic types for Swift""" self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) lldbutil.run_break_set_by_source_regexp(self, "// Set breakpoint 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']) self.expect("frame select 0", substrs=['foo', 'x', 'ivar']) self.expect("frame variable -d run -- x", substrs=['(a.AClass) x', 'ivar = 3735928559']) # first stop on foo self.runCmd("continue", RUN_SUCCEEDED) self.expect("frame select 0", substrs=['bar', 'x', 'y']) self.expect("frame variable -d run -- x y", substrs=['(Int64) x', '(Float) y']) # first stop on bar self.runCmd("continue", RUN_SUCCEEDED) self.expect("frame select 0", substrs=['foo', 'x']) self.expect("frame variable -d run -- x", substrs=['(a.AClass) x', 'ivar = 3735928559']) # second stop on foo self.runCmd("continue", RUN_SUCCEEDED) self.expect("frame select 0", substrs=['baz', 'x']) self.expect("frame variable -d run -- x", substrs=['(a.AClass) x', 'ivar = 3735928559']) # first stop on baz self.runCmd("continue", RUN_SUCCEEDED) self.expect("frame select 0", substrs=['bar', 'x']) self.expect("frame variable -d run -- x y", substrs=['(a.AClass) x', '(a.AClass) y']) # second stop on bar self.runCmd("continue", RUN_SUCCEEDED) self.expect("frame select 0", substrs=['bat', 'x']) self.expect("frame variable -d run -- x", substrs=['(a.ADerivedClass) x']) # first stop on bat self.runCmd("continue", RUN_SUCCEEDED) self.expect("frame select 0", substrs=['bat', 'x']) self.expect("frame variable -d run -- x", substrs=['(a.AnotherDerivedClass) x' ]) # second stop on bat self.runCmd("continue", RUN_SUCCEEDED)
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_imp_ivar_type(self): """Test that dynamically discovered ivars of type IMP do not crash LLDB""" self.build() exe = self.getBuildArtifact("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(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) # 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(self): """Test that std::function 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) # 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 f1", substrs=['f1 = Function = foo(int, int)']) self.expect("frame variable f2", substrs=['f2 = Lambda in File main.cpp at Line 26']) self.expect("frame variable f3", substrs=['f3 = Lambda in File main.cpp at Line 30']) self.expect("frame variable f4", substrs=['f4 = Function in File main.cpp at Line 16']) self.expect("frame variable f5", substrs=['f5 = Function = Bar::add_num(int) const'])
def data_formatter_commands(self): """Benchmark the Swift dictionary data formatter""" self.runCmd("file " + getBuildArtifact("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) sw = Stopwatch() sw.start() self.expect('frame variable -A dict', substrs=['[300]', '300']) sw.stop() print("time to print: %s" % (sw))
def break_commands(self): """Tests that we can set a conditional breakpoint in Swift code""" self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) bkno = lldbutil.run_break_set_by_source_regexp( self, "Set breakpoint here") self.runCmd('breakpoint modify ' + str(bkno) + ' -c x==y') 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 var x y", substrs=['x = 5', 'y = 5']) self.runCmd("continue", RUN_SUCCEEDED) self.expect("frame var x y", substrs=['x = 6', 'y = 6']) self.runCmd('breakpoint modify ' + str(bkno) + ' -c x>y') self.runCmd("continue", RUN_SUCCEEDED) self.expect("frame var x y", substrs=['x = 3', 'y = 1'])
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::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_imp_ivar_type(self): """Test that dynamically discovered ivars of type IMP do not crash LLDB""" self.build() 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): """Benchmark the std::map data formatter (libc++)""" 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) sw = Stopwatch() sw.start() self.expect('frame variable -A map', substrs=['[300]', '300']) sw.stop() print("time to print: %s" % (sw))
def break_commands(self): """Tests that we can set a conditional breakpoint in Swift code""" exe_name = self.getBuildArtifact("a.out") self.runCmd("file %s" % (exe_name), CURRENT_EXECUTABLE_SET) bkno = lldbutil.run_break_set_by_source_regexp(self, "Set breakpoint here") self.runCmd('breakpoint modify ' + str(bkno) + ' -c x==y') 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 var x y", substrs=['x = 5', 'y = 5']) self.runCmd("continue", RUN_SUCCEEDED) self.expect("frame var x y", substrs=['x = 6', 'y = 6']) self.runCmd('breakpoint modify ' + str(bkno) + ' -c x>y') self.runCmd("continue", RUN_SUCCEEDED) self.expect("frame var x y", substrs=['x = 3', 'y = 1'])
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 = self.getBuildArtifact("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_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(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): self.build() self.runCmd("file " + self.getBuildArtifact("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']) frame = self.frame() self.assertTrue(frame.IsValid()) self.expect("frame variable nup", substrs=['nup = nullptr']) self.expect("frame variable iup", substrs=['iup = 0x']) self.expect("frame variable sup", substrs=['sup = 0x']) self.expect("frame variable ndp", substrs=['ndp = nullptr']) self.expect("frame variable idp", substrs=['idp = 0x', 'deleter = ', 'a = 1', 'b = 2']) self.expect("frame variable sdp", substrs=['sdp = 0x', 'deleter = ', 'a = 3', 'b = 4']) self.assertEqual(123, frame.GetValueForVariablePath("iup.object").GetValueAsUnsigned()) self.assertEqual(123, frame.GetValueForVariablePath("*iup").GetValueAsUnsigned()) self.assertFalse(frame.GetValueForVariablePath("iup.deleter").IsValid()) self.assertEqual('"foobar"', frame.GetValueForVariablePath("sup.object").GetSummary()) self.assertEqual('"foobar"', frame.GetValueForVariablePath("*sup").GetSummary()) self.assertFalse(frame.GetValueForVariablePath("sup.deleter").IsValid()) self.assertEqual(456, frame.GetValueForVariablePath("idp.object").GetValueAsUnsigned()) self.assertEqual(456, frame.GetValueForVariablePath("*idp").GetValueAsUnsigned()) self.assertEqual('"baz"', frame.GetValueForVariablePath("sdp.object").GetSummary()) self.assertEqual('"baz"', frame.GetValueForVariablePath("*sdp").GetSummary()) idp_deleter = frame.GetValueForVariablePath("idp.deleter") self.assertTrue(idp_deleter.IsValid()) self.assertEqual(1, idp_deleter.GetChildMemberWithName("a").GetValueAsUnsigned()) self.assertEqual(2, idp_deleter.GetChildMemberWithName("b").GetValueAsUnsigned()) sdp_deleter = frame.GetValueForVariablePath("sdp.deleter") self.assertTrue(sdp_deleter.IsValid()) self.assertEqual(3, sdp_deleter.GetChildMemberWithName("a").GetValueAsUnsigned()) self.assertEqual(4, sdp_deleter.GetChildMemberWithName("b").GetValueAsUnsigned())
def test_with_run_command(self): 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']) frame = self.frame() self.assertTrue(frame.IsValid()) self.expect("frame variable nup", substrs=['nup = nullptr']) self.expect("frame variable iup", substrs=['iup = 0x']) self.expect("frame variable sup", substrs=['sup = 0x']) self.expect("frame variable ndp", substrs=['ndp = nullptr']) self.expect("frame variable idp", substrs=['idp = 0x', 'deleter = ', 'a = 1', 'b = 2']) self.expect("frame variable sdp", substrs=['sdp = 0x', 'deleter = ', 'a = 3', 'b = 4']) self.assertEqual(123, frame.GetValueForVariablePath("iup.object").GetValueAsUnsigned()) self.assertEqual(123, frame.GetValueForVariablePath("*iup").GetValueAsUnsigned()) self.assertFalse(frame.GetValueForVariablePath("iup.deleter").IsValid()) self.assertEqual('"foobar"', frame.GetValueForVariablePath("sup.object").GetSummary()) self.assertEqual('"foobar"', frame.GetValueForVariablePath("*sup").GetSummary()) self.assertFalse(frame.GetValueForVariablePath("sup.deleter").IsValid()) self.assertEqual(456, frame.GetValueForVariablePath("idp.object").GetValueAsUnsigned()) self.assertEqual(456, frame.GetValueForVariablePath("*idp").GetValueAsUnsigned()) self.assertEqual('"baz"', frame.GetValueForVariablePath("sdp.object").GetSummary()) self.assertEqual('"baz"', frame.GetValueForVariablePath("*sdp").GetSummary()) idp_deleter = frame.GetValueForVariablePath("idp.deleter") self.assertTrue(idp_deleter.IsValid()) self.assertEqual(1, idp_deleter.GetChildMemberWithName("a").GetValueAsUnsigned()) self.assertEqual(2, idp_deleter.GetChildMemberWithName("b").GetValueAsUnsigned()) sdp_deleter = frame.GetValueForVariablePath("sdp.deleter") self.assertTrue(sdp_deleter.IsValid()) self.assertEqual(3, sdp_deleter.GetChildMemberWithName("a").GetValueAsUnsigned()) self.assertEqual(4, sdp_deleter.GetChildMemberWithName("b").GetValueAsUnsigned())
def do_test_with_run_command(self, stdlib_type): """Test that that file and class static variables display correctly.""" # 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.addTearDownHook(cleanup) self.build(dictionary={stdlib_type: "1"}) self.runCmd("file " + self.getBuildArtifact("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']) self.runCmd("frame variable has_optional") output = self.res.GetOutput() ## The variable has_optional tells us if the test program ## detected we have a sufficient libc++ version to support optional ## false means we do not and therefore should skip the test if output.find("(bool) has_optional = false") != -1: self.skipTest("Optional not supported") lldbutil.continue_to_breakpoint(self.process(), bkpt) self.expect("frame variable number_not_engaged", substrs=['Has Value=false']) self.expect("frame variable number_engaged", substrs=['Has Value=true', 'Value = 42', '}']) self.expect("frame var numbers", substrs=[ '(optional_int_vect) numbers = Has Value=true {', 'Value = size=4 {', '[0] = 1', '[1] = 2', '[2] = 3', '[3] = 4', '}', '}' ]) self.expect("frame var ostring", substrs=[ '(optional_string) ostring = Has Value=true {', 'Value = "hello"', '}' ])
def test(self): self.build() lldbutil.run_to_source_breakpoint(self, "// break here", lldb.SBFileSpec("f.cpp")) # Sanity check that we really have to debug info for this type. this = self.expect_var_path("this", type="A *") self.assertEquals(this.GetType().GetPointeeType().GetNumberOfFields(), 0, str(this)) self.expect_var_path("af.x", value='42') lldbutil.run_break_set_by_source_regexp(self, "// break here", extra_options="-f g.cpp") self.runCmd("continue") self.expect_var_path("ag.a", value='47')
def test_cross_dso_tail_calls(self): self.build() exe = self.getBuildArtifact("a.out") target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) # Register our shared libraries for remote targets so they get # automatically uploaded environment = self.registerSharedLibrariesWithTarget( target, ['One', 'Two']) lldbutil.run_break_set_by_source_regexp(self, '// break here', extra_options='-f Two.c') process = target.LaunchSimple( None, environment, self.get_process_working_directory()) self.assertTrue(process, PROCESS_IS_VALID) # We should be stopped in the second dylib. thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint) # Debug helper: # self.runCmd("log enable -f /tmp/lldb.log lldb step") # self.runCmd("bt") # Check that the backtrace is what we expect: # frame #0: 0x000000010d5e5f94 libTwo.dylib`tail_called_in_b_from_b at Two.c:7:3 [opt] # frame #1: 0x000000010d5e5fa0 libTwo.dylib`tail_called_in_b_from_a [opt] [artificial] # frame #2: 0x000000010d5dcf80 libOne.dylib`helper_in_a [opt] [artificial] # frame #3: 0x000000010d5dcf79 libOne.dylib`tail_called_in_a_from_main at One.c:10:3 [opt] # frame #4: 0x000000010d5d3f80 a.out`helper [opt] [artificial] # frame #5: 0x000000010d5d3f79 a.out`main at main.c:10:3 [opt] expected_frames = [ ("tail_called_in_b_from_b", False), ("tail_called_in_b_from_a", True), ("helper_in_a", True), ("tail_called_in_a_from_main", False), ("helper", True), ("main", False) ] for idx, (name, is_artificial) in enumerate(expected_frames): frame = thread.GetFrameAtIndex(idx) self.assertTrue(name in frame.GetDisplayFunctionName()) self.assertEqual(frame.IsArtificial(), is_artificial)
def genericresolution_commands(self): """Check that we can correctly figure out the dynamic type of generic things""" 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']) self.expect("frame variable -d run", substrs=[ "(Int) x = 123", "(a.OtherClass<Int>) self = 0x", "a.AClass = {}", "v = 1234567" ]) self.runCmd("continue") self.expect( "frame variable -d run", substrs=['(String) x = "hello world again"', '(Int) v = 1']) self.runCmd("continue") self.expect( "frame variable -d run", substrs=[ '(a.Pair<a.Generic<Int>, a.Pair<String, a.Generic<String>>>) self = 0x', 'one = ', 'v = 193627', 'two = 0x', 'one = "hello"', 'two = (v = "world")' ]) self.runCmd("continue") self.expect( "frame variable -d run", substrs=[ '(a.Pair<a.Generic<Double>, a.Generic<a.Pair<String, String>>>) self = 0', 'one = ', 'v = 3.1', 'two = {', 'v = 0x', '(one = "this is", two = "a good thing")' ]) self.runCmd("continue") self.expect("frame variable -d run", substrs=[ "(Int) x = 5", '(String) y = "hello world"', "(a.OtherClass<Int>) self = 0x", "a.AClass = {}", "v = 1234567" ])
def nserror_commands(self): """Tests that Swift displays NSError correctly""" self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) lldbutil.run_break_set_by_source_regexp( self, "// Set a breakpoint 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']) self.expect("frame variable -d run --ptr-depth=2", substrs=[ '0 = " "', '1 = 0x', 'domain: "lldbrocks" - code: 3133079277 {', '_userInfo = ', '2 key/value pairs {', '0 = ', ' "x"', '1 = ', ' Int64(0)', '0 = ', ' "y"', '1 = ', ' Int64(0)', '0 = "x+y"', 'domain: "lldbrocks" - code: 0 {', '1 = ', ' Int64(3)', '1 = ', ' Int64(4)'])
def test_inferior_handle_sigabrt(self): """Inferior calls abort() and handles the resultant SIGABRT. Stopped at a breakpoint in the handler, verify that the backtrace includes the function that called abort().""" self.build() exe = self.getBuildArtifact("a.out") # Create a target by the debugger. target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) # launch process = target.LaunchSimple(None, None, self.get_process_working_directory()) self.assertTrue(process, PROCESS_IS_VALID) self.assertState(process.GetState(), lldb.eStateStopped) signo = process.GetUnixSignals().GetSignalNumberFromName("SIGABRT") thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonSignal) self.assertTrue(thread and thread.IsValid(), "Thread should be stopped due to a signal") self.assertTrue(thread.GetStopReasonDataCount() >= 1, "There should be data in the event.") self.assertEqual(thread.GetStopReasonDataAtIndex(0), signo, "The stop signal should be SIGABRT") # Continue to breakpoint in abort handler bkpt = target.FindBreakpointByID( lldbutil.run_break_set_by_source_regexp(self, "Set a breakpoint here")) threads = lldbutil.continue_to_breakpoint(process, bkpt) self.assertEqual(len(threads), 1, "Expected single thread") thread = threads[0] # Expect breakpoint in 'handler' frame = thread.GetFrameAtIndex(0) self.assertEqual(frame.GetDisplayFunctionName(), "handler", "Unexpected break?") # Expect that unwinding should find 'abort_caller' foundFoo = False for frame in thread: if frame.GetDisplayFunctionName() == "abort_caller": foundFoo = True self.assertTrue(foundFoo, "Unwinding did not find func that called abort") # Continue until we exit. process.Continue() self.assertState(process.GetState(), lldb.eStateExited) self.assertEqual(process.GetExitStatus(), 0)
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_cross_object_tail_calls(self): self.build() exe = self.getBuildArtifact("a.out") target = self.dbg.CreateTarget(exe) self.assertTrue(target, VALID_TARGET) lldbutil.run_break_set_by_source_regexp(self, '// break here', extra_options='-f Two.c') process = target.LaunchSimple( None, None, self.get_process_working_directory()) self.assertTrue(process, PROCESS_IS_VALID) # We should be stopped in the second dylib. thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint) # Debug helper: # self.runCmd("log enable -f /tmp/lldb.log lldb step") # self.runCmd("bt") # Check that the backtrace is what we expect: # frame #0: 0x000000010be73f94 a.out`tail_called_in_b_from_b at Two.c:7:3 [opt] # frame #1: 0x000000010be73fa0 a.out`tail_called_in_b_from_a at Two.c:8:1 [opt] [artificial] # frame #2: 0x000000010be73f80 a.out`helper_in_a at One.c:11:1 [opt] [artificial] # frame #3: 0x000000010be73f79 a.out`tail_called_in_a_from_main at One.c:10:3 [opt] # frame #4: 0x000000010be73f60 a.out`helper at main.c:11:3 [opt] [artificial] # frame #5: 0x000000010be73f59 a.out`main at main.c:10:3 [opt] expected_frames = [ ("tail_called_in_b_from_b", False), ("tail_called_in_b_from_a", True), ("helper_in_a", True), ("tail_called_in_a_from_main", False), ("helper", True), ("main", False) ] for idx, (name, is_artificial) in enumerate(expected_frames): frame = thread.GetFrameAtIndex(idx) self.assertTrue(name in frame.GetDisplayFunctionName()) self.assertEqual(frame.IsArtificial(), is_artificial)
def var_commands(self): """Test that LLDB can effectively use the type metadata to reconstruct dynamic types for Swift""" self.runCmd("file a.out", CURRENT_EXECUTABLE_SET) lldbutil.run_break_set_by_source_regexp(self,"// Set breakpoint 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']) self.expect("frame select 0", substrs = ['foo', 'x', 'ivar']) self.expect("frame variable -d run -- x", substrs = ['(a.AClass) x','ivar = 3735928559']) # first stop on foo self.runCmd("continue", RUN_SUCCEEDED) self.expect("frame select 0", substrs = ['bar', 'x', 'y']) self.expect("frame variable -d run -- x y", substrs = ['(Int64) x', '(Float) y']) # first stop on bar self.runCmd("continue", RUN_SUCCEEDED) self.expect("frame select 0", substrs = ['foo', 'x']) self.expect("frame variable -d run -- x", substrs = ['(a.AClass) x','ivar = 3735928559']) # second stop on foo self.runCmd("continue", RUN_SUCCEEDED) self.expect("frame select 0", substrs = ['baz', 'x']) self.expect("frame variable -d run -- x", substrs = ['(a.AClass) x','ivar = 3735928559']) # first stop on baz self.runCmd("continue", RUN_SUCCEEDED) self.expect("frame select 0", substrs = ['bar', 'x']) self.expect("frame variable -d run -- x y", substrs = ['(a.AClass) x', '(a.AClass) y']) # second stop on bar self.runCmd("continue", RUN_SUCCEEDED) self.expect("frame select 0", substrs = ['bat', 'x']) self.expect("frame variable -d run -- x", substrs = ['(a.ADerivedClass) x']) # first stop on bat self.runCmd("continue", RUN_SUCCEEDED) self.expect("frame select 0", substrs = ['bat', 'x']) self.expect("frame variable -d run -- x", substrs = ['(a.AnotherDerivedClass) x']) # second stop on bat self.runCmd("continue", RUN_SUCCEEDED)
def make_target_and_bkpt(self, additional_options=None, num_expected_loc=1, pattern="Set a breakpoint here"): exe = self.getBuildArtifact("a.out") self.target = self.dbg.CreateTarget(exe) self.assertTrue(self.target.IsValid(), "Target is not valid") extra_options_txt = "--auto-continue 1 " if additional_options: extra_options_txt += additional_options bpno = lldbutil.run_break_set_by_source_regexp(self, pattern, extra_options = extra_options_txt, num_expected_locations = num_expected_loc) return bpno
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 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, "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']) self.runCmd( "frame variable has_optional" ) output = self.res.GetOutput() ## The variable has_optional tells us if the test program ## detected we have a sufficient libc++ version to support optional ## false means we do not and therefore should skip the test if output.find("(bool) has_optional = false") != -1 : self.skipTest( "Optional not supported" ) lldbutil.continue_to_breakpoint(self.process(), bkpt) self.expect("frame variable number_not_engaged", substrs=['Has Value=false']) self.expect("frame variable number_engaged", substrs=['Has Value=true', 'Value = 42', '}']) self.expect("frame var numbers", substrs=['(optional_int_vect) numbers = Has Value=true {', 'Value = size=4 {', '[0] = 1', '[1] = 2', '[2] = 3', '[3] = 4', '}', '}']) self.expect("frame var ostring", substrs=['(optional_string) ostring = Has Value=true {', 'Value = "hello"', '}'])
def data_formatter_commands(self): """Benchmark different ways to continue a process""" self.runCmd("file "+self.getBuildArtifact("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 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 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.runCmd("frame variable ii --show-types") self.runCmd( "type summary add -x \"std::map<\" --summary-string \"map has ${svar%#} items\" -e") self.expect('frame variable ii', substrs=['map has 0 items', '{}']) self.runCmd("c") self.expect('frame variable ii', substrs=['map has 2 items', '[0] = ', 'first = 0', 'second = 0', '[1] = ', 'first = 1', 'second = 1']) self.runCmd("c") self.expect('frame variable ii', substrs=['map has 4 items', '[2] = ', 'first = 2', 'second = 0', '[3] = ', 'first = 3', 'second = 1']) self.runCmd("c") self.expect("frame variable ii", substrs=['map has 9 items', '[5] = ', 'first = 5', 'second = 0', '[7] = ', 'first = 7', 'second = 1']) self.expect("p ii", substrs=['map has 9 items', '[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 =']) self.expect("frame variable ii[8]", matching=True, substrs=['1234567']) # 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("c") self.expect('frame variable ii', substrs=['map has 0 items', '{}']) self.runCmd("frame variable si --show-types") self.expect('frame variable si', substrs=['map has 0 items', '{}']) self.runCmd("c") self.expect('frame variable si', substrs=['map has 1 items', '[0] = ', 'first = \"zero\"', 'second = 0']) self.runCmd("c") self.expect("frame variable si", substrs=['map has 5 items', '[0] = ', 'first = \"zero\"', 'second = 0', '[1] = ', 'first = \"one\"', 'second = 1', '[2] = ', 'first = \"two\"', 'second = 2', '[3] = ', 'first = \"three\"', 'second = 3', '[4] = ', 'first = \"four\"', 'second = 4']) self.expect("p si", substrs=['map has 5 items', '[0] = ', 'first = \"zero\"', 'second = 0', '[1] = ', 'first = \"one\"', 'second = 1', '[2] = ', 'first = \"two\"', 'second = 2', '[3] = ', 'first = \"three\"', 'second = 3', '[4] = ', 'first = \"four\"', 'second = 4']) # check access-by-index self.expect("frame variable si[0]", substrs=['first = ', 'four', 'second = 4']) # check that MightHaveChildren() gets it right self.assertTrue( self.frame().FindVariable("si").MightHaveChildren(), "si.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 si[0]", matching=False, error=True, # substrs = ['first = ', 'zero']) self.runCmd("c") self.expect('frame variable si', substrs=['map has 0 items', '{}']) self.runCmd("frame variable is --show-types") self.expect('frame variable is', substrs=['map has 0 items', '{}']) self.runCmd("c") self.expect("frame variable is", substrs=['map has 4 items', '[0] = ', 'second = \"goofy\"', 'first = 85', '[1] = ', 'second = \"is\"', 'first = 1', '[2] = ', 'second = \"smart\"', 'first = 2', '[3] = ', 'second = \"!!!\"', 'first = 3']) self.expect("p is", substrs=['map has 4 items', '[0] = ', 'second = \"goofy\"', 'first = 85', '[1] = ', 'second = \"is\"', 'first = 1', '[2] = ', 'second = \"smart\"', 'first = 2', '[3] = ', 'second = \"!!!\"', 'first = 3']) # check access-by-index self.expect("frame variable is[0]", substrs=['first = ', 'second =']) # check that MightHaveChildren() gets it right self.assertTrue( self.frame().FindVariable("is").MightHaveChildren(), "is.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 is[0]", matching=False, error=True, # substrs = ['first = ', 'goofy']) self.runCmd("c") self.expect('frame variable is', substrs=['map has 0 items', '{}']) self.runCmd("frame variable ss --show-types") self.expect('frame variable ss', substrs=['map has 0 items', '{}']) self.runCmd("c") self.expect("frame variable ss", substrs=['map has 4 items', '[0] = ', 'second = \"hello\"', 'first = \"ciao\"', '[1] = ', 'second = \"house\"', 'first = \"casa\"', '[2] = ', 'second = \"cat\"', 'first = \"gatto\"', '[3] = ', 'second = \"..is always a Mac!\"', 'first = \"a Mac..\"']) self.expect("p ss", substrs=['map has 4 items', '[0] = ', 'second = \"hello\"', 'first = \"ciao\"', '[1] = ', 'second = \"house\"', 'first = \"casa\"', '[2] = ', 'second = \"cat\"', 'first = \"gatto\"', '[3] = ', 'second = \"..is always a Mac!\"', 'first = \"a Mac..\"']) # check access-by-index self.expect("frame variable ss[3]", substrs=['gatto', 'cat']) # check that MightHaveChildren() gets it right self.assertTrue( self.frame().FindVariable("ss").MightHaveChildren(), "ss.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 ss[3]", matching=False, error=True, # substrs = ['gatto']) self.runCmd("c") self.expect('frame variable ss', substrs=['map has 0 items', '{}'])