public void TestParallelCommandGroupWithTwoCommands()
        {
            MockCommand command1 = new MockCommand();
            MockCommand command2 = new MockCommand();

            CommandGroup commandGroup = new CommandGroup();
            commandGroup.AddParallel(command1);
            commandGroup.AddParallel(command2);

            AssertCommandState(command1, 0, 0, 0, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            commandGroup.Start();
            AssertCommandState(command1, 0, 0, 0, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 0, 0, 0, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 1, 1, 0, 0);
            AssertCommandState(command2, 1, 1, 1, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 2, 2, 0, 0);
            AssertCommandState(command2, 1, 2, 2, 0, 0);
            command1.SetHasFinished(true);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 3, 3, 1, 0);
            AssertCommandState(command2, 1, 3, 3, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 3, 3, 1, 0);
            AssertCommandState(command2, 1, 4, 4, 0, 0);
            command2.SetHasFinished(true);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 3, 3, 1, 0);
            AssertCommandState(command2, 1, 5, 5, 1, 0);
        }
        public void TestCommandFailingSupersedingBecauseFirstCannotBeInterrupted()
        {
            ASubsystem subsystem = new ASubsystem();

            MockCommand command1 = new MockCommand("Num1");
            command1.AddRequires(subsystem);
            command1.SetInterruptable(false);

            MockCommand command2 = new MockCommand("Num2");
            command2.AddRequires(subsystem);

            AssertCommandState(command1, 0, 0, 0, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            command1.Start();
            AssertCommandState(command1, 0, 0, 0, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 0, 0, 0, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 1, 1, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 2, 2, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 3, 3, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            command2.Start();
            AssertCommandState(command1, 1, 3, 3, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 4, 4, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
        }
 public void AssertCommandState(MockCommand command, int initialize, int execute, int isFinished, int end,
     int interrupted)
 {
     Assert.AreEqual(initialize, command.GetInitializeCount());
     Assert.AreEqual(execute, command.GetExecuteCount());
     Assert.AreEqual(isFinished, command.GetIsFinishedCount());
     Assert.AreEqual(end, command.GetEndCount());
     Assert.AreEqual(interrupted, command.GetInterruptedCount());
 }
示例#4
0
        public void TestDefaultCommandWhereTheInterruptingCommandEndsItself()
        {
            ASubsystem subsystem = new ASubsystem();

            MockCommand defaultCommand = new MockCommand();

            defaultCommand.AddRequires(subsystem);

            MockCommand anotherCommand = new MockCommand();

            anotherCommand.AddRequires(subsystem);

            AssertCommandState(defaultCommand, 0, 0, 0, 0, 0);
            subsystem.Init(defaultCommand);

            AssertCommandState(defaultCommand, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 1, 1, 1, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 1, 2, 2, 0, 0);

            anotherCommand.Start();
            AssertCommandState(defaultCommand, 1, 2, 2, 0, 0);
            AssertCommandState(anotherCommand, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 1, 3, 3, 0, 1);
            AssertCommandState(anotherCommand, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 1, 3, 3, 0, 1);
            AssertCommandState(anotherCommand, 1, 1, 1, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 1, 3, 3, 0, 1);
            AssertCommandState(anotherCommand, 1, 2, 2, 0, 0);
            anotherCommand.SetHasFinished(true);
            AssertCommandState(defaultCommand, 1, 3, 3, 0, 1);
            AssertCommandState(anotherCommand, 1, 2, 2, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 1, 3, 3, 0, 1);
            AssertCommandState(anotherCommand, 1, 3, 3, 1, 0);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 2, 4, 4, 0, 1);
            AssertCommandState(anotherCommand, 1, 3, 3, 1, 0);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 2, 5, 5, 0, 1);
            AssertCommandState(anotherCommand, 1, 3, 3, 1, 0);
        }
示例#5
0
        public void TestDefaultCommandInterruptingCommandCanceled()
        {
            ASubsystem subsystem = new ASubsystem();

            MockCommand defaultCommand = new MockCommand();

            defaultCommand.AddRequires(subsystem);

            MockCommand anotherCommand = new MockCommand();

            anotherCommand.AddRequires(subsystem);

            AssertCommandState(defaultCommand, 0, 0, 0, 0, 0);
            subsystem.Init(defaultCommand);
            subsystem.PublicInitDefaultCommand();
            AssertCommandState(defaultCommand, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 1, 1, 1, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 1, 2, 2, 0, 0);

            anotherCommand.Start();
            AssertCommandState(defaultCommand, 1, 2, 2, 0, 0);
            AssertCommandState(anotherCommand, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 1, 3, 3, 0, 1);
            AssertCommandState(anotherCommand, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 1, 3, 3, 0, 1);
            AssertCommandState(anotherCommand, 1, 1, 1, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 1, 3, 3, 0, 1);
            AssertCommandState(anotherCommand, 1, 2, 2, 0, 0);
            anotherCommand.Cancel();
            AssertCommandState(defaultCommand, 1, 3, 3, 0, 1);
            AssertCommandState(anotherCommand, 1, 2, 2, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 1, 3, 3, 0, 1);
            AssertCommandState(anotherCommand, 1, 2, 2, 0, 1);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 2, 4, 4, 0, 1);
            AssertCommandState(anotherCommand, 1, 2, 2, 0, 1);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 2, 5, 5, 0, 1);
            AssertCommandState(anotherCommand, 1, 2, 2, 0, 1);
        }
