[lldb] Replace asserts on .Success() with assertSuccess()

[kastiglione]

Summary

Replace forms of assertTrue(err.Success()) with assertSuccess(err) (added in D82759).

• assertSuccess prints out the error's message
• assertSuccess expresses explicit higher level semantics, both to the reader and for test failure output
• assertSuccess seems not to be well known, using it where possible will help spread knowledge
• assertSuccess statements are more succinct

[shafik]

Can you please provide a motivation in the summary, thank you!

[labath]

Thanks for doing this.

assertSuccess seems not to be well known

That's probably because it was introduced only recently (for all the reasons that you mention).

[kastiglione]

That's probably because it was introduced only recently

Thanks for adding it! I just learned about it.

lldb/test/API/commands/expression/context-object-objc/TestContextObjectObjc.py

def test_context_object_objc(self):
         # Test an empty expression evaluation
         value = obj_val.EvaluateExpression("")
         self.assertFalse(value.IsValid())
         self.assertFalse(value.GetError().Success())
 
         # Test retrieving of a field (not a local with the same name)
         value = obj_val.EvaluateExpression("field")
         self.assertTrue(value.IsValid())
-        self.assertTrue(value.GetError().Success())
+        self.assertSuccess(value.GetError())
         self.assertEqual(value.GetValueAsSigned(), 1111)
 
         # Test if the self pointer is properly evaluated
 
         # Test retrieving of an objcClass's property through the self pointer
         value = obj_val.EvaluateExpression("self.property")
         self.assertTrue(value.IsValid())
         self.assertSuccess(value.GetError())

lldb/test/API/commands/platform/basic/TestPlatformPython.py

def test_shell_interpreter(self):
 
         sh_cmd = lldb.SBPlatformShellCommand('/bin/zsh', 'echo $0')
         self.assertIn('/bin/zsh', sh_cmd.GetShell())
         self.assertIn('echo $0', sh_cmd.GetCommand())
 
         self.build()
         sh_cmd.SetShell(self.getBuildArtifact('a.out'))
         err = platform.Run(sh_cmd)
-        self.assertTrue(err.Success())
+        self.assertSuccess(err)
         self.assertIn("SUCCESS", sh_cmd.GetOutput())

lldb/test/API/commands/watchpoints/multiple_hits/TestMultipleHits.py

def test(self):
         self.assertTrue(buf and buf.IsValid(), "buf is valid")
 
         for i in [0, target.GetAddressByteSize()]:
             member = buf.GetChildAtIndex(i)
             self.assertTrue(member and member.IsValid(), "member is valid")
 
             error = lldb.SBError()
             watch = member.Watch(True, True, True, error)
-            self.assertTrue(error.Success())
+            self.assertSuccess(error)
 
         process.Continue();
         self.assertEqual(process.GetState(), lldb.eStateStopped)
         self.assertEqual(thread.GetStopReason(), lldb.eStopReasonWatchpoint)
 

lldb/test/API/commands/watchpoints/step_over_watchpoint/TestStepOverWatchpoint.py

def test(self):
         read_value = frame.FindValue('g_watch_me_read',
                                      lldb.eValueTypeVariableGlobal)
         self.assertTrue(read_value.IsValid(), "Failed to find read value.")
 
         error = lldb.SBError()
 
         # resolve_location=True, read=True, write=False
         read_watchpoint = read_value.Watch(True, True, False, error)
-        self.assertTrue(error.Success(),
-                        "Error while setting watchpoint: %s" %
-                        error.GetCString())
+        self.assertSuccess(error, "Error while setting watchpoint")
         self.assertTrue(read_watchpoint, "Failed to set read watchpoint.")
 
         thread.StepOver()
         self.assertEquals(thread.GetStopReason(), lldb.eStopReasonWatchpoint,
                         STOPPED_DUE_TO_WATCHPOINT)
         self.assertEquals(thread.GetStopDescription(20), 'watchpoint 1')
 
         process.Continue()
def test(self):
         # watchpoints are not supported yet
         arch = self.getArchitecture()
         if re.match("^mips", arch) or re.match("powerpc64le", arch):
             self.runCmd("watchpoint delete 1")
 
         # resolve_location=True, read=False, write=True
         write_watchpoint = write_value.Watch(True, False, True, error)
         self.assertTrue(write_watchpoint, "Failed to set write watchpoint.")
-        self.assertTrue(error.Success(),
-                        "Error while setting watchpoint: %s" %
-                        error.GetCString())
+        self.assertSuccess(error, "Error while setting watchpoint")
 
         thread.StepOver()
         self.assertEquals(thread.GetStopReason(), lldb.eStopReasonWatchpoint,
                         STOPPED_DUE_TO_WATCHPOINT)
         self.assertEquals(thread.GetStopDescription(20), 'watchpoint 2')
 
         process.Continue()
         self.assertEquals(process.GetState(), lldb.eStateStopped,

lldb/test/API/functionalities/breakpoint/auto_continue/TestBreakpointAutoContinue.py

def make_target_and_bkpt(self, additional_options=None, num_expected_loc=1,
         return bpno
 
     def launch_it (self, expected_state):
         error = lldb.SBError()
         launch_info = self.target.GetLaunchInfo()
         launch_info.SetWorkingDirectory(self.get_process_working_directory())
 
         process = self.target.Launch(launch_info, error)
-        self.assertTrue(error.Success(), "Launch failed.")
+        self.assertSuccess(error, "Launch failed.")
 
         state = process.GetState()
         self.assertEqual(state, expected_state, "Didn't get expected state")
 
         return process
 
     def simple_auto_continue(self):
         bpno = self.make_target_and_bkpt()

lldb/test/API/functionalities/breakpoint/breakpoint_command/TestBreakpointCommandsFromPython.py

def do_set_python_command_from_python(self):
 
         func_bkpt.SetScriptCallbackFunction("bktptcmd.function")
 
         extra_args = lldb.SBStructuredData()
         stream = lldb.SBStream()
         stream.Print('{"side_effect" : "I am fancy"}')
         extra_args.SetFromJSON(stream)
         error = fancy_bkpt.SetScriptCallbackFunction("bktptcmd.another_function", extra_args)
-        self.assertTrue(error.Success(), "Failed to add callback %s"%(error.GetCString()))
+        self.assertSuccess(error, "Failed to add callback")
 
         stream.Clear()
         stream.Print('{"side_effect" : "I am so much fancier"}')
         extra_args.SetFromJSON(stream)
 
         # Fancier's callback is set up from the command line
         id = fancier_bkpt.GetID()
         self.expect("breakpoint command add -F bktptcmd.a_third_function -k side_effect -v 'I am fancier' %d"%(id))
 
         # Not so fancy gets an empty extra_args:
         empty_args = lldb.SBStructuredData()
         error = not_so_fancy_bkpt.SetScriptCallbackFunction("bktptcmd.empty_extra_args", empty_args)
-        self.assertTrue(error.Success(), "Failed to add callback %s"%(error.GetCString()))
+        self.assertSuccess(error, "Failed to add callback")
 
         # Do list breakpoint like fancy:
         stream.Clear()
         stream.Print('{"side_effect" : "I come from list input"}')
         extra_args.SetFromJSON(stream)
         error = list_bkpt.SetScriptCallbackFunction("bktptcmd.a_list_function", extra_args)
-        self.assertTrue(error.Success(), "Failed to add callback %s"%(error.GetCString()))
+        self.assertSuccess(error, "Failed to add callback")
         
         # Clear out canary variables
         side_effect.bktptcmd = None
         side_effect.callback = None
         side_effect.fancy    = None
         side_effect.fancier  = None
         side_effect.not_so_fancy = None
         side_effect.a_list_function = None

lldb/test/API/functionalities/breakpoint/scripted_bkpt/TestScriptedResolver.py

def import_resolver_script(self):
         self.assertTrue(result.Succeeded(), "com scr imp failed: %s"%(result.GetError()))
 
     def make_extra_args(self):
         json_string = '{"symbol":"break_on_me", "test1": "value1"}'
         json_stream = lldb.SBStream()
         json_stream.Print(json_string)
         extra_args = lldb.SBStructuredData()
         error = extra_args.SetFromJSON(json_stream)
-        self.assertTrue(error.Success(), "Error making SBStructuredData: %s"%(error.GetCString()))
+        self.assertSuccess(error, "Error making SBStructuredData")
         return extra_args
 
     def do_test(self):
         """This reads in a python file and sets a breakpoint using it."""
 
         target = self.make_target_and_import()
         extra_args = self.make_extra_args()
 

lldb/test/API/functionalities/breakpoint/serialize/TestBreakpointSerialization.py

def setUp(self):
         self.bkpts_file_spec = lldb.SBFileSpec(self.bkpts_file_path)
 
     def check_equivalence(self, source_bps, do_write = True):
 
         error = lldb.SBError()
 
         if (do_write):
             error = self.orig_target.BreakpointsWriteToFile(self.bkpts_file_spec, source_bps)
-            self.assertTrue(error.Success(), "Failed writing breakpoints to file: %s."%(error.GetCString()))
+            self.assertSuccess(error, "Failed writing breakpoints to file")
 
         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()))
+        self.assertSuccess(error, "Failed reading breakpoints from file")
 
         num_source_bps = source_bps.GetSize()
         num_copy_bps = copy_bps.GetSize()
         self.assertEqual(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()
def do_check_appending(self):
         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()))
+        self.assertSuccess(error, "Failed writing breakpoints to file")
 
         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)
         all_bps.Append(bkpt)
 
         bkpt = self.orig_target.BreakpointCreateByName("blubby", lldb.eFunctionNameTypeFull, empty_module_list,empty_cu_list)
         bkpt.SetCondition("something != something_else")
         bkpt.SetQueueName("grubby")
         bkpt.AddName("FirstName")
         bkpt.AddName("SecondName")
 
         source_bps.Append(bkpt)
         all_bps.Append(bkpt)
 
         error = self.orig_target.BreakpointsWriteToFile(self.bkpts_file_spec, source_bps, True)
-        self.assertTrue(error.Success(), "Failed appending breakpoints to file: %s."%(error.GetCString()))
+        self.assertSuccess(error, "Failed appending breakpoints to file")
 
         self.check_equivalence(all_bps)
 
     def do_check_names(self):
         bkpt = self.orig_target.BreakpointCreateByLocation(
             lldb.SBFileSpec("blubby.c"), 666, 333, 0, lldb.SBFileSpecList())
         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()))
