Team2890/allwpilib
4
0
Fork 0
mirror of https://github.com/wpilibsuite/allwpilib synced 2026-06-27 02:01:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

New 2018 and later build setup (#1001)

Browse Source
This commit is contained in:
Thad House
2018-04-29 13:29:07 -07:00
committed by Peter Johnson
parent cb2c9eb6d5
commit 7f88cf768d
317 changed files with 60521 additions and 54781 deletions
Download Patch File Download Diff File Expand all files Collapse all files

444
wpilibcIntegrationTests/src/main/native/cpp/command/CommandTest.cpp Normal file
View File

@@ -0,0 +1,444 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2014-2018 FIRST. 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();
}

437
wpilibcIntegrationTests/src/main/native/cpp/command/ConditionalCommandTest.cpp Normal file
View File

@@ -0,0 +1,437 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2017-2018 FIRST. 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 "Commands/Subsystem.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;
MockConditionalCommand* m_commandNull;
Subsystem* m_subsystem;
protected:
void SetUp() override {
RobotState::SetImplementation(DriverStation::GetInstance());
Scheduler::GetInstance()->SetEnabled(true);
m_subsystem = new Subsystem("MockSubsystem");
m_onTrue = new MockCommand(m_subsystem);
m_onFalse = new MockCommand(m_subsystem);
m_command = new MockConditionalCommand(m_onTrue, m_onFalse);
m_commandNull = new MockConditionalCommand(m_onTrue, nullptr);
}
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());
}
void AssertConditionalCommandState(MockConditionalCommand& 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);
SCOPED_TRACE("1");
Scheduler::GetInstance()->AddCommand(m_command);
AssertCommandState(*m_onTrue, 0, 0, 0, 0, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 0, 0, 0, 0, 0);
SCOPED_TRACE("2");
Scheduler::GetInstance()->Run(); // init command and select m_onTrue
AssertCommandState(*m_onTrue, 0, 0, 0, 0, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 0, 0, 0, 0, 0);
SCOPED_TRACE("3");
Scheduler::GetInstance()->Run(); // init m_onTrue
AssertCommandState(*m_onTrue, 0, 0, 0, 0, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 1, 1, 0, 0);
SCOPED_TRACE("4");
Scheduler::GetInstance()->Run();
AssertCommandState(*m_onTrue, 1, 1, 1, 0, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 2, 2, 0, 0);
SCOPED_TRACE("5");
Scheduler::GetInstance()->Run();
AssertCommandState(*m_onTrue, 1, 2, 2, 0, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 3, 3, 0, 0);
SCOPED_TRACE("6");
m_onTrue->SetHasFinished(true);
Scheduler::GetInstance()->Run();
AssertCommandState(*m_onTrue, 1, 3, 3, 1, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 4, 4, 1, 0);
SCOPED_TRACE("7");
Scheduler::GetInstance()->Run();
AssertCommandState(*m_onTrue, 1, 3, 3, 1, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 4, 4, 1, 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);
SCOPED_TRACE("1");
Scheduler::GetInstance()->AddCommand(m_command);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertCommandState(*m_onTrue, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 0, 0, 0, 0, 0);
SCOPED_TRACE("2");
Scheduler::GetInstance()->Run(); // init command and select m_onTrue
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertCommandState(*m_onTrue, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 0, 0, 0, 0, 0);
SCOPED_TRACE("3");
Scheduler::GetInstance()->Run(); // init m_onTrue
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertCommandState(*m_onTrue, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 1, 1, 0, 0);
SCOPED_TRACE("4");
Scheduler::GetInstance()->Run();
AssertCommandState(*m_onFalse, 1, 1, 1, 0, 0);
AssertCommandState(*m_onTrue, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 2, 2, 0, 0);
SCOPED_TRACE("5");
Scheduler::GetInstance()->Run();
AssertCommandState(*m_onFalse, 1, 2, 2, 0, 0);
AssertCommandState(*m_onTrue, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 3, 3, 0, 0);
SCOPED_TRACE("6");
m_onFalse->SetHasFinished(true);
Scheduler::GetInstance()->Run();
AssertCommandState(*m_onFalse, 1, 3, 3, 1, 0);
AssertCommandState(*m_onTrue, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 4, 4, 1, 0);
SCOPED_TRACE("7");
Scheduler::GetInstance()->Run();
AssertCommandState(*m_onFalse, 1, 3, 3, 1, 0);
AssertCommandState(*m_onTrue, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 4, 4, 1, 0);
EXPECT_TRUE(m_onFalse->GetInitializeCount() > 0)
<< "Did not initialize the false command";
EXPECT_TRUE(m_onTrue->GetInitializeCount() == 0)
<< "Initialized the true command";
TeardownScheduler();
}
TEST_F(ConditionalCommandTest, CancelSubCommandTest) {
m_command->SetCondition(true);
SCOPED_TRACE("1");
Scheduler::GetInstance()->AddCommand(m_command);
AssertCommandState(*m_onTrue, 0, 0, 0, 0, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 0, 0, 0, 0, 0);
SCOPED_TRACE("2");
Scheduler::GetInstance()->Run(); // init command and select m_onTrue
AssertCommandState(*m_onTrue, 0, 0, 0, 0, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 0, 0, 0, 0, 0);
SCOPED_TRACE("3");
Scheduler::GetInstance()->Run(); // init m_onTrue
AssertCommandState(*m_onTrue, 0, 0, 0, 0, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 1, 1, 0, 0);
SCOPED_TRACE("4");
Scheduler::GetInstance()->Run();
AssertCommandState(*m_onTrue, 1, 1, 1, 0, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 2, 2, 0, 0);
SCOPED_TRACE("5");
Scheduler::GetInstance()->Run();
AssertCommandState(*m_onTrue, 1, 2, 2, 0, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 3, 3, 0, 0);
SCOPED_TRACE("6");
m_onTrue->Cancel();
Scheduler::GetInstance()->Run();
AssertCommandState(*m_onTrue, 1, 2, 2, 0, 1);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 4, 4, 1, 0);
SCOPED_TRACE("7");
Scheduler::GetInstance()->Run();
AssertCommandState(*m_onTrue, 1, 2, 2, 0, 1);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 4, 4, 1, 0);
TeardownScheduler();
}
TEST_F(ConditionalCommandTest, CancelCondCommandTest) {
m_command->SetCondition(true);
SCOPED_TRACE("1");
Scheduler::GetInstance()->AddCommand(m_command);
AssertCommandState(*m_onTrue, 0, 0, 0, 0, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 0, 0, 0, 0, 0);
SCOPED_TRACE("2");
Scheduler::GetInstance()->Run(); // init command and select m_onTrue
AssertCommandState(*m_onTrue, 0, 0, 0, 0, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 0, 0, 0, 0, 0);
SCOPED_TRACE("3");
Scheduler::GetInstance()->Run(); // init m_onTrue
AssertCommandState(*m_onTrue, 0, 0, 0, 0, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 1, 1, 0, 0);
SCOPED_TRACE("4");
Scheduler::GetInstance()->Run();
AssertCommandState(*m_onTrue, 1, 1, 1, 0, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 2, 2, 0, 0);
SCOPED_TRACE("5");
Scheduler::GetInstance()->Run();
AssertCommandState(*m_onTrue, 1, 2, 2, 0, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 3, 3, 0, 0);
SCOPED_TRACE("6");
m_command->Cancel();
Scheduler::GetInstance()->Run();
AssertCommandState(*m_onTrue, 1, 2, 2, 0, 1);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 3, 3, 0, 1);
SCOPED_TRACE("7");
Scheduler::GetInstance()->Run();
AssertCommandState(*m_onTrue, 1, 2, 2, 0, 1);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 3, 3, 0, 1);
TeardownScheduler();
}
TEST_F(ConditionalCommandTest, OnTrueTwiceTest) {
m_command->SetCondition(true);
SCOPED_TRACE("1");
Scheduler::GetInstance()->AddCommand(m_command);
AssertCommandState(*m_onTrue, 0, 0, 0, 0, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 0, 0, 0, 0, 0);
SCOPED_TRACE("2");
Scheduler::GetInstance()->Run(); // init command and select m_onTrue
AssertCommandState(*m_onTrue, 0, 0, 0, 0, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 0, 0, 0, 0, 0);
SCOPED_TRACE("3");
Scheduler::GetInstance()->Run(); // init m_onTrue
AssertCommandState(*m_onTrue, 0, 0, 0, 0, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 1, 1, 0, 0);
SCOPED_TRACE("4");
Scheduler::GetInstance()->Run();
AssertCommandState(*m_onTrue, 1, 1, 1, 0, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 2, 2, 0, 0);
SCOPED_TRACE("5");
Scheduler::GetInstance()->Run();
AssertCommandState(*m_onTrue, 1, 2, 2, 0, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 3, 3, 0, 0);
SCOPED_TRACE("6");
m_onTrue->SetHasFinished(true);
Scheduler::GetInstance()->Run();
AssertCommandState(*m_onTrue, 1, 3, 3, 1, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 4, 4, 1, 0);
SCOPED_TRACE("7");
Scheduler::GetInstance()->Run();
AssertCommandState(*m_onTrue, 1, 3, 3, 1, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 4, 4, 1, 0);
m_onTrue->ResetCounters();
m_command->ResetCounters();
Scheduler::GetInstance()->AddCommand(m_command);
SCOPED_TRACE("11");
Scheduler::GetInstance()->AddCommand(m_command);
AssertCommandState(*m_onTrue, 0, 0, 0, 0, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 0, 0, 0, 0, 0);
SCOPED_TRACE("12");
Scheduler::GetInstance()->Run(); // init command and select m_onTrue
AssertCommandState(*m_onTrue, 0, 0, 0, 0, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 0, 0, 0, 0, 0);
SCOPED_TRACE("13");
Scheduler::GetInstance()->Run(); // init m_onTrue
AssertCommandState(*m_onTrue, 0, 0, 0, 0, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 1, 1, 0, 0);
SCOPED_TRACE("14");
Scheduler::GetInstance()->Run();
AssertCommandState(*m_onTrue, 1, 1, 1, 0, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 2, 2, 0, 0);
SCOPED_TRACE("15");
Scheduler::GetInstance()->Run();
AssertCommandState(*m_onTrue, 1, 2, 2, 0, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 3, 3, 0, 0);
SCOPED_TRACE("16");
m_onTrue->SetHasFinished(true);
Scheduler::GetInstance()->Run();
AssertCommandState(*m_onTrue, 1, 3, 3, 1, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 4, 4, 1, 0);
SCOPED_TRACE("17");
Scheduler::GetInstance()->Run();
AssertCommandState(*m_onTrue, 1, 3, 3, 1, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 4, 4, 1, 0);
TeardownScheduler();
}
TEST_F(ConditionalCommandTest, OnTrueInstantTest) {
m_command->SetCondition(true);
m_onTrue->SetHasFinished(true);
SCOPED_TRACE("1");
Scheduler::GetInstance()->AddCommand(m_command);
AssertCommandState(*m_onTrue, 0, 0, 0, 0, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 0, 0, 0, 0, 0);
SCOPED_TRACE("2");
Scheduler::GetInstance()->Run(); // init command and select m_onTrue
AssertCommandState(*m_onTrue, 0, 0, 0, 0, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 0, 0, 0, 0, 0);
SCOPED_TRACE("3");
Scheduler::GetInstance()->Run(); // init m_onTrue
AssertCommandState(*m_onTrue, 0, 0, 0, 0, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 1, 1, 0, 0);
SCOPED_TRACE("4");
Scheduler::GetInstance()->Run();
AssertCommandState(*m_onTrue, 1, 1, 1, 1, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 2, 2, 1, 0);
SCOPED_TRACE("5");
Scheduler::GetInstance()->Run();
AssertCommandState(*m_onTrue, 1, 1, 1, 1, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 2, 2, 1, 0);
TeardownScheduler();
}
TEST_F(ConditionalCommandTest, CancelRequiresTest) {
m_command->SetCondition(true);
SCOPED_TRACE("1");
Scheduler::GetInstance()->AddCommand(m_command);
AssertCommandState(*m_onTrue, 0, 0, 0, 0, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 0, 0, 0, 0, 0);
SCOPED_TRACE("2");
Scheduler::GetInstance()->Run(); // init command and select m_onTrue
AssertCommandState(*m_onTrue, 0, 0, 0, 0, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 0, 0, 0, 0, 0);
SCOPED_TRACE("3");
Scheduler::GetInstance()->Run(); // init m_onTrue
AssertCommandState(*m_onTrue, 0, 0, 0, 0, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 1, 1, 0, 0);
SCOPED_TRACE("4");
Scheduler::GetInstance()->Run();
AssertCommandState(*m_onTrue, 1, 1, 1, 0, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 2, 2, 0, 0);
SCOPED_TRACE("5");
Scheduler::GetInstance()->Run();
AssertCommandState(*m_onTrue, 1, 2, 2, 0, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 3, 3, 0, 0);
SCOPED_TRACE("6");
m_onFalse->Start();
Scheduler::GetInstance()->Run();
AssertCommandState(*m_onTrue, 1, 3, 3, 0, 0);
AssertCommandState(*m_onFalse, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_command, 1, 4, 4, 0, 1);
SCOPED_TRACE("7");
Scheduler::GetInstance()->Run();
AssertCommandState(*m_onTrue, 1, 3, 3, 0, 1);
AssertCommandState(*m_onFalse, 1, 1, 1, 0, 0);
AssertConditionalCommandState(*m_command, 1, 4, 4, 0, 1);
TeardownScheduler();
}
TEST_F(ConditionalCommandTest, OnFalseNullTest) {
m_command->SetCondition(false);
SCOPED_TRACE("1");
Scheduler::GetInstance()->AddCommand(m_commandNull);
AssertCommandState(*m_onTrue, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_commandNull, 0, 0, 0, 0, 0);
SCOPED_TRACE("2");
Scheduler::GetInstance()->Run(); // init command and select m_onTrue
AssertCommandState(*m_onTrue, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_commandNull, 0, 0, 0, 0, 0);
SCOPED_TRACE("3");
Scheduler::GetInstance()->Run(); // init m_onTrue
AssertCommandState(*m_onTrue, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_commandNull, 1, 1, 1, 1, 0);
SCOPED_TRACE("4");
Scheduler::GetInstance()->Run();
AssertCommandState(*m_onTrue, 0, 0, 0, 0, 0);
AssertConditionalCommandState(*m_commandNull, 1, 1, 1, 1, 0);
TeardownScheduler();
}

