From 525f8c18b0d67d58cee398d0074c25c8a2dd4fe6 Mon Sep 17 00:00:00 2001
From: Niklas Eicker <git@nikl.me>
Date: Sun, 5 Dec 2021 18:59:53 +0100
Subject: [PATCH 1/5] Rename fixed timestep state and add a test

---
 crates/bevy_core/src/time/fixed_timestep.rs | 93 +++++++++++++++++++--
 1 file changed, 85 insertions(+), 8 deletions(-)

diff --git a/crates/bevy_core/src/time/fixed_timestep.rs b/crates/bevy_core/src/time/fixed_timestep.rs
index a22c874f92930..1a10f38f4631c 100644
--- a/crates/bevy_core/src/time/fixed_timestep.rs
+++ b/crates/bevy_core/src/time/fixed_timestep.rs
@@ -10,6 +10,7 @@ use bevy_ecs::{
 use bevy_utils::HashMap;
 use std::borrow::Cow;
 
+#[derive(PartialEq, Debug)]
 pub struct FixedTimestepState {
     pub step: f64,
     pub accumulator: f64,
@@ -49,14 +50,14 @@ impl FixedTimesteps {
 }
 
 pub struct FixedTimestep {
-    state: State,
+    state: LocalFixedTimestepState,
     internal_system: Box<dyn System<In = (), Out = ShouldRun>>,
 }
 
 impl Default for FixedTimestep {
     fn default() -> Self {
         Self {
-            state: State::default(),
+            state: LocalFixedTimestepState::default(),
             internal_system: Box::new(Self::prepare_system.system()),
         }
     }
@@ -65,7 +66,7 @@ impl Default for FixedTimestep {
 impl FixedTimestep {
     pub fn step(step: f64) -> Self {
         Self {
-            state: State {
+            state: LocalFixedTimestepState {
                 step,
                 ..Default::default()
             },
@@ -75,7 +76,7 @@ impl FixedTimestep {
 
     pub fn steps_per_second(rate: f64) -> Self {
         Self {
-            state: State {
+            state: LocalFixedTimestepState {
                 step: 1.0 / rate,
                 ..Default::default()
             },
@@ -89,7 +90,7 @@ impl FixedTimestep {
     }
 
     fn prepare_system(
-        mut state: Local<State>,
+        mut state: Local<LocalFixedTimestepState>,
         time: Res<Time>,
         mut fixed_timesteps: ResMut<FixedTimesteps>,
     ) -> ShouldRun {
@@ -105,14 +106,14 @@ impl FixedTimestep {
 }
 
 #[derive(Clone)]
-pub struct State {
+pub struct LocalFixedTimestepState {
     label: Option<String>, // TODO: consider making this a TypedLabel
     step: f64,
     accumulator: f64,
     looping: bool,
 }
 
-impl Default for State {
+impl Default for LocalFixedTimestepState {
     fn default() -> Self {
         Self {
             step: 1.0 / 60.0,
@@ -123,7 +124,7 @@ impl Default for State {
     }
 }
 
-impl State {
+impl LocalFixedTimestepState {
     fn update(&mut self, time: &Time) -> ShouldRun {
         if !self.looping {
             self.accumulator += time.delta_seconds_f64();
@@ -194,3 +195,79 @@ impl System for FixedTimestep {
         self.internal_system.check_change_tick(change_tick);
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use bevy_ecs::prelude::*;
+    use bevy_utils::Instant;
+    use std::ops::{Add, Mul};
+    use std::time::Duration;
+
+    const LABEL: &str = "test_step";
+
+    #[test]
+    fn test() {
+        let mut world = World::default();
+        let mut time = Time::default();
+        let instance = Instant::now();
+        time.update_with_instant(instance);
+        world.insert_resource(time);
+        world.insert_resource(FixedTimesteps::default());
+        world.insert_resource(0usize);
+        let mut schedule = Schedule::default();
+
+        schedule.add_stage(
+            "update",
+            SystemStage::parallel()
+                .with_run_criteria(FixedTimestep::step(0.5).with_label(LABEL))
+                .with_system(fixed_update),
+        );
+
+        // if time does not progress, the step does not run
+        schedule.run(&mut world);
+        schedule.run(&mut world);
+        assert_eq!(0usize, *world.get_resource::<usize>().unwrap());
+        assert_eq!(0., get_accumulator_deciseconds(&world));
+
+        // let's progress less than one step
+        set_time(&mut world, instance, 0.4);
+        schedule.run(&mut world);
+        assert_eq!(0usize, *world.get_resource::<usize>().unwrap());
+        assert_eq!(4., get_accumulator_deciseconds(&world));
+
+        // finish the first step with 0.1s above the step length
+        set_time(&mut world, instance, 0.6);
+        schedule.run(&mut world);
+        assert_eq!(1usize, *world.get_resource::<usize>().unwrap());
+        assert_eq!(1., get_accumulator_deciseconds(&world));
+
+        // runns multiple times if the delta is multiple step lengths
+        set_time(&mut world, instance, 1.7);
+        schedule.run(&mut world);
+        assert_eq!(3usize, *world.get_resource::<usize>().unwrap());
+        assert_eq!(2., get_accumulator_deciseconds(&world));
+    }
+
+    fn fixed_update(mut count: ResMut<usize>) {
+        *count += 1;
+    }
+
+    fn set_time(world: &mut World, instance: Instant, seconds: f32) {
+        world
+            .get_resource_mut::<Time>()
+            .unwrap()
+            .update_with_instant(instance.add(Duration::from_secs_f32(seconds)));
+    }
+
+    fn get_accumulator_deciseconds(world: &World) -> f64 {
+        world
+            .get_resource::<FixedTimesteps>()
+            .unwrap()
+            .get(LABEL)
+            .unwrap()
+            .accumulator
+            .mul(10.)
+            .round()
+    }
+}

From f1cf8650d5d9a6f22361296d3cc3f08212365b01 Mon Sep 17 00:00:00 2001
From: Niklas Eicker <git@nikl.me>
Date: Sun, 5 Dec 2021 19:06:04 +0100
Subject: [PATCH 2/5] Remove no longer needed PartialEq derive

---
 crates/bevy_core/src/time/fixed_timestep.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_core/src/time/fixed_timestep.rs b/crates/bevy_core/src/time/fixed_timestep.rs
index 1a10f38f4631c..3aeedbd54b239 100644
--- a/crates/bevy_core/src/time/fixed_timestep.rs
+++ b/crates/bevy_core/src/time/fixed_timestep.rs
@@ -10,7 +10,7 @@ use bevy_ecs::{
 use bevy_utils::HashMap;
 use std::borrow::Cow;
 
-#[derive(PartialEq, Debug)]
+#[derive(Debug)]
 pub struct FixedTimestepState {
     pub step: f64,
     pub accumulator: f64,

From 3e4d7059e1276f9d2226b842dda3a76f6eb63922 Mon Sep 17 00:00:00 2001
From: Niklas Eicker <git@nikl.me>
Date: Sun, 5 Dec 2021 19:06:40 +0100
Subject: [PATCH 3/5] Update crates/bevy_core/src/time/fixed_timestep.rs

Co-authored-by: Alice Cecile <alice.i.cecile@gmail.com>
---
 crates/bevy_core/src/time/fixed_timestep.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_core/src/time/fixed_timestep.rs b/crates/bevy_core/src/time/fixed_timestep.rs
index 3aeedbd54b239..d59224f132ba0 100644
--- a/crates/bevy_core/src/time/fixed_timestep.rs
+++ b/crates/bevy_core/src/time/fixed_timestep.rs
@@ -242,7 +242,7 @@ mod test {
         assert_eq!(1usize, *world.get_resource::<usize>().unwrap());
         assert_eq!(1., get_accumulator_deciseconds(&world));
 
-        // runns multiple times if the delta is multiple step lengths
+        // runs multiple times if the delta is multiple step lengths
         set_time(&mut world, instance, 1.7);
         schedule.run(&mut world);
         assert_eq!(3usize, *world.get_resource::<usize>().unwrap());

From 35a41299e4c557929b1982896b48ce952b83ed60 Mon Sep 17 00:00:00 2001
From: Niklas Eicker <git@nikl.me>
Date: Sun, 5 Dec 2021 19:12:31 +0100
Subject: [PATCH 4/5] Use a new type Count as testing resource

---
 crates/bevy_core/src/time/fixed_timestep.rs | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/crates/bevy_core/src/time/fixed_timestep.rs b/crates/bevy_core/src/time/fixed_timestep.rs
index d59224f132ba0..81f7454278194 100644
--- a/crates/bevy_core/src/time/fixed_timestep.rs
+++ b/crates/bevy_core/src/time/fixed_timestep.rs
@@ -204,6 +204,7 @@ mod test {
     use std::ops::{Add, Mul};
     use std::time::Duration;
 
+    type Count = usize;
     const LABEL: &str = "test_step";
 
     #[test]
@@ -214,7 +215,7 @@ mod test {
         time.update_with_instant(instance);
         world.insert_resource(time);
         world.insert_resource(FixedTimesteps::default());
-        world.insert_resource(0usize);
+        world.insert_resource::<Count>(0);
         let mut schedule = Schedule::default();
 
         schedule.add_stage(
@@ -227,29 +228,29 @@ mod test {
         // if time does not progress, the step does not run
         schedule.run(&mut world);
         schedule.run(&mut world);
-        assert_eq!(0usize, *world.get_resource::<usize>().unwrap());
+        assert_eq!(0, *world.get_resource::<Count>().unwrap());
         assert_eq!(0., get_accumulator_deciseconds(&world));
 
         // let's progress less than one step
         set_time(&mut world, instance, 0.4);
         schedule.run(&mut world);
-        assert_eq!(0usize, *world.get_resource::<usize>().unwrap());
+        assert_eq!(0, *world.get_resource::<Count>().unwrap());
         assert_eq!(4., get_accumulator_deciseconds(&world));
 
         // finish the first step with 0.1s above the step length
         set_time(&mut world, instance, 0.6);
         schedule.run(&mut world);
-        assert_eq!(1usize, *world.get_resource::<usize>().unwrap());
+        assert_eq!(1, *world.get_resource::<Count>().unwrap());
         assert_eq!(1., get_accumulator_deciseconds(&world));
 
         // runs multiple times if the delta is multiple step lengths
         set_time(&mut world, instance, 1.7);
         schedule.run(&mut world);
-        assert_eq!(3usize, *world.get_resource::<usize>().unwrap());
+        assert_eq!(3, *world.get_resource::<Count>().unwrap());
         assert_eq!(2., get_accumulator_deciseconds(&world));
     }
 
-    fn fixed_update(mut count: ResMut<usize>) {
+    fn fixed_update(mut count: ResMut<Count>) {
         *count += 1;
     }
 

From f6c0629e03a6ce5ee4f8aacc7e44366081c50787 Mon Sep 17 00:00:00 2001
From: Niklas Eicker <git@nikl.me>
Date: Sun, 12 Dec 2021 15:05:27 +0100
Subject: [PATCH 5/5] Rename test function to advance_time

---
 crates/bevy_core/src/time/fixed_timestep.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/crates/bevy_core/src/time/fixed_timestep.rs b/crates/bevy_core/src/time/fixed_timestep.rs
index 81f7454278194..2143db7d4cc7a 100644
--- a/crates/bevy_core/src/time/fixed_timestep.rs
+++ b/crates/bevy_core/src/time/fixed_timestep.rs
@@ -232,19 +232,19 @@ mod test {
         assert_eq!(0., get_accumulator_deciseconds(&world));
 
         // let's progress less than one step
-        set_time(&mut world, instance, 0.4);
+        advance_time(&mut world, instance, 0.4);
         schedule.run(&mut world);
         assert_eq!(0, *world.get_resource::<Count>().unwrap());
         assert_eq!(4., get_accumulator_deciseconds(&world));
 
         // finish the first step with 0.1s above the step length
-        set_time(&mut world, instance, 0.6);
+        advance_time(&mut world, instance, 0.6);
         schedule.run(&mut world);
         assert_eq!(1, *world.get_resource::<Count>().unwrap());
         assert_eq!(1., get_accumulator_deciseconds(&world));
 
         // runs multiple times if the delta is multiple step lengths
-        set_time(&mut world, instance, 1.7);
+        advance_time(&mut world, instance, 1.7);
         schedule.run(&mut world);
         assert_eq!(3, *world.get_resource::<Count>().unwrap());
         assert_eq!(2., get_accumulator_deciseconds(&world));
@@ -254,7 +254,7 @@ mod test {
         *count += 1;
     }
 
-    fn set_time(world: &mut World, instance: Instant, seconds: f32) {
+    fn advance_time(world: &mut World, instance: Instant, seconds: f32) {
         world
             .get_resource_mut::<Time>()
             .unwrap()