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

[wpilibj] Use try with resources for Java tests (#2612)

Browse Source
This commit is contained in:
Peter Johnson
2020-07-24 13:07:11 -07:00
committed by GitHub
parent e759dad019
commit 0fe2319dfc
37 changed files with 1235 additions and 1255 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj2/MockHardwareExtension.java
View File

@@ -29,12 +29,9 @@ public final class MockHardwareExtension implements BeforeAllCallback {
private void initializeHardware() {
HAL.initialize(500, 0);
DriverStationSim dsSim = new DriverStationSim();
dsSim.setDsAttached(true);
dsSim.setAutonomous(false);
dsSim.setEnabled(true);
dsSim.setTest(true);
DriverStationSim.setDsAttached(true);
DriverStationSim.setAutonomous(false);
DriverStationSim.setEnabled(true);
DriverStationSim.setTest(true);
}
}

184
wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj2/command/CommandDecoratorTest.java
View File

@@ -1,5 +1,5 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2018-2019 FIRST. All Rights Reserved. */
/* Copyright (c) 2018-2020 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. */
@@ -17,166 +17,166 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
class CommandDecoratorTest extends CommandTestBase {
@Test
void withTimeoutTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
Command command1 = new WaitCommand(10);
Command command1 = new WaitCommand(10);
Command timeout = command1.withTimeout(2);
Command timeout = command1.withTimeout(2);
scheduler.schedule(timeout);
scheduler.run();
scheduler.schedule(timeout);
scheduler.run();
assertFalse(scheduler.isScheduled(command1));
assertTrue(scheduler.isScheduled(timeout));
assertFalse(scheduler.isScheduled(command1));
assertTrue(scheduler.isScheduled(timeout));
Timer.delay(3);
scheduler.run();
Timer.delay(3);
scheduler.run();
assertFalse(scheduler.isScheduled(timeout));
assertFalse(scheduler.isScheduled(timeout));
}
}
@Test
void withInterruptTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
ConditionHolder condition = new ConditionHolder();
ConditionHolder condition = new ConditionHolder();
Command command = new WaitCommand(10).withInterrupt(condition::getCondition);
Command command = new WaitCommand(10).withInterrupt(condition::getCondition);
scheduler.schedule(command);
scheduler.run();
assertTrue(scheduler.isScheduled(command));
condition.setCondition(true);
scheduler.run();
assertFalse(scheduler.isScheduled(command));
scheduler.schedule(command);
scheduler.run();
assertTrue(scheduler.isScheduled(command));
condition.setCondition(true);
scheduler.run();
assertFalse(scheduler.isScheduled(command));
}
}
@Test
void beforeStartingTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
ConditionHolder condition = new ConditionHolder();
condition.setCondition(false);
ConditionHolder condition = new ConditionHolder();
condition.setCondition(false);
Command command = new InstantCommand();
Command command = new InstantCommand();
scheduler.schedule(command.beforeStarting(() -> condition.setCondition(true)));
scheduler.schedule(command.beforeStarting(() -> condition.setCondition(true)));
assertTrue(condition.getCondition());
assertTrue(condition.getCondition());
}
}
@Test
void andThenLambdaTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
ConditionHolder condition = new ConditionHolder();
condition.setCondition(false);
ConditionHolder condition = new ConditionHolder();
condition.setCondition(false);
Command command = new InstantCommand();
Command command = new InstantCommand();
scheduler.schedule(command.andThen(() -> condition.setCondition(true)));
scheduler.schedule(command.andThen(() -> condition.setCondition(true)));
assertFalse(condition.getCondition());
assertFalse(condition.getCondition());
scheduler.run();
scheduler.run();
assertTrue(condition.getCondition());
assertTrue(condition.getCondition());
}
}
@Test
void andThenTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
ConditionHolder condition = new ConditionHolder();
condition.setCondition(false);
ConditionHolder condition = new ConditionHolder();
condition.setCondition(false);
Command command1 = new InstantCommand();
Command command2 = new InstantCommand(() -> condition.setCondition(true));
Command command1 = new InstantCommand();
Command command2 = new InstantCommand(() -> condition.setCondition(true));
scheduler.schedule(command1.andThen(command2));
scheduler.schedule(command1.andThen(command2));
assertFalse(condition.getCondition());
assertFalse(condition.getCondition());
scheduler.run();
scheduler.run();
assertTrue(condition.getCondition());
assertTrue(condition.getCondition());
}
}
@Test
void deadlineWithTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
ConditionHolder condition = new ConditionHolder();
condition.setCondition(false);
ConditionHolder condition = new ConditionHolder();
condition.setCondition(false);
Command dictator = new WaitUntilCommand(condition::getCondition);
Command endsBefore = new InstantCommand();
Command endsAfter = new WaitUntilCommand(() -> false);
Command dictator = new WaitUntilCommand(condition::getCondition);
Command endsBefore = new InstantCommand();
Command endsAfter = new WaitUntilCommand(() -> false);
Command group = dictator.deadlineWith(endsBefore, endsAfter);
Command group = dictator.deadlineWith(endsBefore, endsAfter);
scheduler.schedule(group);
scheduler.run();
scheduler.schedule(group);
scheduler.run();
assertTrue(scheduler.isScheduled(group));
assertTrue(scheduler.isScheduled(group));
condition.setCondition(true);
scheduler.run();
condition.setCondition(true);
scheduler.run();
assertFalse(scheduler.isScheduled(group));
assertFalse(scheduler.isScheduled(group));
}
}
@Test
void alongWithTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
ConditionHolder condition = new ConditionHolder();
condition.setCondition(false);
ConditionHolder condition = new ConditionHolder();
condition.setCondition(false);
Command command1 = new WaitUntilCommand(condition::getCondition);
Command command2 = new InstantCommand();
Command command1 = new WaitUntilCommand(condition::getCondition);
Command command2 = new InstantCommand();
Command group = command1.alongWith(command2);
Command group = command1.alongWith(command2);
scheduler.schedule(group);
scheduler.run();
scheduler.schedule(group);
scheduler.run();
assertTrue(scheduler.isScheduled(group));
assertTrue(scheduler.isScheduled(group));
condition.setCondition(true);
scheduler.run();
condition.setCondition(true);
scheduler.run();
assertFalse(scheduler.isScheduled(group));
assertFalse(scheduler.isScheduled(group));
}
}
@Test
void raceWithTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
Command command1 = new WaitUntilCommand(() -> false);
Command command2 = new InstantCommand();
Command command1 = new WaitUntilCommand(() -> false);
Command command2 = new InstantCommand();
Command group = command1.raceWith(command2);
Command group = command1.raceWith(command2);
scheduler.schedule(group);
scheduler.run();
scheduler.schedule(group);
scheduler.run();
assertFalse(scheduler.isScheduled(group));
assertFalse(scheduler.isScheduled(group));
}
}
@Test
void perpetuallyTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
Command command = new InstantCommand();
Command command = new InstantCommand();
Command perpetual = command.perpetually();
Command perpetual = command.perpetually();
scheduler.schedule(perpetual);
scheduler.run();
scheduler.run();
scheduler.run();
scheduler.schedule(perpetual);
scheduler.run();
scheduler.run();
scheduler.run();
assertTrue(scheduler.isScheduled(perpetual));
assertTrue(scheduler.isScheduled(perpetual));
}
}
}

22
wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj2/command/CommandGroupErrorTest.java
View File

@@ -1,5 +1,5 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2018-2019 FIRST. All Rights Reserved. */
/* Copyright (c) 2018-2020 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. */
@@ -29,18 +29,18 @@ class CommandGroupErrorTest extends CommandTestBase {
@Test
void commandInGroupExternallyScheduledTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
@SuppressWarnings("PMD.UnusedLocalVariable")
Command group = new ParallelCommandGroup(command1, command2);
@SuppressWarnings("PMD.UnusedLocalVariable")
Command group = new ParallelCommandGroup(command1, command2);
assertThrows(IllegalArgumentException.class,
() -> scheduler.schedule(command1));
assertThrows(IllegalArgumentException.class,
() -> scheduler.schedule(command1));
}
}
@Test

80
wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj2/command/CommandRequirementsTest.java
View File

