Merge pull request #3151 from pleroy/MoarTests

DiscreteTrajectorySegment, part 5: some more testing

Author: pleroy

physics/discrete_trajectory_segment_test.cpp

@@ -12,6 +12,7 @@
 #include "quantities/named_quantities.hpp"
 #include "quantities/quantities.hpp"
 #include "quantities/si.hpp"
+#include "testing_utilities/almost_equals.hpp"
 #include "testing_utilities/approximate_quantity.hpp"
 #include "testing_utilities/discrete_trajectory_factories.hpp"
 #include "testing_utilities/is_near.hpp"
@@ -32,6 +33,7 @@ using quantities::si::Milli;
 using quantities::si::Nano;
 using quantities::si::Radian;
 using quantities::si::Second;
+using testing_utilities::AlmostEquals;
 using testing_utilities::AppendTrajectorySegment;
 using testing_utilities::IsNear;
 using testing_utilities::NewCircularTrajectorySegment;
@@ -61,6 +63,11 @@ class DiscreteTrajectorySegmentTest : public ::testing::Test {
     segment_->ForgetAfter(t);
   }
 
+  void ForgetAfter(Instant const& t,
+                   DiscreteTrajectorySegment<World>& segment) {
+    segment.ForgetAfter(t);
+  }
+
   void ForgetBefore(Instant const& t) {
     segment_->ForgetBefore(t);
   }
@@ -233,5 +240,55 @@ TEST_F(DiscreteTrajectorySegmentTest, Downsampling) {
               IsNear(14_⑴ * Milli(Metre / Second)));
 }
 
+TEST_F(DiscreteTrajectorySegmentTest, DownsamplingForgetAfter) {
+  auto const circle = NewEmptyTrajectorySegment<World>();
+  auto const forgotten_circle = NewEmptyTrajectorySegment<World>();
+  SetDownsampling({.max_dense_intervals = 50, .tolerance = 1 * Milli(Metre)},
+                  *circle->front());
+  SetDownsampling({.max_dense_intervals = 50, .tolerance = 1 * Milli(Metre)},
+                  *forgotten_circle->front());
+  AngularFrequency const ω = 3 * Radian / Second;
+  Length const r = 2 * Metre;
+  Time const Δt = 1.0 / 128.0 * Second;  // Yields exact times.
+  Instant const t1 = t0_;
+  Instant const t2 = t0_ + 5 * Second;
+  Instant const t3 = t0_ + 10 * Second;
+
+  // Construct two identical trajectories with downsampling.
+  AppendTrajectorySegment(
+      *NewCircularTrajectorySegment<World>(ω, r, Δt, t1, t3)->front(),
+      /*to=*/*circle->front());
+  AppendTrajectorySegment(
+      *NewCircularTrajectorySegment<World>(ω, r, Δt, t1, t3)->front(),
+      /*to=*/*forgotten_circle->front());
+
+  // Forget one of the trajectories in the middle, and append new points.
+  Instant const restart_time =
+      forgotten_circle->front()->lower_bound(t2)->first;
+  ForgetAfter(t2, *forgotten_circle->front());
+  AppendTrajectorySegment(
+      *NewCircularTrajectorySegment<World>(ω, r, Δt, restart_time, t3)->front(),
+      /*to=*/*forgotten_circle->front());
+
+  EXPECT_THAT(circle->front()->size(), Eq(92));
+  EXPECT_THAT(forgotten_circle->front()->size(), Eq(circle->front()->size()));
+  std::vector<Length> position_errors;
+  std::vector<Speed> velocity_errors;
+
+  // Check that the two trajectories are identical.
+  for (auto const [t, degrees_of_freedom] : *forgotten_circle->front()) {
+    position_errors.push_back(
+        (circle->front()->find(t)->second.position() -
+         degrees_of_freedom.position()).Norm());
+    velocity_errors.push_back(
+        (circle->front()->find(t)->second.velocity() -
+         degrees_of_freedom.velocity()).Norm());
+  }
+  EXPECT_THAT(*std::max_element(position_errors.begin(), position_errors.end()),
+              AlmostEquals(0 * Metre, 0));
+  EXPECT_THAT(*std::max_element(velocity_errors.begin(), velocity_errors.end()),
+              AlmostEquals(0 * Metre / Second, 0));
+}
+
 }  // namespace physics
 }  // namespace principia