cw: Got all tests running correctly.

Charles Weir · Charles Weir · commit 98c3f3c93321 · 2014-04-20T17:20:17.000+01:00
diff --git a/BrickPython/Coroutine.py b/BrickPython/Coroutine.py
@@ -62,6 +62,9 @@ def call(self, param = None):
             self.callerSemaphore.acquire()
             if self.stopEvent.is_set():
                 self.join() # Ensure that is_alive is false on exit.
+                # For testing - assertions within coroutines must be passed back to main thread.
+                if self.lastExceptionCaught != None and isinstance(self.lastExceptionCaught, AssertionError):
+                    raise self.lastExceptionCaught
         return self.callResult
 
     def stop(self):
diff --git a/test/TestCoroutine.py b/test/TestCoroutine.py
@@ -37,9 +37,11 @@ def dummyCoroutineFuncThatDoesCleanup():
 
     def setUp(self):
         TestCoroutine.coroutineCalls = []
+        TestCoroutine.oldCurrentTimeMillis = Coroutine.currentTimeMillis
+        Coroutine.currentTimeMillis = Mock(side_effect = [1,10,500,1200])
 
     def tearDown(self):
-        pass
+        Coroutine.currentTimeMillis = TestCoroutine.oldCurrentTimeMillis
 
     def testCoroutinesGetCalledUntilDone(self):
         # When we start a coroutine
@@ -88,8 +90,6 @@ def dummyCoroutineFuncWaiting1Sec():
             Coroutine.waitMilliseconds(1000)
 
         coroutine = Coroutine(dummyCoroutineFuncWaiting1Sec)
-        # Doesn't matter not restoring this; tests never use real time:
-        Coroutine.currentTimeMillis = Mock(side_effect = [1,10,500,1200])
         for i in range(1,3):
             coroutine.call()
             self.assertTrue(coroutine.is_alive(),"Coroutine dead at call %d" % i)
@@ -132,7 +132,6 @@ def testRunCoroutinesUntilAllComplete(self):
         self.assertEquals(TestCoroutine.coroutineCalls, [1,1,2,2,3,4,5])
 
     def testWithTimeout(self):
-        Coroutine.currentTimeMillis = Mock(side_effect = [1,10,500,1200])
         coroutine = Coroutine(TestCoroutine.dummyCoroutineFunc,1,20).withTimeout(1000)
         for i in range(1,20):
             coroutine.call()
diff --git a/test/TestMotor.py b/test/TestMotor.py
@@ -12,12 +12,18 @@
 class TestMotor(unittest.TestCase):
     ''' Tests for the Motor class, especially for PID Servo Motor functionality'''
     def setUp(self):
+        self.saveTime = Scheduler.currentTimeMillis
+        Scheduler.currentTimeMillis = Mock(side_effect = xrange(1,10000))
         self.bp = BrickPiWrapper()
         motor = self.motor = self.bp.motor( 'A' )
         #motor.position = Mock()
         motor.timeMillis = Mock()
         motor.timeMillis.side_effect = range(0,9999)
 
+    def tearDown(self):
+        Scheduler.currentTimeMillis = self.saveTime
+        unittest.TestCase.tearDown(self)
+
     def testZeroPosition( self ):
         motor = self.motor
         # When the motor is zeroed at absolute position 1
diff --git a/test/TestScheduler.py b/test/TestScheduler.py
@@ -43,7 +43,7 @@ def dummyCoroutineThatTakesTime():
 
     @staticmethod
     def dummyCoroutineThatThrowsException():
-        raise Exception()
+        raise Exception("Hello")
         yield
 
     @staticmethod
@@ -58,9 +58,13 @@ def checkCoroutineFinished(coroutine):
 
     def setUp(self):
         TestScheduler.coroutineCalls = []
-        self.scheduler = Scheduler()
-        # Don't need to replace this afterward - tests never use real time.
+        TestScheduler.oldCurrentTimeMillis = Scheduler.currentTimeMillis
         Scheduler.currentTimeMillis =  Mock( side_effect = xrange(0,10000) ) # Each call answers the next integer
+        self.scheduler = Scheduler()
+
+    def tearDown(self):
+        Scheduler.currentTimeMillis = TestScheduler.oldCurrentTimeMillis
+
 
     def testCoroutinesGetCalledUntilDone(self):
         # When we start a motor coroutine
@@ -162,7 +166,8 @@ def testWaitMilliseconds(self):
         for i in self.scheduler.waitMilliseconds(10):
             pass
         # that's about the time that will have passed:
-        assert( self.scheduler.currentTimeMillis() in range(10,12) )
+        timeNow = self.scheduler.currentTimeMillis()
+        assert( timeNow in range(10,12), "Wrong time "  )
 
     def testRunTillFirstCompletes(self):
         # When we run three coroutines using runTillFirstCompletes:
@@ -224,12 +229,12 @@ def timeCheckerCoroutine(self):
         while True:
             yield
             newTime = Scheduler.currentTimeMillis()
-            self.assertNotEquals( newTime, time )
+            self.assertNotEquals( newTime, time, "Time same for two scheduler calls" )
             time = newTime
 
     def testEachCallToACoroutineGetsADifferentTime(self):
-        scheduler = Scheduler()
         Scheduler.currentTimeMillis =  Mock( side_effect = [0,0,0,0,0,0,0,0,0,0,1,2,3,4,5] )
+        scheduler = Scheduler()
         # For any coroutine,
         scheduler.setUpdateCoroutine( self.timeCheckerCoroutine() )
         # We can guarantee that the timer always increments between calls (for speed calculations etc).
