Don't assume that thread 0 is always the main thread

[zturner]

Summary

Even in a single-threaded app, Windows will often create background threads on startup and these threads can appear in any order with respect to the actual main thread. So everywhere that is doing something like process.GetThreadAtIndex(0) in our test suite is broken on Windows. This fixes a large number of these cases, although there are still a few more difficult ones remaining that I don't plan to address right now.

[amccarth]

A GetMainThread method in SBAPI might be a nice addition to GetThreadAtIndex.

[zturner]

Yea that seems like a good idea. I can do that in a followup.

Jim, does this patch look ok to you?

[jingham]

Yes, that is a cleaner way to do this.

In about half the cases you use get_threads_stopped_at_breakpoint and half get_stopped_thread. It looks like you were just mirroring what the test did, so that's fine, but if I know the breakpoint I'm expecting, I prefer get_threads_stopped_at_breakpoint as it is a more complete test. As noted in the individual comments, I don't think you are using get_threads_stopped_at_breakpoint right, since it returns an array of threads, not a single thread.

BTW, I'm not averse to the notion of an API to get the "main thread" but none of these tests should be changed to use it (or should have used it if it already existed.) After all, you wanted to know that you stopped on a thread at some breakpoint you set. The fact that that is the "main" thread is incidental and gating ALL these tests on having "the main thread" even be a sensible notion for your platform seems to make them fragile for no benefit.

packages/Python/lldbsuite/test/expression_command/test/TestExprs.py

133–134 ↗

