Add subset of translated tests

Author: virtuald

tests/conftest.py

@@ -0,0 +1,11 @@
+import pytest
+
+import commands2
+from wpilib.simulation import DriverStationSim
+
+
+@pytest.fixture(autouse=True)
+def scheduler():
+    commands2.CommandScheduler.resetInstance()
+    DriverStationSim.setEnabled(True)
+    return commands2.CommandScheduler.getInstance()

tests/run_tests.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python3
+
+import os
+from os.path import abspath, dirname
+import sys
+import subprocess
+
+if __name__ == "__main__":
+
+    root = abspath(dirname(__file__))
+    os.chdir(root)
+
+    subprocess.check_call([sys.executable, "-m", "py.test"])

tests/test_button.py

@@ -0,0 +1,204 @@
+import commands2
+import commands2.button
+
+from util import Counter
+
+
+class MyButton(commands2.button.Button):
+    def __init__(self):
+        super().__init__(self.isPressed)
+        self.pressed = False
+
+    def isPressed(self) -> bool:
+        return self.pressed
+
+    def setPressed(self, value: bool):
+        self.pressed = value
+
+
+class MyCommand(commands2.CommandBase):
+    executed = 0
+
+    ended = 0
+    canceled = 0
+
+    def execute(self) -> None:
+        self.executed += 1
+
+    def end(self, interrupted: bool) -> None:
+        self.ended += 1
+        if interrupted:
+            self.canceled += 1
+
+
+def test_when_pressed(scheduler: commands2.CommandScheduler):
+    cmd1 = MyCommand()
+    button = MyButton()
+    button.setPressed(False)
+
+    button.whenPressed(cmd1)
+    scheduler.run()
+
+    assert not cmd1.executed
+    assert not scheduler.isScheduled(cmd1)
+
+    button.setPressed(True)
+    scheduler.run()
+    scheduler.run()
+
+    assert cmd1.executed
+    assert scheduler.isScheduled(cmd1)
+
+
+def test_when_released(scheduler: commands2.CommandScheduler):
+    cmd1 = MyCommand()
+    button = MyButton()
+    button.setPressed(True)
+
+    button.whenReleased(cmd1)
+    scheduler.run()
+
+    assert not cmd1.executed
+    assert not scheduler.isScheduled(cmd1)
+
+    button.setPressed(False)
+    scheduler.run()
+    scheduler.run()
+
+    assert cmd1.executed
+    assert scheduler.isScheduled(cmd1)
+
+
+def test_while_held(scheduler: commands2.CommandScheduler):
+    cmd1 = MyCommand()
+    button = MyButton()
+    button.setPressed(False)
+
+    button.whileHeld(cmd1)
+    scheduler.run()
+
+    assert not cmd1.executed
+    assert not scheduler.isScheduled(cmd1)
+
+    button.setPressed(True)
+    scheduler.run()
+    scheduler.run()
+
+    assert cmd1.executed == 2
+    assert scheduler.isScheduled(cmd1)
+
+    button.setPressed(False)
+    scheduler.run()
+
+    assert cmd1.executed == 2
+    assert not scheduler.isScheduled(cmd1)
+
+
+def test_when_held(scheduler: commands2.CommandScheduler):
+    cmd1 = MyCommand()
+    button = MyButton()
+    button.setPressed(False)
+
+    button.whenHeld(cmd1)
+    scheduler.run()
+
+    assert not cmd1.executed
+    assert not scheduler.isScheduled(cmd1)
+
+    button.setPressed(True)
+    scheduler.run()
+    scheduler.run()
+
+    assert cmd1.executed == 2
+    assert scheduler.isScheduled(cmd1)
+
+    button.setPressed(False)
+    scheduler.run()
+
+    assert cmd1.executed == 2
+    assert not scheduler.isScheduled(cmd1)
+
+
+def test_toggle_when_pressed(scheduler: commands2.CommandScheduler):
+    cmd1 = MyCommand()
+    button = MyButton()
+    button.setPressed(False)
+
+    button.toggleWhenPressed(cmd1)
+    scheduler.run()
+
+    assert not cmd1.executed
+    assert not scheduler.isScheduled(cmd1)
+
+    button.setPressed(True)
+    scheduler.run()
+
+    assert cmd1.executed
+    assert scheduler.isScheduled(cmd1)
+
+
+def test_cancel_when_pressed(scheduler: commands2.CommandScheduler):
+    cmd1 = MyCommand()
+    button = MyButton()
+    button.setPressed(False)
+
+    scheduler.schedule(cmd1)
+
+    button.cancelWhenPressed(cmd1)
+    scheduler.run()
+
+    assert cmd1.executed == 1
+    assert cmd1.ended == 0
+    assert cmd1.canceled == 0
+    assert scheduler.isScheduled(cmd1)
+
+    button.setPressed(True)
+    scheduler.run()
+    scheduler.run()
+
+    assert cmd1.executed == 1
+    assert cmd1.ended == 1
+    assert cmd1.canceled == 1
+    assert not scheduler.isScheduled(cmd1)
+
+
+def test_function_bindings(scheduler: commands2.CommandScheduler):
+
+    buttonWhenPressed = MyButton()
+    buttonWhileHeld = MyButton()
+    buttonWhenReleased = MyButton()
+
+    buttonWhenPressed.setPressed(False)
+    buttonWhileHeld.setPressed(True)
+    buttonWhenReleased.setPressed(True)
+
+    counter = Counter()
+
+    buttonWhenPressed.whenPressed(counter.increment)
+    buttonWhileHeld.whileHeld(counter.increment)
+    buttonWhenReleased.whenReleased(counter.increment)
+
+    scheduler.run()
+    buttonWhenPressed.setPressed(True)
+    buttonWhenReleased.setPressed(False)
+    scheduler.run()
+
+    assert counter.value == 4
+
+
+def test_button_composition(scheduler: commands2.CommandScheduler):
+
+    button1 = MyButton()
+    button2 = MyButton()
+
+    button1.setPressed(True)
+    button2.setPressed(False)
+
+    # TODO: not sure if this is a great idea?
+    assert button1
+    assert not button2
+
+    assert not button1.and_(button2)
+    assert button1.or_(button2)
+    assert not button1.not_()
+    assert button1.and_(button2.not_())

