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

SCRIPT namespace replacements

Browse Source
This commit is contained in:
PJ Reiniger
2025-11-07 20:00:05 -05:00
committed by Peter Johnson
parent ae6c043632
commit 9aca8e0fd6
2622 changed files with 22275 additions and 22275 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
wpimath/src/test/native/cpp/trajectory/CentripetalAccelerationConstraintTest.cpp
View File

@@ -15,7 +15,7 @@
#include "wpi/units/math.hpp"
#include "wpi/units/velocity.hpp"
using namespace frc;
using namespace wpi::math;
TEST(CentripetalAccelerationConstraintTest, Constraint) {
const auto maxCentripetalAcceleration = 7_fps_sq;
@@ -26,16 +26,16 @@ TEST(CentripetalAccelerationConstraintTest, Constraint) {
auto trajectory = TestTrajectory::GetTrajectory(config);
units::second_t time = 0_s;
units::second_t dt = 20_ms;
units::second_t duration = trajectory.TotalTime();
wpi::units::second_t time = 0_s;
wpi::units::second_t dt = 20_ms;
wpi::units::second_t duration = trajectory.TotalTime();
while (time < duration) {
const Trajectory::State point = trajectory.Sample(time);
time += dt;
auto centripetalAcceleration =
units::math::pow<2>(point.velocity) * point.curvature / 1_rad;
wpi::units::math::pow<2>(point.velocity) * point.curvature / 1_rad;
EXPECT_TRUE(centripetalAcceleration <
maxCentripetalAcceleration + 0.05_mps_sq);

8
wpimath/src/test/native/cpp/trajectory/DifferentialDriveKinematicsTest.cpp
View File

@@ -12,7 +12,7 @@
#include "wpi/math/trajectory/constraint/DifferentialDriveKinematicsConstraint.hpp"
#include "wpi/units/time.hpp"
using namespace frc;
using namespace wpi::math;
TEST(DifferentialDriveKinematicsConstraintTest, Constraint) {
const auto maxVelocity = 12_fps;
@@ -24,9 +24,9 @@ TEST(DifferentialDriveKinematicsConstraintTest, Constraint) {
auto trajectory = TestTrajectory::GetTrajectory(config);
units::second_t time = 0_s;
units::second_t dt = 20_ms;
units::second_t duration = trajectory.TotalTime();
wpi::units::second_t time = 0_s;
wpi::units::second_t dt = 20_ms;
wpi::units::second_t duration = trajectory.TotalTime();
while (time < duration) {
const Trajectory::State point = trajectory.Sample(time);

12
wpimath/src/test/native/cpp/trajectory/DifferentialDriveVoltageTest.cpp
View File

@@ -18,11 +18,11 @@
#include "wpi/units/velocity.hpp"
#include "wpi/units/voltage.hpp"
using namespace frc;
using namespace wpi::math;
TEST(DifferentialDriveVoltageConstraintTest, Constraint) {
// Pick an unreasonably large kA to ensure the constraint has to do some work
SimpleMotorFeedforward<units::meter> feedforward{1_V, 1_V / 1_mps,
SimpleMotorFeedforward<wpi::units::meter> feedforward{1_V, 1_V / 1_mps,
3_V / 1_mps_sq};
const DifferentialDriveKinematics kinematics{0.5_m};
const auto maxVoltage = 10_V;
@@ -33,9 +33,9 @@ TEST(DifferentialDriveVoltageConstraintTest, Constraint) {
auto trajectory = TestTrajectory::GetTrajectory(config);
units::second_t time = 0_s;
units::second_t dt = 20_ms;
units::second_t duration = trajectory.TotalTime();
wpi::units::second_t time = 0_s;
wpi::units::second_t dt = 20_ms;
wpi::units::second_t duration = trajectory.TotalTime();
while (time < duration) {
const Trajectory::State point = trajectory.Sample(time);
@@ -63,7 +63,7 @@ TEST(DifferentialDriveVoltageConstraintTest, Constraint) {
}
TEST(DifferentialDriveVoltageConstraintTest, HighCurvature) {
SimpleMotorFeedforward<units::meter> feedforward{1_V, 1_V / 1_mps,
SimpleMotorFeedforward<wpi::units::meter> feedforward{1_V, 1_V / 1_mps,
3_V / 1_mps_sq};
// Large trackwidth - need to test with radius of curvature less than half of
// trackwidth

8
wpimath/src/test/native/cpp/trajectory/EllipticalRegionConstraintTest.cpp
View File

@@ -12,11 +12,11 @@
#include "wpi/units/length.hpp"
#include "wpi/units/velocity.hpp"
using namespace frc;
using namespace wpi::math;
TEST(EllipticalRegionConstraintTest, Constraint) {
constexpr auto maxVelocity = 2_fps;
constexpr frc::Ellipse2d ellipse{{5_ft, 2.5_ft, 180_deg}, 5_ft, 2.5_ft};
constexpr wpi::math::Ellipse2d ellipse{{5_ft, 2.5_ft, 180_deg}, 5_ft, 2.5_ft};
auto config = TrajectoryConfig(13_fps, 13_fps_sq);
config.AddConstraint(
@@ -26,8 +26,8 @@ TEST(EllipticalRegionConstraintTest, Constraint) {
bool exceededConstraintOutsideRegion = false;
for (auto& point : trajectory.States()) {
if (ellipse.Contains(point.pose.Translation())) {
EXPECT_TRUE(units::math::abs(point.velocity) < maxVelocity + 0.05_mps);
} else if (units::math::abs(point.velocity) >= maxVelocity + 0.05_mps) {
EXPECT_TRUE(wpi::units::math::abs(point.velocity) < maxVelocity + 0.05_mps);
} else if (wpi::units::math::abs(point.velocity) >= maxVelocity + 0.05_mps) {
exceededConstraintOutsideRegion = true;
}
}

158
wpimath/src/test/native/cpp/trajectory/ExponentialProfileTest.cpp
View File

@@ -24,7 +24,7 @@ static constexpr auto kV = 2.5629_V / 1_mps;
static constexpr auto kA = 0.43277_V / 1_mps_sq;
#define EXPECT_NEAR_UNITS(val1, val2, eps) \
EXPECT_LE(units::math::abs(val1 - val2), eps)
EXPECT_LE(wpi::units::math::abs(val1 - val2), eps)
#define EXPECT_LT_OR_NEAR_UNITS(val1, val2, eps) \
if (val1 <= val2) { \
@@ -33,29 +33,29 @@ static constexpr auto kA = 0.43277_V / 1_mps_sq;
EXPECT_NEAR_UNITS(val1, val2, eps); \
}
frc::ExponentialProfile<units::meter, units::volts>::State CheckDynamics(
frc::ExponentialProfile<units::meter, units::volts> profile,
frc::ExponentialProfile<units::meter, units::volts>::Constraints
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::State CheckDynamics(
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts> profile,
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::Constraints
constraints,
frc::SimpleMotorFeedforward<units::meter> feedforward,
frc::ExponentialProfile<units::meter, units::volts>::State current,
frc::ExponentialProfile<units::meter, units::volts>::State goal) {
wpi::math::SimpleMotorFeedforward<wpi::units::meter> feedforward,
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::State current,
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::State goal) {
auto next = profile.Calculate(kDt, current, goal);
auto signal = feedforward.Calculate(current.velocity, next.velocity);
EXPECT_LE(units::math::abs(signal), (constraints.maxInput + 1e-9_V));
EXPECT_LE(wpi::units::math::abs(signal), (constraints.maxInput + 1e-9_V));
return next;
}
TEST(ExponentialProfileTest, ReachesGoal) {
frc::ExponentialProfile<units::meter, units::volts>::Constraints constraints{
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::Constraints constraints{
12_V, -kV / kA, 1 / kA};
frc::ExponentialProfile<units::meter, units::volts> profile{constraints};
frc::SimpleMotorFeedforward<units::meter> feedforward{
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts> profile{constraints};
wpi::math::SimpleMotorFeedforward<wpi::units::meter> feedforward{
0_V, 2.5629_V / 1_mps, 0.43277_V / 1_mps_sq, kDt};
frc::ExponentialProfile<units::meter, units::volts>::State goal{10_m, 0_mps};
frc::ExponentialProfile<units::meter, units::volts>::State state{0_m, 0_mps};
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::State goal{10_m, 0_mps};
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::State state{0_m, 0_mps};
for (int i = 0; i < 450; ++i) {
state = CheckDynamics(profile, constraints, feedforward, state, goal);
@@ -66,19 +66,19 @@ TEST(ExponentialProfileTest, ReachesGoal) {
// Tests that decreasing the maximum velocity in the middle when it is already
// moving faster than the new max is handled correctly
TEST(ExponentialProfileTest, PosContinuousUnderVelChange) {
frc::ExponentialProfile<units::meter, units::volts>::Constraints constraints{
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::Constraints constraints{
12_V, -kV / kA, 1 / kA};
frc::ExponentialProfile<units::meter, units::volts> profile{constraints};
frc::SimpleMotorFeedforward<units::meter> feedforward{
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts> profile{constraints};
wpi::math::SimpleMotorFeedforward<wpi::units::meter> feedforward{
0_V, 2.5629_V / 1_mps, 0.43277_V / 1_mps_sq, kDt};
frc::ExponentialProfile<units::meter, units::volts>::State goal{10_m, 0_mps};
frc::ExponentialProfile<units::meter, units::volts>::State state{0_m, 0_mps};
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::State goal{10_m, 0_mps};
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::State state{0_m, 0_mps};
for (int i = 0; i < 300; ++i) {
if (i == 150) {
constraints.maxInput = 9_V;
profile =
frc::ExponentialProfile<units::meter, units::volts>{constraints};
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>{constraints};
}
state = CheckDynamics(profile, constraints, feedforward, state, goal);
@@ -89,19 +89,19 @@ TEST(ExponentialProfileTest, PosContinuousUnderVelChange) {
// Tests that decreasing the maximum velocity in the middle when it is already
// moving faster than the new max is handled correctly
TEST(ExponentialProfileTest, PosContinuousUnderVelChangeBackward) {
frc::ExponentialProfile<units::meter, units::volts>::Constraints constraints{
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::Constraints constraints{
12_V, -kV / kA, 1 / kA};
frc::ExponentialProfile<units::meter, units::volts> profile{constraints};
frc::SimpleMotorFeedforward<units::meter> feedforward{
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts> profile{constraints};
wpi::math::SimpleMotorFeedforward<wpi::units::meter> feedforward{
0_V, 2.5629_V / 1_mps, 0.43277_V / 1_mps_sq, kDt};
frc::ExponentialProfile<units::meter, units::volts>::State goal{-10_m, 0_mps};
frc::ExponentialProfile<units::meter, units::volts>::State state{0_m, 0_mps};
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::State goal{-10_m, 0_mps};
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::State state{0_m, 0_mps};
for (int i = 0; i < 300; ++i) {
if (i == 150) {
constraints.maxInput = 9_V;
profile =
frc::ExponentialProfile<units::meter, units::volts>{constraints};
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>{constraints};
}
state = CheckDynamics(profile, constraints, feedforward, state, goal);
@@ -111,13 +111,13 @@ TEST(ExponentialProfileTest, PosContinuousUnderVelChangeBackward) {
// There is some somewhat tricky code for dealing with going backwards
TEST(ExponentialProfileTest, Backwards) {
frc::ExponentialProfile<units::meter, units::volts>::Constraints constraints{
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::Constraints constraints{
12_V, -kV / kA, 1 / kA};
frc::ExponentialProfile<units::meter, units::volts> profile{constraints};
frc::SimpleMotorFeedforward<units::meter> feedforward{
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts> profile{constraints};
wpi::math::SimpleMotorFeedforward<wpi::units::meter> feedforward{
0_V, 2.5629_V / 1_mps, 0.43277_V / 1_mps_sq, kDt};
frc::ExponentialProfile<units::meter, units::volts>::State goal{-10_m, 0_mps};
frc::ExponentialProfile<units::meter, units::volts>::State state;
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::State goal{-10_m, 0_mps};
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::State state;
for (int i = 0; i < 400; ++i) {
state = CheckDynamics(profile, constraints, feedforward, state, goal);
@@ -126,13 +126,13 @@ TEST(ExponentialProfileTest, Backwards) {
}
TEST(ExponentialProfileTest, SwitchGoalInMiddle) {
frc::ExponentialProfile<units::meter, units::volts>::Constraints constraints{
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::Constraints constraints{
12_V, -kV / kA, 1 / kA};
frc::ExponentialProfile<units::meter, units::volts> profile{constraints};
frc::SimpleMotorFeedforward<units::meter> feedforward{
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts> profile{constraints};
wpi::math::SimpleMotorFeedforward<wpi::units::meter> feedforward{
0_V, 2.5629_V / 1_mps, 0.43277_V / 1_mps_sq, kDt};
frc::ExponentialProfile<units::meter, units::volts>::State goal{-10_m, 0_mps};
frc::ExponentialProfile<units::meter, units::volts>::State state{0_m, 0_mps};
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::State goal{-10_m, 0_mps};
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::State state{0_m, 0_mps};
for (int i = 0; i < 50; ++i) {
state = CheckDynamics(profile, constraints, feedforward, state, goal);
@@ -148,19 +148,19 @@ TEST(ExponentialProfileTest, SwitchGoalInMiddle) {
// Checks to make sure that it hits top speed on long trajectories
TEST(ExponentialProfileTest, TopSpeed) {
frc::ExponentialProfile<units::meter, units::volts>::Constraints constraints{
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::Constraints constraints{
12_V, -kV / kA, 1 / kA};
frc::ExponentialProfile<units::meter, units::volts> profile{constraints};
frc::SimpleMotorFeedforward<units::meter> feedforward{
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts> profile{constraints};
wpi::math::SimpleMotorFeedforward<wpi::units::meter> feedforward{
0_V, 2.5629_V / 1_mps, 0.43277_V / 1_mps_sq, kDt};
frc::ExponentialProfile<units::meter, units::volts>::State goal{40_m, 0_mps};
frc::ExponentialProfile<units::meter, units::volts>::State state;
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::State goal{40_m, 0_mps};
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::State state;
units::meters_per_second_t maxSpeed = 0_mps;
wpi::units::meters_per_second_t maxSpeed = 0_mps;
for (int i = 0; i < 900; ++i) {
state = CheckDynamics(profile, constraints, feedforward, state, goal);
maxSpeed = units::math::max(state.velocity, maxSpeed);
maxSpeed = wpi::units::math::max(state.velocity, maxSpeed);
}
EXPECT_NEAR_UNITS(constraints.MaxVelocity(), maxSpeed, 1e-5_mps);
@@ -169,19 +169,19 @@ TEST(ExponentialProfileTest, TopSpeed) {
// Checks to make sure that it hits top speed on long trajectories
TEST(ExponentialProfileTest, TopSpeedBackward) {
frc::ExponentialProfile<units::meter, units::volts>::Constraints constraints{
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::Constraints constraints{
12_V, -kV / kA, 1 / kA};
frc::ExponentialProfile<units::meter, units::volts> profile{constraints};
frc::SimpleMotorFeedforward<units::meter> feedforward{
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts> profile{constraints};
wpi::math::SimpleMotorFeedforward<wpi::units::meter> feedforward{
0_V, 2.5629_V / 1_mps, 0.43277_V / 1_mps_sq, kDt};
frc::ExponentialProfile<units::meter, units::volts>::State goal{-40_m, 0_mps};
frc::ExponentialProfile<units::meter, units::volts>::State state;
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::State goal{-40_m, 0_mps};
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::State state;
units::meters_per_second_t maxSpeed = 0_mps;
wpi::units::meters_per_second_t maxSpeed = 0_mps;
for (int i = 0; i < 900; ++i) {
state = CheckDynamics(profile, constraints, feedforward, state, goal);
maxSpeed = units::math::min(state.velocity, maxSpeed);
maxSpeed = wpi::units::math::min(state.velocity, maxSpeed);
}
EXPECT_NEAR_UNITS(-constraints.MaxVelocity(), maxSpeed, 1e-5_mps);
@@ -190,13 +190,13 @@ TEST(ExponentialProfileTest, TopSpeedBackward) {
// Checks to make sure that it hits top speed on long trajectories
TEST(ExponentialProfileTest, HighInitialSpeed) {
frc::ExponentialProfile<units::meter, units::volts>::Constraints constraints{
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::Constraints constraints{
12_V, -kV / kA, 1 / kA};
frc::ExponentialProfile<units::meter, units::volts> profile{constraints};
frc::SimpleMotorFeedforward<units::meter> feedforward{
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts> profile{constraints};
wpi::math::SimpleMotorFeedforward<wpi::units::meter> feedforward{
0_V, 2.5629_V / 1_mps, 0.43277_V / 1_mps_sq, kDt};
frc::ExponentialProfile<units::meter, units::volts>::State goal{40_m, 0_mps};
frc::ExponentialProfile<units::meter, units::volts>::State state{0_m, 8_mps};
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::State goal{40_m, 0_mps};
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::State state{0_m, 8_mps};
for (int i = 0; i < 900; ++i) {
state = CheckDynamics(profile, constraints, feedforward, state, goal);
@@ -207,13 +207,13 @@ TEST(ExponentialProfileTest, HighInitialSpeed) {
// Checks to make sure that it hits top speed on long trajectories
TEST(ExponentialProfileTest, HighInitialSpeedBackward) {
frc::ExponentialProfile<units::meter, units::volts>::Constraints constraints{
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::Constraints constraints{
12_V, -kV / kA, 1 / kA};
frc::ExponentialProfile<units::meter, units::volts> profile{constraints};
frc::SimpleMotorFeedforward<units::meter> feedforward{
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts> profile{constraints};
wpi::math::SimpleMotorFeedforward<wpi::units::meter> feedforward{
0_V, 2.5629_V / 1_mps, 0.43277_V / 1_mps_sq, kDt};
frc::ExponentialProfile<units::meter, units::volts>::State goal{-40_m, 0_mps};
frc::ExponentialProfile<units::meter, units::volts>::State state{0_m, -8_mps};
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::State goal{-40_m, 0_mps};
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::State state{0_m, -8_mps};
for (int i = 0; i < 900; ++i) {
state = CheckDynamics(profile, constraints, feedforward, state, goal);
@@ -223,13 +223,13 @@ TEST(ExponentialProfileTest, HighInitialSpeedBackward) {
}
TEST(ExponentialProfileTest, TestHeuristic) {
frc::ExponentialProfile<units::meter, units::volts>::Constraints constraints{
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::Constraints constraints{
12_V, -kV / kA, 1 / kA};
frc::ExponentialProfile<units::meter, units::volts> profile{constraints};
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts> profile{constraints};
std::vector<std::tuple<
frc::ExponentialProfile<units::meter, units::volts>::State, // initial
frc::ExponentialProfile<units::meter, units::volts>::State, // goal
frc::ExponentialProfile<units::meter, units::volts>::State> // inflection
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::State, // initial
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::State, // goal
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::State> // inflection
// point
>
testCases{
@@ -275,13 +275,13 @@ TEST(ExponentialProfileTest, TestHeuristic) {
}
TEST(ExponentialProfileTest, TimingToCurrent) {
frc::ExponentialProfile<units::meter, units::volts>::Constraints constraints{
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::Constraints constraints{
12_V, -kV / kA, 1 / kA};
frc::ExponentialProfile<units::meter, units::volts> profile{constraints};
frc::SimpleMotorFeedforward<units::meter> feedforward{
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts> profile{constraints};
wpi::math::SimpleMotorFeedforward<wpi::units::meter> feedforward{
0_V, 2.5629_V / 1_mps, 0.43277_V / 1_mps_sq, kDt};
frc::ExponentialProfile<units::meter, units::volts>::State goal{2_m, 0_mps};
frc::ExponentialProfile<units::meter, units::volts>::State state{0_m, 0_mps};
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::State goal{2_m, 0_mps};
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::State state{0_m, 0_mps};
for (int i = 0; i < 900; ++i) {
state = CheckDynamics(profile, constraints, feedforward, state, goal);
@@ -292,13 +292,13 @@ TEST(ExponentialProfileTest, TimingToCurrent) {
}
TEST(ExponentialProfileTest, TimingToGoal) {
frc::ExponentialProfile<units::meter, units::volts>::Constraints constraints{
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::Constraints constraints{
12_V, -kV / kA, 1 / kA};
frc::ExponentialProfile<units::meter, units::volts> profile{constraints};
frc::SimpleMotorFeedforward<units::meter> feedforward{
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts> profile{constraints};
wpi::math::SimpleMotorFeedforward<wpi::units::meter> feedforward{
0_V, 2.5629_V / 1_mps, 0.43277_V / 1_mps_sq, kDt};
frc::ExponentialProfile<units::meter, units::volts>::State goal{2_m, 0_mps};
frc::ExponentialProfile<units::meter, units::volts>::State state{0_m, 0_mps};
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::State goal{2_m, 0_mps};
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::State state{0_m, 0_mps};
auto prediction = profile.TimeLeftUntil(state, goal);
auto reachedGoal = false;
@@ -315,13 +315,13 @@ TEST(ExponentialProfileTest, TimingToGoal) {
}
TEST(ExponentialProfileTest, TimingToNegativeGoal) {
frc::ExponentialProfile<units::meter, units::volts>::Constraints constraints{
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::Constraints constraints{
12_V, -kV / kA, 1 / kA};
frc::ExponentialProfile<units::meter, units::volts> profile{constraints};
frc::SimpleMotorFeedforward<units::meter> feedforward{
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts> profile{constraints};
wpi::math::SimpleMotorFeedforward<wpi::units::meter> feedforward{
0_V, 2.5629_V / 1_mps, 0.43277_V / 1_mps_sq, kDt};
frc::ExponentialProfile<units::meter, units::volts>::State goal{-2_m, 0_mps};
frc::ExponentialProfile<units::meter, units::volts>::State state{0_m, 0_mps};
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::State goal{-2_m, 0_mps};
wpi::math::ExponentialProfile<wpi::units::meter, wpi::units::volts>::State state{0_m, 0_mps};
auto prediction = profile.TimeLeftUntil(state, goal);
auto reachedGoal = false;

8
wpimath/src/test/native/cpp/trajectory/RectangularRegionConstraintTest.cpp
View File

@@ -12,11 +12,11 @@
#include "wpi/units/math.hpp"
#include "wpi/units/velocity.hpp"
using namespace frc;
using namespace wpi::math;
TEST(RectangularRegionConstraintTest, Constraint) {
constexpr auto maxVelocity = 2_fps;
constexpr frc::Rectangle2d rectangle{{1_ft, 1_ft}, {5_ft, 27_ft}};
constexpr wpi::math::Rectangle2d rectangle{{1_ft, 1_ft}, {5_ft, 27_ft}};
auto config = TrajectoryConfig(13_fps, 13_fps_sq);
config.AddConstraint(RectangularRegionConstraint{
@@ -26,8 +26,8 @@ TEST(RectangularRegionConstraintTest, Constraint) {
bool exceededConstraintOutsideRegion = false;
for (auto& point : trajectory.States()) {
if (rectangle.Contains(point.pose.Translation())) {
EXPECT_TRUE(units::math::abs(point.velocity) < maxVelocity + 0.05_mps);
} else if (units::math::abs(point.velocity) >= maxVelocity + 0.05_mps) {
EXPECT_TRUE(wpi::units::math::abs(point.velocity) < maxVelocity + 0.05_mps);
} else if (wpi::units::math::abs(point.velocity) >= maxVelocity + 0.05_mps) {
exceededConstraintOutsideRegion = true;
}
}

4
wpimath/src/test/native/cpp/trajectory/TrajectoryConcatenateTest.cpp
View File

@@ -8,9 +8,9 @@
#include "wpi/math/trajectory/TrajectoryGenerator.hpp"
TEST(TrajectoryConcatenateTest, States) {
auto t1 = frc::TrajectoryGenerator::GenerateTrajectory(
auto t1 = wpi::math::TrajectoryGenerator::GenerateTrajectory(
{}, {}, {1_m, 1_m, 0_deg}, {2_mps, 2_mps_sq});
auto t2 = frc::TrajectoryGenerator::GenerateTrajectory(
auto t2 = wpi::math::TrajectoryGenerator::GenerateTrajectory(
{1_m, 1_m, 0_deg}, {}, {2_m, 2_m, 45_deg}, {2_mps, 2_mps_sq});
auto t = t1 + t2;

12
wpimath/src/test/native/cpp/trajectory/TrajectoryGeneratorTest.cpp
View File

@@ -13,22 +13,22 @@
#include "wpi/math/trajectory/constraint/TrajectoryConstraint.hpp"
#include "wpi/units/math.hpp"
using namespace frc;
using namespace wpi::math;
TEST(TrajectoryGenerationTest, ObeysConstraints) {
TrajectoryConfig config{12_fps, 12_fps_sq};
auto trajectory = TestTrajectory::GetTrajectory(config);
units::second_t time = 0_s;
units::second_t dt = 20_ms;
units::second_t duration = trajectory.TotalTime();
wpi::units::second_t time = 0_s;
wpi::units::second_t dt = 20_ms;
wpi::units::second_t duration = trajectory.TotalTime();
while (time < duration) {
const Trajectory::State point = trajectory.Sample(time);
time += dt;
EXPECT_TRUE(units::math::abs(point.velocity) <= 12_fps + 0.01_fps);
EXPECT_TRUE(units::math::abs(point.acceleration) <=
EXPECT_TRUE(wpi::units::math::abs(point.velocity) <= 12_fps + 0.01_fps);
EXPECT_TRUE(wpi::units::math::abs(point.acceleration) <=
12_fps_sq + 0.01_fps_sq);
}
}

16
wpimath/src/test/native/cpp/trajectory/TrajectoryTransformTest.cpp
View File

@@ -10,8 +10,8 @@
#include "wpi/math/trajectory/TrajectoryConfig.hpp"
#include "wpi/math/trajectory/TrajectoryGenerator.hpp"
void TestSameShapedTrajectory(std::vector<frc::Trajectory::State> statesA,
std::vector<frc::Trajectory::State> statesB) {
void TestSameShapedTrajectory(std::vector<wpi::math::Trajectory::State> statesA,
std::vector<wpi::math::Trajectory::State> statesB) {
for (unsigned int i = 0; i < statesA.size() - 1; i++) {
auto a1 = statesA[i].pose;
auto a2 = statesA[i + 1].pose;
@@ -30,9 +30,9 @@ void TestSameShapedTrajectory(std::vector<frc::Trajectory::State> statesA,
}
TEST(TrajectoryTransformsTest, TransformBy) {
frc::TrajectoryConfig config{3_mps, 3_mps_sq};
auto trajectory = frc::TrajectoryGenerator::GenerateTrajectory(
frc::Pose2d{}, {}, frc::Pose2d{1_m, 1_m, 90_deg}, config);
wpi::math::TrajectoryConfig config{3_mps, 3_mps_sq};
auto trajectory = wpi::math::TrajectoryGenerator::GenerateTrajectory(
wpi::math::Pose2d{}, {}, wpi::math::Pose2d{1_m, 1_m, 90_deg}, config);
auto transformedTrajectory = trajectory.TransformBy({{1_m, 2_m}, 30_deg});
@@ -46,9 +46,9 @@ TEST(TrajectoryTransformsTest, TransformBy) {
}
TEST(TrajectoryTransformsTest, RelativeTo) {
frc::TrajectoryConfig config{3_mps, 3_mps_sq};
auto trajectory = frc::TrajectoryGenerator::GenerateTrajectory(
frc::Pose2d{1_m, 2_m, 30_deg}, {}, frc::Pose2d{5_m, 7_m, 90_deg}, config);
wpi::math::TrajectoryConfig config{3_mps, 3_mps_sq};
auto trajectory = wpi::math::TrajectoryGenerator::GenerateTrajectory(
wpi::math::Pose2d{1_m, 2_m, 30_deg}, {}, wpi::math::Pose2d{5_m, 7_m, 90_deg}, config);
auto transformedTrajectory = trajectory.RelativeTo({1_m, 2_m, 30_deg});

140
wpimath/src/test/native/cpp/trajectory/TrapezoidProfileTest.cpp
View File

@@ -17,7 +17,7 @@
static constexpr auto kDt = 10_ms;
#define EXPECT_NEAR_UNITS(val1, val2, eps) \
EXPECT_LE(units::math::abs(val1 - val2), eps)
EXPECT_LE(wpi::units::math::abs(val1 - val2), eps)
#define EXPECT_LT_OR_NEAR_UNITS(val1, val2, eps) \
if (val1 <= val2) { \
@@ -27,12 +27,12 @@ static constexpr auto kDt = 10_ms;
}
TEST(TrapezoidProfileTest, ReachesGoal) {
frc::TrapezoidProfile<units::meter>::Constraints constraints{1.75_mps,
wpi::math::TrapezoidProfile<wpi::units::meter>::Constraints constraints{1.75_mps,
0.75_mps_sq};
frc::TrapezoidProfile<units::meter>::State goal{3_m, 0_mps};
frc::TrapezoidProfile<units::meter>::State state;
wpi::math::TrapezoidProfile<wpi::units::meter>::State goal{3_m, 0_mps};
wpi::math::TrapezoidProfile<wpi::units::meter>::State state;
frc::TrapezoidProfile<units::meter> profile{constraints};
wpi::math::TrapezoidProfile<wpi::units::meter> profile{constraints};
for (int i = 0; i < 450; ++i) {
state = profile.Calculate(kDt, state, goal);
}
@@ -42,19 +42,19 @@ TEST(TrapezoidProfileTest, ReachesGoal) {
// Tests that decreasing the maximum velocity in the middle when it is already
// moving faster than the new max is handled correctly
TEST(TrapezoidProfileTest, PosContinuousUnderVelChange) {
frc::TrapezoidProfile<units::meter>::Constraints constraints{1.75_mps,
wpi::math::TrapezoidProfile<wpi::units::meter>::Constraints constraints{1.75_mps,
0.75_mps_sq};
frc::TrapezoidProfile<units::meter>::State goal{12_m, 0_mps};
wpi::math::TrapezoidProfile<wpi::units::meter>::State goal{12_m, 0_mps};
frc::TrapezoidProfile<units::meter> profile{constraints};
wpi::math::TrapezoidProfile<wpi::units::meter> profile{constraints};
auto state = profile.Calculate(
kDt, frc::TrapezoidProfile<units::meter>::State{}, goal);
kDt, wpi::math::TrapezoidProfile<wpi::units::meter>::State{}, goal);
auto lastPos = state.position;
for (int i = 0; i < 1600; ++i) {
if (i == 400) {
constraints.maxVelocity = 0.75_mps;
profile = frc::TrapezoidProfile<units::meter>{constraints};
profile = wpi::math::TrapezoidProfile<wpi::units::meter>{constraints};
}
state = profile.Calculate(kDt, state, goal);
@@ -76,12 +76,12 @@ TEST(TrapezoidProfileTest, PosContinuousUnderVelChange) {
// There is some somewhat tricky code for dealing with going backwards
TEST(TrapezoidProfileTest, Backwards) {
frc::TrapezoidProfile<units::meter>::Constraints constraints{0.75_mps,
wpi::math::TrapezoidProfile<wpi::units::meter>::Constraints constraints{0.75_mps,
0.75_mps_sq};
frc::TrapezoidProfile<units::meter>::State goal{-2_m, 0_mps};
frc::TrapezoidProfile<units::meter>::State state;
wpi::math::TrapezoidProfile<wpi::units::meter>::State goal{-2_m, 0_mps};
wpi::math::TrapezoidProfile<wpi::units::meter>::State state;
frc::TrapezoidProfile<units::meter> profile{constraints};
wpi::math::TrapezoidProfile<wpi::units::meter> profile{constraints};
for (int i = 0; i < 400; ++i) {
state = profile.Calculate(kDt, state, goal);
}
@@ -89,19 +89,19 @@ TEST(TrapezoidProfileTest, Backwards) {
}
TEST(TrapezoidProfileTest, SwitchGoalInMiddle) {
frc::TrapezoidProfile<units::meter>::Constraints constraints{0.75_mps,
wpi::math::TrapezoidProfile<wpi::units::meter>::Constraints constraints{0.75_mps,
0.75_mps_sq};
frc::TrapezoidProfile<units::meter>::State goal{-2_m, 0_mps};
frc::TrapezoidProfile<units::meter>::State state;
wpi::math::TrapezoidProfile<wpi::units::meter>::State goal{-2_m, 0_mps};
wpi::math::TrapezoidProfile<wpi::units::meter>::State state;
frc::TrapezoidProfile<units::meter> profile{constraints};
wpi::math::TrapezoidProfile<wpi::units::meter> profile{constraints};
for (int i = 0; i < 200; ++i) {
state = profile.Calculate(kDt, state, goal);
}
EXPECT_NE(state, goal);
goal = {0.0_m, 0.0_mps};
profile = frc::TrapezoidProfile<units::meter>{constraints};
profile = wpi::math::TrapezoidProfile<wpi::units::meter>{constraints};
for (int i = 0; i < 550; ++i) {
state = profile.Calculate(kDt, state, goal);
}
@@ -110,18 +110,18 @@ TEST(TrapezoidProfileTest, SwitchGoalInMiddle) {
// Checks to make sure that it hits top speed
TEST(TrapezoidProfileTest, TopSpeed) {
frc::TrapezoidProfile<units::meter>::Constraints constraints{0.75_mps,
wpi::math::TrapezoidProfile<wpi::units::meter>::Constraints constraints{0.75_mps,
0.75_mps_sq};
frc::TrapezoidProfile<units::meter>::State goal{4_m, 0_mps};
frc::TrapezoidProfile<units::meter>::State state;
wpi::math::TrapezoidProfile<wpi::units::meter>::State goal{4_m, 0_mps};
wpi::math::TrapezoidProfile<wpi::units::meter>::State state;
frc::TrapezoidProfile<units::meter> profile{constraints};
wpi::math::TrapezoidProfile<wpi::units::meter> profile{constraints};
for (int i = 0; i < 200; ++i) {
state = profile.Calculate(kDt, state, goal);
}
EXPECT_NEAR_UNITS(constraints.maxVelocity, state.velocity, 10e-5_mps);
profile = frc::TrapezoidProfile<units::meter>{constraints};
profile = wpi::math::TrapezoidProfile<wpi::units::meter>{constraints};
for (int i = 0; i < 2000; ++i) {
state = profile.Calculate(kDt, state, goal);
}
@@ -129,12 +129,12 @@ TEST(TrapezoidProfileTest, TopSpeed) {
}
TEST(TrapezoidProfileTest, TimingToCurrent) {
frc::TrapezoidProfile<units::meter>::Constraints constraints{0.75_mps,
wpi::math::TrapezoidProfile<wpi::units::meter>::Constraints constraints{0.75_mps,
0.75_mps_sq};
frc::TrapezoidProfile<units::meter>::State goal{2_m, 0_mps};
frc::TrapezoidProfile<units::meter>::State state;
wpi::math::TrapezoidProfile<wpi::units::meter>::State goal{2_m, 0_mps};
wpi::math::TrapezoidProfile<wpi::units::meter>::State state;
frc::TrapezoidProfile<units::meter> profile{constraints};
wpi::math::TrapezoidProfile<wpi::units::meter> profile{constraints};
for (int i = 0; i < 400; i++) {
state = profile.Calculate(kDt, state, goal);
EXPECT_NEAR_UNITS(profile.TimeLeftUntil(state.position), 0_s, 2e-2_s);
@@ -142,15 +142,15 @@ TEST(TrapezoidProfileTest, TimingToCurrent) {
}
TEST(TrapezoidProfileTest, TimingToGoal) {
using units::unit_cast;
using wpi::units::unit_cast;
frc::TrapezoidProfile<units::meter>::Constraints constraints{0.75_mps,
wpi::math::TrapezoidProfile<wpi::units::meter>::Constraints constraints{0.75_mps,
0.75_mps_sq};
frc::TrapezoidProfile<units::meter>::State goal{2_m, 0_mps};
wpi::math::TrapezoidProfile<wpi::units::meter>::State goal{2_m, 0_mps};
frc::TrapezoidProfile<units::meter> profile{constraints};
wpi::math::TrapezoidProfile<wpi::units::meter> profile{constraints};
auto state = profile.Calculate(kDt, goal,
frc::TrapezoidProfile<units::meter>::State{});
wpi::math::TrapezoidProfile<wpi::units::meter>::State{});
auto predictedTimeLeft = profile.TimeLeftUntil(goal.position);
bool reachedGoal = false;
@@ -166,22 +166,22 @@ TEST(TrapezoidProfileTest, TimingToGoal) {
}
TEST(TrapezoidProfileTest, TimingBeforeGoal) {
using units::unit_cast;
using wpi::units::unit_cast;
frc::TrapezoidProfile<units::meter>::Constraints constraints{0.75_mps,
wpi::math::TrapezoidProfile<wpi::units::meter>::Constraints constraints{0.75_mps,
0.75_mps_sq};
frc::TrapezoidProfile<units::meter>::State goal{2_m, 0_mps};
wpi::math::TrapezoidProfile<wpi::units::meter>::State goal{2_m, 0_mps};
frc::TrapezoidProfile<units::meter> profile{constraints};
wpi::math::TrapezoidProfile<wpi::units::meter> profile{constraints};
auto state = profile.Calculate(kDt, goal,
frc::TrapezoidProfile<units::meter>::State{});
wpi::math::TrapezoidProfile<wpi::units::meter>::State{});
auto predictedTimeLeft = profile.TimeLeftUntil(1_m);
bool reachedGoal = false;
for (int i = 0; i < 400; i++) {
state = profile.Calculate(kDt, state, goal);
if (!reachedGoal &&
(units::math::abs(state.velocity - 1_mps) < 10e-5_mps)) {
(wpi::units::math::abs(state.velocity - 1_mps) < 10e-5_mps)) {
EXPECT_NEAR(unit_cast<double>(predictedTimeLeft), i / 100.0, 2e-2);
reachedGoal = true;
}
@@ -189,15 +189,15 @@ TEST(TrapezoidProfileTest, TimingBeforeGoal) {
}
TEST(TrapezoidProfileTest, TimingToNegativeGoal) {
using units::unit_cast;
using wpi::units::unit_cast;
frc::TrapezoidProfile<units::meter>::Constraints constraints{0.75_mps,
wpi::math::TrapezoidProfile<wpi::units::meter>::Constraints constraints{0.75_mps,
0.75_mps_sq};
frc::TrapezoidProfile<units::meter>::State goal{-2_m, 0_mps};
wpi::math::TrapezoidProfile<wpi::units::meter>::State goal{-2_m, 0_mps};
frc::TrapezoidProfile<units::meter> profile{constraints};
wpi::math::TrapezoidProfile<wpi::units::meter> profile{constraints};
auto state = profile.Calculate(kDt, goal,
frc::TrapezoidProfile<units::meter>::State{});
wpi::math::TrapezoidProfile<wpi::units::meter>::State{});
auto predictedTimeLeft = profile.TimeLeftUntil(goal.position);
bool reachedGoal = false;
@@ -213,22 +213,22 @@ TEST(TrapezoidProfileTest, TimingToNegativeGoal) {
}
TEST(TrapezoidProfileTest, TimingBeforeNegativeGoal) {
using units::unit_cast;
using wpi::units::unit_cast;
frc::TrapezoidProfile<units::meter>::Constraints constraints{0.75_mps,
wpi::math::TrapezoidProfile<wpi::units::meter>::Constraints constraints{0.75_mps,
0.75_mps_sq};
frc::TrapezoidProfile<units::meter>::State goal{-2_m, 0_mps};
wpi::math::TrapezoidProfile<wpi::units::meter>::State goal{-2_m, 0_mps};
frc::TrapezoidProfile<units::meter> profile{constraints};
wpi::math::TrapezoidProfile<wpi::units::meter> profile{constraints};
auto state = profile.Calculate(kDt, goal,
frc::TrapezoidProfile<units::meter>::State{});
wpi::math::TrapezoidProfile<wpi::units::meter>::State{});
auto predictedTimeLeft = profile.TimeLeftUntil(-1_m);
bool reachedGoal = false;
for (int i = 0; i < 400; i++) {
state = profile.Calculate(kDt, state, goal);
if (!reachedGoal &&
(units::math::abs(state.velocity + 1_mps) < 10e-5_mps)) {
(wpi::units::math::abs(state.velocity + 1_mps) < 10e-5_mps)) {
EXPECT_NEAR(unit_cast<double>(predictedTimeLeft), i / 100.0, 2e-2);
reachedGoal = true;
}
@@ -236,53 +236,53 @@ TEST(TrapezoidProfileTest, TimingBeforeNegativeGoal) {
}
TEST(TrapezoidProfileTest, InitalizationOfCurrentState) {
frc::TrapezoidProfile<units::meter>::Constraints constraints{1_mps, 1_mps_sq};
frc::TrapezoidProfile<units::meter> profile{constraints};
wpi::math::TrapezoidProfile<wpi::units::meter>::Constraints constraints{1_mps, 1_mps_sq};
wpi::math::TrapezoidProfile<wpi::units::meter> profile{constraints};
EXPECT_NEAR_UNITS(profile.TimeLeftUntil(0_m), 0_s, 1e-10_s);
EXPECT_NEAR_UNITS(profile.TotalTime(), 0_s, 1e-10_s);
}
TEST(TrapezoidProfileTest, InitialVelocityConstraints) {
frc::TrapezoidProfile<units::meter>::Constraints constraints{0.75_mps,
wpi::math::TrapezoidProfile<wpi::units::meter>::Constraints constraints{0.75_mps,
0.75_mps_sq};
frc::TrapezoidProfile<units::meter>::State goal{10_m, 0_mps};
frc::TrapezoidProfile<units::meter>::State state{0_m, -10_mps};
wpi::math::TrapezoidProfile<wpi::units::meter>::State goal{10_m, 0_mps};
wpi::math::TrapezoidProfile<wpi::units::meter>::State state{0_m, -10_mps};
frc::TrapezoidProfile<units::meter> profile{constraints};
wpi::math::TrapezoidProfile<wpi::units::meter> profile{constraints};
for (int i = 0; i < 200; ++i) {
state = profile.Calculate(kDt, state, goal);
EXPECT_LE(units::math::abs(state.velocity),
units::math::abs(constraints.maxVelocity));
EXPECT_LE(wpi::units::math::abs(state.velocity),
wpi::units::math::abs(constraints.maxVelocity));
}
}
TEST(TrapezoidProfileTest, GoalVelocityConstraints) {
frc::TrapezoidProfile<units::meter>::Constraints constraints{0.75_mps,
wpi::math::TrapezoidProfile<wpi::units::meter>::Constraints constraints{0.75_mps,
0.75_mps_sq};
frc::TrapezoidProfile<units::meter>::State goal{10_m, 5_mps};
frc::TrapezoidProfile<units::meter>::State state{0_m, 0.75_mps};
wpi::math::TrapezoidProfile<wpi::units::meter>::State goal{10_m, 5_mps};
wpi::math::TrapezoidProfile<wpi::units::meter>::State state{0_m, 0.75_mps};
frc::TrapezoidProfile<units::meter> profile{constraints};
wpi::math::TrapezoidProfile<wpi::units::meter> profile{constraints};
for (int i = 0; i < 200; ++i) {
state = profile.Calculate(kDt, state, goal);
EXPECT_LE(units::math::abs(state.velocity),
units::math::abs(constraints.maxVelocity));
EXPECT_LE(wpi::units::math::abs(state.velocity),
wpi::units::math::abs(constraints.maxVelocity));
}
}
TEST(TrapezoidProfileTest, NegativeGoalVelocityConstraints) {
frc::TrapezoidProfile<units::meter>::Constraints constraints{0.75_mps,
wpi::math::TrapezoidProfile<wpi::units::meter>::Constraints constraints{0.75_mps,
0.75_mps_sq};
frc::TrapezoidProfile<units::meter>::State goal{10_m, -5_mps};
frc::TrapezoidProfile<units::meter>::State state{0_m, 0.75_mps};
wpi::math::TrapezoidProfile<wpi::units::meter>::State goal{10_m, -5_mps};
wpi::math::TrapezoidProfile<wpi::units::meter>::State state{0_m, 0.75_mps};
frc::TrapezoidProfile<units::meter> profile{constraints};
wpi::math::TrapezoidProfile<wpi::units::meter> profile{constraints};
for (int i = 0; i < 200; ++i) {
state = profile.Calculate(kDt, state, goal);
EXPECT_LE(units::math::abs(state.velocity),
units::math::abs(constraints.maxVelocity));
EXPECT_LE(wpi::units::math::abs(state.velocity),
wpi::units::math::abs(constraints.maxVelocity));
}
}

16
wpimath/src/test/native/cpp/trajectory/proto/TrajectoryProtoTest.cpp
View File

@@ -7,27 +7,27 @@
#include "wpi/math/trajectory/Trajectory.hpp"
#include "wpi/util/SmallVector.hpp"
using namespace frc;
using namespace wpi::math;
namespace {
using ProtoType = wpi::Protobuf<frc::Trajectory>;
using ProtoType = wpi::util::Protobuf<wpi::math::Trajectory>;
const Trajectory kExpectedData = Trajectory{std::vector<frc::Trajectory::State>{
const Trajectory kExpectedData = Trajectory{std::vector<wpi::math::Trajectory::State>{
Trajectory::State{1.1_s, 2.2_mps, 3.3_mps_sq,
Pose2d(Translation2d(1.1_m, 2.2_m), Rotation2d(2.2_rad)),
units::curvature_t{6.6}},
wpi::units::curvature_t{6.6}},
Trajectory::State{2.1_s, 2.2_mps, 3.3_mps_sq,
Pose2d(Translation2d(2.1_m, 2.2_m), Rotation2d(2.2_rad)),
units::curvature_t{6.6}},
wpi::units::curvature_t{6.6}},
Trajectory::State{3.1_s, 2.2_mps, 3.3_mps_sq,
Pose2d(Translation2d(3.1_m, 2.2_m), Rotation2d(2.2_rad)),
units::curvature_t{6.6}}}};
wpi::units::curvature_t{6.6}}}};
} // namespace
TEST(TrajectoryProtoTest, Roundtrip) {
wpi::ProtobufMessage<decltype(kExpectedData)> message;
wpi::SmallVector<uint8_t, 64> buf;
wpi::util::ProtobufMessage<decltype(kExpectedData)> message;
wpi::util::SmallVector<uint8_t, 64> buf;
ASSERT_TRUE(message.Pack(buf, kExpectedData));
auto unpacked_data = message.Unpack(buf);

10
wpimath/src/test/native/cpp/trajectory/proto/TrajectoryStateProtoTest.cpp
View File

@@ -7,21 +7,21 @@
#include "wpi/math/trajectory/Trajectory.hpp"
#include "wpi/util/SmallVector.hpp"
using namespace frc;
using namespace wpi::math;
namespace {
using ProtoType = wpi::Protobuf<frc::Trajectory::State>;
using ProtoType = wpi::util::Protobuf<wpi::math::Trajectory::State>;
const Trajectory::State kExpectedData = Trajectory::State{
1.91_s, 4.4_mps, 17.4_mps_sq,
Pose2d{Translation2d{1.74_m, 19.1_m}, Rotation2d{22.9_rad}},
units::curvature_t{0.174}};
wpi::units::curvature_t{0.174}};
} // namespace
TEST(TrajectoryStateProtoTest, Roundtrip) {
wpi::ProtobufMessage<decltype(kExpectedData)> message;
wpi::SmallVector<uint8_t, 64> buf;
wpi::util::ProtobufMessage<decltype(kExpectedData)> message;
wpi::util::SmallVector<uint8_t, 64> buf;
ASSERT_TRUE(message.Pack(buf, kExpectedData));
auto unpacked_data = message.Unpack(buf);