(On Diff #45046)

Is this one right? get_threads_stopped_at_breakpoint returns an array. You need to check that the return has only one element and then set thread to that element. Unless there's some Python magic that I'm missing...

packages/Python/lldbsuite/test/functionalities/breakpoint/consecutive_breakpoins/TestConsecutiveBreakpoints.py

40 ↗

(On Diff #45046)

Is this one right? get_threads_stopped_at_breakpoint returns an array. You need to check that the return has only one element and then set thread to that element. Unless there's some Python magic that I'm missing...

54–55 ↗

(On Diff #45046)

Is this one right? get_threads_stopped_at_breakpoint returns an array. You need to check that the return has only one element and then set thread to that element. Unless there's some Python magic that I'm missing...

packages/Python/lldbsuite/test/functionalities/conditional_break/TestConditionalBreak.py

67–68 ↗

(On Diff #45046)

Is this one right? get_threads_stopped_at_breakpoint returns an array. You need to check that the return has only one element and then set thread to that element. Unless there's some Python magic that I'm missing...

[jingham]

Oh, yeah, I'm supposed to say "request changes" for the use of get_threads_stopped_at_breakpoint...

[zturner]

Fix incorrect usage of get_threads_stopped_at_breakpoint by adding a new function that returns the first thread stopped at a breakpoint.

[zturner]

Fixed that issue. The other issue you pointed out about using get_stopped_thread sometimes is because in those tests breakpoints were created using runCmd so we don't have an SBBreakpoint handy like we do in the other cases.

[jingham]

That looks good. get_one_thread_stopped_at_breakpoint is convenient, but I'd rather not sweep under the rug cases where you expected only one thread to hit your breakpoint but more than one did. I think it would be better if this API returned None for number of threads != 1, not just threads == 0. That way you'd get testing for that for free as well. And then in the cases where it was expected that more than one thread might hit the breakpoint, you should use get_threads_stopped_at_breakpoint.

[zturner]

Maybe I can give it an argument like require_exactly_one_thread which defaults to True. That way at least you can still use the same function in the case where you just want the first thread (which is how get_stopped_thread works)

[jingham]

That would be fine too. Just seems like this is asking to have a miswritten test that accidentally stops at two hits of the breakpoint but you didn't notice because MOST of the time, the right thread was first, which would lead to an odd flakey test.

lldb/trunk/packages/Python/lldbsuite/test/expression_command/test/TestExprs.py

def test_evaluate_expression_python(self):
         if not process:
             self.fail("SBTarget.LaunchProcess() failed")
 
         if process.GetState() != lldb.eStateStopped:
             self.fail("Process should be in the 'stopped' state, "
                       "instead the actual state is: '%s'" %
                       lldbutil.state_type_to_str(process.GetState()))
 
-        # The stop reason of the thread should be breakpoint.
-        thread = process.GetThreadAtIndex(0)
-        if thread.GetStopReason() != lldb.eStopReasonBreakpoint:
-            from lldbsuite.test.lldbutil import stop_reason_to_str
-            self.fail(STOPPED_DUE_TO_BREAKPOINT_WITH_STOP_REASON_AS %
-                      stop_reason_to_str(thread.GetStopReason()))
+        thread = lldbutil.get_one_thread_stopped_at_breakpoint(process, breakpoint)
+        self.assertIsNotNone(thread, "Expected one thread to be stopped at the breakpoint")
 
         # The filename of frame #0 should be 'main.cpp' and function is main.
         self.expect(lldbutil.get_filenames(thread)[0],
                     "Break correctly at main.cpp", exe=False,
             startstr = "main.cpp")
         self.expect(lldbutil.get_function_names(thread)[0],
                     "Break correctly at main()", exe=False,
             startstr = "main")

lldb/trunk/packages/Python/lldbsuite/test/functionalities/breakpoint/consecutive_breakpoins/TestConsecutiveBreakpoints.py

class ConsecutiveBreakpoitsTestCase(TestBase):
         
     def consecutive_breakpoints_tests(self):
         exe = os.path.join (os.getcwd(), "a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
-        breakpoint = target.BreakpointCreateBySourceRegex("Set breakpoint here", lldb.SBFileSpec("main.cpp"))
+        breakpoint1 = target.BreakpointCreateBySourceRegex("Set breakpoint here", lldb.SBFileSpec("main.cpp"))
         self.assertTrue(breakpoint and
                         breakpoint.GetNumLocations() == 1,
                         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)
 
         # We should be stopped at the first breakpoint
-        thread = process.GetThreadAtIndex(0)
-        self.assertEqual(thread.GetStopReason(), lldb.eStopReasonBreakpoint)
+        thread = lldbutil.get_one_thread_stopped_at_breakpoint(process, breakpoint1)
+        self.assertIsNotNone(thread, "Expected one thread to be stopped at breakpoint 1")
 
         # Set breakpoint to the next instruction
         frame = thread.GetFrameAtIndex(0)
         
         address = frame.GetPCAddress()
         instructions = target.ReadInstructions(address, 2)
         self.assertTrue(len(instructions) == 2)
         address = instructions[1].GetAddress()
         
-        target.BreakpointCreateByAddress(address.GetLoadAddress(target))
+        breakpoint2 = target.BreakpointCreateByAddress(address.GetLoadAddress(target))
         process.Continue()
 
         # We should be stopped at the second breakpoint
-        thread = process.GetThreadAtIndex(0)
-        self.assertEqual(thread.GetStopReason(), lldb.eStopReasonBreakpoint)
+        thread = lldbutil.get_one_thread_stopped_at_breakpoint(process, breakpoint2)
+        self.assertIsNotNone(thread, "Expected one thread to be stopped at breakpoint 2")
 
         # Run the process until termination
         process.Continue()

lldb/trunk/packages/Python/lldbsuite/test/functionalities/conditional_break/TestConditionalBreak.py

def do_conditional_break(self):
         # immediate caller is a() and we want to find out the value passed from
         # a().
         #
         # The 10 in range(10) is just an arbitrary number, which means we would
         # like to try for at most 10 times.
         for j in range(10):
             if self.TraceOn():
                 print("j is: ", j)
-            thread = process.GetThreadAtIndex(0)
+            thread = lldbutil.get_one_thread_stopped_at_breakpoint(process, breakpoint)
+            self.assertIsNotNone(thread, "Expected one thread to be stopped at the breakpoint")
             
             if thread.GetNumFrames() >= 2:
                 frame0 = thread.GetFrameAtIndex(0)
                 name0 = frame0.GetFunction().GetName()
                 frame1 = thread.GetFrameAtIndex(1)
                 name1 = frame1.GetFunction().GetName()
                 #lldbutil.print_stacktrace(thread)
                 self.assertTrue(name0 == "c", "Break on function c()")

lldb/trunk/packages/Python/lldbsuite/test/functionalities/thread/crash_during_step/TestCrashDuringStep.py

def test_step_inst_with(self):
         self.bp_num = lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.breakpoint, num_expected_locations=1)
 
         # Run the program.
         process = target.LaunchSimple(None, None, self.get_process_working_directory())
         self.assertTrue(process and process.IsValid(), PROCESS_IS_VALID)
 
         # The stop reason should be breakpoint.
         self.assertEqual(process.GetState(), lldb.eStateStopped, PROCESS_STOPPED)
-        self.assertEqual(lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint).IsValid(), 1,
-                STOPPED_DUE_TO_BREAKPOINT)
-
-        thread = process.GetThreadAtIndex(0)
-        self.assertTrue(thread and thread.IsValid(), "Thread is valid")
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+        self.assertTrue(thread.IsValid(), STOPPED_DUE_TO_BREAKPOINT)
 
         # Keep stepping until the inferior crashes
         while process.GetState() == lldb.eStateStopped and not lldbutil.is_thread_crashed(self, thread):
             thread.StepInstruction(False)
 
         self.assertEqual(process.GetState(), lldb.eStateStopped, PROCESS_STOPPED)
         self.assertTrue(lldbutil.is_thread_crashed(self, thread), "Thread has crashed")
         process.Kill()

lldb/trunk/packages/Python/lldbsuite/test/functionalities/thread/multi_break/TestMultipleBreakpoints.py

def test(self):
         # Get the target process
         target = self.dbg.GetSelectedTarget()
         process = target.GetProcess()
 
         # Get the number of threads
         num_threads = process.GetNumThreads()
 
         # Make sure we see all three threads
-        self.assertTrue(num_threads == 3, 'Number of expected threads and actual threads do not match.')
+        self.assertTrue(num_threads >= 3, 'Number of expected threads and actual threads do not match.')
 
         # Get the thread objects
         thread1 = process.GetThreadAtIndex(0)
         thread2 = process.GetThreadAtIndex(1)
         thread3 = process.GetThreadAtIndex(2)
 
         # Make sure both threads are stopped
         self.assertTrue(thread1.IsStopped(), "Primary thread didn't stop during breakpoint")

lldb/trunk/packages/Python/lldbsuite/test/functionalities/thread/state/TestThreadStates.py

def setUp(self):
         self.break_2 = line_number('main.cpp', '// Set second breakpoint here')
 
     def thread_state_after_breakpoint_test(self):
         """Test thread state after breakpoint."""
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # This should create a breakpoint in the main thread.
-        lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.break_1, num_expected_locations=1)
+        bp = lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.break_1, num_expected_locations=1)
 
         # Run the program.
         self.runCmd("run", RUN_SUCCEEDED)
 
-        # The stop reason of the thread should be breakpoint.
-        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
-            substrs = ['stopped',
-                       '* thread #1',
-                       'stop reason = breakpoint'])
-
         # Get the target process
         target = self.dbg.GetSelectedTarget()
         process = target.GetProcess()
 