@@ -1,5 +1,5 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2018-2019 FIRST. All Rights Reserved. */
/* Copyright (c) 2018-2020 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. */
@@ -18,62 +18,62 @@ import static org.mockito.Mockito.verify;
class CommandRequirementsTest extends CommandTestBase {
@Test
void requirementInterruptTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
Subsystem requirement = new TestSubsystem();
Subsystem requirement = new TestSubsystem();
MockCommandHolder interruptedHolder = new MockCommandHolder(true, requirement);
Command interrupted = interruptedHolder.getMock();
MockCommandHolder interrupterHolder = new MockCommandHolder(true, requirement);
Command interrupter = interrupterHolder.getMock();
MockCommandHolder interruptedHolder = new MockCommandHolder(true, requirement);
Command interrupted = interruptedHolder.getMock();
MockCommandHolder interrupterHolder = new MockCommandHolder(true, requirement);
Command interrupter = interrupterHolder.getMock();
scheduler.schedule(interrupted);
scheduler.run();
scheduler.schedule(interrupter);
scheduler.run();
scheduler.schedule(interrupted);
scheduler.run();
scheduler.schedule(interrupter);
scheduler.run();
verify(interrupted).initialize();
verify(interrupted).execute();
verify(interrupted).end(true);
verify(interrupted).initialize();
verify(interrupted).execute();
verify(interrupted).end(true);
verify(interrupter).initialize();
verify(interrupter).execute();
verify(interrupter).initialize();
verify(interrupter).execute();
assertFalse(scheduler.isScheduled(interrupted));
assertTrue(scheduler.isScheduled(interrupter));
assertFalse(scheduler.isScheduled(interrupted));
assertTrue(scheduler.isScheduled(interrupter));
}
}
@Test
void requirementUninterruptibleTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
Subsystem requirement = new TestSubsystem();
Subsystem requirement = new TestSubsystem();
MockCommandHolder interruptedHolder = new MockCommandHolder(true, requirement);
Command notInterrupted = interruptedHolder.getMock();
MockCommandHolder interrupterHolder = new MockCommandHolder(true, requirement);
Command interrupter = interrupterHolder.getMock();
MockCommandHolder interruptedHolder = new MockCommandHolder(true, requirement);
Command notInterrupted = interruptedHolder.getMock();
MockCommandHolder interrupterHolder = new MockCommandHolder(true, requirement);
Command interrupter = interrupterHolder.getMock();
scheduler.schedule(false, notInterrupted);
scheduler.schedule(interrupter);
scheduler.schedule(false, notInterrupted);
scheduler.schedule(interrupter);
assertTrue(scheduler.isScheduled(notInterrupted));
assertFalse(scheduler.isScheduled(interrupter));
assertTrue(scheduler.isScheduled(notInterrupted));
assertFalse(scheduler.isScheduled(interrupter));
}
}
@Test
void defaultCommandRequirementErrorTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
Subsystem system = new TestSubsystem();
Subsystem system = new TestSubsystem();
Command missingRequirement = new WaitUntilCommand(() -> false);
Command ends = new InstantCommand(() -> {
}, system);
Command missingRequirement = new WaitUntilCommand(() -> false);
Command ends = new InstantCommand(() -> {
}, system);
assertThrows(IllegalArgumentException.class,
() -> scheduler.setDefaultCommand(system, missingRequirement));
assertThrows(IllegalArgumentException.class,
() -> scheduler.setDefaultCommand(system, ends));
assertThrows(IllegalArgumentException.class,
() -> scheduler.setDefaultCommand(system, missingRequirement));
assertThrows(IllegalArgumentException.class,
() -> scheduler.setDefaultCommand(system, ends));
}
}
}

132
wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj2/command/CommandScheduleTest.java
View File

@@ -1,5 +1,5 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2018-2019 FIRST. All Rights Reserved. */
/* Copyright (c) 2018-2020 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. */
@@ -19,104 +19,104 @@ import static org.mockito.Mockito.verify;
class CommandScheduleTest extends CommandTestBase {
@Test
void instantScheduleTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
MockCommandHolder holder = new MockCommandHolder(true);
holder.setFinished(true);
Command mockCommand = holder.getMock();
MockCommandHolder holder = new MockCommandHolder(true);
holder.setFinished(true);
Command mockCommand = holder.getMock();
scheduler.schedule(mockCommand);
assertTrue(scheduler.isScheduled(mockCommand));
verify(mockCommand).initialize();
scheduler.schedule(mockCommand);
assertTrue(scheduler.isScheduled(mockCommand));
verify(mockCommand).initialize();
scheduler.run();
scheduler.run();
verify(mockCommand).execute();
verify(mockCommand).end(false);
verify(mockCommand).execute();
verify(mockCommand).end(false);
assertFalse(scheduler.isScheduled(mockCommand));
assertFalse(scheduler.isScheduled(mockCommand));
}
}
@Test
void singleIterationScheduleTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
MockCommandHolder holder = new MockCommandHolder(true);
Command mockCommand = holder.getMock();
MockCommandHolder holder = new MockCommandHolder(true);
Command mockCommand = holder.getMock();
scheduler.schedule(mockCommand);
scheduler.schedule(mockCommand);
assertTrue(scheduler.isScheduled(mockCommand));
assertTrue(scheduler.isScheduled(mockCommand));
scheduler.run();
holder.setFinished(true);
scheduler.run();
scheduler.run();
holder.setFinished(true);
scheduler.run();
verify(mockCommand).initialize();
verify(mockCommand, times(2)).execute();
verify(mockCommand).end(false);
verify(mockCommand).initialize();
verify(mockCommand, times(2)).execute();
verify(mockCommand).end(false);
assertFalse(scheduler.isScheduled(mockCommand));
assertFalse(scheduler.isScheduled(mockCommand));
}
}
@Test
void multiScheduleTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
MockCommandHolder command3Holder = new MockCommandHolder(true);
Command command3 = command3Holder.getMock();
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
MockCommandHolder command3Holder = new MockCommandHolder(true);
Command command3 = command3Holder.getMock();
scheduler.schedule(true, command1, command2, command3);
assertTrue(scheduler.isScheduled(command1, command2, command3));
scheduler.run();
assertTrue(scheduler.isScheduled(command1, command2, command3));
scheduler.schedule(true, command1, command2, command3);
assertTrue(scheduler.isScheduled(command1, command2, command3));
scheduler.run();
assertTrue(scheduler.isScheduled(command1, command2, command3));
command1Holder.setFinished(true);
scheduler.run();
assertTrue(scheduler.isScheduled(command2, command3));
assertFalse(scheduler.isScheduled(command1));
command1Holder.setFinished(true);
scheduler.run();
assertTrue(scheduler.isScheduled(command2, command3));
assertFalse(scheduler.isScheduled(command1));
command2Holder.setFinished(true);
scheduler.run();
assertTrue(scheduler.isScheduled(command3));
assertFalse(scheduler.isScheduled(command1, command2));
command2Holder.setFinished(true);
scheduler.run();
assertTrue(scheduler.isScheduled(command3));
assertFalse(scheduler.isScheduled(command1, command2));
command3Holder.setFinished(true);
scheduler.run();
assertFalse(scheduler.isScheduled(command1, command2, command3));
command3Holder.setFinished(true);
scheduler.run();
assertFalse(scheduler.isScheduled(command1, command2, command3));
}
}
@Test
void schedulerCancelTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
MockCommandHolder holder = new MockCommandHolder(true);
Command mockCommand = holder.getMock();
MockCommandHolder holder = new MockCommandHolder(true);
Command mockCommand = holder.getMock();
scheduler.schedule(mockCommand);
scheduler.schedule(mockCommand);
scheduler.run();
scheduler.cancel(mockCommand);
scheduler.run();
scheduler.run();
scheduler.cancel(mockCommand);
scheduler.run();
verify(mockCommand).execute();
verify(mockCommand).end(true);
verify(mockCommand, never()).end(false);
verify(mockCommand).execute();
verify(mockCommand).end(true);
verify(mockCommand, never()).end(false);
assertFalse(scheduler.isScheduled(mockCommand));
assertFalse(scheduler.isScheduled(mockCommand));
}
}
@Test
void notScheduledCancelTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
MockCommandHolder holder = new MockCommandHolder(true);
Command mockCommand = holder.getMock();
MockCommandHolder holder = new MockCommandHolder(true);
Command mockCommand = holder.getMock();
assertDoesNotThrow(() -> scheduler.cancel(mockCommand));
assertDoesNotThrow(() -> scheduler.cancel(mockCommand));
}
}
}

7
wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj2/command/CommandTestBase.java
View File