+        self.assertSuccess(error, "Failed writing breakpoints to file")
 
         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.assertSuccess(error, "Failed reading breakpoints from file")
         self.assertEqual(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.assertSuccess(error, "Failed reading breakpoints from file")
         self.assertEqual(copy_bps.GetSize(), 1, "Found the matching breakpoint.")
 
     def do_check_extra_args(self):
 
         import side_effect
         interp = self.dbg.GetCommandInterpreter()
         error = lldb.SBError()
 
         script_name = os.path.join(self.getSourceDir(), "resolver.py")
 
         command = "command script import " + script_name
         result = lldb.SBCommandReturnObject()
         interp.HandleCommand(command, result)
         self.assertTrue(result.Succeeded(), "com scr imp failed: %s"%(result.GetError()))
 
         # First make sure a scripted breakpoint with no args works:
         bkpt = self.orig_target.BreakpointCreateFromScript("resolver.Resolver", lldb.SBStructuredData(),
                                                            lldb.SBFileSpecList(), lldb.SBFileSpecList())
         self.assertTrue(bkpt.IsValid(), "Bkpt is valid")
         write_bps = lldb.SBBreakpointList(self.orig_target)
 
         error = self.orig_target.BreakpointsWriteToFile(self.bkpts_file_spec, write_bps)
-        self.assertTrue(error.Success(), "Failed writing breakpoints: %s"%(error.GetCString()))
+        self.assertSuccess(error, "Failed writing breakpoints")
 
         side_effect.g_extra_args = None
         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: %s"%(error.GetCString()))
+        self.assertSuccess(error, "Failed reading breakpoints")
 
         self.assertEqual(copy_bps.GetSize(), 1, "Got one breakpoint from file.")
         no_keys = lldb.SBStringList()
         side_effect.g_extra_args.GetKeys(no_keys)
         self.assertEqual(no_keys.GetSize(), 0, "Should have no keys")
 
         self.orig_target.DeleteAllBreakpoints()
         self.copy_target.DeleteAllBreakpoints()
 
         # Now try one with extra args:
 
         extra_args = lldb.SBStructuredData()
         stream = lldb.SBStream()
         stream.Print('{"first_arg" : "first_value", "second_arg" : "second_value"}')
         extra_args.SetFromJSON(stream)
         self.assertTrue(extra_args.IsValid(), "SBStructuredData is valid.")
 
         bkpt = self.orig_target.BreakpointCreateFromScript("resolver.Resolver",
                                                            extra_args, lldb.SBFileSpecList(), lldb.SBFileSpecList())
         self.assertTrue(bkpt.IsValid(), "Bkpt is valid")
         write_bps = lldb.SBBreakpointList(self.orig_target)
 
         error = self.orig_target.BreakpointsWriteToFile(self.bkpts_file_spec, write_bps)
-        self.assertTrue(error.Success(), "Failed writing breakpoints: %s"%(error.GetCString()))
+        self.assertSuccess(error, "Failed writing breakpoints")
 
         orig_extra_args = side_effect.g_extra_args
         self.assertTrue(orig_extra_args.IsValid(), "Extra args originally valid")
 
         orig_keys = lldb.SBStringList()
         orig_extra_args.GetKeys(orig_keys)
         self.assertEqual(2, orig_keys.GetSize(), "Should have two keys")
 
         side_effect.g_extra_args = None
 
         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: %s"%(error.GetCString()))
+        self.assertSuccess(error, "Failed reading breakpoints")
 
         self.assertEqual(copy_bps.GetSize(), 1, "Got one breakpoint from file.")
 
         copy_extra_args = side_effect.g_extra_args
         copy_keys = lldb.SBStringList()
         copy_extra_args.GetKeys(copy_keys)
         self.assertEqual(2, copy_keys.GetSize(), "Copy should have two keys")
 

lldb/test/API/functionalities/dlopen_other_executable/TestDlopenOtherExecutable.py

def test(self):
         stopped_threads = lldbutil.continue_to_breakpoint(self.process(), breakpoint)
         self.assertEqual(len(stopped_threads), 1)
 
         # Check that the executable is still the test binary and not "other".
         self.assertEqual(self.target().GetExecutable().GetFilename(), "a.out")
 
         # Kill the process and run the program again.
         err = self.process().Kill()
-        self.assertTrue(err.Success(), str(err))
+        self.assertSuccess(err)
 
         # Test that we hit the breakpoint after dlopen.
         lldbutil.run_to_breakpoint_do_run(self, self.target(), breakpoint)

lldb/test/API/functionalities/dyld-launch-linux/TestDyldLaunchLinux.py

def test(self):
         # Set breakpoints both on shared library function as well as on
         # main. Both of them will be pending breakpoints.
         breakpoint_main = target.BreakpointCreateBySourceRegex("// Break here", lldb.SBFileSpec("main.cpp"))
         breakpoint_shared_library = target.BreakpointCreateBySourceRegex("get_signal_crash", lldb.SBFileSpec("signal_file.cpp"))
         launch_info = lldb.SBLaunchInfo([ "--library-path", self.get_process_working_directory(), self.getBuildArtifact("a.out")])
         launch_info.SetWorkingDirectory(self.get_process_working_directory())
         error = lldb.SBError()
         process = target.Launch(launch_info, error)
-        self.assertTrue(error.Success())
+        self.assertSuccess(error)
 
         # Stopped on main here.
         self.assertEqual(process.GetState(), lldb.eStateStopped)
         thread = process.GetSelectedThread()
         self.assertIn("main", thread.GetFrameAtIndex(0).GetDisplayFunctionName())
         process.Continue()
 
         # Stopped on get_signal_crash function here.
         self.assertEqual(process.GetState(), lldb.eStateStopped)
         self.assertIn("get_signal_crash", thread.GetFrameAtIndex(0).GetDisplayFunctionName())
         process.Continue()
 
         # Stopped because of generated signal.
         self.assertEqual(process.GetState(), lldb.eStateStopped)
         self.assertIn("raise", thread.GetFrameAtIndex(0).GetDisplayFunctionName())
         self.assertIn("get_signal_crash", thread.GetFrameAtIndex(1).GetDisplayFunctionName())

lldb/test/API/functionalities/gdb_remote_client/TestGDBRemoteClient.py

def do_siginfo_test(self, platform, target_yaml, raw_data, expected):
 
         self.server.responder = MyResponder()
 
         self.runCmd("platform select " + platform)
         target = self.createTarget(target_yaml)
         process = self.connect(target)
 
         siginfo = process.threads[0].GetSiginfo()
-        self.assertTrue(siginfo.GetError().Success(), siginfo.GetError())
+        self.assertSuccess(siginfo.GetError())
 
         for key, value in expected.items():
             self.assertEqual(siginfo.GetValueForExpressionPath("." + key)
                              .GetValueAsUnsigned(),
                              value)
 
 
     def test_siginfo_linux_amd64(self):

lldb/test/API/functionalities/gdb_remote_client/TestJLink6Armv7RegisterDefinition.py

</target>""", False
         err = msp_valobj.GetError()
         self.assertTrue(err.Fail(), "lldb should not be able to fetch the msp register")
 
         val = b'\x11\x22\x33\x44'
         error = lldb.SBError()
         data = lldb.SBData()
         data.SetData(error, val, lldb.eByteOrderBig, 4)
         self.assertEqual(r1_valobj.SetData(data, error), True)
-        self.assertTrue(error.Success())
+        self.assertSuccess(error)
 
         r1_valobj = process.GetThreadAtIndex(0).GetFrameAtIndex(0).FindRegister("r1")
         self.assertEqual(r1_valobj.GetValueAsUnsigned(), 0x11223344)
 

lldb/test/API/functionalities/gdb_remote_client/TestMemoryRegionDirtyPages.py

def test(self):
           self.runCmd("log enable gdb-remote packets")
           self.addTearDownHook(
                 lambda: self.runCmd("log disable gdb-remote packets"))
         process = self.connect(target)
 
         # A memory region where we don't know anything about dirty pages
         region = lldb.SBMemoryRegionInfo()
         err = process.GetMemoryRegionInfo(0, region)
-        self.assertTrue(err.Success())
+        self.assertSuccess(err)
         self.assertFalse(region.HasDirtyMemoryPageList())
         self.assertEqual(region.GetNumDirtyPages(), 0)
         region.Clear()
 
         # A memory region with dirty page information -- and zero dirty pages
         err = process.GetMemoryRegionInfo(0x100000000, region)
-        self.assertTrue(err.Success())
+        self.assertSuccess(err)
         self.assertTrue(region.HasDirtyMemoryPageList())
         self.assertEqual(region.GetNumDirtyPages(), 0)
         self.assertEqual(region.GetPageSize(), 4096)
         region.Clear()
 
         # A memory region with one dirty page
         err = process.GetMemoryRegionInfo(0x100004000, region)
-        self.assertTrue(err.Success())
+        self.assertSuccess(err)
         self.assertTrue(region.HasDirtyMemoryPageList())
         self.assertEqual(region.GetNumDirtyPages(), 1)
         self.assertEqual(region.GetDirtyPageAddressAtIndex(0), 0x100004000)
         region.Clear()
 
         # A memory region with multple dirty pages
         err = process.GetMemoryRegionInfo(0x1000a2000, region)
-        self.assertTrue(err.Success())
+        self.assertSuccess(err)
         self.assertTrue(region.HasDirtyMemoryPageList())
         self.assertEqual(region.GetNumDirtyPages(), 5)
         self.assertEqual(region.GetDirtyPageAddressAtIndex(4), 0x1000a6000)
         region.Clear()
 

lldb/test/API/functionalities/launch_stop_at_entry/TestStopAtEntry.py

def do_test_stop_at_entry(self, synchronous, remote):
             self.dbg.SetAsync(False)
 
         if remote:
             self.setup_remote_platform()
 
         error = lldb.SBError()
 
         process = target.Launch(launch_info, error)
-        self.assertTrue(error.Success(), "Launch failed: {0}".format(error.description))
+        self.assertSuccess(error, "Launch failed")
         # If we are asynchronous, we have to wait for the events:
         if not synchronous:
             listener = launch_info.GetListener()
             event = lldb.SBEvent()
             result = listener.WaitForEvent(30, event)
             self.assertTrue(result, "Timed out waiting for event from process")
             state = lldb.SBProcess.GetStateFromEvent(event)
             self.assertEqual(state, lldb.eStateStopped, "Didn't get a stopped state after launch")
 
         # Okay, we should be stopped.  Make sure we are indeed at the
         # entry point.  I only know how to do this on darwin:
         self.assertEqual(len(process.threads), 1, "Should only have one thread at entry")
         thread = process.threads[0]
         frame = thread.GetFrameAtIndex(0)
         stop_func = frame.name
         self.assertEqual(stop_func, "_dyld_start")
 
         # Now make sure that we can resume the process and have it exit.
         error = process.Continue()
-        self.assertTrue(error.Success(), "Error continuing: {0}".format(error.description))
+        self.assertSuccess(error, "Error continuing")
         # Fetch events till we get eStateExited:
         if not synchronous:
             # Get events till exited.
             listener = launch_info.GetListener()
             event = lldb.SBEvent()
             # We get two running events in a row here???  That's a bug
             # but not the one I'm testing for, so for now just fetch as
             # many as were sent.

lldb/test/API/functionalities/load_using_paths/TestLoadUsingPaths.py

def test_load_using_paths(self):
 
         # 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")
+        self.assertSuccess(value.GetError(), "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:
         loaded_module = target.FindModule(out_spec)

lldb/test/API/functionalities/paths/TestPaths.py

def test_paths(self):
         self.assertTrue(any([os.path.exists(os.path.join(shlib_dir, f)) for f in
             filenames]), "shlib_dir = " + shlib_dir)
 
     @no_debug_info_test
     def test_interpreter_info(self):
         info_sd = self.dbg.GetScriptInterpreterInfo(self.dbg.GetScriptingLanguage("python"))
         self.assertTrue(info_sd.IsValid())
         stream = lldb.SBStream()
-        self.assertTrue(info_sd.GetAsJSON(stream).Success())
+        self.assertSuccess(info_sd.GetAsJSON(stream))
         info = json.loads(stream.GetData())
         prefix = info['prefix']
         self.assertEqual(os.path.realpath(sys.prefix), os.path.realpath(prefix))
         self.assertEqual(
             os.path.realpath(os.path.join(info['lldb-pythonpath'], 'lldb')),
             os.path.realpath(os.path.dirname(lldb.__file__)))
         self.assertTrue(os.path.exists(info['executable']))
         self.assertEqual(info['language'], 'python')

lldb/test/API/functionalities/postmortem/elf-core/TestLinuxCore.py

def test_two_cores_same_pid(self):
             altframe.GetLineEntry().GetLine(),
             line_number(
                 "altmain.c",
                 "Frame _start"))
 
         error = lldb.SBError()
         F = altprocess.ReadCStringFromMemory(
             altframe.FindVariable("F").GetValueAsUnsigned(), 256, error)
-        self.assertTrue(error.Success())
+        self.assertSuccess(error)
         self.assertEqual(F, "_start")
 
         # without destroying this process, run the test which opens another core file with the
         # same pid
         self.do_test("linux-x86_64", self._x86_64_pid, self._x86_64_regions,
                      "a.out")
 
 

lldb/test/API/functionalities/postmortem/minidump-new/TestMiniDumpNew.py

class MiniDumpNewTestCase(TestBase):
     def test_loadcore_error_status(self):
         """Test the SBTarget.LoadCore(core, error) overload."""
         minidump_path = self.getBuildArtifact("linux-x86_64.dmp")
         self.yaml2obj("linux-x86_64.yaml", minidump_path)
         self.target = self.dbg.CreateTarget(None)
         error = lldb.SBError()
         self.process = self.target.LoadCore(minidump_path, error)
         self.assertTrue(self.process, PROCESS_IS_VALID)
-        self.assertTrue(error.Success())
+        self.assertSuccess(error)
 
     def test_loadcore_error_status_failure(self):
         """Test the SBTarget.LoadCore(core, error) overload."""
         self.target = self.dbg.CreateTarget(None)
         error = lldb.SBError()
         self.process = self.target.LoadCore("non-existent.dmp", error)
         self.assertFalse(self.process, PROCESS_IS_VALID)
         self.assertTrue(error.Fail())

lldb/test/API/functionalities/postmortem/minidump/TestMiniDump.py

def test_deeper_stack_in_mini_dump(self):
             # Set a breakpoint and capture a mini dump.
             target = self.dbg.CreateTarget(exe)
             breakpoint = target.BreakpointCreateByName("bar")
             process = target.LaunchSimple(
                 None, None, self.get_process_working_directory())
             self.assertEqual(process.GetState(), lldb.eStateStopped)
             self.assertTrue(process.SaveCore(core))
             self.assertTrue(os.path.isfile(core))
-            self.assertTrue(process.Kill().Success())
+            self.assertSuccess(process.Kill())
 
             # Launch with the mini dump, and inspect the stack.
             target = self.dbg.CreateTarget(None)
             process = target.LoadCore(core)
             thread = process.GetThreadAtIndex(0)
 
             expected_stack = {0: 'bar', 1: 'foo', 2: 'main'}
             self.assertGreaterEqual(thread.GetNumFrames(), len(expected_stack))
def test_local_variables_in_mini_dump(self):
             # Set a breakpoint and capture a mini dump.
             target = self.dbg.CreateTarget(exe)
             breakpoint = target.BreakpointCreateByName("bar")
             process = target.LaunchSimple(
                 None, None, self.get_process_working_directory())
             self.assertEqual(process.GetState(), lldb.eStateStopped)
             self.assertTrue(process.SaveCore(core))
             self.assertTrue(os.path.isfile(core))
-            self.assertTrue(process.Kill().Success())
+            self.assertSuccess(process.Kill())
 
             # Launch with the mini dump, and inspect a local variable.
             target = self.dbg.CreateTarget(None)
             process = target.LoadCore(core)
             thread = process.GetThreadAtIndex(0)
             frame = thread.GetFrameAtIndex(0)
             value = frame.EvaluateExpression('x')
             self.assertEqual(value.GetValueAsSigned(), 3)
 
         finally:
             # Clean up the mini dump file.
             self.assertTrue(self.dbg.DeleteTarget(target))
             if (os.path.isfile(core)):
                 os.unlink(core)

lldb/test/API/functionalities/process_crash_info/TestProcessCrashInfo.py

def test_api(self):
 
         process = target.GetProcess()
         self.assertTrue(process)
 
         crash_info = process.GetExtendedCrashInformation()
 
         error = crash_info.GetAsJSON(stream)
 
-        self.assertTrue(error.Success())
+        self.assertSuccess(error)
 
         self.assertTrue(crash_info.IsValid())
 
         self.assertIn("pointer being freed was not allocated", stream.GetData())
 
     # dyld leaves permanent crash_info records when testing on device.
     @skipIfDarwinEmbedded
     def test_on_sane_process(self):

lldb/test/API/functionalities/process_save_core/TestProcessSaveCore.py

def test_save_windows_mini_dump(self):
         try:
             target = self.dbg.CreateTarget(exe)
             breakpoint = target.BreakpointCreateByName("bar")
             process = target.LaunchSimple(
                 None, None, self.get_process_working_directory())
             self.assertEqual(process.GetState(), lldb.eStateStopped)
             self.assertTrue(process.SaveCore(core))
             self.assertTrue(os.path.isfile(core))
-            self.assertTrue(process.Kill().Success())
+            self.assertSuccess(process.Kill())
 
             # To verify, we'll launch with the mini dump, and ensure that we see
             # the executable in the module list.
             target = self.dbg.CreateTarget(None)
             process = target.LoadCore(core)
             files = [
                 target.GetModuleAtIndex(i).GetFileSpec() for i in range(
                     0, target.GetNumModules())]
def test_save_core_via_process_plugin(self):
         try:
             target = self.dbg.CreateTarget(exe)
             breakpoint = target.BreakpointCreateByName("bar")
             process = target.LaunchSimple(
                 None, None, self.get_process_working_directory())
             self.assertEqual(process.GetState(), lldb.eStateStopped)
             self.assertTrue(process.SaveCore(core))
             self.assertTrue(os.path.isfile(core))
-            self.assertTrue(process.Kill().Success())
+            self.assertSuccess(process.Kill())
             pid = process.GetProcessID()
 
             target = self.dbg.CreateTarget(None)
             process = target.LoadCore(core)
             self.assertTrue(process, PROCESS_IS_VALID)
             self.assertEqual(process.GetProcessID(), pid)
 
         finally:
             self.assertTrue(self.dbg.DeleteTarget(target))
             try:
                 os.unlink(core)
             except OSError:
                 pass

lldb/test/API/functionalities/process_save_core_minidump/TestProcessSaveCoreMinidump.py

def test_save_linux_mini_dump(self):
             for thread_idx in range(process.GetNumThreads()):
                 thread = process.GetThreadAtIndex(thread_idx)
                 thread_id = thread.GetThreadID()
                 expected_threads.append(thread_id)
 
             # save core and, kill process and verify corefile existence
             self.runCmd("process save-core --plugin-name=minidump --style=stack " + core)
             self.assertTrue(os.path.isfile(core))
-            self.assertTrue(process.Kill().Success())
+            self.assertSuccess(process.Kill())
 
             # To verify, we'll launch with the mini dump
             target = self.dbg.CreateTarget(None)
             process = target.LoadCore(core)
 
             # check if the core is in desired state
             self.assertTrue(process, PROCESS_IS_VALID)
             self.assertTrue(process.GetProcessInfo().IsValid())

lldb/test/API/functionalities/return-value/TestReturnValue.py

def test_with_python(self):
         exe = self.getBuildArtifact("a.out")
         (self.target, self.process, thread, inner_sint_bkpt) = lldbutil.run_to_name_breakpoint(self, "inner_sint", exe_name = exe)
 
         error = lldb.SBError()
 
         # inner_sint returns the variable value, so capture that here:
         in_int = thread.GetFrameAtIndex(0).FindVariable(
             "value").GetValueAsSigned(error)
-        self.assertTrue(error.Success())
+        self.assertSuccess(error)
 
         thread.StepOut()
 
         self.assertEquals(self.process.GetState(), lldb.eStateStopped)
         self.assertEquals(thread.GetStopReason(), lldb.eStopReasonPlanComplete)
 
         frame = thread.GetFrameAtIndex(0)
         fun_name = frame.GetFunctionName()
         self.assertEquals(fun_name, "outer_sint(int)")
 
         return_value = thread.GetStopReturnValue()
         self.assertTrue(return_value.IsValid())
 
         ret_int = return_value.GetValueAsSigned(error)
-        self.assertTrue(error.Success())
+        self.assertSuccess(error)
         self.assertEquals(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.assertEquals(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)
         fun_name = frame.GetFunctionName()
         self.assertEquals(fun_name, "outer_sint(int)")
         in_int = frame.FindVariable("value").GetValueAsSigned(error)
-        self.assertTrue(error.Success())
+        self.assertSuccess(error)
 
         thread.StepOutOfFrame(frame)
 
         self.assertEquals(self.process.GetState(), lldb.eStateStopped)
         self.assertEquals(thread.GetStopReason(), lldb.eStopReasonPlanComplete)
         frame = thread.GetFrameAtIndex(0)
         fun_name = frame.GetFunctionName()
         self.assertEquals(fun_name, "main")
 
         ret_value = thread.GetStopReturnValue()
         self.assertTrue(return_value.IsValid())
         ret_int = ret_value.GetValueAsSigned(error)
-        self.assertTrue(error.Success())
+        self.assertSuccess(error)
         self.assertEquals(2 * in_int, ret_int)
 
         # Now try some simple returns that have different types:
         inner_float_bkpt = self.target.BreakpointCreateByName(
             "inner_float(float)", exe)
         self.assertTrue(inner_float_bkpt, VALID_BREAKPOINT)
         self.process.Continue()
         thread_list = lldbutil.get_threads_stopped_at_breakpoint(

lldb/test/API/functionalities/scripted_process/TestScriptedProcess.py

def test_invalid_scripted_register_context(self):
 
         launch_info = lldb.SBLaunchInfo(None)
         launch_info.SetProcessPluginName("ScriptedProcess")
         launch_info.SetScriptedProcessClassName("invalid_scripted_process.InvalidScriptedProcess")
         error = lldb.SBError()
 
         process = target.Launch(launch_info, error)
 
-        self.assertTrue(error.Success(), error.GetCString())
+        self.assertSuccess(error)
         self.assertTrue(process, PROCESS_IS_VALID)
         self.assertEqual(process.GetProcessID(), 666)
         self.assertEqual(process.GetNumThreads(), 0)
 
         with open(log_file, 'r') as f:
             log = f.read()
 
         self.assertIn("Failed to get scripted thread registers data.", log)

lldb/test/API/functionalities/scripted_process/TestStackCoreScriptedProcess.py

def test_launch_scripted_process_stack_frames(self):
 
         for module in target.modules:
             if 'a.out' in module.GetFileSpec().GetFilename():
                 main_module = module
                 break
 
         self.assertTrue(main_module, "Invalid main module.")
         error = target.SetModuleLoadAddress(main_module, 0)
-        self.assertTrue(error.Success(), "Reloading main module at offset 0 failed.")
+        self.assertSuccess(error, "Reloading main module at offset 0 failed.")
 
         os.environ['SKIP_SCRIPTED_PROCESS_LAUNCH'] = '1'
         def cleanup():
           del os.environ["SKIP_SCRIPTED_PROCESS_LAUNCH"]
         self.addTearDownHook(cleanup)
 
         scripted_process_example_relpath = 'stack_core_scripted_process.py'
         self.runCmd("command script import " + os.path.join(self.getSourceDir(),
def test_launch_scripted_process_stack_frames(self):
         }))
         launch_info = lldb.SBLaunchInfo(None)
         launch_info.SetProcessPluginName("ScriptedProcess")
         launch_info.SetScriptedProcessClassName("stack_core_scripted_process.StackCoreScriptedProcess")
         launch_info.SetScriptedProcessDictionary(structured_data)
 
         error = lldb.SBError()
         process = target.Launch(launch_info, error)
-        self.assertTrue(error.Success(), error.GetCString())
+        self.assertSuccess(error)
         self.assertTrue(process, PROCESS_IS_VALID)
         self.assertEqual(process.GetProcessID(), 42)
 
         self.assertEqual(process.GetNumThreads(), 3)
         thread = process.GetSelectedThread()
         self.assertTrue(thread, "Invalid thread.")
         self.assertEqual(thread.GetName(), "StackCoreScriptedThread.thread-2")
 

lldb/test/API/functionalities/step_scripted/TestStepScripted.py

def step_out_with_scripted_plan(self, name):
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
                                                                             "Set a breakpoint here",
                                                                             self.main_source_file)
 
         frame = thread.GetFrameAtIndex(0)
         self.assertEqual("foo", frame.GetFunctionName())
 
         err = thread.StepUsingScriptedThreadPlan(name)
-        self.assertTrue(err.Success(), err.GetCString())
+        self.assertSuccess(err)
 
         frame = thread.GetFrameAtIndex(0)
         self.assertEqual("main", frame.GetFunctionName())
 
 
     def test_misspelled_plan_name(self):
         """Test that we get a useful error if we misspell the plan class name"""
         self.build()
def do_test_checking_variable(self, use_cli):
         self.build()
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
                                                                             "Set a breakpoint here",
                                                                             self.main_source_file)
 
         frame = thread.GetFrameAtIndex(0)
         self.assertEqual("foo", frame.GetFunctionName())
         foo_val = frame.FindVariable("foo")
-        self.assertTrue(foo_val.GetError().Success(), "Got the foo variable")
+        self.assertSuccess(foo_val.GetError(), "Got the foo variable")
         self.assertEqual(foo_val.GetValueAsUnsigned(), 10, "foo starts at 10")
 
         if use_cli:
             result = lldb.SBCommandReturnObject()
             self.dbg.GetCommandInterpreter().HandleCommand(
                 "thread step-scripted -C Steps.StepUntil -k variable_name -v foo",
                 result)
             self.assertTrue(result.Succeeded())
         else:
             args_data = lldb.SBStructuredData()
             data = lldb.SBStream()
             data.Print('{"variable_name" : "foo"}')
             error = args_data.SetFromJSON(data)
-            self.assertTrue(error.Success(), "Made the args_data correctly")
+            self.assertSuccess(error, "Made the args_data correctly")
 
             err = thread.StepUsingScriptedThreadPlan("Steps.StepUntil", args_data, True)
-            self.assertTrue(err.Success(), err.GetCString())
+            self.assertSuccess(err)
 
         # We should not have exited:
         self.assertEqual(process.GetState(), lldb.eStateStopped, "We are stopped")
         
         # We should still be in foo:
         self.assertEqual("foo", frame.GetFunctionName())
 
         # And foo should have changed:

lldb/test/API/functionalities/thread/exit_during_expression/TestExitDuringExpression.py

def exiting_expression_test(self, before_one_thread_timeout , unwind):
         var_options.SetIncludeStatics(True)
 
         value_list = frame.GetVariables(var_options)
         g_timeout = value_list.GetFirstValueByName("g_timeout")
         self.assertTrue(g_timeout.IsValid(), "Found g_timeout")
 
         error = lldb.SBError()
         timeout_value = g_timeout.GetValueAsUnsigned(error)
-        self.assertTrue(error.Success(), "Couldn't get timeout value: %s"%(error.GetCString()))
+        self.assertSuccess(error, "Couldn't get timeout value")
 
         one_thread_timeout = 0
         if (before_one_thread_timeout):
             one_thread_timeout = timeout_value * 2
         else:
             one_thread_timeout = int(timeout_value / 2)
 
         options = lldb.SBExpressionOptions()
def exiting_expression_test(self, before_one_thread_timeout , unwind):
             self.fail("didn't get any threads back after continuing")
 
         self.assertEqual(len(threads), 1, "One thread hit our breakpoint")
         thread = threads[0]
         frame = thread.frames[0]
         # Now get the return value, if we successfully caused the thread to exit
         # it should be 10, not 20.
         ret_val = frame.FindVariable("ret_val")
-        self.assertTrue(ret_val.GetError().Success(), "Found ret_val")
+        self.assertSuccess(ret_val.GetError(), "Found ret_val")
         ret_val_value = ret_val.GetValueAsSigned(error)
-        self.assertTrue(error.Success(), "Got ret_val's value")
+        self.assertSuccess(error, "Got ret_val's value")
         self.assertEqual(ret_val_value, 10, "We put the right value in ret_val")

lldb/test/API/functionalities/thread/state_after_expression/TestStateAfterExpression.py

def do_test(self):
         self.assertNotEqual(thread.GetThreadID(), other_thread.GetThreadID(),
                             "A different thread")
         # Run an expression ONLY on other_thread.  Don't let thread run:
         options = lldb.SBExpressionOptions()
         options.SetTryAllThreads(False)
         options.SetStopOthers(True)
 
         result = thread.frames[0].EvaluateExpression('(int) printf("Hello\\n")', options)
-        self.assertTrue(result.GetError().Success(),
-                        "Expression failed: '%s'"%(result.GetError().GetCString()))
+        self.assertSuccess(result.GetError(), "Expression failed")
 
         stop_reason = other_thread.GetStopReason()
 
         self.assertEqual(stop_reason, lldb.eStopReasonBreakpoint,
                          "Still records stopped at breakpoint: %s"
                          %(lldbutil.stop_reason_to_str(stop_reason)))
         self.assertEqual(other_thread.GetStopReasonDataAtIndex(0), 1,
                          "Still records stopped at right breakpoint")
 

lldb/test/API/functionalities/var_path/TestVarPath.py

class TestVarPath(TestBase):
     NO_DEBUG_INFO_TESTCASE = True
 
     def test_frame_var(self):
         self.build()
         self.do_test()
 
     def verify_point(self, frame, var_name, var_typename, x_value, y_value):
         v = frame.GetValueForVariablePath(var_name)
-        self.assertTrue(v.GetError().Success(), "Make sure we find '%s'" % (var_name))
+        self.assertSuccess(v.GetError(), "Make sure we find '%s'" % (var_name))
         self.assertEquals(v.GetType().GetName(), var_typename,
                         "Make sure '%s' has type '%s'" % (var_name, var_typename))
 
         if '*' in var_typename:
             valid_prefix = var_name + '->'
             invalid_prefix = var_name + '.'
         else:
             valid_prefix = var_name + '.'
             invalid_prefix = var_name + '->'
 
         valid_x_path = valid_prefix + 'x'
         valid_y_path = valid_prefix + 'y'
         invalid_x_path = invalid_prefix + 'x'
         invalid_y_path = invalid_prefix + 'y'
         invalid_m_path = invalid_prefix + 'm'
 
         v = frame.GetValueForVariablePath(valid_x_path)
-        self.assertTrue(v.GetError().Success(), "Make sure we find '%s'" % (valid_x_path))
+        self.assertSuccess(v.GetError(), "Make sure we find '%s'" % (valid_x_path))
         self.assertEquals(v.GetValue(), str(x_value), "Make sure '%s' has a value of %i" % (valid_x_path, x_value))
         self.assertEquals(v.GetType().GetName(), "int", "Make sure '%s' has type 'int'" % (valid_x_path))
         v = frame.GetValueForVariablePath(invalid_x_path)
         self.assertTrue(v.GetError().Fail(), "Make sure we don't find '%s'" % (invalid_x_path))
 
         v = frame.GetValueForVariablePath(valid_y_path)
-        self.assertTrue(v.GetError().Success(), "Make sure we find '%s'" % (valid_y_path))
+        self.assertSuccess(v.GetError(), "Make sure we find '%s'" % (valid_y_path))
         self.assertEquals(v.GetValue(), str(y_value), "Make sure '%s' has a value of %i" % (valid_y_path, y_value))
         self.assertEquals(v.GetType().GetName(), "int", "Make sure '%s' has type 'int'" % (valid_y_path))
         v = frame.GetValueForVariablePath(invalid_y_path)
         self.assertTrue(v.GetError().Fail(), "Make sure we don't find '%s'" % (invalid_y_path))
 
         v = frame.GetValueForVariablePath(invalid_m_path)
         self.assertTrue(v.GetError().Fail(), "Make sure we don't find '%s'" % (invalid_m_path))
 
def do_test(self):
         # Test a pointer
         self.verify_point(frame, 'pt_ptr', 'Point *', 3030, 4040)
         # Test using a pointer as an array
         self.verify_point(frame, 'pt_ptr[-1]', 'Point', 1010, 2020)
         self.verify_point(frame, 'pt_ptr[0]', 'Point', 3030, 4040)
         self.verify_point(frame, 'pt_ptr[1]', 'Point', 5050, 6060)
         # Test arrays
         v = frame.GetValueForVariablePath('points')
-        self.assertTrue(v.GetError().Success(),
-                        "Make sure we find 'points'")
+        self.assertSuccess(v.GetError(), "Make sure we find 'points'")
         self.verify_point(frame, 'points[0]', 'Point', 1010, 2020)
         self.verify_point(frame, 'points[1]', 'Point', 3030, 4040)
         self.verify_point(frame, 'points[2]', 'Point', 5050, 6060)
         v = frame.GetValueForVariablePath('points[0]+5')
         self.assertTrue(v.GetError().Fail(),
                         "Make sure we do not ignore characters between ']' and the end")
         # Test a reference
         self.verify_point(frame, 'pt_ref', 'Point &', 1, 2)
         v = frame.GetValueForVariablePath('pt_sp')
-        self.assertTrue(v.GetError().Success(), "Make sure we find 'pt_sp'")
+        self.assertSuccess(v.GetError(), "Make sure we find 'pt_sp'")
         # Make sure we don't crash when looking for non existant child
         # in type with synthetic children. This used to cause a crash.
         v = frame.GetValueForVariablePath('pt_sp->not_valid_child')
         self.assertTrue(v.GetError().Fail(),
                         "Make sure we don't find 'pt_sp->not_valid_child'")
 
 
 

lldb/test/API/lang/c/local_types/TestUseClosestType.py

def test_use_in_expr(self):
         """Use the shadowed type directly, see if we get a conflicting type definition."""
         self.build()
         self.main_source_file = lldb.SBFileSpec("main.c")
         self.expr_test()
 
     def run_and_check_expr(self, num_children, child_type):
         frame = self.thread.GetFrameAtIndex(0)
         result = frame.EvaluateExpression("struct Foo *$mine = (struct Foo *) malloc(sizeof(struct Foo)); $mine")
-        self.assertTrue(result.GetError().Success(), "Failed to parse an expression using a multiply defined type: %s"%(result.GetError().GetCString()), )
+        self.assertSuccess(result.GetError(), "Failed to parse an expression using a multiply defined type")
         self.assertEqual(result.GetTypeName(), "struct Foo *", "The result has the right typename.")
         self.assertEqual(result.GetNumChildren(), num_children, "Got the right number of children")
         self.assertEqual(result.GetChildAtIndex(0).GetTypeName(), child_type, "Got the right type.")
 
     def expr_test(self):
         """ Run to a breakpoint in main.c, check that an expression referring to Foo gets the
             local three int version.  Then run to a breakpoint in other.c and check that an
             expression referring to Foo gets the two char* version. """
         
         (target, process, self.thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
                                    "Set a breakpoint in main", self.main_source_file)
 
         self.run_and_check_expr(3, "int")
         lldbutil.run_to_source_breakpoint(self, "Set a breakpoint in other", lldb.SBFileSpec("other.c"))
         self.run_and_check_expr(2, "char *")
 

lldb/test/API/lang/cpp/incomplete-types/TestCppIncompleteTypes.py

class TestCppIncompleteTypes(TestBase):
     def test_limit_debug_info(self):
         self.build()
         frame = self.get_test_frame('limit')
 
         value_f = frame.EvaluateExpression("f")
         self.assertTrue(
             value_f.IsValid(),
             "'expr f' results in a valid SBValue object")
-        self.assertTrue(value_f.GetError().Success(), "'expr f' is successful")
+        self.assertSuccess(value_f.GetError(), "'expr f' is successful")
 
         value_a = frame.EvaluateExpression("a")
         self.assertTrue(
             value_a.IsValid(),
             "'expr a' results in a valid SBValue object")
-        self.assertTrue(value_a.GetError().Success(), "'expr a' is successful")
+        self.assertSuccess(value_a.GetError(), "'expr a' is successful")
 
     @skipIf(compiler="gcc")
     # Clang on Windows asserts in external record layout in this case.
     @skipIfWindows
     def test_partial_limit_debug_info(self):
         self.build()
         frame = self.get_test_frame('nolimit')
 
         value_f = frame.EvaluateExpression("f")
         self.assertTrue(
             value_f.IsValid(),
             "'expr f' results in a valid SBValue object")
-        self.assertTrue(value_f.GetError().Success(), "'expr f' is successful")
+        self.assertSuccess(value_f.GetError(), "'expr f' is successful")
 
         value_a = frame.EvaluateExpression("a")
         self.assertTrue(
             value_a.IsValid(),
             "'expr a' results in a valid SBValue object")
-        self.assertTrue(value_a.GetError().Success(), "'expr a' is successful")
+        self.assertSuccess(value_a.GetError(), "'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,
                 "break here", src_file_spec, exe_name = exe)
         # Get frame for current thread
         return thread.GetSelectedFrame()

lldb/test/API/lang/cpp/trivial_abi/TestTrivialABI.py

class TestTrivialABI(TestBase):
     @expectedFailureAll(archs=["arm64", "arm64e"], bugnumber="<rdar://problem/57844240>")
     def test_call_nontrivial(self):
         """Test that we can print a variable & call a function on the same class w/o the trivial ABI marker."""
         self.build()
         self.main_source_file = lldb.SBFileSpec("main.cpp")
         self.expr_test(False)
 
     def check_value(self, test_var, ivar_value):
-        self.assertTrue(test_var.GetError().Success(), "Invalid valobj: %s"%(test_var.GetError().GetCString()))
+        self.assertSuccess(test_var.GetError(), "Invalid valobj")
         ivar = test_var.GetChildMemberWithName("ivar")
-        self.assertTrue(test_var.GetError().Success(), "Failed to fetch ivar")
+        self.assertSuccess(test_var.GetError(), "Failed to fetch ivar")
         self.assertEqual(ivar_value, ivar.GetValueAsSigned(), "Got the right value for ivar")
 
     def check_frame(self, thread):
         frame = thread.frames[0]
         inVal_var = frame.FindVariable("inVal")
         self.check_value(inVal_var, 10)
 
         options = lldb.SBExpressionOptions()

lldb/test/API/lang/cpp/type_lookup/TestCppTypeLookup.py

 """
 Test that we can lookup types correctly in the expression parser
 """
 
 
 
 import lldb
 import lldbsuite.test.lldbutil as lldbutil
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import decorators
 
 class TestCppTypeLookup(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def check_value(self, value, ivar_name, ivar_value):
-        self.assertTrue(value.GetError().Success(),
-                        "Invalid valobj: %s" % (
-                                value.GetError().GetCString()))
+        self.assertSuccess(value.GetError(), "Invalid valobj")
         ivar = value.GetChildMemberWithName(ivar_name)
-        self.assertTrue(ivar.GetError().Success(),
+        self.assertSuccess(ivar.GetError(),
                            "Failed to fetch ivar named '%s'" % (ivar_name))
         self.assertEqual(ivar_value,
                          ivar.GetValueAsSigned(),
                          "Got the right value for ivar")
 
     def test_namespace_only(self):
         """
             Test that we fail to lookup a struct type that exists only in a
             namespace.

lldb/test/API/lang/objc/blocks/TestObjCIvarsInBlocks.py

def test_with_python_api(self):
         # equal:
         self_var = frame.GetValueForVariablePath("self")
         self.assertTrue(self_var, "Found self in block.")
         indirect_blocky = self_var.GetChildMemberWithName("blocky_ivar")
         self.assertTrue(indirect_blocky, "Found blocky_ivar through self")
 
         error = lldb.SBError()
         direct_value = direct_blocky.GetValueAsSigned(error)
-        self.assertTrue(error.Success(), "Got direct value for blocky_ivar")
+        self.assertSuccess(error, "Got direct value for blocky_ivar")
 
         indirect_value = indirect_blocky.GetValueAsSigned(error)
-        self.assertTrue(error.Success(), "Got indirect value for blocky_ivar")
+        self.assertSuccess(error, "Got indirect value for blocky_ivar")
 
         self.assertEqual(
             direct_value, indirect_value,
             "Direct and indirect values are equal.")
 
         # Now make sure that we can get at the captured ivar through the expression parser.
         # Doing a little trivial math will force this into the real expression
         # parser:

lldb/test/API/lang/objc/global_ptrs/TestGlobalObjects.py

def test_with_python_api(self):
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         bkpt = target.BreakpointCreateBySourceRegex('NSLog', self.main_source)
         self.assertTrue(bkpt, VALID_BREAKPOINT)
 
         # Before we launch, make an SBValue for our global object pointer:
         g_obj_ptr = target.FindFirstGlobalVariable("g_obj_ptr")
-        self.assertTrue(g_obj_ptr.GetError().Success(), "Made the g_obj_ptr")
+        self.assertSuccess(g_obj_ptr.GetError(), "Made the g_obj_ptr")
         self.assertEqual(
             g_obj_ptr.GetValueAsUnsigned(10), 0,
             "g_obj_ptr is initially null")
 
         # Now launch the process, and do not stop at entry point.
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
 

lldb/test/API/lang/objc/objc-checker/TestObjCCheckers.py

def test_objc_checker(self):
         # ObjC method with the struct return convention.
         # Getting this wrong would cause us to call the checker
         # with the wrong arguments, and the checker would crash
         # So I'm just checking "expression runs successfully" here:
         #
         expr_value = frame.EvaluateExpression("[my_simple getBigStruct]", False)
         expr_error = expr_value.GetError()
         
-        self.assertTrue(expr_error.Success())
+        self.assertSuccess(expr_error)
         

lldb/test/API/lang/objc/objc-ivar-offsets/TestObjCIvarOffsets.py

def test_with_python_api(self):
 
         error = lldb.SBError()
 
         mine_backed_int = mine.GetChildMemberWithName("_backed_int")
         self.assertTrue(
             mine_backed_int,
             "Found mine->backed_int local variable.")
         backed_value = mine_backed_int.GetValueAsSigned(error)
-        self.assertTrue(error.Success())
+        self.assertSuccess(error)
         self.assertEquals(backed_value, 1111)
 
         # Test the value object value for DerivedClass->_derived_backed_int
 
         mine_derived_backed_int = mine.GetChildMemberWithName(
             "_derived_backed_int")
         self.assertTrue(mine_derived_backed_int,
                         "Found mine->derived_backed_int local variable.")
         derived_backed_value = mine_derived_backed_int.GetValueAsSigned(error)
-        self.assertTrue(error.Success())
+        self.assertSuccess(error)
         self.assertEquals(derived_backed_value, 3333)
 
         # Make sure we also get bit-field offsets correct:
 
         mine_flag2 = mine.GetChildMemberWithName("flag2")
         self.assertTrue(mine_flag2, "Found mine->flag2 local variable.")
         flag2_value = mine_flag2.GetValueAsUnsigned(error)
-        self.assertTrue(error.Success())
+        self.assertSuccess(error)
         self.assertEquals(flag2_value, 7)

lldb/test/API/lang/objc/objc-ivar-stripped/TestObjCIvarStripped.py

def test_with_python_api(self):
 
         # Test the expression for mc->_foo
 
         error = lldb.SBError()
 
         ivar = frame.EvaluateExpression("(mc->_foo)")
         self.assertTrue(ivar, "Got result for mc->_foo")
         ivar_value = ivar.GetValueAsSigned(error)
-        self.assertTrue(error.Success())
+        self.assertSuccess(error)
         self.assertEquals(ivar_value, 3)

lldb/test/API/lang/objc/objc-property/TestObjCProperty.py

def test_objc_properties(self):
         #
         # The first set of tests test calling the getter & setter of
         # a property that actually only has a getter & setter and no
         # @property.
         #
         nonexistant_value = frame.EvaluateExpression(
             "mine.nonexistantInt", False)
         nonexistant_error = nonexistant_value.GetError()
-        self.assertTrue(nonexistant_error.Success())
+        self.assertSuccess(nonexistant_error)
         nonexistant_int = nonexistant_value.GetValueAsUnsigned(123456)
         self.assertEquals(nonexistant_int, 6)
 
         # Calling the getter function would up the access count, so make sure
         # that happened.
 
         new_access_count = access_count.GetValueAsUnsigned(123456)
         self.assertEquals(new_access_count - start_access_count, 1)
         start_access_count = new_access_count
 
         #
         # Now call the setter, then make sure that
         nonexistant_change = frame.EvaluateExpression(
             "mine.nonexistantInt = 10", False)
         nonexistant_error = nonexistant_change.GetError()
-        self.assertTrue(nonexistant_error.Success())
+        self.assertSuccess(nonexistant_error)
 
         # Calling the setter function would up the access count, so make sure
         # that happened.
 
         new_access_count = access_count.GetValueAsUnsigned(123456)
         self.assertEquals(new_access_count - start_access_count, 1)
         start_access_count = new_access_count
 
         #
         # Now we call the getter of a property that is backed by an ivar,
         # make sure it works and that we actually update the backing ivar.
         #
 
         backed_value = frame.EvaluateExpression("mine.backedInt", False)
         backed_error = backed_value.GetError()
-        self.assertTrue(backed_error.Success())
+        self.assertSuccess(backed_error)
         backing_value = mine.GetChildMemberWithName("_backedInt")
         self.assertTrue(backing_value.IsValid())
         self.assertTrue(backed_value.GetValueAsUnsigned(12345)
                         == backing_value.GetValueAsUnsigned(23456))
 
         value_from_typedef = frame.EvaluateExpression("typedefd.backedInt", False)
-        self.assertTrue(value_from_typedef.GetError().Success())
+        self.assertSuccess(value_from_typedef.GetError())
         self.assertEqual(value_from_typedef.GetValueAsUnsigned(12345),
                          backing_value.GetValueAsUnsigned(23456))
 
         unbacked_value = frame.EvaluateExpression("mine.unbackedInt", False)
         unbacked_error = unbacked_value.GetError()
-        self.assertTrue(unbacked_error.Success())
+        self.assertSuccess(unbacked_error)
 
         idWithProtocol_value = frame.EvaluateExpression(
             "mine.idWithProtocol", False)
         idWithProtocol_error = idWithProtocol_value.GetError()
-        self.assertTrue(idWithProtocol_error.Success())
+        self.assertSuccess(idWithProtocol_error)
         self.assertEquals(idWithProtocol_value.GetTypeName(), "id")
 
         # Make sure that class property getter works as expected
         value = frame.EvaluateExpression("BaseClass.classInt", False)
-        self.assertTrue(value.GetError().Success())
+        self.assertSuccess(value.GetError())
         self.assertEquals(value.GetValueAsUnsigned(11111), 123)
 
         # Make sure that class property setter works as expected
         value = frame.EvaluateExpression("BaseClass.classInt = 234", False)
-        self.assertTrue(value.GetError().Success())
+        self.assertSuccess(value.GetError())
 
         # Verify that setter above actually worked
         value = frame.EvaluateExpression("BaseClass.classInt", False)
-        self.assertTrue(value.GetError().Success())
+        self.assertSuccess(value.GetError())
         self.assertEquals(value.GetValueAsUnsigned(11111), 234)
 
         # Test that accessing two distinct class and instance properties that
         # share the same name works.
         self.expect_expr("mine.propConflict", result_value="4")
         self.expect_expr("BaseClass.propConflict", result_value="6")

lldb/test/API/linux/aarch64/unwind_signal/TestUnwindSignal.py

def test_unwind_signal(self):
             if frame.GetDisplayFunctionName() == "sigill":
                 # We should have ascending values in the x registers
                 regs = frame.GetRegisters().GetValueAtIndex(0)
                 err = lldb.SBError()
 
                 for i in range(31):
                   name = 'x{}'.format(i)
                   value = regs.GetChildMemberWithName(name).GetValueAsUnsigned(err)
-                  self.assertTrue(err.Success(), "Failed to get register {}: {}".format(
-                                      name, err))
+                  self.assertSuccess(err, "Failed to get register {}".format(name))
                   self.assertEqual(value, i, "Unexpected value for register {}".format(
                                       name))
 
                 found_caller = True
                 break
 
         self.assertTrue(found_caller, "Unwinding did not find func that caused the SIGILL")
 
         # Continue until we exit.
         process.Continue()
         self.assertEqual(process.GetState(), lldb.eStateExited)
         self.assertEqual(process.GetExitStatus(), 0)

lldb/test/API/macosx/function-starts/TestFunctionStarts.py

def do_function_starts(self, in_memory):
 
         target = self.dbg.CreateTarget(None)
         self.assertTrue(target.IsValid(), "Got a vaid empty target.")
         error = lldb.SBError()
         attach_info = lldb.SBAttachInfo()
         attach_info.SetProcessID(popen.pid)
         attach_info.SetIgnoreExisting(False)
         process = target.Attach(attach_info, error)
-        self.assertTrue(error.Success(), "Didn't attach successfully to %d: %s"%(popen.pid, error.GetCString()))
+        self.assertSuccess(error, "Didn't attach successfully to %d"%(popen.pid))
 
         bkpt = target.BreakpointCreateByName("dont_strip_me", exe)
         self.assertTrue(bkpt.GetNumLocations() > 0, "Didn't set the dont_strip_me bkpt.")
 
         threads = lldbutil.continue_to_breakpoint(process, bkpt)
         self.assertEqual(len(threads), 1, "Didn't hit my breakpoint.")
 
         # Our caller frame should have been stripped.  Make sure we made a synthetic symbol
         # for it:
         thread = threads[0]
         self.assertTrue(thread.num_frames > 1, "Couldn't backtrace.")
         name = thread.frame[1].GetFunctionName()
         self.assertTrue(name.startswith("___lldb_unnamed_symbol"))
 
 
 

lldb/test/API/macosx/profile_vrs_detach/TestDetachVrsProfile.py

def do_profile_and_detach(self):
         event = lldb.SBEvent()
         success = listener.WaitForEventForBroadcaster(0, process.GetBroadcaster(), event)
         self.assertTrue(success, "Got an event which should be running.")
         event_state = process.GetStateFromEvent(event)
         self.assertEqual(event_state, lldb.eStateRunning, "Got the running event")
 
         # Now detach:
         error = process.Detach()
-        self.assertTrue(error.Success(), "Detached successfully")
+        self.assertSuccess(error, "Detached successfully")

lldb/test/API/macosx/thread_suspend/TestInternalThreadSuspension.py

def setUp(self):
         TestBase.setUp(self)
         # Set up your test case here. If your test doesn't need any set up then
         # remove this method from your TestCase class.
 
     def try_an_expression(self, thread, correct_value, test_bp):
         frame = thread.frames[0]
 
         value = frame.EvaluateExpression('function_to_call()')
-        self.assertTrue(value.GetError().Success(), "Successfully called the function")
+        self.assertSuccess(value.GetError(), "Successfully called the function")
         self.assertEqual(value.GetValueAsSigned(), correct_value, "Got expected value for expression")
 
         # Again, make sure we didn't let the suspend thread breakpoint run:
         self.assertEqual(test_bp.GetHitCount(), 0, "First expression allowed the suspend thread to run")
 
         
     def make_bkpt(self, pattern):
         bp = self.target.BreakpointCreateBySourceRegex(pattern, self.main_source_file)

lldb/test/API/macosx/universal/TestUniversal.py

def test_process_attach_with_wrong_arch(self):
             "Our main breakpoint has locations.")
 
         popen = self.spawnSubprocess(exe, ["keep_waiting"])
 
         error = lldb.SBError()
         empty_listener = lldb.SBListener()
         process = target.AttachToProcessWithID(
             empty_listener, popen.pid, error)