-        # Get the number of threads
-        num_threads = process.GetNumThreads()
-
-        self.assertTrue(num_threads == 1, 'Number of expected threads and actual threads do not match.')
-
-        # Get the thread object
-        thread = process.GetThreadAtIndex(0)
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+        self.assertIsNotNone(thread)
 
         # Make sure the thread is in the stopped state.
         self.assertTrue(thread.IsStopped(), "Thread state isn't \'stopped\' during breakpoint 1.")
         self.assertFalse(thread.IsSuspended(), "Thread state is \'suspended\' during breakpoint 1.")
 
         # Kill the process
         self.runCmd("process kill")
 
def thread_state_after_continue_test(self):
 
         # This should create a breakpoint in the main thread.
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.break_1, num_expected_locations=1)
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.break_2, num_expected_locations=1)
 
         # Run the program.
         self.runCmd("run", RUN_SUCCEEDED)
 
-        # The stop reason of the thread should be breakpoint.
-        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
-            substrs = ['stopped',
-                       '* thread #1',
-                       'stop reason = breakpoint'])
-
         # Get the target process
         target = self.dbg.GetSelectedTarget()
         process = target.GetProcess()
 
-        # Get the number of threads
-        num_threads = process.GetNumThreads()
-
-        self.assertTrue(num_threads == 1, 'Number of expected threads and actual threads do not match.')
-
-        # Get the thread object
-        thread = process.GetThreadAtIndex(0)
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+        self.assertIsNotNone(thread)
 
         # Continue, the inferior will go into an infinite loop waiting for 'g_test' to change.
         self.dbg.SetAsync(True)
         self.runCmd("continue")
         self.wait_for_running_event()
 
         # Check the thread state. It should be running.
         self.assertFalse(thread.IsStopped(), "Thread state is \'stopped\' when it should be running.")