51
wpilibcIntegrationTests/src/main/native/cpp/command/MockCommand.cpp Normal file
View File

@@ -0,0 +1,51 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2014-2018 FIRST. 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(Subsystem* subsys) : MockCommand() {
Requires(subsys);
}
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; }
void MockCommand::ResetCounters() {
m_initializeCount = 0;
m_executeCount = 0;
m_isFinishedCount = 0;
m_hasFinished = false;
m_endCount = 0;
m_interruptedCount = 0;
}

57
wpilibcIntegrationTests/src/main/native/cpp/command/MockConditionalCommand.cpp Normal file
View File

@@ -0,0 +1,57 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2017-2018 FIRST. 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) {
m_initializeCount = 0;
m_executeCount = 0;
m_isFinishedCount = 0;
m_endCount = 0;
m_interruptedCount = 0;
}
void MockConditionalCommand::SetCondition(bool condition) {
m_condition = condition;
}
bool MockConditionalCommand::Condition() { return m_condition; }
bool MockConditionalCommand::HasInitialized() {
return GetInitializeCount() > 0;
}
bool MockConditionalCommand::HasEnd() { return GetEndCount() > 0; }
bool MockConditionalCommand::HasInterrupted() {
return GetInterruptedCount() > 0;
}
void MockConditionalCommand::Initialize() { ++m_initializeCount; }
void MockConditionalCommand::Execute() { ++m_executeCount; }
bool MockConditionalCommand::IsFinished() {
++m_isFinishedCount;
return ConditionalCommand::IsFinished();
}
void MockConditionalCommand::End() { ++m_endCount; }
void MockConditionalCommand::Interrupted() { ++m_interruptedCount; }
void MockConditionalCommand::ResetCounters() {
m_initializeCount = 0;
m_executeCount = 0;
m_isFinishedCount = 0;
m_endCount = 0;
m_interruptedCount = 0;
}