[lldb] Replace assertTrue(a == b, "msg") with assertEquals(a, b, "msg") in the test suite

[teemperor]

Summary

The error message from the construct assertTrue(a == b, "msg") are nearly always completely useless for actually debugging the issue.
This patch is just replacing this construct (and similar ones like assertTrue(a != b, ...) with the proper call to assertEqual or assertNotEquals.

This patch was mostly written by a shell script with some manual verification afterwards:

import sys

def sanitize_line(line):
  if line.strip().startswith("self.assertTrue(") and " == " in line:
    line = line.replace("self.assertTrue(", "self.assertEquals(")
    line = line.replace(" == ", ", ", 1)
  if line.strip().startswith("self.assertTrue(") and " != " in line:
    line = line.replace("self.assertTrue(", "self.assertNotEqual(")
    line = line.replace(" != ", ", ", 1)
  return line

for a in sys.argv[1:]:
  with open(a, "r") as f:
    lines = f.readlines()
  with open(a, "w") as f:
    for line in lines:
      f.write(sanitize_line(line))

[labath]

I think this is a good idea. I have glanced over the patch, and I have found a couple of places where your script gets things wrong. They all involve doing boolean expressions in the assertion, which takes on a different meaning when you replace the comparison operator with a comma.

lldb/test/API/functionalities/process_group/TestChangeProcessGroup.py

70–71

This is not right. It should probably be two asserts.

lldb/test/API/macosx/thread-names/TestInterruptThreadNames.py

39–41

same here

lldb/test/API/tools/lldb-vscode/launch/TestVSCode_launch.py

147

An equivalent expression would be if output: assertEquals(len(output), 0), though I'm not sure why we'd need both checks tbh -- we should have a consistent way of reporting "no output"...

[teemperor]

• Split up bool conditions (the one Pavel pointed out and one more).

[JDevlieghere]

LGTM. I don't know how complex your script is, but could you include it in the commit message or the script directory so that we can run this again in the future?

[stella.stamenova]

Either this change or D74243 broke the windows bot and I do suspect D74243 but have not confirmed it yet:

http://lab.llvm.org:8011/builders/lldb-x64-windows-ninja/builds/13719

[JDevlieghere]

In D74475#1874860, @stella.stamenova wrote:

Either this change or D74243 broke the windows bot and I do suspect D74243 but have not confirmed it yet:

http://lab.llvm.org:8011/builders/lldb-x64-windows-ninja/builds/13719

I've partially reverted this change (just for for TestBreakpointHitCount.py which is the one timing out on the Windows bot) in 16bf89267e5ac01d2b512ce784f23640a82de821.

[JDevlieghere]

Yup, looks like that was it, the bot is green again: http://lab.llvm.org:8011/builders/lldb-x64-windows-ninja/builds/13740

[stella.stamenova]

In D74475#1875674, @JDevlieghere wrote:

Yup, looks like that was it, the bot is green again: http://lab.llvm.org:8011/builders/lldb-x64-windows-ninja/builds/13740

Thanks for taking care of it!

lldb/test/API/commands/disassemble/basic/TestFrameDisassemble.py

def frame_disassemble_test(self):
         # Did we hit our breakpoint?
         from lldbsuite.test.lldbutil import get_threads_stopped_at_breakpoint
         threads = get_threads_stopped_at_breakpoint(process, breakpoint)
         self.assertTrue(
             len(threads) == 1,
             "There should be a thread stopped at our breakpoint")
 
         # The hit count for the breakpoint should be 1.
-        self.assertTrue(breakpoint.GetHitCount() == 1)
+        self.assertEquals(breakpoint.GetHitCount(), 1)
 
         frame = threads[0].GetFrameAtIndex(0)
         disassembly = frame.Disassemble()
-        self.assertTrue(len(disassembly) != 0, "Disassembly was empty.")
+        self.assertNotEqual(len(disassembly), 0, "Disassembly was empty.")

lldb/test/API/commands/expression/call-restarts/TestCallThatRestarts.py

def call_function(self):
         self.orig_frame_pc = frame.GetPC()
 
         num_sigchld = 30
         value = frame.EvaluateExpression(
             "call_me (%d)" %
             (num_sigchld), options)
         self.assertTrue(value.IsValid())
         self.assertTrue(value.GetError().Success())
-        self.assertTrue(value.GetValueAsSigned(-1) == num_sigchld)
+        self.assertEquals(value.GetValueAsSigned(-1), num_sigchld)
 
         self.check_after_call(num_sigchld)
 
         # Okay, now try with a breakpoint in the called code in the case where
         # we are ignoring breakpoint hits.
         handler_bkpt = target.BreakpointCreateBySourceRegex(
             "Got sigchld %d.", self.main_source_spec)
         self.assertTrue(handler_bkpt.GetNumLocations() > 0)
         options.SetIgnoreBreakpoints(True)
         options.SetUnwindOnError(True)
 
         value = frame.EvaluateExpression(
             "call_me (%d)" %
             (num_sigchld), options)
 
         self.assertTrue(value.IsValid() and value.GetError().Success())
-        self.assertTrue(value.GetValueAsSigned(-1) == num_sigchld)
+        self.assertEquals(value.GetValueAsSigned(-1), num_sigchld)
         self.check_after_call(num_sigchld)
 
         # Now set the signal to print but not stop and make sure that calling
         # still works:
         self.dbg.GetCommandInterpreter().HandleCommand(
             "process handle SIGCHLD -s 0 -p 1 -n 1", return_obj)
         self.assertTrue(
             return_obj.Succeeded(),
             "Set SIGCHLD to pass, no-stop, notify")
 
         value = frame.EvaluateExpression(
             "call_me (%d)" %
             (num_sigchld), options)
 
         self.assertTrue(value.IsValid() and value.GetError().Success())
-        self.assertTrue(value.GetValueAsSigned(-1) == num_sigchld)
+        self.assertEquals(value.GetValueAsSigned(-1), num_sigchld)
         self.check_after_call(num_sigchld)
 
         # Now set this unwind on error to false, and make sure that we still
         # complete the call:
         options.SetUnwindOnError(False)
         value = frame.EvaluateExpression(
             "call_me (%d)" %
             (num_sigchld), options)
 
         self.assertTrue(value.IsValid() and value.GetError().Success())
-        self.assertTrue(value.GetValueAsSigned(-1) == num_sigchld)
+        self.assertEquals(value.GetValueAsSigned(-1), num_sigchld)
         self.check_after_call(num_sigchld)
 
         # Okay, now set UnwindOnError to true, and then make the signal behavior to stop
         # and see that now we do stop at the signal point:
 
         self.dbg.GetCommandInterpreter().HandleCommand(
             "process handle SIGCHLD -s 1 -p 1 -n 1", return_obj)
         self.assertTrue(

lldb/test/API/commands/expression/call-throws/TestCallThatThrows.py

def call_function(self):
 
         frame = self.thread.GetFrameAtIndex(0)
         # Store away the PC to check that the functions unwind to the right
         # place after calls
         self.orig_frame_pc = frame.GetPC()
 
         value = frame.EvaluateExpression("[my_class callMeIThrow]", options)
         self.assertTrue(value.IsValid())
-        self.assertTrue(value.GetError().Success() == False)
+        self.assertEquals(value.GetError().Success(), False)
 
         self.check_after_call()
 
         # Okay, now try with a breakpoint in the called code in the case where
         # we are ignoring breakpoint hits.
         handler_bkpt = target.BreakpointCreateBySourceRegex(
             "I felt like it", self.main_source_spec)
         self.assertTrue(handler_bkpt.GetNumLocations() > 0)
def call_function(self):
 
         # Now turn off exception trapping, and call a function that catches the exceptions,
         # and make sure the function actually completes, and we get the right
         # value:
         options.SetTrapExceptions(False)
         value = frame.EvaluateExpression("[my_class iCatchMyself]", options)
         self.assertTrue(value.IsValid())
         self.assertTrue(value.GetError().Success())
-        self.assertTrue(value.GetValueAsUnsigned() == 57)
+        self.assertEquals(value.GetValueAsUnsigned(), 57)
         self.check_after_call()
         options.SetTrapExceptions(True)
 
         # Now set this unwind on error to false, and make sure that we stop
         # where the exception was thrown
         options.SetUnwindOnError(False)
         value = frame.EvaluateExpression("[my_class callMeIThrow]", options)
 
         self.assertTrue(
             value.IsValid() and value.GetError().Success() == False)
         self.check_after_call()

lldb/test/API/commands/expression/fixits/TestFixIts.py

def try_expressions(self):
         options.SetAutoApplyFixIts(True)
 
         frame = self.thread.GetFrameAtIndex(0)
 
         # Try with one error:
         value = frame.EvaluateExpression("my_pointer.first", options)
         self.assertTrue(value.IsValid())
         self.assertTrue(value.GetError().Success())
-        self.assertTrue(value.GetValueAsUnsigned() == 10)
+        self.assertEquals(value.GetValueAsUnsigned(), 10)
 
         # Try with two errors:
         two_error_expression = "my_pointer.second->a"
         value = frame.EvaluateExpression(two_error_expression, options)
         self.assertTrue(value.IsValid())
         self.assertTrue(value.GetError().Success())
-        self.assertTrue(value.GetValueAsUnsigned() == 20)
+        self.assertEquals(value.GetValueAsUnsigned(), 20)
 
         # Now turn off the fixits, and the expression should fail:
         options.SetAutoApplyFixIts(False)
         value = frame.EvaluateExpression(two_error_expression, options)
         self.assertTrue(value.IsValid())
         self.assertTrue(value.GetError().Fail())
         error_string = value.GetError().GetCString()
         self.assertTrue(
             error_string.find("fixed expression suggested:") != -1,
             "Fix was suggested")
         self.assertTrue(
             error_string.find("my_pointer->second.a") != -1,
             "Fix was right")

lldb/test/API/commands/expression/issue_11588/Test11588.py

def test_11581_commands(self):
         # register r14 is an x86_64 extension let's skip this part of the test
         # if we are on a different architecture
         if self.getArchitecture() == 'x86_64':
             target = self.dbg.GetSelectedTarget()
             process = target.GetProcess()
             frame = process.GetSelectedThread().GetSelectedFrame()
             pointer = frame.FindVariable("r14")
             addr = pointer.GetValueAsUnsigned(0)
-            self.assertTrue(addr != 0, "could not read pointer to StgClosure")
+            self.assertNotEqual(addr, 0, "could not read pointer to StgClosure")
             addr = addr - 1
             self.runCmd("register write r14 %d" % addr)
             self.expect(
                 "register read r14", substrs=[
                     "0x", hex(addr)[
                         2:].rstrip("L")])  # Remove trailing 'L' if it exists
             self.expect("expr --show-types -- *(StgClosure*)$r14",
                         substrs=["(StgClosure) $",
                                  "(StgClosure *) &$", "0x",
                                  hex(addr)[2:].rstrip("L"),
                                  "addr = ",
                                  str(addr),
                                  "load_address = ",
                                  str(addr)])

lldb/test/API/commands/expression/save_jit_objects/TestSaveJITObjects.py

def test_save_jit_objects(self):
 
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(
             self, "break", src_file_spec)
 
         frame = thread.frames[0]
 
         self.cleanJITFiles()
         frame.EvaluateExpression("(void*)malloc(0x1)")
-        self.assertTrue(self.countJITFiles() == 0,
+        self.assertEquals(self.countJITFiles(), 0,
                         "No files emitted with save-jit-objects=false")
 
         self.runCmd("settings set target.save-jit-objects true")
         frame.EvaluateExpression("(void*)malloc(0x1)")
         jit_files_count = self.countJITFiles()
         self.cleanJITFiles()
-        self.assertTrue(jit_files_count != 0,
+        self.assertNotEqual(jit_files_count, 0,
                         "At least one file emitted with save-jit-objects=true")
 
         process.Kill()
         os.chdir(self.getSourceDir())

lldb/test/API/commands/expression/test/TestExprs.py

def test_evaluate_expression_python(self):
         self.expect(lldbutil.get_filenames(thread)[0],
                     "Break correctly at main.cpp", exe=False,
                     startstr="main.cpp")
         self.expect(lldbutil.get_function_names(thread)[0],
                     "Break correctly at main()", exe=False,
                     startstr="main")
 
         # We should be stopped on the breakpoint with a hit count of 1.
-        self.assertTrue(breakpoint.GetHitCount() == 1, BREAKPOINT_HIT_ONCE)
+        self.assertEquals(breakpoint.GetHitCount(), 1, BREAKPOINT_HIT_ONCE)
 
         #
         # Use Python API to evaluate expressions while stopped in a stack frame.
         #
         frame = thread.GetFrameAtIndex(0)
 
         val = frame.EvaluateExpression("2.234")
         self.expect(val.GetValue(), "2.345 evaluated correctly", exe=False,
def test_evaluate_expression_python(self):
 
         callee_break = target.BreakpointCreateByName(
             "a_function_to_call", None)
         self.assertTrue(callee_break.GetNumLocations() > 0)
 
         # Make sure ignoring breakpoints works from the command line:
         self.expect("expression -i true -- a_function_to_call()",
                     substrs=['(int) $', ' 1'])
-        self.assertTrue(callee_break.GetHitCount() == 1)
+        self.assertEquals(callee_break.GetHitCount(), 1)
 
         # Now try ignoring breakpoints using the SB API's:
         options = lldb.SBExpressionOptions()
         options.SetIgnoreBreakpoints(True)
         value = frame.EvaluateExpression('a_function_to_call()', options)
         self.assertTrue(value.IsValid())
-        self.assertTrue(value.GetValueAsSigned(0) == 2)
-        self.assertTrue(callee_break.GetHitCount() == 2)
+        self.assertEquals(value.GetValueAsSigned(0), 2)
+        self.assertEquals(callee_break.GetHitCount(), 2)
 
     # rdar://problem/8686536
     # CommandInterpreter::HandleCommand is stripping \'s from input for
     # WantsRawCommand commands
     @expectedFailureNetBSD
     def test_expr_commands_can_handle_quotes(self):
         """Throw some expression commands with quotes at lldb."""
         self.build()

lldb/test/API/commands/expression/timeout/TestCallWithTimeout.py

def test(self):
 
         # Now do the same thing with the command line command, and make sure it
         # works too.
         interp = self.dbg.GetCommandInterpreter()
 
         result = lldb.SBCommandReturnObject()
         return_value = interp.HandleCommand(
             "expr -t 100 -u true -- wait_a_while(1000000)", result)
-        self.assertTrue(return_value == lldb.eReturnStatusFailed)
+        self.assertEquals(return_value, lldb.eReturnStatusFailed)
 
         # Okay, now do it again with long enough time outs:
 
         options.SetTimeoutInMicroSeconds(1000000)
         value = frame.EvaluateExpression("wait_a_while (1000)", options)
         self.assertTrue(value.IsValid())
         self.assertTrue(value.GetError().Success())
 
         # Now do the same thingwith the command line command, and make sure it
         # works too.
         interp = self.dbg.GetCommandInterpreter()
 
         result = lldb.SBCommandReturnObject()
         return_value = interp.HandleCommand(
             "expr -t 1000000 -u true -- wait_a_while(1000)", result)
-        self.assertTrue(return_value == lldb.eReturnStatusSuccessFinishResult)
+        self.assertEquals(return_value, lldb.eReturnStatusSuccessFinishResult)
 
         # Finally set the one thread timeout and make sure that doesn't change
         # things much:
 
         options.SetTimeoutInMicroSeconds(1000000)
         options.SetOneThreadTimeoutInMicroSeconds(500000)
         value = frame.EvaluateExpression("wait_a_while (1000)", options)
         self.assertTrue(value.IsValid())
         self.assertTrue(value.GetError().Success())

lldb/test/API/commands/frame/language/TestGuessLanguage.py

def do_test(self):
         # Did we hit our breakpoint?
         from lldbsuite.test.lldbutil import get_threads_stopped_at_breakpoint
         threads = get_threads_stopped_at_breakpoint(process, breakpoint)
         self.assertTrue(
             len(threads) == 1,
             "There should be a thread stopped at our breakpoint")
 
         # The hit count for the breakpoint should be 1.
-        self.assertTrue(breakpoint.GetHitCount() == 1)
+        self.assertEquals(breakpoint.GetHitCount(), 1)
 
         thread = threads[0]
 
         c_frame_language = lldb.eLanguageTypeC99
         cxx_frame_language = lldb.eLanguageTypeC_plus_plus_11
         # gcc emits DW_LANG_C89 even if -std=c99 was specified
         if "gcc" in self.getCompiler():
             c_frame_language = lldb.eLanguageTypeC89
             cxx_frame_language = lldb.eLanguageTypeC_plus_plus
 
         self.check_language(thread, 0, c_frame_language)
         self.check_language(thread, 1, cxx_frame_language)
         self.check_language(thread, 2, lldb.eLanguageTypeC_plus_plus)
 
 
 

lldb/test/API/commands/frame/var/TestFrameVar.py

def do_test(self):
         # Did we hit our breakpoint?
         from lldbsuite.test.lldbutil import get_threads_stopped_at_breakpoint
         threads = get_threads_stopped_at_breakpoint(process, breakpoint)
         self.assertTrue(
             len(threads) == 1,
             "There should be a thread stopped at our breakpoint")
 
         # The hit count for the breakpoint should be 1.
-        self.assertTrue(breakpoint.GetHitCount() == 1)
+        self.assertEquals(breakpoint.GetHitCount(), 1)
 
         frame = threads[0].GetFrameAtIndex(0)
         command_result = lldb.SBCommandReturnObject()
         interp = self.dbg.GetCommandInterpreter()
 
         # Just get args:
         result = interp.HandleCommand("frame var -l", command_result)
         self.assertEqual(result, lldb.eReturnStatusSuccessFinishResult, "frame var -a didn't succeed")

lldb/test/API/commands/process/launch-with-shellexpand/TestLaunchWithShellExpand.py

def test(self):
         os.environ["SHELL"] = '/bin/sh'
 
         self.runCmd(
             "process launch -X true -w %s -- fi*.tx? () > <" %
             (self.getSourceDir()))
 
         process = self.process()
 
-        self.assertTrue(process.GetState() == lldb.eStateStopped,
+        self.assertEquals(process.GetState(), lldb.eStateStopped,
                         STOPPED_DUE_TO_BREAKPOINT)
 
         thread = process.GetThreadAtIndex(0)
 
         self.assertTrue(thread.IsValid(),
                         "Process stopped at 'main' should have a valid thread")
 
         stop_reason = thread.GetStopReason()
def test(self):
         self.runCmd("process kill")
 
         self.runCmd(
             'process launch -X true -w %s -- "foo bar"' %
             (self.getSourceDir()))
 
         process = self.process()
 
-        self.assertTrue(process.GetState() == lldb.eStateStopped,
+        self.assertEquals(process.GetState(), lldb.eStateStopped,
                         STOPPED_DUE_TO_BREAKPOINT)
 
         thread = process.GetThreadAtIndex(0)
 
         self.assertTrue(thread.IsValid(),
                         "Process stopped at 'main' should have a valid thread")
 
         stop_reason = thread.GetStopReason()
 
         self.assertTrue(
             stop_reason == lldb.eStopReasonBreakpoint,
             "Thread in process stopped in 'main' should have a stop reason of eStopReasonBreakpoint")
 
         self.expect("frame variable argv[1]", substrs=['foo bar'])
 
         self.runCmd("process kill")
 
         self.runCmd('process launch -X true -w %s -- foo\ bar'
                     % (self.getBuildDir()))
 
         process = self.process()
 
-        self.assertTrue(process.GetState() == lldb.eStateStopped,
+        self.assertEquals(process.GetState(), lldb.eStateStopped,
                         STOPPED_DUE_TO_BREAKPOINT)
 
         thread = process.GetThreadAtIndex(0)
 
         self.assertTrue(thread.IsValid(),
                         "Process stopped at 'main' should have a valid thread")
 
         stop_reason = thread.GetStopReason()
 
         self.assertTrue(
             stop_reason == lldb.eStopReasonBreakpoint,
             "Thread in process stopped in 'main' should have a stop reason of eStopReasonBreakpoint")
 
         self.expect("frame variable argv[1]", substrs=['foo bar'])

lldb/test/API/commands/register/register/intel_xtended_registers/mpx_bound_violation/TestBoundViolation.py

def mpx_boundary_violation(self):
         self.runCmd("continue")
 
         if (process.GetState() == lldb.eStateStopped):
             self.expect("thread backtrace", STOPPED_DUE_TO_SIGNAL,
                         substrs = ['stop reason = signal SIGSEGV: lower bound violation',
                                    'fault address:', 'lower bound:', 'upper bound:'])
 
         self.runCmd("continue")
-        self.assertTrue(process.GetState() == lldb.eStateExited,
+        self.assertEquals(process.GetState(), lldb.eStateExited,
                         PROCESS_EXITED)

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

def test(self):
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(self.target, VALID_TARGET)
 
         lldbutil.run_break_set_by_symbol(self, 'main')
 
         process = target.LaunchSimple(None, None,
                                       self.get_process_working_directory())
         self.assertTrue(process.IsValid(), PROCESS_IS_VALID)
-        self.assertTrue(process.GetState() == lldb.eStateStopped,
+        self.assertEquals(process.GetState(), lldb.eStateStopped,
                         PROCESS_STOPPED)
 
         thread = lldbutil.get_stopped_thread(process,
                                              lldb.eStopReasonBreakpoint)
         self.assertTrue(thread.IsValid(), "Failed to get thread.")
 
         frame = thread.GetFrameAtIndex(0)
         self.assertTrue(frame.IsValid(), "Failed to get frame.")
 
         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.assertTrue(read_watchpoint, "Failed to set read watchpoint.")
 
         thread.StepOver()
-        self.assertTrue(thread.GetStopReason() == lldb.eStopReasonWatchpoint,
+        self.assertEquals(thread.GetStopReason(), lldb.eStopReasonWatchpoint,
                         STOPPED_DUE_TO_WATCHPOINT)
-        self.assertTrue(thread.GetStopDescription(20) == 'watchpoint 1')
+        self.assertEquals(thread.GetStopDescription(20), 'watchpoint 1')
 
         process.Continue()
-        self.assertTrue(process.GetState() == lldb.eStateStopped,
+        self.assertEquals(process.GetState(), lldb.eStateStopped,
                         PROCESS_STOPPED)
-        self.assertTrue(thread.GetStopDescription(20) == 'step over')
+        self.assertEquals(thread.GetStopDescription(20), 'step over')
 
         self.step_inst_for_watchpoint(1)
 
         write_value = frame.FindValue('g_watch_me_write',
                                       lldb.eValueTypeVariableGlobal)
         self.assertTrue(write_value, "Failed to find write value.")
 
         # Most of the MIPS boards provide only one H/W watchpoints, and S/W
         # 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())
 
         thread.StepOver()
-        self.assertTrue(thread.GetStopReason() == lldb.eStopReasonWatchpoint,
+        self.assertEquals(thread.GetStopReason(), lldb.eStopReasonWatchpoint,
                         STOPPED_DUE_TO_WATCHPOINT)
-        self.assertTrue(thread.GetStopDescription(20) == 'watchpoint 2')
+        self.assertEquals(thread.GetStopDescription(20), 'watchpoint 2')
 
         process.Continue()
-        self.assertTrue(process.GetState() == lldb.eStateStopped,
+        self.assertEquals(process.GetState(), lldb.eStateStopped,
                         PROCESS_STOPPED)
-        self.assertTrue(thread.GetStopDescription(20) == 'step over')
+        self.assertEquals(thread.GetStopDescription(20), 'step over')
 
         self.step_inst_for_watchpoint(2)
 
     def step_inst_for_watchpoint(self, wp_id):
         watchpoint_hit = False
         current_line = self.frame().GetLineEntry().GetLine()
         while self.frame().GetLineEntry().GetLine() == current_line:
             self.thread().StepInstruction(False)  # step_over=False
             stop_reason = self.thread().GetStopReason()
             if stop_reason == lldb.eStopReasonWatchpoint:
                 self.assertFalse(watchpoint_hit, "Watchpoint already hit.")
                 expected_stop_desc = "watchpoint %d" % wp_id
                 actual_stop_desc = self.thread().GetStopDescription(20)
-                self.assertTrue(actual_stop_desc == expected_stop_desc,
+                self.assertEquals(actual_stop_desc, expected_stop_desc,
                                 "Watchpoint ID didn't match.")
                 watchpoint_hit = True
             else:
-                self.assertTrue(stop_reason == lldb.eStopReasonPlanComplete,
+                self.assertEquals(stop_reason, lldb.eStopReasonPlanComplete,
                                 STOPPED_DUE_TO_STEP_IN)
         self.assertTrue(watchpoint_hit, "Watchpoint never hit.")

lldb/test/API/commands/watchpoints/watchpoint_disable/TestWatchpointDisable.py

def do_test(self, test_enable):
         self.assertTrue(thread.IsValid(), "We didn't stop at the before breakpoint.")
 
         ret_val = lldb.SBCommandReturnObject()
         self.dbg.GetCommandInterpreter().HandleCommand("watchpoint set variable -w write global_var", ret_val)
         self.assertTrue(ret_val.Succeeded(), "Watchpoint set variable did not return success.")
 
         wp = self.target.FindWatchpointByID(1)
         self.assertTrue(wp.IsValid(), "Didn't make a valid watchpoint.")
-        self.assertTrue(wp.GetWatchAddress() != lldb.LLDB_INVALID_ADDRESS, "Watch address is invalid")
+        self.assertNotEqual(wp.GetWatchAddress(), lldb.LLDB_INVALID_ADDRESS, "Watch address is invalid")
 
         wp.SetEnabled(False)
         self.assertTrue(not wp.IsEnabled(), "The watchpoint thinks it is still enabled")
 
         process.Continue()
 
         stop_reason = thread.GetStopReason()
 

lldb/test/API/functionalities/breakpoint/address_breakpoints/TestAddressBreakpoints.py

def address_breakpoints(self):
         # Did we hit our breakpoint?
         from lldbsuite.test.lldbutil import get_threads_stopped_at_breakpoint
         threads = get_threads_stopped_at_breakpoint(process, breakpoint)
         self.assertTrue(
             len(threads) == 1,
             "There should be a thread stopped at our breakpoint")
 
         # The hit count for the breakpoint should be 1.
-        self.assertTrue(breakpoint.GetHitCount() == 1)
+        self.assertEquals(breakpoint.GetHitCount(), 1)
 
         process.Kill()
 
         # Now re-launch and see that we hit the breakpoint again:
         launch_info.Clear()
         launch_info.SetLaunchFlags(flags)
 
         process = target.Launch(launch_info, error)
         self.assertTrue(process, PROCESS_IS_VALID)
 
         thread = get_threads_stopped_at_breakpoint(process, breakpoint)
         self.assertTrue(
             len(threads) == 1,
             "There should be a thread stopped at our breakpoint")
 
         # The hit count for the breakpoint should now be 2.
-        self.assertTrue(breakpoint.GetHitCount() == 2)
+        self.assertEquals(breakpoint.GetHitCount(), 2)

lldb/test/API/functionalities/breakpoint/address_breakpoints/TestBadAddressBreakpoints.py

def address_breakpoints(self):
         # have a good way to know what an illegal address is...
         error = lldb.SBError()
 
         ptr = process.ReadPointerFromMemory(0x0, error)
 
         if not error.Success():
             bkpt = target.BreakpointCreateByAddress(0x0)
             for bp_loc in bkpt:
-                self.assertTrue(bp_loc.IsResolved() == False)
+                self.assertEquals(bp_loc.IsResolved(), False)
         else:
             self.fail(
                 "Could not find an illegal address at which to set a bad breakpoint.")

lldb/test/API/functionalities/breakpoint/breakpoint_hit_count/TestBreakpointHitCount.py

def test_breakpoint_one_shot(self):
 
         from lldbsuite.test.lldbutil import get_stopped_thread
         thread = get_stopped_thread(process, lldb.eStopReasonBreakpoint)
         self.assertTrue(
             thread.IsValid(),
             "There should be a thread stopped due to breakpoint")
 
         frame0 = thread.GetFrameAtIndex(0)
-        self.assertTrue(frame0.GetFunctionName() == "a(int)" or frame0.GetFunctionName() == "int a(int)");
+        self.assertEquals(frame0.GetFunctionName(), "a(int)" or frame0.GetFunctionName() == "int a(int)");
 
         process.Continue()
         self.assertEqual(process.GetState(), lldb.eStateExited)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         self.a_int_body_line_no = line_number(

lldb/test/API/functionalities/breakpoint/breakpoint_ids/TestBreakpointIDs.py

def test(self):
         self.build()
 
         exe = self.getBuildArtifact("a.out")
         self.expect("file " + exe,
                     patterns=["Current executable set to .*a.out"])
 
         bpno = lldbutil.run_break_set_by_symbol(
             self, 'product', num_expected_locations=-1, sym_exact=False)
-        self.assertTrue(bpno == 1, "First breakpoint number is 1.")
+        self.assertEquals(bpno, 1, "First breakpoint number is 1.")
 
         bpno = lldbutil.run_break_set_by_symbol(
             self, 'sum', num_expected_locations=-1, sym_exact=False)
-        self.assertTrue(bpno == 2, "Second breakpoint number is 2.")
+        self.assertEquals(bpno, 2, "Second breakpoint number is 2.")
 
         bpno = lldbutil.run_break_set_by_symbol(
             self, 'junk', num_expected_locations=0, sym_exact=False)
-        self.assertTrue(bpno == 3, "Third breakpoint number is 3.")
+        self.assertEquals(bpno, 3, "Third breakpoint number is 3.")
 
         self.expect(
             "breakpoint disable 1.1 - 2.2 ",
             COMMAND_FAILED_AS_EXPECTED,
             error=True,
             startstr="error: Invalid range: Ranges that specify particular breakpoint locations must be within the same major breakpoint; you specified two different major breakpoints, 1 and 2.")
 
         self.expect(

lldb/test/API/functionalities/breakpoint/breakpoint_locations/TestBreakpointLocations.py

def shadowed_bkpt_cond_test(self):
         # a breakpoint location option was specifically set.  After that the other options
         # on that location would stop tracking the breakpoint.  That got fixed, and this test
         # makes sure only the option touched is affected.
 
         bkpt = self.set_breakpoint()
         bkpt_cond = "1 == 0"
         bkpt.SetCondition(bkpt_cond)
         self.assertEqual(bkpt.GetCondition(), bkpt_cond,"Successfully set condition")
-        self.assertTrue(bkpt.location[0].GetCondition() == bkpt.GetCondition(), "Conditions are the same")
+        self.assertEquals(bkpt.location[0].GetCondition(), bkpt.GetCondition(), "Conditions are the same")
 
         # Now set a condition on the locations, make sure that this doesn't effect the bkpt:
         bkpt_loc_1_cond = "1 == 1"
         bkpt.location[0].SetCondition(bkpt_loc_1_cond)
         self.assertEqual(bkpt.location[0].GetCondition(), bkpt_loc_1_cond, "Successfully changed location condition")
         self.assertNotEqual(bkpt.GetCondition(), bkpt_loc_1_cond, "Changed location changed Breakpoint condition")
         self.assertEqual(bkpt.location[1].GetCondition(), bkpt_cond, "Changed another location's condition")
 

lldb/test/API/functionalities/breakpoint/breakpoint_names/TestBreakpointNames.py

def do_check_names(self):
         bkpt.RemoveName(bkpt_name)
         matches = bkpt.MatchesName(bkpt_name)
         self.assertTrue(not matches,"We still match a name after removing it.")
 
         # Make sure the name list has the remaining name:
         name_list = lldb.SBStringList()
         bkpt.GetNames(name_list)
         num_names = name_list.GetSize()
-        self.assertTrue(num_names == 1, "Name list has %d items, expected 1."%(num_names))
+        self.assertEquals(num_names, 1, "Name list has %d items, expected 1."%(num_names))
 
         name = name_list.GetStringAtIndex(0)
-        self.assertTrue(name == other_bkpt_name, "Remaining name was: %s expected %s."%(name, other_bkpt_name))
+        self.assertEquals(name, other_bkpt_name, "Remaining name was: %s expected %s."%(name, other_bkpt_name))
 
     def do_check_illegal_names(self):
         """Use Python APIs to check that we reject illegal names."""
         bkpt = self.target.BreakpointCreateByLocation(self.main_file_spec, 10)
         bad_names = ["-CantStartWithADash",
                      "1CantStartWithANumber",
                      "^CantStartWithNonAlpha",
                      "CantHave-ADash",
def do_check_using_names(self):
 
         # Add a name and make sure we match it:
         success = bkpt.AddName(bkpt_name)
         self.assertTrue(success, "We couldn't add a legal name to a breakpoint.")
 
         bkpts = lldb.SBBreakpointList(self.target)
         self.target.FindBreakpointsByName(bkpt_name, bkpts)
 
-        self.assertTrue(bkpts.GetSize() == 1, "One breakpoint matched.")
+        self.assertEquals(bkpts.GetSize(), 1, "One breakpoint matched.")
         found_bkpt = bkpts.GetBreakpointAtIndex(0)
-        self.assertTrue(bkpt.GetID() == found_bkpt.GetID(),"The right breakpoint.")
-        self.assertTrue(bkpt.GetID() == bkpt_id,"With the same ID as before.")
+        self.assertEquals(bkpt.GetID(), found_bkpt.GetID(),"The right breakpoint.")
+        self.assertEquals(bkpt.GetID(), bkpt_id,"With the same ID as before.")
 
         retval = lldb.SBCommandReturnObject()
         self.dbg.GetCommandInterpreter().HandleCommand("break disable %s"%(bkpt_name), retval)
         self.assertTrue(retval.Succeeded(), "break disable failed with: %s."%(retval.GetError()))
         self.assertTrue(not bkpt.IsEnabled(), "We didn't disable the breakpoint.")
 
         # Also make sure we don't apply commands to non-matching names:
         self.dbg.GetCommandInterpreter().HandleCommand("break modify --one-shot 1 %s"%(other_bkpt_name), retval)

lldb/test/API/functionalities/breakpoint/consecutive_breakpoints/TestConsecutiveBreakpoints.py

def prepare_test(self):
         (self.target, self.process, self.thread, bkpt) = lldbutil.run_to_source_breakpoint(
                 self, "Set breakpoint here", lldb.SBFileSpec("main.cpp"))
 
         # Set breakpoint to the next instruction
         frame = self.thread.GetFrameAtIndex(0)
 
         address = frame.GetPCAddress()
         instructions = self.target.ReadInstructions(address, 2)
-        self.assertTrue(len(instructions) == 2)
+        self.assertEquals(len(instructions), 2)
         self.bkpt_address = instructions[1].GetAddress()
         self.breakpoint2 = self.target.BreakpointCreateByAddress(
             self.bkpt_address.GetLoadAddress(self.target))
         self.assertTrue(
             self.breakpoint2 and self.breakpoint2.GetNumLocations() == 1,
             VALID_BREAKPOINT)
 
     def finish_test(self):

lldb/test/API/functionalities/breakpoint/cpp_exception/TestCPPExceptionBreakpoint.py

def do_cpp_exception_bkpt(self):
             "Created exception breakpoint.")
 
         process = self.target.LaunchSimple(
             None, None, self.get_process_working_directory())
         self.assertTrue(process, PROCESS_IS_VALID)
 
         thread_list = lldbutil.get_threads_stopped_at_breakpoint(
             process, exception_bkpt)
-        self.assertTrue(len(thread_list) == 1,
+        self.assertEquals(len(thread_list), 1,
                         "One thread stopped at the exception breakpoint.")
 
     def do_dummy_target_cpp_exception_bkpt(self):
         exe = self.getBuildArtifact("a.out")
         error = lldb.SBError()
 
         dummy_exception_bkpt = self.dbg.GetDummyTarget().BreakpointCreateForException(
             lldb.eLanguageTypeC_plus_plus, False, True)
def do_dummy_target_cpp_exception_bkpt(self):
             "Target primed with exception breakpoint from dummy target.")
 
         process = self.target.LaunchSimple(
             None, None, self.get_process_working_directory())
         self.assertTrue(process, PROCESS_IS_VALID)
 
         thread_list = lldbutil.get_threads_stopped_at_breakpoint(
            process, exception_bkpt)
-        self.assertTrue(len(thread_list) == 1,
+        self.assertEquals(len(thread_list), 1,
                        "One thread stopped at the exception breakpoint.")

lldb/test/API/functionalities/breakpoint/source_regexp/TestSourceRegexBreakpoints.py

def source_regex_locations(self):
         address = loc.GetAddress()
         self.assertTrue(
             address.IsValid(),
             "Got a valid address from the location.")
 
         a_func_line = line_number("a.c", "Set A breakpoint here")
         line_entry = address.GetLineEntry()
         self.assertTrue(line_entry.IsValid(), "Got a valid line entry.")
-        self.assertTrue(line_entry.line == a_func_line,
+        self.assertEquals(line_entry.line, a_func_line,
                         "Our line number matches the one lldbtest found.")
 
     def source_regex_restrictions(self):
         """ Test that restricting source expressions to files & to functions. """
         # Create a target by the debugger.
         exe = self.getBuildArtifact("a.out")
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/test/API/functionalities/data-formatter/format-propagation/TestFormatPropagation.py

def test_with_run_command(self):
         self.assertTrue(
             parent is not None and parent.IsValid(),
             "could not find f")
         X = parent.GetChildMemberWithName("X")
         self.assertTrue(X is not None and X.IsValid(), "could not find X")
         Y = parent.GetChildMemberWithName("Y")
         self.assertTrue(Y is not None and Y.IsValid(), "could not find Y")
         # check their values now
-        self.assertTrue(X.GetValue() == "1", "X has an invalid value")
-        self.assertTrue(Y.GetValue() == "2", "Y has an invalid value")
+        self.assertEquals(X.GetValue(), "1", "X has an invalid value")
+        self.assertEquals(Y.GetValue(), "2", "Y has an invalid value")
         # set the format on the parent
         parent.SetFormat(lldb.eFormatHex)
         self.assertTrue(
             X.GetValue() == "0x00000001",
             "X has not changed format")
         self.assertTrue(
             Y.GetValue() == "0x00000002",
             "Y has not changed format")
         # Step and check if the values make sense still
         self.runCmd("next")
-        self.assertTrue(X.GetValue() == "0x00000004", "X has not become 4")
-        self.assertTrue(Y.GetValue() == "0x00000002", "Y has not stuck as hex")
+        self.assertEquals(X.GetValue(), "0x00000004", "X has not become 4")
+        self.assertEquals(Y.GetValue(), "0x00000002", "Y has not stuck as hex")
         # Check that children can still make their own choices
         Y.SetFormat(lldb.eFormatDecimal)
-        self.assertTrue(X.GetValue() == "0x00000004", "X is still hex")
-        self.assertTrue(Y.GetValue() == "2", "Y has not been reset")
+        self.assertEquals(X.GetValue(), "0x00000004", "X is still hex")
+        self.assertEquals(Y.GetValue(), "2", "Y has not been reset")
         # Make a few more changes
         parent.SetFormat(lldb.eFormatDefault)
         X.SetFormat(lldb.eFormatHex)
         Y.SetFormat(lldb.eFormatDefault)
         self.assertTrue(
             X.GetValue() == "0x00000004",
             "X is not hex as it asked")
-        self.assertTrue(Y.GetValue() == "2", "Y is not defaulted")
+        self.assertEquals(Y.GetValue(), "2", "Y is not defaulted")

lldb/test/API/functionalities/dynamic_value_child_count/TestDynamicValueChildCount.py

def test_get_dynamic_vals(self):
             'pass-to-base.cpp', self.main_sixth_call_line)
         self.assertTrue(sixth_call_bpt,
                         VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at the entry point.
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
 
-        self.assertTrue(process.GetState() == lldb.eStateStopped,
+        self.assertEquals(process.GetState(), lldb.eStateStopped,
                         PROCESS_STOPPED)
 
         b = self.frame().FindVariable("b").GetDynamicValue(lldb.eDynamicCanRunTarget)
-        self.assertTrue(b.GetNumChildren() == 0, "b has 0 children")
+        self.assertEquals(b.GetNumChildren(), 0, "b has 0 children")
         self.runCmd("continue")
-        self.assertTrue(b.GetNumChildren() == 0, "b still has 0 children")
+        self.assertEquals(b.GetNumChildren(), 0, "b still has 0 children")
         self.runCmd("continue")
-        self.assertTrue(b.GetNumChildren() != 0, "b now has 1 child")
+        self.assertNotEqual(b.GetNumChildren(), 0, "b now has 1 child")
         self.runCmd("continue")
         self.assertTrue(
             b.GetNumChildren() == 0,
             "b didn't go back to 0 children")

lldb/test/API/functionalities/memory/cache/TestMemoryCache.py

def test_memory_cache(self):
 
         # Read a chunk of memory containing &my_ints[0]. The number of bytes read
         # must be greater than m_L2_cache_line_byte_size to make sure the L1
         # cache is used.
         self.runCmd('memory read -f d -c 201 `&my_ints - 100`')
 
         # Check the value of my_ints[0] is the same as set in main.cpp.
         line = self.res.GetOutput().splitlines()[100]
-        self.assertTrue(0x00000042 == int(line.split(':')[1], 0))
+        self.assertEquals(0x00000042, int(line.split(':')[1], 0))
 
         # Change the value of my_ints[0] in memory.
         self.runCmd("memory write -s 4 `&my_ints` AA")
 
         # Re-read the chunk of memory. The cache line should have been
         # flushed because of the 'memory write'.
         self.runCmd('memory read -f d -c 201 `&my_ints - 100`')
 
         # Check the value of my_ints[0] have been updated correctly.
         line = self.res.GetOutput().splitlines()[100]
-        self.assertTrue(0x000000AA == int(line.split(':')[1], 0))
+        self.assertEquals(0x000000AA, int(line.split(':')[1], 0))

lldb/test/API/functionalities/memory/read/TestMemoryRead.py

def test_memory_read(self):
 
         # Find the starting address for variable 'argc' to verify later that the
         # '--format uint32_t[] --size 4 --count 4' option increments the address
         # correctly.
         line = self.res.GetOutput().splitlines()[0]
         items = line.split(':')
         address = int(items[0], 0)
         argc = int(items[1], 0)
-        self.assertTrue(address > 0 and argc == 1)
+        self.assertGreater(address, 0)
+        self.assertEquals(argc, 1)
 
         # (lldb) memory read --format uint32_t[] --size 4 --count 4 `&argc`
         # 0x7fff5fbff9a0: {0x00000001}
         # 0x7fff5fbff9a4: {0x00000000}
         # 0x7fff5fbff9a8: {0x0ec0bf27}
         # 0x7fff5fbff9ac: {0x215db505}
         self.runCmd(
             "memory read --format uint32_t[] --size 4 --count 4 `&argc`")
         lines = self.res.GetOutput().splitlines()
         for i in range(4):
             if i == 0:
                 # Verify that the printout for argc is correct.
                 self.assertTrue(
                     argc == int(
                         lines[i].split(':')[1].strip(' {}'), 0))
             addr = int(lines[i].split(':')[0], 0)
             # Verify that the printout for addr is incremented correctly.
-            self.assertTrue(addr == (address + i * 4))
+            self.assertEquals(addr, (address + i * 4))
 
         # (lldb) memory read --format char[] --size 7 --count 1 `&my_string`
         # 0x7fff5fbff990: {abcdefg}
         self.expect(
             "memory read --format char[] --size 7 --count 1 `&my_string`",
             substrs=['abcdefg'])
 
         # (lldb) memory read --format 'hex float' --size 16 `&argc`
def test_memory_read(self):
               "memory read --gdb-format 4%s &my_uint64s" % formatter)
           lines = self.res.GetOutput().splitlines()
           objects_read = []
           for l in lines:
               objects_read.extend(l.split(':')[1].split())
           # Check that we got back 4 0x0000 etc bytes
           for o in objects_read:
               self.assertTrue (len(o) == expected_object_length)
-          self.assertTrue(len(objects_read) == 4)
+          self.assertEquals(len(objects_read), 4)

lldb/test/API/functionalities/mtc/simple/TestMTCSimple.py

def test(self):
         if self.mtc_dylib_path == "":
             self.skipTest("This test requires libMainThreadChecker.dylib")
 
         self.build()
         self.mtc_tests()
 
     @skipIf(archs=['i386'])
     def mtc_tests(self):
-        self.assertTrue(self.mtc_dylib_path != "")
+        self.assertNotEqual(self.mtc_dylib_path, "")
 
         # Load the test
         exe = self.getBuildArtifact("a.out")
         self.expect("file " + exe, patterns=["Current executable set to .*a.out"])
 
         self.runCmd("env DYLD_INSERT_LIBRARIES=%s" % self.mtc_dylib_path)
         self.runCmd("run")
 

lldb/test/API/functionalities/plugins/python_os_plugin/TestPythonOSPlugin.py

def run_python_os_step(self):
         self.assertTrue(
             frame.IsValid(),
             "Make sure we get a frame from thread 0x111111111")
         line_entry = frame.GetLineEntry()
 
         self.assertTrue(
             line_entry.GetFileSpec().GetFilename() == 'main.c',
             "Make sure we stepped from line 5 to line 6 in main.c")
-        self.assertTrue(line_entry.GetLine() == 6,
+        self.assertEquals(line_entry.GetLine(), 6,
                         "Make sure we stepped from line 5 to line 6 in main.c")

lldb/test/API/functionalities/process_group/TestChangeProcessGroup.py

def test_setpgid(self):
         # set a breakpoint just before the setpgid() call
         lldbutil.run_break_set_by_file_and_line(
             self, 'main.c', self.line, num_expected_locations=-1)
 
         thread = process.GetSelectedThread()
 
         # release the child from its loop
         value = thread.GetSelectedFrame().EvaluateExpression("release_child_flag = 1")
-        self.assertTrue(value.IsValid() and value.GetValueAsUnsigned(0) == 1)
+        self.assertTrue(value.IsValid())
+        self.assertEquals(value.GetValueAsUnsigned(0), 1)
         process.Continue()
 
         # make sure the child's process group id is different from its pid
         value = thread.GetSelectedFrame().EvaluateExpression("(int)getpgid(0)")
         self.assertTrue(value.IsValid())
         self.assertNotEqual(value.GetValueAsUnsigned(0), int(pid))
 
         # step over the setpgid() call

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

def test_with_python(self):
 
         # inner_sint returns the variable value, so capture that here:
         in_int = thread.GetFrameAtIndex(0).FindVariable(
             "value").GetValueAsSigned(error)
         self.assertTrue(error.Success())
 
         thread.StepOut()
 
-        self.assertTrue(self.process.GetState() == lldb.eStateStopped)
-        self.assertTrue(thread.GetStopReason() == lldb.eStopReasonPlanComplete)
+        self.assertEquals(self.process.GetState(), lldb.eStateStopped)
+        self.assertEquals(thread.GetStopReason(), lldb.eStopReasonPlanComplete)
 
         frame = thread.GetFrameAtIndex(0)
         fun_name = frame.GetFunctionName()
-        self.assertTrue(fun_name == "outer_sint(int)")
+        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.assertTrue(in_int == ret_int)
+        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.assertTrue(len(thread_list) == 1)
+        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.assertTrue(fun_name == "outer_sint(int)")
+        self.assertEquals(fun_name, "outer_sint(int)")
         in_int = frame.FindVariable("value").GetValueAsSigned(error)
         self.assertTrue(error.Success())
 
         thread.StepOutOfFrame(frame)
 
-        self.assertTrue(self.process.GetState() == lldb.eStateStopped)
-        self.assertTrue(thread.GetStopReason() == lldb.eStopReasonPlanComplete)
+        self.assertEquals(self.process.GetState(), lldb.eStateStopped)
+        self.assertEquals(thread.GetStopReason(), lldb.eStopReasonPlanComplete)
         frame = thread.GetFrameAtIndex(0)
         fun_name = frame.GetFunctionName()
-        self.assertTrue(fun_name == "main")
+        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.assertTrue(2 * in_int == ret_int)
+        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(
             self.process, inner_float_bkpt)
-        self.assertTrue(len(thread_list) == 1)
+        self.assertEquals(len(thread_list), 1)
         thread = thread_list[0]
 
         self.target.BreakpointDelete(inner_float_bkpt.GetID())
 
         frame = thread.GetFrameAtIndex(0)
         in_value = frame.FindVariable("value")
         in_float = float(in_value.GetValue())
         thread.StepOut()
 
-        self.assertTrue(self.process.GetState() == lldb.eStateStopped)
-        self.assertTrue(thread.GetStopReason() == lldb.eStopReasonPlanComplete)
+        self.assertEquals(self.process.GetState(), lldb.eStateStopped)
+        self.assertEquals(thread.GetStopReason(), lldb.eStopReasonPlanComplete)
 
         frame = thread.GetFrameAtIndex(0)
         fun_name = frame.GetFunctionName()
-        self.assertTrue(fun_name == "outer_float(float)")
+        self.assertEquals(fun_name, "outer_float(float)")
 
         #return_value = thread.GetStopReturnValue()
         #self.assertTrue(return_value.IsValid())
         #return_float = float(return_value.GetValue())
 
         #self.assertTrue(in_float == return_float)
 
         if not self.affected_by_radar_34562999() and not self.affected_by_pr44132():
def return_and_test_struct_value(self, func_name):
         bkpt = self.target.BreakpointCreateByName(func_name)
         self.assertTrue(bkpt.GetNumResolvedLocations() > 0)
 
         self.process.Continue()
 
         thread_list = lldbutil.get_threads_stopped_at_breakpoint(
             self.process, bkpt)
 
-        self.assertTrue(len(thread_list) == 1)
+        self.assertEquals(len(thread_list), 1)
         thread = thread_list[0]
 
         self.target.BreakpointDelete(bkpt.GetID())
 
         in_value = thread.GetFrameAtIndex(0).FindVariable("value")
 
         self.assertTrue(in_value.IsValid())
         num_in_children = in_value.GetNumChildren()
 
         # This is a little hokey, but if we don't get all the children now, then
         # once we've stepped we won't be able to get them?
 
         for idx in range(0, num_in_children):
             in_child = in_value.GetChildAtIndex(idx)
             in_child_str = in_child.GetValue()
 
         thread.StepOut()
 
-        self.assertTrue(self.process.GetState() == lldb.eStateStopped)
-        self.assertTrue(thread.GetStopReason() == lldb.eStopReasonPlanComplete)
+        self.assertEquals(self.process.GetState(), lldb.eStateStopped)
+        self.assertEquals(thread.GetStopReason(), lldb.eStopReasonPlanComplete)
 
         # Assuming all these functions step out to main.  Could figure out the caller dynamically
         # if that would add something to the test.
         frame = thread.GetFrameAtIndex(0)
         fun_name = frame.GetFunctionName()
-        self.assertTrue(fun_name == "main")
+        self.assertEquals(fun_name, "main")
 
         frame = thread.GetFrameAtIndex(0)
         ret_value = thread.GetStopReturnValue()
 
         self.assertTrue(ret_value.IsValid())
 
         num_ret_children = ret_value.GetNumChildren()
-        self.assertTrue(num_in_children == num_ret_children)
+        self.assertEquals(num_in_children, num_ret_children)
         for idx in range(0, num_ret_children):
             in_child = in_value.GetChildAtIndex(idx)
             ret_child = ret_value.GetChildAtIndex(idx)
             in_child_str = in_child.GetValue()
             ret_child_str = ret_child.GetValue()
 
             self.assertEqual(in_child_str, ret_child_str)

lldb/test/API/functionalities/signal/TestSendSignal.py

def test_with_run_command(self):
 
         # Now signal the process, and make sure it stops:
         process.Signal(lldbutil.get_signal_number('SIGUSR1'))
 
         self.match_state(process_listener, lldb.eStateStopped)
 
         # Now make sure the thread was stopped with a SIGUSR1:
         threads = lldbutil.get_stopped_threads(process, lldb.eStopReasonSignal)
-        self.assertTrue(len(threads) == 1, "One thread stopped for a signal.")
+        self.assertEquals(len(threads), 1, "One thread stopped for a signal.")
         thread = threads[0]
 
         self.assertTrue(
             thread.GetStopReasonDataCount() >= 1,
             "There was data in the event.")
         self.assertTrue(
             thread.GetStopReasonDataAtIndex(0) == lldbutil.get_signal_number('SIGUSR1'),
             "The stop signal was SIGUSR1")
 
     def match_state(self, process_listener, expected_state):
         num_seconds = 5
         broadcaster = self.process().GetBroadcaster()
         event_type_mask = lldb.SBProcess.eBroadcastBitStateChanged
         event = lldb.SBEvent()
         got_event = process_listener.WaitForEventForBroadcasterWithType(
             num_seconds, broadcaster, event_type_mask, event)
         self.assertTrue(got_event, "Got an event")
         state = lldb.SBProcess.GetStateFromEvent(event)
-        self.assertTrue(state == expected_state,
+        self.assertEquals(state, expected_state,
                         "It was the %s state." %
                         lldb.SBDebugger_StateAsCString(expected_state))

lldb/test/API/functionalities/source-map/TestTargetSourceMap.py

def test_source_map(self):
         obj_path = self.getBuildArtifact("main.o")
         self.yaml2obj(yaml_path, obj_path)
 
         # Create a target with the object file we just created from YAML
         target = self.dbg.CreateTarget(obj_path)
 
         # Set a breakpoint before we remap source and verify that it fails
         bp = target.BreakpointCreateByLocation(src_path, 2)
-        self.assertTrue(bp.GetNumLocations() == 0,
+        self.assertEquals(bp.GetNumLocations(), 0,
                         "make sure no breakpoints were resolved without map")
         src_map_cmd = 'settings set target.source-map . "%s"' % (src_dir)
         self.dbg.HandleCommand(src_map_cmd)
 
         # Set a breakpoint after we remap source and verify that it succeeds
         bp = target.BreakpointCreateByLocation(src_path, 2)
-        self.assertTrue(bp.GetNumLocations() == 1,
+        self.assertEquals(bp.GetNumLocations(), 1,
                         "make sure breakpoint was resolved with map")
 
         # Now make sure that we can actually FIND the source file using this
         # remapping:
         retval = lldb.SBCommandReturnObject()
         self.dbg.GetCommandInterpreter().HandleCommand("source list -f main.c -l 2", retval)
         self.assertTrue(retval.Succeeded(), "source list didn't succeed.")
-        self.assertTrue(retval.GetOutput() != None, "We got no ouput from source list")
+        self.assertNotEqual(retval.GetOutput(), None, "We got no ouput from source list")
         self.assertTrue("return" in retval.GetOutput(), "We didn't find the source file...")
         

lldb/test/API/functionalities/step-avoids-no-debug/TestStepNoDebug.py

def get_to_starting_point(self):
         self.process = self.target.LaunchSimple(
             None, None, self.get_process_working_directory())
 
         self.assertTrue(self.process, PROCESS_IS_VALID)
 
         # Now finish, and make sure the return value is correct.
         threads = lldbutil.get_threads_stopped_at_breakpoint(
             self.process, inner_bkpt)
-        self.assertTrue(len(threads) == 1, "Stopped at inner breakpoint.")
+        self.assertEquals(len(threads), 1, "Stopped at inner breakpoint.")
         self.thread = threads[0]
 
     def do_step_out_past_nodebug(self):
         # The first step out takes us to the called_from_nodebug frame, just to make sure setting
         # step-out-avoid-nodebug doesn't change the behavior in frames with
         # debug info.
         self.thread.StepOut()
         self.hit_correct_line(

lldb/test/API/functionalities/tsan/thread_numbers/TestTsanThreadNumbers.py

def tsan_tests(self):
         data = json.loads(json_line)
         self.assertEqual(data["instrumentation_class"], "ThreadSanitizer")
         self.assertEqual(data["issue_type"], "data-race")
         self.assertEqual(len(data["mops"]), 2)
 
         self.assertEqual(data["mops"][0]["thread_id"], report_thread_id)
 
         other_thread_id = data["mops"][1]["thread_id"]
-        self.assertTrue(other_thread_id != report_thread_id)
+        self.assertNotEqual(other_thread_id, report_thread_id)
         other_thread = self.dbg.GetSelectedTarget(
         ).process.GetThreadByIndexID(other_thread_id)
         self.assertTrue(other_thread.IsValid())
 
         self.runCmd("thread select %d" % other_thread_id)
 
         self.expect(
             "thread backtrace",
             "The other thread should be stopped in f1 or f2",
             substrs=[
                 "a.out",
                 "main.c"])

lldb/test/API/functionalities/ubsan/basic/TestUbsanBasic.py

def ubsan_tests(self):
             frame = thread.GetFrameAtIndex(i)
             if frame.GetLineEntry().GetFileSpec().GetFilename() == "main.c":
                 if frame.GetLineEntry().GetLine() == self.line_align:
                     found = True
         self.assertTrue(found)
 
         backtraces = thread.GetStopReasonExtendedBacktraces(
             lldb.eInstrumentationRuntimeTypeUndefinedBehaviorSanitizer)
-        self.assertTrue(backtraces.GetSize() == 1)
+        self.assertEquals(backtraces.GetSize(), 1)
 
         self.expect(
             "thread info -s",
             "The extended stop info should contain the UBSan provided fields",
             substrs=[
                 "col",
                 "description",
                 "filename",

lldb/test/API/functionalities/value_md5_crash/TestValueMD5Crash.py

def test_with_run_command(self):
                     substrs=['stopped',
                              'stop reason = breakpoint'])
 
         value = self.frame().FindVariable("a")
         value.SetPreferDynamicValue(lldb.eDynamicCanRunTarget)
 
         v = value.GetValue()
         type_name = value.GetTypeName()
-        self.assertTrue(type_name == "B *", "a is a B*")
+        self.assertEquals(type_name, "B *", "a is a B*")
 
         self.runCmd("next")
         self.runCmd("process kill")
 
         # now the process is dead, and value needs updating
         v = value.GetValue()
 
         # if we are here, instead of crashed, the test succeeded

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

class TestVarPath(TestBase):
 
     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.assertTrue(v.GetType().GetName() == var_typename, 
+        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.assertTrue(v.GetValue() == str(x_value), "Make sure '%s' has a value of %i" % (valid_x_path, x_value))
-        self.assertTrue(v.GetType().GetName() == "int", "Make sure '%s' has type 'int'" % (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.assertTrue(v.GetValue() == str(y_value), "Make sure '%s' has a value of %i" % (valid_y_path, y_value))
-        self.assertTrue(v.GetType().GetName() == "int", "Make sure '%s' has type 'int'" % (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):
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(

lldb/test/API/lang/c/array_types/TestArrayTypes.py

def test_and_python_api(self):
         self.expect(
             var,
             "Variable for 'strings' looks good with correct name",
             exe=False,
             substrs=[
                 "%s" %
                 variable.GetName()])
         self.DebugSBValue(variable)
-        self.assertTrue(variable.GetNumChildren() == 4,
+        self.assertEquals(variable.GetNumChildren(), 4,
                         "Variable 'strings' should have 4 children")
         byte_size = variable.GetByteSize()
         self.assertTrue(byte_size >= 4*4 and byte_size <= 1024)
 
         child3 = variable.GetChildAtIndex(3)
         self.DebugSBValue(child3)
-        self.assertTrue(child3.GetSummary() == '"Guten Tag"',
+        self.assertEquals(child3.GetSummary(), '"Guten Tag"',
                         'strings[3] == "Guten Tag"')
 
         # Lookup the "char_16" char array variable.
         variable = frame.FindVariable("char_16")
         self.DebugSBValue(variable)
-        self.assertTrue(variable.GetNumChildren() == 16,
+        self.assertEquals(variable.GetNumChildren(), 16,
                         "Variable 'char_16' should have 16 children")
 
         # Lookup the "ushort_matrix" ushort[] array variable.
         # Notice the pattern of int(child0_2.GetValue(), 0).  We pass a
         # base of 0 so that the proper radix is determined based on the contents
         # of the string.  Same applies to long().
         variable = frame.FindVariable("ushort_matrix")
         self.DebugSBValue(variable)
-        self.assertTrue(variable.GetNumChildren() == 2,
+        self.assertEquals(variable.GetNumChildren(), 2,
                         "Variable 'ushort_matrix' should have 2 children")
         child0 = variable.GetChildAtIndex(0)
         self.DebugSBValue(child0)
-        self.assertTrue(child0.GetNumChildren() == 3,
+        self.assertEquals(child0.GetNumChildren(), 3,
                         "Variable 'ushort_matrix[0]' should have 3 children")
         child0_2 = child0.GetChildAtIndex(2)
         self.DebugSBValue(child0_2)
-        self.assertTrue(int(child0_2.GetValue(), 0) == 3,
+        self.assertEquals(int(child0_2.GetValue(), 0), 3,
                         "ushort_matrix[0][2] == 3")
 
         # Lookup the "long_6" char array variable.
         variable = frame.FindVariable("long_6")
         self.DebugSBValue(variable)
-        self.assertTrue(variable.GetNumChildren() == 6,
+        self.assertEquals(variable.GetNumChildren(), 6,
                         "Variable 'long_6' should have 6 children")
         child5 = variable.GetChildAtIndex(5)
         self.DebugSBValue(child5)
-        self.assertTrue(int(child5.GetValue(), 0) == 6,
+        self.assertEquals(int(child5.GetValue(), 0), 6,
                         "long_6[5] == 6")
 
         # Last, check that "long_6" has a value type of eValueTypeVariableLocal
         # and "argc" has eValueTypeVariableArgument.
         from lldbsuite.test.lldbutil import value_type_to_str
         self.assertTrue(
             variable.GetValueType() == lldb.eValueTypeVariableLocal,
             "Variable 'long_6' should have '%s' value type." %
             value_type_to_str(
                 lldb.eValueTypeVariableLocal))
         argc = frame.FindVariable("argc")
         self.DebugSBValue(argc)
-        self.assertTrue(argc.GetValueType() == lldb.eValueTypeVariableArgument,
+        self.assertEquals(argc.GetValueType(), lldb.eValueTypeVariableArgument,
                         "Variable 'argc' should have '%s' value type." %
                         value_type_to_str(lldb.eValueTypeVariableArgument))

lldb/test/API/lang/cpp/dynamic-value/TestDynamicValue.py

def test_get_dynamic_vals(self):
             'pass-to-base.cpp', self.main_second_call_line)
         self.assertTrue(second_call_bpt,
                         VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at the entry point.
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
 
-        self.assertTrue(process.GetState() == lldb.eStateStopped,
+        self.assertEquals(process.GetState(), lldb.eStateStopped,
                         PROCESS_STOPPED)
 
         threads = lldbutil.get_threads_stopped_at_breakpoint(
             process, first_call_bpt)
-        self.assertTrue(len(threads) == 1)
+        self.assertEquals(len(threads), 1)
         thread = threads[0]
 
         frame = thread.GetFrameAtIndex(0)
 
         # Now find the dynamic addresses of myB and otherB so we can compare them
         # with the dynamic values we get in doSomething:
 
         use_dynamic = lldb.eDynamicCanRunTarget
         no_dynamic = lldb.eNoDynamicValues
 
         myB = frame.FindVariable('myB', no_dynamic)
         self.assertTrue(myB)
         myB_loc = int(myB.GetLocation(), 16)
 
         otherB = frame.FindVariable('otherB', no_dynamic)
         self.assertTrue(otherB)
         otherB_loc = int(otherB.GetLocation(), 16)
 
         # Okay now run to doSomething:
 
         threads = lldbutil.continue_to_breakpoint(process, do_something_bpt)
-        self.assertTrue(len(threads) == 1)
+        self.assertEquals(len(threads), 1)
         thread = threads[0]
 
         frame = thread.GetFrameAtIndex(0)
 
         # Get "this" using FindVariable:
 
         this_static = frame.FindVariable('this', no_dynamic)
         this_dynamic = frame.FindVariable('this', use_dynamic)
def test_get_dynamic_vals(self):
         anotherA_static = frame.FindVariable('anotherA', False)
         self.assertTrue(anotherA_static)
         anotherA_static_addr = int(anotherA_static.GetValue(), 16)
 
         anotherA_dynamic = frame.FindVariable('anotherA', True)
         self.assertTrue(anotherA_dynamic)
         anotherA_dynamic_addr = int(anotherA_dynamic.GetValue(), 16)
         anotherA_dynamic_typename = anotherA_dynamic.GetTypeName()
-        self.assertTrue(anotherA_dynamic_typename.find('B') != -1)
+        self.assertNotEqual(anotherA_dynamic_typename.find('B'), -1)
 
         self.assertTrue(anotherA_dynamic_addr < anotherA_static_addr)
 
         anotherA_m_b_value_dynamic = anotherA_dynamic.GetChildMemberWithName(
             'm_b_value', True)
         self.assertTrue(anotherA_m_b_value_dynamic)
         anotherA_m_b_val = int(anotherA_m_b_value_dynamic.GetValue(), 10)
-        self.assertTrue(anotherA_m_b_val == 300)
+        self.assertEquals(anotherA_m_b_val, 300)
 
         anotherA_m_b_value_static = anotherA_static.GetChildMemberWithName(
             'm_b_value', True)
         self.assertFalse(anotherA_m_b_value_static)
 
         # Okay, now continue again, and when we hit the second breakpoint in
         # main
 
         threads = lldbutil.continue_to_breakpoint(process, second_call_bpt)
-        self.assertTrue(len(threads) == 1)
+        self.assertEquals(len(threads), 1)
         thread = threads[0]
 
         frame = thread.GetFrameAtIndex(0)
         reallyA_value = frame.FindVariable('reallyA', False)
         self.assertTrue(reallyA_value)
         reallyA_loc = int(reallyA_value.GetLocation(), 16)
 
         # Finally continue to doSomething again, and make sure we get the right value for anotherA,
         # which this time around is just an "A".
 
         threads = lldbutil.continue_to_breakpoint(process, do_something_bpt)
-        self.assertTrue(len(threads) == 1)
+        self.assertEquals(len(threads), 1)
         thread = threads[0]
 
         frame = thread.GetFrameAtIndex(0)
         anotherA_value = frame.FindVariable('anotherA', True)
         self.assertTrue(anotherA_value)
         anotherA_loc = int(anotherA_value.GetValue(), 16)
-        self.assertTrue(anotherA_loc == reallyA_loc)
-        self.assertTrue(anotherA_value.GetTypeName().find('B') == -1)
+        self.assertEquals(anotherA_loc, reallyA_loc)
+        self.assertEquals(anotherA_value.GetTypeName().find('B'), -1)
 
     def examine_value_object_of_this_ptr(
             self, this_static, this_dynamic, dynamic_location):
         # Get "this" as its static value
         self.assertTrue(this_static)
         this_static_loc = int(this_static.GetValue(), 16)
 
         # Get "this" as its dynamic value
 
         self.assertTrue(this_dynamic)
         this_dynamic_typename = this_dynamic.GetTypeName()
-        self.assertTrue(this_dynamic_typename.find('B') != -1)
+        self.assertNotEqual(this_dynamic_typename.find('B'), -1)
         this_dynamic_loc = int(this_dynamic.GetValue(), 16)
 
         # Make sure we got the right address for "this"
 
-        self.assertTrue(this_dynamic_loc == dynamic_location)
+        self.assertEquals(this_dynamic_loc, dynamic_location)
 
         # And that the static address is greater than the dynamic one
 
         self.assertTrue(this_static_loc > this_dynamic_loc)
 
         # Now read m_b_value which is only in the dynamic value:
 
         use_dynamic = lldb.eDynamicCanRunTarget
         no_dynamic = lldb.eNoDynamicValues
 
         this_dynamic_m_b_value = this_dynamic.GetChildMemberWithName(
             'm_b_value', use_dynamic)
         self.assertTrue(this_dynamic_m_b_value)
 
         m_b_value = int(this_dynamic_m_b_value.GetValue(), 0)
-        self.assertTrue(m_b_value == 10)
+        self.assertEquals(m_b_value, 10)
 
         # Make sure it is not in the static version
 
         this_static_m_b_value = this_static.GetChildMemberWithName(
             'm_b_value', no_dynamic)
         self.assertFalse(this_static_m_b_value)
 
         # Okay, now let's make sure that we can get the dynamic type of a child

lldb/test/API/lang/cpp/exceptions/TestCPPExceptionBreakpoints.py

def test(self):
         # Okay we hit our exception throw breakpoint, now make sure we get our catch breakpoint.
         # One potential complication is that we might hit a couple of the exception breakpoints in getting out of the throw.
         # so loop till we don't see the throws function on the stack.  We should stop one more time for our exception breakpoint
         # and that should be the catch...
 
         while frame_functions.count("throws_exception_on_even(int)") == 1:
             stopped_threads = lldbutil.continue_to_breakpoint(
                 process, exception_bkpt)
-            self.assertTrue(len(stopped_threads) == 1)
+            self.assertEquals(len(stopped_threads), 1)
 
             thread = stopped_threads[0]
             frame_functions = lldbutil.get_function_names(thread)
 
         self.assertTrue(
             frame_functions.count("throws_exception_on_even(int)") == 0,
             "At catch our throw function is off the stack")
         self.assertTrue(
             frame_functions.count("intervening_function(int)") == 0,
             "At catch our intervening function is off the stack")
         self.assertTrue(
             frame_functions.count("catches_exception(int)") == 1,
             "At catch our catch function is on the stack")

lldb/test/API/lang/cpp/global_variables/TestCPPGlobalVariables.py

def test(self):
                     substrs=['42'])
         self.expect("target variable abc::g_file_global_int", VARIABLES_DISPLAYED_CORRECTLY,
                     substrs=['42'])
         self.expect("target variable xyz::g_file_global_int", VARIABLES_DISPLAYED_CORRECTLY,
                     error=True, substrs=['can\'t find global variable'])
 
         # Check that we can access g_file_global_int by its mangled name
         addr = target.EvaluateExpression("&abc::g_file_global_int").GetValueAsUnsigned()
-        self.assertTrue(addr != 0)
+        self.assertNotEqual(addr, 0)
         mangled = lldb.SBAddress(addr, target).GetSymbol().GetMangledName()
-        self.assertTrue(mangled != None)
+        self.assertNotEqual(mangled, None)
         gv = target.FindFirstGlobalVariable(mangled)
         self.assertTrue(gv.IsValid())
         self.assertEqual(gv.GetName(), "abc::g_file_global_int")
         self.assertEqual(gv.GetValueAsUnsigned(), 42)

lldb/test/API/lang/cpp/gmodules/TestWithModuleDebugging.py

def test_specialized_typedef_from_pch(self):
             VALID_BREAKPOINT)
 
         # Launch the process
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
         self.assertTrue(process.IsValid(), PROCESS_IS_VALID)
 
         # Get the thread of the process
-        self.assertTrue(process.GetState() == lldb.eStateStopped)
+        self.assertEquals(process.GetState(), lldb.eStateStopped)
         thread = lldbutil.get_stopped_thread(
             process, lldb.eStopReasonBreakpoint)
         self.assertTrue(
             thread.IsValid(),
             "There should be a thread stopped due to breakpoint condition")
 
         # Get frame for current thread
         frame = thread.frames[0]

lldb/test/API/lang/cpp/stl/TestSTL.py

def test_SBType_template_aspects(self):
         self.assertTrue(breakpoint, VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at entry point.
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
         self.assertTrue(process, PROCESS_IS_VALID)
 
         # Get Frame #0.
-        self.assertTrue(process.GetState() == lldb.eStateStopped)
+        self.assertEquals(process.GetState(), lldb.eStateStopped)
         thread = lldbutil.get_stopped_thread(
             process, lldb.eStopReasonBreakpoint)
         self.assertTrue(
             thread.IsValid(),
             "There should be a thread stopped due to breakpoint condition")
         frame0 = thread.GetFrameAtIndex(0)
 
         # Get the type for variable 'associative_array'.

lldb/test/API/lang/cpp/template/TestTemplateArgs.py

class TemplateArgsTestCase(TestBase):
 
     def test_integer_args(self):
         frame = self.prepareProcess()
 
         testpos = frame.FindVariable('testpos')
         self.assertTrue(
             testpos.IsValid(),
             'make sure we find a local variabble named "testpos"')
-        self.assertTrue(testpos.GetType().GetName() == 'TestObj<1>')
+        self.assertEquals(testpos.GetType().GetName(), 'TestObj<1>')
 
         expr_result = frame.EvaluateExpression("testpos.getArg()")
         self.assertTrue(
             expr_result.IsValid(),
             'got a valid expression result from expression "testpos.getArg()"')
-        self.assertTrue(expr_result.GetValue() == "1", "testpos.getArg() == 1")
+        self.assertEquals(expr_result.GetValue(), "1", "testpos.getArg() == 1")
         self.assertTrue(
             expr_result.GetType().GetName() == "int",
             'expr_result.GetType().GetName() == "int"')
 
         testneg = frame.FindVariable('testneg')
         self.assertTrue(
             testneg.IsValid(),
             'make sure we find a local variabble named "testneg"')
-        self.assertTrue(testneg.GetType().GetName() == 'TestObj<-1>')
+        self.assertEquals(testneg.GetType().GetName(), 'TestObj<-1>')
 
         expr_result = frame.EvaluateExpression("testneg.getArg()")
         self.assertTrue(
             expr_result.IsValid(),
             'got a valid expression result from expression "testneg.getArg()"')
         self.assertTrue(
             expr_result.GetValue() == "-1",
             "testneg.getArg() == -1")
         self.assertTrue(
             expr_result.GetType().GetName() == "int",
             'expr_result.GetType().GetName() == "int"')
 
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489")
     def test_template_template_args(self):
         frame = self.prepareProcess()
 
         c1 = frame.FindVariable('c1')
         self.assertTrue(
             c1.IsValid(),
             'make sure we find a local variabble named "c1"')
-        self.assertTrue(c1.GetType().GetName() == 'C<float, T1>')
+        self.assertEquals(c1.GetType().GetName(), 'C<float, T1>')
         f1 = c1.GetChildMemberWithName("V").GetChildAtIndex(0).GetChildMemberWithName("f")
-        self.assertTrue(f1.GetType().GetName() == 'float')
-        self.assertTrue(f1.GetValue() == '1.5')
+        self.assertEquals(f1.GetType().GetName(), 'float')
+        self.assertEquals(f1.GetValue(), '1.5')
 
         c2 = frame.FindVariable('c2')
         self.assertTrue(
             c2.IsValid(),
             'make sure we find a local variabble named "c2"')
-        self.assertTrue(c2.GetType().GetName() == 'C<double, T1, T2>')
+        self.assertEquals(c2.GetType().GetName(), 'C<double, T1, T2>')
         f2 = c2.GetChildMemberWithName("V").GetChildAtIndex(0).GetChildMemberWithName("f")
-        self.assertTrue(f2.GetType().GetName() == 'double')
-        self.assertTrue(f2.GetValue() == '1.5')
+        self.assertEquals(f2.GetType().GetName(), 'double')
+        self.assertEquals(f2.GetValue(), '1.5')
         f3 = c2.GetChildMemberWithName("V").GetChildAtIndex(1).GetChildMemberWithName("f")
-        self.assertTrue(f3.GetType().GetName() == 'double')
-        self.assertTrue(f3.GetValue() == '2.5')
+        self.assertEquals(f3.GetType().GetName(), 'double')
+        self.assertEquals(f3.GetValue(), '2.5')
         f4 = c2.GetChildMemberWithName("V").GetChildAtIndex(1).GetChildMemberWithName("i")
-        self.assertTrue(f4.GetType().GetName() == 'int')
-        self.assertTrue(f4.GetValue() == '42')
+        self.assertEquals(f4.GetType().GetName(), 'int')
+        self.assertEquals(f4.GetValue(), '42')
 
     # Gcc does not generate the necessary DWARF attribute for enum template
     # parameters.
     @expectedFailureAll(bugnumber="llvm.org/pr28354", compiler="gcc")
     @skipIf(dwarf_version=['<', '4'])
     def test_enum_args(self):
         frame = self.prepareProcess()
 

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

def test_with_python_api(self):
             self.fail("Failed to stop at breakpoint 1.")
 
         thread = threads[0]
 
         dyn_value = g_obj_ptr.GetDynamicValue(lldb.eDynamicCanRunTarget)
         self.assertTrue(
             dyn_value.GetError().Success(),
             "Dynamic value is valid")
-        self.assertTrue(dyn_value.GetObjectDescription() == "Some NSString")
+        self.assertEquals(dyn_value.GetObjectDescription(), "Some NSString")

lldb/test/API/lang/objc/ivar-IMP/TestObjCiVarIMP.py

def test_imp_ivar_type(self):
         # Set up our breakpoint
 
         bkpt = lldbutil.run_break_set_by_source_regexp(self, "break here")
 
         # Now launch the process, and do not stop at the entry point.
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
 
-        self.assertTrue(process.GetState() == lldb.eStateStopped,
+        self.assertEquals(process.GetState(), lldb.eStateStopped,
                         PROCESS_STOPPED)
 
         self.expect(
             'frame variable --ptr-depth=1 --show-types -d run -- object',
             substrs=[
                 '(MyClass *) object = 0x',
                 '(void *) myImp = 0x'])
         self.expect(
             'disassemble --start-address `((MyClass*)object)->myImp`',
             substrs=['-[MyClass init]'])

lldb/test/API/lang/objc/objc-baseclass-sbtype/TestObjCBaseClassSBType.py

def test_get_baseclass(self):
         self.assertTrue(target, VALID_TARGET)
 
         # Set up our breakpoints:
 
         target.BreakpointCreateByLocation('main.m', self.line)
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
 
-        self.assertTrue(process.GetState() == lldb.eStateStopped,
+        self.assertEquals(process.GetState(), lldb.eStateStopped,
                         PROCESS_STOPPED)
 
         var = self.frame().FindVariable("foo")
         var_ptr_type = var.GetType()
         var_pte_type = var_ptr_type.GetPointeeType()
         self.assertTrue(
             var_ptr_type.GetNumberOfDirectBaseClasses() == 1,
             "Foo * has one base class")
         self.assertTrue(
             var_pte_type.GetNumberOfDirectBaseClasses() == 1,
             "Foo has one base class")
 
         self.assertTrue(var_ptr_type.GetDirectBaseClassAtIndex(
             0).IsValid(), "Foo * has a valid base class")
         self.assertTrue(var_pte_type.GetDirectBaseClassAtIndex(
             0).IsValid(), "Foo * has a valid base class")
 
-        self.assertTrue(var_ptr_type.GetDirectBaseClassAtIndex(0).GetName() == var_pte_type.GetDirectBaseClassAtIndex(
+        self.assertEquals(var_ptr_type.GetDirectBaseClassAtIndex(0).GetName(), var_pte_type.GetDirectBaseClassAtIndex(
             0).GetName(), "Foo and its pointer type don't agree on their base class")

lldb/test/API/lang/objc/objc-builtin-types/TestObjCBuiltinTypes.py

def test_with_python_api(self):
 
         # The stop reason of the thread should be breakpoint.
         thread_list = lldbutil.get_threads_stopped_at_breakpoint(process, bpt)
 
         # Make sure we stopped at the first breakpoint.
         self.assertTrue(
             len(thread_list) != 0,
             "No thread stopped at our breakpoint.")
-        self.assertTrue(len(thread_list) == 1,
+        self.assertEquals(len(thread_list), 1,
                         "More than one thread stopped at our breakpoint.")
 
         # Now make sure we can call a function in the class method we've
         # stopped in.
         frame = thread_list[0].GetFrameAtIndex(0)
         self.assertTrue(frame, "Got a valid frame 0 frame.")
 
         self.expect("expr (foo)", patterns=["\(ns::id\) \$.* = 0"])
 
         self.expect("expr id my_id = 0; my_id", patterns=["\(id\) \$.* = nil"])

lldb/test/API/lang/objc/objc-dynamic-value/TestObjCDynamicValue.py

def test_get_objc_dynamic_vals(self):
         self.assertTrue(main_before_setProperty_bkpt and
                         main_before_setProperty_bkpt.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at the entry point.
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
 
-        self.assertTrue(process.GetState() == lldb.eStateStopped,
+        self.assertEquals(process.GetState(), lldb.eStateStopped,
                         PROCESS_STOPPED)
 
         threads = lldbutil.get_threads_stopped_at_breakpoint(
             process, main_before_setProperty_bkpt)
-        self.assertTrue(len(threads) == 1)
+        self.assertEquals(len(threads), 1)
         thread = threads[0]
 
         #
         #  At this point, myObserver has a Source pointer that is actually a KVO swizzled SourceDerived
         #  make sure we can get that properly:
 
         frame = thread.GetFrameAtIndex(0)
         myObserver = frame.FindVariable(
def test_get_objc_dynamic_vals(self):
         # This test is not entirely related to the main thrust of this test case, but since we're here,
         # try stepping into setProperty, and make sure we get into the version
         # in Source:
 
         thread.StepInto()
 
         threads = lldbutil.get_stopped_threads(
             process, lldb.eStopReasonPlanComplete)
-        self.assertTrue(len(threads) == 1)
+        self.assertEquals(len(threads), 1)
         line_entry = threads[0].GetFrameAtIndex(0).GetLineEntry()
 
         self.assertEqual(line_entry.GetLine(), self.set_property_line)
         self.assertEqual(
             line_entry.GetFileSpec().GetFilename(),
             self.source_name)
 
         # Okay, back to the main business.  Continue to the handle_SourceBase
         # and make sure we get the correct dynamic value.
 
         threads = lldbutil.continue_to_breakpoint(
             process, handle_SourceBase_bkpt)
-        self.assertTrue(len(threads) == 1)
+        self.assertEquals(len(threads), 1)
         thread = threads[0]
 
         frame = thread.GetFrameAtIndex(0)
 
         # Get "object" using FindVariable:
 
         noDynamic = lldb.eNoDynamicValues
         useDynamic = lldb.eDynamicCanRunTarget
def test_get_objc_dynamic_vals(self):
 
         # Continue again to the handle_SourceBase and make sure we get the correct dynamic value.
         # This one looks exactly the same, but in fact this is an "un-KVO'ed" version of SourceBase, so
         # its isa pointer points to SourceBase not NSKVOSourceBase or
         # whatever...
 
         threads = lldbutil.continue_to_breakpoint(
             process, handle_SourceBase_bkpt)
-        self.assertTrue(len(threads) == 1)
+        self.assertEquals(len(threads), 1)
         thread = threads[0]
 
         frame = thread.GetFrameAtIndex(0)
 
         # Get "object" using FindVariable:
 
         object_static = frame.FindVariable('object', noDynamic)
         object_dynamic = frame.FindVariable('object', useDynamic)
 
         # Delete this object to make sure that this doesn't cause havoc with
         # the dynamic object that depends on it.
         del (object_static)
 
         self.examine_SourceDerived_ptr(object_dynamic)
 
     def examine_SourceDerived_ptr(self, object):
         self.assertTrue(object)
-        self.assertTrue(object.GetTypeName().find('SourceDerived') != -1)
+        self.assertNotEqual(object.GetTypeName().find('SourceDerived'), -1)
         derivedValue = object.GetChildMemberWithName('_derivedValue')
         self.assertTrue(derivedValue)
-        self.assertTrue(int(derivedValue.GetValue(), 0) == 30)
+        self.assertEquals(int(derivedValue.GetValue(), 0), 30)

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

def test_with_python_api(self):
             None, None, self.get_process_working_directory())
         self.assertTrue(process, "Created a process.")
         self.assertTrue(
             process.GetState() == lldb.eStateStopped,
             "Stopped it too.")
 
         thread_list = lldbutil.get_threads_stopped_at_breakpoint(
             process, breakpoint)
-        self.assertTrue(len(thread_list) == 1)
+        self.assertEquals(len(thread_list), 1)
         thread = thread_list[0]
 
         frame = thread.GetFrameAtIndex(0)
         self.assertTrue(frame, "frame 0 is valid")
 
         mine = thread.GetFrameAtIndex(0).FindVariable("mine")
         self.assertTrue(mine, "Found local variable mine.")
 
         # Test the value object value for BaseClass->_backed_int
 
         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.assertTrue(backed_value == 1111)
+        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.assertTrue(derived_backed_value == 3333)
+        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.assertTrue(flag2_value == 7)
+        self.assertEquals(flag2_value, 7)

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

def test_with_python_api(self):
             None, None, self.get_process_working_directory())
         self.assertTrue(process, "Created a process.")
         self.assertTrue(
             process.GetState() == lldb.eStateStopped,
             "Stopped it too.")
 
         thread_list = lldbutil.get_threads_stopped_at_breakpoint(
             process, breakpoint)
-        self.assertTrue(len(thread_list) == 1)
+        self.assertEquals(len(thread_list), 1)
         thread = thread_list[0]
 
         frame = thread.GetFrameAtIndex(0)
         self.assertTrue(frame, "frame 0 is valid")
 
         # 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.assertTrue(ivar_value == 3)
+        self.assertEquals(ivar_value, 3)

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

def test_objc_properties(self):
         self.assertTrue(main_bkpt and
                         main_bkpt.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at the entry point.
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
 
-        self.assertTrue(process.GetState() == lldb.eStateStopped,
+        self.assertEquals(process.GetState(), lldb.eStateStopped,
                         PROCESS_STOPPED)
 
         threads = lldbutil.get_threads_stopped_at_breakpoint(
             process, main_bkpt)
-        self.assertTrue(len(threads) == 1)
+        self.assertEquals(len(threads), 1)
         thread = threads[0]
         frame = thread.GetFrameAtIndex(0)
 
         mine = frame.FindVariable("mine")
         self.assertTrue(mine.IsValid())
         access_count = mine.GetChildMemberWithName("_access_count")
         self.assertTrue(access_count.IsValid())
         start_access_count = access_count.GetValueAsUnsigned(123456)
-        self.assertTrue(start_access_count != 123456)
+        self.assertNotEqual(start_access_count, 123456)
 
         #
         # 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())
         nonexistant_int = nonexistant_value.GetValueAsUnsigned(123456)
-        self.assertTrue(nonexistant_int == 6)
+        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.assertTrue(new_access_count - start_access_count == 1)
+        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())
 
         # Calling the setter function would up the access count, so make sure
         # that happened.
 
         new_access_count = access_count.GetValueAsUnsigned(123456)
-        self.assertTrue(new_access_count - start_access_count == 1)
+        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)
def test_objc_properties(self):
         unbacked_value = frame.EvaluateExpression("mine.unbackedInt", False)
         unbacked_error = unbacked_value.GetError()
         self.assertTrue(unbacked_error.Success())
 
         idWithProtocol_value = frame.EvaluateExpression(
             "mine.idWithProtocol", False)
         idWithProtocol_error = idWithProtocol_value.GetError()
         self.assertTrue(idWithProtocol_error.Success())
-        self.assertTrue(idWithProtocol_value.GetTypeName() == "id")
+        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.assertTrue(value.GetValueAsUnsigned(11111) == 123)
+        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())
 
         # Verify that setter above actually worked
         value = frame.EvaluateExpression("BaseClass.classInt", False)
         self.assertTrue(value.GetError().Success())
-        self.assertTrue(value.GetValueAsUnsigned(11111) == 234)
+        self.assertEquals(value.GetValueAsUnsigned(11111), 234)

lldb/test/API/lang/objc/objc-static-method-stripped/TestObjCStaticMethodStripped.py

def test_with_python_api(self):
 
         # The stop reason of the thread should be breakpoint.
         thread_list = lldbutil.get_threads_stopped_at_breakpoint(process, bpt)
 
         # Make sure we stopped at the first breakpoint.
         self.assertTrue(
             len(thread_list) != 0,
             "No thread stopped at our breakpoint.")
-        self.assertTrue(len(thread_list) == 1,
+        self.assertEquals(len(thread_list), 1,
                         "More than one thread stopped at our breakpoint.")
 
         # Now make sure we can call a function in the static method we've
         # stopped in.
         frame = thread_list[0].GetFrameAtIndex(0)
         self.assertTrue(frame, "Got a valid frame 0 frame.")
 
         cmd_value = frame.EvaluateExpression("(char *) sel_getName (_cmd)")

lldb/test/API/lang/objc/objc-static-method/TestObjCStaticMethod.py

def test_with_python_api(self):
 
         # The stop reason of the thread should be breakpoint.
         thread_list = lldbutil.get_threads_stopped_at_breakpoint(process, bpt)
 
         # Make sure we stopped at the first breakpoint.
         self.assertTrue(
             len(thread_list) != 0,
             "No thread stopped at our breakpoint.")
-        self.assertTrue(len(thread_list) == 1,
+        self.assertEquals(len(thread_list), 1,
                         "More than one thread stopped at our breakpoint.")
 
         # Now make sure we can call a function in the static method we've
         # stopped in.
         frame = thread_list[0].GetFrameAtIndex(0)
         self.assertTrue(frame, "Got a valid frame 0 frame.")
 
         cmd_value = frame.EvaluateExpression("(char *) sel_getName (_cmd)")

lldb/test/API/lang/objc/objc-struct-argument/TestObjCStructArgument.py

def test_with_python_api(self):
 
         # The stop reason of the thread should be breakpoint.
         thread_list = lldbutil.get_threads_stopped_at_breakpoint(process, bpt)
 
         # Make sure we stopped at the first breakpoint.
         self.assertTrue(
             len(thread_list) != 0,
             "No thread stopped at our breakpoint.")
-        self.assertTrue(len(thread_list) == 1,
+        self.assertEquals(len(thread_list), 1,
                         "More than one thread stopped at our breakpoint.")
 
         frame = thread_list[0].GetFrameAtIndex(0)
         self.assertTrue(frame, "Got a valid frame 0 frame.")
 
         self.expect("p [summer sumThings:tts]", substrs=['9'])
 
         self.expect(
             "po [NSValue valueWithRect:rect]",
             substrs=['NSRect: {{0, 0}, {10, 20}}'])
 
         # Now make sure we can call a method that returns a struct without
         # crashing.
         cmd_value = frame.EvaluateExpression("[provider getRange]")
         self.assertTrue(cmd_value.IsValid())

lldb/test/API/lang/objc/objc-struct-return/TestObjCStructReturn.py

def test_with_python_api(self):
 
         # The stop reason of the thread should be breakpoint.
         thread_list = lldbutil.get_threads_stopped_at_breakpoint(process, bpt)
 
         # Make sure we stopped at the first breakpoint.
         self.assertTrue(
             len(thread_list) != 0,
             "No thread stopped at our breakpoint.")
-        self.assertTrue(len(thread_list) == 1,
+        self.assertEquals(len(thread_list), 1,
                         "More than one thread stopped at our breakpoint.")
 
         frame = thread_list[0].GetFrameAtIndex(0)
         self.assertTrue(frame, "Got a valid frame 0 frame.")
 
         # Now make sure we can call a method that returns a struct without
         # crashing.
         cmd_value = frame.EvaluateExpression("[provider getRange]")
         self.assertTrue(cmd_value.IsValid())

lldb/test/API/lang/objc/objc-super/TestObjCSuper.py

def test_with_python_api(self):
 
         # The stop reason of the thread should be breakpoint.
         thread_list = lldbutil.get_threads_stopped_at_breakpoint(process, bpt)
 
         # Make sure we stopped at the first breakpoint.
         self.assertTrue(
             len(thread_list) != 0,
             "No thread stopped at our breakpoint.")
-        self.assertTrue(len(thread_list) == 1,
+        self.assertEquals(len(thread_list), 1,
                         "More than one thread stopped at our breakpoint.")
 
         # Now make sure we can call a function in the class method we've
         # stopped in.
         frame = thread_list[0].GetFrameAtIndex(0)
         self.assertTrue(frame, "Got a valid frame 0 frame.")
 
         cmd_value = frame.EvaluateExpression("[self get]")
         self.assertTrue(cmd_value.IsValid())
-        self.assertTrue(cmd_value.GetValueAsUnsigned() == 2)
+        self.assertEquals(cmd_value.GetValueAsUnsigned(), 2)
 
         cmd_value = frame.EvaluateExpression("[super get]")
         self.assertTrue(cmd_value.IsValid())
-        self.assertTrue(cmd_value.GetValueAsUnsigned() == 1)
+        self.assertEquals(cmd_value.GetValueAsUnsigned(), 1)

lldb/test/API/linux/add-symbols/TestTargetSymbolsAddCommand.py

def test_target_symbols_add(self):
         main_bp = self.target.BreakpointCreateByName("main", "stripped.out")
         self.assertTrue(main_bp, VALID_BREAKPOINT)
 
         self.process = self.target.LaunchSimple(
             None, None, self.get_process_working_directory())
         self.assertTrue(self.process, PROCESS_IS_VALID)
 
         # The stop reason of the thread should be breakpoint.
-        self.assertTrue(self.process.GetState() == lldb.eStateStopped,
+        self.assertEquals(self.process.GetState(), lldb.eStateStopped,
                         STOPPED_DUE_TO_BREAKPOINT)
 
         exe_module = self.target.GetModuleAtIndex(0)
 
         # Check that symbols are not loaded and main.c is not know to be
         # the source file.
         self.expect("frame select", substrs=['main.c'], matching=False)
 
         # Tell LLDB that a.out has symbols for stripped.out
         self.runCmd("target symbols add -s %s %s" %
                     (exe, self.getBuildArtifact("a.out")))
 
         # Check that symbols are now loaded and main.c is in the output.
         self.expect("frame select", substrs=['main.c'])

lldb/test/API/linux/mix-dwo-and-regular-objects/TestMixedDwarfBinary.py

def test_mixed_dwarf(self):
         main_bp = self.target.BreakpointCreateByName("g", "a.out")
         self.assertTrue(main_bp, VALID_BREAKPOINT)
 
         self.process = self.target.LaunchSimple(
             None, None, self.get_process_working_directory())
         self.assertTrue(self.process, PROCESS_IS_VALID)
 
         # The stop reason of the thread should be breakpoint.
-        self.assertTrue(self.process.GetState() == lldb.eStateStopped,
+        self.assertEquals(self.process.GetState(), lldb.eStateStopped,
                         STOPPED_DUE_TO_BREAKPOINT)
 
         frame = self.process.GetThreadAtIndex(0).GetFrameAtIndex(0)
         x = frame.FindVariable("x")
         self.assertTrue(x.IsValid(), "x is not valid")
         y = frame.FindVariable("y")
         self.assertTrue(y.IsValid(), "y is not valid")
 

lldb/test/API/macosx/add-dsym/TestAddDsymMidExecutionCommand.py

def test_add_dsym_mid_execution(self):
         self.assertTrue(main_bp, VALID_BREAKPOINT)
 
         self.runCmd("settings set target.disable-aslr false")
         self.process = self.target.LaunchSimple(
             None, None, self.get_process_working_directory())
         self.assertTrue(self.process, PROCESS_IS_VALID)
 
         # The stop reason of the thread should be breakpoint.
-        self.assertTrue(self.process.GetState() == lldb.eStateStopped,
+        self.assertEquals(self.process.GetState(), lldb.eStateStopped,
                         STOPPED_DUE_TO_BREAKPOINT)
 
         self.runCmd("add-dsym " +
                     self.getBuildArtifact("hide.app/Contents/a.out.dSYM"))
 
         self.expect("frame select",
                     substrs=['a.out`main at main.c'])

lldb/test/API/macosx/find-app-in-bundle/TestFindAppInBundle.py

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

lldb/test/API/macosx/find-dsym/bundle-with-dot-in-filename/TestBundleWithDotInFilename.py

def test_attach_and_check_dsyms(self):
         self.runCmd(settings_str)
 
         self.runCmd("process attach -p " + str(popen.pid))
 
         target = self.dbg.GetSelectedTarget()
         self.assertTrue(target.IsValid(), 'Should have a valid Target after attaching to process')
 
         setup_complete = target.FindFirstGlobalVariable("setup_is_complete")
-        self.assertTrue(setup_complete.GetValueAsUnsigned() == 1, 'Check that inferior process has completed setup')
+        self.assertEquals(setup_complete.GetValueAsUnsigned(), 1, 'Check that inferior process has completed setup')
 
         # Find the bundle module, see if we found the dSYM too (they're both in "hide.app")
         i = 0
         while i < target.GetNumModules():
             mod = target.GetModuleAtIndex(i)
             if mod.GetFileSpec().GetFilename() == 'com.apple.sbd':
                 dsym_name = mod.GetSymbolFileSpec().GetFilename()
                 self.assertTrue (dsym_name == 'com.apple.sbd', "Check that we found the dSYM for the bundle that was loaded")
             i=i+1
         os.chdir(self.getSourceDir());
 
 if __name__ == '__main__':
     unittest.main()

lldb/test/API/macosx/find-dsym/deep-bundle/TestDeepBundle.py

def test_attach_and_check_dsyms(self):
         settings_str = "settings set target.exec-search-paths " + self.get_process_working_directory() + "/hide.app"
         self.runCmd(settings_str)
         self.runCmd("process attach -p " + str(popen.pid))
 
         target = self.dbg.GetSelectedTarget()
         self.assertTrue(target.IsValid(), 'Should have a valid Target after attaching to process')
 
         setup_complete = target.FindFirstGlobalVariable("setup_is_complete")
-        self.assertTrue(setup_complete.GetValueAsUnsigned() == 1, 'Check that inferior process has completed setup')
+        self.assertEquals(setup_complete.GetValueAsUnsigned(), 1, 'Check that inferior process has completed setup')
 
         # Find the bundle module, see if we found the dSYM too (they're both in "hide.app")
         i = 0
         found_module = False
         while i < target.GetNumModules():
             mod = target.GetModuleAtIndex(i)
             if mod.GetFileSpec().GetFilename() == 'MyFramework':
                 found_module = True
                 dsym_name = mod.GetSymbolFileSpec().GetFilename()
                 self.assertTrue (dsym_name == 'MyFramework', "Check that we found the dSYM for the bundle that was loaded")
             i=i+1
 
         self.assertTrue(found_module, "Check that we found the framework loaded in lldb's image list")
 
 if __name__ == '__main__':
     unittest.main()

lldb/test/API/macosx/thread-names/TestInterruptThreadNames.py

def test_with_python_api(self):
         error = lldb.SBError()
         self.dbg.SetAsync(True)
         process = target.Launch(launch_info, error)
         self.assertTrue(process, PROCESS_IS_VALID)
 
         listener = self.dbg.GetListener()
         broadcaster = process.GetBroadcaster()
         rc = broadcaster.AddListener(listener, lldb.SBProcess.eBroadcastBitStateChanged)
-        self.assertTrue(rc != 0, "Unable to add listener to process")
+        self.assertNotEqual(rc, 0, "Unable to add listener to process")
         self.assertTrue(self.wait_for_running(process, listener), "Check that process is up and running")
 
         inferior_set_up = self.wait_until_program_setup_complete(process, listener)
 
-        self.assertTrue(inferior_set_up.IsValid() and inferior_set_up.GetValueAsSigned() == 1, "Check that the program was able to create its threads within the allotted time")
+        # Check that the program was able to create its threads within the allotted time
+        self.assertTrue(inferior_set_up.IsValid())
+        self.assertEquals(inferior_set_up.GetValueAsSigned(), 1)
 
         self.check_number_of_threads(process)
 
         main_thread = lldb.SBThread()
         second_thread = lldb.SBThread()
         third_thread = lldb.SBThread()
         for idx in range(0, process.GetNumThreads()):
             t = process.GetThreadAtIndex(idx)

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

def test_process_attach_with_wrong_arch(self):
         # 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.assertTrue(len(threads) == 1)
+        self.assertEquals(len(threads), 1)
         thread = threads[0]
         self.assertTrue(
             thread.GetNumFrames() > 1,
             "We were able to backtrace.")

lldb/test/API/python_api/class_members/TestSBTypeClassMembers.py

def test(self):
         self.assertTrue(breakpoint, VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at entry point.
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
         self.assertTrue(process, PROCESS_IS_VALID)
 
         # Get Frame #0.
-        self.assertTrue(process.GetState() == lldb.eStateStopped)
+        self.assertEquals(process.GetState(), lldb.eStateStopped)
         thread = lldbutil.get_stopped_thread(
             process, lldb.eStopReasonBreakpoint)
         self.assertTrue(
             thread.IsValid(),
             "There should be a thread stopped due to breakpoint condition")
         frame0 = thread.GetFrameAtIndex(0)
 
         variable = frame0.FindVariable("d")

lldb/test/API/python_api/findvalue_duplist/TestSBFrameFindValue.py

def test_formatters_api(self):
             None, None, self.get_process_working_directory())
 
         self.assertTrue(process, PROCESS_IS_VALID)
 
         # Frame #0 should be at our breakpoint.
         threads = lldbutil.get_threads_stopped_at_breakpoint(
             process, breakpoint)
 
-        self.assertTrue(len(threads) == 1)
+        self.assertEquals(len(threads), 1)
         self.thread = threads[0]
         self.frame = self.thread.frames[0]
         self.assertTrue(self.frame, "Frame 0 is valid.")
 
         self.assertTrue(
             self.frame.GetVariables(
                 True,
                 True,

lldb/test/API/python_api/name_lookup/TestNameLookup.py

def test_target(self):
                     c_name_to_symbol[name] = symbol
 
         # Make sure each mangled name turns up exactly one match when looking up
         # functions by full name and using the mangled name as the name in the
         # lookup
         self.assertGreaterEqual(len(mangled_to_symbol), 6)
         for mangled in mangled_to_symbol.keys():
             symbol_contexts = target.FindFunctions(mangled, lldb.eFunctionNameTypeFull)
-            self.assertTrue(symbol_contexts.GetSize() == 1)
+            self.assertEquals(symbol_contexts.GetSize(), 1)
             for symbol_context in symbol_contexts:
                 self.assertTrue(symbol_context.GetFunction().IsValid())
                 self.assertTrue(symbol_context.GetSymbol().IsValid())
 
 

lldb/test/API/python_api/objc_type/TestObjCType.py

def test(self):
         self.assertTrue(breakpoint, VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at entry point.
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
         self.assertTrue(process, PROCESS_IS_VALID)
 
         # Get Frame #0.
-        self.assertTrue(process.GetState() == lldb.eStateStopped)
+        self.assertEquals(process.GetState(), lldb.eStateStopped)
         thread = lldbutil.get_stopped_thread(
             process, lldb.eStopReasonBreakpoint)
         self.assertTrue(
             thread.IsValid(),
             "There should be a thread stopped due to breakpoint condition")
 
         aBar = self.frame().FindVariable("aBar")
         aBarType = aBar.GetType()
         self.assertTrue(aBarType.IsValid(), "Bar should be a valid data type")
         self.assertTrue(
             aBarType.GetName() == "Bar *",
             "Bar has the right name")
 
         self.assertTrue(
             aBarType.GetNumberOfDirectBaseClasses() == 1,
             "Bar has a superclass")
         aFooType = aBarType.GetDirectBaseClassAtIndex(0)
 
         self.assertTrue(aFooType.IsValid(), "Foo should be a valid data type")
-        self.assertTrue(aFooType.GetName() == "Foo", "Foo has the right name")
+        self.assertEquals(aFooType.GetName(), "Foo", "Foo has the right name")
 
-        self.assertTrue(aBarType.GetNumberOfFields() == 1, "Bar has a field")
+        self.assertEquals(aBarType.GetNumberOfFields(), 1, "Bar has a field")
         aBarField = aBarType.GetFieldAtIndex(0)
 
         self.assertTrue(
             aBarField.GetName() == "_iVar",
             "The field has the right name")

lldb/test/API/python_api/sbvalue_persist/TestSBValuePersist.py

def test(self):
         self.assertTrue(bazPersist.IsValid(), "bazPersist is not valid")
 
         self.assertTrue(
             fooPersist.GetValueAsUnsigned(0) == 10,
             "fooPersist != 10")
         self.assertTrue(
             barPersist.GetPointeeData().sint32[0] == 4,
             "barPersist != 4")
-        self.assertTrue(bazPersist.GetSummary() == '"85"', "bazPersist != 85")
+        self.assertEquals(bazPersist.GetSummary(), '"85"', "bazPersist != 85")
 
         self.runCmd("continue")
 
         self.assertTrue(fooPersist.IsValid(), "fooPersist is not valid")
         self.assertTrue(barPersist.IsValid(), "barPersist is not valid")
         self.assertTrue(bazPersist.IsValid(), "bazPersist is not valid")
 
         self.assertTrue(
             fooPersist.GetValueAsUnsigned(0) == 10,
             "fooPersist != 10")
         self.assertTrue(
             barPersist.GetPointeeData().sint32[0] == 4,
             "barPersist != 4")
-        self.assertTrue(bazPersist.GetSummary() == '"85"', "bazPersist != 85")
+        self.assertEquals(bazPersist.GetSummary(), '"85"', "bazPersist != 85")
 
         self.expect("expr *(%s)" % (barPersist.GetName()), substrs=['= 4'])

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

def test_change_value(self):
         self.assertTrue(end_breakpoint, VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at entry point.
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
         self.assertTrue(process, PROCESS_IS_VALID)
 
         # Get Frame #0.
-        self.assertTrue(process.GetState() == lldb.eStateStopped)
+        self.assertEquals(process.GetState(), lldb.eStateStopped)
         thread = lldbutil.get_stopped_thread(
             process, lldb.eStopReasonBreakpoint)
         self.assertTrue(
             thread.IsValid(),
             "There should be a thread stopped due to breakpoint condition")
         frame0 = thread.GetFrameAtIndex(0)
         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.assertTrue(actual_value == 100, "Got the right 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.assertTrue(
             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")
 
         mine_second_value = mine_value.GetChildMemberWithName("second_val")
         self.assertTrue(
             mine_second_value.IsValid(),
             "Got second_val from mine")
         actual_value = mine_second_value.GetValueAsUnsigned(error, 0)
         self.assertTrue(
             error.Success(),
             "Got an unsigned value for second_val")
-        self.assertTrue(actual_value == 5555)
+        self.assertEquals(actual_value, 5555)
 
         result = mine_second_value.SetValueFromCString("98765")
         self.assertTrue(result, "Success setting mine.second_value.")
         actual_value = mine_second_value.GetValueAsSigned(error, 0)
         self.assertTrue(
             error.Success(),
             "Got a changed value from mine.second_val")
-        self.assertTrue(actual_value == 98765,
+        self.assertEquals(actual_value, 98765,
                         "Got the right changed value from mine.second_val")
 
         # Next do the same thing with the pointer version.
         ptr_value = frame0.FindVariable("ptr")
         self.assertTrue(ptr_value.IsValid(), "Got the SBValue for ptr")
 
         ptr_second_value = ptr_value.GetChildMemberWithName("second_val")
         self.assertTrue(ptr_second_value.IsValid(), "Got second_val from ptr")
         actual_value = ptr_second_value.GetValueAsUnsigned(error, 0)
         self.assertTrue(
             error.Success(),
             "Got an unsigned value for ptr->second_val")
-        self.assertTrue(actual_value == 6666)
+        self.assertEquals(actual_value, 6666)
 
         result = ptr_second_value.SetValueFromCString("98765")
         self.assertTrue(result, "Success setting ptr->second_value.")
         actual_value = ptr_second_value.GetValueAsSigned(error, 0)
         self.assertTrue(
             error.Success(),
             "Got a changed value from ptr->second_val")
-        self.assertTrue(actual_value == 98765,
+        self.assertEquals(actual_value, 98765,
                         "Got the right changed value from ptr->second_val")
 
         # gcc may set multiple locations for breakpoint
         breakpoint.SetEnabled(False)
 
         # Now continue, grab the stdout and make sure we changed the real
         # values as well...
         process.Continue()
 
-        self.assertTrue(process.GetState() == lldb.eStateStopped)
+        self.assertEquals(process.GetState(), lldb.eStateStopped)
         thread = lldbutil.get_stopped_thread(
             process, lldb.eStopReasonBreakpoint)
         self.assertTrue(
             thread.IsValid(),
             "There should be a thread stopped due to breakpoint condition")
 
         expected_value = "Val - 12345 Mine - 55, 98765, 55555555. Ptr - 66, 98765, 66666666"
         stdout = process.GetSTDOUT(1000)
def test_change_value(self):
             "Got the right changed value for sp.")
 
         # Boundary condition test the SBValue.CreateValueFromExpression() API.
         # LLDB should not crash!
         nosuchval = mine_value.CreateValueFromExpression(None, None)
 
         process.Continue()
 
-        self.assertTrue(process.GetState() == lldb.eStateStopped)
+        self.assertEquals(process.GetState(), lldb.eStateStopped)
         thread = lldbutil.get_stopped_thread(
             process, lldb.eStopReasonBreakpoint)
         self.assertTrue(
             thread is None,
             "We should not have managed to hit our second breakpoint with sp == 1")
 
         process.Kill()

lldb/test/API/python_api/value/empty_class/TestValueAPIEmptyClass.py

def test(self):
         self.assertTrue(breakpoint, VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at entry point.
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
         self.assertTrue(process, PROCESS_IS_VALID)
 
         # Get Frame #0.
-        self.assertTrue(process.GetState() == lldb.eStateStopped)
+        self.assertEquals(process.GetState(), lldb.eStateStopped)
         thread = lldbutil.get_stopped_thread(
             process, lldb.eStopReasonBreakpoint)
         self.assertTrue(
             thread.IsValid(),
             "There should be a thread stopped due to breakpoint condition")
         frame0 = thread.GetFrameAtIndex(0)
 
         # Verify that we can access to a frame variable with an empty class type

lldb/test/API/tools/lldb-server/TestGdbRemoteThreadsInStopReply.py

def gather_stop_reply_pcs(self, post_startup_log_lines, thread_count):
                 thread_count, ["threads", "thread-pcs"])
         if not results:
             return []
 
         threads_text = results["threads"]
         pcs_text = results["thread-pcs"]
         thread_ids = threads_text.split(",")
         pcs = pcs_text.split(",")
-        self.assertTrue(len(thread_ids) == len(pcs))
+        self.assertEquals(len(thread_ids), len(pcs))
 
         thread_pcs = dict()
         for i in range(0, len(pcs)):
             thread_pcs[int(thread_ids[i], 16)] = pcs[i]
 
         result = dict()
         result["thread_pcs"] = thread_pcs
         result["pc_register"] = results["pc_register"]

lldb/test/API/tools/lldb-server/register-reading/TestGdbRemoteGPacket.py

def run_test_g_packet(self):
         self.test_sequence.add_log_lines(
             ["read packet: $g#67",
              {"direction": "send", "regex": r"^\$(.+)#[0-9a-fA-F]{2}$",
               "capture": {1: "register_bank"}}],
             True)
         self.connect_to_debug_monitor()
         context = self.expect_gdbremote_sequence()
         register_bank = context.get("register_bank")
-        self.assertTrue(register_bank[0] != 'E')
+        self.assertNotEqual(register_bank[0], 'E')
 
         self.test_sequence.add_log_lines(
             ["read packet: $G" + register_bank + "#00",
              {"direction": "send", "regex": r"^\$(.+)#[0-9a-fA-F]{2}$",
               "capture": {1: "G_reply"}}],
             True)
         context = self.expect_gdbremote_sequence()
-        self.assertTrue(context.get("G_reply")[0] != 'E')
+        self.assertNotEqual(context.get("G_reply")[0], 'E')
 
     @skipIfOutOfTreeDebugserver
     @debugserver_test
     @skipIfDarwinEmbedded
     def test_g_packet_debugserver(self):
         self.init_debugserver_test()
         self.run_test_g_packet()
 
def g_returns_correct_data(self, with_suffix):
         self.test_sequence.add_log_lines(
             [g_request,
              {"direction": "send", "regex": r"^\$(.+)#[0-9a-fA-F]{2}$",
               "capture": {1: "register_bank"}}],
             True)
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
         reg_bank = context.get("register_bank")
-        self.assertTrue(reg_bank[0] != 'E')
+        self.assertNotEqual(reg_bank[0], 'E')
 
         byte_order = self.get_target_byte_order()
         get_reg_value = lambda reg_name : _extract_register_value(
             reg_infos[reg_name], reg_bank, byte_order)
 
         self.assertEqual(['0x0102030405060708'], get_reg_value('r8'))
         self.assertEqual(['0x1112131415161718'], get_reg_value('r9'))
         self.assertEqual(['0x2122232425262728'], get_reg_value('r10'))

lldb/test/API/tools/lldb-vscode/attach/TestVSCode_attach.py

def test_commands(self):
         output = self.get_console()
         # Verify all "initCommands" were found in console output
         self.verify_commands('initCommands', output, initCommands)
         # Verify all "preRunCommands" were found in console output
         self.verify_commands('preRunCommands', output, preRunCommands)
 
         functions = ['main']
         breakpoint_ids = self.set_function_breakpoints(functions)
-        self.assertTrue(len(breakpoint_ids) == len(functions),
+        self.assertEquals(len(breakpoint_ids), len(functions),
                         "expect one breakpoint")
         self.continue_to_breakpoints(breakpoint_ids)
         output = self.get_console(timeout=1.0)
         self.verify_commands('stopCommands', output, stopCommands)
 
         # Continue after launch and hit the "pause()" call and stop the target.
         # Get output from the console. This should contain both the
         # "stopCommands" that were run after we stop.

lldb/test/API/tools/lldb-vscode/breakpoint/TestVSCode_setBreakpoints.py

def test_set_and_clear(self):
         program = self.getBuildArtifact("a.out")
         self.build_and_launch(program)
 
         # Set 3 breakoints and verify that they got set correctly
         response = self.vscode.request_setBreakpoints(source_path, lines)
         line_to_id = {}
         if response:
             breakpoints = response['body']['breakpoints']
-            self.assertTrue(len(breakpoints) == len(lines),
+            self.assertEquals(len(breakpoints), len(lines),
                             "expect %u source breakpoints" % (len(lines)))
             for breakpoint in breakpoints:
                 line = breakpoint['line']
                 # Store the "id" of the breakpoint that was set for later
                 line_to_id[line] = breakpoint['id']
                 self.assertTrue(line in lines, "line expected in lines array")
                 self.assertTrue(breakpoint['verified'],
                                 "expect breakpoint verified")
 
         # There is no breakpoint delete packet, clients just send another
         # setBreakpoints packet with the same source file with fewer lines.
         # Below we remove the second line entry and call the setBreakpoints
         # function again. We want to verify that any breakpoints that were set
         # before still have the same "id". This means we didn't clear the
         # breakpoint and set it again at the same location. We also need to
         # verify that the second line location was actually removed.
         lines.remove(second_line)
         # Set 2 breakoints and verify that the previous breakoints that were
         # set above are still set.
         response = self.vscode.request_setBreakpoints(source_path, lines)
         if response:
             breakpoints = response['body']['breakpoints']
-            self.assertTrue(len(breakpoints) == len(lines),
+            self.assertEquals(len(breakpoints), len(lines),
                             "expect %u source breakpoints" % (len(lines)))
             for breakpoint in breakpoints:
                 line = breakpoint['line']
                 # Verify the same breakpoints are still set within LLDB by
                 # making sure the breakpoint ID didn't change
-                self.assertTrue(line_to_id[line] == breakpoint['id'],
+                self.assertEquals(line_to_id[line], breakpoint['id'],
                                 "verify previous breakpoints stayed the same")
                 self.assertTrue(line in lines, "line expected in lines array")
                 self.assertTrue(breakpoint['verified'],
                                 "expect breakpoint still verified")
 
         # Now get the full list of breakpoints set in the target and verify
         # we have only 2 breakpoints set. The response above could have told
         # us about 2 breakpoints, but we want to make sure we don't have the
         # third one still set in the target
         response = self.vscode.request_testGetTargetBreakpoints()
         if response:
             breakpoints = response['body']['breakpoints']
-            self.assertTrue(len(breakpoints) == len(lines),
+            self.assertEquals(len(breakpoints), len(lines),
                             "expect %u source breakpoints" % (len(lines)))
             for breakpoint in breakpoints:
                 line = breakpoint['line']
                 # Verify the same breakpoints are still set within LLDB by
                 # making sure the breakpoint ID didn't change
-                self.assertTrue(line_to_id[line] == breakpoint['id'],
+                self.assertEquals(line_to_id[line], breakpoint['id'],
                                 "verify previous breakpoints stayed the same")
                 self.assertTrue(line in lines, "line expected in lines array")
                 self.assertTrue(breakpoint['verified'],
                                 "expect breakpoint still verified")
 
         # Now clear all breakpoints for the source file by passing down an
         # empty lines array
         lines = []
         response = self.vscode.request_setBreakpoints(source_path, lines)
         if response:
             breakpoints = response['body']['breakpoints']
-            self.assertTrue(len(breakpoints) == len(lines),
+            self.assertEquals(len(breakpoints), len(lines),
                             "expect %u source breakpoints" % (len(lines)))
 
         # Verify with the target that all breakpoints have been cleared
         response = self.vscode.request_testGetTargetBreakpoints()
         if response:
             breakpoints = response['body']['breakpoints']
-            self.assertTrue(len(breakpoints) == len(lines),
+            self.assertEquals(len(breakpoints), len(lines),
                             "expect %u source breakpoints" % (len(lines)))
 
         # Now set a breakpoint again in the same source file and verify it
         # was added.
         lines = [second_line]
         response = self.vscode.request_setBreakpoints(source_path, lines)
         if response:
             breakpoints = response['body']['breakpoints']
-            self.assertTrue(len(breakpoints) == len(lines),
+            self.assertEquals(len(breakpoints), len(lines),
                             "expect %u source breakpoints" % (len(lines)))
             for breakpoint in breakpoints:
                 line = breakpoint['line']
                 self.assertTrue(line in lines, "line expected in lines array")
                 self.assertTrue(breakpoint['verified'],
                                 "expect breakpoint still verified")
 
         # Now get the full list of breakpoints set in the target and verify
         # we have only 2 breakpoints set. The response above could have told
         # us about 2 breakpoints, but we want to make sure we don't have the
         # third one still set in the target
         response = self.vscode.request_testGetTargetBreakpoints()
         if response:
             breakpoints = response['body']['breakpoints']
-            self.assertTrue(len(breakpoints) == len(lines),
+            self.assertEquals(len(breakpoints), len(lines),
                             "expect %u source breakpoints" % (len(lines)))
             for breakpoint in breakpoints:
                 line = breakpoint['line']
                 self.assertTrue(line in lines, "line expected in lines array")
                 self.assertTrue(breakpoint['verified'],
                                 "expect breakpoint still verified")
 
     @skipIfWindows
     def test_functionality(self):
         '''Tests hitting breakpoints and the functionality of a single
            breakpoint, like 'conditions' and 'hitCondition' settings.'''
         source_basename = 'main.cpp'
         source_path = os.path.join(os.getcwd(), source_basename)
         loop_line = line_number('main.cpp', '// break loop')
 
         program = self.getBuildArtifact("a.out")
         self.build_and_launch(program)
         # Set a breakpoint at the loop line with no condition and no
         # hitCondition
         breakpoint_ids = self.set_source_breakpoints(source_path, [loop_line])
-        self.assertTrue(len(breakpoint_ids) == 1, "expect one breakpoint")
+        self.assertEquals(len(breakpoint_ids), 1, "expect one breakpoint")
         self.vscode.request_continue()
 
         # Verify we hit the breakpoint we just set
         self.verify_breakpoint_hit(breakpoint_ids)
 
         # Make sure i is zero at first breakpoint
         i = int(self.vscode.get_local_variable_value('i'))
-        self.assertTrue(i == 0, 'i != 0 after hitting breakpoint')
+        self.assertEquals(i, 0, 'i != 0 after hitting breakpoint')
 
         # Update the condition on our breakpoint
         new_breakpoint_ids = self.set_source_breakpoints(source_path,
                                                          [loop_line],
                                                          condition="i==4")
-        self.assertTrue(breakpoint_ids == new_breakpoint_ids,
+        self.assertEquals(breakpoint_ids, new_breakpoint_ids,
                         "existing breakpoint should have its condition "
                         "updated")
 
         self.continue_to_breakpoints(breakpoint_ids)
         i = int(self.vscode.get_local_variable_value('i'))
-        self.assertTrue(i == 4,
+        self.assertEquals(i, 4,
                         'i != 4 showing conditional works')
 
         new_breakpoint_ids = self.set_source_breakpoints(source_path,
                                                          [loop_line],
                                                          hitCondition="2")
 
-        self.assertTrue(breakpoint_ids == new_breakpoint_ids,
+        self.assertEquals(breakpoint_ids, new_breakpoint_ids,
                         "existing breakpoint should have its condition "
                         "updated")
 
         # Continue with a hitContidtion of 2 and expect it to skip 1 value
         self.continue_to_breakpoints(breakpoint_ids)
         i = int(self.vscode.get_local_variable_value('i'))
-        self.assertTrue(i == 6,
+        self.assertEquals(i, 6,
                         'i != 6 showing hitCondition works')
 
         # continue after hitting our hitCondition and make sure it only goes
         # up by 1
         self.continue_to_breakpoints(breakpoint_ids)
         i = int(self.vscode.get_local_variable_value('i'))
-        self.assertTrue(i == 7,
+        self.assertEquals(i, 7,
                         'i != 7 showing post hitCondition hits every time')

lldb/test/API/tools/lldb-vscode/breakpoint/TestVSCode_setFunctionBreakpoints.py

def test_set_and_clear(self):
         program = self.getBuildArtifact("a.out")
         self.build_and_launch(program)
         bp_id_12 = None
         functions = ['twelve']
         # Set a function breakpoint at 'twelve'
         response = self.vscode.request_setFunctionBreakpoints(functions)
         if response:
             breakpoints = response['body']['breakpoints']
-            self.assertTrue(len(breakpoints) == len(functions),
+            self.assertEquals(len(breakpoints), len(functions),
                             "expect %u source breakpoints" % (len(functions)))
             for breakpoint in breakpoints:
                 bp_id_12 = breakpoint['id']
                 self.assertTrue(breakpoint['verified'],
                                 "expect breakpoint verified")
 
         # Add an extra name and make sure we have two breakpoints after this
         functions.append('thirteen')
         response = self.vscode.request_setFunctionBreakpoints(functions)
         if response:
             breakpoints = response['body']['breakpoints']
-            self.assertTrue(len(breakpoints) == len(functions),
+            self.assertEquals(len(breakpoints), len(functions),
                             "expect %u source breakpoints" % (len(functions)))
             for breakpoint in breakpoints:
                 self.assertTrue(breakpoint['verified'],
                                 "expect breakpoint verified")
 
         # There is no breakpoint delete packet, clients just send another
         # setFunctionBreakpoints packet with the different function names.
         functions.remove('thirteen')
         response = self.vscode.request_setFunctionBreakpoints(functions)
         if response:
             breakpoints = response['body']['breakpoints']
-            self.assertTrue(len(breakpoints) == len(functions),
+            self.assertEquals(len(breakpoints), len(functions),
                             "expect %u source breakpoints" % (len(functions)))
             for breakpoint in breakpoints:
                 bp_id = breakpoint['id']
-                self.assertTrue(bp_id == bp_id_12,
+                self.assertEquals(bp_id, bp_id_12,
                                 'verify "twelve" breakpoint ID is same')
                 self.assertTrue(breakpoint['verified'],
                                 "expect breakpoint still verified")
 
         # Now get the full list of breakpoints set in the target and verify
         # we have only 1 breakpoints set. The response above could have told
         # us about 1 breakpoints, but we want to make sure we don't have the
         # second one still set in the target
         response = self.vscode.request_testGetTargetBreakpoints()
         if response:
             breakpoints = response['body']['breakpoints']
-            self.assertTrue(len(breakpoints) == len(functions),
+            self.assertEquals(len(breakpoints), len(functions),
                             "expect %u source breakpoints" % (len(functions)))
             for breakpoint in breakpoints:
                 bp_id = breakpoint['id']
-                self.assertTrue(bp_id == bp_id_12,
+                self.assertEquals(bp_id, bp_id_12,
                                 'verify "twelve" breakpoint ID is same')
                 self.assertTrue(breakpoint['verified'],
                                 "expect breakpoint still verified")
 
         # Now clear all breakpoints for the source file by passing down an
         # empty lines array
         functions = []
         response = self.vscode.request_setFunctionBreakpoints(functions)
         if response:
             breakpoints = response['body']['breakpoints']
-            self.assertTrue(len(breakpoints) == len(functions),
+            self.assertEquals(len(breakpoints), len(functions),
                             "expect %u source breakpoints" % (len(functions)))
 
         # Verify with the target that all breakpoints have been cleared
         response = self.vscode.request_testGetTargetBreakpoints()
         if response:
             breakpoints = response['body']['breakpoints']
-            self.assertTrue(len(breakpoints) == len(functions),
+            self.assertEquals(len(breakpoints), len(functions),
                             "expect %u source breakpoints" % (len(functions)))
 
     @skipIfWindows
     def test_functionality(self):
         '''Tests hitting breakpoints and the functionality of a single
            breakpoint, like 'conditions' and 'hitCondition' settings.'''
 
         program = self.getBuildArtifact("a.out")
         self.build_and_launch(program)
         # Set a breakpoint on "twelve" with no condition and no hitCondition
         functions = ['twelve']
         breakpoint_ids = self.set_function_breakpoints(functions)
 
-        self.assertTrue(len(breakpoint_ids) == len(functions),
+        self.assertEquals(len(breakpoint_ids), len(functions),
                         "expect one breakpoint")
 
         # Verify we hit the breakpoint we just set
         self.continue_to_breakpoints(breakpoint_ids)
 
         # Make sure i is zero at first breakpoint
         i = int(self.vscode.get_local_variable_value('i'))
-        self.assertTrue(i == 0, 'i != 0 after hitting breakpoint')
+        self.assertEquals(i, 0, 'i != 0 after hitting breakpoint')
 
         # Update the condition on our breakpoint
         new_breakpoint_ids = self.set_function_breakpoints(functions,
                                                            condition="i==4")
-        self.assertTrue(breakpoint_ids == new_breakpoint_ids,
+        self.assertEquals(breakpoint_ids, new_breakpoint_ids,
                         "existing breakpoint should have its condition "
                         "updated")
 
         self.continue_to_breakpoints(breakpoint_ids)
         i = int(self.vscode.get_local_variable_value('i'))
-        self.assertTrue(i == 4,
+        self.assertEquals(i, 4,
                         'i != 4 showing conditional works')
         new_breakpoint_ids = self.set_function_breakpoints(functions,
                                                            hitCondition="2")
 
-        self.assertTrue(breakpoint_ids == new_breakpoint_ids,
+        self.assertEquals(breakpoint_ids, new_breakpoint_ids,
                         "existing breakpoint should have its condition "
                         "updated")
 
         # Continue with a hitContidtion of 2 and expect it to skip 1 value
         self.continue_to_breakpoints(breakpoint_ids)
         i = int(self.vscode.get_local_variable_value('i'))
-        self.assertTrue(i == 6,
+        self.assertEquals(i, 6,
                         'i != 6 showing hitCondition works')
 
         # continue after hitting our hitCondition and make sure it only goes
         # up by 1
         self.continue_to_breakpoints(breakpoint_ids)
         i = int(self.vscode.get_local_variable_value('i'))
-        self.assertTrue(i == 7,
+        self.assertEquals(i, 7,
                         'i != 7 showing post hitCondition hits every time')

lldb/test/API/tools/lldb-vscode/launch/TestVSCode_launch.py

def test_debuggerRoot(self):
         self.assertTrue(output and len(output) > 0,
                         "expect console output")
         lines = output.splitlines()
         prefix = 'cwd = '
         found = False
         for line in lines:
             if line.startswith(prefix):
                 found = True
-                self.assertTrue(program_parent_dir == line[len(prefix):],
+                self.assertEquals(program_parent_dir, line[len(prefix):],
                                 "lldb-vscode working dir '%s' == '%s'" % (
                                     program_parent_dir, line[6:]))
         self.assertTrue(found, "verified lldb-vscode working directory")
         self.continue_to_exit()
 
     @skipIfWindows
     def test_sourcePath(self):
         '''
             Tests the "sourcePath" will set the target.source-map.
         '''
         program = self.getBuildArtifact("a.out")
         program_dir = os.path.dirname(program)
         self.build_and_launch(program,
                               sourcePath=program_dir)
         output = self.get_console()
         self.assertTrue(output and len(output) > 0,
                         "expect console output")
         lines = output.splitlines()
         prefix = '(lldb) settings set target.source-map "." '
         found = False
         for line in lines:
             if line.startswith(prefix):
                 found = True
                 quoted_path = '"%s"' % (program_dir)
-                self.assertTrue(quoted_path == line[len(prefix):],
+                self.assertEquals(quoted_path, line[len(prefix):],
                                 "lldb-vscode working dir %s == %s" % (
                                     quoted_path, line[6:]))
         self.assertTrue(found, 'found "sourcePath" in console output')
         self.continue_to_exit()
 
     @skipIfWindows
     def test_disableSTDIO(self):
         '''
             Tests the default launch of a simple program with STDIO disabled.
         '''
         program = self.getBuildArtifact("a.out")
         self.build_and_launch(program,
                               disableSTDIO=True)
         self.continue_to_exit()
         # Now get the STDOUT and verify our program argument is correct
         output = self.get_stdout()
-        self.assertTrue(output is None or len(output) == 0,
+        self.assertEquals(output, None,
                         "expect no program output")
 
     @skipIfWindows
     @skipIfLinux # shell argument expansion doesn't seem to work on Linux
     @expectedFailureNetBSD
     def test_shellExpandArguments_enabled(self):
         '''
             Tests the default launch of a simple program with shell expansion
def test_commands(self):
         source = 'main.c'
         first_line = line_number(source, '// breakpoint 1')
         second_line = line_number(source, '// breakpoint 2')
         lines = [first_line, second_line]
 
         # Set 2 breakoints so we can verify that "stopCommands" get run as the
         # breakpoints get hit
         breakpoint_ids = self.set_source_breakpoints(source, lines)
-        self.assertTrue(len(breakpoint_ids) == len(lines),
+        self.assertEquals(len(breakpoint_ids), len(lines),
                         "expect correct number of breakpoints")
 
         # Continue after launch and hit the first breakpoint.
         # Get output from the console. This should contain both the
         # "stopCommands" that were run after the first breakpoint was hit
         self.continue_to_breakpoints(breakpoint_ids)
         output = self.get_console(timeout=1.0)
         self.verify_commands('stopCommands', output, stopCommands)

lldb/test/API/tools/lldb-vscode/stackTrace/TestVSCode_stackTrace.py

def verify_stackFrame(self, frame_idx, stackFrame):
             expected_line = self.recurse_end
             expected_name = 'recurse'
         elif frame_idx < 20:
             expected_line = self.recurse_call
             expected_name = 'recurse'
         else:
             expected_line = self.recurse_invocation
             expected_name = 'main'
-        self.assertTrue(frame_name == expected_name,
+        self.assertEquals(frame_name, expected_name,
                         'frame #%i name "%s" == "%s"' % (
                             frame_idx, frame_name, expected_name))
-        self.assertTrue(frame_source == self.source_path,
+        self.assertEquals(frame_source, self.source_path,
                         'frame #%i source "%s" == "%s"' % (
                             frame_idx, frame_source, self.source_path))
-        self.assertTrue(frame_line == expected_line,
+        self.assertEquals(frame_line, expected_line,
                         'frame #%i line %i == %i' % (frame_idx, frame_line,
                                                      expected_line))
 
     @skipIfWindows
     def test_stackTrace(self):
         '''
             Tests the 'stackTrace' packet and all its variants.
         '''
         program = self.getBuildArtifact("a.out")
         self.build_and_launch(program)
         source = 'main.c'
         self.source_path = os.path.join(os.getcwd(), source)
         self.recurse_end = line_number(source, 'recurse end')
         self.recurse_call = line_number(source, 'recurse call')
         self.recurse_invocation = line_number(source, 'recurse invocation')
 
         lines = [self.recurse_end]
 
         # Set breakoint at a point of deepest recuusion
         breakpoint_ids = self.set_source_breakpoints(source, lines)
-        self.assertTrue(len(breakpoint_ids) == len(lines),
+        self.assertEquals(len(breakpoint_ids), len(lines),
                         "expect correct number of breakpoints")
 
         self.continue_to_breakpoints(breakpoint_ids)
         startFrame = 0
         # Verify we get all stack frames with no arguments
         (stackFrames, totalFrames) = self.get_stackFrames_and_totalFramesCount()
         frameCount = len(stackFrames)
         self.assertTrue(frameCount >= 20,
                         'verify we get at least 20 frames for all frames')
-        self.assertTrue(totalFrames == frameCount,
+        self.assertEquals(totalFrames, frameCount,
                         'verify we get correct value for totalFrames count')
         self.verify_stackFrames(startFrame, stackFrames)
 
         # Verify all stack frames by specifying startFrame = 0 and levels not
         # specified
         stackFrames = self.get_stackFrames(startFrame=startFrame)
-        self.assertTrue(frameCount == len(stackFrames),
+        self.assertEquals(frameCount, len(stackFrames),
                         ('verify same number of frames with startFrame=%i') % (
                             startFrame))
         self.verify_stackFrames(startFrame, stackFrames)
 
         # Verify all stack frames by specifying startFrame = 0 and levels = 0
         levels = 0
         stackFrames = self.get_stackFrames(startFrame=startFrame,
                                            levels=levels)
-        self.assertTrue(frameCount == len(stackFrames),
+        self.assertEquals(frameCount, len(stackFrames),
                         ('verify same number of frames with startFrame=%i and'
                          ' levels=%i') % (startFrame, levels))
         self.verify_stackFrames(startFrame, stackFrames)
 
         # Get only the first stack frame by sepcifying startFrame = 0 and
         # levels = 1
         levels = 1
         stackFrames = self.get_stackFrames(startFrame=startFrame,
                                            levels=levels)
-        self.assertTrue(levels == len(stackFrames),
+        self.assertEquals(levels, len(stackFrames),
                         ('verify one frame with startFrame=%i and'
                          ' levels=%i') % (startFrame, levels))
         self.verify_stackFrames(startFrame, stackFrames)
 
         # Get only the first 3 stack frames by sepcifying startFrame = 0 and
         # levels = 3
         levels = 3
         stackFrames = self.get_stackFrames(startFrame=startFrame,
                                            levels=levels)
-        self.assertTrue(levels == len(stackFrames),
+        self.assertEquals(levels, len(stackFrames),
                         ('verify %i frames with startFrame=%i and'
                          ' levels=%i') % (levels, startFrame, levels))
         self.verify_stackFrames(startFrame, stackFrames)
 
         # Get only the first 15 stack frames by sepcifying startFrame = 5 and
         # levels = 16
         startFrame = 5
         levels = 16
         stackFrames = self.get_stackFrames(startFrame=startFrame,
                                            levels=levels)
-        self.assertTrue(levels == len(stackFrames),
+        self.assertEquals(levels, len(stackFrames),
                         ('verify %i frames with startFrame=%i and'
                          ' levels=%i') % (levels, startFrame, levels))
         self.verify_stackFrames(startFrame, stackFrames)
 
         # Verify we cap things correctly when we ask for too many frames
         startFrame = 5
         levels = 1000
         (stackFrames, totalFrames) = self.get_stackFrames_and_totalFramesCount(
                                             startFrame=startFrame,
                                             levels=levels)
-        self.assertTrue(len(stackFrames) == frameCount - startFrame,
+        self.assertEquals(len(stackFrames), frameCount - startFrame,
                         ('verify less than 1000 frames with startFrame=%i and'
                          ' levels=%i') % (startFrame, levels))
-        self.assertTrue(totalFrames == frameCount,
+        self.assertEquals(totalFrames, frameCount,
                         'verify we get correct value for totalFrames count '
                         'when requested frames not from 0 index')
         self.verify_stackFrames(startFrame, stackFrames)
 
         # Verify level=0 works with non-zerp start frame
         startFrame = 5
         levels = 0
         stackFrames = self.get_stackFrames(startFrame=startFrame,
                                            levels=levels)
-        self.assertTrue(len(stackFrames) == frameCount - startFrame,
+        self.assertEquals(len(stackFrames), frameCount - startFrame,
                         ('verify less than 1000 frames with startFrame=%i and'
                          ' levels=%i') % (startFrame, levels))
         self.verify_stackFrames(startFrame, stackFrames)
 
         # Verify we get not frames when startFrame is too high
         startFrame = 1000
         levels = 1
         stackFrames = self.get_stackFrames(startFrame=startFrame,
                                            levels=levels)
-        self.assertTrue(0 == len(stackFrames),
+        self.assertEquals(0, len(stackFrames),
                         'verify zero frames with startFrame out of bounds')