Fix TestEvents.py on OS X

[tfiala]

Summary

This change addresses a hang/segfault in TestEvents.py. The threads that run the listener loops now do an SBListener.Clear() before they wrap up their work. This prevents the test from trying to clean up the SBListener too late.

There is a separate issue here which is that we should prevent this clean-up time lock-up, but that is out of scope for this particular change. I'd like to get these tests back and running the normal flow rather than skipping them.

This addresses:
llvm.org/pr25924 (at least, the OS X side, although I suspect this will also address Linux)

[tfiala]

Added full diff context to diff.

[jingham]

I agree, doing something to get the test working is primary. Then we can go back and figure out why the less ordered shutdown doesn't work.

[tfiala]

Closed by commit r268653

packages/Python/lldbsuite/test/python_api/event/TestEvents.py

 """
 Test lldb Python event APIs.
 """
 
 from __future__ import print_function
 
 
 
 import os, time
 import re
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
-@skipIfDarwin  # llvm.org/pr25924, sometimes generating SIGSEGV
 @skipIfLinux   # llvm.org/pr25924, sometimes generating SIGSEGV
 class EventAPITestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
def test_listen_for_and_print_event(self):
                             print("Event description:", desc)
                             print("Event data flavor:", event.GetDataFlavor())
                             print("Process state:", lldbutil.state_type_to_str(process.GetState()))
                             print()
                     else:
                         if traceOn:
                             print("timeout occurred waiting for event...")
                     count = count + 1
+                listener.Clear()
                 return
 
         # Let's start the listening thread to retrieve the events.
         my_thread = MyListeningThread()
         my_thread.start()
 
         # Use Python API to continue the process.  The listening thread should be
         # able to receive the state changed events.
         process.Continue()
 
         # Use Python API to kill the process.  The listening thread should be
         # able to receive the state changed event, too.
         process.Kill()
 
         # Wait until the 'MyListeningThread' terminates.
         my_thread.join()
 
+        # Shouldn't we be testing against some kind of expectation here?
+
     @add_test_categories(['pyapi'])
     @expectedFlakeyLinux("llvm.org/pr23730") # Flaky, fails ~1/100 cases
     def test_wait_for_event(self):
         """Exercise SBListener.WaitForEvent() API."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         self.dbg.SetAsync(True)
def test_wait_for_event(self):
             def run(self):
                 count = 0
                 # Let's only try at most 3 times to retrieve any kind of event.
                 while not count > 3:
                     if listener.WaitForEvent(5, event):
                         #print("Got a valid event:", event)
                         #print("Event data flavor:", event.GetDataFlavor())
                         #print("Event type:", lldbutil.state_type_to_str(event.GetType()))
+                        listener.Clear()
                         return
                     count = count + 1
                     print("Timeout: listener.WaitForEvent")
-
+                listener.Clear()
                 return
 
         # Use Python API to kill the process.  The listening thread should be
         # able to receive a state changed event.
         process.Kill()
 
         # Let's start the listening thread to retrieve the event.
         my_thread = MyListeningThread()
def test_add_listener_to_broadcaster(self):
                             self.context.state = 'stopped'
                             break
                         else:
                             break
                     print("Timeout: listener.WaitForEvent")
                     count = count + 1
                     if count > 6:
                         break
-
+                listener.Clear()
                 return
 
         # Use Python API to continue the process.  The listening thread should be
         # able to receive the state changed events.
         process.Continue()
 
         # Start the listening thread to receive the "running" followed by the
         # "stopped" events.