def thread_state_after_expression_test(self):
 
         # This should create a breakpoint in the main thread.
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.break_1, num_expected_locations=1)
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.break_2, num_expected_locations=1)
 
         # Run the program.
         self.runCmd("run", RUN_SUCCEEDED)
 
-        # The stop reason of the thread should be breakpoint.
-        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
-            substrs = ['stopped',
-                       '* thread #1',
-                       'stop reason = breakpoint'])
-
         # Get the target process
         target = self.dbg.GetSelectedTarget()
         process = target.GetProcess()
 
-        # Get the number of threads
-        num_threads = process.GetNumThreads()
-
-        self.assertTrue(num_threads == 1, 'Number of expected threads and actual threads do not match.')
-
-        # Get the thread object
-        thread = process.GetThreadAtIndex(0)
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+        self.assertIsNotNone(thread)
 
         # 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.")
 
         # Let the process run to completion
         self.runCmd("process continue")
 
 
     def process_interrupt_test(self):
         """Test process interrupt and continue."""
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # This should create a breakpoint in the main thread.
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.break_1, num_expected_locations=1)
 
         # Run the program.
         self.runCmd("run", RUN_SUCCEEDED)
 
-        # The stop reason of the thread should be breakpoint.
-        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
-            substrs = ['stopped',
-                       '* thread #1',
-                       'stop reason = breakpoint'])
-
         # Get the target process
         target = self.dbg.GetSelectedTarget()
         process = target.GetProcess()
 
-        # Get the number of threads
-        num_threads = process.GetNumThreads()
-
-        self.assertTrue(num_threads == 1, 'Number of expected threads and actual threads do not match.')
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+        self.assertIsNotNone(thread)
 
         # Continue, the inferior will go into an infinite loop waiting for 'g_test' to change.
         self.dbg.SetAsync(True)
         self.runCmd("continue")
         self.wait_for_running_event()
 
         # Go back to synchronous interactions
         self.dbg.SetAsync(False)
 
         # Stop the process
         self.runCmd("process interrupt")
 
-        # The stop reason of the thread should be signal.
-        self.expect("process status", STOPPED_DUE_TO_SIGNAL,
-            substrs = ['stopped',
-                       '* thread #1',
-                       'stop reason = signal'])
+        self.assertEqual(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):
         """Test thread states (comprehensive)."""
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # This should create a breakpoint in the main thread.
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.break_1, num_expected_locations=1)
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.break_2, num_expected_locations=1)
 
         # Run the program.
         self.runCmd("run", RUN_SUCCEEDED)
 
-        # The stop reason of the thread should be breakpoint.
-        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
-            substrs = ['stopped',
-                       '* thread #1',
-                       'stop reason = breakpoint'])
-
         # Get the target process
         target = self.dbg.GetSelectedTarget()
         process = target.GetProcess()
-
-        # Get the number of threads
-        num_threads = process.GetNumThreads()
-
-        self.assertTrue(num_threads == 1, 'Number of expected threads and actual threads do not match.')
-
-        # Get the thread object
-        thread = process.GetThreadAtIndex(0)
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+        self.assertIsNotNone(thread)
 
         # Make sure the thread is in the stopped state.
         self.assertTrue(thread.IsStopped(), "Thread state isn't \'stopped\' during breakpoint 1.")
         self.assertFalse(thread.IsSuspended(), "Thread state is \'suspended\' during breakpoint 1.")
 
         # Continue, the inferior will go into an infinite loop waiting for 'g_test' to change.
         self.dbg.SetAsync(True)
         self.runCmd("continue")
         self.wait_for_running_event()
 
         # Check the thread state. It should be running.
         self.assertFalse(thread.IsStopped(), "Thread state is \'stopped\' when it should be running.")
         self.assertFalse(thread.IsSuspended(), "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")
 
