[lldb/test] Re-enable TestEvents.py on Darwin and fix crashes

[mib]

Summary

This patch re-enables TestEvents.py on Darwin and fixes some crashes
that were happening due to an undefined method.

I ran it 100 times locally with the following command and it passed
every the time:

for i in {1..100}; do print $i/100; ./bin/lldb-dotest -p TestEvents.py 2>&1 | rg PASSED; if [ "$?" -eq "1" ]; then break; fi; done

Let's see if it still fails non-deterministically on the bots and
eventually also re-enable it on linux.

rdar://37037235

Signed-off-by: Med Ismail Bennani <[e-mail]>

[JDevlieghere]

LGTM

lldb/test/API/python_api/event/TestEvents.py

 """
 Test lldb Python event APIs.
 """
 
 from __future__ import print_function
 
 
 import re
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 @skipIfLinux   # llvm.org/pr25924, sometimes generating SIGSEGV
-@skipIfDarwin
 class EventAPITestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     NO_DEBUG_INFO_TESTCASE = True
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
def test_wait_for_event(self):
 
         class MyListeningThread(threading.Thread):
 
             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):
-                        self.trace("Got a valid event:", event)
-                        self.trace("Event data flavor:", event.GetDataFlavor())
-                        self.trace("Event type:", lldbutil.state_type_to_str(event.GetType()))
+                        self.context.trace("Got a valid event:", event)
+                        self.context.trace("Event data flavor:", event.GetDataFlavor())
+                        self.context.trace("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()
+        my_thread.context = self
         my_thread.start()
 
         # Wait until the 'MyListeningThread' terminates.
         my_thread.join()
 
         self.assertTrue(event,
                         "My listening thread successfully received an event")
 
def test_add_listener_to_broadcaster(self):
         # Create MyListeningThread to wait for state changed events.
         # By design, a "running" event is expected following by a "stopped"
         # event.
         import threading
 
         class MyListeningThread(threading.Thread):
 
             def run(self):
-                self.trace("Running MyListeningThread:", self)
+                self.context.trace("Running MyListeningThread:", self)
 
                 # Regular expression pattern for the event description.
                 pattern = re.compile("data = {.*, state = (.*)}$")
 
                 # Let's only try at most 6 times to retrieve our events.
                 count = 0
                 while True:
                     if listener.WaitForEvent(5, event):
                         desc = lldbutil.get_description(event)
-                        self.trace("Event description:", desc)
+                        self.context.trace("Event description:", desc)
                         match = pattern.search(desc)
                         if not match:
                             break
                         if match.group(1) == 'connected':
                             # When debugging remote targets with lldb-server, we
                             # first get the 'connected' event.
                             self.context.assertTrue(self.context.state is None)
                             self.context.state = 'connected'