Only call endCompetition once during tests.

Signed-off-by: Mike Stitt <[email protected]>

Author: MikeStitt

subprojects/robotpy-wpilib/tests/test_poc_timedrobot.py

@@ -25,12 +25,6 @@
 from wpilib.simulation import pauseTiming, restartTiming
 import wpilib.simulation
 
-
-try:
-    import commands2
-except ImportError:
-    commands2 = None
-
 from wpilib.timedrobotpy import TimedRobotPy
 
 import contextlib
@@ -60,12 +54,12 @@ def __init__(self, reraise, robot: wpilib.RobotBase, expectFinished: bool):
 
         self._cond = threading.Condition()
         self._robot_started = False
-        self._robot_initialized = False
+        self._robot_init_started = False
         self._robot_finished = False
 
-    def _on_robot_initialized(self):
+    def _on_robot__init_started(self):
         with self._cond:
-            self._robot_initialized = True
+            self._robot_init_started = True
             self._cond.notify_all()
 
     def _robot_thread(self, robot):
@@ -76,15 +70,12 @@ def _robot_thread(self, robot):
         with self._reraise(catch=True):
             assert robot is not None  # shouldn't happen...
 
-            robot._TestRobot__robotInitialized = self._on_robot_initialized
+            robot._TestRobot__robotInitStarted = self._on_robot__init_started
 
             try:
                 robot.startCompetition()
                 assert self._expectFinished == self._robot_finished
             finally:
-                # always call endCompetition or python hangs
-                print("_robot_thread is calling endCompetition()")
-                robot.endCompetition()
                 del robot
 
     @contextlib.contextmanager
@@ -113,14 +104,13 @@ def run_robot(self):
 
             # If your robotInit is taking more than 2 seconds in simulation, you're
             # probably doing something wrong... but if not, please report a bug!
-            assert self._cond.wait_for(lambda: self._robot_initialized, timeout=2)
+            assert self._cond.wait_for(lambda: self._robot_init_started, timeout=2)
 
         try:
             # in this block you should tell the sim to do sim things
             yield
         finally:
             self._robot_finished = True
-            print("run_robot is calling endCompetition()")
             robot.endCompetition()
 
             if isinstance(self._reraise.exception, RuntimeError):
@@ -147,7 +137,6 @@ def run_robot(self):
         if th.is_alive():
             pytest.fail("robot did not exit within 2 seconds")
 
-        self._robot = None
         self._thread = None
 
     @property
@@ -214,10 +203,8 @@ def decorated_robot_class(myrobot_class) -> tuple:
     # to do that
     class TestRobot(robotClass):
         def robotInit(self):
-            try:
-                super().robotInit()
-            finally:
-                self.__robotInitialized()
+            self.__robotInitStarted()
+            super().robotInit()
 
     TestRobot.__name__ = robotClass.__name__
     TestRobot.__module__ = robotClass.__module__
@@ -263,21 +250,11 @@ def robot_with_sim_setup_teardown(decorated_robot_class):
     # Tests only get a proxy to ensure cleanup is more reliable
     yield weakref.proxy(robot)
 
-    # If running in separate processes, no need to do cleanup
-    # if ISOLATED:
-    #    # .. and funny enough, in isolated mode we *don't* want the
-    #    # robot to be cleaned up, as that can deadlock
-    #    self._saved_robot = robot
-    #    return
-
     # HACK: avoid motor safety deadlock
     wpilib.simulation._simulation._resetMotorSafety()
 
     del robot
 
-    if commands2 is not None:
-        commands2.CommandScheduler.resetInstance()
-
     # Double-check all objects are destroyed so that HAL handles are released
     gc.collect()
 

subprojects/robotpy-wpilib/wpilib/timedrobotpy.py

@@ -155,6 +155,7 @@ def __init__(self, period: wpimath.units.seconds = kDefaultPeriod) -> None:
         self.addPeriodic(self._loopFunc, period=self._periodS)
 
         self._notifier, status = initializeNotifier()