-        self.assertTrue(error.Success(), "Attached to process.")
+        self.assertSuccess(error, "Attached to process.")
 
         self.expect("image list -A -b", substrs=["x86_64h testit"])
 
         # It may seem odd to check the number of frames, but the bug
         # that motivated this test was that we eventually fixed the
         # architecture, but we left the ABI set to the original value.
         # In that case, if you asked the process for its architecture,
         # it would look right, but since the ABI was wrong,
         # backtracing failed.
 
         threads = lldbutil.continue_to_breakpoint(process, bkpt)
         self.assertEquals(len(threads), 1)
         thread = threads[0]
         self.assertTrue(
             thread.GetNumFrames() > 1,
             "We were able to backtrace.")

lldb/test/API/python_api/debugger/TestDebuggerAPI.py

def test_debugger_internal_variables(self):
         process = target.Launch(launch_info, error)
         self.assertTrue(process, PROCESS_IS_VALID)
 
         # This should change the value of a process's local property.
         new_cache_line_size = global_cache_line_size + 512
         error = self.dbg.SetInternalVariable(property_name,
                                              str(new_cache_line_size),
                                              self.dbg.GetInstanceName())
-        self.assertTrue(error.Success(),
+        self.assertSuccess(error,
                            property_name + " value was changed successfully")
 
         # Check that it was set actually.
         self.assertEqual(get_cache_line_size(), new_cache_line_size)
 
         # Run any command to initialize CommandInterpreter's execution context.
         self.runCmd("target list")
 
         # Test the local property again, is it set to new_cache_line_size?
         self.assertEqual(get_cache_line_size(), new_cache_line_size)

lldb/test/API/python_api/file_handle/TestFileHandle.py

def test_sbfile_type_errors(self):
         self.assertRaises(Exception, sbf.Read, u"ham sandwich")
 
 
     def test_sbfile_write_fileno(self):
         with open(self.out_filename, 'w') as f:
             sbf = lldb.SBFile(f.fileno(), "w", False)
             self.assertTrue(sbf.IsValid())
             e, n = sbf.Write(b'FOO\nBAR')
-            self.assertTrue(e.Success())
+            self.assertSuccess(e)
             self.assertEqual(n, 7)
             sbf.Close()
             self.assertFalse(sbf.IsValid())
         with open(self.out_filename, 'r') as f:
             self.assertEqual(readStrippedLines(f), ['FOO', 'BAR'])
 
 
     def test_sbfile_write(self):
         with open(self.out_filename, 'w') as f:
             sbf = lldb.SBFile(f)
             e, n = sbf.Write(b'FOO\n')
-            self.assertTrue(e.Success())
+            self.assertSuccess(e)
             self.assertEqual(n, 4)
             sbf.Close()
             self.assertTrue(f.closed)
         with open(self.out_filename, 'r') as f:
             self.assertEqual(f.read().strip(), 'FOO')
 
 
     def test_sbfile_read_fileno(self):
         with open(self.out_filename, 'w') as f:
             f.write('FOO')
         with open(self.out_filename, 'r') as f:
             sbf = lldb.SBFile(f.fileno(), "r", False)
             self.assertTrue(sbf.IsValid())
             buffer = bytearray(100)
             e, n = sbf.Read(buffer)
-            self.assertTrue(e.Success())
+            self.assertSuccess(e)
             self.assertEqual(buffer[:n], b'FOO')
 
 
     def test_sbfile_read(self):
         with open(self.out_filename, 'w') as f:
             f.write('foo')
         with open(self.out_filename, 'r') as f:
             sbf = lldb.SBFile(f)
             buf = bytearray(100)
             e, n = sbf.Read(buf)
-            self.assertTrue(e.Success())
+            self.assertSuccess(e)
             self.assertEqual(n, 3)
             self.assertEqual(buf[:n], b'foo')
             sbf.Close()
             self.assertTrue(f.closed)
 
 
     def test_fileno_out(self):
         with open(self.out_filename, 'w') as f:
             sbf = lldb.SBFile(f.fileno(), "w", False)
             status = self.dbg.SetOutputFile(sbf)
-            self.assertTrue(status.Success())
+            self.assertSuccess(status)
             self.handleCmd('script 1+2')
             self.dbg.GetOutputFile().Write(b'quux')
             self.dbg.GetOutputFile().Flush()
 
         with open(self.out_filename, 'r') as f:
             self.assertEqual(readStrippedLines(f), ['3', 'quux'])
 
 
     def test_fileno_help(self):
         with open(self.out_filename, 'w') as f:
             sbf = lldb.SBFile(f.fileno(), "w", False)
             status = self.dbg.SetOutputFile(sbf)
-            self.assertTrue(status.Success())
+            self.assertSuccess(status)
             self.handleCmd("help help", collect_result=False, check=False)
         with open(self.out_filename, 'r') as f:
             self.assertTrue(re.search(r'Show a list of all debugger commands', f.read()))
 
 
     def test_help(self):
         with open(self.out_filename, 'w') as f:
             status = self.dbg.SetOutputFile(lldb.SBFile(f))
-            self.assertTrue(status.Success())
+            self.assertSuccess(status)
             self.handleCmd("help help", check=False, collect_result=False)
         with open(self.out_filename, 'r') as f:
             self.assertIn('Show a list of all debugger commands', f.read())
 
 
     def test_immediate(self):
         with open(self.out_filename, 'w') as f:
             ret = lldb.SBCommandReturnObject()
class FileHandleTestCase(lldbtest.TestBase):
     def test_fileno_inout(self):
         with open(self.in_filename, 'w') as f:
             f.write("help help\n")
 
         with open(self.out_filename, 'w') as outf, open(self.in_filename, 'r') as inf:
 
             outsbf = lldb.SBFile(outf.fileno(), "w", False)
             status = self.dbg.SetOutputFile(outsbf)
-            self.assertTrue(status.Success())
+            self.assertSuccess(status)
 
             insbf = lldb.SBFile(inf.fileno(), "r", False)
             status = self.dbg.SetInputFile(insbf)
-            self.assertTrue(status.Success())
+            self.assertSuccess(status)
 
             opts = lldb.SBCommandInterpreterRunOptions()
             self.dbg.RunCommandInterpreter(True, False, opts, 0, False, False)
             self.dbg.GetOutputFile().Flush()
 
         with open(self.out_filename, 'r') as f:
             self.assertTrue(re.search(r'Show a list of all debugger commands', f.read()))
 
 
     def test_inout(self):
         with open(self.in_filename, 'w') as f:
             f.write("help help\n")
         with  open(self.out_filename, 'w') as outf, \
               open(self.in_filename, 'r') as inf:
             status = self.dbg.SetOutputFile(lldb.SBFile(outf))
-            self.assertTrue(status.Success())
+            self.assertSuccess(status)
             status = self.dbg.SetInputFile(lldb.SBFile(inf))
-            self.assertTrue(status.Success())
+            self.assertSuccess(status)
             opts = lldb.SBCommandInterpreterRunOptions()
             self.dbg.RunCommandInterpreter(True, False, opts, 0, False, False)
             self.dbg.GetOutputFile().Flush()
         with open(self.out_filename, 'r') as f:
             output = f.read()
             self.assertIn('Show a list of all debugger commands', output)
 
 
     def test_binary_inout(self):
         with open(self.in_filename, 'w') as f:
             f.write("help help\n")
         with  open(self.out_filename, 'wb') as outf, \
               open(self.in_filename, 'rb') as inf:
             status = self.dbg.SetOutputFile(lldb.SBFile(outf))
-            self.assertTrue(status.Success())
+            self.assertSuccess(status)
             status = self.dbg.SetInputFile(lldb.SBFile(inf))
-            self.assertTrue(status.Success())
+            self.assertSuccess(status)
             opts = lldb.SBCommandInterpreterRunOptions()
             self.dbg.RunCommandInterpreter(True, False, opts, 0, False, False)
             self.dbg.GetOutputFile().Flush()
         with open(self.out_filename, 'r') as f:
             output = f.read()
             self.assertIn('Show a list of all debugger commands', output)
 
 
     @skipIf(py_version=['<', (3,)])
     def test_string_inout(self):
         inf = io.StringIO("help help\np/x ~0\n")
         outf = io.StringIO()
         status = self.dbg.SetOutputFile(lldb.SBFile(outf))
-        self.assertTrue(status.Success())
+        self.assertSuccess(status)
         status = self.dbg.SetInputFile(lldb.SBFile(inf))
-        self.assertTrue(status.Success())
+        self.assertSuccess(status)
         opts = lldb.SBCommandInterpreterRunOptions()
         self.dbg.RunCommandInterpreter(True, False, opts, 0, False, False)
         self.dbg.GetOutputFile().Flush()
         output = outf.getvalue()
         self.assertIn('Show a list of all debugger commands', output)
         self.assertIn('0xfff', output)
 
 
     @skipIf(py_version=['<', (3,)])
     def test_bytes_inout(self):
         inf = io.BytesIO(b"help help\nhelp b\n")
         outf = io.BytesIO()
         status = self.dbg.SetOutputFile(lldb.SBFile(outf))
-        self.assertTrue(status.Success())
+        self.assertSuccess(status)
         status = self.dbg.SetInputFile(lldb.SBFile(inf))
-        self.assertTrue(status.Success())
+        self.assertSuccess(status)
         opts = lldb.SBCommandInterpreterRunOptions()
         self.dbg.RunCommandInterpreter(True, False, opts, 0, False, False)
         self.dbg.GetOutputFile().Flush()
         output = outf.getvalue()
         self.assertIn(b'Show a list of all debugger commands', output)
         self.assertIn(b'Set a breakpoint', output)
 
 
     def test_fileno_error(self):
         with open(self.out_filename, 'w') as f:
 
             sbf = lldb.SBFile(f.fileno(), 'w', False)
             status = self.dbg.SetErrorFile(sbf)
-            self.assertTrue(status.Success())
+            self.assertSuccess(status)
 
             self.handleCmd('lolwut', check=False, collect_result=False)
 
             self.dbg.GetErrorFile().Write(b'\nzork\n')
 
         with open(self.out_filename, 'r') as f:
             errors = f.read()
             self.assertTrue(re.search(r'error:.*lolwut', errors))
def test_replace_stdout_with_nonfile(self):
             sys.stdout.write(u"FOO")
         self.assertEqual(f.getvalue(), "FOO")
 
 
     def test_sbfile_write_borrowed(self):
         with open(self.out_filename, 'w') as f:
             sbf = lldb.SBFile.Create(f, borrow=True)
             e, n = sbf.Write(b'FOO')
-            self.assertTrue(e.Success())
+            self.assertSuccess(e)
             self.assertEqual(n, 3)
             sbf.Close()
             self.assertFalse(f.closed)
             f.write('BAR\n')
         with open(self.out_filename, 'r') as f:
             self.assertEqual(f.read().strip(), 'FOOBAR')
 
 
 
     @skipIf(py_version=['<', (3,)])
     def test_sbfile_write_forced(self):
         with open(self.out_filename, 'w') as f:
             written = MutableBool(False)
             orig_write = f.write
             def mywrite(x):
                 written.set(True)
                 return orig_write(x)
             f.write = mywrite
             sbf = lldb.SBFile.Create(f, force_io_methods=True)
             e, n = sbf.Write(b'FOO')
             self.assertTrue(written)
-            self.assertTrue(e.Success())
+            self.assertSuccess(e)
             self.assertEqual(n, 3)
             sbf.Close()
             self.assertTrue(f.closed)
         with open(self.out_filename, 'r') as f:
             self.assertEqual(f.read().strip(), 'FOO')
 
 
     @skipIf(py_version=['<', (3,)])
     def test_sbfile_write_forced_borrowed(self):
         with open(self.out_filename, 'w') as f:
             written = MutableBool(False)
             orig_write = f.write
             def mywrite(x):
                 written.set(True)
                 return orig_write(x)
             f.write = mywrite
             sbf = lldb.SBFile.Create(f, borrow=True, force_io_methods=True)
             e, n = sbf.Write(b'FOO')
             self.assertTrue(written)
-            self.assertTrue(e.Success())
+            self.assertSuccess(e)
             self.assertEqual(n, 3)
             sbf.Close()
             self.assertFalse(f.closed)
         with open(self.out_filename, 'r') as f:
             self.assertEqual(f.read().strip(), 'FOO')
 
 
     @skipIf(py_version=['<', (3,)])
     def test_sbfile_write_string(self):
         f = io.StringIO()
         sbf = lldb.SBFile(f)
         e, n = sbf.Write(b'FOO')
         self.assertEqual(f.getvalue().strip(), "FOO")
-        self.assertTrue(e.Success())
+        self.assertSuccess(e)
         self.assertEqual(n, 3)
         sbf.Close()
         self.assertTrue(f.closed)
 
 
     @skipIf(py_version=['<', (3,)])
     def test_string_out(self):
         f = io.StringIO()
         status = self.dbg.SetOutputFile(f)
-        self.assertTrue(status.Success())
+        self.assertSuccess(status)
         self.handleCmd("script 'foobar'")
         self.assertEqual(f.getvalue().strip(), "'foobar'")
 
 
     @skipIf(py_version=['<', (3,)])
     def test_string_error(self):
         f = io.StringIO()
         status = self.dbg.SetErrorFile(f)
-        self.assertTrue(status.Success())
+        self.assertSuccess(status)
         self.handleCmd('lolwut', check=False, collect_result=False)
         errors = f.getvalue()
         self.assertTrue(re.search(r'error:.*lolwut', errors))
 
 
     @skipIf(py_version=['<', (3,)])
     def test_sbfile_write_bytes(self):
         f = io.BytesIO()
         sbf = lldb.SBFile(f)
         e, n = sbf.Write(b'FOO')
         self.assertEqual(f.getvalue().strip(), b"FOO")
-        self.assertTrue(e.Success())
+        self.assertSuccess(e)
         self.assertEqual(n, 3)
         sbf.Close()
         self.assertTrue(f.closed)
 
     @skipIf(py_version=['<', (3,)])
     def test_sbfile_read_string(self):
         f = io.StringIO('zork')
         sbf = lldb.SBFile(f)
         buf = bytearray(100)
         e, n = sbf.Read(buf)
-        self.assertTrue(e.Success())
+        self.assertSuccess(e)
         self.assertEqual(buf[:n], b'zork')
 
 
     @skipIf(py_version=['<', (3,)])
     def test_sbfile_read_string_one_byte(self):
         f = io.StringIO('z')
         sbf = lldb.SBFile(f)
         buf = bytearray(1)
         e, n = sbf.Read(buf)
         self.assertTrue(e.Fail())
         self.assertEqual(n, 0)
         self.assertEqual(e.GetCString(), "can't read less than 6 bytes from a utf8 text stream")
 
 
     @skipIf(py_version=['<', (3,)])
     def test_sbfile_read_bytes(self):
         f = io.BytesIO(b'zork')
         sbf = lldb.SBFile(f)
         buf = bytearray(100)
         e, n = sbf.Read(buf)
-        self.assertTrue(e.Success())
+        self.assertSuccess(e)
         self.assertEqual(buf[:n], b'zork')
 
 
     @skipIf(py_version=['<', (3,)])
     def test_sbfile_out(self):
         with open(self.out_filename, 'w') as f:
             sbf = lldb.SBFile(f)
             status = self.dbg.SetOutputFile(sbf)
-            self.assertTrue(status.Success())
+            self.assertSuccess(status)
             self.handleCmd('script 2+2')
         with open(self.out_filename, 'r') as f:
             self.assertEqual(f.read().strip(), '4')
 
 
     @skipIf(py_version=['<', (3,)])
     def test_file_out(self):
         with open(self.out_filename, 'w') as f:
             status = self.dbg.SetOutputFile(f)
-            self.assertTrue(status.Success())
+            self.assertSuccess(status)
             self.handleCmd('script 2+2')
         with open(self.out_filename, 'r') as f:
             self.assertEqual(f.read().strip(), '4')
 
 
     def test_sbfile_error(self):
         with open(self.out_filename, 'w') as f:
             sbf = lldb.SBFile(f)
             status = self.dbg.SetErrorFile(sbf)
-            self.assertTrue(status.Success())
+            self.assertSuccess(status)
             self.handleCmd('lolwut', check=False, collect_result=False)
         with open(self.out_filename, 'r') as f:
             errors = f.read()
             self.assertTrue(re.search(r'error:.*lolwut', errors))
 
 
     def test_file_error(self):
         with open(self.out_filename, 'w') as f:
             status = self.dbg.SetErrorFile(f)
-            self.assertTrue(status.Success())
+            self.assertSuccess(status)
             self.handleCmd('lolwut', check=False, collect_result=False)
         with open(self.out_filename, 'r') as f:
             errors = f.read()
             self.assertTrue(re.search(r'error:.*lolwut', errors))
 
 
     def test_exceptions(self):
         self.assertRaises(Exception, lldb.SBFile, None)
def test_fileno_flush(self):
             self.assertFalse(f.closed)
             f.seek(0)
             self.assertEqual(f.read(), 'foobar')
 
 
     def test_close(self):
         with open(self.out_filename, 'w') as f:
             status = self.dbg.SetOutputFile(f)
-            self.assertTrue(status.Success())
+            self.assertSuccess(status)
             self.handleCmd("help help", check=False, collect_result=False)
             # make sure the file wasn't closed early.
             f.write("\nZAP\n")
             lldb.SBDebugger.Destroy(self.dbg)
             # check that output file was closed when debugger was destroyed.
             with self.assertRaises(ValueError):
                 f.write("\nQUUX\n")
         with open(self.out_filename, 'r') as f:
             output = f.read()
             self.assertTrue(re.search(r'Show a list of all debugger commands', output))
             self.assertTrue(re.search(r'ZAP', output))
 
 
     @skipIf(py_version=['<', (3,)])
     def test_stdout(self):
         f = io.StringIO()
         status = self.dbg.SetOutputFile(f)
-        self.assertTrue(status.Success())
+        self.assertSuccess(status)
         self.handleCmd(r"script sys.stdout.write('foobar\n')")
         self.assertEqual(f.getvalue().strip().split(), ["foobar", "7"])
 
 
     def test_stdout_file(self):
         with open(self.out_filename, 'w') as f:
             status = self.dbg.SetOutputFile(f)
-            self.assertTrue(status.Success())
+            self.assertSuccess(status)
             self.handleCmd(r"script sys.stdout.write('foobar\n')")
         with open(self.out_filename, 'r') as f:
             # In python2 sys.stdout.write() returns None, which
             # the REPL will ignore, but in python3 it will
             # return the number of bytes written, which the REPL
             # will print out.
             lines = [x for x in f.read().strip().split() if x != "7"]
             self.assertEqual(lines, ["foobar"])
def test_set_filehandle_none(self):
         self.assertRaises(Exception, self.dbg.SetInputFile, "ham sandwich")
         self.assertRaises(Exception, self.dbg.SetInputFileHandle, "ham sandwich")
         self.assertRaises(Exception, self.dbg.SetErrorFile, None)
         self.assertRaises(Exception, self.dbg.SetErrorFile, "ham sandwich")
         self.assertRaises(Exception, self.dbg.SetErrorFileHandle, "ham sandwich")
 
         with open(self.out_filename, 'w') as f:
             status = self.dbg.SetOutputFile(f)
-            self.assertTrue(status.Success())
+            self.assertSuccess(status)
             status = self.dbg.SetErrorFile(f)
-            self.assertTrue(status.Success())
+            self.assertSuccess(status)
             self.dbg.SetOutputFileHandle(None, False)
             self.dbg.SetErrorFileHandle(None, False)
             sbf = self.dbg.GetOutputFile()
             if sys.version_info.major >= 3:
                 # python 2 lacks PyFile_FromFd, so GetFile() will
                 # have to duplicate the file descriptor and make a FILE*
                 # in order to convert a NativeFile it back to a python
                 # file.
                 self.assertEqual(sbf.GetFile().fileno(), 1)
             sbf = self.dbg.GetErrorFile()
             if sys.version_info.major >= 3:
                 self.assertEqual(sbf.GetFile().fileno(), 2)
         with open(self.out_filename, 'r') as f:
             status = self.dbg.SetInputFile(f)
-            self.assertTrue(status.Success())
+            self.assertSuccess(status)
             self.dbg.SetInputFileHandle(None, False)
             sbf = self.dbg.GetInputFile()
             if sys.version_info.major >= 3:
                 self.assertEqual(sbf.GetFile().fileno(), 0)
 
 
     def test_sbstream(self):
 
def test_sbstream(self):
         self.assertTrue(f.closed)
         with open(self.out_filename, 'r') as f:
             self.assertEqual(f.read().strip(), "Frobozz")
 
     def test_set_sbstream(self):
         with open(self.out_filename, 'w') as outf:
             outsbf = lldb.SBFile(outf.fileno(), "w", False)
             status = self.dbg.SetOutputFile(outsbf)
-            self.assertTrue(status.Success())
+            self.assertSuccess(status)
             self.dbg.SetInputString("help apropos\nhelp help\n")
 
             opts = lldb.SBCommandInterpreterRunOptions()
             self.dbg.RunCommandInterpreter(True, False, opts, 0, False, False)
             self.dbg.GetOutputFile().Flush()
 
         with open(self.out_filename, 'r') as f:
             output = f.read()
             self.assertIn('Show a list of all debugger commands', output)
             self.assertIn('List debugger commands related to a word', output)

lldb/test/API/python_api/process/read-mem-cstring/TestReadMemCString.py

def test_read_memory_c_string(self):
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(
             self, 'breakpoint here', self.main_source_spec, None, self.exe)
 
         frame = thread.GetFrameAtIndex(0)
 
         err = lldb.SBError()
 
         empty_str_addr = frame.FindVariable("empty_string").GetValueAsUnsigned(err)
-        self.assertTrue(err.Success())
+        self.assertSuccess(err)
         self.assertTrue(empty_str_addr != lldb.LLDB_INVALID_ADDRESS)
 
         one_letter_str_addr = frame.FindVariable("one_letter_string").GetValueAsUnsigned(err)
-        self.assertTrue(err.Success())
+        self.assertSuccess(err)
         self.assertTrue(one_letter_str_addr != lldb.LLDB_INVALID_ADDRESS)
 
         invalid_memory_str_addr = frame.FindVariable("invalid_memory_string").GetValueAsUnsigned(err)
-        self.assertTrue(err.Success())
+        self.assertSuccess(err)
         self.assertTrue(invalid_memory_str_addr != lldb.LLDB_INVALID_ADDRESS)
 
         # Important:  An empty (0-length) c-string must come back as a Python string, not a
         # None object.
         empty_str = process.ReadCStringFromMemory(empty_str_addr, 2048, err)
-        self.assertTrue(err.Success())
+        self.assertSuccess(err)
         self.assertEqual(empty_str, "")
 
         one_letter_string = process.ReadCStringFromMemory(one_letter_str_addr, 2048, err)
-        self.assertTrue(err.Success())
+        self.assertSuccess(err)
         self.assertEqual(one_letter_string, "1")
 
         invalid_memory_string = process.ReadCStringFromMemory(invalid_memory_str_addr, 2048, err)
         self.assertTrue(err.Fail())
         self.assertTrue(invalid_memory_string == "" or invalid_memory_string == None)

lldb/test/API/python_api/sbdata/TestSBData.py

def test_with_run_command(self):
         self.assertTrue(foobar.IsValid())
         data = foobar.GetPointeeData(0, 2)
         offset = 0
         error = lldb.SBError()
 
         self.assert_data(data.GetUnsignedInt32, offset, 1)
         offset += 4
         low = data.GetSignedInt16(error, offset)
-        self.assertTrue(error.Success())
+        self.assertSuccess(error)
         offset += 2
         high = data.GetSignedInt16(error, offset)
-        self.assertTrue(error.Success())
+        self.assertSuccess(error)
         offset += 2
         self.assertTrue(
             (low == 9 and high == 0) or (
                 low == 0 and high == 9),
             'foo[0].b == 9')
         self.assertTrue(
             fabs(
                 data.GetFloat(
                     error,
                     offset) -
                 3.14) < 1,
             'foo[0].c == 3.14')
-        self.assertTrue(error.Success())
+        self.assertSuccess(error)
         offset += 4
         self.assert_data(data.GetUnsignedInt32, offset, 8)
         offset += 4
         self.assert_data(data.GetUnsignedInt32, offset, 5)
         offset += 4
 
         self.runCmd("n")
 
def test_with_run_command(self):
         offset += 4
         self.assertTrue(
             fabs(
                 data.GetFloat(
                     error,
                     offset) -
                 3.14) < 1,
             'foo[1].c == 3.14')
-        self.assertTrue(error.Success())
+        self.assertSuccess(error)
 
         data = new_foobar.GetData()
 
         offset = 0
         self.assert_data(data.GetUnsignedInt32, offset, 8)
         offset += 4
         self.assert_data(data.GetUnsignedInt32, offset, 7)
         offset += 4
         self.assertTrue(
             fabs(
                 data.GetFloat(
                     error,
                     offset) -
                 6.28) < 1,
             'foo[1].c == 6.28')
-        self.assertTrue(error.Success())
+        self.assertSuccess(error)
 
         self.runCmd("n")
 
         barfoo = frame.FindVariable('barfoo')
 
         data = barfoo.GetData()
         offset = 0
         self.assert_data(data.GetUnsignedInt32, offset, 1)
         offset += 4
         self.assert_data(data.GetUnsignedInt32, offset, 2)
         offset += 4
         self.assertTrue(
             fabs(
                 data.GetFloat(
                     error,
                     offset) -
                 3) < 1,
             'barfoo[0].c == 3')
-        self.assertTrue(error.Success())
+        self.assertSuccess(error)
         offset += 4
         self.assert_data(data.GetUnsignedInt32, offset, 4)
         offset += 4
         self.assert_data(data.GetUnsignedInt32, offset, 5)
         offset += 4
         self.assertTrue(
             fabs(
                 data.GetFloat(
                     error,
                     offset) -
                 6) < 1,
             'barfoo[1].c == 6')
-        self.assertTrue(error.Success())
+        self.assertSuccess(error)
 
         new_object = barfoo.CreateValueFromData(
             "new_object", data, barfoo.GetType().GetBasicType(
                 lldb.eBasicTypeInt))
         self.assertEqual(new_object.GetValue(), "1", 'new_object == 1')
 
         if data.GetByteOrder() == lldb.eByteOrderBig:
             data.SetData(
                 error,
                 '\0\0\0A',
                 data.GetByteOrder(),
                 data.GetAddressByteSize())
         else:
             data.SetData(
                 error,
                 'A\0\0\0',
                 data.GetByteOrder(),
                 data.GetAddressByteSize())
-        self.assertTrue(error.Success())
+        self.assertSuccess(error)
 
         data2 = lldb.SBData()
         data2.SetData(
             error,
             'BCD',
             data.GetByteOrder(),
             data.GetAddressByteSize())
-        self.assertTrue(error.Success())
+        self.assertSuccess(error)
 
         data.Append(data2)
 
         # this breaks on EBCDIC
         offset = 0
         self.assert_data(data.GetUnsignedInt32, offset, 65)
         offset += 4
         self.assert_data(data.GetUnsignedInt8, offset, 66)
def test_with_run_command(self):
                 3.14, 6.28, 2.71])
         self.assertTrue(
             fabs(
                 data2.GetDouble(
                     error,
                     0) -
                 3.14) < 0.5,
             'double data2[0] = 3.14')