@@ -33,11 +33,10 @@ public abstract class CommandTestBase {
}
public void setDSEnabled(boolean enabled) {
DriverStationSim sim = new DriverStationSim();
sim.setDsAttached(true);
DriverStationSim.setDsAttached(true);
sim.setEnabled(enabled);
sim.notifyNewData();
DriverStationSim.setEnabled(enabled);
DriverStationSim.notifyNewData();
DriverStation.getInstance().isNewControlData();
while (DriverStation.getInstance().isEnabled() != enabled) {
try {

62
wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj2/command/ConditionalCommandTest.java
View File

@@ -1,5 +1,5 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2019 FIRST. All Rights Reserved. */
/* Copyright (c) 2019-2020 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. */
@@ -16,26 +16,27 @@ import static org.mockito.Mockito.verify;
class ConditionalCommandTest extends CommandTestBase {
@Test
void conditionalCommandTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
command1Holder.setFinished(true);
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
command1Holder.setFinished(true);
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
ConditionalCommand conditionalCommand =
new ConditionalCommand(command1, command2, () -> true);
ConditionalCommand conditionalCommand = new ConditionalCommand(command1, command2, () -> true);
scheduler.schedule(conditionalCommand);
scheduler.run();
scheduler.schedule(conditionalCommand);
scheduler.run();
verify(command1).initialize();
verify(command1).execute();
verify(command1).end(false);
verify(command1).initialize();
verify(command1).execute();
verify(command1).end(false);
verify(command2, never()).initialize();
verify(command2, never()).execute();
verify(command2, never()).end(false);
verify(command2, never()).initialize();
verify(command2, never()).execute();
verify(command2, never()).end(false);
}
}
@Test
@@ -44,22 +45,23 @@ class ConditionalCommandTest extends CommandTestBase {
Subsystem system2 = new TestSubsystem();
Subsystem system3 = new TestSubsystem();
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
MockCommandHolder command1Holder = new MockCommandHolder(true, system1, system2);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true, system3);
Command command2 = command2Holder.getMock();
MockCommandHolder command1Holder = new MockCommandHolder(true, system1, system2);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true, system3);
Command command2 = command2Holder.getMock();
ConditionalCommand conditionalCommand =
new ConditionalCommand(command1, command2, () -> true);
ConditionalCommand conditionalCommand = new ConditionalCommand(command1, command2, () -> true);
scheduler.schedule(conditionalCommand);
scheduler.schedule(new InstantCommand(() -> {
}, system3));
scheduler.schedule(conditionalCommand);
scheduler.schedule(new InstantCommand(() -> {
}, system3));
assertFalse(scheduler.isScheduled(conditionalCommand));
assertFalse(scheduler.isScheduled(conditionalCommand));
verify(command1).end(true);
verify(command2, never()).end(true);
verify(command1).end(true);
verify(command2, never()).end(true);
}
}
}

80
wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj2/command/DefaultCommandTest.java
View File

@@ -1,5 +1,5 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2018-2019 FIRST. All Rights Reserved. */
/* Copyright (c) 2018-2020 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. */
@@ -16,68 +16,68 @@ import static org.mockito.Mockito.verify;
class DefaultCommandTest extends CommandTestBase {
@Test
void defaultCommandScheduleTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
TestSubsystem hasDefaultCommand = new TestSubsystem();
TestSubsystem hasDefaultCommand = new TestSubsystem();
MockCommandHolder defaultHolder = new MockCommandHolder(true, hasDefaultCommand);
Command defaultCommand = defaultHolder.getMock();
MockCommandHolder defaultHolder = new MockCommandHolder(true, hasDefaultCommand);
Command defaultCommand = defaultHolder.getMock();
scheduler.setDefaultCommand(hasDefaultCommand, defaultCommand);
scheduler.run();
scheduler.setDefaultCommand(hasDefaultCommand, defaultCommand);
scheduler.run();
assertTrue(scheduler.isScheduled(defaultCommand));
assertTrue(scheduler.isScheduled(defaultCommand));
}
}
@Test
void defaultCommandInterruptResumeTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
TestSubsystem hasDefaultCommand = new TestSubsystem();
TestSubsystem hasDefaultCommand = new TestSubsystem();
MockCommandHolder defaultHolder = new MockCommandHolder(true, hasDefaultCommand);
Command defaultCommand = defaultHolder.getMock();
MockCommandHolder interrupterHolder = new MockCommandHolder(true, hasDefaultCommand);
Command interrupter = interrupterHolder.getMock();
MockCommandHolder defaultHolder = new MockCommandHolder(true, hasDefaultCommand);
Command defaultCommand = defaultHolder.getMock();
MockCommandHolder interrupterHolder = new MockCommandHolder(true, hasDefaultCommand);
Command interrupter = interrupterHolder.getMock();
scheduler.setDefaultCommand(hasDefaultCommand, defaultCommand);
scheduler.run();
scheduler.schedule(interrupter);
scheduler.setDefaultCommand(hasDefaultCommand, defaultCommand);
scheduler.run();
scheduler.schedule(interrupter);
assertFalse(scheduler.isScheduled(defaultCommand));
assertTrue(scheduler.isScheduled(interrupter));
assertFalse(scheduler.isScheduled(defaultCommand));
assertTrue(scheduler.isScheduled(interrupter));
scheduler.cancel(interrupter);
scheduler.run();
scheduler.cancel(interrupter);
scheduler.run();
assertTrue(scheduler.isScheduled(defaultCommand));
assertFalse(scheduler.isScheduled(interrupter));
assertTrue(scheduler.isScheduled(defaultCommand));
assertFalse(scheduler.isScheduled(interrupter));
}
}
@Test
void defaultCommandDisableResumeTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
TestSubsystem hasDefaultCommand = new TestSubsystem();
TestSubsystem hasDefaultCommand = new TestSubsystem();
MockCommandHolder defaultHolder = new MockCommandHolder(false, hasDefaultCommand);
Command defaultCommand = defaultHolder.getMock();
MockCommandHolder defaultHolder = new MockCommandHolder(false, hasDefaultCommand);
Command defaultCommand = defaultHolder.getMock();
scheduler.setDefaultCommand(hasDefaultCommand, defaultCommand);
scheduler.run();
scheduler.setDefaultCommand(hasDefaultCommand, defaultCommand);
scheduler.run();
assertTrue(scheduler.isScheduled(defaultCommand));
assertTrue(scheduler.isScheduled(defaultCommand));
setDSEnabled(false);
scheduler.run();
setDSEnabled(false);
scheduler.run();
assertFalse(scheduler.isScheduled(defaultCommand));
assertFalse(scheduler.isScheduled(defaultCommand));
setDSEnabled(true);
scheduler.run();
setDSEnabled(true);
scheduler.run();
assertTrue(scheduler.isScheduled(defaultCommand));
assertTrue(scheduler.isScheduled(defaultCommand));
verify(defaultCommand).end(true);
verify(defaultCommand).end(true);
}
}
}

38
wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj2/command/FunctionalCommandTest.java
View File

@@ -1,5 +1,5 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2019 FIRST. All Rights Reserved. */
/* Copyright (c) 2019-2020 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. */
@@ -15,29 +15,29 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
class FunctionalCommandTest extends CommandTestBase {
@Test
void functionalCommandScheduleTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
ConditionHolder cond1 = new ConditionHolder();
ConditionHolder cond2 = new ConditionHolder();
ConditionHolder cond3 = new ConditionHolder();
ConditionHolder cond4 = new ConditionHolder();
ConditionHolder cond1 = new ConditionHolder();
ConditionHolder cond2 = new ConditionHolder();
ConditionHolder cond3 = new ConditionHolder();
ConditionHolder cond4 = new ConditionHolder();
FunctionalCommand command =
new FunctionalCommand(() -> cond1.setCondition(true), () -> cond2.setCondition(true),
interrupted -> cond3.setCondition(true), cond4::getCondition);
FunctionalCommand command =
new FunctionalCommand(() -> cond1.setCondition(true), () -> cond2.setCondition(true),
interrupted -> cond3.setCondition(true), cond4::getCondition);
scheduler.schedule(command);
scheduler.run();
scheduler.schedule(command);
scheduler.run();
assertTrue(scheduler.isScheduled(command));
assertTrue(scheduler.isScheduled(command));
cond4.setCondition(true);
cond4.setCondition(true);
scheduler.run();
scheduler.run();
assertFalse(scheduler.isScheduled(command));
assertTrue(cond1.getCondition());
assertTrue(cond2.getCondition());
assertTrue(cond3.getCondition());
assertFalse(scheduler.isScheduled(command));
assertTrue(cond1.getCondition());
assertTrue(cond2.getCondition());
assertTrue(cond3.getCondition());
}
}
}

18
wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj2/command/InstantCommandTest.java
View File

@@ -1,5 +1,5 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2019 FIRST. All Rights Reserved. */
/* Copyright (c) 2019-2020 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. */
@@ -15,16 +15,16 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
class InstantCommandTest extends CommandTestBase {
@Test
void instantCommandScheduleTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
ConditionHolder cond = new ConditionHolder();
ConditionHolder cond = new ConditionHolder();
InstantCommand command = new InstantCommand(() -> cond.setCondition(true));
InstantCommand command = new InstantCommand(() -> cond.setCondition(true));
scheduler.schedule(command);
scheduler.run();
scheduler.schedule(command);
scheduler.run();
assertTrue(cond.getCondition());
assertFalse(scheduler.isScheduled(command));
assertTrue(cond.getCondition());
assertFalse(scheduler.isScheduled(command));
}
}
}

20
wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj2/command/NotifierCommandTest.java
View File

