[lldb] Use assertState in more tests (NFC)

[kastiglione]

Summary

Followup to D127355, converting assertEqual (singular) to assertState.

[JDevlieghere]

In never realized we had both assertEqual and assertEquals. Great...

[kastiglione]

@JDevlieghere assertEquals is the deprecated name, assertEqual is the

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.assertEqual(process.GetState(), lldb.eStateStopped,
+        self.assertState(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")
 
         # Extract the value of fstat and ftag flag at the point just before

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

def test(self):
         self.build()
         target = self.createTestTarget()
 
         bp = target.BreakpointCreateByName("main")
         self.assertTrue(bp and bp.IsValid(), "Breakpoint is valid")
 
         process = target.LaunchSimple(None, None,
                 self.get_process_working_directory())
-        self.assertEqual(process.GetState(), lldb.eStateStopped)
+        self.assertState(process.GetState(), lldb.eStateStopped)
 
         thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
         self.assertIsNotNone(thread)
 
         frame = thread.GetFrameAtIndex(0)
         self.assertTrue(frame and frame.IsValid(), "Frame is valid")
 
         buf = frame.FindValue("buf", lldb.eValueTypeVariableGlobal)
         self.assertTrue(buf and buf.IsValid(), "buf is valid")
 
         for i in [0, target.GetAddressByteSize()]:
             member = buf.GetChildAtIndex(i)
             self.assertTrue(member and member.IsValid(), "member is valid")
 
             error = lldb.SBError()
             watch = member.Watch(True, True, True, error)
             self.assertSuccess(error)
 
         process.Continue();
-        self.assertEqual(process.GetState(), lldb.eStateStopped)
+        self.assertState(process.GetState(), lldb.eStateStopped)
         self.assertEqual(thread.GetStopReason(), lldb.eStopReasonWatchpoint)
 

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

def simple_auto_continue(self):
 
         bkpt = self.target.FindBreakpointByID(bpno)
         self.assertEqual(bkpt.GetHitCount(), 2, "Should have run through the breakpoint twice")
 
     def auto_continue_with_command(self):
         bpno = self.make_target_and_bkpt("-N BKPT -C 'break modify --auto-continue 0 BKPT'")
         process = self.launch_it(lldb.eStateStopped)
         state = process.GetState()
-        self.assertEqual(state, lldb.eStateStopped, "Process should be stopped")
+        self.assertState(state, lldb.eStateStopped, "Process should be stopped")
         bkpt = self.target.FindBreakpointByID(bpno)
         threads = lldbutil.get_threads_stopped_at_breakpoint(process, bkpt)
         self.assertEqual(len(threads), 1, "There was a thread stopped at our breakpoint")
         self.assertEqual(bkpt.GetHitCount(), 2, "Should have hit the breakpoint twice")
 
     def auto_continue_location(self):
         bpno = self.make_target_and_bkpt(pattern="Set a[^ ]* breakpoint here", num_expected_loc=2)
         bkpt = self.target.FindBreakpointByID(bpno)

lldb/test/API/functionalities/breakpoint/debugbreak/TestDebugBreak.py

def test_asm_int_3(self):
         exe = self.getBuildArtifact("a.out")
 
         # Run the program.
         target = self.dbg.CreateTarget(exe)
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
 
         # We've hit the first stop, so grab the frame.
-        self.assertEqual(process.GetState(), lldb.eStateStopped)
+        self.assertState(process.GetState(), lldb.eStateStopped)
         stop_reason = lldb.eStopReasonException if (lldbplatformutil.getPlatform(
         ) == "windows" or lldbplatformutil.getPlatform() == "macosx") else lldb.eStopReasonSignal
         thread = lldbutil.get_stopped_thread(process, stop_reason)
         self.assertIsNotNone(
             thread, "Unable to find thread stopped at the __debugbreak()")
         frame = thread.GetFrameAtIndex(0)
 
         # We should be in funciton 'bar'.

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.assertEqual(process.GetState(), lldb.eStateStopped,
+        self.assertState(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
         # immediate caller is a() and we want to find out the value passed from

lldb/test/API/functionalities/dyld-exec-linux/TestDyldExecLinux.py

def test(self):
         self.assertSuccess(error)
 
         threads = lldbutil.get_stopped_threads(process, lldb.eStopReasonExec)
         self.assertEqual(len(threads), 1, "We got a thread stopped for exec.")
 
         process.Continue();
 
         # Stopped on main here.
-        self.assertEqual(process.GetState(), lldb.eStateStopped)
+        self.assertState(process.GetState(), lldb.eStateStopped)
         thread = process.GetSelectedThread()
         self.assertIn("main", thread.GetFrameAtIndex(0).GetDisplayFunctionName())

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

def test(self):
         breakpoint_shared_library = target.BreakpointCreateBySourceRegex("get_signal_crash", lldb.SBFileSpec("signal_file.cpp"))
         launch_info = lldb.SBLaunchInfo([ "--library-path", self.get_process_working_directory(), self.getBuildArtifact("a.out")])
         launch_info.SetWorkingDirectory(self.get_process_working_directory())
         error = lldb.SBError()
         process = target.Launch(launch_info, error)
         self.assertSuccess(error)
 
         # Stopped on main here.
-        self.assertEqual(process.GetState(), lldb.eStateStopped)
+        self.assertState(process.GetState(), lldb.eStateStopped)
         thread = process.GetSelectedThread()
         self.assertIn("main", thread.GetFrameAtIndex(0).GetDisplayFunctionName())
         process.Continue()
 
         # Stopped on get_signal_crash function here.
-        self.assertEqual(process.GetState(), lldb.eStateStopped)
+        self.assertState(process.GetState(), lldb.eStateStopped)
         self.assertIn("get_signal_crash", thread.GetFrameAtIndex(0).GetDisplayFunctionName())
         process.Continue()
 
         # Stopped because of generated signal.
-        self.assertEqual(process.GetState(), lldb.eStateStopped)
+        self.assertState(process.GetState(), lldb.eStateStopped)
         self.assertIn("raise", thread.GetFrameAtIndex(0).GetDisplayFunctionName())
         self.assertIn("get_signal_crash", thread.GetFrameAtIndex(1).GetDisplayFunctionName())

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.assertEqual(process.GetState(), lldb.eStateStopped,
+        self.assertState(process.GetState(), lldb.eStateStopped,
                          STOPPED_DUE_TO_BREAKPOINT)
 
         threads = lldbutil.get_threads_stopped_at_breakpoint(
         process, breakpoint1)
         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.assertEqual(int_value, 3, "Expression got the right result.")
 
         # Run and we should stop due to exec
         process.Continue()
 
         if not skip_exec:
             self.assertNotEqual(process.GetState(), lldb.eStateExited,
                                 "Process should not have exited!")
-            self.assertEqual(process.GetState(), lldb.eStateStopped,
+            self.assertState(process.GetState(), lldb.eStateStopped,
                              "Process should be stopped at __dyld_start")
 
             threads = lldbutil.get_stopped_threads(
                 process, lldb.eStopReasonExec)
             self.assertEqual(
                 len(threads), 1,
                 "We got a thread stopped for exec.")
 
def test_correct_thread_plan_state_before_exec(self):
         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.assertEqual(process.GetState(), lldb.eStateStopped,
+        self.assertState(process.GetState(), lldb.eStateStopped,
                          STOPPED_DUE_TO_BREAKPOINT)
 
         threads = lldbutil.get_threads_stopped_at_breakpoint(process, breakpoint1)
         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
def test_correct_thread_plan_state_before_exec(self):
         # Run and we should stop due to exec
         breakpoint2 = target.BreakpointCreateBySourceRegex(
             'Set breakpoint 2 here', lldb.SBFileSpec("secondprog.cpp", False))
 
         process.Continue()
 
         self.assertNotEqual(process.GetState(), lldb.eStateExited,
                             "Process should not have exited!")
-        self.assertEqual(process.GetState(), lldb.eStateStopped,
+        self.assertState(process.GetState(), lldb.eStateStopped,
                          "Process should be stopped at __dyld_start")
 
         threads = lldbutil.get_stopped_threads(
             process, lldb.eStopReasonExec)
         self.assertEqual(
             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.assertEqual(len(threads), 1,
                         "Stopped at breakpoint in exec'ed process.")

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

def do_test(self, use_target_create):
         # We need to fetch the connected event:
         lldbutil.expect_state_changes(self, self.dbg.GetListener(), process, [lldb.eStateConnected])
 
         self.server.responder.after_launch = True
 
         process = target.Launch(launch_info, error)
 
         self.assertSuccess(error, "Successfully launched.")
-        self.assertEqual(process.GetState(), lldb.eStateStopped, "Should be stopped at entry")
+        self.assertState(process.GetState(), lldb.eStateStopped, "Should be stopped at entry")
         self.assertIsNotNone(self.a_packet_file, "A packet was sent")
         self.assertEqual(self.absent_file, self.a_packet_file, "The A packet file was correct")

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

def test(self):
                     self.dbg.StateAsCString(process.GetStateFromEvent(event)))
             if process.GetStateFromEvent(event) == lldb.eStateExited:
                 break
 
         # We should get only one continue packet as the client should not
         # auto-continue after setting the breakpoint.
         self.assertEqual(self.server.responder.continueCount, 1)
         # And the process should end up in the stopped state.
-        self.assertEqual(process.GetState(), lldb.eStateStopped)
+        self.assertState(process.GetState(), lldb.eStateStopped)

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

def test_deeper_stack_in_mini_dump(self):
         exe = self.getBuildArtifact("a.out")
         core = self.getBuildArtifact("core.dmp")
         try:
             # Set a breakpoint and capture a mini dump.
             target = self.dbg.CreateTarget(exe)
             breakpoint = target.BreakpointCreateByName("bar")
             process = target.LaunchSimple(
                 None, None, self.get_process_working_directory())
-            self.assertEqual(process.GetState(), lldb.eStateStopped)
+            self.assertState(process.GetState(), lldb.eStateStopped)
             self.assertTrue(process.SaveCore(core))
             self.assertTrue(os.path.isfile(core))
             self.assertSuccess(process.Kill())
 
             # Launch with the mini dump, and inspect the stack.
             target = self.dbg.CreateTarget(None)
             process = target.LoadCore(core)
             thread = process.GetThreadAtIndex(0)
def test_local_variables_in_mini_dump(self):
         exe = self.getBuildArtifact("a.out")
         core = self.getBuildArtifact("core.dmp")
         try:
             # Set a breakpoint and capture a mini dump.
             target = self.dbg.CreateTarget(exe)
             breakpoint = target.BreakpointCreateByName("bar")
             process = target.LaunchSimple(
                 None, None, self.get_process_working_directory())
-            self.assertEqual(process.GetState(), lldb.eStateStopped)
+            self.assertState(process.GetState(), lldb.eStateStopped)
             self.assertTrue(process.SaveCore(core))
             self.assertTrue(os.path.isfile(core))
             self.assertSuccess(process.Kill())
 
             # Launch with the mini dump, and inspect a local variable.
             target = self.dbg.CreateTarget(None)
             process = target.LoadCore(core)
             thread = process.GetThreadAtIndex(0)

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

def test_save_windows_mini_dump(self):
         self.build()
         exe = self.getBuildArtifact("a.out")
         core = self.getBuildArtifact("core.dmp")
         try:
             target = self.dbg.CreateTarget(exe)
             breakpoint = target.BreakpointCreateByName("bar")
             process = target.LaunchSimple(
                 None, None, self.get_process_working_directory())
-            self.assertEqual(process.GetState(), lldb.eStateStopped)
+            self.assertState(process.GetState(), lldb.eStateStopped)
             self.assertTrue(process.SaveCore(core))
             self.assertTrue(os.path.isfile(core))
             self.assertSuccess(process.Kill())
 
             # To verify, we'll launch with the mini dump, and ensure that we see
             # the executable in the module list.
             target = self.dbg.CreateTarget(None)
             process = target.LoadCore(core)
def test_save_core_via_process_plugin(self):
         self.build()
         exe = self.getBuildArtifact("a.out")
         core = self.getBuildArtifact("a.out.core")
         try:
             target = self.dbg.CreateTarget(exe)
             breakpoint = target.BreakpointCreateByName("bar")
             process = target.LaunchSimple(
                 None, None, self.get_process_working_directory())
-            self.assertEqual(process.GetState(), lldb.eStateStopped)
+            self.assertState(process.GetState(), lldb.eStateStopped)
             self.assertTrue(process.SaveCore(core))
             self.assertTrue(os.path.isfile(core))
             self.assertSuccess(process.Kill())
             pid = process.GetProcessID()
 
             target = self.dbg.CreateTarget(None)
             process = target.LoadCore(core)
             self.assertTrue(process, PROCESS_IS_VALID)
             self.assertEqual(process.GetProcessID(), pid)
 
         finally:
             self.assertTrue(self.dbg.DeleteTarget(target))
             try:
                 os.unlink(core)
             except OSError:
                 pass

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

def test_save_linux_mini_dump(self):
         self.build()
         exe = self.getBuildArtifact("a.out")
         core = self.getBuildArtifact("core.dmp")
         core_sb = self.getBuildArtifact("core_sb.dmp")
         try:
             target = self.dbg.CreateTarget(exe)
             process = target.LaunchSimple(
                 None, None, self.get_process_working_directory())
-            self.assertEqual(process.GetState(), lldb.eStateStopped)
+            self.assertState(process.GetState(), lldb.eStateStopped)
 
             # get neccessary data for the verification phase
             process_info = process.GetProcessInfo()
             expected_pid = process_info.GetProcessID() if process_info.IsValid() else -1
             expected_number_of_modules = target.GetNumModules()
             expected_modules = target.modules
             expected_number_of_threads = process.GetNumThreads()
             expected_threads = []

lldb/test/API/functionalities/signal/handle-abrt/TestHandleAbort.py

def test_inferior_handle_sigabrt(self):
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # launch
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
         self.assertTrue(process, PROCESS_IS_VALID)
-        self.assertEqual(process.GetState(), lldb.eStateStopped)
+        self.assertState(process.GetState(), lldb.eStateStopped)
         signo = process.GetUnixSignals().GetSignalNumberFromName("SIGABRT")
 
         thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonSignal)
         self.assertTrue(
             thread and thread.IsValid(),
             "Thread should be stopped due to a signal")
         self.assertTrue(
             thread.GetStopReasonDataCount() >= 1,

lldb/test/API/functionalities/signal/handle-segv/TestHandleSegv.py

def test_inferior_handle_sigsegv(self):
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # launch
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
         self.assertTrue(process, PROCESS_IS_VALID)
-        self.assertEqual(process.GetState(), lldb.eStateStopped)
+        self.assertState(process.GetState(), lldb.eStateStopped)
         signo = process.GetUnixSignals().GetSignalNumberFromName("SIGSEGV")
 
         thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonSignal)
         self.assertTrue(
             thread and thread.IsValid(),
             "Thread should be stopped due to a signal")
         self.assertTrue(
             thread.GetStopReasonDataCount() >= 1,
             "There was data in the event.")
         self.assertEqual(thread.GetStopReasonDataAtIndex(0),
                          signo, "The stop signal was SIGSEGV")
 
         # Continue until we exit.
         process.Continue()
         self.assertEqual(process.GetState(), lldb.eStateExited)
         self.assertEqual(process.GetExitStatus(), 0)

lldb/test/API/functionalities/signal/raise/TestRaise.py

def launch(self, target, signal):
         # launch the process, do not stop at entry point.
         # If we have gotten the default for this signal, reset that as well.
         if len(self.default_pass) != 0:
             lldbutil.set_actions_for_signal(self, signal, self.default_pass, self.default_stop, self.default_notify)
 
         process = target.LaunchSimple(
             [signal], None, self.get_process_working_directory())
         self.assertTrue(process, PROCESS_IS_VALID)
-        self.assertEqual(process.GetState(), lldb.eStateStopped)
+        self.assertState(process.GetState(), lldb.eStateStopped)
         thread = lldbutil.get_stopped_thread(
             process, lldb.eStopReasonBreakpoint)
         self.assertTrue(
             thread.IsValid(),
             "Thread should be stopped due to a breakpoint")
         return process
 
     def set_handle(self, signal, pass_signal, stop_at_signal, notify_signal):
def signal_test(self, signal, test_passing):
         signo = process.GetUnixSignals().GetSignalNumberFromName(signal)
 
         # retrieve default signal disposition
         (self.default_pass, self.default_stop, self.default_notify) = lldbutil.get_actions_for_signal(self, signal)
 
         # Make sure we stop at the signal
         lldbutil.set_actions_for_signal(self, signal, "false", "true", "true")
         process.Continue()
-        self.assertEqual(process.GetState(), lldb.eStateStopped)
+        self.assertState(process.GetState(), lldb.eStateStopped)
         thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonSignal)
         self.assertTrue(
             thread.IsValid(),
             "Thread should be stopped due to a signal")
         self.assertTrue(
             thread.GetStopReasonDataCount() >= 1,
             "There was data in the event.")
         self.assertEqual(thread.GetStopReasonDataAtIndex(0), signo,
def signal_test(self, signal, test_passing):
             return
 
         # launch again
         process = self.launch(target, signal)
 
         # Make sure we stop at the signal
         lldbutil.set_actions_for_signal(self, signal, "true", "true", "true")
         process.Continue()
-        self.assertEqual(process.GetState(), lldb.eStateStopped)
+        self.assertState(process.GetState(), lldb.eStateStopped)
         thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonSignal)
         self.assertTrue(
             thread.IsValid(),
             "Thread should be stopped due to a signal")
         self.assertTrue(
             thread.GetStopReasonDataCount() >= 1,
             "There was data in the event.")
         self.assertEqual(

lldb/test/API/functionalities/step-vrs-interrupt/TestStepVrsInterruptTimeout.py

def sample_test(self):
         # breakpoint, runs to it, and returns the thread, process & target.
         # It optionally takes an SBLaunchOption argument if you want to pass
         # arguments or environment variables.
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
                                    "Set a breakpoint here", self.main_source_file)
         self.dbg.SetAsync(False)
         self.runCmd("settings set target.process.interrupt-timeout 1")
         thread.StepOver()
-        self.assertEqual(process.GetState(), lldb.eStateStopped, "Stopped like we should")
+        self.assertState(process.GetState(), lldb.eStateStopped, "Stopped like we should")

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

def do_test_checking_variable(self, use_cli):
             data.Print('{"variable_name" : "foo"}')
             error = args_data.SetFromJSON(data)
             self.assertSuccess(error, "Made the args_data correctly")
 
             err = thread.StepUsingScriptedThreadPlan("Steps.StepUntil", args_data, True)
             self.assertSuccess(err)
 
         # We should not have exited:
-        self.assertEqual(process.GetState(), lldb.eStateStopped, "We are stopped")
+        self.assertState(process.GetState(), lldb.eStateStopped, "We are stopped")
 
         # We should still be in foo:
         self.assertEqual("foo", frame.GetFunctionName())
 
         # And foo should have changed:
         self.assertTrue(foo_val.GetValueDidChange(), "Foo changed")
 
     def test_stop_others_from_command(self):

lldb/test/API/functionalities/stop-on-sharedlibrary-load/TestStopOnSharedlibraryEvents.py

def do_test(self, bkpt_modifier = None):
 
         # Since I don't know how to check that we are at the "right place" to stop for
         # shared library events, make an breakpoint after the load is done and
         # make sure we don't stop there:
         backstop_bkpt_1 = target.BreakpointCreateBySourceRegex("Set another here - we should not hit this one", main_spec)
         self.assertGreater(backstop_bkpt_1.GetNumLocations(), 0, "Set our second breakpoint")
         
         process.Continue() 
-        self.assertEqual(process.GetState(), lldb.eStateStopped, "We didn't stop for the load")
+        self.assertState(process.GetState(), lldb.eStateStopped, "We didn't stop for the load")
         self.assertEqual(backstop_bkpt_1.GetHitCount(), 0, "Hit our backstop breakpoint")
         
         # We should be stopped after the library is loaded, check that:
         found_it = False
         for module in target.modules:
             if module.file.basename.find("load_a") > -1:
                 found_it = True
                 break
         self.assertTrue(found_it, "Found the loaded module.")
 
         # Now capture the place where we stopped so we can set a breakpoint and make
         # sure the breakpoint there works correctly:
         load_address = process.GetSelectedThread().frames[0].addr
         load_bkpt = target.BreakpointCreateBySBAddress(load_address)
         self.assertGreater(load_bkpt.GetNumLocations(), 0, "Set the load breakpoint")
 
         backstop_bkpt_1.SetEnabled(False)
 
         backstop_bkpt_2 = target.BreakpointCreateBySourceRegex("Set a third here - we should not hit this one", main_spec)
         self.assertGreater(backstop_bkpt_2.GetNumLocations(), 0, "Set our third breakpoint")
             
         if bkpt_modifier == None:
             process.Continue()
-            self.assertEqual(process.GetState(), lldb.eStateStopped, "We didn't stop for the load")
+            self.assertState(process.GetState(), lldb.eStateStopped, "We didn't stop for the load")
             self.assertEqual(backstop_bkpt_2.GetHitCount(), 0, "Hit our backstop breakpoint")
             self.assertEqual(thread.stop_reason, lldb.eStopReasonBreakpoint, "We attributed the stop to the breakpoint")
             self.assertEqual(load_bkpt.GetHitCount(), 1, "We hit our breakpoint at the load address")
         else:
             bkpt_modifier(load_bkpt)
             process.Continue()
-            self.assertEqual(process.GetState(), lldb.eStateStopped, "We didn't stop")
+            self.assertState(process.GetState(), lldb.eStateStopped, "We didn't stop")
             self.assertTrue(thread.IsValid(), "Our thread was no longer valid.")
             self.assertEqual(thread.stop_reason, lldb.eStopReasonBreakpoint, "We didn't hit some breakpoint")
             self.assertEqual(backstop_bkpt_2.GetHitCount(), 1, "We continued to the right breakpoint")
 
         
         
         
         

lldb/test/API/lang/c/step_over_no_deadlock/TestStepOverDoesntBlock.py

def test_step_over(self):
                                                                             "without running the first thread at least somewhat",
                                                                             lldb.SBFileSpec("locking.cpp"))
         # This is just testing that the step over actually completes.
         # If the test fails this step never return, so failure is really
         # signaled by the test timing out.
         
         thread.StepOver()
         state = process.GetState()
-        self.assertEqual(state, lldb.eStateStopped)
+        self.assertState(state, lldb.eStateStopped)

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.assertEqual(process.GetState(), lldb.eStateStopped,
+        self.assertState(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)

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.assertEqual(process.GetState(), lldb.eStateStopped,
+        self.assertState(process.GetState(), lldb.eStateStopped,
                          PROCESS_STOPPED)
 
         threads = lldbutil.get_threads_stopped_at_breakpoint(
             process, main_bkpt)
         self.assertEqual(len(threads), 1)
         thread = threads[0]
 
         #
         #  The class Simple doesn't have a count method.  Make sure that we don't

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

def test_unwind_signal(self):
         exe = self.getBuildArtifact("a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
         self.assertTrue(process, PROCESS_IS_VALID)
-        self.assertEqual(process.GetState(), lldb.eStateStopped)
+        self.assertState(process.GetState(), lldb.eStateStopped)
         signo = process.GetUnixSignals().GetSignalNumberFromName("SIGILL")
 
         thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonSignal)
         self.assertTrue(
             thread and thread.IsValid(),
             "Thread should be stopped due to a signal")
         self.assertTrue(
             thread.GetStopReasonDataCount() >= 1,

lldb/test/API/macosx/ignore_exceptions/TestIgnoredExceptions.py

def suspended_thread_test(self):
         sig_bkpt = target.BreakpointCreateBySourceRegex("stop here in the signal handler",
                                                         self.main_source_file)
         self.assertEqual(sig_bkpt.GetNumLocations(), 1, "Found sig handler breakpoint")
         return_bkpt = target.BreakpointCreateBySourceRegex("Break here to make sure we got past the signal handler",
                                                         self.main_source_file)
         self.assertEqual(return_bkpt.GetNumLocations(), 1, "Found return breakpoint")
         # Now continue, and we should stop with a stop reason of SIGBUS:
         process.Continue()
-        self.assertEqual(process.state, lldb.eStateStopped, "Stopped after continue to SIGBUS")
+        self.assertState(process.state, lldb.eStateStopped, "Stopped after continue to SIGBUS")
         if thread.stop_reason == lldb.eStopReasonBreakpoint:
             id = thread.GetStopReasonDataAtIndex(0)
             name = thread.frame[0].name
             self.fail("Hit breakpoint {0} in '{1}' rather than getting a SIGBUS".format(id, name))
 
         self.assertEqual(thread.stop_reason, lldb.eStopReasonSignal)
         self.assertEqual(thread.GetStopReasonDataAtIndex(0), 10, "Got a SIGBUS")
 

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.assertEqual(process.GetState(), lldb.eStateStopped,
+        self.assertState(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()
         while process.GetState() == lldb.eStateStopped:
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.assertEqual(process.GetState(), lldb.eStateStopped,
+        self.assertState(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.assertEqual(process.GetState(), lldb.eStateStopped,
+        self.assertState(process.GetState(), lldb.eStateStopped,
                          PROCESS_STOPPED)
 
         thread = lldbutil.get_stopped_thread(
             process, lldb.eStopReasonBreakpoint)
         self.assertIsNotNone(thread)
 
         frameEntered = thread.GetFrameAtIndex(0)
         if self.TraceOn():
             print(frameEntered)

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.assertEqual(process.GetState(), lldb.eStateStopped,
+        self.assertState(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)
 
def test_stop_at_outer_inline(self):
             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.assertEqual(process.GetState(), lldb.eStateStopped,
+            self.assertState(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.assertEqual(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)
         lineEntry = frame0.GetLineEntry()
         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.assertEqual(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)
         lineEntry = frame0.GetLineEntry()
         self.assertEqual(lineEntry.GetLine(), self.line2)

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.assertEqual(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)
         symbol_line1 = frame0.GetSymbol()
         # We should have a symbol type of code.
         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.assertEqual(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)
         symbol_line2 = frame0.GetSymbol()
         # We should have a symbol type of code.

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.assertEqual(process.GetState(), lldb.eStateStopped,
+        self.assertState(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)
         frame1 = thread.GetFrameAtIndex(1)

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

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.assertEqual(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")
         #self.runCmd("process status")
         frame0 = thread.GetFrameAtIndex(0)
         lineEntry = frame0.GetLineEntry()
         self.assertEqual(lineEntry.GetLine(), self.line1)
 
         address1 = lineEntry.GetStartAddress()
 
         # Continue the inferior, the breakpoint 2 should be hit.
         process.Continue()
-        self.assertEqual(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")
         #self.runCmd("process status")
         frame0 = thread.GetFrameAtIndex(0)
         lineEntry = frame0.GetLineEntry()

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.assertEqual(process.GetState(), lldb.eStateStopped)
+        self.assertState(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.assertEqual(lineEntry.GetLine(), self.step_out_of_malloc)
def run_to_address(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.assertEqual(process.GetState(), lldb.eStateStopped)
+        self.assertState(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.assertEqual(lineEntry.GetLine(), self.step_out_of_malloc)

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.assertEqual(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)
 
         # Get the type 'Task'.

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.assertEqual(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)
 
         # Get global variable 'days_of_week'.

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.assertEqual(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)
 
         # Get variable 'task_head'.

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.assertEqual(process.GetState(), lldb.eStateStopped,
+        self.assertState(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, True, True, error)

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

def test_set_watch_ignore_count(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.assertEqual(process.GetState(), lldb.eStateStopped,
+        self.assertState(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, True, True, error)

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.assertEqual(process.GetState(), lldb.eStateStopped,
+        self.assertState(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)

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.assertEqual(process.GetState(), lldb.eStateStopped,
+        self.assertState(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()
         watchpoint = value.Watch(True, False, True, error)

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.assertEqual(process.GetState(), lldb.eStateStopped,
+        self.assertState(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(
             "pointee",

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.assertEqual(process.GetState(), lldb.eStateStopped,
+        self.assertState(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(
             "pointee",
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.assertEqual(process.GetState(), lldb.eStateStopped,
+        self.assertState(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(
             "pointee",