check

Author: databasedav

src/builder.rs

@@ -865,7 +865,6 @@ mod tests {
         app.update();
 
         // Verify the component was mutated correctly.
-        app.world_mut().entity(entity1);
         let component1 = app.world().get::<TestComponent>(entity1).unwrap();
         assert_eq!(component1.0, 15, "Component should be 10 + 5 = 15.");
 
@@ -1428,7 +1427,6 @@ mod tests {
             drop(output_guard);
 
             // Reactivity test
-            app.world_mut().entity(parent);
             app.world_mut().get_mut::<TestComponent>(parent).unwrap().0 = "Parent B".to_string();
             app.update();
             let mut output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
@@ -2120,9 +2118,7 @@ mod tests {
 
         // Mutate the parent's component again. If the signal was not cleaned up,
         // this could panic when trying to access the despawned child.
-        app.world_mut().get_mut::<SourceComponent>(parent).unwrap().0 = "Post-Despawn
-    Update"
-            .to_string();
+        app.world_mut().get_mut::<SourceComponent>(parent).unwrap().0 = "Post-Despawn Update".to_string();
         app.update();
 
         // The test passes if the previous update didn't panic.

src/signal.rs

@@ -1521,12 +1521,15 @@ pub trait SignalExt: Signal {
         Throttle {
             signal: self.map(
                 move |In(item): In<Self::Item>, time: Res<Time>, mut timer_option: Local<Option<Timer>>| {
+                    bevy_log::info!("delta y: {:?}", time.delta());
                     match timer_option.as_mut() {
                         None => {
                             *timer_option = Some(Timer::new(duration, TimerMode::Once));
+                            bevy_log::info!("delta f: {:?}", time.delta());
                             Some(item)
                         }
                         Some(timer) => {
+                            bevy_log::info!("delta: {:?}", time.delta());
                             if timer.tick(time.delta()).finished() {
                                 timer.reset();
                                 Some(item)
@@ -1976,10 +1979,11 @@ mod tests {
     // Import Bevy prelude for MinimalPlugins and other common items
     use bevy::prelude::*;
     use bevy_platform::sync::*;
-    use bevy_time::TimeUpdateStrategy;
+    use bevy_time::TimePlugin;
 
     // Add Duration
     use core::time::Duration;
+    use test_log::test;
 
     // Helper component and resource for testing Add Default
     #[derive(Component, Clone, Debug, PartialEq, Reflect, Default, Resource)]
@@ -2641,12 +2645,15 @@ mod tests {
 
     #[test]
     fn test_throttle() {
-        let mut app = create_test_app();
+        let mut app = App::new();
+        app.add_plugins((MinimalPlugins.build().disable::<TimePlugin>(), JonmoPlugin));
+        app.init_resource::<Time>(); // manually managing time for the test
         app.init_resource::<SignalOutput<i32>>();
 
         // A simple counter to generate a new value (1, 2, 3...) for each update.
         let source_signal = SignalBuilder::from_system(|_: In<()>, mut counter: Local<i32>| {
             *counter += 1;
+            bevy_log::info!("fuck");
             *counter
         });
 
@@ -2655,68 +2662,71 @@ mod tests {
             .map(capture_output)
             .register(app.world_mut());
 
-        // 1. Initial emission: The first value should always pass through.
+        // 1. Initial emission: The first update runs with near-zero delta. The first value should always
+        //    pass.
         app.update();
         assert_eq!(
-            get_output(&app.world()),
+            get_output(app.world()),
             Some(1),
             "First value (1) should pass immediately."
         );
         // Clear the output to prepare for the next check.
         app.world_mut().resource_mut::<SignalOutput<i32>>().0 = None;
 
-        // 2. Blocked emission: Advance time by less than the duration. The next value (2) should be
-        //    blocked.
+        // 2. Blocked emission: Manually advance time by 50ms.
         app.world_mut()
-            .insert_resource(TimeUpdateStrategy::ManualDuration(Duration::from_millis(50)));
-        app.update();
+            .resource_mut::<Time>()
+            .advance_by(Duration::from_millis(50));
+        app.update(); // `time.delta()` is now 50ms. The timer ticks but isn't finished.
         assert_eq!(
-            get_output::<i32>(&app.world()),
+            get_output::<i32>(app.world()),
             None,
             "Value (2) emitted after 50ms should be blocked."
         );
 
-        // 3. Another blocked emission: Update again with no time elapsed. The next value (3) should also be
-        //    blocked.
+        // 3. Another blocked emission: Advance time by another 40ms (total 90ms).
         app.world_mut()
-            .insert_resource(TimeUpdateStrategy::ManualDuration(Duration::from_millis(0)));
-        app.update();
+            .resource_mut::<Time>()
+            .advance_by(Duration::from_millis(40));
+        app.update(); // `time.delta()` is 40ms. Timer ticks to 90ms. Still not finished.
         assert_eq!(
-            get_output::<i32>(&app.world()),
+            get_output::<i32>(app.world()),
             None,
-            "Value (3) emitted immediately after should also be blocked."
+            "Value (3) emitted after 90ms total should be blocked."
         );
-
-        // 4. Allowed emission: Advance time past the threshold (50ms from step 2 + 60ms now = 110ms total).
+        app.world_mut().entity(**handle);
+        // 4. Allowed emission: Advance time by another 20ms (total 110ms).
         app.world_mut()
-            .insert_resource(TimeUpdateStrategy::ManualDuration(Duration::from_millis(60)));
-        app.update();
+            .resource_mut::<Time>()
+            .advance_by(Duration::from_millis(20));
+        app.update(); // `time.delta()` is 20ms. Timer ticks to 110ms, which is >= 100ms.
         // The source signal has been called 4 times now. The value should be 4.
         assert_eq!(
-            get_output(&app.world()),
+            get_output(app.world()),
             Some(4),
             "Value (4) should pass after total duration > 100ms."
         );
         app.world_mut().resource_mut::<SignalOutput<i32>>().0 = None;
 
-        // 5. Blocked again: Immediately after an emission, the timer resets, so the next value (5) is
-        //    blocked.
+        // 5. Blocked again: The timer was reset on the last pass. A small advance is not enough.
         app.world_mut()
-            .insert_resource(TimeUpdateStrategy::ManualDuration(Duration::from_millis(10)));
+            .resource_mut::<Time>()
+            .advance_by(Duration::from_millis(10));
         app.update();
         assert_eq!(
-            get_output::<i32>(&app.world()),
+            get_output::<i32>(app.world()),
             None,
             "Value (5) immediately after a pass should be blocked again."
         );
 
         // 6. Pass again: Advance time to pass the threshold again.
         app.world_mut()
-            .insert_resource(TimeUpdateStrategy::ManualDuration(Duration::from_millis(100)));
+            .resource_mut::<Time>()
+            .advance_by(Duration::from_millis(100));
         app.update();
         // The source signal has now been called 6 times. The value should be 6.
         assert_eq!(
-            get_output(&app.world()),
+            get_output(app.world()),
             Some(6),
             "Value (6) should pass again after another full duration."
         );

src/signal_map.rs

@@ -977,10 +977,9 @@ impl<K, V> MutableBTreeMap<K, V> {
         V: Clone + SSs,
     {
         let replay_lazy_signal = LazySignal::new(clone!((self => self_) move |world: &mut World| {
-            let self_entity = LazyEntity::new();
             let broadcaster_system = world.get::<MutableBTreeMapData<K, V>>(self_.entity).unwrap().broadcaster.clone().register(world);
 
-            let replay_system_logic = clone!((self_entity, self_) move |In(upstream_diffs): In<Vec<MapDiff<K, V>>>, world: &mut World, mut has_run: Local<bool>| {
+            let replay_system_logic = clone!((self_) move |In(upstream_diffs): In<Vec<MapDiff<K, V>>>, world: &mut World, mut has_run: Local<bool>| {
                 if !*has_run {
                     *has_run = true;
                     let initial_map = self_.read(&*world);
@@ -993,7 +992,6 @@ impl<K, V> MutableBTreeMap<K, V> {
             });
 
             let replay_signal = register_signal::<_, Vec<MapDiff<K, V>>, _, _, _>(world, replay_system_logic);
-            self_entity.set(*replay_signal);
 
             let trigger = Box::new(move |world: &mut World| {
                 process_signals(world, [replay_signal], Box::new(Vec::<MapDiff<K, V>>::new()));

src/signal_vec.rs

@@ -3758,10 +3758,9 @@ impl<T> MutableVec<T> {
         T: Clone + SSs,
     {
         let replay_lazy_signal = LazySignal::new(clone!((self => self_) move |world: &mut World| {
-            let self_entity = LazyEntity::new();
             let broadcaster_system = world.get::<MutableVecData<T>>(self_.entity).unwrap().broadcaster.clone().register(world);
 
-            let replay_system_logic = clone!((self_entity, self_) move |In(upstream_diffs): In<Vec<VecDiff<T>>>, world: &mut World, mut has_run: Local<bool>| {
+            let replay_system_logic = clone!((self_) move |In(upstream_diffs): In<Vec<VecDiff<T>>>, world: &mut World, mut has_run: Local<bool>| {
                 if !*has_run {
                     *has_run = true;
                     let initial_vec = self_.read(&*world).to_vec();
@@ -3774,7 +3773,6 @@ impl<T> MutableVec<T> {
             });
 
             let replay_signal = register_signal::<_, Vec<VecDiff<T>>, _, _, _>(world, replay_system_logic);
-            self_entity.set(*replay_signal);
 
             let trigger = Box::new(move |world: &mut World| {
                 process_signals(world, [replay_signal], Box::new(Vec::<VecDiff<T>>::new()));
@@ -4006,7 +4004,7 @@ pub(crate) mod tests {
     use crate::JonmoPlugin;
     use bevy::prelude::*;
     use bevy_platform::sync::RwLock;
-    use test_log;
+    use test_log::test;
 
     #[derive(Resource, Default, Debug)]
     struct SignalVecOutput<T: Clone + fmt::Debug>(Vec<VecDiff<T>>);
@@ -5085,7 +5083,7 @@ pub(crate) mod tests {
         cleanup(true)
     }
 
-    #[test_log::test]
+    #[test]
     fn test_filter_map() {
         {
             // A comprehensive test for `SignalVecExt::filter_map`, covering all `VecDiff`