@@ -1,5 +1,5 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2019 FIRST. All Rights Reserved. */
/* Copyright (c) 2019-2020 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. */
@@ -19,17 +19,17 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
class NotifierCommandTest extends CommandTestBase {
@Test
void notifierCommandScheduleTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
Counter counter = new Counter();
Counter counter = new Counter();
NotifierCommand command = new NotifierCommand(counter::increment, 0.01);
NotifierCommand command = new NotifierCommand(counter::increment, 0.01);
scheduler.schedule(command);
Timer.delay(0.25);
scheduler.cancel(command);
scheduler.schedule(command);
Timer.delay(0.25);
scheduler.cancel(command);
assertTrue(counter.m_counter > 10, "Should have hit at least 10 triggers");
assertTrue(counter.m_counter < 100, "Shouldn't hit more then 100 triggers");
assertTrue(counter.m_counter > 10, "Should have hit at least 10 triggers");
assertTrue(counter.m_counter < 100, "Shouldn't hit more then 100 triggers");
}
}
}

119
wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj2/command/ParallelCommandGroupTest.java
View File

@@ -1,5 +1,5 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2018-2019 FIRST. All Rights Reserved. */
/* Copyright (c) 2018-2020 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. */
@@ -20,73 +20,74 @@ import static org.mockito.Mockito.verify;
class ParallelCommandGroupTest extends CommandTestBase {
@Test
void parallelGroupScheduleTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
Command group = new ParallelCommandGroup(command1, command2);
Command group = new ParallelCommandGroup(command1, command2);
scheduler.schedule(group);
scheduler.schedule(group);
verify(command1).initialize();
verify(command2).initialize();
verify(command1).initialize();
verify(command2).initialize();
command1Holder.setFinished(true);
scheduler.run();
command2Holder.setFinished(true);
scheduler.run();
command1Holder.setFinished(true);
scheduler.run();
command2Holder.setFinished(true);
scheduler.run();
verify(command1).execute();
verify(command1).end(false);
verify(command2, times(2)).execute();
verify(command2).end(false);
verify(command1).execute();
verify(command1).end(false);
verify(command2, times(2)).execute();
verify(command2).end(false);
assertFalse(scheduler.isScheduled(group));
assertFalse(scheduler.isScheduled(group));
}
}
@Test
void parallelGroupInterruptTest() {
CommandScheduler scheduler = new CommandScheduler();
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
try (CommandScheduler scheduler = new CommandScheduler()) {
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
Command group = new ParallelCommandGroup(command1, command2);
Command group = new ParallelCommandGroup(command1, command2);
scheduler.schedule(group);
scheduler.schedule(group);
command1Holder.setFinished(true);
scheduler.run();
scheduler.run();
scheduler.cancel(group);
command1Holder.setFinished(true);
scheduler.run();
scheduler.run();
scheduler.cancel(group);
verify(command1).execute();
verify(command1).end(false);
verify(command1, never()).end(true);
verify(command1).execute();
verify(command1).end(false);
verify(command1, never()).end(true);
verify(command2, times(2)).execute();
verify(command2, never()).end(false);
verify(command2).end(true);
verify(command2, times(2)).execute();
verify(command2, never()).end(false);
verify(command2).end(true);
assertFalse(scheduler.isScheduled(group));
assertFalse(scheduler.isScheduled(group));
}
}
@Test
void notScheduledCancelTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
Command group = new ParallelCommandGroup(command1, command2);
Command group = new ParallelCommandGroup(command1, command2);
assertDoesNotThrow(() -> scheduler.cancel(group));
assertDoesNotThrow(() -> scheduler.cancel(group));
}
}
@Test
@@ -96,22 +97,22 @@ class ParallelCommandGroupTest extends CommandTestBase {
Subsystem system3 = new TestSubsystem();
Subsystem system4 = new TestSubsystem();
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
MockCommandHolder command1Holder = new MockCommandHolder(true, system1, system2);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true, system3);
Command command2 = command2Holder.getMock();
MockCommandHolder command3Holder = new MockCommandHolder(true, system3, system4);
Command command3 = command3Holder.getMock();
MockCommandHolder command1Holder = new MockCommandHolder(true, system1, system2);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true, system3);
Command command2 = command2Holder.getMock();
MockCommandHolder command3Holder = new MockCommandHolder(true, system3, system4);
Command command3 = command3Holder.getMock();
Command group = new ParallelCommandGroup(command1, command2);
Command group = new ParallelCommandGroup(command1, command2);
scheduler.schedule(group);
scheduler.schedule(command3);
scheduler.schedule(group);
scheduler.schedule(command3);
assertFalse(scheduler.isScheduled(group));
assertTrue(scheduler.isScheduled(command3));
assertFalse(scheduler.isScheduled(group));
assertTrue(scheduler.isScheduled(command3));
}
}
@Test

122
wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj2/command/ParallelDeadlineGroupTest.java
View File

@@ -1,5 +1,5 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2018-2019 FIRST. All Rights Reserved. */
/* Copyright (c) 2018-2020 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. */
@@ -19,71 +19,71 @@ import static org.mockito.internal.verification.VerificationModeFactory.times;
class ParallelDeadlineGroupTest extends CommandTestBase {
@Test
void parallelDeadlineScheduleTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
command2Holder.setFinished(true);
MockCommandHolder command3Holder = new MockCommandHolder(true);
Command command3 = command3Holder.getMock();
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
command2Holder.setFinished(true);
MockCommandHolder command3Holder = new MockCommandHolder(true);
Command command3 = command3Holder.getMock();
Command group = new ParallelDeadlineGroup(command1, command2, command3);
Command group = new ParallelDeadlineGroup(command1, command2, command3);
scheduler.schedule(group);
scheduler.run();
scheduler.schedule(group);
scheduler.run();
assertTrue(scheduler.isScheduled(group));
assertTrue(scheduler.isScheduled(group));
command1Holder.setFinished(true);
scheduler.run();
command1Holder.setFinished(true);
scheduler.run();
assertFalse(scheduler.isScheduled(group));
assertFalse(scheduler.isScheduled(group));
verify(command2).initialize();
verify(command2).execute();
verify(command2).end(false);
verify(command2, never()).end(true);
verify(command2).initialize();
verify(command2).execute();
verify(command2).end(false);
verify(command2, never()).end(true);
verify(command1).initialize();
verify(command1, times(2)).execute();
verify(command1).end(false);
verify(command1, never()).end(true);
verify(command1).initialize();
verify(command1, times(2)).execute();
verify(command1).end(false);
verify(command1, never()).end(true);
verify(command3).initialize();
verify(command3, times(2)).execute();
verify(command3, never()).end(false);
verify(command3).end(true);
verify(command3).initialize();
verify(command3, times(2)).execute();
verify(command3, never()).end(false);
verify(command3).end(true);
}
}
@Test
void parallelDeadlineInterruptTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
command2Holder.setFinished(true);
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
command2Holder.setFinished(true);
Command group = new ParallelDeadlineGroup(command1, command2);
Command group = new ParallelDeadlineGroup(command1, command2);
scheduler.schedule(group);
scheduler.schedule(group);
scheduler.run();
scheduler.run();
scheduler.cancel(group);
scheduler.run();
scheduler.run();
scheduler.cancel(group);
verify(command1, times(2)).execute();
verify(command1, never()).end(false);
verify(command1).end(true);
verify(command1, times(2)).execute();
verify(command1, never()).end(false);
verify(command1).end(true);
verify(command2).execute();
verify(command2).end(false);
verify(command2, never()).end(true);
verify(command2).execute();
verify(command2).end(false);
verify(command2, never()).end(true);
assertFalse(scheduler.isScheduled(group));
assertFalse(scheduler.isScheduled(group));
}
}
@@ -94,22 +94,22 @@ class ParallelDeadlineGroupTest extends CommandTestBase {
Subsystem system3 = new TestSubsystem();
Subsystem system4 = new TestSubsystem();
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
MockCommandHolder command1Holder = new MockCommandHolder(true, system1, system2);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true, system3);
Command command2 = command2Holder.getMock();
MockCommandHolder command3Holder = new MockCommandHolder(true, system3, system4);
Command command3 = command3Holder.getMock();
MockCommandHolder command1Holder = new MockCommandHolder(true, system1, system2);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true, system3);
Command command2 = command2Holder.getMock();
MockCommandHolder command3Holder = new MockCommandHolder(true, system3, system4);
Command command3 = command3Holder.getMock();
Command group = new ParallelDeadlineGroup(command1, command2);
Command group = new ParallelDeadlineGroup(command1, command2);
scheduler.schedule(group);
scheduler.schedule(command3);
scheduler.schedule(group);
scheduler.schedule(command3);
assertFalse(scheduler.isScheduled(group));
assertTrue(scheduler.isScheduled(command3));
assertFalse(scheduler.isScheduled(group));
assertTrue(scheduler.isScheduled(command3));
}
}
@Test

