cw: Got runTillFirstCompletes working for new Coroutine implementation.

Charles Weir · Charles Weir · commit c616647c9963 · 2014-04-20T15:34:58.000+01:00
diff --git a/BrickPython/Coroutine.py b/BrickPython/Coroutine.py
@@ -16,6 +16,7 @@ class StopCoroutineException( Exception ):
 
 class Coroutine( threading.Thread ):
     def __init__(self, func, *args, **kwargs):
+        print "Coroutine: %r %r" % (args, kwargs)
         threading.Thread.__init__(self)
         self.args = args
         self.kwargs = kwargs
@@ -48,17 +49,20 @@ def run(self):
             exc_type, exc_value, exc_traceback = sys.exc_info()
             trace = "".join(traceback.format_tb(exc_traceback))
             self.logger.debug( "Traceback (latest call first):\n %s" % trace )
+        self.stopEvent.set() # Need to tell caller to do a join.
         self.callerSemaphore.release()
         threading.Thread.run(self) # Does some cleanup.
 
     def call(self, param = None):
         '''Executed from the caller thread.  Runs the coroutine until it calls wait.
         Does nothing if the thread has terminated.
         If a parameter is passed, it is returned from the Coroutine.wait() function in the coroutine thread.'''
-        if self.isAlive():
+        if self.is_alive():
             self.callParam = param
             self.mySemaphore.release()
             self.callerSemaphore.acquire()
+            if self.stopEvent.is_set():
+                self.join() # Ensure that is_alive is false on exit.
         return self.callResult
 
     def stop(self):
@@ -85,12 +89,27 @@ def wait(param = None):
 
     @staticmethod
     def waitMilliseconds(timeMillis):
-        'Called from within the coroutine to wait the given time'
+        '''Called from within the coroutine to wait the given time.
+        I.e. Invocations of the coroutine using call() will do nothing until then. '''
         startTime = Coroutine.currentTimeMillis()
         while Coroutine.currentTimeMillis() - startTime < timeMillis:
             Coroutine.wait()
 
-#             while not self.stopEvent.is_set():
+    @staticmethod
+    def runTillFirstCompletes(*coroutines):
+        def runTillFirstCompletesFunc(*coroutineList):
+            while True:
+                for c in coroutineList:
+                    c.call()
+                    if not c.is_alive():
+                        break
+                Coroutine.wait()
+            for c in coroutineList:
+                if c.is_alive():
+                    c.stop()
+
+        result = Coroutine(runTillFirstCompletesFunc, *coroutines)
+        return result
 
 #
 #         self.scheduler.coroutines.remove( self )
diff --git a/test/TestCoroutine.py b/test/TestCoroutine.py
@@ -14,13 +14,16 @@
 import logging
 from mock import *
 
+logging.basicConfig(format='%(message)s', level=logging.DEBUG) # Logging is a simple print
+
 class TestCoroutine(unittest.TestCase):
     ''' Tests for the Scheduler class, its built-in coroutines, and its coroutine handling.
     '''
     coroutineCalls = []
     @staticmethod
-    def dummyCoroutineFunc():
-        for i in range(1, 5):
+    def dummyCoroutineFunc(start=1, end=5):
+        logging.debug( "in dummyCoroutineFunc %d %d" %(start, end) )
+        for i in range(start, end):
             TestCoroutine.coroutineCalls.append(i)
             Coroutine.wait();
 
@@ -32,7 +35,7 @@ def dummyCoroutineFuncThatDoesCleanup():
                 Coroutine.wait()
             finally:
                 TestCoroutine.coroutineCalls.append( -1 )
-                
+
     def setUp(self):
         TestCoroutine.coroutineCalls = []
 
@@ -45,7 +48,9 @@ def testCoroutinesGetCalledUntilDone(self):
         coroutine = Coroutine( f )
         # It's a daemon thread
         self.assertTrue( coroutine.isDaemon())
-        # It doesn't run until we call it.
+        # It's alive
+        self.assertTrue(coroutine.is_alive())
+        # But it doesn't run until we call it.
         self.assertEqual(TestCoroutine.coroutineCalls, [] )
         # Each call gets one iteration
         coroutine.call()
@@ -113,17 +118,13 @@ def cofunc():
         #And running it has caused the result parameter to be checked correctly before the coroutine terminated
         self.assertFalse(coroutine.is_alive())
 
-    def testRunCoroutinesUntilFirstCompletes(self):
-        def cofunc1():
-            Coroutine.wait()
-        def cofunc2():
-            Coroutine.wait()
-            Coroutine.wait()
-#         Coroutine.runTillFirstCompletes
-        pass
+    def testRunCoroutinesUntilFirstCompletesOrAllComplete(self):
+        coroutine = Coroutine.runTillFirstCompletes(Coroutine(TestCoroutine.dummyCoroutineFunc,1,3),
+                                                    Coroutine(TestCoroutine.dummyCoroutineFunc,1,6))
+        for i in range(1,10):
+            coroutine.call()
+        self.assertEquals(TestCoroutine.coroutineCalls, [1,1,2,2])
 
-    def testRunCoroutinesUntilAllComplete(self):
-        pass
 
 
 