-        # The stop reason of the thread should be signal.
-        self.expect("process status", STOPPED_DUE_TO_SIGNAL,
-            substrs = ['stopped',
-                       '* thread #1',
-                       'stop reason = signal'])
+        self.assertEqual(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.")
 
-        # The stop reason of the thread should be signal.
-        self.expect("process status", STOPPED_DUE_TO_SIGNAL,
-            substrs = ['stopped',
-                       '* thread #1',
-                       'stop reason = signal'])
+        self.assertEqual(thread.GetState(), lldb.eStopReasonSignal)
 
         # Run to breakpoint 2
         self.runCmd("continue")
 
-        # The stop reason of the thread should be breakpoint.
-        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
-            substrs = ['stopped',
-                       '* thread #1',
-                       'stop reason = breakpoint'])
+        self.assertEqual(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.assertTrue(process.GetState() == lldb.eStateExited, PROCESS_EXITED)
+        self.assertEqual(process.GetState(), lldb.eStateExited, PROCESS_EXITED)

lldb/trunk/packages/Python/lldbsuite/test/lang/c/array_types/TestArrayTypes.py

def test_and_python_api(self):
 
         # Sanity check the print representation of process.
         proc = str(process)
         self.expect(proc, msg="Process looks good", exe=False,
             substrs = ["state = stopped",
                        "executable = a.out"])
 
         # The stop reason of the thread should be breakpoint.
-        thread = process.GetThreadAtIndex(0)
-        if thread.GetStopReason() != lldb.eStopReasonBreakpoint:
-            from lldbsuite.test.lldbutil import stop_reason_to_str
-            self.fail(STOPPED_DUE_TO_BREAKPOINT_WITH_STOP_REASON_AS %
-                      stop_reason_to_str(thread.GetStopReason()))
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+        self.assertIsNotNone(thread)
 
         # Sanity check the print representation of thread.
         thr = str(thread)
         # TODO(zturner): Whether the TID is printed in hex or decimal should be controlled by a setting,
         # and this test should read the value of the setting.  This check is currently hardcoded to
         # match the check in Core/FormatEntity.cpp in the function FormatEntity::Format() for
         # the Entry::Type::ThreadID case of the switch statement.
         if self.getPlatform() == "linux" or self.getPlatform() == "freebsd":
             tidstr = "tid = %u" % thread.GetThreadID()
         else:
             tidstr = "tid = 0x%4.4x" % thread.GetThreadID()
         self.expect(thr, "Thread looks good with stop reason = breakpoint", exe=False,
             substrs = [tidstr])
 
         # The breakpoint should have a hit count of 1.
-        self.assertTrue(breakpoint.GetHitCount() == 1, BREAKPOINT_HIT_ONCE)
+        self.assertEqual(breakpoint.GetHitCount(), 1, BREAKPOINT_HIT_ONCE)
 
         # The breakpoint should be resolved by now.
         bp = str(breakpoint)
         self.expect(bp, "Breakpoint looks good and is resolved", exe=False,
             substrs = ["file = 'main.c'",
                        "line = %d" % self.line,
                        "locations = 1"])
 

lldb/trunk/packages/Python/lldbsuite/test/lang/c/bitfields/TestBitfields.py

def test_and_python_api(self):
 
         breakpoint = target.BreakpointCreateByLocation("main.c", self.line)
         self.assertTrue(breakpoint, VALID_BREAKPOINT)
 
         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.
-        thread = target.GetProcess().GetThreadAtIndex(0)
-        if thread.GetStopReason() != lldb.eStopReasonBreakpoint:
-            from lldbsuite.test.lldbutil import stop_reason_to_str
-            self.fail(STOPPED_DUE_TO_BREAKPOINT_WITH_STOP_REASON_AS %
-                      stop_reason_to_str(thread.GetStopReason()))
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+        self.assertIsNotNone(thread)
 
         # The breakpoint should have a hit count of 1.
-        self.assertTrue(breakpoint.GetHitCount() == 1, BREAKPOINT_HIT_ONCE)
+        self.assertEqual(breakpoint.GetHitCount(), 1, BREAKPOINT_HIT_ONCE)
 
         # Lookup the "bits" variable which contains 8 bitfields.
         frame = thread.GetFrameAtIndex(0)
         bits = frame.FindVariable("bits")
         self.DebugSBValue(bits)
         self.assertTrue(bits.GetTypeName() == 'Bits', "bits.GetTypeName() == 'Bits'");
         self.assertTrue(bits.GetNumChildren() == 10, "bits.GetNumChildren() == 10");
         test_compiler = self.getCompiler()

lldb/trunk/packages/Python/lldbsuite/test/lang/cpp/class_static/TestStaticVariables.py

def test_with_python_api(self):
         breakpoint = target.BreakpointCreateByLocation("main.cpp", self.line)
         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)
 
         # The stop reason of the thread should be breakpoint.