199
wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj2/command/ParallelRaceGroupTest.java
View File

@@ -22,74 +22,74 @@ import static org.mockito.Mockito.verify;
class ParallelRaceGroupTest extends CommandTestBase {
@Test
void parallelRaceScheduleTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
Command group = new ParallelRaceGroup(command1, command2);
Command group = new ParallelRaceGroup(command1, command2);
scheduler.schedule(group);
scheduler.schedule(group);
verify(command1).initialize();
verify(command2).initialize();
verify(command1).initialize();
verify(command2).initialize();
command1Holder.setFinished(true);
scheduler.run();
command2Holder.setFinished(true);
scheduler.run();
command1Holder.setFinished(true);
scheduler.run();
command2Holder.setFinished(true);
scheduler.run();
verify(command1).execute();
verify(command1).end(false);
verify(command2).execute();
verify(command2).end(true);
verify(command2, never()).end(false);
verify(command1).execute();
verify(command1).end(false);
verify(command2).execute();
verify(command2).end(true);
verify(command2, never()).end(false);
assertFalse(scheduler.isScheduled(group));
assertFalse(scheduler.isScheduled(group));
}
}
@Test
void parallelRaceInterruptTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
Command group = new ParallelRaceGroup(command1, command2);
Command group = new ParallelRaceGroup(command1, command2);
scheduler.schedule(group);
scheduler.schedule(group);
scheduler.run();
scheduler.run();
scheduler.cancel(group);
scheduler.run();
scheduler.run();
scheduler.cancel(group);
verify(command1, times(2)).execute();
verify(command1, never()).end(false);
verify(command1).end(true);
verify(command1, times(2)).execute();
verify(command1, never()).end(false);
verify(command1).end(true);
verify(command2, times(2)).execute();
verify(command2, never()).end(false);
verify(command2).end(true);
verify(command2, times(2)).execute();
verify(command2, never()).end(false);
verify(command2).end(true);
assertFalse(scheduler.isScheduled(group));
assertFalse(scheduler.isScheduled(group));
}
}
@Test
void notScheduledCancelTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
Command group = new ParallelRaceGroup(command1, command2);
Command group = new ParallelRaceGroup(command1, command2);
assertDoesNotThrow(() -> scheduler.cancel(group));
assertDoesNotThrow(() -> scheduler.cancel(group));
}
}
@@ -100,22 +100,22 @@ class ParallelRaceGroupTest extends CommandTestBase {
Subsystem system3 = new TestSubsystem();
Subsystem system4 = new TestSubsystem();
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
MockCommandHolder command1Holder = new MockCommandHolder(true, system1, system2);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true, system3);
Command command2 = command2Holder.getMock();
MockCommandHolder command3Holder = new MockCommandHolder(true, system3, system4);
Command command3 = command3Holder.getMock();
MockCommandHolder command1Holder = new MockCommandHolder(true, system1, system2);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true, system3);
Command command2 = command2Holder.getMock();
MockCommandHolder command3Holder = new MockCommandHolder(true, system3, system4);
Command command3 = command3Holder.getMock();
Command group = new ParallelRaceGroup(command1, command2);
Command group = new ParallelRaceGroup(command1, command2);
scheduler.schedule(group);
scheduler.schedule(command3);
scheduler.schedule(group);
scheduler.schedule(command3);
assertFalse(scheduler.isScheduled(group));
assertTrue(scheduler.isScheduled(command3));
assertFalse(scheduler.isScheduled(group));
assertTrue(scheduler.isScheduled(command3));
}
}
@Test
@@ -149,62 +149,61 @@ class ParallelRaceGroupTest extends CommandTestBase {
assertNotNull(command3);
Command group2 = new ParallelRaceGroup(group1, command3);
CommandScheduler scheduler = new CommandScheduler();
scheduler.schedule(group2);
scheduler.run();
command1Holder.setFinished(true);
scheduler.run();
command2Holder.setFinished(true);
// at this point the sequential group should be done
assertDoesNotThrow(() -> scheduler.run());
try (CommandScheduler scheduler = new CommandScheduler()) {
scheduler.schedule(group2);
scheduler.run();
command1Holder.setFinished(true);
scheduler.run();
command2Holder.setFinished(true);
// at this point the sequential group should be done
assertDoesNotThrow(() -> scheduler.run());
}
}
@Test
void parallelRaceScheduleTwiceTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
Command group = new ParallelRaceGroup(command1, command2);
Command group = new ParallelRaceGroup(command1, command2);
scheduler.schedule(group);
scheduler.schedule(group);
verify(command1).initialize();
verify(command2).initialize();
verify(command1).initialize();
verify(command2).initialize();
command1Holder.setFinished(true);
scheduler.run();
command2Holder.setFinished(true);
scheduler.run();
command1Holder.setFinished(true);
scheduler.run();
command2Holder.setFinished(true);
scheduler.run();
verify(command1).execute();
verify(command1).end(false);
verify(command2).execute();
verify(command2).end(true);
verify(command2, never()).end(false);
verify(command1).execute();
verify(command1).end(false);
verify(command2).execute();
verify(command2).end(true);
verify(command2, never()).end(false);
assertFalse(scheduler.isScheduled(group));
assertFalse(scheduler.isScheduled(group));
reset(command1);
reset(command2);
reset(command1);
reset(command2);
scheduler.schedule(group);
scheduler.schedule(group);
verify(command1).initialize();
verify(command2).initialize();
verify(command1).initialize();
verify(command2).initialize();
scheduler.run();
scheduler.run();
assertTrue(scheduler.isScheduled(group));
command2Holder.setFinished(true);
scheduler.run();
scheduler.run();
scheduler.run();
assertTrue(scheduler.isScheduled(group));
command2Holder.setFinished(true);
scheduler.run();
assertFalse(scheduler.isScheduled(group));
assertFalse(scheduler.isScheduled(group));
}
}
}

14
wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj2/command/PerpetualCommandTest.java
View File

@@ -1,5 +1,5 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2019 FIRST. All Rights Reserved. */
/* Copyright (c) 2019-2020 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. */
@@ -14,13 +14,13 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
class PerpetualCommandTest extends CommandTestBase {
@Test
void perpetualCommandScheduleTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
PerpetualCommand command = new PerpetualCommand(new InstantCommand());
PerpetualCommand command = new PerpetualCommand(new InstantCommand());
scheduler.schedule(command);
scheduler.run();
scheduler.schedule(command);
scheduler.run();
assertTrue(scheduler.isScheduled(command));
assertTrue(scheduler.isScheduled(command));
}
}
}

29
wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj2/command/PrintCommandTest.java
View File

@@ -1,5 +1,5 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2019 FIRST. All Rights Reserved. */
/* Copyright (c) 2019-2020 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. */
@@ -18,20 +18,21 @@ import static org.junit.jupiter.api.Assertions.assertFalse;
class PrintCommandTest extends CommandTestBase {
@Test
void printCommandScheduleTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
final PrintStream originalOut = System.out;
ByteArrayOutputStream testOut = new ByteArrayOutputStream();
System.setOut(new PrintStream(testOut));
try {
PrintCommand command = new PrintCommand("Test!");
final PrintStream originalOut = System.out;
ByteArrayOutputStream testOut = new ByteArrayOutputStream();
System.setOut(new PrintStream(testOut));
scheduler.schedule(command);
scheduler.run();
PrintCommand command = new PrintCommand("Test!");
scheduler.schedule(command);
scheduler.run();
assertFalse(scheduler.isScheduled(command));
assertEquals(testOut.toString(), "Test!" + System.lineSeparator());
System.setOut(originalOut);
assertFalse(scheduler.isScheduled(command));
assertEquals(testOut.toString(), "Test!" + System.lineSeparator());
} finally {
System.setOut(originalOut);
}
}
}
}

40
wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj2/command/ProxyScheduleCommandTest.java
View File

