[lldb] Add assertState function

[JDevlieghere]

Summary

Add a function to make it easier to debug a test failure caused by an unexpected state. Currently, tests are using assertEqual which results in a cryptic error message: "AssertionError: 5 != 10". Even when a test provides a message to make it clear why a particular state is expected, you still have to figure out which of the two numbers was the expected state and what the actual state corresponds to. We have a function in lldbutil that helps you convert the state number into a user readable string. This patch adds a wrapper around assertEqual specifically for comparing states. The aforementioned error message now looks like this: "AssertionError: 5 != 10 : stopped != exited". If the user provided a message, that gets displayed as well.

[mib]

Pretty cool but it would be nice to have the following formatting: "AssertionError: stopped (5) != exited (10) : message" ... I feel like it's easier to read this way

[JDevlieghere]

Implement Ismail's suggestion:

AssertionError: stopped (5) != exited (10) : Got exit event

[mib]

Awesome! Thanks!

[kastiglione]

nice, I've wanted this too.

lldb/packages/Python/lldbsuite/test/lldbtest.py

def compute_mydir(test_file):
         '''Subclasses should call this function to correctly calculate the
            required "mydir" attribute as follows:
 
             mydir = TestBase.compute_mydir(__file__)
         '''
         # /abs/path/to/packages/group/subdir/mytest.py -> group/subdir
         lldb_test_src = configuration.test_src_root
         if not test_file.startswith(lldb_test_src):
             raise Exception(
                 "Test file '%s' must reside within lldb_test_src "
                 "(which is '%s')." % (test_file, lldb_test_src))
         return os.path.dirname(os.path.relpath(test_file, start=lldb_test_src))
 
     def TraceOn(self):
         """Returns True if we are in trace mode (tracing detailed test execution)."""
         return traceAlways
 
     def trace(self, *args,**kwargs):
         with recording(self, self.TraceOn()) as sbuf:
""".format(cmd_status, filecheck_cmd, output, cmd_stdout, cmd_stderr)
 
     """Assert that an lldb.SBError is in the "success" state."""
     def assertSuccess(self, obj, msg=None):
         if not obj.Success():
             error = obj.GetCString()
             self.fail(self._formatMessage(msg,
                 "'{}' is not success".format(error)))
 
+    """Assert two states are equal"""
+    def assertState(self, first, second, msg=None):
+        if first != second:
+            error = "{} ({}) != {} ({})".format(
+                lldbutil.state_type_to_str(first), first,
+                lldbutil.state_type_to_str(second), second)
+            self.fail(self._formatMessage(msg, error))
+
     def createTestTarget(self, file_path=None, msg=None,
                          load_dependent_modules=True):
         """
         Creates a target from the file found at the given file path.
         Asserts that the resulting target is valid.
         :param file_path: The file path that should be used to create the target.
                           The default argument opens the current default test
                           executable in the current test directory.

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

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

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

def test(self):
         self.build()
         target = self.createTestTarget()
 
         lldbutil.run_break_set_by_symbol(self, 'main')
 
         process = target.LaunchSimple(None, None,
                                       self.get_process_working_directory())
         self.assertTrue(process.IsValid(), PROCESS_IS_VALID)
