[lldb] Add assertStopReason helper function

[JDevlieghere]

Summary

Add a function to make it easier to debug a test failure caused by an unexpected stop reason. This is similar to the assertState helper function that I added in D127355.

Before:

self.assertEqual(stop_reason, lldb.eStopReasonInstrumentation)
AssertionError: 5 != 10

After:

self.assertStopReason(stop_reason, lldb.eStopReasonInstrumentation)
AssertionError: signal (5) != instrumentation (10)

[JDevlieghere]

Add missing stop reasons

[mib]

LGTM!

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

269–272

This is more a general comment, but I'm very annoyed at how C/C++ enums are exposed to Python ... Now every time we add a new value to the enum we need to remember to update these helper function. The comment is not related specifically to this patch but I think we can do a better job here.

[JDevlieghere]

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

269–272

I'm sure there's some kind of introspection API that would allow us to have the equivalent of a static_assert in C++. I'll add it to my list of nice-to-haves :-)

[kastiglione]

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

269–272

https://reviews.llvm.org/D131138

lldb/docs/resources/test.rst

**Prefer using specific asserts over the generic assertTrue/assertFalse.**.
     The `self.assertTrue`/`self.assertFalse` functions should always be your
     last option as they give non-descriptive error messages. The test class has
     several expressive asserts such as `self.assertIn` that automatically
     generate an explanation how the received values differ from the expected
     ones. Check the documentation of Python's `unittest` module to see what
     asserts are available. LLDB also has a few custom asserts that are tailored
     to our own data types.
 
-+-----------------------------------------------+---------------------------------------------------------------+
++-----------------------------------------------+-----------------------------------------------------------------+
 | **Assert**                                    | **Description**                                               |
-+-----------------------------------------------+---------------------------------------------------------------+
++-----------------------------------------------+-----------------------------------------------------------------+
 | ``assertSuccess``                             | Assert that an ``lldb.SBError`` is in the "success" state.    |
-+-----------------------------------------------+---------------------------------------------------------------+
++-----------------------------------------------+-----------------------------------------------------------------+
 | ``assertState``                               | Assert that two states (``lldb.eState*``) are equal.          |
-+-----------------------------------------------+---------------------------------------------------------------+
++-----------------------------------------------+-----------------------------------------------------------------+
+| ``assertStopReason``                          | Assert that two stop reasons (``lldb.eStopReason*``) are equal. |
++-----------------------------------------------+-----------------------------------------------------------------+
 
     If you can't find a specific assert that fits your needs and you fall back
     to a generic assert, make sure you put useful information into the assert's
     `msg` argument that helps explain the failure.
 
 ::
 
     # Bad. Will print a generic error such as 'False is not True'.

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

""".format(cmd_status, filecheck_cmd, output, cmd_stdout, cmd_stderr)
     """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))
 
