Update test snapshots for play state fix

Author: joelreymont

crates/store/re_entity_db/src/entity_db.rs

@@ -451,7 +451,6 @@ impl EntityDb {
         self.storage_engine().store().timelines()
     }
 
-
     pub fn has_any_data_on_timeline(&self, timeline: &TimelineName) -> bool {
         self.time_histogram_per_timeline
             .get(timeline)

crates/viewer/re_view_time_series/src/view_class.rs

@@ -196,7 +196,8 @@ impl ViewClass for TimeSeriesView {
         system_registry.register_fallback_provider(
             TimeAxis::descriptor_view_range().component,
             |ctx| {
-                let time_histogram_per_timeline = ctx.viewer_ctx().recording().time_histogram_per_timeline();
+                let time_histogram_per_timeline =
+                    ctx.viewer_ctx().recording().time_histogram_per_timeline();
                 let (timeline_min, timeline_max) = time_histogram_per_timeline
                     .get(ctx.viewer_ctx().time_ctrl.timeline().name())
                     .and_then(|hist| {

crates/viewer/re_viewer_context/src/time_control.rs

@@ -531,7 +531,11 @@ impl TimeControl {
             && new_play_state != self.play_state()
         {
             if let Some(time_histogram_per_timeline) = time_histogram_per_timeline {
-                self.set_play_state(time_histogram_per_timeline, new_play_state, Some(blueprint_ctx));
+                self.set_play_state(
+                    time_histogram_per_timeline,
+                    new_play_state,
+                    Some(blueprint_ctx),
+                );
             } else {
                 // Even without histogram data, we need to set the play state flags
                 let empty_histogram = TimeHistogramPerTimeline::default();
@@ -552,7 +556,11 @@ impl TimeControl {
                         );
                     } else {
                         let empty_histogram = TimeHistogramPerTimeline::default();
-                        self.set_play_state(&empty_histogram, PlayState::Playing, Some(blueprint_ctx));
+                        self.set_play_state(
+                            &empty_histogram,
+                            PlayState::Playing,
+                            Some(blueprint_ctx),
+                        );
                     }
                 }
 
@@ -833,8 +841,12 @@ impl TimeControl {
         );
 
         for command in commands {
-            let needs_repaint =
-                self.handle_time_command(blueprint_ctx, time_histogram_per_timeline, timelines, command);
+            let needs_repaint = self.handle_time_command(
+                blueprint_ctx,
+                time_histogram_per_timeline,
+                timelines,
+                command,
+            );
 
             if needs_repaint == NeedsRepaint::Yes {
                 response.needs_repaint = NeedsRepaint::Yes;
@@ -1259,9 +1271,17 @@ impl TimeControl {
             }
 
             if self.following {
-                self.set_play_state(time_histogram_per_timeline, PlayState::Following, blueprint_ctx);
+                self.set_play_state(
+                    time_histogram_per_timeline,
+                    PlayState::Following,
+                    blueprint_ctx,
+                );
             } else {
-                self.set_play_state(time_histogram_per_timeline, PlayState::Playing, blueprint_ctx);
+                self.set_play_state(
+                    time_histogram_per_timeline,
+                    PlayState::Playing,
+                    blueprint_ctx,
+                );
             }
         }
     }
@@ -1456,14 +1476,16 @@ impl TimeControl {
         &self,
         time_histogram_per_timeline: &TimeHistogramPerTimeline,
     ) -> Option<AbsoluteTimeRange> {
-        time_histogram_per_timeline.get(self.timeline().name()).map(|hist| {
-            let data_range = range(hist);
-            let max_valid_range_for = self.max_valid_range_for(*self.timeline().name());
-            AbsoluteTimeRange::new(
-                data_range.min.max(max_valid_range_for.min),
-                data_range.max.min(max_valid_range_for.max),
-            )
-        })
+        time_histogram_per_timeline
+            .get(self.timeline().name())
+            .map(|hist| {
+                let data_range = range(hist);
+                let max_valid_range_for = self.max_valid_range_for(*self.timeline().name());
+                AbsoluteTimeRange::new(
+                    data_range.min.max(max_valid_range_for.min),
+                    data_range.max.min(max_valid_range_for.max),
+                )
+            })
     }
 
     /// The selected slice of time that is called the "loop selection".
@@ -1537,16 +1559,14 @@ fn default_timeline(
     let most_events = time_histogram_per_timeline
         .iter()
         .filter_map(|(name, hist)| {
-            timelines.get(name).map(|timeline| {
-                (timeline, hist.total_count())
-            })
+            timelines
+                .get(name)
+                .map(|timeline| (timeline, hist.total_count()))
         })
         .max_by(|(a_timeline, a_count), (b_timeline, b_count)| {
             a_count
                 .cmp(b_count)
-                .then_with(|| {
-                    timeline_priority(a_timeline).cmp(&timeline_priority(b_timeline))
-                })
+                .then_with(|| timeline_priority(a_timeline).cmp(&timeline_priority(b_timeline)))
         });
 
     if let Some((timeline, _)) = most_events {
@@ -1623,7 +1643,13 @@ fn step_back_time_looped(
 mod tests {
     use super::*;
 
-    fn create_test_data(timelines: &[Timeline], counts: &[u64]) -> (TimeHistogramPerTimeline, std::collections::BTreeMap<TimelineName, Timeline>) {
+    fn create_test_data(
+        timelines: &[Timeline],
+        counts: &[u64],
+    ) -> (
+        TimeHistogramPerTimeline,
+        std::collections::BTreeMap<TimelineName, Timeline>,
+    ) {
         let mut hist_per_timeline = TimeHistogramPerTimeline::default();
         let mut timeline_map = std::collections::BTreeMap::new();
 
@@ -1661,23 +1687,43 @@ mod tests {
         assert_eq!(default_timeline(&hist_both, &timelines_both), log_time);
 
         // Custom timeline should win over both log_time and log_tick when counts are equal
-        let (hist_custom0, timelines_custom0) = create_test_data(&[log_time, log_tick, custom_timeline0], &[42, 42, 42]);
-        assert_eq!(default_timeline(&hist_custom0, &timelines_custom0), custom_timeline0);
+        let (hist_custom0, timelines_custom0) =
+            create_test_data(&[log_time, log_tick, custom_timeline0], &[42, 42, 42]);
+        assert_eq!(
+            default_timeline(&hist_custom0, &timelines_custom0),
+            custom_timeline0
+        );
 
         // Order shouldn't matter
-        let (hist_custom0_rev, timelines_custom0_rev) = create_test_data(&[custom_timeline0, log_time, log_tick], &[42, 42, 42]);
-        assert_eq!(default_timeline(&hist_custom0_rev, &timelines_custom0_rev), custom_timeline0);
+        let (hist_custom0_rev, timelines_custom0_rev) =
+            create_test_data(&[custom_timeline0, log_time, log_tick], &[42, 42, 42]);
+        assert_eq!(
+            default_timeline(&hist_custom0_rev, &timelines_custom0_rev),
+            custom_timeline0
+        );
 
-        let (hist_custom0_mid, timelines_custom0_mid) = create_test_data(&[log_time, custom_timeline0, log_tick], &[42, 42, 42]);
-        assert_eq!(default_timeline(&hist_custom0_mid, &timelines_custom0_mid), custom_timeline0);
+        let (hist_custom0_mid, timelines_custom0_mid) =
+            create_test_data(&[log_time, custom_timeline0, log_tick], &[42, 42, 42]);
+        assert_eq!(
+            default_timeline(&hist_custom0_mid, &timelines_custom0_mid),
+            custom_timeline0
+        );
 
         // Custom timelines with different counts - higher count wins
-        let (hist_custom1, timelines_custom1) = create_test_data(&[custom_timeline0, custom_timeline1], &[42, 43]);
-        assert_eq!(default_timeline(&hist_custom1, &timelines_custom1), custom_timeline1);
+        let (hist_custom1, timelines_custom1) =
+            create_test_data(&[custom_timeline0, custom_timeline1], &[42, 43]);
+        assert_eq!(
+            default_timeline(&hist_custom1, &timelines_custom1),
+            custom_timeline1
+        );
 
         // Single custom timeline
-        let (hist_single_custom, timelines_single_custom) = create_test_data(&[custom_timeline0], &[42]);
-        assert_eq!(default_timeline(&hist_single_custom, &timelines_single_custom), custom_timeline0);
+        let (hist_single_custom, timelines_single_custom) =
+            create_test_data(&[custom_timeline0], &[42]);
+        assert_eq!(
+            default_timeline(&hist_single_custom, &timelines_single_custom),
+            custom_timeline0
+        );
     }
 
     #[test]
@@ -1690,16 +1736,28 @@ mod tests {
         hist.increment(30, 1);
 
         // Step forward from before first key
-        assert_eq!(step_fwd_time(TimeReal::from(5), &hist), TimeInt::new_temporal(10));
+        assert_eq!(
+            step_fwd_time(TimeReal::from(5), &hist),
+            TimeInt::new_temporal(10)
+        );
 
         // Step forward from middle
-        assert_eq!(step_fwd_time(TimeReal::from(15), &hist), TimeInt::new_temporal(20));
+        assert_eq!(
+            step_fwd_time(TimeReal::from(15), &hist),
+            TimeInt::new_temporal(20)
+        );
 
         // Step forward from last key (wraps around)
-        assert_eq!(step_fwd_time(TimeReal::from(30), &hist), TimeInt::new_temporal(10));
+        assert_eq!(
+            step_fwd_time(TimeReal::from(30), &hist),
+            TimeInt::new_temporal(10)
+        );
 
         // Step forward from after last key (wraps around)
-        assert_eq!(step_fwd_time(TimeReal::from(35), &hist), TimeInt::new_temporal(10));
+        assert_eq!(
+            step_fwd_time(TimeReal::from(35), &hist),
+            TimeInt::new_temporal(10)
+        );
 
         // Empty histogram
         let empty_hist = TimeHistogram::default();
@@ -1716,20 +1774,35 @@ mod tests {
         hist.increment(30, 1);
 
         // Step back from after last key
-        assert_eq!(step_back_time(TimeReal::from(35), &hist), TimeInt::new_temporal(30));
+        assert_eq!(
+            step_back_time(TimeReal::from(35), &hist),
+            TimeInt::new_temporal(30)
+        );
 
         // Step back from middle
-        assert_eq!(step_back_time(TimeReal::from(25), &hist), TimeInt::new_temporal(20));
+        assert_eq!(
+            step_back_time(TimeReal::from(25), &hist),
+            TimeInt::new_temporal(20)
+        );
 
         // Step back from first key (wraps around)
-        assert_eq!(step_back_time(TimeReal::from(10), &hist), TimeInt::new_temporal(30));
+        assert_eq!(
+            step_back_time(TimeReal::from(10), &hist),
+            TimeInt::new_temporal(30)
+        );
 
         // Step back from before first key (wraps around)
-        assert_eq!(step_back_time(TimeReal::from(5), &hist), TimeInt::new_temporal(30));
+        assert_eq!(
+            step_back_time(TimeReal::from(5), &hist),
+            TimeInt::new_temporal(30)
+        );
 
         // Empty histogram
         let empty_hist = TimeHistogram::default();
-        assert_eq!(step_back_time(TimeReal::from(10), &empty_hist), TimeInt::MIN);
+        assert_eq!(
+            step_back_time(TimeReal::from(10), &empty_hist),
+            TimeInt::MIN
+        );
     }
 
     #[test]
@@ -1744,16 +1817,28 @@ mod tests {
         let loop_range = AbsoluteTimeRangeF::new(15.0, 25.0);
 
         // Before loop range - should jump to start
-        assert_eq!(step_fwd_time_looped(TimeReal::from(5), &hist, &loop_range), TimeReal::from(15.0));
+        assert_eq!(
+            step_fwd_time_looped(TimeReal::from(5), &hist, &loop_range),
+            TimeReal::from(15.0)
+        );
 
         // In loop range - should step to next key
-        assert_eq!(step_fwd_time_looped(TimeReal::from(15), &hist, &loop_range), TimeReal::from(20));
+        assert_eq!(
+            step_fwd_time_looped(TimeReal::from(15), &hist, &loop_range),
+            TimeReal::from(20)
+        );
 
         // At end of loop range - should wrap to start
-        assert_eq!(step_fwd_time_looped(TimeReal::from(25), &hist, &loop_range), TimeReal::from(15.0));
+        assert_eq!(
+            step_fwd_time_looped(TimeReal::from(25), &hist, &loop_range),
+            TimeReal::from(15.0)
+        );
 
         // After loop range - should jump to start
-        assert_eq!(step_fwd_time_looped(TimeReal::from(35), &hist, &loop_range), TimeReal::from(15.0));
+        assert_eq!(
+            step_fwd_time_looped(TimeReal::from(35), &hist, &loop_range),
+            TimeReal::from(15.0)
+        );
     }
 
     #[test]
@@ -1768,16 +1853,28 @@ mod tests {
         let loop_range = AbsoluteTimeRangeF::new(15.0, 25.0);
 
         // Before loop range - should jump to end
-        assert_eq!(step_back_time_looped(TimeReal::from(5), &hist, &loop_range), TimeReal::from(25.0));
+        assert_eq!(
+            step_back_time_looped(TimeReal::from(5), &hist, &loop_range),
+            TimeReal::from(25.0)
+        );
 
         // In loop range - should step to previous key
-        assert_eq!(step_back_time_looped(TimeReal::from(25), &hist, &loop_range), TimeReal::from(20));
+        assert_eq!(
+            step_back_time_looped(TimeReal::from(25), &hist, &loop_range),
+            TimeReal::from(20)
+        );
 
         // At start of loop range - should wrap to end
-        assert_eq!(step_back_time_looped(TimeReal::from(15), &hist, &loop_range), TimeReal::from(25.0));
+        assert_eq!(
+            step_back_time_looped(TimeReal::from(15), &hist, &loop_range),
+            TimeReal::from(25.0)
+        );
 
         // After loop range - should jump to end
-        assert_eq!(step_back_time_looped(TimeReal::from(35), &hist, &loop_range), TimeReal::from(25.0));
+        assert_eq!(
+            step_back_time_looped(TimeReal::from(35), &hist, &loop_range),
+            TimeReal::from(25.0)
+        );
     }
 
     #[test]