-        thread = process.GetThreadAtIndex(0)
-        if thread.GetStopReason() != lldb.eStopReasonBreakpoint:
-            from lldbsuite.test.lldbutil import stop_reason_to_str
-            self.fail(STOPPED_DUE_TO_BREAKPOINT_WITH_STOP_REASON_AS %
-                      stop_reason_to_str(thread.GetStopReason()))
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+        self.assertIsNotNone(thread)
 
         # Get the SBValue of 'A::g_points' and 'g_points'.
         frame = thread.GetFrameAtIndex(0)
 
         # arguments =>     False
         # locals =>        False
         # statics =>       True
         # in_scope_only => False

lldb/trunk/packages/Python/lldbsuite/test/lang/cpp/class_types/TestClassTypes.py

def test_with_python_api(self):
             self.fail("SBTarget.Launch() failed")
 
         if process.GetState() != lldb.eStateStopped:
             self.fail("Process should be in the 'stopped' state, "
                       "instead the actual state is: '%s'" %
                       lldbutil.state_type_to_str(process.GetState()))
 
         # The stop reason of the thread should be breakpoint.
-        thread = process.GetThreadAtIndex(0)
-        if thread.GetStopReason() != lldb.eStopReasonBreakpoint:
-            from lldbsuite.test.lldbutil import stop_reason_to_str
-            self.fail(STOPPED_DUE_TO_BREAKPOINT_WITH_STOP_REASON_AS %
-                      stop_reason_to_str(thread.GetStopReason()))
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+        self.assertIsNotNone(thread)
 
         # The filename of frame #0 should be 'main.cpp' and the line number
         # should be 93.
         self.expect("%s:%d" % (lldbutil.get_filenames(thread)[0],
                                lldbutil.get_line_numbers(thread)[0]),
                     "Break correctly at main.cpp:%d" % self.line, exe=False,
             startstr = "main.cpp:")
             ### clang compiled code reported main.cpp:94?
def test_with_constructor_name (self):
             self.fail("SBTarget.Launch() failed")
 
         if process.GetState() != lldb.eStateStopped:
             self.fail("Process should be in the 'stopped' state, "
                       "instead the actual state is: '%s'" %
                       lldbutil.state_type_to_str(process.GetState()))
 
         # The stop reason of the thread should be breakpoint.
-        thread = process.GetThreadAtIndex(0)
-        if thread.GetStopReason() != lldb.eStopReasonBreakpoint:
-            from lldbsuite.test.lldbutil import stop_reason_to_str
-            self.fail(STOPPED_DUE_TO_BREAKPOINT_WITH_STOP_REASON_AS %
-                      stop_reason_to_str(thread.GetStopReason()))
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+        self.assertIsNotNone(thread)
 
         frame = thread.frames[0]
         self.assertTrue (frame.IsValid(), "Got a valid frame.")
 
         self.assertTrue ("C::C" in frame.name, "Constructor name includes class name.")

lldb/trunk/packages/Python/lldbsuite/test/lang/cpp/class_types/TestClassTypesDisassembly.py

def test_and_python_api(self):
         """Disassemble each call frame when stopped on C's constructor."""
         self.build()
         self.breakOnCtor()
 
         # Now use the Python API to get at each function on the call stack and
         # disassemble it.
         target = self.dbg.GetSelectedTarget()
         process = target.GetProcess()
-        thread = process.GetThreadAtIndex(0)
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+        self.assertIsNotNone(thread)
         depth = thread.GetNumFrames()
         for i in range(depth - 1):
             frame = thread.GetFrameAtIndex(i)
             function = frame.GetFunction()
             # Print the function header.
             if self.TraceOn():
                 print()
                 print(function)

