Fix whitespace in the python test suite.

[teemperor]

Summary

The test suite has often unnecessary trailing whitespace, and sometimes
unnecessary trailing lines or a missing final new line. This patch just strips
trailing whitespace/lines and adds missing newlines at the end.

packages/Python/lldbsuite/test/api/multiple-debuggers/TestMultipleDebuggers.py

 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestMultipleSimultaneousDebuggers(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    # This test case fails non-deterministically. 
+    # This test case fails non-deterministically.
     @skipIfNoSBHeaders
     @expectedFailureAll(bugnumber="llvm.org/pr20282")
     def test_multiple_debuggers(self):
         env = {self.dylibPath: self.getLLDBLibraryEnvVal()}
 
         self.driver_exe = self.getBuildArtifact("multi-process-driver")
         self.buildDriver('multi-process-driver.cpp', self.driver_exe)
         self.addTearDownHook(lambda: os.remove(self.driver_exe))

packages/Python/lldbsuite/test/api/multithreaded/TestMultithreaded.py

 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 import subprocess
 
 
 class SBBreakpointCallbackCase(TestBase):
 
     NO_DEBUG_INFO_TESTCASE = True
-   
     def setUp(self):
         TestBase.setUp(self)
         self.generateSource('driver.cpp')
         self.generateSource('listener_test.cpp')
         self.generateSource('test_breakpoint_callback.cpp')
         self.generateSource('test_listener_event_description.cpp')
         self.generateSource('test_listener_event_process_state.cpp')
         self.generateSource('test_listener_resume.cpp')

packages/Python/lldbsuite/test/decorators.py

 def skipIfLLVMTargetMissing(target):
     config = lldb.SBDebugger.GetBuildConfiguration()
     targets = config.GetValueForKey("targets").GetValueForKey("value")
     found = False
     for i in range(targets.GetSize()):
         if targets.GetItemAtIndex(i).GetStringValue(99) == target:
             found = True
             break
-    
     return unittest2.skipIf(not found, "requires " + target)
 
 # Call sysctl on darwin to see if a specified hardware feature is available on this machine.
 def skipUnlessFeature(feature):
     def is_feature_enabled(self):
         if platform.system() == 'Darwin':
             try:
                 DEVNULL = open(os.devnull, 'w')

packages/Python/lldbsuite/test/expression_command/call-function/TestCallStdStringFunction.py

def test_with(self):
         self.runCmd("run", RUN_SUCCEEDED)
 
         self.expect("print str",
                     substrs=['Hello world'])
 
         # Calling this function now succeeds, but we follow the typedef return type through to
         # const char *, and thus don't invoke the Summary formatter.
 
-        # clang's libstdc++ on ios arm64 inlines std::string::c_str() always; 
+        # clang's libstdc++ on ios arm64 inlines std::string::c_str() always;
         # skip this part of the test.
         triple = self.dbg.GetSelectedPlatform().GetTriple()
         do_cstr_test = True
         if triple == "arm64-apple-ios" or triple == "arm64-apple-tvos" or triple == "armv7k-apple-watchos" or triple == "arm64-apple-bridgeos":
             do_cstr_test = False
         if do_cstr_test:
             self.expect("print str.c_str()",
                         substrs=['Hello world'])

packages/Python/lldbsuite/test/expression_command/call-restarts/TestCallThatRestarts.py

def check_after_call(self, num_sigchld):
 
         # Check that we are back where we were before:
         frame = self.thread.GetFrameAtIndex(0)
         self.assertTrue(
             self.orig_frame_pc == frame.GetPC(),
             "Restored the zeroth frame correctly")
 
     def call_function(self):
-        (target, process, self.thread, bkpt) = lldbutil.run_to_source_breakpoint(self, 
+        (target, process, self.thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
                                       'Stop here in main.', self.main_source_spec)
 
         # Make sure the SIGCHLD behavior is pass/no-stop/no-notify:
         return_obj = lldb.SBCommandReturnObject()
         self.dbg.GetCommandInterpreter().HandleCommand(
             "process handle SIGCHLD -s 0 -p 1 -n 0", return_obj)
         self.assertTrue(return_obj.Succeeded(), "Set SIGCHLD to pass, no-stop")
 

packages/Python/lldbsuite/test/expression_command/call-throws/TestCallThatThrows.py

def check_after_call(self):
         # Check that we are back where we were before:
         frame = self.thread.GetFrameAtIndex(0)
         self.assertTrue(
             self.orig_frame_pc == frame.GetPC(),
             "Restored the zeroth frame correctly")
 
     def call_function(self):
         """Test calling function that throws."""
-        (target, process, self.thread, bkpt) = lldbutil.run_to_source_breakpoint(self, 
+        (target, process, self.thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
                                    'I am about to throw.', self.main_source_spec)
 
         options = lldb.SBExpressionOptions()
         options.SetUnwindOnError(True)
 
         frame = self.thread.GetFrameAtIndex(0)
         # Store away the PC to check that the functions unwind to the right
         # place after calls

packages/Python/lldbsuite/test/expression_command/char/TestExprsChar.py

def setUp(self):
 
         self.main_source = "main.cpp"
         self.main_source_spec = lldb.SBFileSpec(self.main_source)
 
     def do_test(self, dictionary=None):
         """These basic expression commands should work as expected."""
         self.build(dictionary=dictionary)
 
-        (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self, 
+        (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
                                           '// Break here', self.main_source_spec)
         frame = thread.GetFrameAtIndex(0)
 
         value = frame.EvaluateExpression("foo(c)")
         self.assertTrue(value.IsValid())
         self.assertTrue(value.GetError().Success())
         self.assertEqual(value.GetValueAsSigned(0), 1)
 

packages/Python/lldbsuite/test/expression_command/fixits/TestFixIts.py

def test_with_dummy_target(self):
         """Test calling expressions in the dummy target with errors that can be fixed by the FixIts."""
         ret_val = lldb.SBCommandReturnObject()
         result = self.dbg.GetCommandInterpreter().HandleCommand("expression ((1 << 16) - 1))", ret_val)
         self.assertEqual(result, lldb.eReturnStatusSuccessFinishResult, "The expression was successful.")
         self.assertTrue("Fix-it applied" in ret_val.GetError(), "Found the applied FixIt.")
 
     def try_expressions(self):
         """Test calling expressions with errors that can be fixed by the FixIts."""
-        (target, process, self.thread, bkpt) = lldbutil.run_to_source_breakpoint(self, 
+        (target, process, self.thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
                                         'Stop here to evaluate expressions', self.main_source_spec)
 
         options = lldb.SBExpressionOptions()
         options.SetAutoApplyFixIts(True)
 
         frame = self.thread.GetFrameAtIndex(0)
 
         # Try with one error:

packages/Python/lldbsuite/test/expression_command/issue_11588/Test11588.py

def test_11581_commands(self):
             self.runCmd('type synthetic clear', check=False)
 
         # Execute the cleanup function during test case tear down.
         self.addTearDownHook(cleanup)
 
         """valobj.AddressOf() should return correct values."""
         self.build()
 
-        (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self, 
-                                              'Set breakpoint here.', 
+        (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
+                                              'Set breakpoint here.',
                                               lldb.SBFileSpec("main.cpp", False))
         self.runCmd("command script import --allow-reload s11588.py")
         self.runCmd(
             "type synthetic add --python-class s11588.Issue11581SyntheticProvider StgClosure")
 
         self.expect("expr --show-types -- *((StgClosure*)(r14-1))",
                     substrs=["(StgClosure) $",
                              "(StgClosure *) &$", "0x",

packages/Python/lldbsuite/test/expression_command/pr35310/TestExprsBug35310.py

class ExprBug35310(TestBase):
     def test_issue35310(self):
         """Test invoking functions with non-standard linkage names.
 
         The GNU abi_tag extension used by libstdc++ is a common source
         of these, but they could originate from other reasons as well.
         """
         self.build()
 
-        (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self, 
+        (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
                                           '// Break here', self.main_source_spec)
         frame = thread.GetFrameAtIndex(0)
 
         value = frame.EvaluateExpression("a.test_abi_tag()")
         self.assertTrue(value.IsValid())
         self.assertTrue(value.GetError().Success())
         self.assertEqual(value.GetValueAsSigned(0), 1)
 
         value = frame.EvaluateExpression("a.test_asm_name()")
         self.assertTrue(value.IsValid())
         self.assertTrue(value.GetError().Success())
         self.assertEqual(value.GetValueAsSigned(0), 2)

packages/Python/lldbsuite/test/expression_command/save_jit_objects/TestSaveJITObjects.py

 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class SaveJITObjectsTestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     def enumerateJITFiles(self):
         return [f for f in os.listdir(self.getBuildDir()) if f.startswith("jit")]
-    
     def countJITFiles(self):
         return len(self.enumerateJITFiles())
 
     def cleanJITFiles(self):
         for j in self.enumerateJITFiles():
             os.remove(j)
         return
 
     @expectedFailureAll(oslist=["windows"])
     def test_save_jit_objects(self):
         self.build()
         os.chdir(self.getBuildDir())
         src_file = "main.c"
         src_file_spec = lldb.SBFileSpec(src_file)
-  
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(
             self, "break", src_file_spec)
 
         frame = thread.frames[0]
 
         self.cleanJITFiles()
         frame.EvaluateExpression("(void*)malloc(0x1)")
         self.assertTrue(self.countJITFiles() == 0,

packages/Python/lldbsuite/test/expression_command/unwind_expression/TestUnwindExpression.py

 class UnwindFromExpressionTest(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     main_spec = lldb.SBFileSpec("main.cpp", False)
 
     def build_and_run_to_bkpt(self):
         self.build()
 
-        (target, process, self.thread, bkpt) = lldbutil.run_to_source_breakpoint(self, 
+        (target, process, self.thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
                 "// Set a breakpoint here to get started", self.main_spec)
 
         # Next set a breakpoint in this function, set up Expression options to stop on
         # breakpoint hits, and call the function.
         self.fun_bkpt = self.target().BreakpointCreateBySourceRegex(
             "// Stop inside the function here.", self.main_spec)
         self.assertTrue(self.fun_bkpt, VALID_BREAKPOINT)
 

packages/Python/lldbsuite/test/expression_command/xvalue/TestXValuePrinting.py

def setUp(self):
 
         self.main_source = "main.cpp"
         self.main_source_spec = lldb.SBFileSpec(self.main_source)
 
     def do_test(self, dictionary=None):
         """Printing an xvalue should work."""
         self.build(dictionary=dictionary)
 
-        (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self, 
+        (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
                                           '// Break here', self.main_source_spec)
         frame = thread.GetFrameAtIndex(0)
 
         value = frame.EvaluateExpression("foo().data")
         self.assertTrue(value.IsValid())
         self.assertTrue(value.GetError().Success())
         self.assertEqual(value.GetValueAsSigned(), 1234)
 
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765")
     def test(self):
         self.do_test()
 

packages/Python/lldbsuite/test/functionalities/breakpoint/address_breakpoints/TestBadAddressBreakpoints.py

class BadAddressBreakpointTestCase(TestBase):
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
 
     def address_breakpoints(self):
         """Test that breakpoints set on a bad address say they are bad."""
         target, process, thread, bkpt = \
-            lldbutil.run_to_source_breakpoint(self, 
+            lldbutil.run_to_source_breakpoint(self,
                                               "Set a breakpoint here",
                                               lldb.SBFileSpec("main.c"))
 
         # Now see if we can read from 0.  If I can't do that, I don't
         # have a good way to know what an illegal address is...
         error = lldb.SBError()
 
         ptr = process.ReadPointerFromMemory(0x0, error)
 
         if not error.Success():
             bkpt = target.BreakpointCreateByAddress(0x0)
             for bp_loc in bkpt:
                 self.assertTrue(bp_loc.IsResolved() == False)
         else:
             self.fail(
                 "Could not find an illegal address at which to set a bad breakpoint.")

packages/Python/lldbsuite/test/functionalities/breakpoint/auto_continue/TestBreakpointAutoContinue.py

def test_auto_continue_with_command(self):
         self.build()
         self.auto_continue_with_command()
 
     def test_auto_continue_on_location(self):
         """Set auto-continue on a location and make sure only that location continues"""
         self.build()
         self.auto_continue_location()
 
-    def make_target_and_bkpt(self, additional_options=None, num_expected_loc=1, 
+    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, 
+        bpno = lldbutil.run_break_set_by_source_regexp(self, pattern,
+                                            extra_options = extra_options_txt,
                                             num_expected_locations = num_expected_loc)
         return bpno
 
     def launch_it (self, expected_state):
         error = lldb.SBError()
         launch_info = lldb.SBLaunchInfo(None)
         launch_info.SetWorkingDirectory(self.get_process_working_directory())
 

packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_locations/TestBreakpointLocations.py

def setUp(self):
         self.line = line_number('main.c', '// Set break point at this line.')
 
     def set_breakpoint (self):
         exe = self.getBuildArtifact("a.out")
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, "Target %s is not valid"%(exe))
 
         # This should create a breakpoint with 3 locations.
-        
         bkpt = target.BreakpointCreateByLocation("main.c", self.line)
 
         # The breakpoint list should show 3 locations.
         self.assertEqual(bkpt.GetNumLocations(), 3, "Wrong number of locations")
-        
         self.expect(
             "breakpoint list -f",
             "Breakpoint locations shown correctly",
             substrs=[
                 "1: file = 'main.c', line = %d, exact_match = 0, locations = 3" %
                 self.line],
             patterns=[
                 "where = a.out`func_inlined .+unresolved, hit count = 0",
                 "where = a.out`main .+\[inlined\].+unresolved, hit count = 0"])
 
-        return bkpt        
+        return bkpt
 
     def shadowed_bkpt_cond_test(self):
         """Test that options set on the breakpoint and location behave correctly."""
         # Breakpoint option propagation from bkpt to loc used to be done the first time
         # a breakpoint location option was specifically set.  After that the other options
         # on that location would stop tracking the breakpoint.  That got fixed, and this test
         # makes sure only the option touched is affected.
 
def shadowed_bkpt_command_test(self):
         # a breakpoint location option was specifically set.  After that the other options
         # on that location would stop tracking the breakpoint.  That got fixed, and this test
         # makes sure only the option touched is affected.
 
         bkpt = self.set_breakpoint()
         commands = ["AAAAAA", "BBBBBB", "CCCCCC"]
         str_list = lldb.SBStringList()
         str_list.AppendList(commands, len(commands))
-        
         bkpt.SetCommandLineCommands(str_list)
         cmd_list = lldb.SBStringList()
         bkpt.GetCommandLineCommands(cmd_list)
         list_size = str_list.GetSize()
         self.assertEqual(cmd_list.GetSize() , list_size, "Added the right number of commands")
         for i in range(0,list_size):
             self.assertEqual(str_list.GetStringAtIndex(i), cmd_list.GetStringAtIndex(i), "Mismatched commands.")
 
         commands = ["DDDDDD", "EEEEEE", "FFFFFF", "GGGGGG"]
         loc_list = lldb.SBStringList()
         loc_list.AppendList(commands, len(commands))
         bkpt.location[1].SetCommandLineCommands(loc_list)
         loc_cmd_list = lldb.SBStringList()
         bkpt.location[1].GetCommandLineCommands(loc_cmd_list)
 
         loc_list_size = loc_list.GetSize()
-        
         # Check that the location has the right commands:
         self.assertEqual(loc_cmd_list.GetSize() , loc_list_size, "Added the right number of commands to location")
         for i in range(0,loc_list_size):
             self.assertEqual(loc_list.GetStringAtIndex(i), loc_cmd_list.GetStringAtIndex(i), "Mismatched commands.")
 
         # Check that we didn't mess up the breakpoint level commands:
         self.assertEqual(cmd_list.GetSize() , list_size, "Added the right number of commands")
         for i in range(0,list_size):

packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_names/TestBreakpointNames.py

class BreakpointNames(TestBase):
 
     def setup_target(self):
         exe = self.getBuildArtifact("a.out")
 
         # Create a targets we are making breakpoint in and copying to:
         self.target = self.dbg.CreateTarget(exe)
         self.assertTrue(self.target, VALID_TARGET)
         self.main_file_spec = lldb.SBFileSpec(os.path.join(self.getSourceDir(), "main.c"))
-        
     def check_name_in_target(self, bkpt_name):
         name_list = lldb.SBStringList()
         self.target.GetBreakpointNames(name_list)
         found_it = False
         for name in name_list:
             if name == bkpt_name:
                 found_it = True
                 break
         self.assertTrue(found_it, "Didn't find the name %s in the target's name list:"%(bkpt_name))
-       
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
 
         # These are the settings we're going to be putting into names & breakpoints:
         self.bp_name_string = "ABreakpoint"
         self.is_one_shot = True
         self.ignore_count = 1000
def do_check_names(self):
         other_bkpt_name = "_AnotherBreakpoint"
 
         # Add a name and make sure we match it:
         success = bkpt.AddName(bkpt_name)
         self.assertTrue(success, "We couldn't add a legal name to a breakpoint.")
 
         matches = bkpt.MatchesName(bkpt_name)
         self.assertTrue(matches, "We didn't match the name we just set")
-        
         # Make sure we don't match irrelevant names:
         matches = bkpt.MatchesName("NotABreakpoint")
         self.assertTrue(not matches, "We matched a name we didn't set.")
 
         # Make sure the name is also in the target:
         self.check_name_in_target(bkpt_name)
- 
         # Add another name, make sure that works too:
         bkpt.AddName(other_bkpt_name)
 
         matches = bkpt.MatchesName(bkpt_name)
         self.assertTrue(matches, "Adding a name means we didn't match the name we just set")
         self.check_name_in_target(other_bkpt_name)
 
         # Remove the name and make sure we no longer match it:
         bkpt.RemoveName(bkpt_name)
         matches = bkpt.MatchesName(bkpt_name)
         self.assertTrue(not matches,"We still match a name after removing it.")
 
         # Make sure the name list has the remaining name:
         name_list = lldb.SBStringList()
         bkpt.GetNames(name_list)
         num_names = name_list.GetSize()
         self.assertTrue(num_names == 1, "Name list has %d items, expected 1."%(num_names))
-        
         name = name_list.GetStringAtIndex(0)
         self.assertTrue(name == other_bkpt_name, "Remaining name was: %s expected %s."%(name, other_bkpt_name))
 
     def do_check_illegal_names(self):
         """Use Python APIs to check that we reject illegal names."""
         bkpt = self.target.BreakpointCreateByLocation(self.main_file_spec, 10)
         bad_names = ["-CantStartWithADash",
                      "1CantStartWithANumber",
                      "^CantStartWithNonAlpha",
                      "CantHave-ADash",
                      "Cant Have Spaces"]
         for bad_name in bad_names:
             success = bkpt.AddName(bad_name)
             self.assertTrue(not success,"We allowed an illegal name: %s"%(bad_name))
             bp_name = lldb.SBBreakpointName(self.target, bad_name)
             self.assertFalse(bp_name.IsValid(), "We made a breakpoint name with an illegal name: %s"%(bad_name));
 
             retval =lldb.SBCommandReturnObject()
             self.dbg.GetCommandInterpreter().HandleCommand("break set -n whatever -N '%s'"%(bad_name), retval)
             self.assertTrue(not retval.Succeeded(), "break set succeeded with: illegal name: %s"%(bad_name))
 
     def do_check_using_names(self):
         """Use Python APIs to check names work in place of breakpoint ID's."""
-        
         bkpt = self.target.BreakpointCreateByLocation(self.main_file_spec, 10)
         bkpt_name = "ABreakpoint"
         other_bkpt_name= "_AnotherBreakpoint"
 
         # Add a name and make sure we match it:
         success = bkpt.AddName(bkpt_name)
         self.assertTrue(success, "We couldn't add a legal name to a breakpoint.")
 
def do_check_configuring_names(self):
         self.check_option_values(bkpt)
 
         # Now change the name's option and make sure it gets propagated to
         # the breakpoint:
         new_auto_continue = not self.auto_continue
         bp_name.SetAutoContinue(new_auto_continue)
         self.assertEqual(bp_name.GetAutoContinue(), new_auto_continue, "Couldn't change auto-continue on the name")
         self.assertEqual(bkpt.GetAutoContinue(), new_auto_continue, "Option didn't propagate to the breakpoint.")
-        
         # Now make this same breakpoint name - but from the command line
-        cmd_str = "breakpoint name configure %s -o %d -i %d -c '%s' -G %d -t %d -x %d -T '%s' -q '%s' -H '%s'"%(cl_bp_name_string, 
-                                                                             self.is_one_shot, 
-                                                                             self.ignore_count, 
-                                                                             self.condition, 
+        cmd_str = "breakpoint name configure %s -o %d -i %d -c '%s' -G %d -t %d -x %d -T '%s' -q '%s' -H '%s'"%(cl_bp_name_string,
+                                                                             self.is_one_shot,
+                                                                             self.ignore_count,
+                                                                             self.condition,
                                                                              self.auto_continue,
                                                                              self.tid,
                                                                              self.tidx,
                                                                              self.thread_name,
                                                                              self.queue_name,
                                                                              self.help_string)
         for cmd in self.cmd_list:
             cmd_str += " -C '%s'"%(cmd)
-        
         self.runCmd(cmd_str, check=True)
         # Now look up this name again and check its options:
         cl_name = lldb.SBBreakpointName(self.target, cl_bp_name_string)
         self.check_option_values(cl_name)
         # Also check the help string:
         self.assertEqual(self.help_string, cl_name.GetHelpString(), "Help string didn't match")
         # Change the name and make sure that works:
         new_help = "I do something even more interesting"
         cl_name.SetHelpString(new_help)
         self.assertEqual(new_help, cl_name.GetHelpString(), "SetHelpString didn't")
-        
         # We should have three names now, make sure the target can list them:
         name_list = lldb.SBStringList()
         self.target.GetBreakpointNames(name_list)
         for name_string in [self.bp_name_string, other_bp_name_string, cl_bp_name_string]:
             self.assertTrue(name_string in name_list, "Didn't find %s in names"%(name_string))
 
-        # Delete the name from the current target.  Make sure that works and deletes the 
+        # Delete the name from the current target.  Make sure that works and deletes the
         # name from the breakpoint as well:
         self.target.DeleteBreakpointName(self.bp_name_string)
         name_list.Clear()
         self.target.GetBreakpointNames(name_list)
         self.assertTrue(self.bp_name_string not in name_list, "Didn't delete %s from a real target"%(self.bp_name_string))
         # Also make sure the name got removed from breakpoints holding it:
         self.assertFalse(bkpt.MatchesName(self.bp_name_string), "Didn't remove the name from the breakpoint.")
 
         # Test that deleting the name we injected into the dummy target works (there's also a
         # cleanup that will do this, but that won't test the result...
         dummy_target = self.dbg.GetDummyTarget()
         dummy_target.DeleteBreakpointName(self.bp_name_string)
         name_list.Clear()
         dummy_target.GetBreakpointNames(name_list)
         self.assertTrue(self.bp_name_string not in name_list, "Didn't delete %s from the dummy target"%(self.bp_name_string))
         # Also make sure the name got removed from breakpoints holding it:
         self.assertFalse(bkpt.MatchesName(self.bp_name_string), "Didn't remove the name from the breakpoint.")
-        
     def check_permission_results(self, bp_name):
         self.assertEqual(bp_name.GetAllowDelete(), False, "Didn't set allow delete.")
         protected_bkpt = self.target.BreakpointCreateByLocation(self.main_file_spec, 10)
         protected_id = protected_bkpt.GetID()
 
         unprotected_bkpt = self.target.BreakpointCreateByLocation(self.main_file_spec, 10)
         unprotected_id = unprotected_bkpt.GetID()
 

packages/Python/lldbsuite/test/functionalities/breakpoint/hardware_breakpoints/hardware_breakpoint_on_multiple_threads/TestHWBreakMultiThread.py

class HardwareBreakpointMultiThreadTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     # LLDB supports hardware breakpoints for arm and aarch64 architectures.
     @skipIf(archs=no_match(['arm', 'aarch64']))
     @expectedFailureAndroid
     def test_hw_break_set_delete_multi_thread(self):
         self.build()
-        self.setTearDownCleanup() 
+        self.setTearDownCleanup()
         self.break_multi_thread('delete')
 
     # LLDB supports hardware breakpoints for arm and aarch64 architectures.
     @skipIf(archs=no_match(['arm', 'aarch64']))
     @expectedFailureAndroid
     def test_hw_break_set_disable_multi_thread(self):
         self.build()
-        self.setTearDownCleanup() 
+        self.setTearDownCleanup()
         self.break_multi_thread('disable')
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Our simple source filename.
         self.source = 'main.cpp'
         # Find the line number to break inside main().
def break_multi_thread(self, removal_type):
                 'Breakpoint',
                 'hw_break_function',
                 'address = 0x'])
 
         # We should stop in hw_break_function function for 4 threads.
         count = 0
 
         while count < 2 :
-         
             self.runCmd("process continue")
 
             # We should be stopped in hw_break_function
             # The stop reason of the thread should be breakpoint.
             self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                 substrs=[
                     'stop reason = breakpoint',
                     'hw_break_function'])

packages/Python/lldbsuite/test/functionalities/breakpoint/serialize/TestBreakpointSerialization.py

def setup_targets_and_cleanup(self):
         self.addTearDownHook(cleanup)
         self.RemoveTempFile(self.bkpts_file_path)
 
         exe = self.getBuildArtifact("a.out")
 
         # Create the targets we are making breakpoints in and copying them to:
         self.orig_target = self.dbg.CreateTarget(exe)
         self.assertTrue(self.orig_target, VALID_TARGET)
-        
         self.copy_target = self.dbg.CreateTarget(exe)
         self.assertTrue(self.copy_target, VALID_TARGET)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
 
         self.bkpts_file_path = self.getBuildArtifact("breakpoints.json")
def check_equivalence(self, source_bps, do_write = True):
 
         copy_bps = lldb.SBBreakpointList(self.copy_target)
         error = self.copy_target.BreakpointsCreateFromFile(self.bkpts_file_spec, copy_bps)
         self.assertTrue(error.Success(), "Failed reading breakpoints from file: %s"%(error.GetCString()))
 
         num_source_bps = source_bps.GetSize()
         num_copy_bps = copy_bps.GetSize()
         self.assertTrue(num_source_bps == num_copy_bps, "Didn't get same number of input and output breakpoints - orig: %d copy: %d"%(num_source_bps, num_copy_bps))
-        
         for i in range(0, num_source_bps):
             source_bp = source_bps.GetBreakpointAtIndex(i)
             source_desc = lldb.SBStream()
             source_bp.GetDescription(source_desc, False)
             source_text = source_desc.GetData()
 
             # I am assuming here that the breakpoints will get written out in breakpoint ID order, and
             # read back in ditto.  That is true right now, and I can't see any reason to do it differently
def do_check_resolvers(self):
         source_bps.Append(self.orig_target.BreakpointCreateByLocation("blubby.c", 666))
         # Make sure we do one breakpoint right:
         self.check_equivalence(source_bps)
         source_bps.Clear()
 
         source_bps.Append(self.orig_target.BreakpointCreateByName("blubby", lldb.eFunctionNameTypeAuto, empty_module_list, empty_cu_list))
         source_bps.Append(self.orig_target.BreakpointCreateByName("blubby", lldb.eFunctionNameTypeFull, empty_module_list,empty_cu_list))
         source_bps.Append(self.orig_target.BreakpointCreateBySourceRegex("dont really care", blubby_file_spec))
-        
         # And some number greater than one:
         self.check_equivalence(source_bps)
 
     def do_check_filters(self):
         """Use Python APIs to check serialization of breakpoint filters."""
         module_list = lldb.SBFileSpecList()
         module_list.Append(lldb.SBFileSpec("SomeBinary"))
         module_list.Append(lldb.SBFileSpec("SomeOtherBinary"))
def do_check_options(self):
         # actually have locations.
         source_bps = lldb.SBBreakpointList(self.orig_target)
 
         bkpt = self.orig_target.BreakpointCreateByLocation("blubby.c", 666)
         bkpt.SetEnabled(False)
         bkpt.SetOneShot(True)
         bkpt.SetThreadID(10)
         source_bps.Append(bkpt)
-        
         # Make sure we get one right:
         self.check_equivalence(source_bps)
         source_bps.Clear()
 
         bkpt = self.orig_target.BreakpointCreateByName("blubby", lldb.eFunctionNameTypeAuto, empty_module_list, empty_cu_list)
         bkpt.SetIgnoreCount(10)
         bkpt.SetThreadName("grubby")
         source_bps.Append(bkpt)
def do_check_appending(self):
         source_bps = lldb.SBBreakpointList(self.orig_target)
 
         bkpt = self.orig_target.BreakpointCreateByLocation("blubby.c", 666)
         bkpt.SetEnabled(False)
         bkpt.SetOneShot(True)
         bkpt.SetThreadID(10)
         source_bps.Append(bkpt)
         all_bps.Append(bkpt)
-        
         error = lldb.SBError()
         error = self.orig_target.BreakpointsWriteToFile(self.bkpts_file_spec, source_bps)
         self.assertTrue(error.Success(), "Failed writing breakpoints to file: %s."%(error.GetCString()))
 
         source_bps.Clear()
 
         bkpt = self.orig_target.BreakpointCreateByName("blubby", lldb.eFunctionNameTypeAuto, empty_module_list, empty_cu_list)
         bkpt.SetIgnoreCount(10)
def do_check_appending(self):
         self.check_equivalence(all_bps)
 
     def do_check_names(self):
         bkpt = self.orig_target.BreakpointCreateByLocation("blubby.c", 666)
         good_bkpt_name = "GoodBreakpoint"
         write_bps = lldb.SBBreakpointList(self.orig_target)
         bkpt.AddName(good_bkpt_name)
         write_bps.Append(bkpt)
-        
         error = lldb.SBError()
         error = self.orig_target.BreakpointsWriteToFile(self.bkpts_file_spec, write_bps)
         self.assertTrue(error.Success(), "Failed writing breakpoints to file: %s."%(error.GetCString()))
 
         copy_bps = lldb.SBBreakpointList(self.copy_target)
         names_list = lldb.SBStringList()
         names_list.AppendString("NoSuchName")
 
         error = self.copy_target.BreakpointsCreateFromFile(self.bkpts_file_spec, names_list, copy_bps)
         self.assertTrue(error.Success(), "Failed reading breakpoints from file: %s"%(error.GetCString()))
         self.assertTrue(copy_bps.GetSize() == 0, "Found breakpoints with a nonexistent name.")
 
         names_list.AppendString(good_bkpt_name)
         error = self.copy_target.BreakpointsCreateFromFile(self.bkpts_file_spec, names_list, copy_bps)
         self.assertTrue(error.Success(), "Failed reading breakpoints from file: %s"%(error.GetCString()))
         self.assertTrue(copy_bps.GetSize() == 1, "Found the matching breakpoint.")
-        
-        
-        
-        

packages/Python/lldbsuite/test/functionalities/breakpoint/step_over_breakpoint/TestStepOverBreakpoint.py

 """
 Test that breakpoints do not affect stepping.
-Check for correct StopReason when stepping to the line with breakpoint 
+Check for correct StopReason when stepping to the line with breakpoint
 which chould be eStopReasonBreakpoint in general,
-and eStopReasonPlanComplete when breakpoint's condition fails.  
+and eStopReasonPlanComplete when breakpoint's condition fails.
 """
 
 from __future__ import print_function
 
 import unittest2
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class StepOverBreakpointsTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         TestBase.setUp(self)
-       
         self.build()
         exe = self.getBuildArtifact("a.out")
         src = lldb.SBFileSpec("main.cpp")
 
         # Create a target by the debugger.
         self.target = self.dbg.CreateTarget(exe)
         self.assertTrue(self.target, VALID_TARGET)
 
         # Setup four breakpoints, two of them with false condition
         self.line1 = line_number('main.cpp', "breakpoint_1")
         self.line4 = line_number('main.cpp', "breakpoint_4")
 
-        self.breakpoint1 = self.target.BreakpointCreateByLocation(src, self.line1)        
+        self.breakpoint1 = self.target.BreakpointCreateByLocation(src, self.line1)
         self.assertTrue(
             self.breakpoint1 and self.breakpoint1.GetNumLocations() == 1,
             VALID_BREAKPOINT)
 
         self.breakpoint2 = self.target.BreakpointCreateBySourceRegex("breakpoint_2", src)
         self.breakpoint2.GetLocationAtIndex(0).SetCondition('false')
 
         self.breakpoint3 = self.target.BreakpointCreateBySourceRegex("breakpoint_3", src)
         self.breakpoint3.GetLocationAtIndex(0).SetCondition('false')
 
         self.breakpoint4 = self.target.BreakpointCreateByLocation(src, self.line4)
 
         # Start debugging
         self.process = self.target.LaunchSimple(
             None, None, self.get_process_working_directory())
         self.assertIsNotNone(self.process, PROCESS_IS_VALID)
         self.thread = lldbutil.get_one_thread_stopped_at_breakpoint(self.process, self.breakpoint1)
         self.assertIsNotNone(self.thread, "Didn't stop at breakpoint 1.")
 
-    def test_step_instruction(self): 
+    def test_step_instruction(self):
         # Count instructions between breakpoint_1 and breakpoint_4
         contextList = self.target.FindFunctions('main', lldb.eFunctionNameTypeAuto)
         self.assertEquals(contextList.GetSize(), 1)
         symbolContext = contextList.GetContextAtIndex(0)
         function = symbolContext.GetFunction()
         self.assertTrue(function)
         instructions = function.GetInstructions(self.target)
         addr_1 = self.breakpoint1.GetLocationAtIndex(0).GetAddress()
def test_step_instruction(self):
 
         # Run the process until termination
         self.process.Continue()
         self.assertEquals(self.process.GetState(), lldb.eStateExited)
 
     @skipIf(bugnumber="llvm.org/pr31972", hostoslist=["windows"])
     def test_step_over(self):
         #lldb.DBG.EnableLog("lldb", ["step","breakpoint"])
-        
         self.thread.StepOver()
         # We should be stopped at the breakpoint_2 line with stop plan complete reason
         self.assertEquals(self.process.GetState(), lldb.eStateStopped)
         self.assertEquals(self.thread.GetStopReason(), lldb.eStopReasonPlanComplete)
 
         self.thread.StepOver()
         # We should be stopped at the breakpoint_3 line with stop plan complete reason
         self.assertEquals(self.process.GetState(), lldb.eStateStopped)

packages/Python/lldbsuite/test/functionalities/completion/TestCompletion.py

def complete_from_to(self, str_input, patterns, turn_off_re_match=False):
             patterns = [patterns]
 
         interp = self.dbg.GetCommandInterpreter()
         match_strings = lldb.SBStringList()
         num_matches = interp.HandleCompletion(str_input, len(str_input), 0, -1, match_strings)
         common_match = match_strings.GetStringAtIndex(0)
         if num_matches == 0:
             compare_string = str_input
-        else: 
+        else:
             if common_match != None and len(common_match) > 0:
                 compare_string = str_input + common_match
             else:
                 compare_string = ""
                 for idx in range(1, num_matches+1):
                     compare_string += match_strings.GetStringAtIndex(idx) + "\n"
 
         for p in patterns:
             if turn_off_re_match:
                 self.expect(
                     compare_string, msg=COMPLETION_MSG(
                         str_input, p), exe=False, substrs=[p])
             else:
                 self.expect(
                     compare_string, msg=COMPLETION_MSG(
                         str_input, p), exe=False, patterns=[p])

packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/bitset/TestDataFormatterLibcxxBitset.py

def test_value(self):
         self.check("empty", 0)
         self.check("small", 13)
         self.check("large", 200)
 
     @add_test_categories(["libc++"])
     def test_ptr_and_ref(self):
         """Test that ref and ptr to std::bitset is displayed correctly"""
         self.build()
-        (_, process, _, bkpt) = lldbutil.run_to_source_breakpoint(self, 
+        (_, process, _, bkpt) = lldbutil.run_to_source_breakpoint(self,
                 'Check ref and ptr',
                 lldb.SBFileSpec("main.cpp", False))
 
         self.check("ref", 13)
         self.check("ptr", 13)
 
         lldbutil.continue_to_breakpoint(process, bkpt)
-        
         self.check("ref", 200)
         self.check("ptr", 200)

packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/list/TestDataFormatterLibcxxList.py

def test_with_run_command(self):
                              '{}'])
 
         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")

packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/multiset/TestDataFormatterLibcxxMultiSet.py

def test_with_run_command(self):
                 '[1] = "a very long string is right here"',
                 '[2] = "c"'])
 
     @add_test_categories(["libc++"])
     def test_ref_and_ptr(self):
         """Test that the data formatters work on ref and ptr."""
         self.build()
         (self.target, process, _, bkpt) = lldbutil.run_to_source_breakpoint(
-            self, "Stop here to check by ref and ptr.", 
+            self, "Stop here to check by ref and ptr.",
             lldb.SBFileSpec("main.cpp", False))
         # The reference should print just like the value:
         self.check_ii("ref")
 
         self.expect("frame variable ptr",
                     substrs=["ptr =", "size=7"])
         self.expect("expr ptr",
                     substrs=["size=7"])

packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/set/TestDataFormatterLibcxxSet.py

def test_with_run_command(self):
                      '[1] = "a very long string is right here"',
                      '[2] = "c"'])
 
     @add_test_categories(["libc++"])
     def test_ref_and_ptr(self):
         """Test that the data formatters work on ref and ptr."""
         self.build()
         (self.target, process, _, bkpt) = lldbutil.run_to_source_breakpoint(
-            self, "Stop here to check by ref and ptr.", 
+            self, "Stop here to check by ref and ptr.",
             lldb.SBFileSpec("main.cpp", False))
         # The reference should print just like the value:
         self.check_ii("ref")
 
         self.expect("frame variable ptr",
                     substrs=["ptr =", "size=7"])
         self.expect("expr ptr",
                     substrs=["size=7"])
-                    

packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libcxx/vector/TestDataFormatterLibcxxVector.py

def test_ref_and_ptr(self):
         self.build()
         (self.target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(
             self, "Stop here to check by ref", lldb.SBFileSpec("main.cpp", False))
 
         # The reference should display the same was as the value did
         self.check_numbers("ref")
 
         # The pointer should just show the right number of elements:
-        
         self.expect("frame variable ptr", substrs=['ptr =', ' size=7'])
 
         self.expect("p ptr", substrs=['$', 'size=7'])

packages/Python/lldbsuite/test/functionalities/data-formatter/data-formatter-stl/libstdcpp/tuple/TestDataFormatterStdTuple.py

def test_with_run_command(self):
         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())

packages/Python/lldbsuite/test/functionalities/exec/TestExec.py

def do_test(self, skip_exec):
         self.assertTrue(int_value == 3, "Expression got the right result.")
 
         # Run and we should stop due to exec
         process.Continue()
 
         if not skip_exec:
             self.assertTrue(process.GetState() == lldb.eStateStopped,
                             "Process should be stopped at __dyld_start")
-            
             threads = lldbutil.get_stopped_threads(
                 process, lldb.eStopReasonExec)
             self.assertTrue(
                 len(threads) == 1,
                 "We got a thread stopped for exec.")
 
             # Run and we should stop at breakpoint in main after exec
             process.Continue()

packages/Python/lldbsuite/test/functionalities/frame-language/TestGuessLanguage.py

 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 
 
 class TestFrameGuessLanguage(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    # If your test case doesn't stress debug info, the 
+    # If your test case doesn't stress debug info, the
     # set this to true.  That way it won't be run once for
     # each debug info format.
     NO_DEBUG_INFO_TESTCASE = True
 
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr37658")
     def test_guess_language(self):
         """Test GuessLanguage for C and C++."""
         self.build()
def do_test(self):
         c_frame_language = lldb.eLanguageTypeC99
         # gcc emits DW_LANG_C89 even if -std=c99 was specified
         if "gcc" in self.getCompiler():
             c_frame_language = lldb.eLanguageTypeC89
 
         self.check_language(thread, 0, c_frame_language)
         self.check_language(thread, 1, lldb.eLanguageTypeC_plus_plus)
         self.check_language(thread, 2, lldb.eLanguageTypeC_plus_plus)
-        
-        
 

packages/Python/lldbsuite/test/functionalities/frame_var/TestFrameVar.py

 import lldbsuite.test.lldbutil as lldbutil
 from lldbsuite.test.lldbtest import *
 
 
 class TestFrameVar(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    # If your test case doesn't stress debug info, the 
+    # If your test case doesn't stress debug info, the
     # set this to true.  That way it won't be run once for
     # each debug info format.
     NO_DEBUG_INFO_TESTCASE = True
 
     def test_frame_var(self):
         self.build()
         self.do_test()
 
def do_test(self):
             "There should be a thread stopped at our breakpoint")
 
         # The hit count for the breakpoint should be 1.
         self.assertTrue(breakpoint.GetHitCount() == 1)
 
         frame = threads[0].GetFrameAtIndex(0)
         command_result = lldb.SBCommandReturnObject()
         interp = self.dbg.GetCommandInterpreter()
-        
         # Just get args:
         result = interp.HandleCommand("frame var -l", command_result)
         self.assertEqual(result, lldb.eReturnStatusSuccessFinishResult, "frame var -a didn't succeed")
         output = command_result.GetOutput()
         self.assertTrue("argc" in output, "Args didn't find argc")
         self.assertTrue("argv" in output, "Args didn't find argv")
         self.assertTrue("test_var" not in output, "Args found a local")
         self.assertTrue("g_var" not in output, "Args found a global")
 
         # Just get locals:
         result = interp.HandleCommand("frame var -a", command_result)
         self.assertEqual(result, lldb.eReturnStatusSuccessFinishResult, "frame var -a didn't succeed")
         output = command_result.GetOutput()
         self.assertTrue("argc" not in output, "Locals found argc")
         self.assertTrue("argv" not in output, "Locals found argv")
         self.assertTrue("test_var" in output, "Locals didn't find test_var")
         self.assertTrue("g_var" not in output, "Locals found a global")
-        
         # Get the file statics:
         result = interp.HandleCommand("frame var -l -a -g", command_result)
         self.assertEqual(result, lldb.eReturnStatusSuccessFinishResult, "frame var -a didn't succeed")
         output = command_result.GetOutput()
         self.assertTrue("argc" not in output, "Globals found argc")
         self.assertTrue("argv" not in output, "Globals found argv")
         self.assertTrue("test_var" not in output, "Globals found test_var")
         self.assertTrue("g_var" in output, "Globals didn't find g_var")
-        
-                        
 

packages/Python/lldbsuite/test/functionalities/gdb_remote_client/TestTargetXMLArch.py

def test(self):
 
             def qC(self):
                 return "QC1"
 
             def haltReason(self):
                 return "T05thread:00000001;06:9038d60f00700000;07:98b4062680ffffff;10:c0d7bf1b80ffffff;"
 
             def readRegister(self, register):
-                regs = {0x0: "00b0060000610000", 
-                        0xa: "68fe471c80ffffff", 
-                        0xc: "60574a1c80ffffff", 
-                        0xd: "18f3042680ffffff", 
-                        0xe: "be8a4d7142000000", 
-                        0xf: "50df471c80ffffff", 
+                regs = {0x0: "00b0060000610000",
+                        0xa: "68fe471c80ffffff",
+                        0xc: "60574a1c80ffffff",
+                        0xd: "18f3042680ffffff",
+                        0xe: "be8a4d7142000000",
+                        0xf: "50df471c80ffffff",
                         0x10: "c0d7bf1b80ffffff" }
                 if register in regs:
                     return regs[register]
                 else:
                     return "0000000000000000"
 
         self.server.responder = MyResponder()
         interp = self.dbg.GetCommandInterpreter()

packages/Python/lldbsuite/test/functionalities/gdb_remote_client/gdbclientutils.py

def assertPacketLogContains(self, packets):
         sent the expected packets to the server.
 
         The check does not require that the packets be consecutive, but does
         require that they are ordered in the log as they ordered in the arg.
         """
         i = 0
         j = 0
         log = self.server.responder.packetLog
-        
         while i < len(packets) and j < len(log):
             if log[j] == packets[i]:
                 i += 1
             j += 1
         if i < len(packets):
             self.fail(u"Did not receive: %s\nLast 10 packets:\n\t%s" %
                     (packets[i], u'\n\t'.join(log[-10:])))

packages/Python/lldbsuite/test/functionalities/history/TestHistoryRecall.py

 import lldbsuite.test.lldbutil as lldbutil
 from lldbsuite.test.lldbtest import *
 
 
 class TestHistoryRecall(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    # If your test case doesn't stress debug info, the 
+    # If your test case doesn't stress debug info, the
     # set this to true.  That way it won't be run once for
     # each debug info format.
     NO_DEBUG_INFO_TESTCASE = True
 
     def test_history_recall(self):
         """Test the !N and !-N functionality of the command interpreter."""
         self.sample_test()
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
 
     def sample_test(self):
         interp = self.dbg.GetCommandInterpreter()
         result = lldb.SBCommandReturnObject()
         interp.HandleCommand("command history", result, True)
         interp.HandleCommand("platform list", result, True)
-        
         interp.HandleCommand("!0", result, False)
         self.assertTrue(result.Succeeded(), "!0 command did not work: %s"%(result.GetError()))
         self.assertTrue("command history" in result.GetOutput(), "!0 didn't rerun command history")
 
         interp.HandleCommand("!-1", result, False)
         self.assertTrue(result.Succeeded(), "!-1 command did not work: %s"%(result.GetError()))
         self.assertTrue("host:" in result.GetOutput(), "!-1 didn't rerun platform list.")

packages/Python/lldbsuite/test/functionalities/load_unload/TestLoadUnload.py

 
 
 @skipIfWindows  # Windows doesn't have dlopen and friends, dynamic libraries work differently
 class LoadUnloadTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     NO_DEBUG_INFO_TESTCASE = True
-   
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         self.setup_test()
         # Invoke the default build rule.
         self.build()
         # Find the line number to break for main.cpp.
         self.line = line_number(
def test_dyld_library_path(self):
         self.runCmd("continue")
 
         # Add the hidden directory first in the search path.
         env_cmd_string = ("settings set target.env-vars %s=%s" %
                           (self.dylibPath, new_dir))
         if not self.platformIsDarwin():
             env_cmd_string += ":" + wd
         self.runCmd(env_cmd_string)
-        
         # This time, the hidden library should be picked up.
         self.expect("run", substrs=["return", "12345"])
 
     @expectedFailureAll(
         bugnumber="llvm.org/pr25805",
         hostoslist=["windows"],
         triple='.*-android')
     @skipIfFreeBSD  # llvm.org/pr14424 - missing FreeBSD Makefiles/testcase support

packages/Python/lldbsuite/test/functionalities/load_using_paths/TestLoadUsingPaths.py

 
 
 @skipIfWindows  # The Windows platform doesn't implement DoLoadImage.
 class LoadUsingPathsTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     NO_DEBUG_INFO_TESTCASE = True
-   
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Make the hidden directory in the build hierarchy:
         lldbutil.mkdir_p(self.getBuildArtifact("hidden"))
 
         # Invoke the default build rule.
         self.build()
def test_load_using_paths(self):
         if self.platformIsDarwin():
             dylibName = 'libloadunload_d.dylib'
         else:
             dylibName = 'libloadunload_d.so'
 
         # The directory with the dynamic library we did not link to.
         path_dir = os.path.join(self.getBuildDir(), "hidden")
 
-        (target, process, thread, 
-         _) = lldbutil.run_to_source_breakpoint(self, 
+        (target, process, thread,
+         _) = lldbutil.run_to_source_breakpoint(self,
                                                 "Break here to do the load using paths",
                                                 lldb.SBFileSpec("main.cpp"))
         error = lldb.SBError()
         lib_spec = lldb.SBFileSpec(self.lib_name)
         paths = lldb.SBStringList()
         paths.AppendString(self.wd)
         paths.AppendString(os.path.join(self.wd, "no_such_dir"))
 
         out_spec = lldb.SBFileSpec()
-        
         # First try with no correct directories on the path, and make sure that doesn't blow up:
         token = process.LoadImageUsingPaths(lib_spec, paths, out_spec, error)
         self.assertEqual(token, lldb.LLDB_INVALID_IMAGE_TOKEN, "Only looked on the provided path.")
-        
         # Now add the correct dir to the paths list and try again:
         paths.AppendString(self.hidden_dir)
         token = process.LoadImageUsingPaths(lib_spec, paths, out_spec, error)
 
         self.assertNotEqual(token, lldb.LLDB_INVALID_IMAGE_TOKEN, "Got a valid token")
         self.assertEqual(out_spec, lldb.SBFileSpec(self.hidden_lib), "Found the expected library")
-        
         # Make sure this really is in the image list:
         loaded_module = target.FindModule(out_spec)
 
         self.assertTrue(loaded_module.IsValid(), "The loaded module is in the image list.")
 
         # Now see that we can call a function in the loaded module.
         value = thread.frames[0].EvaluateExpression("d_function()", lldb.SBExpressionOptions())
         self.assertTrue(value.GetError().Success(), "Got a value from the expression")
         ret_val = value.GetValueAsSigned()
         self.assertEqual(ret_val, 12345, "Got the right value")
 
         # Make sure the token works to unload it:
         process.UnloadImage(token)
 
-        # Make sure this really is no longer in the image list: 
+        # Make sure this really is no longer in the image list:
         loaded_module = target.FindModule(out_spec)
 
         self.assertFalse(loaded_module.IsValid(), "The unloaded module is no longer in the image list.")
-        
         # Make sure a relative path also works:
         paths.Clear()
         paths.AppendString(os.path.join(self.wd, "no_such_dir"))
         paths.AppendString(self.wd)
         relative_spec = lldb.SBFileSpec(os.path.join("hidden", self.lib_name))
 
         out_spec = lldb.SBFileSpec()
         token = process.LoadImageUsingPaths(relative_spec, paths, out_spec, error)
 
         self.assertNotEqual(token, lldb.LLDB_INVALID_IMAGE_TOKEN, "Got a valid token with relative path")
         self.assertEqual(out_spec, lldb.SBFileSpec(self.hidden_lib), "Found the expected library with relative path")
 
         process.UnloadImage(token)
-        
         # Make sure the presence of an empty path doesn't mess anything up:
         paths.Clear()
         paths.AppendString("")
         paths.AppendString(os.path.join(self.wd, "no_such_dir"))
         paths.AppendString(self.wd)
         relative_spec = lldb.SBFileSpec(os.path.join("hidden", self.lib_name))
 
         out_spec = lldb.SBFileSpec()
         token = process.LoadImageUsingPaths(relative_spec, paths, out_spec, error)
 
         self.assertNotEqual(token, lldb.LLDB_INVALID_IMAGE_TOKEN, "Got a valid token with included empty path")
         self.assertEqual(out_spec, lldb.SBFileSpec(self.hidden_lib), "Found the expected library with included empty path")
 
         process.UnloadImage(token)
-        
 
 
         # Finally, passing in an absolute path should work like the basename:
         # This should NOT work because we've taken hidden_dir off the paths:
         abs_spec = lldb.SBFileSpec(os.path.join(self.hidden_dir, self.lib_name))
 
         token = process.LoadImageUsingPaths(lib_spec, paths, out_spec, error)
         self.assertEqual(token, lldb.LLDB_INVALID_IMAGE_TOKEN, "Only looked on the provided path.")
 
         # But it should work when we add the dir:
         # Now add the correct dir to the paths list and try again:
         paths.AppendString(self.hidden_dir)
         token = process.LoadImageUsingPaths(lib_spec, paths, out_spec, error)
 
         self.assertNotEqual(token, lldb.LLDB_INVALID_IMAGE_TOKEN, "Got a valid token")
         self.assertEqual(out_spec, lldb.SBFileSpec(self.hidden_lib), "Found the expected library")
 
-                                        

packages/Python/lldbsuite/test/functionalities/pre_run_dylibs/TestPreRunDylibs.py

def test(self):
         for module in target.modules:
             file_name = module.GetFileSpec().GetFilename()
             if file_name.find("unlikely_name") != -1:
                 found_it = True
                 break
 
         self.assertTrue(found_it, "Couldn't find unlikely_to_occur_name in loaded libraries.")
 
-            

packages/Python/lldbsuite/test/functionalities/register/intel_avx/TestZMMRegister.py

def test(self):
             register_byte = (byte_pattern2 | j)
             pattern = "ymm" + str(i) + " = " + str('{') + (
                 str(hex(register_byte)) + ' ') * 31 + str(hex(register_byte)) + str('}')
 
             self.runCmd("thread step-inst")
             self.expect(
                 "register read ymm" + str(i),
                 substrs=[pattern])
-        
         self.expect("continue", PROCESS_STOPPED, substrs=['stopped'])
 
         # Check stop reason; Should be either signal SIGTRAP or EXC_BREAKPOINT
         output = self.res.GetOutput()
         matched = False
         substrs = [
             'stop reason = EXC_BREAKPOINT',
             'stop reason = signal SIGTRAP']

packages/Python/lldbsuite/test/functionalities/return-value/TestReturnValue.py

def test_with_python(self):
         self.assertTrue(return_value.IsValid())
 
         ret_int = return_value.GetValueAsSigned(error)
         self.assertTrue(error.Success())
         self.assertTrue(in_int == ret_int)
 
         # Run again and we will stop in inner_sint the second time outer_sint is called.
         # Then test stepping out two frames at once:
-        
         thread_list = lldbutil.continue_to_breakpoint(self.process, inner_sint_bkpt)
         self.assertTrue(len(thread_list) == 1)
         thread = thread_list[0]
 
         # We are done with the inner_sint breakpoint:
         self.target.BreakpointDelete(inner_sint_bkpt.GetID())
 
         frame = thread.GetFrameAtIndex(1)

packages/Python/lldbsuite/test/functionalities/thread/create_during_step/TestCreateDuringStep.py

def create_during_step_base(self, step_cmd, step_stop_reason):
         """Test thread creation while using step-in."""
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Get the target process
         target = self.dbg.GetSelectedTarget()
 
         # This should create a breakpoint in the stepping thread.
-        self.bkpt = target.BreakpointCreateByLocation("main.cpp", self.breakpoint) 
+        self.bkpt = target.BreakpointCreateByLocation("main.cpp", self.breakpoint)
 
         # Run the program.
         self.runCmd("run", RUN_SUCCEEDED)
 
         process = target.GetProcess()
 
         # The stop reason of the thread should be breakpoint.
         stepping_thread = lldbutil.get_one_thread_stopped_at_breakpoint(process, self.bkpt)

packages/Python/lldbsuite/test/functionalities/thread/num_threads/TestNumThreads.py

def test_unique_stacks(self):
         # Get the number of threads
         num_threads = process.GetNumThreads()
 
         # Using std::thread may involve extra threads, so we assert that there are
         # at least 10 thread3's rather than exactly 10.
         self.assertTrue(
             num_threads >= 10,
             'Number of expected threads and actual threads do not match.')
-        
         # Attempt to walk each of the thread's executing the thread3 function to
         # the same breakpoint.
         def is_thread3(thread):
             for frame in thread:
                 if "thread3" in frame.GetFunctionName(): return True
             return False
 
         expect_threads = ""

packages/Python/lldbsuite/test/functionalities/thread/step_until/TestStepUntil.py

def do_until (self, args, until_lines, expected_linenum):
         thread = self.common_setup(None)
 
         cmd_interp = self.dbg.GetCommandInterpreter()
         ret_obj = lldb.SBCommandReturnObject()
 
         cmd_line = "thread until"
         for line_num in until_lines:
             cmd_line += " %d"%(line_num)
- 
         cmd_interp.HandleCommand(cmd_line, ret_obj)
         self.assertTrue(ret_obj.Succeeded(), "'%s' failed: %s."%(cmd_line, ret_obj.GetError()))
 
         frame = thread.frames[0]
         line = frame.GetLineEntry().GetLine()
         self.assertEqual(line, expected_linenum, 'Did not get the expected stop line number')
 
     def test_hitting_one (self):

packages/Python/lldbsuite/test/functionalities/watchpoint/multi_watchpoint_slots/TestWatchpointMultipleSlots.py

def test_multiple_watchpoints_on_same_word(self):
                     substrs=['stopped', 'stop reason = watchpoint 1'])
 
         # Delete the watchpoint we hit above successfully.
         self.expect("watchpoint delete 1", substrs=['1 watchpoints deleted'])
 
         # Set a watchpoint at byteArray[3]
         self.expect("watchpoint set variable byteArray[3]", WATCHPOINT_CREATED,
                     substrs=['Watchpoint created','size = 1'])
-   
         # Resume inferior.
         self.runCmd("process continue")
 
         # We should be stopped due to the watchpoint.
         # The stop reason of the thread should be watchpoint.
         if self.platformIsDarwin():
             # On darwin we'll hit byteArray[3] which is watchpoint 2
             self.expect("thread list -v", STOPPED_DUE_TO_WATCHPOINT,
                         substrs=['stopped', 'stop reason = watchpoint 2'])
         else:
             self.expect("thread list -v", STOPPED_DUE_TO_WATCHPOINT,
                         substrs=['stopped', 'stop reason = watchpoint 3'])
-   
         # Resume inferior.
         self.runCmd("process continue")

packages/Python/lldbsuite/test/functionalities/watchpoint/watchpoint_disable/TestWatchpointDisable.py

def do_test(self, test_enable):
         self.assertTrue(ret_val.Succeeded(), "Watchpoint set variable did not return success.")
 
         wp = self.target.FindWatchpointByID(1)
         self.assertTrue(wp.IsValid(), "Didn't make a valid watchpoint.")
         self.assertTrue(wp.GetWatchAddress() != lldb.LLDB_INVALID_ADDRESS, "Watch address is invalid")
 
         wp.SetEnabled(False)
         self.assertTrue(not wp.IsEnabled(), "The watchpoint thinks it is still enabled")
-        
         process.Continue()
-        
         stop_reason = thread.GetStopReason()
 
         self.assertEqual(stop_reason, lldb.eStopReasonBreakpoint, "We didn't stop at our breakpoint.")
 
         if test_enable:
             wp.SetEnabled(True)
             self.assertTrue(wp.IsEnabled(), "The watchpoint thinks it is still disabled.")
             process.Continue()
             stop_reason = thread.GetStopReason()
             self.assertEqual(stop_reason, lldb.eStopReasonWatchpoint, "We didn't stop at our watchpoint")
-        

packages/Python/lldbsuite/test/lang/c/find_struct_type/TestFindStructTypes.py

 import lldbsuite.test.lldbutil as lldbutil
 from lldbsuite.test.lldbtest import *
 
 
 class TestFindTypesOnStructType(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    # If your test case doesn't stress debug info, the 
+    # If your test case doesn't stress debug info, the
     # set this to true.  That way it won't be run once for
     # each debug info format.
     NO_DEBUG_INFO_TESTCASE = True
 
     def test_find_types_struct_type(self):
         """Make sure FindTypes actually finds 'struct typename' not just 'typename'."""
         self.build()
         self.do_test()

packages/Python/lldbsuite/test/lang/cpp/dynamic-value-same-basename/TestDynamicValueSameBase.py

 import lldbsuite.test.lldbutil as lldbutil
 from lldbsuite.test.lldbtest import *
 
 
 class DynamicValueSameBaseTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    # If your test case doesn't stress debug info, the 
+    # If your test case doesn't stress debug info, the
     # set this to true.  That way it won't be run once for
     # each debug info format.
     NO_DEBUG_INFO_TESTCASE = True
 
     def test_same_basename_this(self):
         """Test that the we use the full name to resolve dynamic types."""
         self.build()
         self.main_source_file = lldb.SBFileSpec("main.cpp")
         self.sample_test()
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
 
     def sample_test(self):
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
-                                   "Break here to get started", self.main_source_file) 
+                                   "Break here to get started", self.main_source_file)
 
         # Set breakpoints in the two class methods and run to them:
         namesp_bkpt = target.BreakpointCreateBySourceRegex("namesp function did something.", self.main_source_file)
         self.assertEqual(namesp_bkpt.GetNumLocations(), 1, "Namespace breakpoint invalid")
 
         virtual_bkpt = target.BreakpointCreateBySourceRegex("Virtual function did something.", self.main_source_file)
         self.assertEqual(virtual_bkpt.GetNumLocations(), 1, "Virtual breakpoint invalid")
 
def sample_test(self):
         threads = lldbutil.continue_to_breakpoint(process, virtual_bkpt)
         self.assertEqual(len(threads), 1, "Didn't stop at virtual breakpoint")
 
         frame = threads[0].frame[0]
         virtual_this = frame.FindVariable("this", lldb.eDynamicCanRunTarget)
         virtual_type = virtual_this.GetType().GetUnqualifiedType()
         self.assertEqual(virtual_type.GetName(), "Virtual *", "Didn't get the right dynamic type")
 
-        
 

packages/Python/lldbsuite/test/lang/cpp/incomplete-types/TestCppIncompleteTypes.py

def test_partial_limit_debug_info(self):
             "'expr a' results in a valid SBValue object")
         self.assertTrue(value_a.GetError().Success(), "'expr a' is successful")
 
     def get_test_frame(self, exe):
         # Get main source file
         src_file = "main.cpp"
         src_file_spec = lldb.SBFileSpec(src_file)
 
-        (target, process, thread, main_breakpoint) = lldbutil.run_to_source_breakpoint(self, 
+        (target, process, thread, main_breakpoint) = lldbutil.run_to_source_breakpoint(self,
                 "break here", src_file_spec, exe_name = exe)
         # Get frame for current thread
         return thread.GetSelectedFrame()

packages/Python/lldbsuite/test/lang/cpp/llvm-style/TestLLVMStyle.py

 from lldbsuite.test import lldbinline
 from lldbsuite.test import decorators
 
 lldbinline.MakeInlineTest(
     __file__, globals(), [
         decorators.expectedFailureAll(
-            oslist=["windows"], bugnumber="llvm.org/pr24764")])
+            oslist=["windows"], bugnumber="llvm.org/pr24764")])
 

packages/Python/lldbsuite/test/lang/cpp/scope/TestCppScope.py

class TestCppScopes(TestBase):
 
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24764")
     def test_all_but_c(self):
         self.do_test(False)
 
     @expectedFailureAll(oslist=["windows"])
     def test_c(self):
         self.do_test(True)
-    
     def do_test(self, test_c):
         self.build()
 
         # Get main source file
         src_file = os.path.join(self.getSourceDir(), "main.cpp")
         src_file_spec = lldb.SBFileSpec(src_file)
         self.assertTrue(src_file_spec.IsValid(), "Main source file")
 

packages/Python/lldbsuite/test/lang/cpp/trivial_abi/TestTrivialABI.py

class TestTrivialABI(TestBase):
     def check_frame(self, thread):
         frame = thread.frames[0]
         inVal_var = frame.FindVariable("inVal")
         self.check_value(inVal_var, 10)
 
         options = lldb.SBExpressionOptions()
         inVal_expr = frame.EvaluateExpression("inVal", options)
         self.check_value(inVal_expr, 10)
-        
         thread.StepOut()
         outVal_ret = thread.GetStopReturnValue()
         self.check_value(outVal_ret, 30)
 
     def expr_test(self, trivial):
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
-                                   "Set a breakpoint here", self.main_source_file) 
+                                   "Set a breakpoint here", self.main_source_file)
 
         # Stop in a function that takes a trivial value, and try both frame var & expr to get its value:
         if trivial:
             self.check_frame(thread)
             return
 
         # Now continue to the same thing without the trivial_abi and see if we get that right:
         threads = lldbutil.continue_to_breakpoint(process, bkpt)
         self.assertEqual(len(threads), 1, "Hit my breakpoint the second time.")
 
         self.check_frame(threads[0])

packages/Python/lldbsuite/test/lldbdwarf.py

def evaluateDwarfExpression(self, dwarf_opcode, byte_order):
         for index in range(len(dwarf_opcode)):
 
             if index < len(dwarf_opcode):
                 val = int(dwarf_opcode[index], 16)
             else:
                 break
 
             if val == DW_OP_regx:
-                # Read register number 
+                # Read register number
                 self.assertTrue(len(dwarf_opcode) > (index + 1))
                 reg_no = int(dwarf_opcode.pop(index + 1), 16)
 
                 self.reset_test_sequence()
                 # Read register value
                 self.test_sequence.add_log_lines(
                              ["read packet: $p{0:x}#00".format(reg_no),
                              {"direction": "send", "regex": r"^\$([0-9a-fA-F]+)#",
                              "capture": {1: "p_response"}}],True)
-                
                 Context = self.expect_gdbremote_sequence()
                 self.assertIsNotNone(Context)
                 p_response = Context.get("p_response")
                 self.assertIsNotNone(p_response)
 
                 if byte_order == lldb.eByteOrderLittle:
                    # In case of little endian
                    # first decode the HEX ASCII bytes and then reverse it
                    # to get actual value of SR register
                    p_response = "".join(reversed([p_response[i:i+2] for i in range(0,
                                                   len(p_response),2)]))
                 # Push register value
                 dwarf_data.append(int(p_response,16))
 
             elif val == DW_OP_lit1:
                 # Push literal 1
                 dwarf_data.append(1)
-           
             elif val == DW_OP_lit26:
                 # Push literal 26
                 dwarf_data.append(26)
 
             elif val == DW_OP_shl:
                 # left shift and push the result back
                 self.assertTrue(len(dwarf_data) > 1)
                 shift_amount = dwarf_data.pop()

packages/Python/lldbsuite/test/lldbtest.py

class Base(unittest2.TestCase):
 
     def getBuildDirBasename(self):
         return self.__class__.__module__ + "." + self.testMethodName
 
     def getBuildDir(self):
         """Return the full path to the current test."""
         return os.path.join(os.environ["LLDB_BUILD"], self.mydir,
                             self.getBuildDirBasename())
-    
-     
     def makeBuildDir(self):
         """Create the test-specific working directory, deleting any previous
         contents."""
         # See also dotest.py which sets up ${LLDB_BUILD}.
         bdir = self.getBuildDir()
         if os.path.isdir(bdir):
             shutil.rmtree(bdir)
         lldbutil.mkdir_p(bdir)
- 
     def getBuildArtifact(self, name="a.out"):
         """Return absolute path to an artifact in the test's build directory."""
         return os.path.join(self.getBuildDir(), name)
- 
     def getSourcePath(self, name):
         """Return absolute path to a file in the test's source directory."""
         return os.path.join(self.getSourceDir(), name)
 
     def setUp(self):
         """Fixture for unittest test case setup.
 
         It works with the test driver to conditionally skip tests and does other
class TestBase(Base):
     # Can be overridden by the LLDB_TIME_WAIT_NEXT_LAUNCH environment variable.
     timeWaitNextLaunch = 1.0
 
     def generateSource(self, source):
         template = source + '.template'
         temp = os.path.join(self.getSourceDir(), template)
         with open(temp, 'r') as f:
             content = f.read()
-            
         public_api_dir = os.path.join(
             os.environ["LLDB_SRC"], "include", "lldb", "API")
 
         # Look under the include/lldb/API directory and add #include statements
         # for all the SB API headers.
         public_headers = os.listdir(public_api_dir)
         # For different platforms, the include statement can vary.
         if self.hasDarwinFramework():

packages/Python/lldbsuite/test/lldbutil.py

for thread in process:
             threads.append(thread)
     return threads
 
 # Helper functions for run_to_{source,name}_breakpoint:
 
 def run_to_breakpoint_make_target(test, exe_name, in_cwd):
     if in_cwd:
         exe = test.getBuildArtifact(exe_name)
-    
     # Create the target
     target = test.dbg.CreateTarget(exe)
     test.assertTrue(target, "Target: %s is not valid."%(exe_name))
     return target
 
 def run_to_breakpoint_do_run(test, target, bkpt, launch_info):
 
     # Launch the process, and do not stop at the entry point.
     if not launch_info:
         launch_info = lldb.SBLaunchInfo(None)
         launch_info.SetWorkingDirectory(test.get_process_working_directory())
 
     error = lldb.SBError()
     process = target.Launch(launch_info, error)
 
-    test.assertTrue(process, 
-                    "Could not create a valid process for %s: %s"%(target.GetExecutable().GetFilename(), 
+    test.assertTrue(process,
+                    "Could not create a valid process for %s: %s"%(target.GetExecutable().GetFilename(),
                     error.GetCString()))
 
     # Frame #0 should be at our breakpoint.
     threads = get_threads_stopped_at_breakpoint(
                 process, bkpt)
 
     test.assertTrue(len(threads) == 1, "Expected 1 thread to stop at breakpoint, %d did."%(len(threads)))
     thread = threads[0]
     return (target, process, thread, bkpt)
 
-def run_to_name_breakpoint (test, bkpt_name, launch_info = None, 
+def run_to_name_breakpoint (test, bkpt_name, launch_info = None,
                             exe_name = "a.out",
                             bkpt_module = None,
                             in_cwd = True):
     """Start up a target, using exe_name as the executable, and run it to
        a breakpoint set by name on bkpt_name restricted to bkpt_module.
 
        If you want to pass in launch arguments or environment
        variables, you can optionally pass in an SBLaunchInfo.  If you
"""Start up a target, using exe_name as the executable, and run it to
 
        The rest of the behavior is the same as run_to_name_breakpoint.
     """
 
     target = run_to_breakpoint_make_target(test, exe_name, in_cwd)
     # Set the breakpoints
     breakpoint = target.BreakpointCreateBySourceRegex(
             bkpt_pattern, source_spec, bkpt_module)
-    test.assertTrue(breakpoint.GetNumLocations() > 0, 
+    test.assertTrue(breakpoint.GetNumLocations() > 0,
                     'No locations found for source breakpoint: "%s", file: "%s", dir: "%s"'%(bkpt_pattern, source_spec.GetFilename(), source_spec.GetDirectory()))
     return run_to_breakpoint_do_run(test, target, breakpoint, launch_info)
 
 def continue_to_breakpoint(process, bkpt):
     """ Continues the process, if it stops, returns the threads stopped at bkpt; otherwise, returns None"""
     process.Continue()
     if process.GetState() != lldb.eStateStopped:
         return None

packages/Python/lldbsuite/test/macosx/find-app-in-bundle/TestFindAppInBundle.py

def find_app_in_bundle_test(self):
         self.assertTrue(bkpt.GetNumLocations() == 1, "Couldn't set a breakpoint in the main app")
 
         if lldbplatformutil.getPlatform() == "macosx":
             launch_info = lldb.SBLaunchInfo(None)
             launch_info.SetWorkingDirectory(self.get_process_working_directory())
 
             error = lldb.SBError()
             process = target.Launch(launch_info, error)
-            
             self.assertTrue(process.IsValid(), "Could not create a valid process for TestApp: %s"%(error.GetCString()))
-            
             # Frame #0 should be at our breakpoint.
             threads = lldbutil.get_threads_stopped_at_breakpoint(process, bkpt)
-            
             self.assertTrue(len(threads) == 1, "Expected 1 thread to stop at breakpoint, %d did."%(len(threads)))
 
 

packages/Python/lldbsuite/test/macosx/find-dsym/bundle-with-dot-in-filename/TestBundleWithDotInFilename.py

def test_attach_and_check_dsyms(self):
         os.chdir(self.getBuildDir());
         popen = self.spawnSubprocess(exe)
         self.addTearDownHook(self.cleanupSubprocesses)
 
         # Give the inferior time to start up, dlopen a bundle, remove the bundle it linked in
         sleep(5)
 
         # Since the library that was dlopen()'ed is now removed, lldb will need to find the
-        # binary & dSYM via target.exec-search-paths 
+        # binary & dSYM via target.exec-search-paths
         settings_str = "settings set target.exec-search-paths " + self.get_process_working_directory() + "/hide.app"
         self.runCmd(settings_str)
 
         self.runCmd("process attach -p " + str(popen.pid))
 
         target = self.dbg.GetSelectedTarget()
         self.assertTrue(target.IsValid(), 'Should have a valid Target after attaching to process')
 

packages/Python/lldbsuite/test/macosx/find-dsym/deep-bundle/TestDeepBundle.py

def test_attach_and_check_dsyms(self):
         self.build()
         popen = self.spawnSubprocess(exe, [self.getBuildDir()])
         self.addTearDownHook(self.cleanupSubprocesses)
 
         # Give the inferior time to start up, dlopen a bundle, remove the bundle it linked in
         sleep(5)
 
         # Since the library that was dlopen()'ed is now removed, lldb will need to find the
-        # binary & dSYM via target.exec-search-paths 
+        # binary & dSYM via target.exec-search-paths
         settings_str = "settings set target.exec-search-paths " + self.get_process_working_directory() + "/hide.app"
         self.runCmd(settings_str)
         self.runCmd("process attach -p " + str(popen.pid))
 
         target = self.dbg.GetSelectedTarget()
         self.assertTrue(target.IsValid(), 'Should have a valid Target after attaching to process')
 
         setup_complete = target.FindFirstGlobalVariable("setup_is_complete")
         self.assertTrue(setup_complete.GetValueAsUnsigned() == 1, 'Check that inferior process has completed setup')
 
         # Find the bundle module, see if we found the dSYM too (they're both in "hide.app")
         i = 0
         found_module = False
         while i < target.GetNumModules():
             mod = target.GetModuleAtIndex(i)
             if mod.GetFileSpec().GetFilename() == 'MyFramework':
                 found_module = True
                 dsym_name = mod.GetSymbolFileSpec().GetFilename()
                 self.assertTrue (dsym_name == 'MyFramework', "Check that we found the dSYM for the bundle that was loaded")
             i=i+1
-         
         self.assertTrue(found_module, "Check that we found the framework loaded in lldb's image list")
 
 if __name__ == '__main__':
     unittest.main()

packages/Python/lldbsuite/test/macosx/thread-names/TestInterruptThreadNames.py

-"""Test that we get thread names when interrupting a process.""" 
+"""Test that we get thread names when interrupting a process."""
 from __future__ import print_function
 
 
 import os
 import time
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
def test_with_python_api(self):
             if t.GetName() == "third thread":
                 third_thread = t
 
         self.check_expected_threads_present(main_thread, second_thread, third_thread)
 
         process.Kill()
 
 
-    # The process will set a global variable 'threads_up_and_running' to 1 when 
+    # The process will set a global variable 'threads_up_and_running' to 1 when
     # it has has completed its setup.  Sleep for one second, pause the program,
     # check to see if the global has that value, and continue if it does not.
     def wait_until_program_setup_complete(self, process, listener):
         inferior_set_up = lldb.SBValue()
         retry = 5
         while retry > 0:
             arch = self.getArchitecture()
             # when running the testsuite against a remote arm device, it may take
def wait_for_running(self, process, listener):
             if event.GetType() == lldb.SBProcess.eBroadcastBitStateChanged:
                 if process.GetState() == lldb.eStateRunning:
                     return True
             retry_count = retry_count - 1
 
         return False
 
     # Listen to the process events until we get an event saying the process is
-    # stopped.  Retry up to five times in case we get other events that we are 
+    # stopped.  Retry up to five times in case we get other events that we are
     # not looking for.
     def wait_for_stop(self, process, listener):
         retry_count = 5
         if process.GetState() == lldb.eStateStopped or process.GetState() == lldb.eStateCrashed or process.GetState() == lldb.eStateDetached or process.GetState() == lldb.eStateExited:
             return True
 
         while retry_count > 0:
             event = lldb.SBEvent()

packages/Python/lldbsuite/test/python_api/name_lookup/TestNameLookup.py

 class TestNameLookup(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @add_test_categories(['pyapi'])
     @expectedFailureAll(oslist=["windows"], bugnumber='llvm.org/pr21765')
     def test_target(self):
         """Exercise SBTarget.FindFunctions() with various name masks.
-        
         A previous regression caused mangled names to not be able to be looked up.
         This test verifies that using a mangled name with eFunctionNameTypeFull works
         and that using a function basename with eFunctionNameTypeFull works for all
         C++ functions that are at the global namespace level."""
         self.build();
         exe = self.getBuildArtifact("a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         exe_module = target.FindModule(target.GetExecutable())
-        
         c_name_to_symbol = {}
         cpp_name_to_symbol = {}
         mangled_to_symbol = {}
         num_symbols = exe_module.GetNumSymbols();
         for i in range(num_symbols):
             symbol = exe_module.GetSymbolAtIndex(i);
             name = symbol.GetName()
             if name and 'unique_function_name' in name and '__PRETTY_FUNCTION__' not in name:
                 mangled = symbol.GetMangledName()
                 if mangled:
                     mangled_to_symbol[mangled] = symbol
                     if name:
                         cpp_name_to_symbol[name] = symbol
                 elif name:
                     c_name_to_symbol[name] = symbol
 
         # Make sure each mangled name turns up exactly one match when looking up
-        # functions by full name and using the mangled name as the name in the 
+        # functions by full name and using the mangled name as the name in the
         # lookup
         self.assertGreaterEqual(len(mangled_to_symbol), 6)
         for mangled in mangled_to_symbol.keys():
             symbol_contexts = target.FindFunctions(mangled, lldb.eFunctionNameTypeFull)
             self.assertTrue(symbol_contexts.GetSize() == 1)
             for symbol_context in symbol_contexts:
                 self.assertTrue(symbol_context.GetFunction().IsValid())
                 self.assertTrue(symbol_context.GetSymbol().IsValid())
-            
-            

packages/Python/lldbsuite/test/python_api/sbdata/TestSBData.py

class SBDataAPICase(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break on inside main.cpp.
         self.line = line_number('main.cpp', '// set breakpoint here')
 
     @add_test_categories(['pyapi'])
     def test_byte_order_and_address_byte_size(self):
-        """Test the SBData::SetData() to ensure the byte order and address 
+        """Test the SBData::SetData() to ensure the byte order and address
         byte size are obeyed"""
         addr_data = b'\x11\x22\x33\x44\x55\x66\x77\x88'
         error = lldb.SBError()
         data = lldb.SBData()
         data.SetData(error, addr_data, lldb.eByteOrderBig, 4)
         addr = data.GetAddress(error, 0)
         self.assertTrue(addr == 0x11223344);
         data.SetData(error, addr_data, lldb.eByteOrderBig, 8)

packages/Python/lldbsuite/test/sample_test/TestSampleTest.py

 import lldbsuite.test.lldbutil as lldbutil
 from lldbsuite.test.lldbtest import *
 
 
 class RenameThisSampleTestTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    # If your test case doesn't stress debug info, the 
+    # If your test case doesn't stress debug info, the
     # set this to true.  That way it won't be run once for
     # each debug info format.
     NO_DEBUG_INFO_TESTCASE = True
 
     def test_sample_rename_this(self):
         """There can be many tests in a test case - describe this test here."""
         self.build()
         self.main_source_file = lldb.SBFileSpec("main.c")
         self.sample_test()
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
 
     def sample_test(self):
         """You might use the test implementation in several ways, say so here."""
 
         # This function starts a process, "a.out" by default, sets a source
         # breakpoint, runs to it, and returns the thread, process & target.
         # It optionally takes an SBLaunchOption argument if you want to pass
         # arguments or environment variables.
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
-                                   "Set a breakpoint here", self.main_source_file) 
+                                   "Set a breakpoint here", self.main_source_file)
 
         frame = thread.GetFrameAtIndex(0)
         test_var = frame.FindVariable("test_var")
         self.assertTrue(test_var.GetError().Success(), "Failed to fetch test_var")
         test_value = test_var.GetValueAsUnsigned()
         self.assertEqual(test_value, 10, "Got the right value for test_var")
 

packages/Python/lldbsuite/test/settings/TestSettings.py

def test_all_settings_exist(self):
                              "target.process.disable-memory-cache",
                              "target.process.extra-startup-command",
                              "target.process.thread.step-avoid-regexp",
                              "target.process.thread.trace-thread"])
 
     # settings under an ".experimental" domain should have two properties:
     #   1. If the name does not exist with "experimental" in the name path,
     #      the name lookup should try to find it without "experimental".  So
-    #      a previously-experimental setting that has been promoted to a 
+    #      a previously-experimental setting that has been promoted to a
     #      "real" setting will still be set by the original name.
     #   2. Changing a setting with .experimental., name, where the setting
     #      does not exist either with ".experimental." or without, should
     #      not generate an error.  So if an experimental setting is removed,
     #      people who may have that in their ~/.lldbinit files should not see
     #      any errors.
     def test_experimental_settings(self):
         cmdinterp = self.dbg.GetCommandInterpreter()

packages/Python/lldbsuite/test/tools/lldb-mi/startup_options/TestMiStartupOptions.py

class MiStartupOptionsTestCase(lldbmi_testcase.MiTestCaseBase):
     def copyScript(self, sourceFile):
         """copy the script to builddir and replace a.out with the full path"""
         destFile = os.path.join(os.path.dirname(self.myexe),
                                 sourceFile+'.script')
         with open(sourceFile, 'r') as src:
             with open(destFile, 'w+') as dest:
                 dest.write(src.read().replace("a.out", self.myexe))
         return destFile
-        
     @skipIfRemote   # We do not currently support remote debugging via the MI.
     @skipIfWindows  # llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD  # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux  # llvm.org/pr22841: lldb-mi tests fail on all Linux buildbots
     @skipIfDarwin
     def test_lldbmi_source_option_start_script(self):
         """Test that 'lldb-mi --interpreter' can execute user's commands after initial commands were executed."""
 

packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemote_qThreadStopInfo.py

 
 
 class TestGdbRemote_qThreadStopInfo(gdbremote_testcase.GdbRemoteTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
     THREAD_COUNT = 5
 
     @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
-    @skipIfDarwinEmbedded # <rdar://problem/27005337> 
+    @skipIfDarwinEmbedded # <rdar://problem/27005337>
     def gather_stop_replies_via_qThreadStopInfo(self, thread_count):
         # Set up the inferior args.
         inferior_args = []
         for i in range(thread_count - 1):
             inferior_args.append("thread:new")
         inferior_args.append("sleep:10")
         procs = self.prep_debug_monitor_and_inferior(
             inferior_args=inferior_args)

packages/Python/lldbsuite/test/tools/lldb-server/TestLldbGdbServer.py

def breakpoint_set_and_remove_work(self, want_hardware=False):
         # Set the breakpoint.
         if (target_arch == "arm") or (target_arch == "aarch64"):
             # TODO: Handle case when setting breakpoint in thumb code
             BREAKPOINT_KIND = 4
         else:
             BREAKPOINT_KIND = 1
 
         # Set default packet type to Z0 (software breakpoint)
-        z_packet_type = 0       
+        z_packet_type = 0
 
         # If hardware breakpoint is requested set packet type to Z1
         if want_hardware == True:
             z_packet_type = 1
 
         self.reset_test_sequence()
         self.add_set_breakpoint_packets(
             function_address,