Squashed 'third_party/allwpilib_2017/' content from commit 35ac87d
Change-Id: I7bb6f5556c30d3f5a092e68de0be9c710c60c9f4
git-subtree-dir: third_party/allwpilib_2017
git-subtree-split: 35ac87d6ff8b7f061c4f18c9ea316e5dccd4888a
diff --git a/wpilibcIntegrationTests/src/command/CommandTest.cpp b/wpilibcIntegrationTests/src/command/CommandTest.cpp
new file mode 100644
index 0000000..351f3ba
--- /dev/null
+++ b/wpilibcIntegrationTests/src/command/CommandTest.cpp
@@ -0,0 +1,444 @@
+/*----------------------------------------------------------------------------*/
+/* Copyright (c) FIRST 2014-2017. All Rights Reserved. */
+/* Open Source Software - may be modified and shared by FRC teams. The code */
+/* must be accompanied by the FIRST BSD license file in the root directory of */
+/* the project. */
+/*----------------------------------------------------------------------------*/
+
+#include "Commands/CommandGroup.h"
+#include "Commands/Scheduler.h"
+#include "Commands/Subsystem.h"
+#include "DriverStation.h"
+#include "RobotState.h"
+#include "Timer.h"
+#include "command/MockCommand.h"
+#include "gtest/gtest.h"
+
+using namespace frc;
+
+class CommandTest : public testing::Test {
+ protected:
+ void SetUp() override {
+ RobotState::SetImplementation(DriverStation::GetInstance());
+ Scheduler::GetInstance()->SetEnabled(true);
+ }
+
+ /**
+ * Tears Down the Scheduler at the end of each test.
+ * Must be called at the end of each test inside each test in order to prevent
+ * them being deallocated
+ * when they leave the scope of the test (causing a segfault).
+ * This can not be done within the virtual void Teardown() method because it
+ * is called outside of the
+ * scope of the test.
+ */
+ void TeardownScheduler() { Scheduler::GetInstance()->ResetAll(); }
+
+ void AssertCommandState(MockCommand& command, int32_t initialize,
+ int32_t execute, int32_t isFinished, int32_t end,
+ int32_t interrupted) {
+ EXPECT_EQ(initialize, command.GetInitializeCount());
+ EXPECT_EQ(execute, command.GetExecuteCount());
+ EXPECT_EQ(isFinished, command.GetIsFinishedCount());
+ EXPECT_EQ(end, command.GetEndCount());
+ EXPECT_EQ(interrupted, command.GetInterruptedCount());
+ }
+};
+
+class ASubsystem : public Subsystem {
+ private:
+ Command* m_command = nullptr;
+
+ public:
+ explicit ASubsystem(const std::string& name) : Subsystem(name) {}
+
+ void InitDefaultCommand() override {
+ if (m_command != nullptr) {
+ SetDefaultCommand(m_command);
+ }
+ }
+
+ void Init(Command* command) { m_command = command; }
+};
+
+// CommandParallelGroupTest ported from CommandParallelGroupTest.java
+TEST_F(CommandTest, ParallelCommands) {
+ MockCommand command1;
+ MockCommand command2;
+ CommandGroup 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::GetInstance()->Run();
+ AssertCommandState(command1, 0, 0, 0, 0, 0);
+ AssertCommandState(command2, 0, 0, 0, 0, 0);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(command1, 1, 1, 1, 0, 0);
+ AssertCommandState(command2, 1, 1, 1, 0, 0);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(command1, 1, 2, 2, 0, 0);
+ AssertCommandState(command2, 1, 2, 2, 0, 0);
+ command1.SetHasFinished(true);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(command1, 1, 3, 3, 1, 0);
+ AssertCommandState(command2, 1, 3, 3, 0, 0);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(command1, 1, 3, 3, 1, 0);
+ AssertCommandState(command2, 1, 4, 4, 0, 0);
+ command2.SetHasFinished(true);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(command1, 1, 3, 3, 1, 0);
+ AssertCommandState(command2, 1, 5, 5, 1, 0);
+
+ TeardownScheduler();
+}
+// END CommandParallelGroupTest
+
+// CommandScheduleTest ported from CommandScheduleTest.java
+TEST_F(CommandTest, RunAndTerminate) {
+ MockCommand command;
+ command.Start();
+ AssertCommandState(command, 0, 0, 0, 0, 0);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(command, 0, 0, 0, 0, 0);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(command, 1, 1, 1, 0, 0);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(command, 1, 2, 2, 0, 0);
+ command.SetHasFinished(true);
+ AssertCommandState(command, 1, 2, 2, 0, 0);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(command, 1, 3, 3, 1, 0);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(command, 1, 3, 3, 1, 0);
+
+ TeardownScheduler();
+}
+
+TEST_F(CommandTest, RunAndCancel) {
+ MockCommand command;
+ command.Start();
+ AssertCommandState(command, 0, 0, 0, 0, 0);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(command, 0, 0, 0, 0, 0);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(command, 1, 1, 1, 0, 0);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(command, 1, 2, 2, 0, 0);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(command, 1, 3, 3, 0, 0);
+ command.Cancel();
+ AssertCommandState(command, 1, 3, 3, 0, 0);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(command, 1, 3, 3, 0, 1);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(command, 1, 3, 3, 0, 1);
+
+ TeardownScheduler();
+}
+// END CommandScheduleTest
+
+// CommandSequentialGroupTest ported from CommandSequentialGroupTest.java
+TEST_F(CommandTest, ThreeCommandOnSubSystem) {
+ ASubsystem subsystem("Three Command Test Subsystem");
+ MockCommand command1;
+ command1.Requires(&subsystem);
+ MockCommand command2;
+ command2.Requires(&subsystem);
+ MockCommand command3;
+ command3.Requires(&subsystem);
+
+ CommandGroup 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::GetInstance()->Run();
+ AssertCommandState(command1, 0, 0, 0, 0, 0);
+ AssertCommandState(command2, 0, 0, 0, 0, 0);
+ AssertCommandState(command3, 0, 0, 0, 0, 0);
+
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(command1, 1, 1, 1, 0, 0);
+ AssertCommandState(command2, 0, 0, 0, 0, 0);
+ AssertCommandState(command3, 0, 0, 0, 0, 0);
+ Wait(1); // command 1 timeout
+
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(command1, 1, 1, 1, 0, 1);
+ AssertCommandState(command2, 1, 1, 1, 0, 0);
+ AssertCommandState(command3, 0, 0, 0, 0, 0);
+
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(command1, 1, 1, 1, 0, 1);
+ AssertCommandState(command2, 1, 2, 2, 0, 0);
+ AssertCommandState(command3, 0, 0, 0, 0, 0);
+ Wait(2); // command 2 timeout
+
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(command1, 1, 1, 1, 0, 1);
+ AssertCommandState(command2, 1, 2, 2, 0, 1);
+ AssertCommandState(command3, 1, 1, 1, 0, 0);
+
+ Scheduler::GetInstance()->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::GetInstance()->Run();
+ AssertCommandState(command1, 1, 1, 1, 0, 1);
+ AssertCommandState(command2, 1, 2, 2, 0, 1);
+ AssertCommandState(command3, 1, 3, 3, 1, 0);
+
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(command1, 1, 1, 1, 0, 1);
+ AssertCommandState(command2, 1, 2, 2, 0, 1);
+ AssertCommandState(command3, 1, 3, 3, 1, 0);
+
+ TeardownScheduler();
+}
+// END CommandSequentialGroupTest
+
+// CommandSequentialGroupTest ported from CommandSequentialGroupTest.java
+TEST_F(CommandTest, OneCommandSupersedingAnotherBecauseOfDependencies) {
+ auto subsystem = new ASubsystem("Command Superseding Test Subsystem");
+ MockCommand command1;
+ command1.Requires(subsystem);
+ MockCommand command2;
+ command2.Requires(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::GetInstance()->Run();
+ AssertCommandState(command1, 0, 0, 0, 0, 0);
+ AssertCommandState(command2, 0, 0, 0, 0, 0);
+
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(command1, 1, 1, 1, 0, 0);
+ AssertCommandState(command2, 0, 0, 0, 0, 0);
+
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(command1, 1, 2, 2, 0, 0);
+ AssertCommandState(command2, 0, 0, 0, 0, 0);
+
+ Scheduler::GetInstance()->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::GetInstance()->Run();
+ AssertCommandState(command1, 1, 4, 4, 0, 1);
+ AssertCommandState(command2, 0, 0, 0, 0, 0);
+
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(command1, 1, 4, 4, 0, 1);
+ AssertCommandState(command2, 1, 1, 1, 0, 0);
+
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(command1, 1, 4, 4, 0, 1);
+ AssertCommandState(command2, 1, 2, 2, 0, 0);
+
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(command1, 1, 4, 4, 0, 1);
+ AssertCommandState(command2, 1, 3, 3, 0, 0);
+
+ TeardownScheduler();
+}
+
+TEST_F(CommandTest,
+ OneCommandFailingSupersedingBecauseFirstCanNotBeInterrupted) {
+ ASubsystem subsystem("Command Superseding Test Subsystem");
+ MockCommand command1;
+
+ command1.Requires(&subsystem);
+
+ command1.SetInterruptible(false);
+ MockCommand command2;
+ command2.Requires(&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::GetInstance()->Run();
+ AssertCommandState(command1, 0, 0, 0, 0, 0);
+ AssertCommandState(command2, 0, 0, 0, 0, 0);
+
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(command1, 1, 1, 1, 0, 0);
+ AssertCommandState(command2, 0, 0, 0, 0, 0);
+
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(command1, 1, 2, 2, 0, 0);
+ AssertCommandState(command2, 0, 0, 0, 0, 0);
+
+ Scheduler::GetInstance()->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::GetInstance()->Run();
+ AssertCommandState(command1, 1, 4, 4, 0, 0);
+ AssertCommandState(command2, 0, 0, 0, 0, 0);
+
+ TeardownScheduler();
+}
+
+// END CommandSequentialGroupTest
+
+class ModifiedMockCommand : public MockCommand {
+ public:
+ ModifiedMockCommand() : MockCommand() { SetTimeout(2.0); }
+ bool IsFinished() override {
+ return MockCommand::IsFinished() || IsTimedOut();
+ }
+};
+
+TEST_F(CommandTest, TwoSecondTimeout) {
+ ASubsystem subsystem("Two Second Timeout Test Subsystem");
+ ModifiedMockCommand command;
+ command.Requires(&subsystem);
+
+ command.Start();
+ AssertCommandState(command, 0, 0, 0, 0, 0);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(command, 0, 0, 0, 0, 0);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(command, 1, 1, 1, 0, 0);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(command, 1, 2, 2, 0, 0);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(command, 1, 3, 3, 0, 0);
+ Wait(2);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(command, 1, 4, 4, 1, 0);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(command, 1, 4, 4, 1, 0);
+
+ TeardownScheduler();
+}
+
+TEST_F(CommandTest, DefaultCommandWhereTheInteruptingCommandEndsItself) {
+ ASubsystem subsystem("Default Command Test Subsystem");
+ MockCommand defaultCommand;
+ defaultCommand.Requires(&subsystem);
+ MockCommand anotherCommand;
+ anotherCommand.Requires(&subsystem);
+
+ AssertCommandState(defaultCommand, 0, 0, 0, 0, 0);
+ subsystem.Init(&defaultCommand);
+
+ AssertCommandState(defaultCommand, 0, 0, 0, 0, 0);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(defaultCommand, 0, 0, 0, 0, 0);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(defaultCommand, 1, 1, 1, 0, 0);
+ Scheduler::GetInstance()->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::GetInstance()->Run();
+ AssertCommandState(defaultCommand, 1, 3, 3, 0, 1);
+ AssertCommandState(anotherCommand, 0, 0, 0, 0, 0);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(defaultCommand, 1, 3, 3, 0, 1);
+ AssertCommandState(anotherCommand, 1, 1, 1, 0, 0);
+ Scheduler::GetInstance()->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::GetInstance()->Run();
+ AssertCommandState(defaultCommand, 1, 3, 3, 0, 1);
+ AssertCommandState(anotherCommand, 1, 3, 3, 1, 0);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(defaultCommand, 2, 4, 4, 0, 1);
+ AssertCommandState(anotherCommand, 1, 3, 3, 1, 0);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(defaultCommand, 2, 5, 5, 0, 1);
+ AssertCommandState(anotherCommand, 1, 3, 3, 1, 0);
+
+ TeardownScheduler();
+}
+
+TEST_F(CommandTest, DefaultCommandsInterruptingCommandCanceled) {
+ ASubsystem subsystem("Default Command Test Subsystem");
+ MockCommand defaultCommand;
+ defaultCommand.Requires(&subsystem);
+ MockCommand anotherCommand;
+ anotherCommand.Requires(&subsystem);
+
+ AssertCommandState(defaultCommand, 0, 0, 0, 0, 0);
+ subsystem.Init(&defaultCommand);
+ subsystem.InitDefaultCommand();
+ AssertCommandState(defaultCommand, 0, 0, 0, 0, 0);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(defaultCommand, 0, 0, 0, 0, 0);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(defaultCommand, 1, 1, 1, 0, 0);
+ Scheduler::GetInstance()->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::GetInstance()->Run();
+ AssertCommandState(defaultCommand, 1, 3, 3, 0, 1);
+ AssertCommandState(anotherCommand, 0, 0, 0, 0, 0);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(defaultCommand, 1, 3, 3, 0, 1);
+ AssertCommandState(anotherCommand, 1, 1, 1, 0, 0);
+ Scheduler::GetInstance()->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::GetInstance()->Run();
+ AssertCommandState(defaultCommand, 1, 3, 3, 0, 1);
+ AssertCommandState(anotherCommand, 1, 2, 2, 0, 1);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(defaultCommand, 2, 4, 4, 0, 1);
+ AssertCommandState(anotherCommand, 1, 2, 2, 0, 1);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(defaultCommand, 2, 5, 5, 0, 1);
+ AssertCommandState(anotherCommand, 1, 2, 2, 0, 1);
+
+ TeardownScheduler();
+}
diff --git a/wpilibcIntegrationTests/src/command/ConditionalCommandTest.cpp b/wpilibcIntegrationTests/src/command/ConditionalCommandTest.cpp
new file mode 100644
index 0000000..271131d
--- /dev/null
+++ b/wpilibcIntegrationTests/src/command/ConditionalCommandTest.cpp
@@ -0,0 +1,100 @@
+/*----------------------------------------------------------------------------*/
+/* Copyright (c) FIRST 2017. All Rights Reserved. */
+/* Open Source Software - may be modified and shared by FRC teams. The code */
+/* must be accompanied by the FIRST BSD license file in the root directory of */
+/* the project. */
+/*----------------------------------------------------------------------------*/
+
+#include <DriverStation.h>
+#include <RobotState.h>
+
+#include "Commands/ConditionalCommand.h"
+#include "Commands/Scheduler.h"
+#include "command/MockCommand.h"
+#include "command/MockConditionalCommand.h"
+#include "gtest/gtest.h"
+
+using namespace frc;
+
+class ConditionalCommandTest : public testing::Test {
+ public:
+ MockConditionalCommand* m_command;
+ MockCommand* m_onTrue;
+ MockCommand* m_onFalse;
+
+ protected:
+ void SetUp() override {
+ RobotState::SetImplementation(DriverStation::GetInstance());
+ Scheduler::GetInstance()->SetEnabled(true);
+
+ m_onTrue = new MockCommand();
+ m_onFalse = new MockCommand();
+ m_command = new MockConditionalCommand(m_onTrue, m_onFalse);
+ }
+
+ void TearDown() override { delete m_command; }
+
+ /**
+ * Tears Down the Scheduler at the end of each test.
+ *
+ * Must be called at the end of each test inside each test in order to prevent
+ * them being deallocated when they leave the scope of the test (causing a
+ * segfault). This cannot be done within the virtual void Teardown() method
+ * because it is called outside of the scope of the test.
+ */
+ void TeardownScheduler() { Scheduler::GetInstance()->ResetAll(); }
+
+ void AssertCommandState(MockCommand& command, int32_t initialize,
+ int32_t execute, int32_t isFinished, int32_t end,
+ int32_t interrupted) {
+ EXPECT_EQ(initialize, command.GetInitializeCount());
+ EXPECT_EQ(execute, command.GetExecuteCount());
+ EXPECT_EQ(isFinished, command.GetIsFinishedCount());
+ EXPECT_EQ(end, command.GetEndCount());
+ EXPECT_EQ(interrupted, command.GetInterruptedCount());
+ }
+};
+
+TEST_F(ConditionalCommandTest, OnTrueTest) {
+ m_command->SetCondition(true);
+
+ Scheduler::GetInstance()->AddCommand(m_command);
+ AssertCommandState(*m_onTrue, 0, 0, 0, 0, 0);
+ Scheduler::GetInstance()->Run(); // init command and select m_onTrue
+ AssertCommandState(*m_onTrue, 0, 0, 0, 0, 0);
+ Scheduler::GetInstance()->Run(); // init m_onTrue
+ AssertCommandState(*m_onTrue, 0, 0, 0, 0, 0);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(*m_onTrue, 1, 1, 2, 0, 0);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(*m_onTrue, 1, 2, 4, 0, 0);
+
+ EXPECT_TRUE(m_onTrue->GetInitializeCount() > 0)
+ << "Did not initialize the true command\n";
+ EXPECT_TRUE(m_onFalse->GetInitializeCount() == 0)
+ << "Initialized the false command\n";
+
+ TeardownScheduler();
+}
+
+TEST_F(ConditionalCommandTest, OnFalseTest) {
+ m_command->SetCondition(false);
+
+ Scheduler::GetInstance()->AddCommand(m_command);
+ AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
+ Scheduler::GetInstance()->Run(); // init command and select m_onTrue
+ AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
+ Scheduler::GetInstance()->Run(); // init m_onTrue
+ AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(*m_onFalse, 1, 1, 2, 0, 0);
+ Scheduler::GetInstance()->Run();
+ AssertCommandState(*m_onFalse, 1, 2, 4, 0, 0);
+
+ EXPECT_TRUE(m_onFalse->GetInitializeCount() > 0)
+ << "Did not initialize the false command";
+ EXPECT_TRUE(m_onTrue->GetInitializeCount() == 0)
+ << "Initialized the true command";
+
+ TeardownScheduler();
+}
diff --git a/wpilibcIntegrationTests/src/command/MockCommand.cpp b/wpilibcIntegrationTests/src/command/MockCommand.cpp
new file mode 100644
index 0000000..19c0c64
--- /dev/null
+++ b/wpilibcIntegrationTests/src/command/MockCommand.cpp
@@ -0,0 +1,38 @@
+/*----------------------------------------------------------------------------*/
+/* Copyright (c) FIRST 2014-2017. All Rights Reserved. */
+/* Open Source Software - may be modified and shared by FRC teams. The code */
+/* must be accompanied by the FIRST BSD license file in the root directory of */
+/* the project. */
+/*----------------------------------------------------------------------------*/
+
+#include "command/MockCommand.h"
+
+using namespace frc;
+
+MockCommand::MockCommand() {
+ m_initializeCount = 0;
+ m_executeCount = 0;
+ m_isFinishedCount = 0;
+ m_hasFinished = false;
+ m_endCount = 0;
+ m_interruptedCount = 0;
+}
+
+bool MockCommand::HasInitialized() { return GetInitializeCount() > 0; }
+
+bool MockCommand::HasEnd() { return GetEndCount() > 0; }
+
+bool MockCommand::HasInterrupted() { return GetInterruptedCount() > 0; }
+
+void MockCommand::Initialize() { ++m_initializeCount; }
+
+void MockCommand::Execute() { ++m_executeCount; }
+
+bool MockCommand::IsFinished() {
+ ++m_isFinishedCount;
+ return IsHasFinished();
+}
+
+void MockCommand::End() { ++m_endCount; }
+
+void MockCommand::Interrupted() { ++m_interruptedCount; }
diff --git a/wpilibcIntegrationTests/src/command/MockConditionalCommand.cpp b/wpilibcIntegrationTests/src/command/MockConditionalCommand.cpp
new file mode 100644
index 0000000..b23b815
--- /dev/null
+++ b/wpilibcIntegrationTests/src/command/MockConditionalCommand.cpp
@@ -0,0 +1,20 @@
+/*----------------------------------------------------------------------------*/
+/* Copyright (c) FIRST 2017. All Rights Reserved. */
+/* Open Source Software - may be modified and shared by FRC teams. The code */
+/* must be accompanied by the FIRST BSD license file in the root directory of */
+/* the project. */
+/*----------------------------------------------------------------------------*/
+
+#include "command/MockConditionalCommand.h"
+
+using namespace frc;
+
+MockConditionalCommand::MockConditionalCommand(MockCommand* onTrue,
+ MockCommand* onFalse)
+ : ConditionalCommand(onTrue, onFalse) {}
+
+void MockConditionalCommand::SetCondition(bool condition) {
+ m_condition = condition;
+}
+
+bool MockConditionalCommand::Condition() { return m_condition; }