+    """Assert two stop reasons are equal"""
+    def assertStopReason(self, first, second, msg=None):
+        if first != second:
+            error = "{} ({}) != {} ({})".format(
+                lldbutil.stop_reason_to_str(first), first,
+                lldbutil.stop_reason_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/packages/Python/lldbsuite/test/lldbutil.py

def stop_reason_to_str(enum):
     elif enum == lldb.eStopReasonSignal:
         return "signal"
     elif enum == lldb.eStopReasonException:
         return "exception"
     elif enum == lldb.eStopReasonPlanComplete:
         return "plancomplete"
     elif enum == lldb.eStopReasonThreadExiting:
         return "threadexiting"
+    elif enum == lldb.eStopReasonInstrumentation:
+        return "instrumentation"
+    elif enum == lldb.eStopReasonProcessorTrace:
+        return "processortrace"
     else:
         raise Exception("Unknown StopReason enum")
 
 
 def symbol_type_to_str(enum):
     """Returns the symbolType string given an enum."""
     if enum == lldb.eSymbolTypeInvalid:
         return "invalid"

lldb/test/API/commands/process/continue_to_bkpt/TestContinueToBkpts.py

class TestContinueToBkpts(TestBase):
     def continue_and_check(self, stop_list, bkpt_to_hit, loc_to_hit = 0):
         """Build up a command that will run a continue -b commands using the breakpoints on stop_list, and
            ensure that we hit bkpt_to_hit.
            If loc_to_hit is not 0, also verify that we hit that location."""
         command = "process continue"
         for elem in stop_list:
             command += " -b {0}".format(elem)
         self.expect(command)
-        self.assertEqual(self.thread.stop_reason, lldb.eStopReasonBreakpoint, "Hit a breakpoint")
+        self.assertStopReason(self.thread.stop_reason, lldb.eStopReasonBreakpoint, "Hit a breakpoint")
         self.assertEqual(self.thread.GetStopReasonDataAtIndex(0), bkpt_to_hit, "Hit the right breakpoint")
         if loc_to_hit != 0:
             self.assertEqual(self.thread.GetStopReasonDataAtIndex(1), loc_to_hit, "Hit the right location")
         for bkpt_id in self.bkpt_list:
             bkpt = self.target.FindBreakpointByID(bkpt_id)
             self.assertTrue(bkpt.IsValid(), "Breakpoint id's round trip")
             if bkpt.MatchesName("disabled"):
                 self.assertFalse(bkpt.IsEnabled(), "Disabled breakpoints stay disabled: {0}".format(bkpt.GetID()))

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

def test(self):
             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.assertState(process.GetState(), lldb.eStateStopped)
-        self.assertEqual(thread.GetStopReason(), lldb.eStopReasonWatchpoint)
+        self.assertStopReason(thread.GetStopReason(), lldb.eStopReasonWatchpoint)
 

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

def test(self):
         error = lldb.SBError()
 
         # resolve_location=True, read=True, write=False
         read_watchpoint = read_value.Watch(True, True, False, error)
         self.assertSuccess(error, "Error while setting watchpoint")
         self.assertTrue(read_watchpoint, "Failed to set read watchpoint.")
 
         thread.StepOver()
-        self.assertEquals(thread.GetStopReason(), lldb.eStopReasonWatchpoint,
+        self.assertStopReason(thread.GetStopReason(), lldb.eStopReasonWatchpoint,
                         STOPPED_DUE_TO_WATCHPOINT)
         self.assertEquals(thread.GetStopDescription(20), 'watchpoint 1')
 
         process.Continue()
         self.assertState(process.GetState(), lldb.eStateStopped,
                          PROCESS_STOPPED)
         self.assertEquals(thread.GetStopDescription(20), 'step over')
 
def test(self):
             self.runCmd("watchpoint delete 1")
 
         # resolve_location=True, read=False, write=True
         write_watchpoint = write_value.Watch(True, False, True, error)
         self.assertTrue(write_watchpoint, "Failed to set write watchpoint.")
         self.assertSuccess(error, "Error while setting watchpoint")
 
         thread.StepOver()
-        self.assertEquals(thread.GetStopReason(), lldb.eStopReasonWatchpoint,
+        self.assertStopReason(thread.GetStopReason(), lldb.eStopReasonWatchpoint,
                         STOPPED_DUE_TO_WATCHPOINT)
         self.assertEquals(thread.GetStopDescription(20), 'watchpoint 2')
 
         process.Continue()
         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:
             self.thread().StepInstruction(False)  # step_over=False
             stop_reason = self.thread().GetStopReason()
             if stop_reason == lldb.eStopReasonWatchpoint:
                 self.assertFalse(watchpoint_hit, "Watchpoint already hit.")
                 expected_stop_desc = "watchpoint %d" % wp_id
                 actual_stop_desc = self.thread().GetStopDescription(20)
                 self.assertEquals(actual_stop_desc, expected_stop_desc,
                                 "Watchpoint ID didn't match.")
                 watchpoint_hit = True
             else:
-                self.assertEquals(stop_reason, lldb.eStopReasonPlanComplete,
+                self.assertStopReason(stop_reason, lldb.eStopReasonPlanComplete,
                                 STOPPED_DUE_TO_STEP_IN)
         self.assertTrue(watchpoint_hit, "Watchpoint never hit.")

lldb/test/API/commands/watchpoints/watchpoint_count/TestWatchpointCount.py

def test_watchpoint_count(self):
         second_watch = second_var.Watch(True, False, True, error)
         if not error.Success():
             self.fail(
                 "Failed to make watchpoint for x2: %s" %
                 (error.GetCString()))
         process.Continue()
 
         stop_reason = thread.GetStopReason()
-        self.assertEqual(stop_reason, lldb.eStopReasonWatchpoint, "watchpoint for x1 not hit")
+        self.assertStopReason(stop_reason, lldb.eStopReasonWatchpoint, "watchpoint for x1 not hit")
         stop_reason_descr = thread.GetStopDescription(256)
         self.assertEqual(stop_reason_descr, "watchpoint 1")
 
         process.Continue()
         stop_reason = thread.GetStopReason()
-        self.assertEqual(stop_reason, lldb.eStopReasonWatchpoint, "watchpoint for x2 not hit")
+        self.assertStopReason(stop_reason, lldb.eStopReasonWatchpoint, "watchpoint for x2 not hit")
         stop_reason_descr = thread.GetStopDescription(256)
         self.assertEqual(stop_reason_descr, "watchpoint 2")

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

def do_test(self, test_enable):
 
         wp.SetEnabled(False)
         self.assertTrue(not wp.IsEnabled(), "The watchpoint thinks it is still enabled")
 
         process.Continue()
 
         stop_reason = thread.GetStopReason()
 
-        self.assertEqual(stop_reason, lldb.eStopReasonBreakpoint, "We didn't stop at our breakpoint.")
+        self.assertStopReason(stop_reason, lldb.eStopReasonBreakpoint, "We didn't stop at our breakpoint.")
 
         if test_enable:
             wp.SetEnabled(True)
             self.assertTrue(wp.IsEnabled(), "The watchpoint thinks it is still disabled.")
             process.Continue()
             stop_reason = thread.GetStopReason()
-            self.assertEqual(stop_reason, lldb.eStopReasonWatchpoint, "We didn't stop at our watchpoint")
+            self.assertStopReason(stop_reason, lldb.eStopReasonWatchpoint, "We didn't stop at our watchpoint")
 

lldb/test/API/functionalities/breakpoint/breakpoint_on_lambda_capture/TestBreakOnLambdaCapture.py

def test_break_on_lambda_capture(self):
         # by continuing 20 times and assert we only ever hit the first thread.  Either
         # this is a platform that only reports one hit at a time, in which case all
         # this code is unused, or we actually didn't hit the other thread.
 
         for idx in range(0, 20):
             process.Continue()
             for thread in process.threads:
                 if thread.id == main_thread.id:
-                    self.assertEqual(thread.stop_reason, lldb.eStopReasonBreakpoint)
+                    self.assertStopReason(thread.stop_reason, lldb.eStopReasonBreakpoint)
                 else:
-                    self.assertEqual(thread.stop_reason, lldb.eStopReasonNone)
+                    self.assertStopReason(thread.stop_reason, lldb.eStopReasonNone)

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

def test_step_instruction(self):
         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.assertState(self.process.GetState(), lldb.eStateStopped)
-        self.assertEquals(self.thread.GetStopReason(), lldb.eStopReasonPlanComplete)
+        self.assertStopReason(self.thread.GetStopReason(), lldb.eStopReasonPlanComplete)
 
         self.thread.StepOver()
         # We should be stopped at the breakpoint_3 line with stop plan complete reason
         self.assertState(self.process.GetState(), lldb.eStateStopped)
-        self.assertEquals(self.thread.GetStopReason(), lldb.eStopReasonPlanComplete)
+        self.assertStopReason(self.thread.GetStopReason(), lldb.eStopReasonPlanComplete)
 
         self.thread.StepOver()
         # We should be stopped at the breakpoint_4
         self.assertState(self.process.GetState(), lldb.eStateStopped)
-        self.assertEquals(self.thread.GetStopReason(), lldb.eStopReasonBreakpoint)
+        self.assertStopReason(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.assertState(self.process.GetState(), lldb.eStateExited)
 

lldb/test/API/functionalities/breakpoint/two_hits_one_actual/TestTwoHitsOneActual.py

def sample_test(self):
         # by continuing 20 times and assert we only ever hit the first thread.  Either
         # this is a platform that only reports one hit at a time, in which case all
         # this code is unused, or we actually didn't hit the other thread.
 
         for idx in range(0, 20):
             process.Continue()
             for thread in process.threads:
                 if thread.id == main_thread.id:
-                    self.assertEqual(thread.stop_reason, lldb.eStopReasonBreakpoint)
+                    self.assertStopReason(thread.stop_reason, lldb.eStopReasonBreakpoint)
                 else:
-                    self.assertEqual(thread.stop_reason, lldb.eStopReasonNone)
+                    self.assertStopReason(thread.stop_reason, lldb.eStopReasonNone)
 
                 

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

def test(self):
         self.assertEqual(thread_0.GetStopReason(), 1, "Thread_0 stopped for no reason")
         self.assertEqual(thread_0.GetName(), "one", "Thread_0 is called one")
         
         thread_1 = process.threads[1]
         self.assertEqual(thread_1.GetStopReason(), 3, "Thread_0 stopped for SIGTRAP")
         self.assertEqual(thread_1.GetName(), "three", "Thread_0 is called three")
 
         self.assertTrue(thread_1.IsValid(), "Thread_1 is valid")
-        self.assertEqual(thread_1.GetStopReason(), lldb.eStopReasonBreakpoint, "Stopped at breakpoint")
+        self.assertStopReason(thread_1.GetStopReason(), lldb.eStopReasonBreakpoint, "Stopped at breakpoint")
         

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

def mtc_tests(self):
             "thread info -s",
             substrs=[
                 "api_name",
                 "class_name",
                 "description",
                 "instrumentation_class",
                 "selector"
             ])
-        self.assertEqual(thread.GetStopReason(), lldb.eStopReasonInstrumentation)
+        self.assertStopReason(thread.GetStopReason(), lldb.eStopReasonInstrumentation)
         output_lines = self.res.GetOutput().split('\n')
         json_line = '\n'.join(output_lines[2:])
         data = json.loads(json_line)
         self.assertEqual(data["instrumentation_class"], "MainThreadChecker")
         self.assertEqual(data["api_name"], "-[" + view + " superview]")
         self.assertEqual(data["class_name"], view)
         self.assertEqual(data["selector"], "superview")
         self.assertEqual(data["description"], "-[" + view + " superview] must be used from main thread only")

lldb/test/API/functionalities/postmortem/elf-core/gcore/TestGCore.py

def do_test(self, filename, pid):
         target = self.dbg.CreateTarget("")
         process = target.LoadCore(filename + ".core")
         self.assertTrue(process, PROCESS_IS_VALID)
         self.assertEqual(process.GetNumThreads(), 3)
         self.assertEqual(process.GetProcessID(), pid)
 
         for thread in process:
             reason = thread.GetStopReason()
-            self.assertEqual(reason, lldb.eStopReasonSignal)
+            self.assertStopReason(reason, lldb.eStopReasonSignal)
             signal = thread.GetStopReasonDataAtIndex(1)
             # Check we got signal 19 (SIGSTOP)
             self.assertEqual(signal, 19)
 
         self.dbg.DeleteTarget(target)

lldb/test/API/functionalities/postmortem/elf-core/thread_crash/TestLinuxCoreThreads.py

def do_test(self, filename, pid, tid):
             mem_err = lldb.SBError()
             if process.GetAddressByteSize() == 4:
                 bytes_read = process.ReadMemory(0x8048000, 4, mem_err)
             else:
                 bytes_read = process.ReadMemory(0x400000, 4, mem_err)
             self.assertEqual(bytes_read, None)
             reason = thread.GetStopReason()
             if( thread.GetThreadID() == tid ):
-                self.assertEqual(reason, lldb.eStopReasonSignal)
+                self.assertStopReason(reason, lldb.eStopReasonSignal)
                 signal = thread.GetStopReasonDataAtIndex(1)
                 # Check we got signal 4 (SIGILL)
                 self.assertEqual(signal, 4)
             else:
                 signal = thread.GetStopReasonDataAtIndex(1)
                 # Check we got no signal on the other threads
                 self.assertEqual(signal, 0)
 
         self.dbg.DeleteTarget(target)

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

class MiniDumpNewTestCase(TestBase):
     def test_thread_info_in_minidump(self):
         """Test that lldb can read the thread information from the Minidump."""
         self.process_from_yaml("linux-x86_64.yaml")
         self.check_state()
         # This process crashed due to a segmentation fault in its
         # one and only thread.
         self.assertEqual(self.process.GetNumThreads(), 1)
         thread = self.process.GetThreadAtIndex(0)
-        self.assertEqual(thread.GetStopReason(), lldb.eStopReasonSignal)
+        self.assertStopReason(thread.GetStopReason(), lldb.eStopReasonSignal)
         stop_description = thread.GetStopDescription(256)
         self.assertIn("SIGSEGV", stop_description)
 
     @skipIfLLVMTargetMissing("X86")
     def test_stack_info_in_minidump(self):
         """Test that we can see a trivial stack in a breakpad-generated Minidump."""
         # target create linux-x86_64 -c linux-x86_64.dmp
         self.dbg.CreateTarget("linux-x86_64")
def test_snapshot_minidump_dump_requested(self):
         did not crash) with exception code "DUMP_REQUESTED" there is no stop reason."""
         # target create -c linux-x86_64_not_crashed.dmp
         self.dbg.CreateTarget(None)
         self.target = self.dbg.GetSelectedTarget()
         self.process = self.target.LoadCore("linux-x86_64_not_crashed.dmp")
         self.check_state()
         self.assertEqual(self.process.GetNumThreads(), 1)
         thread = self.process.GetThreadAtIndex(0)
-        self.assertEqual(thread.GetStopReason(), lldb.eStopReasonNone)
+        self.assertStopReason(thread.GetStopReason(), lldb.eStopReasonNone)
         stop_description = thread.GetStopDescription(256)
         self.assertEqual(stop_description, "")
 
     def test_snapshot_minidump_null_exn_code(self):
         """Test that if we load a snapshot minidump file (meaning the process
         did not crash) with exception code zero there is no stop reason."""
         self.process_from_yaml("linux-x86_64_null_signal.yaml")
         self.check_state()
         self.assertEqual(self.process.GetNumThreads(), 1)
         thread = self.process.GetThreadAtIndex(0)
-        self.assertEqual(thread.GetStopReason(), lldb.eStopReasonNone)
+        self.assertStopReason(thread.GetStopReason(), lldb.eStopReasonNone)
         stop_description = thread.GetStopDescription(256)
         self.assertEqual(stop_description, "")
 
     def check_register_unsigned(self, set, name, expected):
         reg_value = set.GetChildMemberWithName(name)
         self.assertTrue(reg_value.IsValid(),
                         'Verify we have a register named "%s"' % (name))
         self.assertEqual(reg_value.GetValueAsUnsigned(), expected,
def check_register_string_value(self, set, name, expected, format):
                                                                 expected))
 
     def test_arm64_registers(self):
         """Test ARM64 registers from a breakpad created minidump."""
         self.process_from_yaml("arm64-macos.yaml")
         self.check_state()
         self.assertEqual(self.process.GetNumThreads(), 1)
         thread = self.process.GetThreadAtIndex(0)
-        self.assertEqual(thread.GetStopReason(), lldb.eStopReasonNone)
+        self.assertStopReason(thread.GetStopReason(), lldb.eStopReasonNone)
         stop_description = thread.GetStopDescription(256)
         self.assertEqual(stop_description, "")
         registers = thread.GetFrameAtIndex(0).GetRegisters()
         # Verify the GPR registers are all correct
         # Verify x0 - x31 register values
         gpr = registers.GetValueAtIndex(0)
         for i in range(32):
             v = i+1 | i+2 << 32 | i+3 << 48
def verify_arm_registers(self, apple=False):
         """
         if apple:
             self.process_from_yaml("arm-macos.yaml")
         else:
             self.process_from_yaml("arm-linux.yaml")
         self.check_state()
         self.assertEqual(self.process.GetNumThreads(), 1)
         thread = self.process.GetThreadAtIndex(0)
-        self.assertEqual(thread.GetStopReason(), lldb.eStopReasonNone)
+        self.assertStopReason(thread.GetStopReason(), lldb.eStopReasonNone)
         stop_description = thread.GetStopDescription(256)
         self.assertEqual(stop_description, "")
         registers = thread.GetFrameAtIndex(0).GetRegisters()
         # Verify the GPR registers are all correct
         # Verify x0 - x31 register values
         gpr = registers.GetValueAtIndex(0)
         for i in range(1, 16):
             self.check_register_unsigned(gpr, 'r%i' % (i), i+1)

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

def test_thread_info_in_mini_dump(self):
         # target create -c fizzbuzz_no_heap.dmp
         self.dbg.CreateTarget("")
         self.target = self.dbg.GetSelectedTarget()
         self.process = self.target.LoadCore("fizzbuzz_no_heap.dmp")
         # This process crashed due to an access violation (0xc0000005) in its
         # one and only thread.
         self.assertEqual(self.process.GetNumThreads(), 1)
         thread = self.process.GetThreadAtIndex(0)
-        self.assertEqual(thread.GetStopReason(), lldb.eStopReasonException)
+        self.assertStopReason(thread.GetStopReason(), lldb.eStopReasonException)
         stop_description = thread.GetStopDescription(256)
         self.assertIn("0xc0000005", stop_description)
 
     def test_modules_in_mini_dump(self):
         """Test that lldb can read the list of modules from the minidump."""
         # target create -c fizzbuzz_no_heap.dmp
         self.dbg.CreateTarget("")
         self.target = self.dbg.GetSelectedTarget()

lldb/test/API/functionalities/postmortem/netbsd-core/TestNetBSDCore.py

 
 class NetBSD1LWPCoreTestCase(NetBSDCoreCommonTestCase):
     THREAD_COUNT = 1
 
     def check_stack(self, process, pid, filename):
         thread = process.GetSelectedThread()
         self.assertTrue(thread)
         self.assertEqual(thread.GetThreadID(), 1)
-        self.assertEqual(thread.GetStopReason(), lldb.eStopReasonSignal)
+        self.assertStopReason(thread.GetStopReason(), lldb.eStopReasonSignal)
         self.assertEqual(thread.GetStopReasonDataCount(), 1)
         self.assertEqual(thread.GetStopReasonDataAtIndex(0), signal.SIGSEGV)
         backtrace = ["bar", "foo", "main"]
         self.check_backtrace(thread, filename, backtrace)
 
     @skipIfLLVMTargetMissing("AArch64")
     def test_aarch64(self):
         """Test single-threaded aarch64 core dump."""
         self.do_test("1lwp_SIGSEGV.aarch64", pid=8339, region_count=32)
 
     @skipIfLLVMTargetMissing("X86")
     def test_amd64(self):
         """Test single-threaded amd64 core dump."""
         self.do_test("1lwp_SIGSEGV.amd64", pid=693, region_count=21)
 
 
 class NetBSD2LWPT2CoreTestCase(NetBSDCoreCommonTestCase):
     THREAD_COUNT = 2
 
     def check_stack(self, process, pid, filename):
         thread = process.GetSelectedThread()
         self.assertTrue(thread)
         self.assertEqual(thread.GetThreadID(), 2)
-        self.assertEqual(thread.GetStopReason(), lldb.eStopReasonSignal)
+        self.assertStopReason(thread.GetStopReason(), lldb.eStopReasonSignal)
         self.assertEqual(thread.GetStopReasonDataCount(), 1)
         self.assertEqual(thread.GetStopReasonDataAtIndex(0), signal.SIGSEGV)
         backtrace = ["bar", "foo", "lwp_main"]
         self.check_backtrace(thread, filename, backtrace)
 
         # thread 1 should have no signal
         thread = process.GetThreadByID(1)
-        self.assertEqual(thread.GetStopReason(), lldb.eStopReasonSignal)
+        self.assertStopReason(thread.GetStopReason(), lldb.eStopReasonSignal)
         self.assertEqual(thread.GetStopReasonDataCount(), 1)
         self.assertEqual(thread.GetStopReasonDataAtIndex(0), 0)
 
     @skipIfLLVMTargetMissing("AArch64")
     def test_aarch64(self):
         """Test double-threaded aarch64 core dump where thread 2 is signalled."""
         self.do_test("2lwp_t2_SIGSEGV.aarch64", pid=14142, region_count=31)
 
     @skipIfLLVMTargetMissing("X86")
     def test_amd64(self):
         """Test double-threaded amd64 core dump where thread 2 is signalled."""
         self.do_test("2lwp_t2_SIGSEGV.amd64", pid=622, region_count=24)
 
 
 class NetBSD2LWPProcessSigCoreTestCase(NetBSDCoreCommonTestCase):
     THREAD_COUNT = 2
 
     def check_stack(self, process, pid, filename):
         thread = process.GetSelectedThread()
         self.assertTrue(thread)
         self.assertEqual(thread.GetThreadID(), 2)
-        self.assertEqual(thread.GetStopReason(), lldb.eStopReasonSignal)
+        self.assertStopReason(thread.GetStopReason(), lldb.eStopReasonSignal)
         self.assertEqual(thread.GetStopReasonDataCount(), 1)
         self.assertEqual(thread.GetStopReasonDataAtIndex(0), signal.SIGSEGV)
         backtrace = ["bar", "foo", "lwp_main"]
         self.check_backtrace(thread, filename, backtrace)
 
         # thread 1 should have the same signal
         thread = process.GetThreadByID(1)
-        self.assertEqual(thread.GetStopReason(), lldb.eStopReasonSignal)
+        self.assertStopReason(thread.GetStopReason(), lldb.eStopReasonSignal)
         self.assertEqual(thread.GetStopReasonDataCount(), 1)
         self.assertEqual(thread.GetStopReasonDataAtIndex(0), signal.SIGSEGV)
 
     @skipIfLLVMTargetMissing("AArch64")
     def test_aarch64(self):
         """Test double-threaded aarch64 core dump where process is signalled."""
         self.do_test("2lwp_process_SIGSEGV.aarch64", pid=1403, region_count=30)
 
     @skipIfLLVMTargetMissing("X86")
     def test_amd64(self):
         """Test double-threaded amd64 core dump where process is signalled."""
         self.do_test("2lwp_process_SIGSEGV.amd64", pid=665, region_count=24)

lldb/test/API/functionalities/postmortem/wow64_minidump/TestWow64MiniDump.py

def test_thread_info_in_wow64_mini_dump(self):
         # minidump doesn't have an exception record--perhaps the crash handler
         # ate it.
         # TODO:  See if we can recover the exception information from the TEB,
         # which, according to Windbg, has a pointer to an exception list.
 
         # In the dump, none of the threads are stopped, so we cannot use
         # lldbutil.get_stopped_thread.
         thread = process.GetThreadAtIndex(0)
-        self.assertEqual(thread.GetStopReason(), lldb.eStopReasonNone)
+        self.assertStopReason(thread.GetStopReason(), lldb.eStopReasonNone)
 
     def test_stack_info_in_wow64_mini_dump(self):
         """Test that we can see a trivial stack in a VS-generate mini dump."""
         # target create -c fizzbuzz_no_heap.dmp
         target = self.dbg.CreateTarget("")
         process = target.LoadCore("fizzbuzz_wow64.dmp")
         self.assertGreaterEqual(process.GetNumThreads(), 1)
         # This process crashed due to an access violation (0xc0000005), but the

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

def test_setpgid(self):
 
         # make sure the child's process group id is different from its pid
         value = thread.GetSelectedFrame().EvaluateExpression("(int)getpgid(0)")
         self.assertTrue(value.IsValid())
         self.assertNotEqual(value.GetValueAsUnsigned(0), int(pid))
 
         # step over the setpgid() call
         thread.StepOver()
-        self.assertEqual(thread.GetStopReason(), lldb.eStopReasonPlanComplete)
+        self.assertStopReason(thread.GetStopReason(), lldb.eStopReasonPlanComplete)
 
         # verify that the process group has been set correctly
         # this also checks that we are still in full control of the child
         value = thread.GetSelectedFrame().EvaluateExpression("(int)getpgid(0)")
         self.assertTrue(value.IsValid())
         self.assertEqual(value.GetValueAsUnsigned(0), int(pid))
 
         # run to completion
         process.Continue()
         self.assertState(process.GetState(), lldb.eStateExited)

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.assertState(self.process.GetState(), lldb.eStateStopped)
-        self.assertEquals(thread.GetStopReason(), lldb.eStopReasonPlanComplete)
+        self.assertStopReason(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):
         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.assertState(self.process.GetState(), lldb.eStateStopped)
-        self.assertEquals(thread.GetStopReason(), lldb.eStopReasonPlanComplete)
+        self.assertStopReason(thread.GetStopReason(), lldb.eStopReasonPlanComplete)
         frame = thread.GetFrameAtIndex(0)
         fun_name = frame.GetFunctionName()
         self.assertEquals(fun_name, "main")
 
         ret_value = thread.GetStopReturnValue()
         self.assertTrue(return_value.IsValid())
         ret_int = ret_value.GetValueAsSigned(error)
         self.assertSuccess(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.assertState(self.process.GetState(), lldb.eStateStopped)
-        self.assertEquals(thread.GetStopReason(), lldb.eStopReasonPlanComplete)
+        self.assertStopReason(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())
         #return_float = float(return_value.GetValue())
def return_and_test_struct_value(self, func_name):
 
         for idx in range(0, num_in_children):
             in_child = in_value.GetChildAtIndex(idx)
             in_child_str = in_child.GetValue()
 
         thread.StepOut()
 
         self.assertState(self.process.GetState(), lldb.eStateStopped)
-        self.assertEquals(thread.GetStopReason(), lldb.eStopReasonPlanComplete)
+        self.assertStopReason(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")
 
         frame = thread.GetFrameAtIndex(0)

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

def test_scripted_process_and_scripted_thread(self):
         self.assertEqual(process.GetProcessID(), 42)
 
         self.assertEqual(process.GetNumThreads(), 1)
 
         thread = process.GetSelectedThread()
         self.assertTrue(thread, "Invalid thread.")
         self.assertEqual(thread.GetThreadID(), 0x19)
         self.assertEqual(thread.GetName(), "DummyScriptedThread.thread-1")
-        self.assertEqual(thread.GetStopReason(), lldb.eStopReasonSignal)
+        self.assertStopReason(thread.GetStopReason(), lldb.eStopReasonSignal)
 
         self.assertGreater(thread.GetNumFrames(), 0)
 
         frame = thread.GetFrameAtIndex(0)
         GPRs = None
         register_set = frame.registers # Returns an SBValueList.
         for regs in register_set:
             if 'general purpose' in regs.name.lower():

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

def do_test(self, bkpt_modifier = None):
 
         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.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.assertStopReason(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.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.assertStopReason(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/functionalities/thread/create_during_step/TestCreateDuringStep.py

def create_during_step_base(self, step_cmd, step_stop_reason):
         num_threads = process.GetNumThreads()
 
         # Check to see that we increased the number of threads as expected
         self.assertEqual(
             num_threads, 3,
             'Number of expected threads and actual threads do not match after thread exit.')
 
         stop_reason = stepping_thread.GetStopReason()
-        self.assertEqual(stop_reason, lldb.eStopReasonPlanComplete, "Stopped for plan completion")
+        self.assertStopReason(stop_reason, lldb.eStopReasonPlanComplete, "Stopped for plan completion")
 
         # Run to completion
         self.runCmd("process continue")
 
         # At this point, the inferior process should have exited.
         self.assertEqual(
             process.GetState(), lldb.eStateExited,
             PROCESS_EXITED)

lldb/test/API/functionalities/thread/num_threads/TestNumThreads.py

def test_unique_stacks(self):
             thread = process.GetThreadAtIndex(i)
             self.assertTrue(thread.IsValid())
             if not is_thread3(thread):
                 continue
 
             # If we aren't stopped out the thread breakpoint try to resume.
             if thread.GetStopReason() != lldb.eStopReasonBreakpoint:
                 self.runCmd("thread continue %d"%(i+1))
-            self.assertEqual(thread.GetStopReason(), lldb.eStopReasonBreakpoint)
+            self.assertStopReason(thread.GetStopReason(), lldb.eStopReasonBreakpoint)
 
             expect_threads += " #%d"%(i+1)
 
         # Construct our expected back trace string
         expect_string = "10 thread(s)%s" % (expect_threads)
 
         # Now that we are stopped, we should have 10 threads waiting in the
         # thread3 function. All of these threads should show as one stack.
         self.expect("thread backtrace unique",
                     "Backtrace with unique stack shown correctly",
                     substrs=[expect_string,
                         "main.cpp:%d"%self.thread3_before_lock_line])

lldb/test/API/functionalities/thread/state/TestThreadStates.py

def test_process_interrupt(self):
         self.wait_for_running_event(process)
 
         # Go back to synchronous interactions
         self.dbg.SetAsync(False)
 
         # Stop the process
         self.runCmd("process interrupt")
 
-        self.assertEqual(thread.GetStopReason(), lldb.eStopReasonSignal)
+        self.assertStopReason(thread.GetStopReason(), lldb.eStopReasonSignal)
 
         # Get the inferior out of its loop
         self.runCmd("expression g_test = 1")
 
         # Run to completion
         self.runCmd("continue")
 
     def thread_states_test(self):
def thread_states_test(self):
             "Thread state is \'suspended\' when it should be running.")
 
         # Go back to synchronous interactions
         self.dbg.SetAsync(False)
 
         # Stop the process
         self.runCmd("process interrupt")
 
-        self.assertEqual(thread.GetState(), lldb.eStopReasonSignal)
+        self.assertStopReason(thread.GetState(), lldb.eStopReasonSignal)
 
         # Check the thread state
         self.assertTrue(
             thread.IsStopped(),
             "Thread state isn't \'stopped\' after process stop.")
         self.assertFalse(thread.IsSuspended(),
                          "Thread state is \'suspended\' after process stop.")
 
         # Get the inferior out of its loop
         self.runCmd("expression g_test = 1")
 
         # Check the thread state
         self.assertTrue(
             thread.IsStopped(),
             "Thread state isn't \'stopped\' after expression evaluation.")
         self.assertFalse(
             thread.IsSuspended(),
             "Thread state is \'suspended\' after expression evaluation.")
 
-        self.assertEqual(thread.GetState(), lldb.eStopReasonSignal)
+        self.assertStopReason(thread.GetState(), lldb.eStopReasonSignal)
 
         # Run to breakpoint 2
         self.runCmd("continue")
 
-        self.assertEqual(thread.GetState(), lldb.eStopReasonBreakpoint)
+        self.assertStopReason(thread.GetState(), lldb.eStopReasonBreakpoint)
 
         # Make sure both threads are stopped
         self.assertTrue(
             thread.IsStopped(),
             "Thread state isn't \'stopped\' during breakpoint 2.")
         self.assertFalse(thread.IsSuspended(),
                          "Thread state is \'suspended\' during breakpoint 2.")
 
         # Run to completion
         self.runCmd("continue")
 
         # At this point, the inferior process should have exited.
         self.assertState(process.GetState(), lldb.eStateExited, PROCESS_EXITED)

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

def do_test(self):
         options.SetTryAllThreads(False)
         options.SetStopOthers(True)
 
         result = thread.frames[0].EvaluateExpression('(int) printf("Hello\\n")', options)
         self.assertSuccess(result.GetError(), "Expression failed")
 
         stop_reason = other_thread.GetStopReason()
 
-        self.assertEqual(stop_reason, lldb.eStopReasonBreakpoint,
+        self.assertStopReason(stop_reason, lldb.eStopReasonBreakpoint,
                          "Still records stopped at breakpoint: %s"
                          %(lldbutil.stop_reason_to_str(stop_reason)))
         self.assertEqual(other_thread.GetStopReasonDataAtIndex(0), 1,
                          "Still records stopped at right breakpoint")
 

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

def ubsan_tests(self):
         thread = process.GetSelectedThread()
         frame = thread.GetSelectedFrame()
 
         # the stop reason of the thread should be breakpoint.
         self.expect("thread list", "A ubsan issue should be detected",
                     substrs=['stopped', 'stop reason ='])
 
         stop_reason = thread.GetStopReason()
-        self.assertEqual(stop_reason, lldb.eStopReasonInstrumentation)
+        self.assertStopReason(stop_reason, lldb.eStopReasonInstrumentation)
 
         # test that the UBSan dylib is present
         self.expect(
             "image lookup -n __ubsan_on_report",
             "__ubsan_on_report should be present",
             substrs=['1 match found'])
 
         # We should be stopped in __ubsan_on_report

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

def test_and_python_api(self):
         # Disable all our breakpoints first - sometimes the compiler puts two line table entries in for the
         # breakpoint a "b" and we don't want to hit that.
         for bkpt in breakpoints_to_disable:
             bkpt.SetEnabled(False)
 
         process.Continue()
 
         self.assertEqual(thread.GetFrameAtIndex(0).GetFunctionName(), "a")
-        self.assertEqual(thread.GetStopReason(), lldb.eStopReasonPlanComplete)
+        self.assertStopReason(thread.GetStopReason(), lldb.eStopReasonPlanComplete)
 
         # And one more time should get us back to main:
         process.Continue()
 
         self.assertEqual(thread.GetFrameAtIndex(0).GetFunctionName(), "main")
-        self.assertEqual(thread.GetStopReason(), lldb.eStopReasonPlanComplete)
+        self.assertStopReason(thread.GetStopReason(), lldb.eStopReasonPlanComplete)
 
         # Now make sure we can call a function, break in the called function,
         # then have "continue" get us back out again:
         frame = thread.GetFrameAtIndex(0)
         frame = thread.GetFrameAtIndex(0)
         current_line = frame.GetLineEntry().GetLine()
         current_file = frame.GetLineEntry().GetFileSpec()
 

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

def suspended_thread_test(self):
         # Now continue, and we should stop with a stop reason of SIGBUS:
         process.Continue()
         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.assertStopReason(thread.stop_reason, lldb.eStopReasonSignal)
         self.assertEqual(thread.GetStopReasonDataAtIndex(0), 10, "Got a SIGBUS")
 
         # Now when we continue, we'll find our way into the signal handler:
         threads = lldbutil.continue_to_breakpoint(process, sig_bkpt)
         self.assertEqual(len(threads), 1, "Stopped at sig breakpoint")
 
         threads = lldbutil.continue_to_breakpoint(process, return_bkpt)
         self.assertEqual(len(threads), 1, "Stopped at return breakpoint")
 
         # Make sure we really changed the value:
 
         process.Continue()
         self.assertState(process.state, lldb.eStateExited, "Process exited")
         self.assertEqual(process.exit_state, 20, "Got the right exit status")
 

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

def step_over_3_times(self, exe_name):
         thread.StepOver()
         thread.StepOver()
         self.runCmd("thread backtrace")
 
         # Verify that we are stopped at the correct source line number in
         # main2.cpp.
         frame0 = thread.GetFrameAtIndex(0)
         lineEntry = frame0.GetLineEntry()
-        self.assertEqual(thread.GetStopReason(), lldb.eStopReasonPlanComplete)
+        self.assertStopReason(thread.GetStopReason(), lldb.eStopReasonPlanComplete)
         # Expected failure with clang as the compiler.
         # rdar://problem/9223880
         #
         # Which has been fixed on the lldb by compensating for inaccurate line
         # table information with r140416.
         self.assertEqual(lineEntry.GetLine(), self.after_3_step_overs)
 
     def run_to_address(self, exe_name):