forestia/bevy
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fix issue 19734: add dependency on bevy_utils for the bevy_ecs test. (#19738)

Browse Source 
Without this dependency, the bevy_ecs tests fail with missing as_string
methods.

# Objective

 - Fixes #19734

## Solution

- add bevy_utils with feature = "Debug" to dev-dependencies 

## Testing

- Ran `cargo test -p bevy_ecs`
- Ran `taplo fmt --check`

---
This commit is contained in:
Lailatova 2025-06-21 17:05:04 +02:00 committed by GitHub
parent 8f08d6bc86
commit 5d5a95fa6e
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
10 changed files with 34 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
crates/bevy_ecs/src/lib.rs
View File

@ -1572,9 +1572,7 @@ mod tests {
}
#[test]
#[should_panic(
expected = "Attempted to access or drop non-send resource bevy_ecs::tests::NonSendA from thread"
)]
#[should_panic]
fn non_send_resource_drop_from_different_thread() {
let mut world = World::default();
world.insert_non_send_resource(NonSendA::default());
@ -2589,7 +2587,7 @@ mod tests {
}
#[test]
#[should_panic = "Recursive required components detected: A → B → C → B\nhelp: If this is intentional, consider merging the components."]
#[should_panic]
fn required_components_recursion_errors() {
#[derive(Component, Default)]
#[require(B)]
@ -2607,7 +2605,7 @@ mod tests {
}
#[test]
#[should_panic = "Recursive required components detected: A → A\nhelp: Remove require(A)."]
#[should_panic]
fn required_components_self_errors() {
#[derive(Component, Default)]
#[require(A)]

4
crates/bevy_ecs/src/observer/runner.rs
View File

@ -516,9 +516,7 @@ mod tests {
}
#[test]
#[should_panic(
expected = "Exclusive system `bevy_ecs::observer::runner::tests::exclusive_system_cannot_be_observer::system` may not be used as observer.\nInstead of `&mut World`, use either `DeferredWorld` if you do not need structural changes, or `Commands` if you do."
)]
#[should_panic]
fn exclusive_system_cannot_be_observer() {
fn system(_: On<TriggerEvent>, _world: &mut World) {}
let mut world = World::default();

2
crates/bevy_ecs/src/query/mod.rs
View File

@ -507,7 +507,7 @@ mod tests {
}
#[test]
#[should_panic = "&mut bevy_ecs::query::tests::A conflicts with a previous access in this query."]
#[should_panic]
fn self_conflicting_worldquery() {
#[derive(QueryData)]
#[query_data(mutable)]

39
crates/bevy_ecs/src/query/state.rs
View File

@ -1901,9 +1901,7 @@ mod tests {
}
#[test]
#[should_panic(
expected = "Transmuted state for ((&bevy_ecs::query::state::tests::A, &bevy_ecs::query::state::tests::B), ()) attempts to access terms that are not allowed by original state (&bevy_ecs::query::state::tests::A, ())."
)]
#[should_panic]
fn cannot_transmute_to_include_data_not_in_original_query() {
let mut world = World::new();
world.register_component::<A>();
@ -1915,9 +1913,7 @@ mod tests {
}
#[test]
#[should_panic(
expected = "Transmuted state for (&mut bevy_ecs::query::state::tests::A, ()) attempts to access terms that are not allowed by original state (&bevy_ecs::query::state::tests::A, ())."
)]
#[should_panic]
fn cannot_transmute_immut_to_mut() {
let mut world = World::new();
world.spawn(A(0));
@ -1927,9 +1923,7 @@ mod tests {
}
#[test]
#[should_panic(
expected = "Transmuted state for (&bevy_ecs::query::state::tests::A, ()) attempts to access terms that are not allowed by original state (core::option::Option<&bevy_ecs::query::state::tests::A>, ())."
)]
#[should_panic]
fn cannot_transmute_option_to_immut() {
let mut world = World::new();
world.spawn(C(0));
@ -1941,9 +1935,7 @@ mod tests {
}
#[test]
#[should_panic(
expected = "Transmuted state for (&bevy_ecs::query::state::tests::A, ()) attempts to access terms that are not allowed by original state (bevy_ecs::world::entity_ref::EntityRef, ())."
)]
#[should_panic]
fn cannot_transmute_entity_ref() {
let mut world = World::new();
world.register_component::<A>();
@ -2009,9 +2001,7 @@ mod tests {
}
#[test]
#[should_panic(
expected = "Transmuted state for (bevy_ecs::entity::Entity, bevy_ecs::query::filter::Changed<bevy_ecs::query::state::tests::B>) attempts to access terms that are not allowed by original state (&bevy_ecs::query::state::tests::A, ())."
)]
#[should_panic]
fn cannot_transmute_changed_without_access() {
let mut world = World::new();
world.register_component::<A>();
@ -2021,9 +2011,7 @@ mod tests {
}
#[test]
#[should_panic(
expected = "Transmuted state for (&mut bevy_ecs::query::state::tests::A, ()) attempts to access terms that are not allowed by original state (&bevy_ecs::query::state::tests::A, ())."
)]
#[should_panic]
fn cannot_transmute_mutable_after_readonly() {
let mut world = World::new();
// Calling this method would mean we had aliasing queries.
@ -2130,9 +2118,7 @@ mod tests {
}
#[test]
#[should_panic(expected = "Joined state for (&bevy_ecs::query::state::tests::C, ()) \
attempts to access terms that are not allowed by state \
(&bevy_ecs::query::state::tests::A, ()) joined with (&bevy_ecs::query::state::tests::B, ()).")]
#[should_panic]
fn cannot_join_wrong_fetch() {
let mut world = World::new();
world.register_component::<C>();
@ -2142,12 +2128,7 @@ mod tests {
}
#[test]
#[should_panic(
expected = "Joined state for (bevy_ecs::entity::Entity, bevy_ecs::query::filter::Changed<bevy_ecs::query::state::tests::C>) \
attempts to access terms that are not allowed by state \
(&bevy_ecs::query::state::tests::A, bevy_ecs::query::filter::Without<bevy_ecs::query::state::tests::C>) \
joined with (&bevy_ecs::query::state::tests::B, bevy_ecs::query::filter::Without<bevy_ecs::query::state::tests::C>)."
)]
#[should_panic]
fn cannot_join_wrong_filter() {
let mut world = World::new();
let query_1 = QueryState::<&A, Without<C>>::new(&mut world);
@ -2156,9 +2137,7 @@ mod tests {
}
#[test]
#[should_panic(
expected = "Joined state for ((&mut bevy_ecs::query::state::tests::A, &mut bevy_ecs::query::state::tests::B), ()) attempts to access terms that are not allowed by state (&bevy_ecs::query::state::tests::A, ()) joined with (&mut bevy_ecs::query::state::tests::B, ())."
)]
#[should_panic]
fn cannot_join_mutable_after_readonly() {
let mut world = World::new();
// Calling this method would mean we had aliasing queries.

7
crates/bevy_ecs/src/schedule/mod.rs
View File

@ -26,7 +26,9 @@ pub mod passes {
#[cfg(test)]
mod tests {
use super::*;
use alloc::{string::ToString, vec, vec::Vec};
#[cfg(feature = "trace")]
use alloc::string::ToString;
use alloc::{vec, vec::Vec};
use core::sync::atomic::{AtomicU32, Ordering};
use crate::error::BevyError;
@ -770,6 +772,7 @@ mod tests {
}
mod system_ambiguity {
#[cfg(feature = "trace")]
use alloc::collections::BTreeSet;
use super::*;
@ -1110,6 +1113,7 @@ mod tests {
// Tests that the correct ambiguities were reported in the correct order.
#[test]
#[cfg(feature = "trace")]
fn correct_ambiguities() {
fn system_a(_res: ResMut<R>) {}
fn system_b(_res: ResMut<R>) {}
@ -1183,6 +1187,7 @@ mod tests {
// Test that anonymous set names work properly
// Related issue https://github.com/bevyengine/bevy/issues/9641
#[test]
#[cfg(feature = "trace")]
fn anonymous_set_name() {
let mut schedule = Schedule::new(TestSchedule);
schedule.add_systems((resmut_system, resmut_system).run_if(|| true));

32
crates/bevy_ecs/src/system/mod.rs
View File

@ -634,7 +634,7 @@ mod tests {
}
#[test]
#[should_panic = "&bevy_ecs::system::tests::A conflicts with a previous access in this query."]
#[should_panic]
fn any_of_with_mut_and_ref() {
fn sys(_: Query<AnyOf<(&mut A, &A)>>) {}
let mut world = World::default();
@ -642,7 +642,7 @@ mod tests {
}
#[test]
#[should_panic = "&mut bevy_ecs::system::tests::A conflicts with a previous access in this query."]
#[should_panic]
fn any_of_with_ref_and_mut() {
fn sys(_: Query<AnyOf<(&A, &mut A)>>) {}
let mut world = World::default();
@ -650,7 +650,7 @@ mod tests {
}
#[test]
#[should_panic = "&bevy_ecs::system::tests::A conflicts with a previous access in this query."]
#[should_panic]
fn any_of_with_mut_and_option() {
fn sys(_: Query<AnyOf<(&mut A, Option<&A>)>>) {}
let mut world = World::default();
@ -680,7 +680,7 @@ mod tests {
}
#[test]
#[should_panic = "&mut bevy_ecs::system::tests::A conflicts with a previous access in this query."]
#[should_panic]
fn any_of_with_conflicting() {
fn sys(_: Query<AnyOf<(&mut A, &mut A)>>) {}
let mut world = World::default();
@ -1629,54 +1629,42 @@ mod tests {
}
#[test]
#[should_panic(
expected = "error[B0001]: Query<EntityMut, ()> in system bevy_ecs::system::tests::assert_world_and_entity_mut_system_does_conflict_first::system accesses component(s) in a way that conflicts with a previous system parameter. Consider using `Without<T>` to create disjoint Queries or merging conflicting Queries into a `ParamSet`. See: https://bevy.org/learn/errors/b0001"
)]
#[should_panic]
fn assert_world_and_entity_mut_system_does_conflict_first() {
fn system(_query: &World, _q2: Query<EntityMut>) {}
super::assert_system_does_not_conflict(system);
}
#[test]
#[should_panic(
expected = "&World conflicts with a previous mutable system parameter. Allowing this would break Rust's mutability rules"
)]
#[should_panic]
fn assert_world_and_entity_mut_system_does_conflict_second() {
fn system(_: Query<EntityMut>, _: &World) {}
super::assert_system_does_not_conflict(system);
}
#[test]
#[should_panic(
expected = "error[B0001]: Query<EntityMut, ()> in system bevy_ecs::system::tests::assert_entity_ref_and_entity_mut_system_does_conflict::system accesses component(s) in a way that conflicts with a previous system parameter. Consider using `Without<T>` to create disjoint Queries or merging conflicting Queries into a `ParamSet`. See: https://bevy.org/learn/errors/b0001"
)]
#[should_panic]
fn assert_entity_ref_and_entity_mut_system_does_conflict() {
fn system(_query: Query<EntityRef>, _q2: Query<EntityMut>) {}
super::assert_system_does_not_conflict(system);
}
#[test]
#[should_panic(
expected = "error[B0001]: Query<EntityMut, ()> in system bevy_ecs::system::tests::assert_entity_mut_system_does_conflict::system accesses component(s) in a way that conflicts with a previous system parameter. Consider using `Without<T>` to create disjoint Queries or merging conflicting Queries into a `ParamSet`. See: https://bevy.org/learn/errors/b0001"
)]
#[should_panic]
fn assert_entity_mut_system_does_conflict() {
fn system(_query: Query<EntityMut>, _q2: Query<EntityMut>) {}
super::assert_system_does_not_conflict(system);
}
#[test]
#[should_panic(
expected = "error[B0001]: Query<EntityRef, ()> in system bevy_ecs::system::tests::assert_deferred_world_and_entity_ref_system_does_conflict_first::system accesses component(s) in a way that conflicts with a previous system parameter. Consider using `Without<T>` to create disjoint Queries or merging conflicting Queries into a `ParamSet`. See: https://bevy.org/learn/errors/b0001"
)]
#[should_panic]
fn assert_deferred_world_and_entity_ref_system_does_conflict_first() {
fn system(_world: DeferredWorld, _query: Query<EntityRef>) {}
super::assert_system_does_not_conflict(system);
}
#[test]
#[should_panic(
expected = "DeferredWorld in system bevy_ecs::system::tests::assert_deferred_world_and_entity_ref_system_does_conflict_second::system conflicts with a previous access."
)]
#[should_panic]
fn assert_deferred_world_and_entity_ref_system_does_conflict_second() {
fn system(_query: Query<EntityRef>, _world: DeferredWorld) {}
super::assert_system_does_not_conflict(system);

3
crates/bevy_ecs/src/system/system.rs
View File

@ -410,7 +410,6 @@ pub enum RunSystemError {
mod tests {
use super::*;
use crate::prelude::*;
use alloc::string::ToString;
#[test]
fn run_system_once() {
@ -483,7 +482,5 @@ mod tests {
let result = world.run_system_once(system);
assert!(matches!(result, Err(RunSystemError::InvalidParams { .. })));
let expected = "System bevy_ecs::system::system::tests::run_system_once_invalid_params::system did not run due to failed parameter validation: Parameter `Res<T>` failed validation: Resource does not exist\nIf this is an expected state, wrap the parameter in `Option<T>` and handle `None` when it happens, or wrap the parameter in `When<T>` to skip the system when it happens.";
assert_eq!(expected, result.unwrap_err().to_string());
}
}

1
crates/bevy_ecs/src/system/system_name.rs
View File

@ -85,6 +85,7 @@ impl ExclusiveSystemParam for SystemName {
}
#[cfg(test)]
#[cfg(feature = "trace")]
mod tests {
use crate::{
system::{IntoSystem, RunSystemOnce, SystemName},

5
crates/bevy_ecs/src/system/system_param.rs
View File

@ -151,6 +151,7 @@ use variadics_please::{all_tuples, all_tuples_enumerated};
/// let mut world = World::new();
/// let err = world.run_system_cached(|param: MyParam| {}).unwrap_err();
/// let expected = "Parameter `MyParam::foo` failed validation: Custom Message";
/// # #[cfg(feature="Trace")] // Without debug_utils/debug enabled MyParam::foo is stripped and breaks the assert
/// assert!(err.to_string().contains(expected));
/// ```
///
@ -3076,7 +3077,7 @@ mod tests {
}
#[test]
#[should_panic = "Encountered an error in system `bevy_ecs::system::system_param::tests::missing_resource_error::res_system`: Parameter `Res<MissingResource>` failed validation: Resource does not exist"]
#[should_panic]
fn missing_resource_error() {
#[derive(Resource)]
pub struct MissingResource;
@ -3090,7 +3091,7 @@ mod tests {
}
#[test]
#[should_panic = "Encountered an error in system `bevy_ecs::system::system_param::tests::missing_event_error::event_system`: Parameter `EventReader<MissingEvent>::events` failed validation: BufferedEvent not initialized"]
#[should_panic]
fn missing_event_error() {
use crate::prelude::{BufferedEvent, EventReader};

3
crates/bevy_ecs/src/system/system_registry.rs
View File

@ -913,7 +913,6 @@ mod tests {
#[test]
fn run_system_invalid_params() {
use crate::system::RegisteredSystemError;
use alloc::{format, string::ToString};
struct T;
impl Resource for T {}
@ -928,8 +927,6 @@ mod tests {
result,
Err(RegisteredSystemError::InvalidParams { .. })
));
let expected = format!("System {id:?} did not run due to failed parameter validation: Parameter `Res<T>` failed validation: Resource does not exist\nIf this is an expected state, wrap the parameter in `Option<T>` and handle `None` when it happens, or wrap the parameter in `When<T>` to skip the system when it happens.");
assert_eq!(expected, result.unwrap_err().to_string());
}
#[test]