Stepping FixedUpdate systems for unit testing?

[liquid-dragons]

I have some systems that rely on FixedUpdate, and require the precise timings of Time<Fixed> (so I can't add them under a regular Update schedule). Is there a way to step these systems in a unit test?

The examples I've seen all use Update, and calling app.update() doesn't seem to run FixedUpdate systems at all. Is there some equivalent that I'm missing here?

Minimal example of what I've tried so far:

use bevy::prelude::*;

fn main() {}

#[derive(Component, Default)]
pub struct Counter(pub usize);

fn increment_counter_with_time(time: Res<Time<Fixed>>, mut query: Query<&mut Counter>) {
    println!("delta: {:?}, elapsed: {:?}", time.delta(), time.elapsed());
    for mut counter in &mut query {
        counter.0 += 1;
    }
}

#[cfg(test)]
mod tests {
    use bevy::ecs::schedule::Stepping;

    use super::*;

    fn assert(world: &World, count: usize) {
        let mut query = world.try_query::<&Counter>().unwrap();
        let counter = query.single(world).unwrap();
        assert_eq!(counter.0, count);
    }

    #[test]
    fn stepping_fixed_update_with_time() {
        let mut app = App::new();

        println!("init");

        app.add_systems(FixedUpdate, increment_counter_with_time);
        app.insert_resource(Time::<Fixed>::from_seconds(1.0));
        app.insert_resource(Stepping::new());

        let mut stepping = app.world_mut().resource_mut::<Stepping>();
        stepping.add_schedule(FixedUpdate);

        app.world_mut().spawn(Counter::default());

        assert(app.world(), 0);
        app.update();
        assert(app.world(), 1);
        app.update();
        assert(app.world(), 2);
    }
}

The test fails on the second assert like so:

thread 'tests::stepping_fixed_update_with_time' (21738) panicked at src/main.rs:24:9:
assertion `left == right` failed
  left: 0
 right: 1
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

My bevy version is 0.18.1

[hymm]

I think you want to change the TimeUpdateStrategy to a manual mode. https://docs.rs/bevy/latest/bevy/time/enum.TimeUpdateStrategy.html

[liquid-dragons]

I wasn't able to make it work, but I've found that bevy seems to enforce a maximum timestep of 250ms?

While looking up some usage for TimeUpdateStrategy I was poking around in bevy_time, and found this test: fixed_main_schedule_should_run_with_time_plugin_enabled.

I've changed the timestep like this:

diff --git a/crates/bevy_time/src/lib.rs b/crates/bevy_time/src/lib.rs
index ebc63af94..dc87bc0fc 100644
--- a/crates/bevy_time/src/lib.rs
+++ b/crates/bevy_time/src/lib.rs
@@ -249,14 +249,18 @@ mod tests {
         // Set the time step to just over half the fixed update timestep
         // This way, it will have not accumulated enough time to run the fixed update after one update
         // But will definitely have enough time after two updates
-        let fixed_update_timestep = Time::<Fixed>::default().timestep();
+        let fixed_update_timestep = Duration::from_secs_f32(0.4);
+        // let fixed_update_timestep = Time::<Fixed>::default().timestep();
         let time_step = fixed_update_timestep / 2 + Duration::from_millis(1);
 
+        println!("time step: {time_step:?}");
+
         let mut app = App::new();
         app.add_plugins(TimePlugin)
             .add_systems(FixedUpdate, count_fixed_updates)
             .add_systems(Update, report_time)
             .init_resource::<FixedUpdateCounter>()
+            .insert_resource(Time::<Fixed>::from_duration(fixed_update_timestep))
             .insert_resource(TimeUpdateStrategy::ManualDuration(time_step));
 
         // Frame 0

With a time step < 250ms this test logs what you would expect, e.g.:

time step: 201.000003ms
Virtual time on frame 0: 0ns
Fixed time on frame 0: 0ns
Virtual time on frame 1: 201.000003ms
Fixed time on frame 1: 0ns
Virtual time on frame 2: 402.000006ms
Fixed time on frame 2: 400.000006ms
Virtual time on frame 3: 603.000009ms
Fixed time on frame 3: 400.000006ms
Virtual time on frame 4: 804.000012ms
Fixed time on frame 4: 800.000012ms

But trying to set a larger value, the step will be capped to 250 ms:

time step: 501ms
Virtual time on frame 0: 0ns
Fixed time on frame 0: 0ns
Virtual time on frame 1: 250ms
Fixed time on frame 1: 0ns
Virtual time on frame 2: 500ms
Fixed time on frame 2: 0ns

thread 'tests::fixed_main_schedule_should_run_with_time_plugin_enabled' (36982) panicked at src/main.rs:144:9:
assertion `left == right` failed: Fixed update should have run once
  left: 0
 right: 1
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

For my own tests I can just set a smaller timestep no problem (I was just going for 1 second for cleaner numbers), but I wonder if this is intentional?