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
Files
6d854afb0edb0f94eab78f9c9427174abc19a95a
allwpilib/wpilibcIntegrationTests/src/command/CommandTest.cpp

442 lines
15 KiB
C++
Raw Normal View History

Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
/*----------------------------------------------------------------------------*/
/* Copyright (c) FIRST 2014. 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. */
/*----------------------------------------------------------------------------*/
Replaced WPILib.h includes in integration tests with the minimum required subheaders to improve compilation times I ran the benchmark in a tmpfs with an Intel Core i5-2430M. I ran it three times for each combination of build invokation and source tree. First, I tested "make". For master (eb7d55f), I measured an average of 42.751s with a standard deviation of 0.372s. For this commit, I measured an average of 33.394s with a standard deviation of 0.140s. There was a 9.356s, or 22%, improvement with a total error of 1.3%. Second, I tested "make -j4". For master (eb7d55f), I measured an average of 21.723s with a standard deviation of 0.158s. For this commit, I measured an average of 16.823s with a standard deviation of 0.340s. There was a 4.900s, or 23%, improvement with a total error of 2.7%. Change-Id: Idb3adce62ed8ef449360c6583896b6da3565cf58
2015-07-22 02:34:12 -07:00
#include <Commands/CommandGroup.h>
#include <Commands/Scheduler.h>
#include <Commands/Subsystem.h>
#include <DriverStation.h>
#include <RobotState.h>
#include <Timer.h>
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
#include "command/MockCommand.h"
#include "gtest/gtest.h"
class CommandTest : public testing::Test {
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
protected:
virtual void SetUp() override {
RobotState::SetImplementation(DriverStation::GetInstance());
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->SetEnabled(true);
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
}
/**
* 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.
*/
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
void TeardownScheduler() { Scheduler::GetInstance()->ResetAll(); }
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
void AssertCommandState(MockCommand &command, int initialize, int execute,
int isFinished, int end, int 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());
}
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
};
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
class ASubsystem : public Subsystem {
private:
artf4107: Uniform initialization syntax introduced Change-Id: I452b4794d757a0817589ec62b75eda7fbdd74904
2015-06-24 01:06:29 -07:00
Command *m_command = nullptr;
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
public:
Changed const char* -> string in most of wpilibc. The HAL will remain untouched in order to maintain C-style compatibility. A few places in wpilibc were left as C-style strings, especially if special formatting (eg, elaborate uses of snprintf or sscanf) was being used. In general, const char* was changed to std::string. character buffers used for formatting were either untouched, changed to std::stringstream, or changed to std::string, depending on what was done with the buffer. Change-Id: I5e431ddf1cc4d9a6d534e1f21b16ea23be26e7f1
2015-06-30 15:01:20 -04:00
ASubsystem(const std::string &name) : Subsystem(name) {}
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
virtual void InitDefaultCommand() override {
artf4107: clang-modernize was run on WPILib Loops were converted to their range-based equivalents, variable types were replaced with auto where the type was already specified on the same line, the override keyword was added, and instances of NULL and assignments of 0 to pointers were replaced with nullptr. Change-Id: If281e46a2e2e1c37f278d56df9915236d4b2c864
2015-06-23 04:49:51 -07:00
if (m_command != nullptr) {
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
SetDefaultCommand(m_command);
}
}
void Init(Command *command) { m_command = command; }
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
};
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
// 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);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command1, 0, 0, 0, 0, 0);
AssertCommandState(command2, 0, 0, 0, 0, 0);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command1, 1, 1, 1, 0, 0);
AssertCommandState(command2, 1, 1, 1, 0, 0);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command1, 1, 2, 2, 0, 0);
AssertCommandState(command2, 1, 2, 2, 0, 0);
command1.SetHasFinished(true);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command1, 1, 3, 3, 1, 0);
AssertCommandState(command2, 1, 3, 3, 0, 0);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command1, 1, 3, 3, 1, 0);
AssertCommandState(command2, 1, 4, 4, 0, 0);
command2.SetHasFinished(true);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command1, 1, 3, 3, 1, 0);
AssertCommandState(command2, 1, 5, 5, 1, 0);
TeardownScheduler();
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
}
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
// END CommandParallelGroupTest
// CommandScheduleTest ported from CommandScheduleTest.java
TEST_F(CommandTest, RunAndTerminate) {
MockCommand command;
command.Start();
AssertCommandState(command, 0, 0, 0, 0, 0);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command, 0, 0, 0, 0, 0);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command, 1, 1, 1, 0, 0);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command, 1, 2, 2, 0, 0);
command.SetHasFinished(true);
AssertCommandState(command, 1, 2, 2, 0, 0);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command, 1, 3, 3, 1, 0);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command, 1, 3, 3, 1, 0);
TeardownScheduler();
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
}
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
TEST_F(CommandTest, RunAndCancel) {
MockCommand command;
command.Start();
AssertCommandState(command, 0, 0, 0, 0, 0);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command, 0, 0, 0, 0, 0);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command, 1, 1, 1, 0, 0);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command, 1, 2, 2, 0, 0);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command, 1, 3, 3, 0, 0);
command.Cancel();
AssertCommandState(command, 1, 3, 3, 0, 0);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command, 1, 3, 3, 0, 1);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command, 1, 3, 3, 0, 1);
TeardownScheduler();
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
}
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
// 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);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command1, 0, 0, 0, 0, 0);
AssertCommandState(command2, 0, 0, 0, 0, 0);
AssertCommandState(command3, 0, 0, 0, 0, 0);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
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
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command1, 1, 1, 1, 0, 1);
AssertCommandState(command2, 1, 1, 1, 0, 0);
AssertCommandState(command3, 0, 0, 0, 0, 0);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
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
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command1, 1, 1, 1, 0, 1);
AssertCommandState(command2, 1, 2, 2, 0, 1);
AssertCommandState(command3, 1, 1, 1, 0, 0);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
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);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command1, 1, 1, 1, 0, 1);
AssertCommandState(command2, 1, 2, 2, 0, 1);
AssertCommandState(command3, 1, 3, 3, 1, 0);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command1, 1, 1, 1, 0, 1);
AssertCommandState(command2, 1, 2, 2, 0, 1);
AssertCommandState(command3, 1, 3, 3, 1, 0);
TeardownScheduler();
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
}
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
// END CommandSequentialGroupTest
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
// CommandSequentialGroupTest ported from CommandSequentialGroupTest.java
TEST_F(CommandTest, OneCommandSupersedingAnotherBecauseOfDependencies) {
artf4107: clang-modernize was run on WPILib Loops were converted to their range-based equivalents, variable types were replaced with auto where the type was already specified on the same line, the override keyword was added, and instances of NULL and assignments of 0 to pointers were replaced with nullptr. Change-Id: If281e46a2e2e1c37f278d56df9915236d4b2c864
2015-06-23 04:49:51 -07:00
auto subsystem = new ASubsystem("Command Superseding Test Subsystem");
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
MockCommand command1;
command1.Requires(subsystem);
MockCommand command2;
command2.Requires(subsystem);
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command1, 0, 0, 0, 0, 0);
AssertCommandState(command2, 0, 0, 0, 0, 0);
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
command1.Start();
AssertCommandState(command1, 0, 0, 0, 0, 0);
AssertCommandState(command2, 0, 0, 0, 0, 0);
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command1, 0, 0, 0, 0, 0);
AssertCommandState(command2, 0, 0, 0, 0, 0);
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command1, 1, 1, 1, 0, 0);
AssertCommandState(command2, 0, 0, 0, 0, 0);
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command1, 1, 2, 2, 0, 0);
AssertCommandState(command2, 0, 0, 0, 0, 0);
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command1, 1, 3, 3, 0, 0);
AssertCommandState(command2, 0, 0, 0, 0, 0);
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
command2.Start();
AssertCommandState(command1, 1, 3, 3, 0, 0);
AssertCommandState(command2, 0, 0, 0, 0, 0);
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command1, 1, 4, 4, 0, 1);
AssertCommandState(command2, 0, 0, 0, 0, 0);
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command1, 1, 4, 4, 0, 1);
AssertCommandState(command2, 1, 1, 1, 0, 0);
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command1, 1, 4, 4, 0, 1);
AssertCommandState(command2, 1, 2, 2, 0, 0);
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command1, 1, 4, 4, 0, 1);
AssertCommandState(command2, 1, 3, 3, 0, 0);
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
TeardownScheduler();
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
}
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
TEST_F(CommandTest,
OneCommandFailingSupersedingBecauseFirstCanNotBeInterrupted) {
ASubsystem subsystem("Command Superseding Test Subsystem");
MockCommand command1;
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
command1.Requires(&subsystem);
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
command1.SetInterruptible(false);
MockCommand command2;
command2.Requires(&subsystem);
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command1, 0, 0, 0, 0, 0);
AssertCommandState(command2, 0, 0, 0, 0, 0);
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
command1.Start();
AssertCommandState(command1, 0, 0, 0, 0, 0);
AssertCommandState(command2, 0, 0, 0, 0, 0);
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command1, 0, 0, 0, 0, 0);
AssertCommandState(command2, 0, 0, 0, 0, 0);
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command1, 1, 1, 1, 0, 0);
AssertCommandState(command2, 0, 0, 0, 0, 0);
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command1, 1, 2, 2, 0, 0);
AssertCommandState(command2, 0, 0, 0, 0, 0);
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command1, 1, 3, 3, 0, 0);
AssertCommandState(command2, 0, 0, 0, 0, 0);
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
command2.Start();
AssertCommandState(command1, 1, 3, 3, 0, 0);
AssertCommandState(command2, 0, 0, 0, 0, 0);
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command1, 1, 4, 4, 0, 0);
AssertCommandState(command2, 0, 0, 0, 0, 0);
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
TeardownScheduler();
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
}
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
// END CommandSequentialGroupTest
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
class ModifiedMockCommand : public MockCommand {
public:
ModifiedMockCommand() : MockCommand() { SetTimeout(2.0); }
bool IsFinished() override {
return MockCommand::IsFinished() || IsTimedOut();
}
};
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
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);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command, 0, 0, 0, 0, 0);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command, 1, 1, 1, 0, 0);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command, 1, 2, 2, 0, 0);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command, 1, 3, 3, 0, 0);
Wait(2);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command, 1, 4, 4, 1, 0);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(command, 1, 4, 4, 1, 0);
TeardownScheduler();
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
}
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
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);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(defaultCommand, 0, 0, 0, 0, 0);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(defaultCommand, 1, 1, 1, 0, 0);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(defaultCommand, 1, 2, 2, 0, 0);
anotherCommand.Start();
AssertCommandState(defaultCommand, 1, 2, 2, 0, 0);
AssertCommandState(anotherCommand, 0, 0, 0, 0, 0);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(defaultCommand, 1, 3, 3, 0, 1);
AssertCommandState(anotherCommand, 0, 0, 0, 0, 0);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(defaultCommand, 1, 3, 3, 0, 1);
AssertCommandState(anotherCommand, 1, 1, 1, 0, 0);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
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);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(defaultCommand, 1, 3, 3, 0, 1);
AssertCommandState(anotherCommand, 1, 3, 3, 1, 0);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(defaultCommand, 2, 4, 4, 0, 1);
AssertCommandState(anotherCommand, 1, 3, 3, 1, 0);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(defaultCommand, 2, 5, 5, 0, 1);
AssertCommandState(anotherCommand, 1, 3, 3, 1, 0);
TeardownScheduler();
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
}
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
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);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(defaultCommand, 0, 0, 0, 0, 0);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(defaultCommand, 1, 1, 1, 0, 0);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(defaultCommand, 1, 2, 2, 0, 0);
anotherCommand.Start();
AssertCommandState(defaultCommand, 1, 2, 2, 0, 0);
AssertCommandState(anotherCommand, 0, 0, 0, 0, 0);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(defaultCommand, 1, 3, 3, 0, 1);
AssertCommandState(anotherCommand, 0, 0, 0, 0, 0);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(defaultCommand, 1, 3, 3, 0, 1);
AssertCommandState(anotherCommand, 1, 1, 1, 0, 0);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
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);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(defaultCommand, 1, 3, 3, 0, 1);
AssertCommandState(anotherCommand, 1, 2, 2, 0, 1);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(defaultCommand, 2, 4, 4, 0, 1);
AssertCommandState(anotherCommand, 1, 2, 2, 0, 1);
Revert changes preventing old user code from compiling. I'm not 100% sure whether we want these, but they are a quick find and replace to do. Basically, there are two primary things that we have done this summer that break existing user code: -Changing GetInstance() calls to return references instead of pointers. This forces users to change from doing something like LiveWindow::GetInstance()->AddSensor() to LiveWindow::GetInstance().AddSensor(). -Making PIDGet() and related calls const, forcing users to change the function signatures wherever they override them. The GetInstance() calls don't really matter to me either way, especially since there are no real ownership issues going on there, unlike the rest of the smart pointer-related changes. For the const stuff, it is certainly more correct to mandate that user PIDGet() functions be const and the such, but at the same time, I'm not sure that there is any strong need for it, and the errors generated are not the most helpful. While this wouldn't necessarily be an issue for more experienced teams or completely new teams (who don't have any old code to be reusing), it may cause issues for more average teams who aren't familiar with the intricacies of C++ anything. Change-Id: I6e7007982069292ea70e6d0fc8ca40203340df1b
2015-07-24 19:19:40 -04:00
Scheduler::GetInstance()->Run();
Major formatting changes (breaks diffs). No code changes. The changes made in this commit do not affect any actual code, they are purely aesthetic. I ran clang-format with google style over all .h/.cpp files in wpilibc that weren't in wpilibC++Sim or gtest, and the eclipse formatter over all of the Java files using the Google eclipse formatting configuration. Change-Id: I9627bca0bc103c398ecc1c5ba17467193291ae63
2015-06-25 15:07:55 -04:00
AssertCommandState(defaultCommand, 2, 5, 5, 0, 1);
AssertCommandState(anotherCommand, 1, 2, 2, 0, 1);
TeardownScheduler();
Adds CommandTests to the C++ Integration Test Suite Also adds/updates some comments in the Java Command Tests Change-Id: I24ae6cce06b8d5251e1cb115cd725f24a871635f
2014-06-23 15:12:58 -04:00
}
Reference in New Issue Copy Permalink