lldb/trunk/packages/Python/lldbsuite/test/lang/cpp/diamond/TestDiamond.py

def test_with_run_command(self):
         exe = os.path.join(os.getcwd(), "a.out")
         
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
         self.set_breakpoint(line_number('main.cpp', '// breakpoint 1'))
         self.set_breakpoint(line_number('main.cpp', '// breakpoint 2'))
         process = target.LaunchSimple (None, None, self.get_process_working_directory())
         self.assertTrue(process, PROCESS_IS_VALID)
-        thread = process.GetThreadAtIndex(0)
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+        self.assertIsNotNone(thread)
         frame = thread.GetFrameAtIndex(0)
         j1 = frame.FindVariable("j1")
         j1_Derived1 = j1.GetChildAtIndex(0)
         j1_Derived2 = j1.GetChildAtIndex(1)
         j1_Derived1_VBase = j1_Derived1.GetChildAtIndex(0)
         j1_Derived2_VBase = j1_Derived2.GetChildAtIndex(0)
         j1_Derived1_VBase_m_value = j1_Derived1_VBase.GetChildAtIndex(0)
         j1_Derived2_VBase_m_value = j1_Derived2_VBase.GetChildAtIndex(0)

lldb/trunk/packages/Python/lldbsuite/test/lang/cpp/stl/TestStdCXXDisassembly.py

def test_stdcxx_disasm(self):
 
         # The process should be in a 'stopped' state.
         self.expect(str(process), STOPPED_DUE_TO_BREAKPOINT, exe=False,
             substrs = ["a.out",
                        "stopped"])
 
         # Disassemble the functions on the call stack.
         self.runCmd("thread backtrace")
-        thread = process.GetThreadAtIndex(0)
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+        self.assertIsNotNone(thread)
         depth = thread.GetNumFrames()
         for i in range(depth - 1):
             frame = thread.GetFrameAtIndex(i)
             function = frame.GetFunction()
             if function.GetName():
                 self.runCmd("disassemble -n '%s'" % function.GetName())
 
         lib_stdcxx = "FAILHORRIBLYHERE"

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

def get_threads_stopped_at_breakpoint (process, bkpt):
     for thread in stopped_threads:
         # Make sure we've hit our breakpoint...
         break_id = thread.GetStopReasonDataAtIndex (0)
         if break_id == bkpt.GetID():
             threads.append(thread)
 
     return threads
 
+def get_one_thread_stopped_at_breakpoint(process, bkpt, require_exactly_one = True):
+    threads = get_threads_stopped_at_breakpoint(process, bkpt)
+    if len(threads) == 0:
+        return None
+    if require_exactly_one and len(threads) != 1:
+        return None
+
+    return threads[0]
+
 def is_thread_crashed (test, thread):
     """In the test suite we dereference a null pointer to simulate a crash. The way this is
     reported depends on the platform."""
     if test.platformIsDarwin():
         return thread.GetStopReason() == lldb.eStopReasonException and "EXC_BAD_ACCESS" in thread.GetStopDescription(100)
     elif test.getPlatform() == "linux":
         return thread.GetStopReason() == lldb.eStopReasonSignal and thread.GetStopReasonDataAtIndex(0) == thread.GetProcess().GetUnixSignals().GetSignalNumberFromName("SIGSEGV")
     else:

lldb/trunk/packages/Python/lldbsuite/test/python_api/frame/TestFrames.py

def test_get_arg_vals_for_call_stack(self):
 
         # 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:
-            thread = process.GetThreadAtIndex(0)
+            thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+            self.assertIsNotNone(thread)
             # Inspect at most 3 frames.
             numFrames = min(3, thread.GetNumFrames())
             for i in range(numFrames):
                 frame = thread.GetFrameAtIndex(i)
                 if self.TraceOn():
                     print("frame:", frame)
 
                 name = frame.GetFunction().GetName()
def test_frame_api_boundary_condition(self):
 
         # Now launch the process, and do not stop at the entry point.
         process = target.LaunchSimple (None, None, self.get_process_working_directory())
 
         process = target.GetProcess()
         self.assertTrue(process.GetState() == lldb.eStateStopped,
                         PROCESS_STOPPED)
 
