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

[wpimath] Remove unhelpful test fixtures (#7344)

Browse Source 
These test fixtures were adding complexity while only saving one line of
object initialization per test. Our other tests like this just make the
object at the top of each test.
This commit is contained in:
Tyler Veness
2024-11-05 08:49:38 -08:00
committed by GitHub
parent ad09d73dd6
commit 9e8d37c03b
8 changed files with 202 additions and 183 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
wpimath/src/test/native/cpp/controller/BangBangInputOutputTest.cpp
View File

@@ -6,15 +6,14 @@
#include "frc/controller/BangBangController.h"
class BangBangInputOutputTest : public testing::Test {
protected:
TEST(BangBangInputOutputTest, ShouldOutput) {
frc::BangBangController controller;
};
TEST_F(BangBangInputOutputTest, ShouldOutput) {
EXPECT_DOUBLE_EQ(controller.Calculate(0, 1), 1);
}
TEST_F(BangBangInputOutputTest, ShouldNotOutput) {
TEST(BangBangInputOutputTest, ShouldNotOutput) {
frc::BangBangController controller;
EXPECT_DOUBLE_EQ(controller.Calculate(1, 0), 0);
}

9
wpimath/src/test/native/cpp/controller/BangBangToleranceTest.cpp
View File

@@ -6,18 +6,17 @@
#include "frc/controller/BangBangController.h"
class BangBangToleranceTest : public testing::Test {
protected:
TEST(BangBangToleranceTest, InTolerance) {
frc::BangBangController controller{0.1};
};
TEST_F(BangBangToleranceTest, InTolerance) {
controller.SetSetpoint(1);
controller.Calculate(1);
EXPECT_TRUE(controller.AtSetpoint());
}
TEST_F(BangBangToleranceTest, OutOfTolerance) {
TEST(BangBangToleranceTest, OutOfTolerance) {
frc::BangBangController controller{0.1};
controller.SetSetpoint(1);
controller.Calculate(0);
EXPECT_FALSE(controller.AtSetpoint());

73
wpimath/src/test/native/cpp/controller/PIDInputOutputTest.cpp
View File

@@ -6,65 +6,68 @@
#include "frc/controller/PIDController.h"
class PIDInputOutputTest : public testing::Test {
protected:
frc::PIDController* controller;
TEST(PIDInputOutputTest, ContinuousInput) {
frc::PIDController controller{0.0, 0.0, 0.0};
void SetUp() override { controller = new frc::PIDController{0, 0, 0}; }
controller.SetP(1);
controller.EnableContinuousInput(-180, 180);
EXPECT_DOUBLE_EQ(controller.Calculate(-179, 179), -2);
void TearDown() override { delete controller; }
};
TEST_F(PIDInputOutputTest, ContinuousInput) {
controller->SetP(1);
controller->EnableContinuousInput(-180, 180);
EXPECT_DOUBLE_EQ(controller->Calculate(-179, 179), -2);
controller->EnableContinuousInput(0, 360);
EXPECT_DOUBLE_EQ(controller->Calculate(1, 359), -2);
controller.EnableContinuousInput(0, 360);
EXPECT_DOUBLE_EQ(controller.Calculate(1, 359), -2);
}
TEST_F(PIDInputOutputTest, ProportionalGainOutput) {
controller->SetP(4);
TEST(PIDInputOutputTest, ProportionalGainOutput) {
frc::PIDController controller{0.0, 0.0, 0.0};
EXPECT_DOUBLE_EQ(-0.1, controller->Calculate(0.025, 0));
controller.SetP(4);
EXPECT_DOUBLE_EQ(-0.1, controller.Calculate(0.025, 0));
}
TEST_F(PIDInputOutputTest, IntegralGainOutput) {
controller->SetI(4);
TEST(PIDInputOutputTest, IntegralGainOutput) {
frc::PIDController controller{0.0, 0.0, 0.0};
controller.SetI(4);
double out = 0;
for (int i = 0; i < 5; i++) {
out = controller->Calculate(0.025, 0);
out = controller.Calculate(0.025, 0);
}
EXPECT_DOUBLE_EQ(-0.5 * controller->GetPeriod().value(), out);
EXPECT_DOUBLE_EQ(-0.5 * controller.GetPeriod().value(), out);
}
TEST_F(PIDInputOutputTest, DerivativeGainOutput) {
controller->SetD(4);
TEST(PIDInputOutputTest, DerivativeGainOutput) {
frc::PIDController controller{0.0, 0.0, 0.0};
controller->Calculate(0, 0);
controller.SetD(4);
EXPECT_DOUBLE_EQ(-10_ms / controller->GetPeriod(),
controller->Calculate(0.0025, 0));
controller.Calculate(0, 0);
EXPECT_DOUBLE_EQ(-10_ms / controller.GetPeriod(),
controller.Calculate(0.0025, 0));
}
TEST_F(PIDInputOutputTest, IZoneNoOutput) {
controller->SetI(1);
controller->SetIZone(1);
TEST(PIDInputOutputTest, IZoneNoOutput) {
frc::PIDController controller{0.0, 0.0, 0.0};
double out = controller->Calculate(2, 0);
controller.SetI(1);
controller.SetIZone(1);
double out = controller.Calculate(2, 0);
EXPECT_DOUBLE_EQ(0, out);
}
TEST_F(PIDInputOutputTest, IZoneOutput) {
controller->SetI(1);
controller->SetIZone(1);
TEST(PIDInputOutputTest, IZoneOutput) {
frc::PIDController controller{0.0, 0.0, 0.0};
double out = controller->Calculate(1, 0);
controller.SetI(1);
controller.SetIZone(1);
EXPECT_DOUBLE_EQ(-1 * controller->GetPeriod().value(), out);
double out = controller.Calculate(1, 0);
EXPECT_DOUBLE_EQ(-1 * controller.GetPeriod().value(), out);
}

109
wpimath/src/test/native/cpp/controller/ProfiledPIDInputOutputTest.cpp
View File

@@ -11,108 +11,117 @@
#include "units/angular_acceleration.h"
#include "units/angular_velocity.h"
class ProfiledPIDInputOutputTest : public testing::Test {
protected:
frc::ProfiledPIDController<units::degrees>* controller;
TEST(ProfiledPIDInputOutputTest, ContinuousInput1) {
frc::ProfiledPIDController<units::degree> controller{
0.0, 0.0, 0.0, {360_deg_per_s, 180_deg_per_s_sq}};
void SetUp() override {
controller = new frc::ProfiledPIDController<units::degrees>(
0, 0, 0, {360_deg_per_s, 180_deg_per_s_sq});
}
void TearDown() override { delete controller; }
};
TEST_F(ProfiledPIDInputOutputTest, ContinuousInput1) {
controller->SetP(1);
controller->EnableContinuousInput(-180_deg, 180_deg);
controller.SetP(1);
controller.EnableContinuousInput(-180_deg, 180_deg);
static constexpr units::degree_t kSetpoint{-179.0};
static constexpr units::degree_t kMeasurement{-179.0};
static constexpr units::degree_t kGoal{179.0};
controller->Reset(kSetpoint);
EXPECT_LT(controller->Calculate(kMeasurement, kGoal), 0.0);
controller.Reset(kSetpoint);
EXPECT_LT(controller.Calculate(kMeasurement, kGoal), 0.0);
// Error must be less than half the input range at all times
EXPECT_LT(units::math::abs(controller->GetSetpoint().position - kMeasurement),
EXPECT_LT(units::math::abs(controller.GetSetpoint().position - kMeasurement),
180_deg);
}
TEST_F(ProfiledPIDInputOutputTest, ContinuousInput2) {
controller->SetP(1);
controller->EnableContinuousInput(-units::radian_t{std::numbers::pi},
units::radian_t{std::numbers::pi});
TEST(ProfiledPIDInputOutputTest, ContinuousInput2) {
frc::ProfiledPIDController<units::degree> controller{
0.0, 0.0, 0.0, {360_deg_per_s, 180_deg_per_s_sq}};
controller.SetP(1);
controller.EnableContinuousInput(-units::radian_t{std::numbers::pi},
units::radian_t{std::numbers::pi});
static constexpr units::radian_t kSetpoint{-3.4826633343199735};
static constexpr units::radian_t kMeasurement{-3.1352207333939606};
static constexpr units::radian_t kGoal{-3.534162788601621};
controller->Reset(kSetpoint);
EXPECT_LT(controller->Calculate(kMeasurement, kGoal), 0.0);
controller.Reset(kSetpoint);
EXPECT_LT(controller.Calculate(kMeasurement, kGoal), 0.0);
// Error must be less than half the input range at all times
EXPECT_LT(units::math::abs(controller->GetSetpoint().position - kMeasurement),
EXPECT_LT(units::math::abs(controller.GetSetpoint().position - kMeasurement),
units::radian_t{std::numbers::pi});
}
TEST_F(ProfiledPIDInputOutputTest, ContinuousInput3) {
controller->SetP(1);
controller->EnableContinuousInput(-units::radian_t{std::numbers::pi},
units::radian_t{std::numbers::pi});
TEST(ProfiledPIDInputOutputTest, ContinuousInput3) {
frc::ProfiledPIDController<units::degree> controller{
0.0, 0.0, 0.0, {360_deg_per_s, 180_deg_per_s_sq}};
controller.SetP(1);
controller.EnableContinuousInput(-units::radian_t{std::numbers::pi},
units::radian_t{std::numbers::pi});
static constexpr units::radian_t kSetpoint{-3.5176604690006377};
static constexpr units::radian_t kMeasurement{3.1191729343822456};
static constexpr units::radian_t kGoal{2.709680418117445};
controller->Reset(kSetpoint);
EXPECT_LT(controller->Calculate(kMeasurement, kGoal), 0.0);
controller.Reset(kSetpoint);
EXPECT_LT(controller.Calculate(kMeasurement, kGoal), 0.0);
// Error must be less than half the input range at all times
EXPECT_LT(units::math::abs(controller->GetSetpoint().position - kMeasurement),
EXPECT_LT(units::math::abs(controller.GetSetpoint().position - kMeasurement),
units::radian_t{std::numbers::pi});
}
TEST_F(ProfiledPIDInputOutputTest, ContinuousInput4) {
controller->SetP(1);
controller->EnableContinuousInput(0_rad,
units::radian_t{2.0 * std::numbers::pi});
TEST(ProfiledPIDInputOutputTest, ContinuousInput4) {
frc::ProfiledPIDController<units::degree> controller{
0.0, 0.0, 0.0, {360_deg_per_s, 180_deg_per_s_sq}};
controller.SetP(1);
controller.EnableContinuousInput(0_rad,
units::radian_t{2.0 * std::numbers::pi});
static constexpr units::radian_t kSetpoint{2.78};
static constexpr units::radian_t kMeasurement{3.12};
static constexpr units::radian_t kGoal{2.71};
controller->Reset(kSetpoint);
EXPECT_LT(controller->Calculate(kMeasurement, kGoal), 0.0);
controller.Reset(kSetpoint);
EXPECT_LT(controller.Calculate(kMeasurement, kGoal), 0.0);
// Error must be less than half the input range at all times
EXPECT_LT(units::math::abs(controller->GetSetpoint().position - kMeasurement),
EXPECT_LT(units::math::abs(controller.GetSetpoint().position - kMeasurement),
units::radian_t{std::numbers::pi});
}
TEST_F(ProfiledPIDInputOutputTest, ProportionalGainOutput) {
controller->SetP(4);
TEST(ProfiledPIDInputOutputTest, ProportionalGainOutput) {
frc::ProfiledPIDController<units::degree> controller{
0.0, 0.0, 0.0, {360_deg_per_s, 180_deg_per_s_sq}};
EXPECT_DOUBLE_EQ(-0.1, controller->Calculate(0.025_deg, 0_deg));
controller.SetP(4);
EXPECT_DOUBLE_EQ(-0.1, controller.Calculate(0.025_deg, 0_deg));
}
TEST_F(ProfiledPIDInputOutputTest, IntegralGainOutput) {
controller->SetI(4);
TEST(ProfiledPIDInputOutputTest, IntegralGainOutput) {
frc::ProfiledPIDController<units::degree> controller{
0.0, 0.0, 0.0, {360_deg_per_s, 180_deg_per_s_sq}};
controller.SetI(4);
double out = 0;
for (int i = 0; i < 5; i++) {
out = controller->Calculate(0.025_deg, 0_deg);
out = controller.Calculate(0.025_deg, 0_deg);
}
EXPECT_DOUBLE_EQ(-0.5 * controller->GetPeriod().value(), out);
EXPECT_DOUBLE_EQ(-0.5 * controller.GetPeriod().value(), out);
}
TEST_F(ProfiledPIDInputOutputTest, DerivativeGainOutput) {
controller->SetD(4);
TEST(ProfiledPIDInputOutputTest, DerivativeGainOutput) {
frc::ProfiledPIDController<units::degree> controller{
0.0, 0.0, 0.0, {360_deg_per_s, 180_deg_per_s_sq}};
controller->Calculate(0_deg, 0_deg);
controller.SetD(4);
EXPECT_DOUBLE_EQ(-10_ms / controller->GetPeriod(),
controller->Calculate(0.0025_deg, 0_deg));
controller.Calculate(0_deg, 0_deg);
EXPECT_DOUBLE_EQ(-10_ms / controller.GetPeriod(),
controller.Calculate(0.0025_deg, 0_deg));
}