-        self.assertTrue(error.Success())
+        self.assertSuccess(error)
         self.assertTrue(
             fabs(
                 data2.GetDouble(
                     error,
                     8) -
                 6.28) < 0.5,
             'double data2[1] = 6.28')
-        self.assertTrue(error.Success())
+        self.assertSuccess(error)
         self.assertTrue(
             fabs(
                 data2.GetDouble(
                     error,
                     16) -
                 2.71) < 0.5,
             'double data2[2] = 2.71')
-        self.assertTrue(error.Success())
+        self.assertSuccess(error)
 
         data2 = lldb.SBData()
 
         data2.SetDataFromCString(hello_str)
         self.assertEqual(len(data2.uint8), len(hello_str))
         self.assert_data(data2.GetUnsignedInt8, 0, 104)
         self.assert_data(data2.GetUnsignedInt8, 1, 101)
         self.assert_data(data2.GetUnsignedInt8, 2, 108)

lldb/test/API/python_api/sbmodule/TestSBModule.py

def test_module_is_file_backed(self):
                                                self.background_pid, error)
         self.assertTrue(error.Success() and process,  PROCESS_IS_VALID)
         main_module = target.GetModuleAtIndex(0)
         self.assertEqual(main_module.GetFileSpec().GetFilename(), "a.out")
         self.assertFalse(main_module.IsFileBacked(),
                          "The module should not be backed by a file on disk.")
 
         error = process.Destroy()
