[lldb] Convert assertTrue(a == b) to assertEqual(a, b)

[kastiglione]

Summary

Convert assertTrue(a == b) to assertEqual(a, b) to produce better failure messages.

These were mostly done via regex search & replace, with some manual fixes.

[kastiglione]

I haven't run tests yet.

[JDevlieghere]

Cool, I was under the impression @teemperor had already done something similar, but I must be misremembering.

lldb/test/API/python_api/frame/TestFrames.py

96–97

Very odd/confusing formatting.

lldb/test/API/python_api/lldbutil/iter/TestLLDBIterator.py

53

😁

[kastiglione]

lldb/test/API/python_api/frame/TestFrames.py

96–97

I noticed this too in the diff, I'll fix it up.

[teemperor]

In D95813#2535209, @JDevlieghere wrote:

Cool, I was under the impression @teemperor had already done something similar, but I must be misremembering.

I ran one big regex that got most of the Equal/Less/Bigger than, but I think the multi-line calls I didn't transform (because of laziness).

[teemperor]

Don't see any change that looks wrong from scrolling over this, so LGTM

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/atomic/TestLibCxxAtomic.py

59–60

10/10

[kastiglione]

assertNotEqual & formatting

lldb/test/API/commands/register/register/register_command/TestRegisters.py

def fp_special_purpose_register_read(self):
             with recording(self, False) as sbuf:
                 print("%s sub string: %s" % ('Expecting', str1), file=sbuf)
                 print("Matched" if matched else "Not Matched", file=sbuf)
             if matched:
                 break
         self.assertTrue(matched, STOPPED_DUE_TO_SIGNAL)
 
         process = target.GetProcess()