示例#6
0
        public void TestDefaultCommandInterruptingCommandCanceled()
        {
            ASubsystem subsystem = new ASubsystem();

            MockCommand defaultCommand = new MockCommand();
            defaultCommand.AddRequires(subsystem);

            MockCommand anotherCommand = new MockCommand();
            anotherCommand.AddRequires(subsystem);

            AssertCommandState(defaultCommand, 0, 0, 0, 0, 0);
            subsystem.Init(defaultCommand);
            subsystem.PublicInitDefaultCommand();
            AssertCommandState(defaultCommand, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 1, 1, 1, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 1, 2, 2, 0, 0);

            anotherCommand.Start();
            AssertCommandState(defaultCommand, 1, 2, 2, 0, 0);
            AssertCommandState(anotherCommand, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 1, 3, 3, 0, 1);
            AssertCommandState(anotherCommand, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 1, 3, 3, 0, 1);
            AssertCommandState(anotherCommand, 1, 1, 1, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 1, 3, 3, 0, 1);
            AssertCommandState(anotherCommand, 1, 2, 2, 0, 0);
            anotherCommand.Cancel();
            AssertCommandState(defaultCommand, 1, 3, 3, 0, 1);
            AssertCommandState(anotherCommand, 1, 2, 2, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 1, 3, 3, 0, 1);
            AssertCommandState(anotherCommand, 1, 2, 2, 0, 1);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 2, 4, 4, 0, 1);
            AssertCommandState(anotherCommand, 1, 2, 2, 0, 1);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 2, 5, 5, 0, 1);
            AssertCommandState(anotherCommand, 1, 2, 2, 0, 1);
        }
示例#7
0
        public void TestDefaultCommandWhereTheInterruptingCommandEndsItself()
        {
            ASubsystem subsystem = new ASubsystem();

            MockCommand defaultCommand = new MockCommand();
            defaultCommand.AddRequires(subsystem);

            MockCommand anotherCommand = new MockCommand();
            anotherCommand.AddRequires(subsystem);

            AssertCommandState(defaultCommand, 0, 0, 0, 0, 0);
            subsystem.Init(defaultCommand);

            AssertCommandState(defaultCommand, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 1, 1, 1, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 1, 2, 2, 0, 0);

            anotherCommand.Start();
            AssertCommandState(defaultCommand, 1, 2, 2, 0, 0);
            AssertCommandState(anotherCommand, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 1, 3, 3, 0, 1);
            AssertCommandState(anotherCommand, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 1, 3, 3, 0, 1);
            AssertCommandState(anotherCommand, 1, 1, 1, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 1, 3, 3, 0, 1);
            AssertCommandState(anotherCommand, 1, 2, 2, 0, 0);
            anotherCommand.SetHasFinished(true);
            AssertCommandState(defaultCommand, 1, 3, 3, 0, 1);
            AssertCommandState(anotherCommand, 1, 2, 2, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 1, 3, 3, 0, 1);
            AssertCommandState(anotherCommand, 1, 3, 3, 1, 0);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 2, 4, 4, 0, 1);
            AssertCommandState(anotherCommand, 1, 3, 3, 1, 0);
            Scheduler.Instance.Run();
            AssertCommandState(defaultCommand, 2, 5, 5, 0, 1);
            AssertCommandState(anotherCommand, 1, 3, 3, 1, 0);
        }