@@ -1,5 +1,5 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2019 FIRST. All Rights Reserved. */
/* Copyright (c) 2019-2020 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. */
@@ -16,36 +16,36 @@ import static org.mockito.Mockito.verify;
class ProxyScheduleCommandTest extends CommandTestBase {
@Test
void proxyScheduleCommandScheduleTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
ProxyScheduleCommand scheduleCommand = new ProxyScheduleCommand(command1);
ProxyScheduleCommand scheduleCommand = new ProxyScheduleCommand(command1);
scheduler.schedule(scheduleCommand);
scheduler.schedule(scheduleCommand);
verify(command1).schedule();
verify(command1).schedule();
}
}
@Test
void proxyScheduleCommandEndTest() {
CommandScheduler scheduler = CommandScheduler.getInstance();
try (CommandScheduler scheduler = CommandScheduler.getInstance()) {
ConditionHolder cond = new ConditionHolder();
ConditionHolder cond = new ConditionHolder();
WaitUntilCommand command = new WaitUntilCommand(cond::getCondition);
WaitUntilCommand command = new WaitUntilCommand(cond::getCondition);
ProxyScheduleCommand scheduleCommand = new ProxyScheduleCommand(command);
ProxyScheduleCommand scheduleCommand = new ProxyScheduleCommand(command);
scheduler.schedule(scheduleCommand);
scheduler.schedule(scheduleCommand);
scheduler.run();
assertTrue(scheduler.isScheduled(scheduleCommand));
scheduler.run();
assertTrue(scheduler.isScheduled(scheduleCommand));
cond.setCondition(true);
scheduler.run();
scheduler.run();
assertFalse(scheduler.isScheduled(scheduleCommand));
cond.setCondition(true);
scheduler.run();
scheduler.run();
assertFalse(scheduler.isScheduled(scheduleCommand));
}
}
}

150
wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj2/command/RobotDisabledCommandTest.java
View File

@@ -1,5 +1,5 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2018-2019 FIRST. All Rights Reserved. */
/* Copyright (c) 2018-2020 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. */
@@ -18,94 +18,94 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
class RobotDisabledCommandTest extends CommandTestBase {
@Test
void robotDisabledCommandCancelTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
MockCommandHolder holder = new MockCommandHolder(false);
Command mockCommand = holder.getMock();
MockCommandHolder holder = new MockCommandHolder(false);
Command mockCommand = holder.getMock();
scheduler.schedule(mockCommand);
scheduler.schedule(mockCommand);
assertTrue(scheduler.isScheduled(mockCommand));
assertTrue(scheduler.isScheduled(mockCommand));
setDSEnabled(false);
setDSEnabled(false);
scheduler.run();
scheduler.run();
assertFalse(scheduler.isScheduled(mockCommand));
assertFalse(scheduler.isScheduled(mockCommand));
setDSEnabled(true);
setDSEnabled(true);
}
}
@Test
void runWhenDisabledTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
MockCommandHolder holder = new MockCommandHolder(true);
Command mockCommand = holder.getMock();
MockCommandHolder holder = new MockCommandHolder(true);
Command mockCommand = holder.getMock();
scheduler.schedule(mockCommand);
scheduler.schedule(mockCommand);
assertTrue(scheduler.isScheduled(mockCommand));
assertTrue(scheduler.isScheduled(mockCommand));
setDSEnabled(false);
setDSEnabled(false);
scheduler.run();
scheduler.run();
assertTrue(scheduler.isScheduled(mockCommand));
assertTrue(scheduler.isScheduled(mockCommand));
}
}
@Test
void sequentialGroupRunWhenDisabledTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
MockCommandHolder command3Holder = new MockCommandHolder(true);
Command command3 = command3Holder.getMock();
MockCommandHolder command4Holder = new MockCommandHolder(false);
Command command4 = command4Holder.getMock();
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
MockCommandHolder command3Holder = new MockCommandHolder(true);
Command command3 = command3Holder.getMock();
MockCommandHolder command4Holder = new MockCommandHolder(false);
Command command4 = command4Holder.getMock();
Command runWhenDisabled = new SequentialCommandGroup(command1, command2);
Command dontRunWhenDisabled = new SequentialCommandGroup(command3, command4);
Command runWhenDisabled = new SequentialCommandGroup(command1, command2);
Command dontRunWhenDisabled = new SequentialCommandGroup(command3, command4);
scheduler.schedule(runWhenDisabled);
scheduler.schedule(dontRunWhenDisabled);
scheduler.schedule(runWhenDisabled);
scheduler.schedule(dontRunWhenDisabled);
setDSEnabled(false);
setDSEnabled(false);
scheduler.run();
scheduler.run();
assertTrue(scheduler.isScheduled(runWhenDisabled));
assertFalse(scheduler.isScheduled(dontRunWhenDisabled));
assertTrue(scheduler.isScheduled(runWhenDisabled));
assertFalse(scheduler.isScheduled(dontRunWhenDisabled));
}
}
@Test
void parallelGroupRunWhenDisabledTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
MockCommandHolder command3Holder = new MockCommandHolder(true);
Command command3 = command3Holder.getMock();
MockCommandHolder command4Holder = new MockCommandHolder(false);
Command command4 = command4Holder.getMock();
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
MockCommandHolder command3Holder = new MockCommandHolder(true);
Command command3 = command3Holder.getMock();
MockCommandHolder command4Holder = new MockCommandHolder(false);
Command command4 = command4Holder.getMock();
Command runWhenDisabled = new ParallelCommandGroup(command1, command2);
Command dontRunWhenDisabled = new ParallelCommandGroup(command3, command4);
Command runWhenDisabled = new ParallelCommandGroup(command1, command2);
Command dontRunWhenDisabled = new ParallelCommandGroup(command3, command4);
scheduler.schedule(runWhenDisabled);
scheduler.schedule(dontRunWhenDisabled);
scheduler.schedule(runWhenDisabled);
scheduler.schedule(dontRunWhenDisabled);
setDSEnabled(false);
setDSEnabled(false);
scheduler.run();
scheduler.run();
assertTrue(scheduler.isScheduled(runWhenDisabled));
assertFalse(scheduler.isScheduled(dontRunWhenDisabled));
assertTrue(scheduler.isScheduled(runWhenDisabled));
assertFalse(scheduler.isScheduled(dontRunWhenDisabled));
}
}
@Test
@@ -121,15 +121,15 @@ class RobotDisabledCommandTest extends CommandTestBase {
MockCommandHolder command4Holder = new MockCommandHolder(false);
Command command4 = command4Holder.getMock();
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
Command runWhenDisabled = new ConditionalCommand(command1, command2, () -> true);
Command dontRunWhenDisabled = new ConditionalCommand(command3, command4, () -> true);
Command runWhenDisabled = new ConditionalCommand(command1, command2, () -> true);
Command dontRunWhenDisabled = new ConditionalCommand(command3, command4, () -> true);
scheduler.schedule(runWhenDisabled, dontRunWhenDisabled);
scheduler.schedule(runWhenDisabled, dontRunWhenDisabled);
assertTrue(scheduler.isScheduled(runWhenDisabled));
assertFalse(scheduler.isScheduled(dontRunWhenDisabled));
assertTrue(scheduler.isScheduled(runWhenDisabled));
assertFalse(scheduler.isScheduled(dontRunWhenDisabled));
}
}
@Test
@@ -148,12 +148,12 @@ class RobotDisabledCommandTest extends CommandTestBase {
Command runWhenDisabled = new SelectCommand(Map.of(1, command1, 2, command2), () -> 1);
Command dontRunWhenDisabled = new SelectCommand(Map.of(1, command3, 2, command4), () -> 1);
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
scheduler.schedule(runWhenDisabled, dontRunWhenDisabled);
scheduler.schedule(runWhenDisabled, dontRunWhenDisabled);
assertTrue(scheduler.isScheduled(runWhenDisabled));
assertFalse(scheduler.isScheduled(dontRunWhenDisabled));
assertTrue(scheduler.isScheduled(runWhenDisabled));
assertFalse(scheduler.isScheduled(dontRunWhenDisabled));
}
}
@Test
@@ -169,15 +169,15 @@ class RobotDisabledCommandTest extends CommandTestBase {
MockCommandHolder command4Holder = new MockCommandHolder(false);
Command command4 = command4Holder.getMock();
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
Command runWhenDisabled = new ConditionalCommand(command1, command2, () -> true);
Command dontRunWhenDisabled = new ConditionalCommand(command3, command4, () -> true);
Command runWhenDisabled = new ConditionalCommand(command1, command2, () -> true);
Command dontRunWhenDisabled = new ConditionalCommand(command3, command4, () -> true);
Command parallel = parallel(runWhenDisabled, dontRunWhenDisabled);
Command parallel = parallel(runWhenDisabled, dontRunWhenDisabled);
scheduler.schedule(parallel);
scheduler.schedule(parallel);
assertFalse(scheduler.isScheduled(runWhenDisabled));
assertFalse(scheduler.isScheduled(runWhenDisabled));
}
}
}

20
wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj2/command/RunCommandTest.java
View File

@@ -1,5 +1,5 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2019 FIRST. All Rights Reserved. */
/* Copyright (c) 2019-2020 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. */
@@ -14,17 +14,17 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
class RunCommandTest extends CommandTestBase {
@Test
void runCommandScheduleTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
Counter counter = new Counter();
Counter counter = new Counter();
RunCommand command = new RunCommand(counter::increment);
RunCommand command = new RunCommand(counter::increment);
scheduler.schedule(command);
scheduler.run();
scheduler.run();
scheduler.run();
scheduler.schedule(command);
scheduler.run();
scheduler.run();
scheduler.run();
assertEquals(3, counter.m_counter);
assertEquals(3, counter.m_counter);
}
}
}