-        self.assertEquals(process.GetState(), lldb.eStateStopped,
+        self.assertState(process.GetState(), lldb.eStateStopped,
                          PROCESS_STOPPED)
 
         thread = lldbutil.get_stopped_thread(process,
                                              lldb.eStopReasonBreakpoint)
         self.assertTrue(thread.IsValid(), "Failed to get thread.")
 
         frame = thread.GetFrameAtIndex(0)
         self.assertTrue(frame.IsValid(), "Failed to get frame.")
 
def test(self):
         self.assertTrue(read_watchpoint, "Failed to set read watchpoint.")
 
         thread.StepOver()
         self.assertEquals(thread.GetStopReason(), lldb.eStopReasonWatchpoint,
                         STOPPED_DUE_TO_WATCHPOINT)
         self.assertEquals(thread.GetStopDescription(20), 'watchpoint 1')
 
         process.Continue()
-        self.assertEquals(process.GetState(), lldb.eStateStopped,
+        self.assertState(process.GetState(), lldb.eStateStopped,
                          PROCESS_STOPPED)
         self.assertEquals(thread.GetStopDescription(20), 'step over')
 
         self.step_inst_for_watchpoint(1)
 
         write_value = frame.FindValue('g_watch_me_write',
                                       lldb.eValueTypeVariableGlobal)
         self.assertTrue(write_value, "Failed to find write value.")
 
def test(self):
         self.assertSuccess(error, "Error while setting watchpoint")
 
         thread.StepOver()
         self.assertEquals(thread.GetStopReason(), lldb.eStopReasonWatchpoint,
                         STOPPED_DUE_TO_WATCHPOINT)
         self.assertEquals(thread.GetStopDescription(20), 'watchpoint 2')
 
         process.Continue()
-        self.assertEquals(process.GetState(), lldb.eStateStopped,
+        self.assertState(process.GetState(), lldb.eStateStopped,
                          PROCESS_STOPPED)
         self.assertEquals(thread.GetStopDescription(20), 'step over')
 
         self.step_inst_for_watchpoint(2)
 
     def step_inst_for_watchpoint(self, wp_id):
         watchpoint_hit = False
         current_line = self.frame().GetLineEntry().GetLine()
         while self.frame().GetLineEntry().GetLine() == current_line:

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

def prepare_test(self):
             self.bkpt_address.GetLoadAddress(self.target))
         self.assertTrue(
             self.breakpoint2 and self.breakpoint2.GetNumLocations() == 1,
             VALID_BREAKPOINT)
 
     def finish_test(self):
         # Run the process until termination
         self.process.Continue()
-        self.assertEquals(self.process.GetState(), lldb.eStateExited)
+        self.assertState(self.process.GetState(), lldb.eStateExited)
 
     @no_debug_info_test
     def test_continue(self):
         """Test that continue stops at the second breakpoint."""
         self.prepare_test()
 
         self.process.Continue()
-        self.assertEquals(self.process.GetState(), lldb.eStateStopped)
+        self.assertState(self.process.GetState(), lldb.eStateStopped)
         # We should be stopped at the second breakpoint
         self.thread = lldbutil.get_one_thread_stopped_at_breakpoint(
             self.process, self.breakpoint2)
         self.assertIsNotNone(
             self.thread,
             "Expected one thread to be stopped at breakpoint 2")
 
         self.finish_test()
 
     @no_debug_info_test
     def test_single_step(self):
         """Test that single step stops at the second breakpoint."""
         self.prepare_test()
 
         step_over = False
         self.thread.StepInstruction(step_over)
 
-        self.assertEquals(self.process.GetState(), lldb.eStateStopped)
+        self.assertState(self.process.GetState(), lldb.eStateStopped)
         self.assertEquals(
             self.thread.GetFrameAtIndex(0).GetPCAddress().GetLoadAddress(
                 self.target), self.bkpt_address.GetLoadAddress(
                 self.target))
         self.thread = lldbutil.get_one_thread_stopped_at_breakpoint(
             self.process, self.breakpoint2)
         self.assertIsNotNone(
             self.thread,
def test_single_step_thread_specific(self):
         # fine.
         thread_index = self.process.GetNumThreads() + 1
         self.assertFalse(self.process.GetThreadAtIndex(thread_index).IsValid())
         self.breakpoint2.SetThreadIndex(thread_index)
 
         step_over = False
         self.thread.StepInstruction(step_over)
 
-        self.assertEquals(self.process.GetState(), lldb.eStateStopped)
+        self.assertState(self.process.GetState(), lldb.eStateStopped)
         self.assertEquals(
             self.thread.GetFrameAtIndex(0).GetPCAddress().GetLoadAddress(
                 self.target), self.bkpt_address.GetLoadAddress(
                 self.target))
         self.assertEquals(
             self.thread.GetStopReason(),
             lldb.eStopReasonPlanComplete,
             "Stop reason should be 'plan complete'")
 
         self.finish_test()

lldb/test/API/functionalities/breakpoint/move_nearest/TestMoveNearest.py

def test(self):
 
         self.build()
         target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
         self.assertTrue(target, VALID_TARGET)
 
         lldbutil.run_break_set_by_symbol(self, 'main', sym_exact=True)
         environment = self.registerSharedLibrariesWithTarget(target, ["foo"])
         process = target.LaunchSimple(None, environment, self.get_process_working_directory())
-        self.assertEquals(process.GetState(), lldb.eStateStopped)
+        self.assertState(process.GetState(), lldb.eStateStopped)
 
         # Regardless of the -m value the breakpoint should have exactly one
         # location on the foo functions
         self.runCmd("settings set target.move-to-nearest-code true")
         lldbutil.run_break_set_by_file_and_line(self, 'foo.h', self.line1,
                 loc_exact=True, extra_options="-m 1")
         lldbutil.run_break_set_by_file_and_line(self, 'foo.h', self.line2,
                 loc_exact=True, extra_options="-m 1")

lldb/test/API/functionalities/breakpoint/step_over_breakpoint/TestStepOverBreakpoint.py

def test_step_instruction(self):
         # instructions on which a breakpoint can be set.
         # start = addr_1, end = addr_4, canSetBreakpoint = True
         steps_expected = instructions.GetInstructionsCount(addr_1, addr_4, True)
         step_count = 0
         # Step from breakpoint_1 to breakpoint_4
         while True:
             self.thread.StepInstruction(True)
             step_count = step_count + 1
-            self.assertEquals(self.process.GetState(), lldb.eStateStopped)
+            self.assertState(self.process.GetState(), lldb.eStateStopped)
             self.assertTrue(self.thread.GetStopReason() == lldb.eStopReasonPlanComplete or
                             self.thread.GetStopReason() == lldb.eStopReasonBreakpoint)
             if (self.thread.GetStopReason() == lldb.eStopReasonBreakpoint) :
                 # we should not stop on breakpoint_2 and _3 because they have false condition
                 self.assertEquals(self.thread.GetFrameAtIndex(0).GetLineEntry().GetLine(), self.line4)
                 # breakpoint_2 and _3 should not affect step count
                 self.assertTrue(step_count >= steps_expected)
                 break
 
         # Run the process until termination
         self.process.Continue()
-        self.assertEquals(self.process.GetState(), lldb.eStateExited)
+        self.assertState(self.process.GetState(), lldb.eStateExited)
 
     @skipIf(bugnumber="llvm.org/pr31972", hostoslist=["windows"])
     def test_step_over(self):
 
         self.thread.StepOver()
         # We should be stopped at the breakpoint_2 line with stop plan complete reason
-        self.assertEquals(self.process.GetState(), lldb.eStateStopped)
+        self.assertState(self.process.GetState(), lldb.eStateStopped)
         self.assertEquals(self.thread.GetStopReason(), lldb.eStopReasonPlanComplete)
 
         self.thread.StepOver()
         # We should be stopped at the breakpoint_3 line with stop plan complete reason
-        self.assertEquals(self.process.GetState(), lldb.eStateStopped)
+        self.assertState(self.process.GetState(), lldb.eStateStopped)
         self.assertEquals(self.thread.GetStopReason(), lldb.eStopReasonPlanComplete)
 
         self.thread.StepOver()
         # We should be stopped at the breakpoint_4
-        self.assertEquals(self.process.GetState(), lldb.eStateStopped)
+        self.assertState(self.process.GetState(), lldb.eStateStopped)
         self.assertEquals(self.thread.GetStopReason(), lldb.eStopReasonBreakpoint)
         thread1 = lldbutil.get_one_thread_stopped_at_breakpoint(self.process, self.breakpoint4)
         self.assertEquals(self.thread, thread1, "Didn't stop at breakpoint 4.")
 
         # Check that stepping does not affect breakpoint's hit count
         self.assertEquals(self.breakpoint1.GetHitCount(), 1)
         self.assertEquals(self.breakpoint2.GetHitCount(), 0)
         self.assertEquals(self.breakpoint3.GetHitCount(), 0)
         self.assertEquals(self.breakpoint4.GetHitCount(), 1)
 
         # Run the process until termination
         self.process.Continue()
-        self.assertEquals(self.process.GetState(), lldb.eStateExited)
+        self.assertState(self.process.GetState(), lldb.eStateExited)
 

lldb/test/API/functionalities/completion/TestCompletion.py

class CommandLineCompletionTestCase(TestBase):
 
     def test_frame_variable(self):
         self.build()
         self.main_source = "main.cpp"
         self.main_source_spec = lldb.SBFileSpec(self.main_source)
 
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
                                           '// Break here', self.main_source_spec)
-        self.assertEquals(process.GetState(), lldb.eStateStopped)
+        self.assertState(process.GetState(), lldb.eStateStopped)
 
         # Since CommandInterpreter has been corrected to update the current execution
         # context at the beginning of HandleCompletion, we're here explicitly testing
         # the scenario where "frame var" is completed without any preceding commands.
 
         self.complete_from_to('frame variable fo',
                               'frame variable fooo')
         self.complete_from_to('frame variable fooo.',

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

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

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

class TestStopAtEntry(TestBase):
 
     @skipUnlessDarwin
     @skipIfRemote
     @expectedFailureIfFn(no_debugserver)
     @expectedFailureIfFn(port_not_available)
     def test_stop_remote_platform_async(self):
         self.do_test_stop_at_entry(False, True)
 
-    def do_test_stop_at_entry(self, synchronous, remote):        
+    def do_test_stop_at_entry(self, synchronous, remote):
         """Test the normal launch path in either sync or async mode"""
         self.build()
 
         target = lldbutil.run_to_breakpoint_make_target(self)
         launch_info = target.GetLaunchInfo()
         launch_info.SetLaunchFlags(lldb.eLaunchFlagStopAtEntry)
         old_async = self.dbg.GetAsync()
         def cleanup ():
def do_test_stop_at_entry(self, synchronous, remote):
         self.assertSuccess(error, "Launch failed")
         # If we are asynchronous, we have to wait for the events:
         if not synchronous:
             listener = launch_info.GetListener()
             event = lldb.SBEvent()
             result = listener.WaitForEvent(30, event)
             self.assertTrue(result, "Timed out waiting for event from process")
             state = lldb.SBProcess.GetStateFromEvent(event)
-            self.assertEqual(state, lldb.eStateStopped, "Didn't get a stopped state after launch")
+            self.assertState(state, lldb.eStateStopped, "Didn't get a stopped state after launch")
 
         # Okay, we should be stopped.  Make sure we are indeed at the
         # entry point.  I only know how to do this on darwin:
         self.assertEqual(len(process.threads), 1, "Should only have one thread at entry")
         thread = process.threads[0]
         frame = thread.GetFrameAtIndex(0)
         stop_func = frame.name
         self.assertEqual(stop_func, "_dyld_start")
def do_test_stop_at_entry(self, synchronous, remote):
             num_running = 0
             state = lldb.eStateRunning
             while state == lldb.eStateRunning:
                 num_running += 1
                 result = listener.WaitForEvent(30, event)
                 self.assertTrue(result, "Timed out waiting for running")
                 state = lldb.SBProcess.GetStateFromEvent(event)
                 if num_running == 1:
-                    self.assertEqual(state, lldb.eStateRunning, "Got running event")
+                    self.assertState(state, lldb.eStateRunning, "Got running event")
             # The last event we should get is the exited event
-            self.assertEqual(state, lldb.eStateExited, "Got running event")
+            self.assertState(state, lldb.eStateExited, "Got exit event")
         else:
             # Make sure that the process has indeed exited
             state = process.GetState()
-            self.assertEqual(state, lldb.eStateExited);
+            self.assertState(state, lldb.eStateExited);
 
     def setup_remote_platform(self):
         return
         self.build()
 
         exe = self.getBuildArtifact('a.out')
         # Launch our test binary.
 

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

def test_with_python(self):
 
         # inner_sint returns the variable value, so capture that here:
         in_int = thread.GetFrameAtIndex(0).FindVariable(
             "value").GetValueAsSigned(error)
         self.assertSuccess(error)
 
         thread.StepOut()
 
-        self.assertEquals(self.process.GetState(), lldb.eStateStopped)
+        self.assertState(self.process.GetState(), lldb.eStateStopped)
         self.assertEquals(thread.GetStopReason(), lldb.eStopReasonPlanComplete)
 
         frame = thread.GetFrameAtIndex(0)
         fun_name = frame.GetFunctionName()
         self.assertEquals(fun_name, "outer_sint(int)")
 
         return_value = thread.GetStopReturnValue()
         self.assertTrue(return_value.IsValid())
def test_with_python(self):
         frame = thread.GetFrameAtIndex(1)
         fun_name = frame.GetFunctionName()
         self.assertEquals(fun_name, "outer_sint(int)")
         in_int = frame.FindVariable("value").GetValueAsSigned(error)
         self.assertSuccess(error)
 
         thread.StepOutOfFrame(frame)
 
-        self.assertEquals(self.process.GetState(), lldb.eStateStopped)
+        self.assertState(self.process.GetState(), lldb.eStateStopped)
         self.assertEquals(thread.GetStopReason(), lldb.eStopReasonPlanComplete)
         frame = thread.GetFrameAtIndex(0)
         fun_name = frame.GetFunctionName()
         self.assertEquals(fun_name, "main")
 
         ret_value = thread.GetStopReturnValue()
         self.assertTrue(return_value.IsValid())
         ret_int = ret_value.GetValueAsSigned(error)
def test_with_python(self):
 
         self.target.BreakpointDelete(inner_float_bkpt.GetID())
 
         frame = thread.GetFrameAtIndex(0)
         in_value = frame.FindVariable("value")
         in_float = float(in_value.GetValue())
         thread.StepOut()
 
-        self.assertEquals(self.process.GetState(), lldb.eStateStopped)
+        self.assertState(self.process.GetState(), lldb.eStateStopped)
         self.assertEquals(thread.GetStopReason(), lldb.eStopReasonPlanComplete)
 
         frame = thread.GetFrameAtIndex(0)
         fun_name = frame.GetFunctionName()
         self.assertEquals(fun_name, "outer_float(float)")
 
         #return_value = thread.GetStopReturnValue()
         #self.assertTrue(return_value.IsValid())
def return_and_test_struct_value(self, func_name):
         # once we've stepped we won't be able to get them?
 
         for idx in range(0, num_in_children):
             in_child = in_value.GetChildAtIndex(idx)
             in_child_str = in_child.GetValue()
 
         thread.StepOut()
 
-        self.assertEquals(self.process.GetState(), lldb.eStateStopped)
+        self.assertState(self.process.GetState(), lldb.eStateStopped)
         self.assertEquals(thread.GetStopReason(), lldb.eStopReasonPlanComplete)
 
         # Assuming all these functions step out to main.  Could figure out the caller dynamically
         # if that would add something to the test.
         frame = thread.GetFrameAtIndex(0)
         fun_name = frame.GetFunctionName()
         self.assertEquals(fun_name, "main")
 

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

def test_get_dynamic_vals(self):
             'pass-to-base.cpp', self.main_second_call_line)
         self.assertTrue(second_call_bpt,
                         VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at the entry point.
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
 
-        self.assertEquals(process.GetState(), lldb.eStateStopped,
+        self.assertState(process.GetState(), lldb.eStateStopped,
                          PROCESS_STOPPED)
 
         threads = lldbutil.get_threads_stopped_at_breakpoint(
             process, first_call_bpt)
         self.assertEquals(len(threads), 1)
         thread = threads[0]
 
         frame = thread.GetFrameAtIndex(0)
 

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

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

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

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

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

def test_get_baseclass(self):
         self.assertTrue(target, VALID_TARGET)
 
         # Set up our breakpoints:
 
         target.BreakpointCreateByLocation('main.m', self.line)
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
 
-        self.assertEquals(process.GetState(), lldb.eStateStopped,
+        self.assertState(process.GetState(), lldb.eStateStopped,
                          PROCESS_STOPPED)
 
         var = self.frame().FindVariable("foo")
         var_ptr_type = var.GetType()
         var_pte_type = var_ptr_type.GetPointeeType()
         self.assertEqual(
             var_ptr_type.GetNumberOfDirectBaseClasses(), 1,
             "Foo * has one base class")
         self.assertEqual(

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

def test_get_objc_dynamic_vals(self):
         self.assertTrue(main_before_setProperty_bkpt and
                         main_before_setProperty_bkpt.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at the entry point.
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
 
-        self.assertEquals(process.GetState(), lldb.eStateStopped,
+        self.assertState(process.GetState(), lldb.eStateStopped,
                          PROCESS_STOPPED)
 
         threads = lldbutil.get_threads_stopped_at_breakpoint(
             process, main_before_setProperty_bkpt)
         self.assertEquals(len(threads), 1)
         thread = threads[0]
 
         #
         #  At this point, myObserver has a Source pointer that is actually a KVO swizzled SourceDerived

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

def test_objc_properties(self):
         self.assertTrue(main_bkpt and
                         main_bkpt.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at the entry point.
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
 
-        self.assertEquals(process.GetState(), lldb.eStateStopped,
+        self.assertState(process.GetState(), lldb.eStateStopped,
                          PROCESS_STOPPED)
 
         threads = lldbutil.get_threads_stopped_at_breakpoint(
             process, main_bkpt)
         self.assertEquals(len(threads), 1)
         thread = threads[0]
         frame = thread.GetFrameAtIndex(0)
 
         mine = frame.FindVariable("mine")

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

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

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

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

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

def do_test(self, command):
         main_bp = self.target.BreakpointCreateByName("main", "a.out")
         self.assertTrue(main_bp, VALID_BREAKPOINT)
 
         self.process = self.target.LaunchSimple(
             None, None, self.get_process_working_directory())
         self.assertTrue(self.process, PROCESS_IS_VALID)
 
         # The stop reason of the thread should be breakpoint.
-        self.assertEquals(self.process.GetState(), lldb.eStateStopped,
-                          STOPPED_DUE_TO_BREAKPOINT)
+        self.assertState(self.process.GetState(), lldb.eStateStopped,
 
         self.runCmd(command)
         self.expect("frame select", substrs=['a.out`main at main.c'])
 
     @no_debug_info_test
     def test_frame(self):
         self.do_test("add-dsym --frame")
 
     @no_debug_info_test
     def test_uuid(self):
         self.do_test("add-dsym --uuid {}".format(self.uuid))
 
     @no_debug_info_test
     def test_stack(self):
         self.do_test("add-dsym --stack")

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

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

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

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

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

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

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

def test_change_value(self):
         self.assertTrue(end_breakpoint, VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at entry point.
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
         self.assertTrue(process, PROCESS_IS_VALID)
 
         # Get Frame #0.
-        self.assertEquals(process.GetState(), lldb.eStateStopped)
+        self.assertState(process.GetState(), lldb.eStateStopped)
         thread = lldbutil.get_stopped_thread(
             process, lldb.eStopReasonBreakpoint)
         self.assertTrue(
             thread.IsValid(),
             "There should be a thread stopped due to breakpoint condition")
         frame0 = thread.GetFrameAtIndex(0)
         self.assertTrue(frame0.IsValid(), "Got a valid frame.")
 
def test_change_value(self):
                         "Got the right changed value from ptr->second_val")
 
         # gcc may set multiple locations for breakpoint
         breakpoint.SetEnabled(False)
 
         # Now continue.
         process.Continue()
 
-        self.assertEquals(process.GetState(), lldb.eStateStopped)
+        self.assertState(process.GetState(), lldb.eStateStopped)
         thread = lldbutil.get_stopped_thread(
             process, lldb.eStopReasonBreakpoint)
         self.assertTrue(
             thread.IsValid(),
             "There should be a thread stopped due to breakpoint condition")
 
         expected_value = "Val - 12345 Mine - 55, 98765, 55555555. Ptr - 66, 98765, 66666666"
         stdout = process.GetSTDOUT(1000)
def test_change_value(self):
             "Got the right changed value for sp.")
 
         # Boundary condition test the SBValue.CreateValueFromExpression() API.
         # LLDB should not crash!
         nosuchval = mine_value.CreateValueFromExpression(None, None)
 
         process.Continue()
 
-        self.assertEquals(process.GetState(), lldb.eStateStopped)
+        self.assertState(process.GetState(), lldb.eStateStopped)
         thread = lldbutil.get_stopped_thread(
             process, lldb.eStopReasonBreakpoint)
         self.assertTrue(
             thread is None,
             "We should not have managed to hit our second breakpoint with sp == 1")
 
         process.Kill()

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

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