示例#8
0
        public void TestOneCommandSupersedingAnotherBecauseOfDependencies()
        {
            ASubsystem subsystem = new ASubsystem();

            MockCommand command1 = new MockCommand("Num1");

            command1.AddRequires(subsystem);

            MockCommand command2 = new MockCommand("Num2");

            command2.AddRequires(subsystem);

            AssertCommandState(command1, 0, 0, 0, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            command1.Start();
            AssertCommandState(command1, 0, 0, 0, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 0, 0, 0, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 1, 1, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 2, 2, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 3, 3, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            command2.Start();
            AssertCommandState(command1, 1, 3, 3, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 4, 4, 0, 1);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 4, 4, 0, 1);
            AssertCommandState(command2, 1, 1, 1, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 4, 4, 0, 1);
            AssertCommandState(command2, 1, 2, 2, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 4, 4, 0, 1);
            AssertCommandState(command2, 1, 3, 3, 0, 0);
        }
 public void RunTestAndTerminate()
 {
     MockCommand command = new MockCommand();
     command.Start();
     AssertCommandState(command, 0, 0, 0, 0, 0);
     Scheduler.Instance.Run();
     AssertCommandState(command, 0, 0, 0, 0, 0);
     Scheduler.Instance.Run();
     AssertCommandState(command, 1, 1, 1, 0, 0);
     Scheduler.Instance.Run();
     AssertCommandState(command, 1, 2, 2, 0, 0);
     command.SetHasFinished(true);
     AssertCommandState(command, 1, 2, 2, 0, 0);
     Scheduler.Instance.Run();
     AssertCommandState(command, 1, 3, 3, 1, 0);
     Scheduler.Instance.Run();
     AssertCommandState(command, 1, 3, 3, 1, 0);
 }
示例#10
0
        public void RunTestAndTerminate()
        {
            MockCommand command = new MockCommand();

            command.Start();
            AssertCommandState(command, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command, 1, 1, 1, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command, 1, 2, 2, 0, 0);
            command.SetHasFinished(true);
            AssertCommandState(command, 1, 2, 2, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command, 1, 3, 3, 1, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command, 1, 3, 3, 1, 0);
        }
        public void TestOneCommandSupersedingAnotherBecauseOfDependencies()
        {
            ASubsystem subsystem = new ASubsystem();

            MockCommand command1 = new MockCommand("Num1");
            command1.AddRequires(subsystem);

            MockCommand command2 = new MockCommand("Num2");
            command2.AddRequires(subsystem);

            AssertCommandState(command1, 0, 0, 0, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            command1.Start();
            AssertCommandState(command1, 0, 0, 0, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 0, 0, 0, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 1, 1, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 2, 2, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 3, 3, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            command2.Start();
            AssertCommandState(command1, 1, 3, 3, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 4, 4, 0, 1);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 4, 4, 0, 1);
            AssertCommandState(command2, 1, 1, 1, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 4, 4, 0, 1);
            AssertCommandState(command2, 1, 2, 2, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 4, 4, 0, 1);
            AssertCommandState(command2, 1, 3, 3, 0, 0);
        }
示例#12
0
 public void TestRunAndCancel()
 {
     MockCommand command = new MockCommand();
     command.Start();
     AssertCommandState(command, 0, 0, 0, 0, 0);
     Scheduler.Instance.Run();
     AssertCommandState(command, 0, 0, 0, 0, 0);
     Scheduler.Instance.Run();
     AssertCommandState(command, 1, 1, 1, 0, 0);
     Scheduler.Instance.Run();
     AssertCommandState(command, 1, 2, 2, 0, 0);
     Scheduler.Instance.Run();
     AssertCommandState(command, 1, 3, 3, 0, 0);
     command.Cancel();
     AssertCommandState(command, 1, 3, 3, 0, 0);
     Scheduler.Instance.Run();
     AssertCommandState(command, 1, 3, 3, 0, 1);
     Scheduler.Instance.Run();
     AssertCommandState(command, 1, 3, 3, 0, 1);
 }
示例#13
0
        public void TestRunAndCancel()
        {
            MockCommand command = new MockCommand();

            command.Start();
            AssertCommandState(command, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command, 1, 1, 1, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command, 1, 2, 2, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command, 1, 3, 3, 0, 0);
            command.Cancel();
            AssertCommandState(command, 1, 3, 3, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command, 1, 3, 3, 0, 1);
            Scheduler.Instance.Run();
            AssertCommandState(command, 1, 3, 3, 0, 1);
        }
示例#14
0
        public void TestCommandFailingSupersedingBecauseFirstCannotBeInterrupted()
        {
            ASubsystem subsystem = new ASubsystem();

            MockCommand command1 = new MockCommand("Num1");

            command1.AddRequires(subsystem);
            command1.SetInterruptable(false);

            MockCommand command2 = new MockCommand("Num2");

            command2.AddRequires(subsystem);

            AssertCommandState(command1, 0, 0, 0, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            command1.Start();
            AssertCommandState(command1, 0, 0, 0, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 0, 0, 0, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 1, 1, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 2, 2, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 3, 3, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            command2.Start();
            AssertCommandState(command1, 1, 3, 3, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 4, 4, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
        }
示例#15
0
        public void TestParallelCommandGroupWithTwoCommands()
        {
            MockCommand command1 = new MockCommand();
            MockCommand command2 = new MockCommand();

            CommandGroup commandGroup = new CommandGroup();

            commandGroup.AddParallel(command1);
            commandGroup.AddParallel(command2);

            AssertCommandState(command1, 0, 0, 0, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            commandGroup.Start();
            AssertCommandState(command1, 0, 0, 0, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 0, 0, 0, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 1, 1, 0, 0);
            AssertCommandState(command2, 1, 1, 1, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 2, 2, 0, 0);
            AssertCommandState(command2, 1, 2, 2, 0, 0);
            command1.SetHasFinished(true);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 3, 3, 1, 0);
            AssertCommandState(command2, 1, 3, 3, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 3, 3, 1, 0);
            AssertCommandState(command2, 1, 4, 4, 0, 0);
            command2.SetHasFinished(true);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 3, 3, 1, 0);
            AssertCommandState(command2, 1, 5, 5, 1, 0);
        }
示例#16
0
        public void TestThreeCommandOnSubSystem()
        {
            ASubsystem subsystem = new ASubsystem();

            MockCommand command1 = new MockCommand();

            command1.AddRequires(subsystem);

            MockCommand command2 = new MockCommand();

            command2.AddRequires(subsystem);

            MockCommand command3 = new MockCommand();

            command3.AddRequires(subsystem);

            CommandGroup commandGroup = new CommandGroup();

            commandGroup.AddSequential(command1, 1.0);
            commandGroup.AddSequential(command2, 2.0);
            commandGroup.AddSequential(command3);

            AssertCommandState(command1, 0, 0, 0, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            AssertCommandState(command3, 0, 0, 0, 0, 0);
            commandGroup.Start();
            AssertCommandState(command1, 0, 0, 0, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            AssertCommandState(command3, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 0, 0, 0, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            AssertCommandState(command3, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 1, 1, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            AssertCommandState(command3, 0, 0, 0, 0, 0);
            Sleep(1000);// Command 1 timeout
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 1, 1, 0, 1);
            AssertCommandState(command2, 1, 1, 1, 0, 0);
            AssertCommandState(command3, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 1, 1, 0, 1);
            AssertCommandState(command2, 1, 2, 2, 0, 0);
            AssertCommandState(command3, 0, 0, 0, 0, 0);
            Sleep(2000);// Command 2 timeout
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 1, 1, 0, 1);
            AssertCommandState(command2, 1, 2, 2, 0, 1);
            AssertCommandState(command3, 1, 1, 1, 0, 0);

            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 1, 1, 0, 1);
            AssertCommandState(command2, 1, 2, 2, 0, 1);
            AssertCommandState(command3, 1, 2, 2, 0, 0);
            command3.SetHasFinished(true);
            AssertCommandState(command1, 1, 1, 1, 0, 1);
            AssertCommandState(command2, 1, 2, 2, 0, 1);
            AssertCommandState(command3, 1, 2, 2, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 1, 1, 0, 1);
            AssertCommandState(command2, 1, 2, 2, 0, 1);
            AssertCommandState(command3, 1, 3, 3, 1, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 1, 1, 0, 1);
            AssertCommandState(command2, 1, 2, 2, 0, 1);
            AssertCommandState(command3, 1, 3, 3, 1, 0);
        }
        public void TestThreeCommandOnSubSystem()
        {
            ASubsystem subsystem = new ASubsystem();

            MockCommand command1 = new MockCommand();
            command1.AddRequires(subsystem);

            MockCommand command2 = new MockCommand();
            command2.AddRequires(subsystem);

            MockCommand command3 = new MockCommand();
            command3.AddRequires(subsystem);

            CommandGroup commandGroup = new CommandGroup();
            commandGroup.AddSequential(command1, 1.0);
            commandGroup.AddSequential(command2, 2.0);
            commandGroup.AddSequential(command3);

            AssertCommandState(command1, 0, 0, 0, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            AssertCommandState(command3, 0, 0, 0, 0, 0);
            commandGroup.Start();
            AssertCommandState(command1, 0, 0, 0, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            AssertCommandState(command3, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 0, 0, 0, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            AssertCommandState(command3, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 1, 1, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            AssertCommandState(command3, 0, 0, 0, 0, 0);
            Sleep(1000);// command 1 timeout
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 1, 1, 0, 1);
            AssertCommandState(command2, 1, 1, 1, 0, 0);
            AssertCommandState(command3, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 1, 1, 0, 1);
            AssertCommandState(command2, 1, 2, 2, 0, 0);
            AssertCommandState(command3, 0, 0, 0, 0, 0);
            Sleep(2000);// command 2 timeout
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 1, 1, 0, 1);
            AssertCommandState(command2, 1, 2, 2, 0, 1);
            AssertCommandState(command3, 1, 1, 1, 0, 0);

            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 1, 1, 0, 1);
            AssertCommandState(command2, 1, 2, 2, 0, 1);
            AssertCommandState(command3, 1, 2, 2, 0, 0);
            command3.SetHasFinished(true);
            AssertCommandState(command1, 1, 1, 1, 0, 1);
            AssertCommandState(command2, 1, 2, 2, 0, 1);
            AssertCommandState(command3, 1, 2, 2, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 1, 1, 0, 1);
            AssertCommandState(command2, 1, 2, 2, 0, 1);
            AssertCommandState(command3, 1, 3, 3, 1, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 1, 1, 0, 1);
            AssertCommandState(command2, 1, 2, 2, 0, 1);
            AssertCommandState(command3, 1, 3, 3, 1, 0);
        }
示例#18
0
        public void Test()
        {
            MockCommand command1 = new MockCommand();
            MockCommand command2 = new MockCommand();
            MockCommand command3 = new MockCommand();
            MockCommand command4 = new MockCommand();

            button1.WhenPressed(command1);
            button1.WhenReleased(command2);
            button1.WhileHeld(command3);
            button2.WhileHeld(command4);

            AssertCommandState(command1, 0, 0, 0, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            AssertCommandState(command3, 0, 0, 0, 0, 0);
            AssertCommandState(command4, 0, 0, 0, 0, 0);
            button1.SetPressed(true);
            AssertCommandState(command1, 0, 0, 0, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            AssertCommandState(command3, 0, 0, 0, 0, 0);
            AssertCommandState(command4, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 0, 0, 0, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            AssertCommandState(command3, 0, 0, 0, 0, 0);
            AssertCommandState(command4, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 1, 1, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            AssertCommandState(command3, 1, 1, 1, 0, 0);
            AssertCommandState(command4, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 2, 2, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            AssertCommandState(command3, 1, 2, 2, 0, 0);
            AssertCommandState(command4, 0, 0, 0, 0, 0);
            button2.SetPressed(true);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 3, 3, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            AssertCommandState(command3, 1, 3, 3, 0, 0);
            AssertCommandState(command4, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 4, 4, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            AssertCommandState(command3, 1, 4, 4, 0, 0);
            AssertCommandState(command4, 1, 1, 1, 0, 0);
            button1.SetPressed(false);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 5, 5, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            AssertCommandState(command3, 1, 4, 4, 0, 1);
            AssertCommandState(command4, 1, 2, 2, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 6, 6, 0, 0);
            AssertCommandState(command2, 1, 1, 1, 0, 0);
            AssertCommandState(command3, 1, 4, 4, 0, 1);
            AssertCommandState(command4, 1, 3, 3, 0, 0);
            button2.SetPressed(false);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 7, 7, 0, 0);
            AssertCommandState(command2, 1, 2, 2, 0, 0);
            AssertCommandState(command3, 1, 4, 4, 0, 1);
            AssertCommandState(command4, 1, 3, 3, 0, 1);
            command1.Cancel();
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 7, 7, 0, 1);
            AssertCommandState(command2, 1, 3, 3, 0, 0);
            AssertCommandState(command3, 1, 4, 4, 0, 1);
            AssertCommandState(command4, 1, 3, 3, 0, 1);
            command2.SetHasFinished(true);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 7, 7, 0, 1);
            AssertCommandState(command2, 1, 4, 4, 1, 0);
            AssertCommandState(command3, 1, 4, 4, 0, 1);
            AssertCommandState(command4, 1, 3, 3, 0, 1);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 7, 7, 0, 1);
            AssertCommandState(command2, 1, 4, 4, 1, 0);
            AssertCommandState(command3, 1, 4, 4, 0, 1);
            AssertCommandState(command4, 1, 3, 3, 0, 1);
        }
示例#19
0
        public void Test()
        {
            MockCommand command1 = new MockCommand();
            MockCommand command2 = new MockCommand();
            MockCommand command3 = new MockCommand();
            MockCommand command4 = new MockCommand();

            m_button1.WhenPressed(command1);
            m_button1.WhenReleased(command2);
            m_button1.WhileHeld(command3);
            m_button2.WhileHeld(command4);

            AssertCommandState(command1, 0, 0, 0, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            AssertCommandState(command3, 0, 0, 0, 0, 0);
            AssertCommandState(command4, 0, 0, 0, 0, 0);
            m_button1.SetPressed(true);
            AssertCommandState(command1, 0, 0, 0, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            AssertCommandState(command3, 0, 0, 0, 0, 0);
            AssertCommandState(command4, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 0, 0, 0, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            AssertCommandState(command3, 0, 0, 0, 0, 0);
            AssertCommandState(command4, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 1, 1, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            AssertCommandState(command3, 1, 1, 1, 0, 0);
            AssertCommandState(command4, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 2, 2, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            AssertCommandState(command3, 1, 2, 2, 0, 0);
            AssertCommandState(command4, 0, 0, 0, 0, 0);
            m_button2.SetPressed(true);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 3, 3, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            AssertCommandState(command3, 1, 3, 3, 0, 0);
            AssertCommandState(command4, 0, 0, 0, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 4, 4, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            AssertCommandState(command3, 1, 4, 4, 0, 0);
            AssertCommandState(command4, 1, 1, 1, 0, 0);
            m_button1.SetPressed(false);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 5, 5, 0, 0);
            AssertCommandState(command2, 0, 0, 0, 0, 0);
            AssertCommandState(command3, 1, 4, 4, 0, 1);
            AssertCommandState(command4, 1, 2, 2, 0, 0);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 6, 6, 0, 0);
            AssertCommandState(command2, 1, 1, 1, 0, 0);
            AssertCommandState(command3, 1, 4, 4, 0, 1);
            AssertCommandState(command4, 1, 3, 3, 0, 0);
            m_button2.SetPressed(false);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 7, 7, 0, 0);
            AssertCommandState(command2, 1, 2, 2, 0, 0);
            AssertCommandState(command3, 1, 4, 4, 0, 1);
            AssertCommandState(command4, 1, 3, 3, 0, 1);
            command1.Cancel();
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 7, 7, 0, 1);
            AssertCommandState(command2, 1, 3, 3, 0, 0);
            AssertCommandState(command3, 1, 4, 4, 0, 1);
            AssertCommandState(command4, 1, 3, 3, 0, 1);
            command2.SetHasFinished(true);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 7, 7, 0, 1);
            AssertCommandState(command2, 1, 4, 4, 1, 0);
            AssertCommandState(command3, 1, 4, 4, 0, 1);
            AssertCommandState(command4, 1, 3, 3, 0, 1);
            Scheduler.Instance.Run();
            AssertCommandState(command1, 1, 7, 7, 0, 1);
            AssertCommandState(command2, 1, 4, 4, 1, 0);
            AssertCommandState(command3, 1, 4, 4, 0, 1);
            AssertCommandState(command4, 1, 3, 3, 0, 1);
        }