Make TestThreadStates more stable

[labath]

Summary

Because of the large number of XFAILs TestThreadStates has decayed quite a bit. This commit does
the following:

• removes the "breakpoint list" expectations. Most tests have been failing on this, because the command output changed quite a while back. I remove it, because run_break_set_by_file_and_line already does a decent amount of checking
• fixup test_state_after_expression: this was calling the wrong function by mistake. As now the function actually tests something (which we know is broken), I needed to XFAIL it as well.
• replaces the sleep() with a proper wait-for-event functionality in parts which use async mode, to stabilize the one function that actually tests something.

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

class ThreadStateTestCase(TestBase):
     def test_state_after_continue(self):
         """Test thread state after continue."""
         self.build(dictionary=self.getBuildFlags(use_cpp11=False))
         self.thread_state_after_continue_test()
 
     @skipIfDarwin # 'llvm.org/pr23669', cause Python crash randomly
     @expectedFailureDarwin('llvm.org/pr23669')
     @expectedFailureWindows("llvm.org/pr24660")
+    @unittest2.expectedFailure("llvm.org/pr16712") # thread states not properly maintained
     def test_state_after_expression(self):
         """Test thread state after expression."""
         self.build(dictionary=self.getBuildFlags(use_cpp11=False))
-        self.thread_state_after_continue_test()
+        self.thread_state_after_expression_test()
 
     @unittest2.expectedFailure("llvm.org/pr16712") # thread states not properly maintained
     @expectedFailureWindows("llvm.org/pr24668") # Breakpoints not resolved correctly
     def test_process_interrupt(self):
         """Test process interrupt."""
         self.build(dictionary=self.getBuildFlags(use_cpp11=False))
         self.process_interrupt_test()
 
class ThreadStateTestCase(TestBase):
     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)
 
-        # The breakpoint list should show 1 breakpoint with 1 location.
-        self.expect("breakpoint list -f", "Breakpoint location shown correctly",
-            substrs = ["1: file = 'main.cpp', line = %d, locations = 1" % self.break_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'])
def thread_state_after_breakpoint_test(self):
 
         # 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 wait_for_running_event(self):
+        listener = self.dbg.GetListener()
+        if lldb.remote_platform:
+            lldbutil.expect_state_changes(self, listener, [lldb.eStateConnected])
+        lldbutil.expect_state_changes(self, listener, [lldb.eStateRunning])
+
     def thread_state_after_continue_test(self):
         """Test thread state after 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)
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.break_2, num_expected_locations=1)
 
-        # The breakpoint list should show 1 breakpoints with 1 location.
-        self.expect("breakpoint list -f", "Breakpoint location shown correctly",
-            substrs = ["1: file = 'main.cpp', line = %d, exact_match = 0, locations = 1" % self.break_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)
 
         # Continue, the inferior will go into an infinite loop waiting for 'g_test' to change.
         self.dbg.SetAsync(True)
         self.runCmd("continue")
-        time.sleep(1)
+        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)
 
         # Kill the process
         self.runCmd("process kill")
 
     def thread_state_after_expression_test(self):
         """Test thread state after expression."""
         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)
 
-        # The breakpoint list should show 1 breakpoints with 1 location.
-        self.expect("breakpoint list -f", "Breakpoint location shown correctly",
-            substrs = ["1: file = 'main.cpp', line = %d, locations = 1" % self.break_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'])
class ThreadStateTestCase(TestBase):
     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)
 
-        # The breakpoint list should show 1 breakpoints with 1 location.
-        self.expect("breakpoint list -f", "Breakpoint location shown correctly",
-            substrs = ["1: file = 'main.cpp', line = %d, locations = 1" % self.break_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.')
 
         # Continue, the inferior will go into an infinite loop waiting for 'g_test' to change.
         self.dbg.SetAsync(True)
         self.runCmd("continue")
-        time.sleep(1)
+        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.
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)
 
-        # The breakpoint list should show 2 breakpoints with 1 location each.
-        self.expect("breakpoint list -f", "Breakpoint location shown correctly",
-            substrs = ["1: file = 'main.cpp', line = %d, locations = 1" % self.break_1,
-                       "2: file = 'main.cpp', line = %d, locations = 1" % self.break_2])
-
         # 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'])
def thread_states_test(self):
 
         # 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")
-        time.sleep(1)
+        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)