+        print(f"{self._notifier}, {status} = initializeNotifier()")
         if status != 0:
             raise RuntimeError(
                 f"initializeNotifier() returned {self._notifier}, {status}"
@@ -170,59 +171,65 @@ def startCompetition(self) -> None:
         """
         Provide an alternate "main loop" via startCompetition().
         """
-        self.robotInit()
-
-        if self.isSimulation():
-            self._simulationInit()
-
-        # Tell the DS that the robot is ready to be enabled
-        print("********** Robot program startup complete **********")
-        observeUserProgramStarting()
-
-        # Loop forever, calling the appropriate mode-dependent function
-        # (really not forever, there is a check for a break)
-        while True:
-            #  We don't have to check there's an element in the queue first because
-            #  there's always at least one (the constructor adds one). It's re-enqueued
-            #  at the end of the loop.
-            callback = self._callbacks.pop()
-
-            status = updateNotifierAlarm(self._notifier, callback.expirationUs)
-            if status != 0:
-                raise RuntimeError(f"updateNotifierAlarm() returned {status}")
-
-            currentTimeUs, status = waitForNotifierAlarm(self._notifier)
-            if status != 0:
-                raise RuntimeError(
-                    f"waitForNotifierAlarm() returned currentTimeUs={currentTimeUs} status={status}"
-                )
-
-            if currentTimeUs == 0:
-                # when HAL_StopNotifier(self.notifier) is called the above waitForNotifierAlarm
-                # will return a currentTimeUs==0 and the API requires robots to stop any loops.
-                # See the API for waitForNotifierAlarm
-                break
-
-            self._loopStartTimeUs = _getFPGATime()
-            self._runCallbackAndReschedule(callback, currentTimeUs)
-
-            #  Process all other callbacks that are ready to run
-            while self._callbacks.peek().expirationUs <= currentTimeUs:
+        try:
+            self.robotInit()
+
+            if self.isSimulation():
+                self._simulationInit()
+
+            # Tell the DS that the robot is ready to be enabled
+            print("********** Robot program startup complete **********", flush=True)
+            observeUserProgramStarting()
+
+            # Loop forever, calling the appropriate mode-dependent function
+            # (really not forever, there is a check for a break)
+            while True:
+                #  We don't have to check there's an element in the queue first because
+                #  there's always at least one (the constructor adds one). It's re-enqueued
+                #  at the end of the loop.
                 callback = self._callbacks.pop()
+
+                status = updateNotifierAlarm(self._notifier, callback.expirationUs)
+                if status != 0:
+                    raise RuntimeError(f"updateNotifierAlarm() returned {status}")
+
+                currentTimeUs, status = waitForNotifierAlarm(self._notifier)
+                if status != 0:
+                    raise RuntimeError(
+                        f"waitForNotifierAlarm() returned currentTimeUs={currentTimeUs} status={status}"
+                    )
+
+                if currentTimeUs == 0:
+                    # when HAL_StopNotifier(self.notifier) is called the above waitForNotifierAlarm
+                    # will return a currentTimeUs==0 and the API requires robots to stop any loops.
+                    # See the API for waitForNotifierAlarm
+                    break
+
+                self._loopStartTimeUs = _getFPGATime()
                 self._runCallbackAndReschedule(callback, currentTimeUs)
 
+                #  Process all other callbacks that are ready to run
+                while self._callbacks.peek().expirationUs <= currentTimeUs:
+                    callback = self._callbacks.pop()
+                    self._runCallbackAndReschedule(callback, currentTimeUs)
+        finally:
+            self._stopNotifier()
+
     def _runCallbackAndReschedule(
         self, callback: _Callback, currentTimeUs: microsecondsAsInt
     ) -> None:
         callback.func()
         callback.setNextStartTimeUs(currentTimeUs)
         self._callbacks.add(callback)
 
+    def _stopNotifier(self):
+        stopNotifier(self._notifier)
+
     def endCompetition(self) -> None:
         """
         Ends the main loop in startCompetition().
         """
-        stopNotifier(self._notifier)
+        self._stopNotifier()
 
     def getLoopStartTime(self) -> microsecondsAsInt:
         """