-        self.assertTrue(error.Success(), "couldn't destroy process %s" % background_process.pid)
+        self.assertSuccess(error, "couldn't destroy process %s" % background_process.pid)
 

lldb/test/API/python_api/sbplatform/TestSBPlatform.py

def test_run(self):
         self.build()
         plat = lldb.SBPlatform.GetHostPlatform()
 
         os.environ["MY_TEST_ENV_VAR"]="SBPlatformAPICase.test_run"
         def cleanup():
             del os.environ["MY_TEST_ENV_VAR"]
         self.addTearDownHook(cleanup)
         cmd = lldb.SBPlatformShellCommand(self.getBuildArtifact("a.out"))
-        self.assertTrue(plat.Run(cmd).Success())
+        self.assertSuccess(plat.Run(cmd))
         self.assertIn("MY_TEST_ENV_VAR=SBPlatformAPICase.test_run", cmd.GetOutput())
 
     def test_SetSDKRoot(self):
         plat = lldb.SBPlatform("remote-linux") # arbitrary choice
         self.assertTrue(plat)
         plat.SetSDKRoot(self.getBuildDir())
         self.dbg.SetCurrentPlatform("remote-linux")
         self.expect("platform status",
                 substrs=["Sysroot:", self.getBuildDir()])

lldb/test/API/python_api/sbstructureddata/TestStructuredDataAPI.py