40
wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj2/command/ScheduleCommandTest.java
View File

@@ -15,33 +15,33 @@ import static org.mockito.Mockito.verify;
class ScheduleCommandTest extends CommandTestBase {
@Test
void scheduleCommandScheduleTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
ScheduleCommand scheduleCommand = new ScheduleCommand(command1, command2);
ScheduleCommand scheduleCommand = new ScheduleCommand(command1, command2);
scheduler.schedule(scheduleCommand);
scheduler.schedule(scheduleCommand);
verify(command1).schedule();
verify(command2).schedule();
verify(command1).schedule();
verify(command2).schedule();
}
}
@Test
void scheduleCommandDuringRunTest() {
CommandScheduler scheduler = CommandScheduler.getInstance();
try (CommandScheduler scheduler = CommandScheduler.getInstance()) {
InstantCommand toSchedule = new InstantCommand();
ScheduleCommand scheduleCommand = new ScheduleCommand(toSchedule);
SequentialCommandGroup group =
new SequentialCommandGroup(new InstantCommand(), scheduleCommand);
InstantCommand toSchedule = new InstantCommand();
ScheduleCommand scheduleCommand = new ScheduleCommand(toSchedule);
SequentialCommandGroup group =
new SequentialCommandGroup(new InstantCommand(), scheduleCommand);
scheduler.schedule(group);
scheduler.schedule(new InstantCommand().perpetually());
scheduler.run();
assertDoesNotThrow(scheduler::run);
scheduler.schedule(group);
scheduler.schedule(new InstantCommand().perpetually());
scheduler.run();
assertDoesNotThrow(scheduler::run);
}
}
}

64
wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj2/command/SchedulerTest.java
View File

@@ -15,61 +15,61 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
class SchedulerTest extends CommandTestBase {
@Test
void schedulerLambdaTestNoInterrupt() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
Counter counter = new Counter();
Counter counter = new Counter();
scheduler.onCommandInitialize(command -> counter.increment());
scheduler.onCommandExecute(command -> counter.increment());
scheduler.onCommandFinish(command -> counter.increment());
scheduler.onCommandInitialize(command -> counter.increment());
scheduler.onCommandExecute(command -> counter.increment());
scheduler.onCommandFinish(command -> counter.increment());
scheduler.schedule(new InstantCommand());
scheduler.run();
scheduler.schedule(new InstantCommand());
scheduler.run();
assertEquals(counter.m_counter, 3);
assertEquals(counter.m_counter, 3);
}
}
@Test
void schedulerInterruptLambdaTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
Counter counter = new Counter();
Counter counter = new Counter();
scheduler.onCommandInterrupt(command -> counter.increment());
scheduler.onCommandInterrupt(command -> counter.increment());
Command command = new WaitCommand(10);
Command command = new WaitCommand(10);
scheduler.schedule(command);
scheduler.cancel(command);
scheduler.schedule(command);
scheduler.cancel(command);
assertEquals(counter.m_counter, 1);
assertEquals(counter.m_counter, 1);
}
}
@Test
void unregisterSubsystemTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
Subsystem system = new TestSubsystem();
Subsystem system = new TestSubsystem();
scheduler.registerSubsystem(system);
assertDoesNotThrow(() -> scheduler.unregisterSubsystem(system));
scheduler.registerSubsystem(system);
assertDoesNotThrow(() -> scheduler.unregisterSubsystem(system));
}
}
@Test
void schedulerCancelAllTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
Counter counter = new Counter();
Counter counter = new Counter();
scheduler.onCommandInterrupt(command -> counter.increment());
scheduler.onCommandInterrupt(command -> counter.increment());
Command command = new WaitCommand(10);
Command command2 = new WaitCommand(10);
Command command = new WaitCommand(10);
Command command2 = new WaitCommand(10);
scheduler.schedule(command);
scheduler.schedule(command2);
scheduler.cancelAll();
scheduler.schedule(command);
scheduler.schedule(command2);
scheduler.cancelAll();
assertEquals(counter.m_counter, 2);
assertEquals(counter.m_counter, 2);
}
}
}

122
wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj2/command/SelectCommandTest.java
View File

@@ -1,5 +1,5 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2018-2019 FIRST. All Rights Reserved. */
/* Copyright (c) 2018-2020 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. */
@@ -19,59 +19,59 @@ import static org.mockito.Mockito.verify;
class SelectCommandTest extends CommandTestBase {
@Test
void selectCommandTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
command1Holder.setFinished(true);
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
MockCommandHolder command3Holder = new MockCommandHolder(true);
Command command3 = command3Holder.getMock();
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
command1Holder.setFinished(true);
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
MockCommandHolder command3Holder = new MockCommandHolder(true);
Command command3 = command3Holder.getMock();
SelectCommand selectCommand =
new SelectCommand(Map.ofEntries(
Map.entry("one", command1),
Map.entry("two", command2),
Map.entry("three", command3)),
() -> "one");
SelectCommand selectCommand =
new SelectCommand(Map.ofEntries(
Map.entry("one", command1),
Map.entry("two", command2),
Map.entry("three", command3)),
() -> "one");
scheduler.schedule(selectCommand);
scheduler.run();
scheduler.schedule(selectCommand);
scheduler.run();
verify(command1).initialize();
verify(command1).execute();
verify(command1).end(false);
verify(command1).initialize();
verify(command1).execute();
verify(command1).end(false);
verify(command2, never()).initialize();
verify(command2, never()).execute();
verify(command2, never()).end(false);
verify(command2, never()).initialize();
verify(command2, never()).execute();
verify(command2, never()).end(false);
verify(command3, never()).initialize();
verify(command3, never()).execute();
verify(command3, never()).end(false);
verify(command3, never()).initialize();
verify(command3, never()).execute();
verify(command3, never()).end(false);
}
}
@Test
void selectCommandInvalidKeyTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
command1Holder.setFinished(true);
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
MockCommandHolder command3Holder = new MockCommandHolder(true);
Command command3 = command3Holder.getMock();
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
command1Holder.setFinished(true);
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
MockCommandHolder command3Holder = new MockCommandHolder(true);
Command command3 = command3Holder.getMock();
SelectCommand selectCommand =
new SelectCommand(Map.ofEntries(
Map.entry("one", command1),
Map.entry("two", command2),
Map.entry("three", command3)),
() -> "four");
SelectCommand selectCommand =
new SelectCommand(Map.ofEntries(
Map.entry("one", command1),
Map.entry("two", command2),
Map.entry("three", command3)),
() -> "four");
assertDoesNotThrow(() -> scheduler.schedule(selectCommand));
assertDoesNotThrow(() -> scheduler.schedule(selectCommand));
}
}
@@ -82,27 +82,27 @@ class SelectCommandTest extends CommandTestBase {
Subsystem system3 = new TestSubsystem();
Subsystem system4 = new TestSubsystem();
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
MockCommandHolder command1Holder = new MockCommandHolder(true, system1, system2);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true, system3);
Command command2 = command2Holder.getMock();
MockCommandHolder command3Holder = new MockCommandHolder(true, system3, system4);
Command command3 = command3Holder.getMock();
MockCommandHolder command1Holder = new MockCommandHolder(true, system1, system2);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true, system3);
Command command2 = command2Holder.getMock();
MockCommandHolder command3Holder = new MockCommandHolder(true, system3, system4);
Command command3 = command3Holder.getMock();
SelectCommand selectCommand = new SelectCommand(
Map.ofEntries(Map.entry("one", command1), Map.entry("two", command2),
Map.entry("three", command3)), () -> "one");
SelectCommand selectCommand = new SelectCommand(
Map.ofEntries(Map.entry("one", command1), Map.entry("two", command2),
Map.entry("three", command3)), () -> "one");
scheduler.schedule(selectCommand);
scheduler.schedule(new InstantCommand(() -> {
}, system3));
scheduler.schedule(selectCommand);
scheduler.schedule(new InstantCommand(() -> {
}, system3));
assertFalse(scheduler.isScheduled(selectCommand));
assertFalse(scheduler.isScheduled(selectCommand));
verify(command1).end(true);
verify(command2, never()).end(true);
verify(command3, never()).end(true);
verify(command1).end(true);
verify(command2, never()).end(true);
verify(command3, never()).end(true);
}
}
}

142
wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj2/command/SequentialCommandGroupTest.java
View File