-        self.assertTrue(process.GetState() == lldb.eStateStopped,
+        self.assertEqual(process.GetState(), lldb.eStateStopped,
                         PROCESS_STOPPED)
 
         thread = process.GetThreadAtIndex(0)
         self.assertTrue(thread.IsValid(), "current thread is valid")
 
         currentFrame = thread.GetFrameAtIndex(0)
         self.assertTrue(currentFrame.IsValid(), "current frame is valid")
 

lldb/test/API/commands/watchpoints/watchpoint_events/TestWatchpointEvents.py

def test_with_python_api(self):
 
         local_watch.SetIgnoreCount(10)
         self.GetWatchpointEvent(lldb.eWatchpointEventTypeIgnoreChanged)
 
         condition = "1 == 2"
         local_watch.SetCondition(condition)
         self.GetWatchpointEvent(lldb.eWatchpointEventTypeConditionChanged)
 
-        self.assertTrue(local_watch.GetCondition() == condition,
+        self.assertEqual(local_watch.GetCondition(), condition,
                         'make sure watchpoint condition is "' + condition + '"')
 
     def GetWatchpointEvent(self, event_type):
         # We added a watchpoint so we should get a watchpoint added event.
         event = lldb.SBEvent()
         success = self.listener.WaitForEvent(1, event)
         self.assertTrue(success, "Successfully got watchpoint event")
         self.assertTrue(

lldb/test/API/functionalities/breakpoint/breakpoint_conditions/TestBreakpointConditions.py

def breakpoint_conditions_python(self):
         breakpoint = target.BreakpointCreateByName('c', 'a.out')
         self.trace("breakpoint:", breakpoint)
         self.assertTrue(breakpoint and
                         breakpoint.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
 
         # We didn't associate a thread index with the breakpoint, so it should
         # be invalid.
-        self.assertTrue(breakpoint.GetThreadIndex() == lldb.UINT32_MAX,
+        self.assertEqual(breakpoint.GetThreadIndex(), lldb.UINT32_MAX,
                         "The thread index should be invalid")
         # The thread name should be invalid, too.
         self.assertTrue(breakpoint.GetThreadName() is None,
                         "The thread name should be invalid")
 
         # Let's set the thread index for this breakpoint and verify that it is,
         # indeed, being set correctly.
         # There's only one thread for the process.
         breakpoint.SetThreadIndex(1)
-        self.assertTrue(breakpoint.GetThreadIndex() == 1,
+        self.assertEqual(breakpoint.GetThreadIndex(), 1,
                         "The thread index has been set correctly")
 
         # Get the breakpoint location from breakpoint after we verified that,
         # indeed, it has one location.
         location = breakpoint.GetLocationAtIndex(0)
         self.assertTrue(location and
                         location.IsEnabled(),
                         VALID_BREAKPOINT_LOCATION)
def breakpoint_conditions_python(self):
             thread.IsValid(),
             "There should be a thread stopped due to breakpoint condition")
         frame0 = thread.GetFrameAtIndex(0)
         var = frame0.FindValue('val', lldb.eValueTypeVariableArgument)
         self.assertTrue(frame0.GetLineEntry().GetLine() == self.line1 and
                         var.GetValue() == '3')
 
         # The hit count for the breakpoint should be 1.
-        self.assertTrue(breakpoint.GetHitCount() == 1)
+        self.assertEqual(breakpoint.GetHitCount(), 1)
 
         # Test that the condition expression didn't create a result variable:
         options = lldb.SBExpressionOptions()
         value = frame0.EvaluateExpression("$0", options)
         self.assertTrue(value.GetError().Fail(),
                         "Conditions should not make result variables.")
         process.Continue()
 
def breakpoint_invalid_conditions_python(self):
         # Frame #0 should be on self.line1 and the break condition should hold.
         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 condition")
         frame0 = thread.GetFrameAtIndex(0)
         var = frame0.FindValue('val', lldb.eValueTypeVariableArgument)
-        self.assertTrue(frame0.GetLineEntry().GetLine() == self.line1)
+        self.assertEqual(frame0.GetLineEntry().GetLine(), self.line1)
 
         # The hit count for the breakpoint should be 1.
-        self.assertTrue(breakpoint.GetHitCount() == 1)
+        self.assertEqual(breakpoint.GetHitCount(), 1)

lldb/test/API/functionalities/breakpoint/breakpoint_ignore_count/TestBreakpointIgnoreCount.py

def breakpoint_ignore_count_python(self):
         # indeed, it has one location.
         location = breakpoint.GetLocationAtIndex(0)
         self.assertTrue(location and
                         location.IsEnabled(),
                         VALID_BREAKPOINT_LOCATION)
 
         # Set the ignore count on the breakpoint location.
         location.SetIgnoreCount(2)
-        self.assertTrue(location.GetIgnoreCount() == 2,
+        self.assertEqual(location.GetIgnoreCount(), 2,
                         "SetIgnoreCount() works correctly")
 
         # 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)
 
         # Frame#0 should be on main.c:37, frame#1 should be on main.c:25, and
         # frame#2 should be on main.c:48.
         # lldbutil.print_stacktraces(process)
         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)
         frame1 = thread.GetFrameAtIndex(1)
         frame2 = thread.GetFrameAtIndex(2)
         self.assertTrue(frame0.GetLineEntry().GetLine() == self.line1 and
                         frame1.GetLineEntry().GetLine() == self.line3 and
                         frame2.GetLineEntry().GetLine() == self.line4,
                         STOPPED_DUE_TO_BREAKPOINT_IGNORE_COUNT)
 
         # The hit count for the breakpoint should be 3.
-        self.assertTrue(breakpoint.GetHitCount() == 3)
+        self.assertEqual(breakpoint.GetHitCount(), 3)
 
         process.Continue()

lldb/test/API/functionalities/breakpoint/breakpoint_in_delayslot/TestAvoidBreakpointInDelaySlot.py

def test(self):
                         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)
 
         list = target.FindFunctions('foo', lldb.eFunctionNameTypeAuto)
-        self.assertTrue(list.GetSize() == 1)
+        self.assertEqual(list.GetSize(), 1)
         sc = list.GetContextAtIndex(0)
-        self.assertTrue(sc.GetSymbol().GetName() == "foo")
+        self.assertEqual(sc.GetSymbol().GetName(), "foo")
         function = sc.GetFunction()
         self.assertTrue(function)
         self.function(function, target)
 
     def function(self, function, target):
         """Iterate over instructions in function and place a breakpoint on delay slot instruction"""
         # Get the list of all instructions in the function
         insts = function.GetInstructions(target)
def function(self, function, target):
                 # Get the location from breakpoint
                 location = breakpoint.GetLocationAtIndex(0)
 
                 # Get the address where breakpoint is actually set.
                 bpaddr = location.GetLoadAddress()
 
                 # Breakpoint address should be adjusted to the address of
                 # branch instruction.
-                self.assertTrue(branchinstaddress == bpaddr)
+                self.assertEqual(branchinstaddress, bpaddr)
                 i += 1
             else:
                 i += 1

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

def check_equivalence(self, source_bps, do_write = True):
             self.assertTrue(error.Success(), "Failed writing breakpoints to file: %s."%(error.GetCString()))
 
         copy_bps = lldb.SBBreakpointList(self.copy_target)
         error = self.copy_target.BreakpointsCreateFromFile(self.bkpts_file_spec, copy_bps)
         self.assertTrue(error.Success(), "Failed reading breakpoints from file: %s"%(error.GetCString()))
 
         num_source_bps = source_bps.GetSize()
         num_copy_bps = copy_bps.GetSize()
-        self.assertTrue(num_source_bps == num_copy_bps, "Didn't get same number of input and output breakpoints - orig: %d copy: %d"%(num_source_bps, num_copy_bps))
+        self.assertEqual(num_source_bps, num_copy_bps, "Didn't get same number of input and output breakpoints - orig: %d copy: %d"%(num_source_bps, num_copy_bps))
 
         for i in range(0, num_source_bps):
             source_bp = source_bps.GetBreakpointAtIndex(i)
             source_desc = lldb.SBStream()
             source_bp.GetDescription(source_desc, False)
             source_text = source_desc.GetData()
 
             # I am assuming here that the breakpoints will get written out in breakpoint ID order, and
def do_check_names(self):
         self.assertTrue(error.Success(), "Failed writing breakpoints to file: %s."%(error.GetCString()))
 
         copy_bps = lldb.SBBreakpointList(self.copy_target)
         names_list = lldb.SBStringList()
         names_list.AppendString("NoSuchName")
 
         error = self.copy_target.BreakpointsCreateFromFile(self.bkpts_file_spec, names_list, copy_bps)
         self.assertTrue(error.Success(), "Failed reading breakpoints from file: %s"%(error.GetCString()))
-        self.assertTrue(copy_bps.GetSize() == 0, "Found breakpoints with a nonexistent name.")
+        self.assertEqual(copy_bps.GetSize(), 0, "Found breakpoints with a nonexistent name.")
 
         names_list.AppendString(good_bkpt_name)
         error = self.copy_target.BreakpointsCreateFromFile(self.bkpts_file_spec, names_list, copy_bps)
         self.assertTrue(error.Success(), "Failed reading breakpoints from file: %s"%(error.GetCString()))
-        self.assertTrue(copy_bps.GetSize() == 1, "Found the matching breakpoint.")
+        self.assertEqual(copy_bps.GetSize(), 1, "Found the matching breakpoint.")
 
     def do_check_extra_args(self):
 
         import side_effect
         interp = self.dbg.GetCommandInterpreter()
         error = lldb.SBError()
 
         script_name = os.path.join(self.getSourceDir(), "resolver.py")

lldb/test/API/functionalities/conditional_break/TestConditionalBreak.py

def do_conditional_break(self):
 
         # 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)
 
         # The stop reason of the thread should be breakpoint.
-        self.assertTrue(process.GetState() == lldb.eStateStopped,
+        self.assertEqual(process.GetState(), lldb.eStateStopped,
                         STOPPED_DUE_TO_BREAKPOINT)
 
         # Find the line number where a's parent frame function is c.
         line = line_number(
             'main.c',
             "// Find the line number where c's parent frame is a here.")
 
         # Suppose we are only interested in the call scenario where c()'s
def do_conditional_break(self):
                 thread, "Expected one thread to be stopped at the breakpoint")
 
             if thread.GetNumFrames() >= 2:
                 frame0 = thread.GetFrameAtIndex(0)
                 name0 = frame0.GetFunction().GetName()
                 frame1 = thread.GetFrameAtIndex(1)
                 name1 = frame1.GetFunction().GetName()
                 # lldbutil.print_stacktrace(thread)
-                self.assertTrue(name0 == "c", "Break on function c()")
+                self.assertEqual(name0, "c", "Break on function c()")
                 if (name1 == "a"):
                     # By design, we know that a() calls c() only from main.c:27.
                     # In reality, similar logic can be used to find out the call
                     # site.
-                    self.assertTrue(frame1.GetLineEntry().GetLine() == line,
+                    self.assertEqual(frame1.GetLineEntry().GetLine(), line,
                                     "Immediate caller a() at main.c:%d" % line)
 
                     # And the local variable 'val' should have a value of (int)
                     # 3.
                     val = frame1.FindVariable("val")
                     self.assertEqual("int", val.GetTypeName())
                     self.assertEqual("3", val.GetValue())
                     break

lldb/test/API/functionalities/data-formatter/data-formatter-stl/libcxx/atomic/TestLibCxxAtomic.py

def test(self):
             print(i_atomic)
 
         # Extract the content of the std::atomic wrappers.
         self.assertEqual(s_atomic.GetNumChildren(), 1)
         s = s_atomic.GetChildAtIndex(0)
         self.assertEqual(i_atomic.GetNumChildren(), 1)
         i = i_atomic.GetChildAtIndex(0)
 
-        self.assertTrue(i.GetValueAsUnsigned(0) == 5, "i == 5")
-        self.assertTrue(s.GetNumChildren() == 2, "s has two children")
+        self.assertEqual(i.GetValueAsUnsigned(0), 5, "i == 5")
+        self.assertEqual(s.GetNumChildren(), 2, "s has two children")
         self.assertTrue(
             s.GetChildAtIndex(0).GetValueAsUnsigned(0) == 1,
             "s.x == 1")
         self.assertTrue(
             s.GetChildAtIndex(1).GetValueAsUnsigned(0) == 2,
             "s.y == 2")
 
         # Try printing the child that points to its own parent object.
         # This should just treat the atomic pointer as a normal pointer.
         self.expect("frame var p.child", substrs=["Value = 0x"])
         self.expect("frame var p", substrs=["parent = {", "Value = 0x", "}"])
         self.expect("frame var p.child.parent", substrs=["p.child.parent = {\n  Value = 0x"])

lldb/test/API/functionalities/data-formatter/data-formatter-synthval/TestDataFormatterSynthVal.py

def test_with_run_command(self):
         z_val = z.GetValueAsUnsigned
         q_val = q.GetValueAsUnsigned
 
         if self.TraceOn():
             print(
                 "x_val = %s; y_val = %s; z_val = %s; q_val = %s" %
                 (x_val(), y_val(), z_val(), q_val()))
 
-        self.assertFalse(x_val() == 3, "x == 3 before synthetics")
-        self.assertFalse(y_val() == 4, "y == 4 before synthetics")
-        self.assertFalse(z_val() == 7, "z == 7 before synthetics")
-        self.assertFalse(q_val() == 8, "q == 8 before synthetics")
+        self.assertNotEqual(x_val(), 3, "x == 3 before synthetics")
+        self.assertNotEqual(y_val(), 4, "y == 4 before synthetics")
+        self.assertNotEqual(z_val(), 7, "z == 7 before synthetics")
+        self.assertNotEqual(q_val(), 8, "q == 8 before synthetics")
 
         # now set up the synth
         self.runCmd("script from myIntSynthProvider import *")
         self.runCmd("type synth add -l myIntSynthProvider myInt")
         self.runCmd("type synth add -l myArraySynthProvider myArray")
         self.runCmd("type synth add -l myIntSynthProvider myIntAndStuff")
 
         if self.TraceOn():
             print(
                 "x_val = %s; y_val = %s; z_val = %s; q_val = %s" %
                 (x_val(), y_val(), z_val(), q_val()))
 
-        self.assertTrue(x_val() == 3, "x != 3 after synthetics")
-        self.assertTrue(y_val() == 4, "y != 4 after synthetics")
-        self.assertTrue(z_val() == 7, "z != 7 after synthetics")
-        self.assertTrue(q_val() == 8, "q != 8 after synthetics")
+        self.assertEqual(x_val(), 3, "x != 3 after synthetics")
+        self.assertEqual(y_val(), 4, "y != 4 after synthetics")
+        self.assertEqual(z_val(), 7, "z != 7 after synthetics")
+        self.assertEqual(q_val(), 8, "q != 8 after synthetics")
 
         self.expect("frame variable x", substrs=['3'])
         self.expect(
             "frame variable x",
             substrs=['theValue = 3'],
             matching=False)
         self.expect("frame variable q", substrs=['8'])
         self.expect(

lldb/test/API/functionalities/data-formatter/vector-types/TestVectorTypesFormatting.py

def test_with_run_command(self):
 
         v = self.frame().FindVariable("v")
         v.SetPreferSyntheticValue(True)
         v.SetFormat(lldb.eFormatVectorOfFloat32)
 
         if self.TraceOn():
             print(v)
 
-        self.assertTrue(
-            v.GetNumChildren() == 4,
+        self.assertEqual(
+            v.GetNumChildren(), 4,
             "v as float32[] has 4 children")
-        self.assertTrue(v.GetChildAtIndex(0).GetData().float[
-                        0] == 1.25, "child 0 == 1.25")
-        self.assertTrue(v.GetChildAtIndex(1).GetData().float[
-                        0] == 1.25, "child 1 == 1.25")
-        self.assertTrue(v.GetChildAtIndex(2).GetData().float[
-                        0] == 2.50, "child 2 == 2.50")
-        self.assertTrue(v.GetChildAtIndex(3).GetData().float[
-                        0] == 2.50, "child 3 == 2.50")
+        self.assertEqual(v.GetChildAtIndex(0).GetData().float[0], 1.25,
+                         "child 0 == 1.25")
+        self.assertEqual(v.GetChildAtIndex(1).GetData().float[0], 1.25,
+                         "child 1 == 1.25")
+        self.assertEqual(v.GetChildAtIndex(2).GetData().float[0], 2.50,
+                         "child 2 == 2.50")
+        self.assertEqual(v.GetChildAtIndex(3).GetData().float[0], 2.50,
+                         "child 3 == 2.50")
 
         self.expect("expr -f int16_t[] -- v",
                     substrs=['(0, 16288, 0, 16288, 0, 16416, 0, 16416)'])
         self.expect("expr -f uint128_t[] -- v",
                     substrs=['(85236745249553456609335044694184296448)'])
         self.expect(
             "expr -f float32[] -- v",
             substrs=['(1.25, 1.25, 2.5, 2.5)'])
 
         oldValue = v.GetChildAtIndex(0).GetValue()
         v.SetFormat(lldb.eFormatHex)
         newValue = v.GetChildAtIndex(0).GetValue()
-        self.assertFalse(oldValue == newValue,
+        self.assertNotEqual(oldValue, newValue,
                             "values did not change along with format")
 
         v.SetFormat(lldb.eFormatVectorOfFloat32)
         oldValueAgain = v.GetChildAtIndex(0).GetValue()
-        self.assertTrue(
-            oldValue == oldValueAgain,
+        self.assertEqual(
+            oldValue, oldValueAgain,
             "same format but different values")

lldb/test/API/functionalities/exec/TestExec.py

def do_test(self, skip_exec):
             def cleanup():
                 self.runCmd("settings set target.process.stop-on-exec false",
                             check=False)
 
             # Execute the cleanup function during test case tear down.
             self.addTearDownHook(cleanup)
 
         # The stop reason of the thread should be breakpoint.
-        self.assertTrue(process.GetState() == lldb.eStateStopped,
+        self.assertEqual(process.GetState(), lldb.eStateStopped,
                         STOPPED_DUE_TO_BREAKPOINT)
 
         threads = lldbutil.get_threads_stopped_at_breakpoint(
         process, breakpoint1)
-        self.assertTrue(len(threads) == 1)
+        self.assertEqual(len(threads), 1)
 
         # We had a deadlock tearing down the TypeSystemMap on exec, but only if some
         # expression had been evaluated.  So make sure we do that here so the teardown
         # is not trivial.
 
         thread = threads[0]
         value = thread.frames[0].EvaluateExpression("1 + 2")
         self.assertTrue(
             value.IsValid(),
             "Expression evaluated successfully")
         int_value = value.GetValueAsSigned()
-        self.assertTrue(int_value == 3, "Expression got the right result.")
+        self.assertEqual(int_value, 3, "Expression got the right result.")
 
         # Run and we should stop due to exec
         process.Continue()
 
         if not skip_exec:
-            self.assertFalse(process.GetState() == lldb.eStateExited,
+            self.assertNotEqual(process.GetState(), lldb.eStateExited,
                                 "Process should not have exited!")
-            self.assertTrue(process.GetState() == lldb.eStateStopped,
+            self.assertEqual(process.GetState(), lldb.eStateStopped,
                              "Process should be stopped at __dyld_start")
 
             threads = lldbutil.get_stopped_threads(
                 process, lldb.eStopReasonExec)
             self.assertTrue(
                 len(threads) == 1,
                 "We got a thread stopped for exec.")
 
             # Run and we should stop at breakpoint in main after exec
             process.Continue()
 
         threads = lldbutil.get_threads_stopped_at_breakpoint(
             process, breakpoint2)
         if self.TraceOn():
             for t in process.threads:
                 print(t)
                 if t.GetStopReason() != lldb.eStopReasonBreakpoint:
                     self.runCmd("bt")
-        self.assertTrue(len(threads) == 1,
+        self.assertEqual(len(threads), 1,
                         "Stopped at breakpoint in exec'ed process.")
 
     @expectedFailureAll(archs=['i386'],
                         oslist=no_match(["freebsd"]),
                         bugnumber="rdar://28656532")
     @expectedFailureAll(oslist=["ios", "tvos", "watchos", "bridgeos"], bugnumber="rdar://problem/34559552") # this exec test has problems on ios systems
     @expectedFailureNetBSD
     @skipIfAsan # rdar://problem/43756823
     @skipIfWindows
     def test_correct_thread_plan_state_before_exec(self):
         '''
         In this test we make sure that the Thread* cache in the ThreadPlans
         is cleared correctly when performing exec
         '''
 
         self.build()
         exe = self.getBuildArtifact("a.out")
         target = self.dbg.CreateTarget(exe)
 
         (target, process, thread, breakpoint1) = lldbutil.run_to_source_breakpoint(
             self, 'Set breakpoint 1 here', lldb.SBFileSpec('main.cpp', False))
 
         # The stop reason of the thread should be breakpoint.
-        self.assertTrue(process.GetState() == lldb.eStateStopped,
+        self.assertEqual(process.GetState(), lldb.eStateStopped,
                         STOPPED_DUE_TO_BREAKPOINT)
 
         threads = lldbutil.get_threads_stopped_at_breakpoint(process, breakpoint1)
-        self.assertTrue(len(threads) == 1)
+        self.assertEqual(len(threads), 1)
 
         # We perform an instruction step, which effectively sets the cache of the base
         # thread plan, which should be cleared when a new thread list appears.
         #
         # Continuing after this instruction step will trigger a call to
         # ThreadPlan::ShouldReportRun, which sets the ThreadPlan's Thread cache to 
         # the old Thread* value. In Process::UpdateThreadList we are clearing this
         # cache in preparation for the new ThreadList.
         #
         # Not doing this stepping will cause LLDB to first execute a private single step
         # past the current breakpoint, which eventually avoids the call to ShouldReportRun,
         # thus not setting the cache to its invalid value.
         thread.StepInstruction(False)
 
         # Run and we should stop due to exec
         breakpoint2 = target.BreakpointCreateBySourceRegex(
             'Set breakpoint 2 here', lldb.SBFileSpec("secondprog.cpp", False))
 
         process.Continue()
 
-        self.assertFalse(process.GetState() == lldb.eStateExited,
+        self.assertNotEqual(process.GetState(), lldb.eStateExited,
                             "Process should not have exited!")
-        self.assertTrue(process.GetState() == lldb.eStateStopped,
+        self.assertEqual(process.GetState(), lldb.eStateStopped,
                          "Process should be stopped at __dyld_start")
 
         threads = lldbutil.get_stopped_threads(
             process, lldb.eStopReasonExec)
         self.assertTrue(
             len(threads) == 1,
             "We got a thread stopped for exec.")
 
         # Run and we should stop at breakpoint in main after exec
         process.Continue()
 
         threads = lldbutil.get_threads_stopped_at_breakpoint(
             process, breakpoint2)
-        self.assertTrue(len(threads) == 1,
+        self.assertEqual(len(threads), 1,
                         "Stopped at breakpoint in exec'ed process.")

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

def test_with_python(self):
         frame = thread.GetFrameAtIndex(0)
         fun_name = frame.GetFunctionName()
         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)
+        #self.assertEqual(in_float, return_float)
 
         if not self.affected_by_radar_34562999() and not self.affected_by_pr44132():
             self.return_and_test_struct_value("return_one_int")
             self.return_and_test_struct_value("return_two_int")
             self.return_and_test_struct_value("return_three_int")
             self.return_and_test_struct_value("return_four_int")
             if not self.affected_by_pr33042():
                 self.return_and_test_struct_value("return_five_int")

lldb/test/API/functionalities/tty/TestTerminal.py

def test_launch_in_terminal(self):
         error = lldb.SBError()
         process = target.Launch(launch_info, error)
         print("Error was: %s."%(error.GetCString()))
         self.assertTrue(
             error.Success(),
             "Make sure launch happened successfully in a terminal window")
         # Running in synchronous mode our process should have run and already
         # exited by the time target.Launch() returns
-        self.assertTrue(process.GetState() == lldb.eStateExited)
+        self.assertEqual(process.GetState(), lldb.eStateExited)

lldb/test/API/functionalities/type_get_module/TestTypeGetModule.py

def test(self):
         target  = lldbutil.run_to_breakpoint_make_target(self)
         exe_module = self.find_module(target, 'a.out')
 
         num_comp_units = exe_module.GetNumCompileUnits()
         self.assertGreaterEqual(num_comp_units, 3)
 
         comp_unit = self.find_comp_unit(exe_module, 'compile_unit1.c')
         cu_type = self.find_type(comp_unit.GetTypes(), 'compile_unit1_type')
-        self.assertTrue(exe_module == cu_type.GetModule())
+        self.assertEqual(exe_module, cu_type.GetModule())
         
         comp_unit = self.find_comp_unit(exe_module, 'compile_unit2.c')
         cu_type = self.find_type(comp_unit.GetTypes(), 'compile_unit2_type')
-        self.assertTrue(exe_module == cu_type.GetModule())
+        self.assertEqual(exe_module, cu_type.GetModule())

lldb/test/API/lang/c/bitfields/TestBitfields.py

def test_and_python_api(self):
         self.DebugSBValue(bits)
         self.assertTrue(
             bits.GetTypeName() == 'Bits',
             "bits.GetTypeName() == 'Bits'")
         self.assertTrue(
             bits.GetNumChildren() == 10,
             "bits.GetNumChildren() == 10")
         test_compiler = self.getCompiler()
-        self.assertTrue(bits.GetByteSize() == 32, "bits.GetByteSize() == 32")
+        self.assertEqual(bits.GetByteSize(), 32, "bits.GetByteSize() == 32")
 
         # Notice the pattern of int(b1.GetValue(), 0).  We pass a base of 0
         # so that the proper radix is determined based on the contents of the
         # string.
         b1 = bits.GetChildMemberWithName("b1")
         self.DebugSBValue(b1)
         self.assertTrue(b1.GetName() == "b1" and
                         b1.GetTypeName() == "uint32_t:1" and

lldb/test/API/lang/c/stepping/TestStepAndBreakpoints.py

def test_and_python_api(self):
         # Now continue and make sure we just complete the step:
         # Disable all our breakpoints first - sometimes the compiler puts two line table entries in for the
         # breakpoint a "b" and we don't want to hit that.
         for bkpt in breakpoints_to_disable:
             bkpt.SetEnabled(False)
 
         process.Continue()
 
-        self.assertTrue(thread.GetFrameAtIndex(0).GetFunctionName() == "a")
-        self.assertTrue(thread.GetStopReason() == lldb.eStopReasonPlanComplete)
+        self.assertEqual(thread.GetFrameAtIndex(0).GetFunctionName(), "a")
+        self.assertEqual(thread.GetStopReason(), lldb.eStopReasonPlanComplete)
 
         # And one more time should get us back to main:
         process.Continue()
 
-        self.assertTrue(thread.GetFrameAtIndex(0).GetFunctionName() == "main")
-        self.assertTrue(thread.GetStopReason() == lldb.eStopReasonPlanComplete)
+        self.assertEqual(thread.GetFrameAtIndex(0).GetFunctionName(), "main")
+        self.assertEqual(thread.GetStopReason(), lldb.eStopReasonPlanComplete)
 
         # Now make sure we can call a function, break in the called function,
         # then have "continue" get us back out again:
         frame = thread.GetFrameAtIndex(0)
         frame = thread.GetFrameAtIndex(0)
         current_line = frame.GetLineEntry().GetLine()
         current_file = frame.GetLineEntry().GetFileSpec()
 
def test_and_python_api(self):
         self.assertTrue(break_before_complex_3, VALID_BREAKPOINT)
 
         break_before_complex_4 = target.BreakpointCreateBySourceRegex(
             '// Stop here to make sure bogus target steps over.', self.main_source_spec)
         self.assertTrue(break_before_complex_4, VALID_BREAKPOINT)
 
         threads = lldbutil.continue_to_breakpoint(
             process, break_before_complex_1)
-        self.assertTrue(len(threads) == 1)
+        self.assertEqual(len(threads), 1)
         thread = threads[0]
         break_before_complex_1.SetEnabled(False)
 
         thread.StepInto("b")
-        self.assertTrue(thread.GetFrameAtIndex(0).GetFunctionName() == "b")
+        self.assertEqual(thread.GetFrameAtIndex(0).GetFunctionName(), "b")
 
         # Now continue out and stop at the next call to complex.  This time
         # step all the way into complex:
         threads = lldbutil.continue_to_breakpoint(
             process, break_before_complex_2)
-        self.assertTrue(len(threads) == 1)
+        self.assertEqual(len(threads), 1)
         thread = threads[0]
         break_before_complex_2.SetEnabled(False)
 
         thread.StepInto("complex")
         self.assertTrue(thread.GetFrameAtIndex(
             0).GetFunctionName() == "complex")
 
         # Now continue out and stop at the next call to complex.  This time
         # enable breakpoints in a and c and then step targeting b:
         threads = lldbutil.continue_to_breakpoint(
             process, break_before_complex_3)
-        self.assertTrue(len(threads) == 1)
+        self.assertEqual(len(threads), 1)
         thread = threads[0]
         break_before_complex_3.SetEnabled(False)
 
         break_at_start_of_a = target.BreakpointCreateByName('a')
         break_at_start_of_c = target.BreakpointCreateByName('c')
 
         thread.StepInto("b")
         threads = lldbutil.get_stopped_threads(
             process, lldb.eStopReasonBreakpoint)
 
-        self.assertTrue(len(threads) == 1)
+        self.assertEqual(len(threads), 1)
         thread = threads[0]
         stop_break_id = thread.GetStopReasonDataAtIndex(0)
         self.assertTrue(stop_break_id == break_at_start_of_a.GetID()
                         or stop_break_id == break_at_start_of_c.GetID())
 
         break_at_start_of_a.SetEnabled(False)
         break_at_start_of_c.SetEnabled(False)
 
         process.Continue()
-        self.assertTrue(thread.GetFrameAtIndex(0).GetFunctionName() == "b")
+        self.assertEqual(thread.GetFrameAtIndex(0).GetFunctionName(), "b")
 
         # Now continue out and stop at the next call to complex.  This time
         # enable breakpoints in a and c and then step targeting b:
         threads = lldbutil.continue_to_breakpoint(
             process, break_before_complex_4)
-        self.assertTrue(len(threads) == 1)
+        self.assertEqual(len(threads), 1)
         thread = threads[0]
         break_before_complex_4.SetEnabled(False)
 
         thread.StepInto("NoSuchFunction")
-        self.assertTrue(thread.GetFrameAtIndex(0).GetFunctionName() == "main")
+        self.assertEqual(thread.GetFrameAtIndex(0).GetFunctionName(), "main")

lldb/test/API/lang/cpp/class_static/TestStaticVariables.py

def test_with_python_api(self):
                 child1_x = child1.GetChildAtIndex(0)
                 self.DebugSBValue(child1_x)
                 self.assertTrue(child1_x.GetTypeName() == 'int' and
                                 child1_x.GetValue() == '11')
 
         # SBFrame.FindValue() should also work.
         val = frame.FindValue("A::g_points", lldb.eValueTypeVariableGlobal)
         self.DebugSBValue(val)
-        self.assertTrue(val.GetName() == 'A::g_points')
+        self.assertEqual(val.GetName(), 'A::g_points')
 
         # Also exercise the "parameter" and "local" scopes while we are at it.
         val = frame.FindValue("argc", lldb.eValueTypeVariableArgument)
         self.DebugSBValue(val)
-        self.assertTrue(val.GetName() == 'argc')
+        self.assertEqual(val.GetName(), 'argc')
 
         val = frame.FindValue("argv", lldb.eValueTypeVariableArgument)
         self.DebugSBValue(val)
-        self.assertTrue(val.GetName() == 'argv')
+        self.assertEqual(val.GetName(), 'argv')
 
         val = frame.FindValue("hello_world", lldb.eValueTypeVariableLocal)
         self.DebugSBValue(val)
-        self.assertTrue(val.GetName() == 'hello_world')
+        self.assertEqual(val.GetName(), 'hello_world')

lldb/test/API/lang/cpp/class_types/TestClassTypes.py

def test_with_python_api(self):
         self.expect("%s:%d" % (lldbutil.get_filenames(thread)[0],
                                lldbutil.get_line_numbers(thread)[0]),
                     "Break correctly at main.cpp:%d" % self.line, exe=False,
                     startstr="main.cpp:")
         # clang compiled code reported main.cpp:94?
         # startstr = "main.cpp:93")
 
         # We should be stopped on the breakpoint with a hit count of 1.
-        self.assertTrue(breakpoint.GetHitCount() == 1, BREAKPOINT_HIT_ONCE)
+        self.assertEqual(breakpoint.GetHitCount(), 1, BREAKPOINT_HIT_ONCE)
 
         process.Continue()
 
     def test_with_expr_parser(self):
         """Test 'frame variable this' and 'expr this' when stopped inside a constructor."""
         self.build()
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)

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

def do_sbvalue_cast(self, exe_name):
 
         breakpoint = target.BreakpointCreateByLocation(self.source, self.line)
         self.assertTrue(breakpoint, 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.assertEqual(process.GetState(), lldb.eStateStopped,
                         PROCESS_STOPPED)
 
         # Find DerivedA and DerivedB types.
         typeA = target.FindFirstType('DerivedA')
         typeB = target.FindFirstType('DerivedB')
         self.DebugSBType(typeA)
         self.DebugSBType(typeB)
         self.assertTrue(typeA)
         self.assertTrue(typeB)
         error = lldb.SBError()
 
         # First stop is for DerivedA instance.
         threads = lldbutil.get_threads_stopped_at_breakpoint(
             process, breakpoint)
-        self.assertTrue(len(threads) == 1)
+        self.assertEqual(len(threads), 1)
         thread = threads[0]
         frame0 = thread.GetFrameAtIndex(0)
 
         tellerA = frame0.FindVariable('teller', lldb.eNoDynamicValues)
         self.DebugSBValue(tellerA)
         self.assertTrue(tellerA.GetChildMemberWithName(
             'm_base_val').GetValueAsUnsigned(error, 0) == 20)
 
         if self.TraceOn():
             for child in tellerA:
                 print("child name:", child.GetName())
                 print(child)
 
         # Call SBValue.Cast() to obtain instanceA.
         instanceA = tellerA.Cast(typeA.GetPointerType())
         self.DebugSBValue(instanceA)
 
         # Iterate through all the children and print their values.
         if self.TraceOn():
             for child in instanceA:
                 print("child name:", child.GetName())
                 print(child)
         a_member_val = instanceA.GetChildMemberWithName('m_a_val')
         self.DebugSBValue(a_member_val)
-        self.assertTrue(a_member_val.GetValueAsUnsigned(error, 0) == 10)
+        self.assertEqual(a_member_val.GetValueAsUnsigned(error, 0), 10)
 
         # Second stop is for DerivedB instance.
         threads = lldbutil.continue_to_breakpoint(process, breakpoint)
-        self.assertTrue(len(threads) == 1)
+        self.assertEqual(len(threads), 1)
         thread = threads[0]
         frame0 = thread.GetFrameAtIndex(0)
 
         tellerB = frame0.FindVariable('teller', lldb.eNoDynamicValues)
         self.DebugSBValue(tellerB)
         self.assertTrue(tellerB.GetChildMemberWithName(
             'm_base_val').GetValueAsUnsigned(error, 0) == 12)
 
         if self.TraceOn():
             for child in tellerB:
                 print("child name:", child.GetName())
                 print(child)
 
         # Call SBValue.Cast() to obtain instanceB.
         instanceB = tellerB.Cast(typeB.GetPointerType())
         self.DebugSBValue(instanceB)
 
         # Iterate through all the children and print their values.
         if self.TraceOn():
             for child in instanceB:
                 print("child name:", child.GetName())
                 print(child)
         b_member_val = instanceB.GetChildMemberWithName('m_b_val')
         self.DebugSBValue(b_member_val)
-        self.assertTrue(b_member_val.GetValueAsUnsigned(error, 0) == 36)
+        self.assertEqual(b_member_val.GetValueAsUnsigned(error, 0), 36)

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

def test_enum_args(self):
         frame = self.prepareProcess()
 
         # Make sure "member" can be displayed and also used in an expression
         # correctly
         member = frame.FindVariable('member')
         self.assertTrue(
             member.IsValid(),
             'make sure we find a local variabble named "member"')
-        self.assertTrue(member.GetType().GetName() ==
+        self.assertEqual(member.GetType().GetName(),
                         'EnumTemplate<EnumType::Member>')
 
         expr_result = frame.EvaluateExpression("member.getMember()")
         self.assertTrue(
             expr_result.IsValid(),
             'got a valid expression result from expression "member.getMember()"')
         self.assertTrue(
             expr_result.GetValue() == "123",
             "member.getMember() == 123")
         self.assertTrue(
             expr_result.GetType().GetName() == "int",
             'expr_result.GetType().GetName() == "int"')
 
         # Make sure "subclass" can be displayed and also used in an expression
         # correctly
         subclass = frame.FindVariable('subclass')
         self.assertTrue(
             subclass.IsValid(),
             'make sure we find a local variabble named "subclass"')
-        self.assertTrue(subclass.GetType().GetName() ==
+        self.assertEqual(subclass.GetType().GetName(),
                         'EnumTemplate<EnumType::Subclass>')
 
         expr_result = frame.EvaluateExpression("subclass.getMember()")
         self.assertTrue(
             expr_result.IsValid(),
             'got a valid expression result from expression "subclass.getMember()"')
         self.assertTrue(
             expr_result.GetValue() == "246",
             "subclass.getMember() == 246")
         self.assertTrue(
             expr_result.GetType().GetName() == "int",
             'expr_result.GetType().GetName() == "int"')

lldb/test/API/lang/objc/blocks/TestObjCIvarsInBlocks.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.assertEqual(len(thread_list), 1)
         thread = thread_list[0]
 
         frame = thread.GetFrameAtIndex(0)
         self.assertTrue(frame, "frame 0 is valid")
 
         # First use the FindVariable API to see if we can find the ivar by
         # undecorated name:
         direct_blocky = frame.GetValueForVariablePath("blocky_ivar")
def test_with_python_api(self):
 
         process.Continue()
         self.assertTrue(
             process.GetState() == lldb.eStateStopped,
             "Stopped at the second breakpoint.")
 
         thread_list = lldbutil.get_threads_stopped_at_breakpoint(
             process, breakpoint_two)
-        self.assertTrue(len(thread_list) == 1)
+        self.assertEqual(len(thread_list), 1)
         thread = thread_list[0]
 
         frame = thread.GetFrameAtIndex(0)
         self.assertTrue(frame, "frame 0 is valid")
 
         expr = frame.EvaluateExpression("(ret)")
         self.assertTrue(
             expr, "Successfully got a local variable in a block in a class method.")
 
         ret_value_signed = expr.GetValueAsSigned(error)
         self.trace('ret_value_signed = %i' % (ret_value_signed))
         self.assertTrue(
             ret_value_signed == 5,
             "The local variable in the block was what we expected.")

lldb/test/API/lang/objc/foundation/TestObjCMethods.py

def test_print_ivars_correctly(self):
             self.fail(STOPPED_DUE_TO_BREAKPOINT_WITH_STOP_REASON_AS %
                       stop_reason_to_str(thread.GetStopReason()))
 
         # Make sure we stopped at the first breakpoint.
 
         cur_frame = thread.GetFrameAtIndex(0)
 
         line_number = cur_frame.GetLineEntry().GetLine()
-        self.assertTrue(line_number == self.line, "Hit the first breakpoint.")
+        self.assertEqual(line_number, self.line, "Hit the first breakpoint.")
 
         my_var = cur_frame.FindVariable("my")
         self.assertTrue(my_var, "Made a variable object for my")
 
         str_var = cur_frame.FindVariable("str")
         self.assertTrue(str_var, "Made a variable object for str")
 
         # Now make sure that the my->str == str:
def test_expression_lookups_objc(self):
             num_errors = 0
             for line in lines:
                 if "$__lldb" in line:
                     if num_errors == 0:
                         print(
                             "error: found spurious name lookups when evaluating an expression:")
                     num_errors += 1
                     print(line, end='')
-            self.assertTrue(num_errors == 0, "Spurious lookups detected")
+            self.assertEqual(num_errors, 0, "Spurious lookups detected")
             f.close()

lldb/test/API/lang/objc/foundation/TestObjectDescriptionAPI.py

def test_find_global_variables_then_object_description(self):
 
         # 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)
         # Make sure we hit our breakpoint:
         thread_list = lldbutil.get_threads_stopped_at_breakpoint(
             process, breakpoint)
-        self.assertTrue(len(thread_list) == 1)
+        self.assertEqual(len(thread_list), 1)
 
         thread = thread_list[0]
         frame0 = thread.GetFrameAtIndex(0)
 
         # Note my_global_str's object description prints fine here.
         value_list1 = frame0.GetVariables(True, True, True, True)
         for v in value_list1:
             self.DebugSBValue(v)
             if self.TraceOn():
                 print("val:", v)
                 print("object description:", v.GetObjectDescription())
             if v.GetName() == 'my_global_str':
-                self.assertTrue(v.GetObjectDescription() ==
+                self.assertEqual(v.GetObjectDescription(),
                                 'This is a global string')
 
         # But not here!
         value_list2 = target.FindGlobalVariables('my_global_str', 3)
         for v in value_list2:
             self.DebugSBValue(v)
             if self.TraceOn():
                 print("val:", v)
                 print("object description:", v.GetObjectDescription())
             if v.GetName() == 'my_global_str':
-                self.assertTrue(v.GetObjectDescription() ==
+                self.assertEqual(v.GetObjectDescription(),
                                 'This is a global string')

lldb/test/API/lang/objc/foundation/TestSymbolTable.py

def test_with_python_api(self):
             name = symbol.GetName()
             if name in expected_symbols:
                 self.trace("Removing %s from known_symbols %s" % (name, expected_symbols))
                 expected_symbols.remove(name)
 
         # At this point, the known_symbols set should have become an empty set.
         # If not, raise an error.
         self.trace("symbols unaccounted for:", expected_symbols)
-        self.assertTrue(len(expected_symbols) == 0,
+        self.assertEqual(len(expected_symbols), 0,
                         "All the known symbols are accounted for")

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

def test_objc_checker(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.assertEqual(process.GetState(), lldb.eStateStopped,
                         PROCESS_STOPPED)
 
         threads = lldbutil.get_threads_stopped_at_breakpoint(
             process, main_bkpt)
-        self.assertTrue(len(threads) == 1)
+        self.assertEqual(len(threads), 1)
         thread = threads[0]
 
         #
         #  The class Simple doesn't have a count method.  Make sure that we don't
         #  actually try to send count but catch it as an unrecognized selector.
 
         frame = thread.GetFrameAtIndex(0)
         expr_value = frame.EvaluateExpression("(int) [my_simple count]", False)

lldb/test/API/lang/objc/objc-class-method/TestObjCClassMethod.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.assertEqual(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(
             "(int)[Foo doSomethingWithString:@\"Hello\"]")
         if self.TraceOn():
             if cmd_value.IsValid():
                 print("cmd_value is valid")
                 print("cmd_value has the value %d" % cmd_value.GetValueAsUnsigned())
         self.assertTrue(cmd_value.IsValid())
-        self.assertTrue(cmd_value.GetValueAsUnsigned() == 5)
+        self.assertEqual(cmd_value.GetValueAsUnsigned(), 5)

lldb/test/API/python_api/disassemble-raw-data/TestDisassembleRawData.py

def test_disassemble_raw_data(self):
 
         inst = insts.GetInstructionAtIndex(0)
 
         if self.TraceOn():
             print()
             print("Raw bytes:    ", [hex(x) for x in raw_bytes])
             print("Disassembled%s" % str(inst))
         if re.match("mips", arch):
-            self.assertTrue(inst.GetMnemonic(target) == "move")
-            self.assertTrue(inst.GetOperands(target) ==
+            self.assertEqual(inst.GetMnemonic(target), "move")
+            self.assertEqual(inst.GetOperands(target),
                             '$' + "fp, " + '$' + "sp")
         elif re.match("powerpc64le", arch):
-            self.assertTrue(inst.GetMnemonic(target) == "li")
-            self.assertTrue(inst.GetOperands(target) == "4, 0")
+            self.assertEqual(inst.GetMnemonic(target), "li")
+            self.assertEqual(inst.GetOperands(target), "4, 0")
         else:
-            self.assertTrue(inst.GetMnemonic(target) == "movq")
-            self.assertTrue(inst.GetOperands(target) ==
+            self.assertEqual(inst.GetMnemonic(target), "movq")
+            self.assertEqual(inst.GetOperands(target),
                             '%' + "rsp, " + '%' + "rbp")

lldb/test/API/python_api/disassemble-raw-data/TestDisassemble_VST1_64.py

def test_disassemble_invalid_vst_1_64_raw_data(self):
 
         inst = insts.GetInstructionAtIndex(0)
 
         if self.TraceOn():
             print()
             print("Raw bytes:    ", [hex(x) for x in raw_bytes])
             print("Disassembled%s" % str(inst))
 
-        self.assertTrue(inst.GetMnemonic(target) == "vst1.64")
+        self.assertEqual(inst.GetMnemonic(target), "vst1.64")

lldb/test/API/python_api/event/TestEvents.py

def test_add_listener_to_broadcaster(self):
         # the 'state' variable.
         my_thread.context = self
         my_thread.start()
 
         # Wait until the 'MyListeningThread' terminates.
         my_thread.join()
 
         # The final judgement. :-)
-        self.assertTrue(self.state == 'stopped',
+        self.assertEqual(self.state, 'stopped',
                         "Both expected state changed events received")

lldb/test/API/python_api/frame/TestFrames.py

def test_get_arg_vals_for_call_stack(self):
                         breakpoint.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())
 
         process = target.GetProcess()
-        self.assertTrue(process.GetState() == lldb.eStateStopped,
+        self.assertEqual(process.GetState(), lldb.eStateStopped,
                         PROCESS_STOPPED)
 
         # Keeps track of the number of times 'a' is called where it is within a
         # depth of 3 of the 'c' leaf function.
         callsOfA = 0
 
         from six import StringIO as SixStringIO
         session = SixStringIO()
def test_get_arg_vals_for_call_stack(self):
                 # instruction as PC.
                 if self.getArchitecture() in ['arm', 'armv7', 'armv7k']:
                     pc_value_int &= ~1
                 self.assertTrue(
                     pc_value_int == frame.GetPC(),
                     "PC gotten as a value should equal frame's GetPC")
                 sp_value = gpr_reg_set.GetChildMemberWithName("sp")
                 self.assertTrue(
                     sp_value, "We should have a valid Stack Pointer.")
-                self.assertTrue(int(sp_value.GetValue(), 0) == frame.GetSP(
-                ), "SP gotten as a value should equal frame's GetSP")
+                self.assertEqual(
+                    int(sp_value.GetValue(), 0), frame.GetSP(),
+                    "SP gotten as a value should equal frame's GetSP")
 
             print("---", file=session)
             process.Continue()
 
         # At this point, the inferior process should have exited.
         self.assertTrue(
             process.GetState() == lldb.eStateExited,
             PROCESS_EXITED)
 
         # Expect to find 'a' on the call stacks two times.
-        self.assertTrue(callsOfA == 2,
+        self.assertEqual(callsOfA, 2,
                         "Expect to find 'a' on the call stacks two times")
         # By design, the 'a' call frame has the following arg vals:
         #     o a((int)val=1, (char)ch='A')
         #     o a((int)val=3, (char)ch='A')
         if self.TraceOn():
             print("Full stack traces when stopped on the breakpoint 'c':")
             print(session.getvalue())
         self.expect(session.getvalue(), "Argument values displayed correctly",
def test_frame_api_boundary_condition(self):
                         breakpoint.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())
 
         process = target.GetProcess()
-        self.assertTrue(process.GetState() == lldb.eStateStopped,
+        self.assertEqual(process.GetState(), lldb.eStateStopped,
                         PROCESS_STOPPED)
 
         thread = lldbutil.get_stopped_thread(
             process, lldb.eStopReasonBreakpoint)
         self.assertIsNotNone(thread)
         frame = thread.GetFrameAtIndex(0)
         if self.TraceOn():
             print("frame:", frame)
def test_frame_api_IsEqual(self):
                         breakpoint.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())
 
         process = target.GetProcess()
-        self.assertTrue(process.GetState() == lldb.eStateStopped,
+        self.assertEqual(process.GetState(), lldb.eStateStopped,
                         PROCESS_STOPPED)
 
         thread = lldbutil.get_stopped_thread(
             process, lldb.eStopReasonBreakpoint)
         self.assertIsNotNone(thread)
 
         frameEntered = thread.GetFrameAtIndex(0)
         if self.TraceOn():

lldb/test/API/python_api/frame/inlines/TestInlinedFrame.py

def test_stop_at_outer_inline(self):
                         breakpoint.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())
 
         process = target.GetProcess()
-        self.assertTrue(process.GetState() == lldb.eStateStopped,
+        self.assertEqual(process.GetState(), lldb.eStateStopped,
                         PROCESS_STOPPED)
 
         import lldbsuite.test.lldbutil as lldbutil
         stack_traces1 = lldbutil.print_stacktraces(process, string_buffer=True)
         if self.TraceOn():
             print(
                 "Full stack traces when first stopped on the breakpoint 'inner_inline':")
             print(stack_traces1)
 
         # The first breakpoint should correspond to an inlined call frame.
         # If it's an inlined call frame, expect to find, in the stack trace,
         # that there is a frame which corresponds to the following call site:
         #
         #     outer_inline (argc);
         #
         thread = lldbutil.get_stopped_thread(
             process, lldb.eStopReasonBreakpoint)
         self.assertIsNotNone(thread)
 
         frame0 = thread.GetFrameAtIndex(0)
         if frame0.IsInlined():
             filename = frame0.GetLineEntry().GetFileSpec().GetFilename()
-            self.assertTrue(filename == self.source)
+            self.assertEqual(filename, self.source)
             self.expect(
                 stack_traces1, "First stop at %s:%d" %
                 (self.source, self.first_stop), exe=False, substrs=[
                     '%s:%d' %
                     (self.source, self.first_stop)])
 
             # Expect to break again for the second time.
             process.Continue()
-            self.assertTrue(process.GetState() == lldb.eStateStopped,
+            self.assertEqual(process.GetState(), lldb.eStateStopped,
                             PROCESS_STOPPED)
             stack_traces2 = lldbutil.print_stacktraces(
                 process, string_buffer=True)
             if self.TraceOn():
                 print(
                     "Full stack traces when stopped on the breakpoint 'inner_inline' for the second time:")
                 print(stack_traces2)
                 self.expect(
                     stack_traces2, "Second stop at %s:%d" %
                     (self.source, self.second_stop), exe=False, substrs=[
                         '%s:%d' %
                         (self.source, self.second_stop)])

lldb/test/API/python_api/function_symbol/TestDisasmAPI.py

def test(self):
                         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)
 
         # Frame #0 should be on self.line1.
-        self.assertTrue(process.GetState() == lldb.eStateStopped)
+        self.assertEqual(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)
         lineEntry = frame0.GetLineEntry()
-        self.assertTrue(lineEntry.GetLine() == self.line1)
+        self.assertEqual(lineEntry.GetLine(), self.line1)
 
         address1 = lineEntry.GetStartAddress()
         self.trace("address1:", address1)
 
         # Now call SBTarget.ResolveSymbolContextForAddress() with address1.
         context1 = target.ResolveSymbolContextForAddress(
             address1, lldb.eSymbolContextEverything)
 
         self.assertTrue(context1)
         if self.TraceOn():
             print("context1:", context1)
 
         # Continue the inferior, the breakpoint 2 should be hit.
         process.Continue()
-        self.assertTrue(process.GetState() == lldb.eStateStopped)
+        self.assertEqual(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)
         lineEntry = frame0.GetLineEntry()
-        self.assertTrue(lineEntry.GetLine() == self.line2)
+        self.assertEqual(lineEntry.GetLine(), self.line2)
 
         # Verify that the symbol and the function has the same address range
         # per function 'a'.
         symbol = context1.GetSymbol()
         function = frame0.GetFunction()
         self.assertTrue(symbol and function)
 
         disasm_output = lldbutil.disassemble(target, symbol)

lldb/test/API/python_api/function_symbol/TestSymbolAPI.py

def test(self):
                         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)
 
         # Frame #0 should be on self.line1.
-        self.assertTrue(process.GetState() == lldb.eStateStopped)
+        self.assertEqual(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)
         symbol_line1 = frame0.GetSymbol()
         # We should have a symbol type of code.
-        self.assertTrue(symbol_line1.GetType() == lldb.eSymbolTypeCode)
+        self.assertEqual(symbol_line1.GetType(), lldb.eSymbolTypeCode)
         addr_line1 = symbol_line1.GetStartAddress()
         # And a section type of code, too.
         self.assertTrue(addr_line1.GetSection().GetSectionType()
                         == lldb.eSectionTypeCode)
 
         # Continue the inferior, the breakpoint 2 should be hit.
         process.Continue()
-        self.assertTrue(process.GetState() == lldb.eStateStopped)
+        self.assertEqual(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)
         symbol_line2 = frame0.GetSymbol()
         # We should have a symbol type of code.
-        self.assertTrue(symbol_line2.GetType() == lldb.eSymbolTypeCode)
+        self.assertEqual(symbol_line2.GetType(), lldb.eSymbolTypeCode)
         addr_line2 = symbol_line2.GetStartAddress()
         # And a section type of code, too.
         self.assertTrue(addr_line2.GetSection().GetSectionType()
                         == lldb.eSectionTypeCode)
 
         # Now verify that both addresses point to the same module.
         if self.TraceOn():
             print("UUID:", addr_line1.GetModule().GetUUIDString())
         self.assertTrue(addr_line1.GetModule().GetUUIDString()
                         == addr_line2.GetModule().GetUUIDString())

lldb/test/API/python_api/lldbutil/frame/TestFrameUtils.py

def test_frame_utils(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())
 
         if not process:
             self.fail("SBTarget.LaunchProcess() failed")
-        self.assertTrue(process.GetState() == lldb.eStateStopped,
+        self.assertEqual(process.GetState(), lldb.eStateStopped,
                         PROCESS_STOPPED)
 
         import lldbsuite.test.lldbutil as lldbutil
         thread = lldbutil.get_stopped_thread(
             process, lldb.eStopReasonBreakpoint)
         self.assertTrue(thread)
         frame0 = thread.GetFrameAtIndex(0)
         self.assertTrue(frame0)

lldb/test/API/python_api/lldbutil/iter/TestLLDBIterator.py

def test_lldb_iter_module(self):
         from lldbsuite.test.lldbutil import get_description
         yours = []
         for i in range(target.GetNumModules()):
             yours.append(target.GetModuleAtIndex(i))
         mine = []
         for m in target.module_iter():
             mine.append(m)
 
-        self.assertTrue(len(yours) == len(mine))
+        self.assertEqual(len(yours), len(mine))
         for i in range(len(yours)):
             if self.TraceOn():
                 print("yours[%d]='%s'" % (i, get_description(yours[i])))
                 print("mine[%d]='%s'" % (i, get_description(mine[i])))
             self.assertTrue(
                 yours[i] == mine[i],
                 "UUID+FileSpec of yours[{0}] and mine[{0}] matches".format(i))
 
     @add_test_categories(['pyapi'])
     def test_lldb_iter_breakpoint(self):
         """Test breakpoint_iter works correctly for SBTarget -> SBBreakpoint."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         breakpoint = target.BreakpointCreateByLocation("main.cpp", self.line1)
         self.assertTrue(breakpoint, VALID_BREAKPOINT)
         breakpoint = target.BreakpointCreateByLocation("main.cpp", self.line2)
         self.assertTrue(breakpoint, VALID_BREAKPOINT)
 
-        self.assertTrue(target.GetNumBreakpoints() == 2)
+        self.assertEqual(target.GetNumBreakpoints(), 2)
 
         from lldbsuite.test.lldbutil import get_description
         yours = []
         for i in range(target.GetNumBreakpoints()):
             yours.append(target.GetBreakpointAtIndex(i))
         mine = []
         for b in target.breakpoint_iter():
             mine.append(b)
 
-        self.assertTrue(len(yours) == len(mine))
+        self.assertEqual(len(yours), len(mine))
         for i in range(len(yours)):
             if self.TraceOn():
                 print("yours[%d]='%s'" % (i, get_description(yours[i])))
                 print("mine[%d]='%s'" % (i, get_description(mine[i])))
-            self.assertTrue(yours[i] == mine[i],
+            self.assertEqual(yours[i], mine[i],
                             "ID of yours[{0}] and mine[{0}] matches".format(i))
 
     @add_test_categories(['pyapi'])
     def test_lldb_iter_frame(self):
         """Test iterator works correctly for SBProcess->SBThread->SBFrame."""
         self.build()
         exe = self.getBuildArtifact("a.out")
 
def test_lldb_iter_frame(self):
         stopped_due_to_breakpoint = False
         for thread in process:
             if self.TraceOn():
                 print_stacktrace(thread)
             ID = thread.GetThreadID()
             if thread.GetStopReason() == lldb.eStopReasonBreakpoint:
                 stopped_due_to_breakpoint = True
             for frame in thread:
-                self.assertTrue(frame.GetThread().GetThreadID() == ID)
+                self.assertEqual(frame.GetThread().GetThreadID(), ID)
                 if self.TraceOn():
                     print(frame)
 
         self.assertTrue(stopped_due_to_breakpoint)

lldb/test/API/python_api/process/io/TestProcessIO.py

def run_process(self, put_stdin):
 
         if self.TraceOn():
             print("process launched.")
 
         # Frame #0 should be at our breakpoint.
         threads = lldbutil.get_threads_stopped_at_breakpoint(
             self.process, self.breakpoint)
 
-        self.assertTrue(len(threads) == 1)
+        self.assertEqual(len(threads), 1)
         self.thread = threads[0]
         self.frame = self.thread.frames[0]
         self.assertTrue(self.frame, "Frame 0 is valid.")
 
         if self.TraceOn():
             print("process stopped at breakpoint, sending STDIN via LLDB API.")
 
         # Write data to stdin via the public API if we were asked to
         if put_stdin:
             for line in self.lines:
                 self.process.PutSTDIN(line + "\n")
 
         # Let process continue so it will exit
         self.process.Continue()
         state = self.process.GetState()
-        self.assertTrue(state == lldb.eStateExited, PROCESS_IS_VALID)
+        self.assertEqual(state, lldb.eStateExited, PROCESS_IS_VALID)
 
     def check_process_output(self, output, error):
             # Since we launched the process without specifying stdin/out/err,
             # a pseudo terminal is used for stdout/err, and we are satisfied
             # once "input line=>1" appears in stdout.
             # See also main.c.
         if self.TraceOn():
             print("output = '%s'" % output)

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

def test_read_memory_c_string(self):
         invalid_memory_str_addr = frame.FindVariable("invalid_memory_string").GetValueAsUnsigned(err)
         self.assertTrue(err.Success())
         self.assertTrue(invalid_memory_str_addr != lldb.LLDB_INVALID_ADDRESS)
 
         # Important:  An empty (0-length) c-string must come back as a Python string, not a
         # None object.
         empty_str = process.ReadCStringFromMemory(empty_str_addr, 2048, err)
         self.assertTrue(err.Success())
-        self.assertTrue(empty_str == "")
+        self.assertEqual(empty_str, "")
 
         one_letter_string = process.ReadCStringFromMemory(one_letter_str_addr, 2048, err)
         self.assertTrue(err.Success())
-        self.assertTrue(one_letter_string == "1")
+        self.assertEqual(one_letter_string, "1")
 
         invalid_memory_string = process.ReadCStringFromMemory(invalid_memory_str_addr, 2048, err)
         self.assertTrue(err.Fail())
         self.assertTrue(invalid_memory_string == "" or invalid_memory_string == None)

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

class SBDataAPICase(TestBase):
     def test_byte_order_and_address_byte_size(self):
         """Test the SBData::SetData() to ensure the byte order and address
         byte size are obeyed"""
         addr_data = b'\x11\x22\x33\x44\x55\x66\x77\x88'
         error = lldb.SBError()
         data = lldb.SBData()
         data.SetData(error, addr_data, lldb.eByteOrderBig, 4)
         addr = data.GetAddress(error, 0)
-        self.assertTrue(addr == 0x11223344);
+        self.assertEqual(addr, 0x11223344);
         data.SetData(error, addr_data, lldb.eByteOrderBig, 8)
         addr = data.GetAddress(error, 0)
-        self.assertTrue(addr == 0x1122334455667788);
+        self.assertEqual(addr, 0x1122334455667788);
         data.SetData(error, addr_data, lldb.eByteOrderLittle, 4)
         addr = data.GetAddress(error, 0)
-        self.assertTrue(addr == 0x44332211);
+        self.assertEqual(addr, 0x44332211);
         data.SetData(error, addr_data, lldb.eByteOrderLittle, 8)
         addr = data.GetAddress(error, 0)
-        self.assertTrue(addr == 0x8877665544332211);
+        self.assertEqual(addr, 0x8877665544332211);
 
     @add_test_categories(['pyapi'])
     @skipIfReproducer # SBData::SetData is not instrumented.
     def test_with_run_command(self):
         """Test the SBData APIs."""
         self.build()
         self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
 
def test_with_run_command(self):
             "nothing", foobar_addr, star_foobar.GetType().GetBasicType(
                 lldb.eBasicTypeInvalid))
 
         new_foobar = foobar.CreateValueFromAddress(
             "f00", foobar_addr, star_foobar.GetType())
         self.assertTrue(new_foobar.IsValid())
         data = new_foobar.GetData()
 
-        self.assertTrue(data.uint32[0] == 8, 'then foo[1].a == 8')
-        self.assertTrue(data.uint32[1] == 7, 'then foo[1].b == 7')
+        self.assertEqual(data.uint32[0], 8, 'then foo[1].a == 8')
+        self.assertEqual(data.uint32[1], 7, 'then foo[1].b == 7')
         # exploiting that sizeof(uint32) == sizeof(float)
         self.assertTrue(fabs(data.float[2] - 3.14) < 1, 'foo[1].c == 3.14')
 
         self.runCmd("n")
 
         offset = 0
         self.assert_data(data.GetUnsignedInt32, offset, 8)
         offset += 4
def test_with_run_command(self):
                     offset) -
                 6) < 1,
             'barfoo[1].c == 6')
         self.assertTrue(error.Success())
 
         new_object = barfoo.CreateValueFromData(
             "new_object", data, barfoo.GetType().GetBasicType(
                 lldb.eBasicTypeInt))
-        self.assertTrue(new_object.GetValue() == "1", 'new_object == 1')
+        self.assertEqual(new_object.GetValue(), "1", 'new_object == 1')
 
         if data.GetByteOrder() == lldb.eByteOrderBig:
             data.SetData(
                 error,
                 '\0\0\0A',
                 data.GetByteOrder(),
                 data.GetAddressByteSize())
         else:
def test_with_run_command(self):
 
         # check the new API calls introduced per LLVM llvm.org/prenhancement request
         # 11619 (Allow creating SBData values from arrays or primitives in
         # Python)
 
         hello_str = "hello!"
         data2 = lldb.SBData.CreateDataFromCString(
             process.GetByteOrder(), process.GetAddressByteSize(), hello_str)
-        self.assertTrue(len(data2.uint8) == len(hello_str))
-        self.assertTrue(data2.uint8[0] == 104, 'h == 104')
-        self.assertTrue(data2.uint8[1] == 101, 'e == 101')
-        self.assertTrue(data2.uint8[2] == 108, 'l == 108')
+        self.assertEqual(len(data2.uint8), len(hello_str))
+        self.assertEqual(data2.uint8[0], 104, 'h == 104')
+        self.assertEqual(data2.uint8[1], 101, 'e == 101')
+        self.assertEqual(data2.uint8[2], 108, 'l == 108')
         self.assert_data(data2.GetUnsignedInt8, 3, 108)  # l
-        self.assertTrue(data2.uint8[4] == 111, 'o == 111')
+        self.assertEqual(data2.uint8[4], 111, 'o == 111')
         self.assert_data(data2.GetUnsignedInt8, 5, 33)  # !
 
         uint_lists = [[1, 2, 3, 4, 5], [int(i) for i in [1, 2, 3, 4, 5]]]
         int_lists = [[2, -2], [int(i) for i in [2, -2]]]
 
         for l in uint_lists:
             data2 = lldb.SBData.CreateDataFromUInt64Array(
                 process.GetByteOrder(), process.GetAddressByteSize(), l)
def test_with_run_command(self):
                     16) -
                 2.71) < 0.5,
             'double data2[2] = 2.71')
         self.assertTrue(error.Success())
 
         data2 = lldb.SBData()
 
         data2.SetDataFromCString(hello_str)
-        self.assertTrue(len(data2.uint8) == len(hello_str))
+        self.assertEqual(len(data2.uint8), len(hello_str))
         self.assert_data(data2.GetUnsignedInt8, 0, 104)
         self.assert_data(data2.GetUnsignedInt8, 1, 101)
         self.assert_data(data2.GetUnsignedInt8, 2, 108)
         self.assert_data(data2.GetUnsignedInt8, 3, 108)
         self.assert_data(data2.GetUnsignedInt8, 4, 111)
         self.assert_data(data2.GetUnsignedInt8, 5, 33)
 
         data2.SetDataFromUInt64Array([1, 2, 3, 4, 5])

lldb/test/API/python_api/symbol-context/TestSymbolContext.py

def test(self):
         self.assertTrue(process, PROCESS_IS_VALID)
 
         # Frame #0 should be on self.line.
         thread = lldbutil.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.GetLineEntry().GetLine() == self.line)
+        self.assertEqual(frame0.GetLineEntry().GetLine(), self.line)
 
         # Now get the SBSymbolContext from this frame.  We want everything. :-)
         context = frame0.GetSymbolContext(lldb.eSymbolContextEverything)
         self.assertTrue(context)
 
         # Get the description of this module.
         module = context.GetModule()
         desc = lldbutil.get_description(module)
def test(self):
         self.expect(lineEntry.GetFileSpec().GetDirectory(),
                     "The line entry should have the correct directory",
                     exe=False,
                     substrs=[self.mydir])
         self.expect(lineEntry.GetFileSpec().GetFilename(),
                     "The line entry should have the correct filename",
                     exe=False,
                     substrs=['main.c'])
-        self.assertTrue(lineEntry.GetLine() == self.line,
+        self.assertEqual(lineEntry.GetLine(), self.line,
                         "The line entry's line number should match ")
 
         symbol = context.GetSymbol()
         self.assertTrue(
             function.GetName() == symbol.GetName() and symbol.GetName() == 'c',
             "The symbol name should be 'c'")
 
         sc_list = lldb.SBSymbolContextList()
         sc_list.Append(context)
         self.assertEqual(len(sc_list), 1)
         for sc in sc_list:
             self.assertEqual(lineEntry, sc.GetLineEntry())

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

def find_global_variables(self, exe_name):
 
         # 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)
         # Make sure we hit our breakpoint:
         thread_list = lldbutil.get_threads_stopped_at_breakpoint(
             process, breakpoint)
-        self.assertTrue(len(thread_list) == 1)
+        self.assertEqual(len(thread_list), 1)
 
         value_list = target.FindGlobalVariables(
             'my_global_var_of_char_type', 3)
-        self.assertTrue(value_list.GetSize() == 1)
+        self.assertEqual(value_list.GetSize(), 1)
         my_global_var = value_list.GetValueAtIndex(0)
         self.DebugSBValue(my_global_var)
         self.assertTrue(my_global_var)
         self.expect(my_global_var.GetName(), exe=False,
                     startstr="my_global_var_of_char_type")
         self.expect(my_global_var.GetTypeName(), exe=False,
                     startstr="char")
         self.expect(my_global_var.GetValue(), exe=False,
                     startstr="'X'")
 
 
         if not configuration.is_reproducer():
             # While we are at it, let's also exercise the similar
             # SBModule.FindGlobalVariables() API.
             for m in target.module_iter():
                 if os.path.normpath(m.GetFileSpec().GetDirectory()) == self.getBuildDir() and m.GetFileSpec().GetFilename() == exe_name:
                     value_list = m.FindGlobalVariables(
                         target, 'my_global_var_of_char_type', 3)
-                    self.assertTrue(value_list.GetSize() == 1)
+                    self.assertEqual(value_list.GetSize(), 1)
                     self.assertTrue(
                         value_list.GetValueAtIndex(0).GetValue() == "'X'")
                     break
 
     def find_compile_units(self, exe):
         """Exercise SBTarget.FindCompileUnits() API."""
         source_name = "main.c"
 
def find_functions(self, exe_name):
         exe = self.getBuildArtifact(exe_name)
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # Try it with a null name:
         list = target.FindFunctions(None, lldb.eFunctionNameTypeAuto)
-        self.assertTrue(list.GetSize() == 0)
+        self.assertEqual(list.GetSize(), 0)
 
         list = target.FindFunctions('c', lldb.eFunctionNameTypeAuto)
-        self.assertTrue(list.GetSize() == 1)
+        self.assertEqual(list.GetSize(), 1)
 
         for sc in list:
             self.assertTrue(
                 sc.GetModule().GetFileSpec().GetFilename() == exe_name)
-            self.assertTrue(sc.GetSymbol().GetName() == 'c')
+            self.assertEqual(sc.GetSymbol().GetName(), 'c')
 
     def get_description(self):
         """Exercise SBTaget.GetDescription() API."""
         exe = self.getBuildArtifact("a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
def resolve_symbol_context_with_address(self):
                         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)
 
         # Frame #0 should be on self.line1.
-        self.assertTrue(process.GetState() == lldb.eStateStopped)
+        self.assertEqual(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")
         #self.runCmd("process status")
         frame0 = thread.GetFrameAtIndex(0)
         lineEntry = frame0.GetLineEntry()
-        self.assertTrue(lineEntry.GetLine() == self.line1)
+        self.assertEqual(lineEntry.GetLine(), self.line1)
 
         address1 = lineEntry.GetStartAddress()
 
         # Continue the inferior, the breakpoint 2 should be hit.
         process.Continue()
-        self.assertTrue(process.GetState() == lldb.eStateStopped)
+        self.assertEqual(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")
         #self.runCmd("process status")
         frame0 = thread.GetFrameAtIndex(0)
         lineEntry = frame0.GetLineEntry()
-        self.assertTrue(lineEntry.GetLine() == self.line2)
+        self.assertEqual(lineEntry.GetLine(), self.line2)
 
         address2 = lineEntry.GetStartAddress()
 
         self.trace("address1:", address1)
         self.trace("address2:", address2)
 
         # Now call SBTarget.ResolveSymbolContextForAddress() with the addresses
         # from our line entry.

lldb/test/API/python_api/thread/TestThreadAPI.py

def step_over_3_times(self, exe_name):
 
         # Launch the process, and do not stop at the entry point.
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
 
         self.assertTrue(process, PROCESS_IS_VALID)
 
         # Frame #0 should be on self.step_out_of_malloc.
-        self.assertTrue(process.GetState() == lldb.eStateStopped)
+        self.assertEqual(process.GetState(), lldb.eStateStopped)
         thread = get_stopped_thread(process, lldb.eStopReasonBreakpoint)
         self.assertTrue(
             thread.IsValid(),
             "There should be a thread stopped due to breakpoint condition")
         self.runCmd("thread backtrace")
         frame0 = thread.GetFrameAtIndex(0)
         lineEntry = frame0.GetLineEntry()
-        self.assertTrue(lineEntry.GetLine() == self.step_out_of_malloc)
+        self.assertEqual(lineEntry.GetLine(), self.step_out_of_malloc)
 
         thread.StepOver()
         thread.StepOver()
         thread.StepOver()
         self.runCmd("thread backtrace")
 
         # Verify that we are stopped at the correct source line number in
         # main2.cpp.
         frame0 = thread.GetFrameAtIndex(0)
         lineEntry = frame0.GetLineEntry()
-        self.assertTrue(thread.GetStopReason() == lldb.eStopReasonPlanComplete)
+        self.assertEqual(thread.GetStopReason(), lldb.eStopReasonPlanComplete)
         # Expected failure with clang as the compiler.
         # rdar://problem/9223880
         #
         # Which has been fixed on the lldb by compensating for inaccurate line
         # table information with r140416.
-        self.assertTrue(lineEntry.GetLine() == self.after_3_step_overs)
+        self.assertEqual(lineEntry.GetLine(), self.after_3_step_overs)
 
     def run_to_address(self, exe_name):
         """Test Python SBThread.RunToAddress() API."""
         exe = self.getBuildArtifact(exe_name)
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         breakpoint = target.BreakpointCreateByLocation(
             'main2.cpp', self.step_out_of_malloc)
         self.assertTrue(breakpoint, VALID_BREAKPOINT)
         self.runCmd("breakpoint list")
 
         # Launch the process, and do not stop at the entry point.
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
 
         self.assertTrue(process, PROCESS_IS_VALID)
 
         # Frame #0 should be on self.step_out_of_malloc.
-        self.assertTrue(process.GetState() == lldb.eStateStopped)
+        self.assertEqual(process.GetState(), lldb.eStateStopped)
         thread = get_stopped_thread(process, lldb.eStopReasonBreakpoint)
         self.assertTrue(
             thread.IsValid(),
             "There should be a thread stopped due to breakpoint condition")
         self.runCmd("thread backtrace")
         frame0 = thread.GetFrameAtIndex(0)
         lineEntry = frame0.GetLineEntry()
-        self.assertTrue(lineEntry.GetLine() == self.step_out_of_malloc)
+        self.assertEqual(lineEntry.GetLine(), self.step_out_of_malloc)
 
         # Get the start/end addresses for this line entry.
         start_addr = lineEntry.GetStartAddress().GetLoadAddress(target)
         end_addr = lineEntry.GetEndAddress().GetLoadAddress(target)
         if self.TraceOn():
             print("start addr:", hex(start_addr))
             print("end addr:", hex(end_addr))
 

lldb/test/API/python_api/type/TestTypeList.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.assertEqual(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 'Task'.
def test(self):
         # Get variable 'task_head'.
         task_head = frame0.FindVariable('task_head')
         self.assertTrue(task_head, VALID_VARIABLE)
         self.DebugSBValue(task_head)
         task_head_type = task_head.GetType()
         self.DebugSBType(task_head_type)
         self.assertTrue(task_head_type.IsPointerType())
 
-        self.assertTrue(task_head_type == task_pointer_type)
+        self.assertEqual(task_head_type, task_pointer_type)
 
         # Get the pointee type of 'task_head'.
         task_head_pointee_type = task_head_type.GetPointeeType()
         self.DebugSBType(task_head_pointee_type)
 
-        self.assertTrue(task_type == task_head_pointee_type)
+        self.assertEqual(task_type, task_head_pointee_type)
 
         # We'll now get the child member 'id' from 'task_head'.
         id = task_head.GetChildMemberWithName('id')
         self.DebugSBValue(id)
         id_type = id.GetType()
         self.DebugSBType(id_type)
 
         # SBType.GetBasicType() takes an enum 'BasicType'
         # (lldb-enumerations.h).
         int_type = id_type.GetBasicType(lldb.eBasicTypeInt)
-        self.assertTrue(id_type == int_type)
+        self.assertEqual(id_type, int_type)
 
         # Find 'myint_arr' and check the array element type.
         myint_arr = frame0.FindVariable('myint_arr')
         self.assertTrue(myint_arr, VALID_VARIABLE)
         self.DebugSBValue(myint_arr)
         myint_arr_type = myint_arr.GetType()
         self.DebugSBType(myint_arr_type)
         self.assertTrue(myint_arr_type.IsArrayType())
         myint_arr_element_type = myint_arr_type.GetArrayElementType()
         self.DebugSBType(myint_arr_element_type)
         myint_type = target.FindFirstType('myint')
         self.DebugSBType(myint_type)
-        self.assertTrue(myint_arr_element_type == myint_type)
+        self.assertEqual(myint_arr_element_type, myint_type)
 
         # Test enum methods. Requires DW_AT_enum_class which was added in Dwarf 4.
         if configuration.dwarf_version >= 4:
             enum_type = target.FindFirstType('EnumType')
             self.assertTrue(enum_type)
             self.DebugSBType(enum_type)
             self.assertFalse(enum_type.IsScopedEnumerationType())
 

lldb/test/API/python_api/value/TestValueAPI.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.assertEqual(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 global variable 'days_of_week'.
def test(self):
         # Spot check the actual value:
         first_day = days_of_week.child[1]
         self.assertEqual(first_day.GetSummary(), '"Monday"', VALID_VARIABLE)
 
         # Get global variable 'weekdays'.
         list = target.FindGlobalVariables('weekdays', 1)
         weekdays = list.GetValueAtIndex(0)
         self.assertTrue(weekdays, VALID_VARIABLE)
-        self.assertTrue(weekdays.GetNumChildren() == 5, VALID_VARIABLE)
+        self.assertEqual(weekdays.GetNumChildren(), 5, VALID_VARIABLE)
         self.DebugSBValue(weekdays)
 
         # Get global variable 'g_table'.
         list = target.FindGlobalVariables('g_table', 1)
         g_table = list.GetValueAtIndex(0)
         self.assertTrue(g_table, VALID_VARIABLE)
-        self.assertTrue(g_table.GetNumChildren() == 2, VALID_VARIABLE)
+        self.assertEqual(g_table.GetNumChildren(), 2, VALID_VARIABLE)
         self.DebugSBValue(g_table)
 
         fmt = lldbutil.BasicFormatter()
         cvf = lldbutil.ChildVisitingFormatter(indent_child=2)
         rdf = lldbutil.RecursiveDecentFormatter(indent_child=2)
         if self.TraceOn():
             print(fmt.format(days_of_week))
             print(cvf.format(days_of_week))
def test(self):
         self.DebugSBValue(value)
 
         # SBValue::TypeIsPointerType() should return true.
         self.assertTrue(value.TypeIsPointerType())
 
         # Verify the SBValue::GetByteSize() API is working correctly.
         arch = self.getArchitecture()
         if arch == 'i386':
-            self.assertTrue(value.GetByteSize() == 4)
+            self.assertEqual(value.GetByteSize(), 4)
         elif arch == 'x86_64':
-            self.assertTrue(value.GetByteSize() == 8)
+            self.assertEqual(value.GetByteSize(), 8)
 
         # Get child at index 5 => 'Friday'.
         child = value.GetChildAtIndex(5, lldb.eNoDynamicValues, True)
         self.assertTrue(child, VALID_VARIABLE)
         self.DebugSBValue(child)
 
         self.expect(child.GetSummary(), exe=False,
                     substrs=['Friday'])

lldb/test/API/python_api/value/linked_list/TestValueAPILinkedList.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.assertEqual(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 variable 'task_head'.
def test(self):
             self.assertTrue(t.TypeIsPointerType())
             if self.TraceOn():
                 print(cvf.format(t))
             list.append(int(t.GetChildMemberWithName("id").GetValue()))
 
         # Sanity checks that the we visited all the items (no more, no less).
         if self.TraceOn():
             print("visited IDs:", list)
-        self.assertTrue(visitedIDs == list)
+        self.assertEqual(visitedIDs, list)
 
         # Let's exercise the linked_list_iter() API again, this time supplying
         # our end of list test function.
         def eol(val):
             """Test function to determine end of list."""
             # End of list is reached if either the value object is invalid
             # or it corresponds to a null pointer.
             if not val or int(val.GetValue(), 16) == 0:
def test(self):
             self.assertTrue(t.TypeIsPointerType())
             if self.TraceOn():
                 print(cvf.format(t))
             list.append(int(t.GetChildMemberWithName("id").GetValue()))
 
         # Sanity checks that the we visited all the items (no more, no less).
         if self.TraceOn():
             print("visited IDs:", list)
-        self.assertTrue(visitedIDs == list)
+        self.assertEqual(visitedIDs, list)
 
         # Get variable 'empty_task_head'.
         empty_task_head = frame0.FindVariable('empty_task_head')
         self.assertTrue(empty_task_head, VALID_VARIABLE)
         self.DebugSBValue(empty_task_head)
 
         list = []
         # There is no iterable item from empty_task_head.linked_list_iter().
         for t in empty_task_head.linked_list_iter('next', eol):
             if self.TraceOn():
                 print(cvf.format(t))
             list.append(int(t.GetChildMemberWithName("id").GetValue()))
 
-        self.assertTrue(len(list) == 0)
+        self.assertEqual(len(list), 0)
 
         # Get variable 'task_evil'.
         task_evil = frame0.FindVariable('task_evil')
         self.assertTrue(task_evil, VALID_VARIABLE)
         self.DebugSBValue(task_evil)
 
         list = []
         # There 3 iterable items from task_evil.linked_list_iter(). :-)
         for t in task_evil.linked_list_iter('next'):
             if self.TraceOn():
                 print(cvf.format(t))
             list.append(int(t.GetChildMemberWithName("id").GetValue()))
 
-        self.assertTrue(len(list) == 3)
+        self.assertEqual(len(list), 3)

lldb/test/API/python_api/watchpoint/TestSetWatchpoint.py

def test_watch_val(self):
                         VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at the entry point.
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
 
         # We should be stopped due to the breakpoint.  Get frame #0.
         process = target.GetProcess()
-        self.assertTrue(process.GetState() == lldb.eStateStopped,
+        self.assertEqual(process.GetState(), lldb.eStateStopped,
                         PROCESS_STOPPED)
         thread = lldbutil.get_stopped_thread(
             process, lldb.eStopReasonBreakpoint)
         frame0 = thread.GetFrameAtIndex(0)
 
         # Watch 'global' for read and write.
         value = frame0.FindValue('global', lldb.eValueTypeVariableGlobal)
         error = lldb.SBError()

lldb/test/API/python_api/watchpoint/TestWatchpointIter.py

def test_watch_iter(self):
                         VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at the entry point.
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
 
         # We should be stopped due to the breakpoint.  Get frame #0.
         process = target.GetProcess()
-        self.assertTrue(process.GetState() == lldb.eStateStopped,
+        self.assertEqual(process.GetState(), lldb.eStateStopped,
                         PROCESS_STOPPED)
         thread = lldbutil.get_stopped_thread(
             process, lldb.eStopReasonBreakpoint)
         frame0 = thread.GetFrameAtIndex(0)
 
         # Watch 'global' for read and write.
         value = frame0.FindValue('global', lldb.eValueTypeVariableGlobal)
         error = lldb.SBError()
         watchpoint = value.Watch(True, False, True, error)
         self.assertTrue(value and watchpoint,
                         "Successfully found the variable and set a watchpoint")
         self.DebugSBValue(value)
 
         # Hide stdout if not running with '-t' option.
         if not self.TraceOn():
             self.HideStdout()
 
         # There should be only 1 watchpoint location under the target.
-        self.assertTrue(target.GetNumWatchpoints() == 1)
+        self.assertEqual(target.GetNumWatchpoints(), 1)
         self.assertTrue(watchpoint.IsEnabled())
         watch_id = watchpoint.GetID()
         self.assertTrue(watch_id != 0)
 
         # Continue.  Expect the program to stop due to the variable being
         # written to.
         process.Continue()
 
def test_watch_iter(self):
             self.assertTrue(watchpoint.GetHardwareIndex() != -1)
 
         # SBWatchpoint.GetDescription() takes a description level arg.
         print(lldbutil.get_description(watchpoint, lldb.eDescriptionLevelFull))
 
         # Now disable the 'rw' watchpoint.  The program won't stop when it reads
         # 'global' next.
         watchpoint.SetEnabled(False)
-        self.assertTrue(watchpoint.GetHardwareIndex() == -1)
+        self.assertEqual(watchpoint.GetHardwareIndex(), -1)
         self.assertFalse(watchpoint.IsEnabled())
 
         # Continue.  The program does not stop again when the variable is being
         # read from because the watchpoint location has been disabled.
         process.Continue()
 
         # At this point, the inferior process should have exited.
         self.assertTrue(
             process.GetState() == lldb.eStateExited,
             PROCESS_EXITED)
 
         # Verify some vital statistics and exercise the iterator API.
         for watchpoint in target.watchpoint_iter():
             self.assertTrue(watchpoint)
-            self.assertTrue(watchpoint.GetWatchSize() == 4)
-            self.assertTrue(watchpoint.GetHitCount() == 1)
+            self.assertEqual(watchpoint.GetWatchSize(), 4)
+            self.assertEqual(watchpoint.GetHitCount(), 1)
             print(watchpoint)

lldb/test/API/python_api/watchpoint/condition/TestWatchpointConditionAPI.py

def test_watchpoint_cond_api(self):
                         VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at the entry point.
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
 
         # We should be stopped due to the breakpoint.  Get frame #0.
         process = target.GetProcess()
-        self.assertTrue(process.GetState() == lldb.eStateStopped,
+        self.assertEqual(process.GetState(), lldb.eStateStopped,
                         PROCESS_STOPPED)
         thread = lldbutil.get_stopped_thread(
             process, lldb.eStopReasonBreakpoint)
         frame0 = thread.GetFrameAtIndex(0)
 
         # Watch 'global' for write.
         value = frame0.FindValue('global', lldb.eValueTypeVariableGlobal)
         error = lldb.SBError()
def test_watchpoint_cond_api(self):
             lldbutil.print_stacktraces(process)
 
         thread = lldbutil.get_stopped_thread(
             process, lldb.eStopReasonWatchpoint)
         self.assertTrue(thread, "The thread stopped due to watchpoint")
         self.DebugSBValue(value)
 
         # Verify that the condition is met.
-        self.assertTrue(value.GetValueAsUnsigned() == 5)
+        self.assertEqual(value.GetValueAsUnsigned(), 5)

lldb/test/API/python_api/watchpoint/watchlocation/TestSetWatchlocation.py

def test_watch_location(self):
                         VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at the entry point.
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
 
         # We should be stopped due to the breakpoint.  Get frame #0.
         process = target.GetProcess()
-        self.assertTrue(process.GetState() == lldb.eStateStopped,
+        self.assertEqual(process.GetState(), lldb.eStateStopped,
                         PROCESS_STOPPED)
         thread = lldbutil.get_stopped_thread(
             process, lldb.eStopReasonBreakpoint)
         frame0 = thread.GetFrameAtIndex(0)
 
         value = frame0.FindValue('g_char_ptr',
                                  lldb.eValueTypeVariableGlobal)
         pointee = value.CreateValueFromAddress(

lldb/test/API/python_api/watchpoint/watchlocation/TestTargetWatchAddress.py

def test_watch_address(self):
                         VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at the entry point.
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
 
         # We should be stopped due to the breakpoint.  Get frame #0.
         process = target.GetProcess()
-        self.assertTrue(process.GetState() == lldb.eStateStopped,
+        self.assertEqual(process.GetState(), lldb.eStateStopped,
                         PROCESS_STOPPED)
         thread = lldbutil.get_stopped_thread(
             process, lldb.eStopReasonBreakpoint)
         frame0 = thread.GetFrameAtIndex(0)
 
         value = frame0.FindValue('g_char_ptr',
                                  lldb.eValueTypeVariableGlobal)
         pointee = value.CreateValueFromAddress(
def test_watch_address_with_invalid_watch_size(self):
                         VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at the entry point.
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
 
         # We should be stopped due to the breakpoint.  Get frame #0.
         process = target.GetProcess()
-        self.assertTrue(process.GetState() == lldb.eStateStopped,
+        self.assertEqual(process.GetState(), lldb.eStateStopped,
                         PROCESS_STOPPED)
         thread = lldbutil.get_stopped_thread(
             process, lldb.eStopReasonBreakpoint)
         frame0 = thread.GetFrameAtIndex(0)
 
         value = frame0.FindValue('g_char_ptr',
                                  lldb.eValueTypeVariableGlobal)
         pointee = value.CreateValueFromAddress(

lldb/test/API/terminal/TestSTTYBeforeAndAfter.py

def test_stty_dash_a_before_and_afetr_invoking_lldb_command(self):
         stty_output2_lines = child_read2.getvalue().splitlines()
         zipped = list(zip(stty_output1_lines, stty_output2_lines))
         for tuple in zipped:
             if self.TraceOn():
                 print("tuple->%s" % str(tuple))
             # Every line should compare equal until the first blank line.
             if len(tuple[0]) == 0:
                 break
-            self.assertTrue(tuple[0] == tuple[1])
+            self.assertEqual(tuple[0], tuple[1])

lldb/test/API/tools/lldb-server/registers-target-xml-reading/TestGdbRemoteTargetXmlPacket.py

def test_g_target_xml_returns_correct_data(self):
         self.assertTrue(len(target_xml_registers) > 0)
 
         # registers info collected by qRegisterInfo
         self.add_register_info_collection_packets()
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
         q_info_registers = self.parse_register_info_packets(context)
 
-        self.assertTrue(len(target_xml_registers) == len(q_info_registers))
+        self.assertEqual(len(target_xml_registers), len(q_info_registers))
         for register in zip(target_xml_registers, q_info_registers):
             xml_info_reg = register[0]
             q_info_reg = register[1]
             self.assertEqual(q_info_reg["name"], xml_info_reg.get("name"))
             self.assertEqual(q_info_reg["set"], xml_info_reg.get("group"))
             self.assertEqual(q_info_reg["format"], xml_info_reg.get("format"))
             self.assertEqual(q_info_reg["bitsize"], xml_info_reg.get("bitsize"))
 
             if not self.getArchitecture() == 'aarch64':
                 self.assertEqual(q_info_reg["offset"], xml_info_reg.get("offset"))
 
             self.assertEqual(q_info_reg["encoding"], xml_info_reg.get("encoding"))

lldb/test/API/tools/lldb-vscode/breakpoint-events/TestVSCode_breakpointEvents.py

def test_breakpoint_events(self):
                                  "expect foo breakpoint to not be verified")
 
         # Get the stop at the entry point
         self.continue_to_next_stop()
 
         # We are now stopped at the entry point to the program. Shared
         # libraries are not loaded yet (at least on macOS they aren't) and any
         # breakpoints set in foo.cpp should not be resolved.
-        self.assertTrue(len(self.vscode.breakpoint_events) == 0,
+        self.assertEqual(len(self.vscode.breakpoint_events), 0,
                         "no breakpoint events when stopped at entry point")
 
         # Continue to the breakpoint
         self.continue_to_breakpoints(vscode_breakpoint_ids)
 
         # Make sure we only get an event for the breakpoint we set via a call
         # to self.vscode.request_setBreakpoints(...), not the breakpoint
         # we set with with a LLDB command in preRunCommands.
-        self.assertTrue(len(self.vscode.breakpoint_events) == 1,
+        self.assertEqual(len(self.vscode.breakpoint_events), 1,
                         "make sure we got a breakpoint event")
         event = self.vscode.breakpoint_events[0]
         # Verify the details of the breakpoint changed notification.
         body = event['body']
-        self.assertTrue(body['reason'] == 'changed',
+        self.assertEqual(body['reason'], 'changed',
                 "breakpoint event is says breakpoint is changed")
         breakpoint = body['breakpoint']
-        self.assertTrue(breakpoint['verified'] == True,
+        self.assertTrue(breakpoint['verified'],
                 "breakpoint event is says it is verified")
-        self.assertTrue(breakpoint['id'] == foo_bp_id,
+        self.assertEqual(breakpoint['id'], foo_bp_id,
                 "breakpoint event is for breakpoint %i" % (foo_bp_id))
         self.assertTrue('line' in breakpoint and breakpoint['line'] > 0,
                 "breakpoint event is has a line number")
         self.assertNotIn("source", breakpoint,
                 "breakpoint event should not return a source object")

lldb/test/API/tools/lldb-vscode/console/TestVSCode_console.py

def test_scopes_variables_setVariable_evaluate(self):
         '''
         program = self.getBuildArtifact("a.out")
         self.build_and_launch(program)
         source = 'main.cpp'
         breakpoint1_line = line_number(source, '// breakpoint 1')
         lines = [breakpoint1_line]
         # Set breakpoint in the thread function so we can step the threads
         breakpoint_ids = self.set_source_breakpoints(source, lines)
-        self.assertTrue(len(breakpoint_ids) == len(lines),
+        self.assertEqual(len(breakpoint_ids), len(lines),
                         "expect correct number of breakpoints")
         self.continue_to_breakpoints(breakpoint_ids)
         # Cause a "scopes" to be sent for frame zero which should update the
         # selected thread and frame to frame 0.
         self.vscode.get_local_variables(frameIndex=0)
         # Verify frame #0 is selected in the command interpreter by running
         # the "frame select" command with no frame index which will print the
         # currently selected frame.

lldb/test/API/tools/lldb-vscode/module/TestVSCode_module.py

def test_compile_units(self):
         main_source_path = self.getSourcePath(source)
         breakpoint1_line = line_number(source, '// breakpoint 1')
         lines = [breakpoint1_line]
         breakpoint_ids = self.set_source_breakpoints(source, lines)
         self.continue_to_breakpoints(breakpoint_ids)
         moduleId = self.vscode.get_modules()['a.out']['id']
         response = self.vscode.request_compileUnits(moduleId)
         self.assertTrue(response['body'])
-        self.assertTrue(len(response['body']['compileUnits']) == 1,
+        self.assertEqual(len(response['body']['compileUnits']), 1,
                         'Only one source file should exist')
-        self.assertTrue(response['body']['compileUnits'][0]['compileUnitPath'] == main_source_path,
+        self.assertEqual(response['body']['compileUnits'][0]['compileUnitPath'], main_source_path,
                         'Real path to main.cpp matches')

lldb/test/API/tools/lldb-vscode/variables/TestVSCode_variables.py

class TestVSCode_variables(lldbvscode_testcase.VSCodeTestCaseBase):
     mydir = TestBase.compute_mydir(__file__)
 
     def verify_values(self, verify_dict, actual, varref_dict=None):
         if 'equals' in verify_dict:
             verify = verify_dict['equals']
             for key in verify:
                 verify_value = verify[key]
                 actual_value = actual[key]
-                self.assertTrue(verify_value == actual_value,
+                self.assertEqual(verify_value, actual_value,
                                 '"%s" keys don\'t match (%s != %s)' % (
                                     key, actual_value, verify_value))
         if 'startswith' in verify_dict:
             verify = verify_dict['startswith']
             for key in verify:
                 verify_value = verify[key]
                 actual_value = actual[key]
                 startswith = actual_value.startswith(verify_value)
def test_scopes_variables_setVariable_evaluate(self):
         '''
         program = self.getBuildArtifact("a.out")
         self.build_and_launch(program)
         source = 'main.cpp'
         breakpoint1_line = line_number(source, '// breakpoint 1')
         lines = [breakpoint1_line]
         # Set breakpoint in the thread function so we can step the threads
         breakpoint_ids = self.set_source_breakpoints(source, lines)
-        self.assertTrue(len(breakpoint_ids) == len(lines),
+        self.assertEqual(len(breakpoint_ids), len(lines),
                         "expect correct number of breakpoints")
         self.continue_to_breakpoints(breakpoint_ids)
         locals = self.vscode.get_local_variables()
         globals = self.vscode.get_global_variables()
         buffer_children = make_buffer_verify_dict(0, 32)
         verify_locals = {
             'argc': {
                 'equals': {'type': 'int', 'value': '1'}
def test_scopes_variables_setVariable_evaluate(self):
         # Verify setting the start index and count gets only the children we
         # want
         response = self.vscode.request_variables(varRef, start=5, count=5)
         self.verify_variables(make_buffer_verify_dict(5, 5),
                               response['body']['variables'])
         # Verify setting the start index to a value that is out of range
         # results in an empty list
         response = self.vscode.request_variables(varRef, start=32, count=1)
-        self.assertTrue(len(response['body']['variables']) == 0,
+        self.assertEqual(len(response['body']['variables']), 0,
                         'verify we get no variable back for invalid start')
 
         # Test evaluate
         expressions = {
             'pt.x': {
                 'equals': {'result': '11', 'type': 'int'},
                 'hasVariablesReference': False
             },
def test_scopes_variables_setVariable_evaluate(self):
         }
         for expression in expressions:
             response = self.vscode.request_evaluate(expression)
             self.verify_values(expressions[expression], response['body'])
 
         # Test setting variables
         self.set_local('argc', 123)
         argc = self.get_local_as_int('argc')
-        self.assertTrue(argc == 123,
+        self.assertEqual(argc, 123,
                         'verify argc was set to 123 (123 != %i)' % (argc))
 
         self.set_local('argv', 0x1234)
         argv = self.get_local_as_int('argv')
-        self.assertTrue(argv == 0x1234,
+        self.assertEqual(argv, 0x1234,
                         'verify argv was set to 0x1234 (0x1234 != %#x)' % (
                             argv))
 
         # Set a variable value whose name is synthetic, like a variable index
         # and verify the value by reading it
         self.vscode.request_setVariable(varRef, "[0]", 100)
         response = self.vscode.request_variables(varRef, start=0, count=1)
         self.verify_variables(make_buffer_verify_dict(0, 1, 100),
                               response['body']['variables'])
 
         # Set a variable value whose name is a real child value, like "pt.x"
         # and verify the value by reading it
         varRef = varref_dict['pt']
         self.vscode.request_setVariable(varRef, "x", 111)
         response = self.vscode.request_variables(varRef, start=0, count=1)
         value = response['body']['variables'][0]['value']
-        self.assertTrue(value == '111',
+        self.assertEqual(value, '111',
                         'verify pt.x got set to 111 (111 != %s)' % (value))