| """ |
| Test that SBFrame::GetVariables() calls work correctly. |
| """ |
| |
| from __future__ import print_function |
| |
| |
| import os |
| import time |
| import lldb |
| from lldbsuite.test.decorators import * |
| from lldbsuite.test.lldbtest import * |
| from lldbsuite.test import lldbplatform |
| from lldbsuite.test import lldbutil |
| |
| |
| def get_names_from_value_list(value_list): |
| names = list() |
| for value in value_list: |
| names.append(value.GetName()) |
| return names |
| |
| |
| class TestGetVariables(TestBase): |
| |
| mydir = TestBase.compute_mydir(__file__) |
| |
| def setUp(self): |
| # Call super's setUp(). |
| TestBase.setUp(self) |
| self.source = 'main.c' |
| |
| def verify_variable_names(self, description, value_list, names): |
| copy_names = list(names) |
| actual_names = get_names_from_value_list(value_list) |
| for name in actual_names: |
| if name in copy_names: |
| copy_names.remove(name) |
| else: |
| self.assertTrue( |
| False, "didn't find '%s' in %s" % |
| (name, copy_names)) |
| self.assertEqual( |
| len(copy_names), 0, "%s: we didn't find variables: %s in value list (%s)" % |
| (description, copy_names, actual_names)) |
| |
| def test(self): |
| self.build() |
| |
| # Set debugger into synchronous mode |
| self.dbg.SetAsync(False) |
| |
| # Create a target by the debugger. |
| exe = self.getBuildArtifact("a.out") |
| target = self.dbg.CreateTarget(exe) |
| self.assertTrue(target, VALID_TARGET) |
| |
| line1 = line_number(self.source, '// breakpoint 1') |
| line2 = line_number(self.source, '// breakpoint 2') |
| line3 = line_number(self.source, '// breakpoint 3') |
| |
| breakpoint1 = target.BreakpointCreateByLocation(self.source, line1) |
| breakpoint2 = target.BreakpointCreateByLocation(self.source, line2) |
| breakpoint3 = target.BreakpointCreateByLocation(self.source, line3) |
| |
| self.assertTrue(breakpoint1.GetNumLocations() >= 1, PROCESS_IS_VALID) |
| self.assertTrue(breakpoint2.GetNumLocations() >= 1, PROCESS_IS_VALID) |
| self.assertTrue(breakpoint3.GetNumLocations() >= 1, PROCESS_IS_VALID) |
| |
| # 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) |
| |
| threads = lldbutil.get_threads_stopped_at_breakpoint( |
| process, breakpoint1) |
| self.assertEqual( |
| len(threads), |
| 1, |
| "There should be a thread stopped at breakpoint 1") |
| |
| thread = threads[0] |
| self.assertTrue(thread.IsValid(), "Thread must be valid") |
| frame = thread.GetFrameAtIndex(0) |
| self.assertTrue(frame.IsValid(), "Frame must be valid") |
| |
| arg_names = ['argc', 'argv'] |
| local_names = ['i', 'j', 'k'] |
| static_names = ['static_var', 'g_global_var', 'g_static_var'] |
| breakpoint1_locals = ['i'] |
| breakpoint1_statics = ['static_var'] |
| num_args = len(arg_names) |
| num_locals = len(local_names) |
| num_statics = len(static_names) |
| args_yes = True |
| args_no = False |
| locals_yes = True |
| locals_no = False |
| statics_yes = True |
| statics_no = False |
| in_scopy_only = True |
| ignore_scope = False |
| |
| # Verify if we ask for only arguments that we got what we expect |
| vars = frame.GetVariables( |
| args_yes, locals_no, statics_no, ignore_scope) |
| self.assertEqual( |
| vars.GetSize(), |
| num_args, |
| "There should be %i arguments, but we are reporting %i" % |
| (num_args, |
| vars.GetSize())) |
| self.verify_variable_names("check names of arguments", vars, arg_names) |
| self.assertEqual( |
| len(arg_names), |
| num_args, |
| "make sure verify_variable_names() didn't mutate list") |
| |
| # Verify if we ask for only locals that we got what we expect |
| vars = frame.GetVariables( |
| args_no, locals_yes, statics_no, ignore_scope) |
| self.assertEqual( |
| vars.GetSize(), |
| num_locals, |
| "There should be %i local variables, but we are reporting %i" % |
| (num_locals, |
| vars.GetSize())) |
| self.verify_variable_names("check names of locals", vars, local_names) |
| |
| # Verify if we ask for only statics that we got what we expect |
| vars = frame.GetVariables( |
| args_no, locals_no, statics_yes, ignore_scope) |
| print('statics: ', str(vars)) |
| self.assertEqual( |
| vars.GetSize(), |
| num_statics, |
| "There should be %i static variables, but we are reporting %i" % |
| (num_statics, |
| vars.GetSize())) |
| self.verify_variable_names( |
| "check names of statics", vars, static_names) |
| |
| # Verify if we ask for arguments and locals that we got what we expect |
| vars = frame.GetVariables( |
| args_yes, locals_yes, statics_no, ignore_scope) |
| desc = 'arguments + locals' |
| names = arg_names + local_names |
| count = len(names) |
| self.assertEqual( |
| vars.GetSize(), |
| count, |
| "There should be %i %s (%s) but we are reporting %i (%s)" % |
| (count, |
| desc, |
| names, |
| vars.GetSize(), |
| get_names_from_value_list(vars))) |
| self.verify_variable_names("check names of %s" % (desc), vars, names) |
| |
| # Verify if we ask for arguments and statics that we got what we expect |
| vars = frame.GetVariables( |
| args_yes, locals_no, statics_yes, ignore_scope) |
| desc = 'arguments + statics' |
| names = arg_names + static_names |
| count = len(names) |
| self.assertEqual( |
| vars.GetSize(), |
| count, |
| "There should be %i %s (%s) but we are reporting %i (%s)" % |
| (count, |
| desc, |
| names, |
| vars.GetSize(), |
| get_names_from_value_list(vars))) |
| self.verify_variable_names("check names of %s" % (desc), vars, names) |
| |
| # Verify if we ask for locals and statics that we got what we expect |
| vars = frame.GetVariables( |
| args_no, locals_yes, statics_yes, ignore_scope) |
| desc = 'locals + statics' |
| names = local_names + static_names |
| count = len(names) |
| self.assertEqual( |
| vars.GetSize(), |
| count, |
| "There should be %i %s (%s) but we are reporting %i (%s)" % |
| (count, |
| desc, |
| names, |
| vars.GetSize(), |
| get_names_from_value_list(vars))) |
| self.verify_variable_names("check names of %s" % (desc), vars, names) |
| |
| # Verify if we ask for arguments, locals and statics that we got what |
| # we expect |
| vars = frame.GetVariables( |
| args_yes, locals_yes, statics_yes, ignore_scope) |
| desc = 'arguments + locals + statics' |
| names = arg_names + local_names + static_names |
| count = len(names) |
| self.assertEqual( |
| vars.GetSize(), |
| count, |
| "There should be %i %s (%s) but we are reporting %i (%s)" % |
| (count, |
| desc, |
| names, |
| vars.GetSize(), |
| get_names_from_value_list(vars))) |
| self.verify_variable_names("check names of %s" % (desc), vars, names) |
| |
| # Verify if we ask for in scope locals that we got what we expect |
| vars = frame.GetVariables( |
| args_no, locals_yes, statics_no, in_scopy_only) |
| desc = 'in scope locals at breakpoint 1' |
| names = ['i'] |
| count = len(names) |
| self.assertEqual( |
| vars.GetSize(), |
| count, |
| "There should be %i %s (%s) but we are reporting %i (%s)" % |
| (count, |
| desc, |
| names, |
| vars.GetSize(), |
| get_names_from_value_list(vars))) |
| self.verify_variable_names("check names of %s" % (desc), vars, names) |
| |
| # Continue to breakpoint 2 |
| process.Continue() |
| |
| threads = lldbutil.get_threads_stopped_at_breakpoint( |
| process, breakpoint2) |
| self.assertEqual( |
| len(threads), |
| 1, |
| "There should be a thread stopped at breakpoint 2") |
| |
| thread = threads[0] |
| self.assertTrue(thread.IsValid(), "Thread must be valid") |
| frame = thread.GetFrameAtIndex(0) |
| self.assertTrue(frame.IsValid(), "Frame must be valid") |
| |
| # Verify if we ask for in scope locals that we got what we expect |
| vars = frame.GetVariables( |
| args_no, locals_yes, statics_no, in_scopy_only) |
| desc = 'in scope locals at breakpoint 2' |
| names = ['i', 'j'] |
| count = len(names) |
| self.assertEqual( |
| vars.GetSize(), |
| count, |
| "There should be %i %s (%s) but we are reporting %i (%s)" % |
| (count, |
| desc, |
| names, |
| vars.GetSize(), |
| get_names_from_value_list(vars))) |
| self.verify_variable_names("check names of %s" % (desc), vars, names) |
| |
| # Continue to breakpoint 3 |
| process.Continue() |
| |
| threads = lldbutil.get_threads_stopped_at_breakpoint( |
| process, breakpoint3) |
| self.assertEqual( |
| len(threads), |
| 1, |
| "There should be a thread stopped at breakpoint 3") |
| |
| thread = threads[0] |
| self.assertTrue(thread.IsValid(), "Thread must be valid") |
| frame = thread.GetFrameAtIndex(0) |
| self.assertTrue(frame.IsValid(), "Frame must be valid") |
| |
| # Verify if we ask for in scope locals that we got what we expect |
| vars = frame.GetVariables( |
| args_no, locals_yes, statics_no, in_scopy_only) |
| desc = 'in scope locals at breakpoint 3' |
| names = ['i', 'j', 'k'] |
| count = len(names) |
| self.assertEqual( |
| vars.GetSize(), |
| count, |
| "There should be %i %s (%s) but we are reporting %i (%s)" % |
| (count, |
| desc, |
| names, |
| vars.GetSize(), |
| get_names_from_value_list(vars))) |
| self.verify_variable_names("check names of %s" % (desc), vars, names) |
