def test_without_process(self): """Test that C++ supports char8_t without a running process.""" self.build() lldbutil.run_to_breakpoint_make_target(self) self.expect("target variable a", substrs=["char8_t", "0x61 u8'a'"]) self.expect("target variable ab", substrs=["const char8_t *", 'u8"你好"']) self.expect("target variable abc", substrs=["char8_t[9]", 'u8"你好"']) self.expect_expr("a", result_type="char8_t", result_summary="0x61 u8'a'") self.expect_expr("ab", result_type="const char8_t *", result_summary='u8"你好"') # FIXME: This should work too. self.expect("expr abc", substrs=['u8"你好"'], matching=False)
def test_api(self): """Test that the SBTypeEnumMember API's work correctly for enum_test_days""" self.build() target = lldbutil.run_to_breakpoint_make_target(self) types = target.FindTypes("enum_test_days") self.assertEqual(len(types), 1, "Found more than one enum_test_days type...") type = types.GetTypeAtIndex(0) # First check using the Python list returned by the type: self.check_enum_members(type.enum_members) # Now use the SBTypeEnumMemberList. member_list = type.GetEnumMembers() self.check_enum_members(member_list) # Now check that the by name accessor works: for member in member_list: name = member.name check_member = member_list[name] self.assertTrue(check_member.IsValid(), "Got a valid member for %s." % (name)) self.assertEqual(name, check_member.name, "Got back the right name") self.assertEqual(member.unsigned, check_member.unsigned)
def test_break_on_overload(self): self.build() self.target = lldbutil.run_to_breakpoint_make_target(self) self.check_breakpoint("a_function(int)") self.check_breakpoint("a_function(double)") self.check_breakpoint("a_function(int, double)") self.check_breakpoint("a_function(double, int)")
def test(self): self.build() target = lldbutil.run_to_breakpoint_make_target(self) #This should create a breakpoint with 1 location. bp1_id = \ lldbutil.run_break_set_by_file_and_line(self, "main.cpp", self.break_1, num_expected_locations=1) bp2_id = \ lldbutil.run_break_set_by_file_and_line(self, "main.cpp", self.break_2, num_expected_locations=1) bp3_id = \ lldbutil.run_break_set_by_file_and_line(self, "main.cpp", self.break_3, num_expected_locations=1) #Run the program. self.runCmd("run", RUN_SUCCEEDED) #Get the target process process = target.GetProcess() if self.TraceOn(): print('First stop:') self.printThreadsStoppedByBreakpoint(process) thread_to_suspend = \ lldbutil.get_one_thread_stopped_at_breakpoint_id(process, bp1_id) self.assertIsNotNone(thread_to_suspend, "Should hit breakpoint 1") thread_to_suspend.Suspend() #Do not stop at bp2 and autocontinue to bp3 target.FindBreakpointByID(bp2_id).SetAutoContinue(True) #Run to the third breakpoint self.runCmd("continue") if self.TraceOn(): print('Second stop:') self.printThreadsStoppedByBreakpoint(process) stopped_thread = \ lldbutil.get_one_thread_stopped_at_breakpoint_id(process, bp3_id) self.assertIsNotNone(stopped_thread, "Should hit breakpoint 3") thread_to_suspend.Resume() #Run to completion self.runCmd("continue") #At this point, the inferior process should have exited. self.assertEqual(process.GetState(), lldb.eStateExited, PROCESS_EXITED)
def do_test(self): lib_name = "libDylib.dylib" target = lldbutil.run_to_breakpoint_make_target(self, exe_name=lib_name) module = target.FindModule(lldb.SBFileSpec(lib_name)) self.assertTrue(module.IsValid(), "Didn't find the libDylib.dylib module") # For now the actual version numbers are wrong for a library of 0.0.0 # but the previous code would crash iterating over the resultant # list. So we are testing that that doesn't happen. did_iterate = False for elem in module.GetVersion(): did_iterate = True self.assertTrue(did_iterate, "Didn't get into the GetVersion loop")
def do_test(self): lib_name = "libDylib.dylib" target = lldbutil.run_to_breakpoint_make_target(self, exe_name=lib_name) module = target.FindModule(lldb.SBFileSpec(lib_name)) self.assertTrue(module.IsValid(), "Didn't find the libDylib.dylib module") # For now the actual version numbers are wrong for a library of 0.0.0 # but the previous code would crash iterating over the resultant # list. So we are testing that that doesn't happen. did_iterate = False for elem in module.GetVersion(): did_iterate = True self.assertTrue(did_iterate, "Didn't get into the GetVersion loop")
def make_target_and_import(self): target = lldbutil.run_to_breakpoint_make_target(self) interp = self.dbg.GetCommandInterpreter() error = lldb.SBError() script_name = os.path.join(self.getSourceDir(), "resolver.py") source_name = os.path.join(self.getSourceDir(), "main.c") command = "command script import " + script_name result = lldb.SBCommandReturnObject() interp.HandleCommand(command, result) self.assertTrue(result.Succeeded(), "com scr imp failed: %s"%(result.GetError())) return target
def test(self): self.build() target = lldbutil.run_to_breakpoint_make_target(self) exe_module = self.find_module(target, 'a.out') num_comp_units = exe_module.GetNumCompileUnits() self.assertEqual(num_comp_units, 3) comp_unit = self.find_comp_unit(exe_module, 'compile_unit1.c') cu_type = self.find_type(comp_unit.GetTypes(), 'compile_unit1_type') self.assertTrue(exe_module == cu_type.GetModule()) comp_unit = self.find_comp_unit(exe_module, 'compile_unit2.c') cu_type = self.find_type(comp_unit.GetTypes(), 'compile_unit2_type') self.assertTrue(exe_module == cu_type.GetModule())
def make_target(self): return lldbutil.run_to_breakpoint_make_target(self)
def do_test_stop_at_entry(self, synchronous, remote): """Test the normal launch path in either sync or async mode""" self.build() target = lldbutil.run_to_breakpoint_make_target(self) launch_info = target.GetLaunchInfo() launch_info.SetLaunchFlags(lldb.eLaunchFlagStopAtEntry) old_async = self.dbg.GetAsync() def cleanup(): self.dbg.SetAsync(old_async) self.addTearDownHook(cleanup) if not synchronous: self.dbg.SetAsync(True) listener = lldb.SBListener("test-process-listener") mask = listener.StartListeningForEventClass( self.dbg, lldb.SBProcess.GetBroadcasterClassName(), lldb.SBProcess.eBroadcastBitStateChanged) self.assertEqual(mask, lldb.SBProcess.eBroadcastBitStateChanged, "Got right mask for listener") launch_info.SetListener(listener) else: self.dbg.SetAsync(False) if remote: self.setup_remote_platform() error = lldb.SBError() process = target.Launch(launch_info, error) self.assertSuccess(error, "Launch failed") # If we are asynchronous, we have to wait for the events: if not synchronous: listener = launch_info.GetListener() event = lldb.SBEvent() result = listener.WaitForEvent(30, event) self.assertTrue(result, "Timed out waiting for event from process") state = lldb.SBProcess.GetStateFromEvent(event) self.assertState(state, lldb.eStateStopped, "Didn't get a stopped state after launch") # Okay, we should be stopped. Make sure we are indeed at the # entry point. I only know how to do this on darwin: self.assertEqual(len(process.threads), 1, "Should only have one thread at entry") thread = process.threads[0] frame = thread.GetFrameAtIndex(0) stop_func = frame.name self.assertEqual(stop_func, "_dyld_start") # Now make sure that we can resume the process and have it exit. error = process.Continue() self.assertSuccess(error, "Error continuing") # Fetch events till we get eStateExited: if not synchronous: # Get events till exited. listener = launch_info.GetListener() event = lldb.SBEvent() # We get two running events in a row here??? That's a bug # but not the one I'm testing for, so for now just fetch as # many as were sent. num_running = 0 state = lldb.eStateRunning while state == lldb.eStateRunning: num_running += 1 result = listener.WaitForEvent(30, event) self.assertTrue(result, "Timed out waiting for running") state = lldb.SBProcess.GetStateFromEvent(event) if num_running == 1: self.assertState(state, lldb.eStateRunning, "Got running event") # The last event we should get is the exited event self.assertState(state, lldb.eStateExited, "Got exit event") else: # Make sure that the process has indeed exited state = process.GetState() self.assertState(state, lldb.eStateExited)