tests/test_command_decorators.py

@@ -0,0 +1,149 @@
+from util import ConditionHolder, ManualSimTime
+import commands2
+
+
+def test_with_timeout(scheduler: commands2.CommandScheduler):
+    with ManualSimTime() as tm:
+
+        cmd = commands2.WaitCommand(10)
+        timeout = cmd.withTimeout(2)
+
+        scheduler.schedule(timeout)
+        scheduler.run()
+
+        assert not scheduler.isScheduled(cmd)
+        assert scheduler.isScheduled(timeout)
+
+        tm.step(3)
+
+        scheduler.run()
+        assert not scheduler.isScheduled(timeout)
+
+
+def test_with_interrupt(scheduler: commands2.CommandScheduler):
+
+    cond = ConditionHolder()
+
+    cmd = commands2.WaitCommand(10)
+    timeout = cmd.withInterrupt(cond.getCondition)
+
+    scheduler.schedule(timeout)
+    scheduler.run()
+
+    assert not scheduler.isScheduled(cmd)
+    assert scheduler.isScheduled(timeout)
+
+    cond.setTrue()
+
+    scheduler.run()
+    assert not scheduler.isScheduled(cmd)
+
+
+def test_before_starting(scheduler: commands2.CommandScheduler):
+
+    cond = ConditionHolder()
+
+    cmd = commands2.InstantCommand().beforeStarting(cond.setTrue)
+
+    scheduler.schedule(cmd)
+
+    assert cond.getCondition()
+
+    scheduler.run()
+    scheduler.run()
+
+    assert not scheduler.isScheduled(cmd)
+
+
+def test_and_then_fn(scheduler: commands2.CommandScheduler):
+    cond = ConditionHolder()
+
+    cmd = commands2.InstantCommand().andThen(cond.setTrue)
+
+    scheduler.schedule(cmd)
+
+    assert not cond.getCondition()
+
+    scheduler.run()
+    scheduler.run()
+
+    assert not scheduler.isScheduled(cmd)
+    assert cond.getCondition()
+
+
+def test_and_then_commands(scheduler: commands2.CommandScheduler):
+    cond = ConditionHolder()
+
+    cmd1 = commands2.InstantCommand()
+    cmd2 = commands2.InstantCommand(cond.setTrue)
+
+    scheduler.schedule(cmd1.andThen(cmd2))
+
+    assert not cond.getCondition()
+
+    scheduler.run()
+
+    assert cond.getCondition()
+
+
+def test_deadline_with(scheduler: commands2.CommandScheduler):
+    cond = ConditionHolder()
+
+    dictator = commands2.WaitUntilCommand(cond.getCondition)
+    endsBefore = commands2.InstantCommand()
+    endsAfter = commands2.WaitUntilCommand(lambda: False)
+
+    group = dictator.deadlineWith(endsBefore, endsAfter)
+
+    scheduler.schedule(group)
+    scheduler.run()
+
+    assert scheduler.isScheduled(group)
+
+    cond.setTrue()
+    scheduler.run()
+
+    assert not scheduler.isScheduled(group)
+
+
+def test_along_with(scheduler: commands2.CommandScheduler):
+    cond = ConditionHolder(False)
+
+    cmd1 = commands2.WaitUntilCommand(cond.getCondition)
+    cmd2 = commands2.InstantCommand()
+
+    group = cmd1.alongWith(cmd2)
+
+    scheduler.schedule(group)
+    scheduler.run()
+
+    assert scheduler.isScheduled(group)
+
+    cond.setTrue()
+    scheduler.run()
+
+    assert not scheduler.isScheduled(group)
+
+
+def test_race_with(scheduler: commands2.CommandScheduler):
+    cmd1 = commands2.WaitUntilCommand(lambda: False)
+    cmd2 = commands2.InstantCommand()
+
+    group = cmd1.raceWith(cmd2)
+
+    scheduler.schedule(group)
+    scheduler.run()
+
+    assert not scheduler.isScheduled(group)
+
+
+def test_perpetually(scheduler: commands2.CommandScheduler):
+
+    cmd = commands2.InstantCommand().perpetually()
+
+    scheduler.schedule(cmd)
+
+    scheduler.run()
+    scheduler.run()
+
+    assert scheduler.isScheduled(cmd)