def structured_data_api_test(self):
             self.fail("FAILED:   " + error.GetCString())
 
         # Tests for invalid data type
         self.invalid_struct_test(example)
 
         # Test that GetDescription works:
         s.Clear()
         error = example.GetDescription(s)
-        self.assertTrue(error.Success(), "GetDescription works")
+        self.assertSuccess(error, "GetDescription works")
         if not "key_float" in s.GetData():
             self.fail("FAILED: could not find key_float in description output")
         
         dict_struct = lldb.SBStructuredData()
         dict_struct = example.GetValueForKey("key_dict")
 
         # Tests for dictionary data type
         self.dictionary_struct_test(example)

lldb/test/API/python_api/target/TestTargetAPI.py

def test_read_memory(self):
             None, None, self.get_process_working_directory())
 
         # find the file address in the .data section of the main
         # module
         data_section = self.find_data_section(target)
         sb_addr = lldb.SBAddress(data_section, 0)
         error = lldb.SBError()
         content = target.ReadMemory(sb_addr, 1, error)
-        self.assertTrue(error.Success(), "Make sure memory read succeeded")
+        self.assertSuccess(error, "Make sure memory read succeeded")
         self.assertEqual(len(content), 1)
 
 
     @skipIfWindows  # stdio manipulation unsupported on Windows
     @skipIfRemote   # stdio manipulation unsupported on remote iOS devices<rdar://problem/54581135>
     @skipIf(oslist=["linux"], archs=["arm", "aarch64"])
     @no_debug_info_test
     def test_launch_simple(self):