-        thread = process.GetThreadAtIndex(0)
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+        self.assertIsNotNone(thread)
         frame = thread.GetFrameAtIndex(0)
         if self.TraceOn():
             print("frame:", frame)
 
         # Boundary condition testings.
         val1 = frame.FindVariable(None, True)
         val2 = frame.FindVariable(None, False)
         val3 = frame.FindValue(None, lldb.eValueTypeVariableGlobal)
def test_frame_api_IsEqual(self):
 
         # Now launch the process, and do not stop at the entry point.
         process = target.LaunchSimple (None, None, self.get_process_working_directory())
 
         process = target.GetProcess()
         self.assertTrue(process.GetState() == lldb.eStateStopped,
                         PROCESS_STOPPED)
 
-        thread = process.GetThreadAtIndex(0)
-        self.assertTrue(thread)
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+        self.assertIsNotNone(thread)
 
         frameEntered = thread.GetFrameAtIndex(0)
         if self.TraceOn():
             print(frameEntered)
             lldbutil.print_stacktrace(thread)
         self.assertTrue(frameEntered)
 
         # Doing two step overs while still inside c().

lldb/trunk/packages/Python/lldbsuite/test/python_api/frame/inlines/TestInlinedFrame.py

def test_stop_at_outer_inline(self):
             print(stack_traces1)
 
         # The first breakpoint should correspond to an inlined call frame.
         # If it's an inlined call frame, expect to find, in the stack trace,
         # that there is a frame which corresponds to the following call site:
         #
         #     outer_inline (argc);
         #
-        frame0 = process.GetThreadAtIndex(0).GetFrameAtIndex(0)
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+        self.assertIsNotNone(thread)
+
+        frame0 = thread.GetFrameAtIndex(0)
         if frame0.IsInlined():
             filename = frame0.GetLineEntry().GetFileSpec().GetFilename()
             self.assertTrue(filename == self.source)
             self.expect(stack_traces1, "First stop at %s:%d" % (self.source, self.first_stop), exe=False,
                         substrs = ['%s:%d' % (self.source, self.first_stop)])
 
             # Expect to break again for the second time.
             process.Continue()
             self.assertTrue(process.GetState() == lldb.eStateStopped,
                             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/trunk/packages/Python/lldbsuite/test/python_api/hello_world/TestHelloWorld.py

def test_with_process_launch_api(self):
         #
         # Apply some dances after LaunchProcess() in order to break at "main".
         # It only works sometimes.
         #self.breakAfterLaunch(process, "main")
 
         process = target.GetProcess()
         self.assertTrue(process, PROCESS_IS_VALID)
 
-        thread = process.GetThreadAtIndex(0)
-        if thread.GetStopReason() != lldb.eStopReasonBreakpoint:
-            from lldbsuite.test.lldbutil import stop_reason_to_str
-            self.fail(STOPPED_DUE_TO_BREAKPOINT_WITH_STOP_REASON_AS %
-                      stop_reason_to_str(thread.GetStopReason()))
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+        self.assertIsNotNone(thread)
 
         # The breakpoint should have a hit count of 1.
-        self.assertTrue(breakpoint.GetHitCount() == 1, BREAKPOINT_HIT_ONCE)
+        self.assertEqual(breakpoint.GetHitCount(), 1, BREAKPOINT_HIT_ONCE)
 
     @add_test_categories(['pyapi'])
     @expectedFailureWindows("llvm.org/pr24600")
     @skipIfiOSSimulator
     def test_with_attach_to_process_with_id_api(self):
         """Create target, spawn a process, and attach to it with process id."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)

lldb/trunk/packages/Python/lldbsuite/test/python_api/sbdata/TestSBData.py

def test_with_run_command(self):
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs = ['stopped',
                                'stop reason = breakpoint'])
         
         target = self.dbg.GetSelectedTarget()
         
         process = target.GetProcess()
-        
-        thread = process.GetThreadAtIndex(0)
+        thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+        self.assertIsNotNone(thread)
 
         frame = thread.GetSelectedFrame()
         if self.TraceOn():
             print(frame)
         foobar = frame.FindVariable('foobar')
         self.assertTrue(foobar.IsValid())
         if self.TraceOn():
             print(foobar)