[TestEvents] Add a 'connected' state to include remote debugging.

[chaoren]

test/python_api/event/TestEvents.py

249–250

Update comment here?

259

Update comment here?

276–277

Perhaps we need another self.context.state value for this to ensure ordering (Bump everything after by 1).

279

s/pass/continue/?

294

We don't need this.

[sivachandra]

test/python_api/event/TestEvents.py

249–250

See my comment at 275.

259

See my comment at 275.

276–277

Should we be treating this as a state at all? The 'connected' event is just a notification of being connected and has nothing to do with the inferior state.

279

Re-reading, 'continue' seems correct. Let me know your opinion around other changes and will change this to continue along with them.

294

Perhaps. But whoever has put it, probably wanted to see a message when listener.WaitForEvent times out. That's my guess, which if correct should be have been under an else.

We could ofcourse remove this altogether as I think it was a debug print statement which the committer forgot to remove before committing.

[chaoren]

test/python_api/event/TestEvents.py

276–277

I think state describes this test (which event to expect next), and not the inferior. Regardless, It's still nice to ensure ordering.

294

Is it an error condition if all 6 attempts fail? Perhaps we should just remove this line and error out below.

297

Error here?

[sivachandra]

test/python_api/event/TestEvents.py

276–277

If ordering is a concern, how about this:

if match.group(1) == 'connected':
  self.assertTrue(self.context.state == 0)
  continue

If 'connected' is treated as a state, then there will be a different state machine (a different start state) for remote and non-remote platforms. It sounds unnecessarily complicated, but will do it if you really want it.

294

That makes it out of scope for this change. I am going to remove all my changes around this to avoid further mixup.

[chaoren]

test/python_api/event/TestEvents.py

276–277

Why not store the previous state as a string?

if match.group(1) == 'connected':
  self.assertTrue(self.context.state == None)
  self.context.state = 'connected'
  continue
elif match.group(1) == 'running':
  self.assertTrue(self.context.state == None or self.context.state == 'connected')
  self.context.state = 'running'
  continue
...

[sivachandra]

Reaching round my neck...

[chaoren]

LGTM

test/python_api/event/TestEvents.py

def do_add_listener_to_broadcaster(self):
                                  False,     # Stop at entry
                                  error)     # error
 
         # Create an empty event object.
         event = lldb.SBEvent()
         self.assertFalse(event, "Event should not be valid initially")
 
 
         # The finite state machine for our custom listening thread, with an
-        # initail state of 0, which means a "running" event is expected.
-        # It changes to 1 after "running" is received.
-        # It cahnges to 2 after "stopped" is received.
-        # 2 will be our final state and the test is complete.
-        self.state = 0 
+        # initail state of None, which means no event has been received.
+        # It changes to 'connected' after 'connected' event is received (for remote platforms)
+        # It changes to 'running' after 'running' event is received (should happen only if the
+        # currentstate is either 'None' or 'connected')
+        # It changes to 'stopped' if a 'stopped' event is received (should happen only if the
+        # current state is 'running'.)
+        self.state = None
 
         # 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):
                 #print "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)
                         #print "Event description:", desc
                         match = pattern.search(desc)
                         if not match:
                             break;
-                        if self.context.state == 0 and match.group(1) == 'running':
-                            self.context.state = 1
+                        if match.group(1) == 'connected':
+                            # When debugging remote targets with lldb-server, we
+                            # first get the 'connected' event.
+                            self.context.assertTrue(self.context.state == None)
+                            self.context.state = 'connected'
                             continue
-                        elif self.context.state == 1 and match.group(1) == 'stopped':
+                        elif match.group(1) == 'running':
+                            self.context.assertTrue(self.context.state == None or self.context.state == 'connected')
+                            self.context.state = 'running'
+                            continue
+                        elif match.group(1) == 'stopped':
+                            self.context.assertTrue(self.context.state == 'running')
                             # Whoopee, both events have been received!
-                            self.context.state = 2
+                            self.context.state = 'stopped'
                             break
                         else:
                             break
                     print "Timeout: listener.WaitForEvent"
                     count = count + 1
                     if count > 6:
                         break
 
                 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.
         my_thread = MyListeningThread()
         # Supply the enclosing context so that our listening thread can access
         # the 'state' variable.
         my_thread.context = self
         my_thread.start()
 
         # Wait until the 'MyListeningThread' terminates.
         my_thread.join()
 
         # The final judgement. :-)
-        self.assertTrue(self.state == 2,
+        self.assertTrue(self.state == 'stopped',
                         "Both expected state changed events received")
 
         
 if __name__ == '__main__':
     import atexit
     lldb.SBDebugger.Initialize()
     atexit.register(lambda: lldb.SBDebugger.Terminate())
     unittest2.main()