lldb/test/API/python_api/value/change_values/TestChangeValueAPI.py

def test_change_value(self):
         self.assertTrue(frame0.IsValid(), "Got a valid frame.")
 
         # Get the val variable and change it:
         error = lldb.SBError()
 
         val_value = frame0.FindVariable("val")
         self.assertTrue(val_value.IsValid(), "Got the SBValue for val")
         actual_value = val_value.GetValueAsSigned(error, 0)
-        self.assertTrue(error.Success(), "Got a value from val")
+        self.assertSuccess(error, "Got a value from val")
         self.assertEquals(actual_value, 100, "Got the right value from val")
 
         result = val_value.SetValueFromCString("12345")
         self.assertTrue(result, "Setting val returned True.")
         actual_value = val_value.GetValueAsSigned(error, 0)
-        self.assertTrue(error.Success(), "Got a changed value from val")
+        self.assertSuccess(error, "Got a changed value from val")
         self.assertEqual(
             actual_value, 12345,
             "Got the right changed value from val")
 
         # Now check that we can set a structure element:
 
         mine_value = frame0.FindVariable("mine")
         self.assertTrue(mine_value.IsValid(), "Got the SBValue for mine")
def test_change_value(self):
         # our end breakpoint.
         frame0 = thread.GetFrameAtIndex(0)
         self.assertTrue(frame0.IsValid(), "Second time: got a valid frame.")
         sp_value = frame0.FindValue("sp", lldb.eValueTypeRegister)
         self.assertTrue(sp_value.IsValid(), "Got a stack pointer value")
         result = sp_value.SetValueFromCString("1")
         self.assertTrue(result, "Setting sp returned true.")
         actual_value = sp_value.GetValueAsUnsigned(error, 0)