@@ -1,5 +1,5 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2018-2019 FIRST. All Rights Reserved. */
/* Copyright (c) 2018-2020 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. */
@@ -18,86 +18,86 @@ import static org.mockito.Mockito.verify;
class SequentialCommandGroupTest extends CommandTestBase {
@Test
void sequentialGroupScheduleTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
Command group = new SequentialCommandGroup(command1, command2);
Command group = new SequentialCommandGroup(command1, command2);
scheduler.schedule(group);
scheduler.schedule(group);
verify(command1).initialize();
verify(command2, never()).initialize();
verify(command1).initialize();
verify(command2, never()).initialize();
command1Holder.setFinished(true);
scheduler.run();
command1Holder.setFinished(true);
scheduler.run();
verify(command1).execute();
verify(command1).end(false);
verify(command2).initialize();
verify(command2, never()).execute();
verify(command2, never()).end(false);
verify(command1).execute();
verify(command1).end(false);
verify(command2).initialize();
verify(command2, never()).execute();
verify(command2, never()).end(false);
command2Holder.setFinished(true);
scheduler.run();
command2Holder.setFinished(true);
scheduler.run();
verify(command1).execute();
verify(command1).end(false);
verify(command2).execute();
verify(command2).end(false);
verify(command1).execute();
verify(command1).end(false);
verify(command2).execute();
verify(command2).end(false);
assertFalse(scheduler.isScheduled(group));
assertFalse(scheduler.isScheduled(group));
}
}
@Test
void sequentialGroupInterruptTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
MockCommandHolder command3Holder = new MockCommandHolder(true);
Command command3 = command3Holder.getMock();
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
MockCommandHolder command3Holder = new MockCommandHolder(true);
Command command3 = command3Holder.getMock();
Command group = new SequentialCommandGroup(command1, command2, command3);
Command group = new SequentialCommandGroup(command1, command2, command3);
scheduler.schedule(group);
scheduler.schedule(group);
command1Holder.setFinished(true);
scheduler.run();
scheduler.cancel(group);
scheduler.run();
command1Holder.setFinished(true);
scheduler.run();
scheduler.cancel(group);
scheduler.run();
verify(command1).execute();
verify(command1, never()).end(true);
verify(command1).end(false);
verify(command2, never()).execute();
verify(command2).end(true);
verify(command2, never()).end(false);
verify(command3, never()).initialize();
verify(command3, never()).execute();
verify(command3, never()).end(true);
verify(command3, never()).end(false);
verify(command1).execute();
verify(command1, never()).end(true);
verify(command1).end(false);
verify(command2, never()).execute();
verify(command2).end(true);
verify(command2, never()).end(false);
verify(command3, never()).initialize();
verify(command3, never()).execute();
verify(command3, never()).end(true);
verify(command3, never()).end(false);
assertFalse(scheduler.isScheduled(group));
assertFalse(scheduler.isScheduled(group));
}
}
@Test
void notScheduledCancelTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true);
Command command2 = command2Holder.getMock();
Command group = new SequentialCommandGroup(command1, command2);
Command group = new SequentialCommandGroup(command1, command2);
assertDoesNotThrow(() -> scheduler.cancel(group));
assertDoesNotThrow(() -> scheduler.cancel(group));
}
}
@@ -108,21 +108,21 @@ class SequentialCommandGroupTest extends CommandTestBase {
Subsystem system3 = new TestSubsystem();
Subsystem system4 = new TestSubsystem();
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
MockCommandHolder command1Holder = new MockCommandHolder(true, system1, system2);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true, system3);
Command command2 = command2Holder.getMock();
MockCommandHolder command3Holder = new MockCommandHolder(true, system3, system4);
Command command3 = command3Holder.getMock();
MockCommandHolder command1Holder = new MockCommandHolder(true, system1, system2);
Command command1 = command1Holder.getMock();
MockCommandHolder command2Holder = new MockCommandHolder(true, system3);
Command command2 = command2Holder.getMock();
MockCommandHolder command3Holder = new MockCommandHolder(true, system3, system4);
Command command3 = command3Holder.getMock();
Command group = new SequentialCommandGroup(command1, command2);
Command group = new SequentialCommandGroup(command1, command2);
scheduler.schedule(group);
scheduler.schedule(command3);
scheduler.schedule(group);
scheduler.schedule(command3);
assertFalse(scheduler.isScheduled(group));
assertTrue(scheduler.isScheduled(command3));
assertFalse(scheduler.isScheduled(group));
assertTrue(scheduler.isScheduled(command3));
}
}
}

28
wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj2/command/StartEndCommandTest.java
View File

@@ -1,5 +1,5 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2019 FIRST. All Rights Reserved. */
/* Copyright (c) 2019-2020 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. */
@@ -15,23 +15,23 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
class StartEndCommandTest extends CommandTestBase {
@Test
void startEndCommandScheduleTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
ConditionHolder cond1 = new ConditionHolder();
ConditionHolder cond2 = new ConditionHolder();
ConditionHolder cond1 = new ConditionHolder();
ConditionHolder cond2 = new ConditionHolder();
StartEndCommand command =
new StartEndCommand(() -> cond1.setCondition(true), () -> cond2.setCondition(true));
StartEndCommand command =
new StartEndCommand(() -> cond1.setCondition(true), () -> cond2.setCondition(true));
scheduler.schedule(command);
scheduler.run();
scheduler.schedule(command);
scheduler.run();
assertTrue(scheduler.isScheduled(command));
assertTrue(scheduler.isScheduled(command));
scheduler.cancel(command);
scheduler.cancel(command);
assertFalse(scheduler.isScheduled(command));
assertTrue(cond1.getCondition());
assertTrue(cond2.getCondition());
assertFalse(scheduler.isScheduled(command));
assertTrue(cond1.getCondition());
assertTrue(cond2.getCondition());
}
}
}

58
wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj2/command/WaitCommandTest.java
View File

@@ -1,5 +1,5 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2018-2019 FIRST. All Rights Reserved. */
/* Copyright (c) 2018-2020 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. */
@@ -21,47 +21,47 @@ import static org.mockito.Mockito.when;
class WaitCommandTest extends CommandTestBase {
@Test
void waitCommandTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
WaitCommand waitCommand = new WaitCommand(2);
WaitCommand waitCommand = new WaitCommand(2);
scheduler.schedule(waitCommand);
scheduler.run();
Timer.delay(1);
scheduler.run();
scheduler.schedule(waitCommand);
scheduler.run();
Timer.delay(1);
scheduler.run();
assertTrue(scheduler.isScheduled(waitCommand));
assertTrue(scheduler.isScheduled(waitCommand));
Timer.delay(2);
Timer.delay(2);
scheduler.run();
scheduler.run();
assertFalse(scheduler.isScheduled(waitCommand));
assertFalse(scheduler.isScheduled(waitCommand));
}
}
@Test
void withTimeoutTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
when(command1.withTimeout(anyDouble())).thenCallRealMethod();
MockCommandHolder command1Holder = new MockCommandHolder(true);
Command command1 = command1Holder.getMock();
when(command1.withTimeout(anyDouble())).thenCallRealMethod();
Command timeout = command1.withTimeout(2);
Command timeout = command1.withTimeout(2);
scheduler.schedule(timeout);
scheduler.run();
scheduler.schedule(timeout);
scheduler.run();
verify(command1).initialize();
verify(command1).execute();
assertFalse(scheduler.isScheduled(command1));
assertTrue(scheduler.isScheduled(timeout));
verify(command1).initialize();
verify(command1).execute();
assertFalse(scheduler.isScheduled(command1));
assertTrue(scheduler.isScheduled(timeout));
Timer.delay(3);
scheduler.run();
Timer.delay(3);
scheduler.run();
verify(command1).end(true);
verify(command1, never()).end(false);
assertFalse(scheduler.isScheduled(timeout));
verify(command1).end(true);
verify(command1, never()).end(false);
assertFalse(scheduler.isScheduled(timeout));
}
}
}

22
wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj2/command/WaitUntilCommandTest.java
View File

@@ -1,5 +1,5 @@
/*----------------------------------------------------------------------------*/
/* Copyright (c) 2018-2019 FIRST. All Rights Reserved. */
/* Copyright (c) 2018-2020 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. */
@@ -15,17 +15,17 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
class WaitUntilCommandTest extends CommandTestBase {
@Test
void waitUntilTest() {
CommandScheduler scheduler = new CommandScheduler();
try (CommandScheduler scheduler = new CommandScheduler()) {
ConditionHolder condition = new ConditionHolder();
ConditionHolder condition = new ConditionHolder();
Command command = new WaitUntilCommand(condition::getCondition);
Command command = new WaitUntilCommand(condition::getCondition);
scheduler.schedule(command);
scheduler.run();
assertTrue(scheduler.isScheduled(command));
condition.setCondition(true);
scheduler.run();
assertFalse(scheduler.isScheduled(command));
scheduler.schedule(command);
scheduler.run();
assertTrue(scheduler.isScheduled(command));
condition.setCondition(true);
scheduler.run();
assertFalse(scheduler.isScheduled(command));
}
}
}