-        self.assertTrue(error.Success(), "Got a changed value for sp")
+        self.assertSuccess(error, "Got a changed value for sp")
         self.assertEqual(
             actual_value, 1,
             "Got the right changed value for sp.")
 
         # Boundary condition test the SBValue.CreateValueFromExpression() API.
         # LLDB should not crash!
         nosuchval = mine_value.CreateValueFromExpression(None, None)
 

lldb/test/API/sample_test/TestSampleTest.py

def sample_test(self):
         # 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)
 
         frame = thread.GetFrameAtIndex(0)
         test_var = frame.FindVariable("test_var")
-        self.assertTrue(test_var.GetError().Success(), "Failed to fetch test_var")
+        self.assertSuccess(test_var.GetError(), "Failed to fetch test_var")
         test_value = test_var.GetValueAsUnsigned()
         self.assertEqual(test_value, 10, "Got the right value for test_var")
 
     def sample_test_no_launch(self):
         """ Same as above but doesn't launch a process."""
 
         target = self.createTestTarget()
         self.expect_expr("global_test_var", result_value="10")

lldb/test/API/sample_test/main.c

 #include <stdio.h>
 
 int global_test_var = 10;
 
 int
 main()
 {
   int test_var = 10;
   printf ("Set a breakpoint here: %d.\n", test_var);
   //% test_var = self.frame().FindVariable("test_var")
   //% test_value = test_var.GetValueAsUnsigned()
-  //% self.assertTrue(test_var.GetError().Success(), "Failed to fetch test_var")
+  //% self.assertSuccess(test_var.GetError(), "Failed to fetch test_var")
   //% self.assertEqual(test_value, 10, "Failed to get the right value for test_var")
   return global_test_var;
 }