port old ambiguity tests over #9617

hymm · 2023-08-29T04:00:10Z

Objective

Some of the old ambiguity tests didn't get ported over during schedule v3.

Solution

Port over tests from

bevy/crates/bevy_ecs/src/schedule/ambiguity_detection.rs

Lines 279 to 612 in 15ee98d

    
           #[cfg(test)] 
        
           mod tests { 
        
               // Required to make the derive macro behave 
        
               use crate as bevy_ecs; 
        
               use crate::event::Events; 
        
               use crate::prelude::*; 
        
               #[derive(Resource)] 
        
               struct R; 
        
               #[derive(Component)] 
        
               struct A; 
        
               #[derive(Component)] 
        
               struct B; 
        
               // An event type 
        
               struct E; 
        
               fn empty_system() {} 
        
               fn res_system(_res: Res<R>) {} 
        
               fn resmut_system(_res: ResMut<R>) {} 
        
               fn nonsend_system(_ns: NonSend<R>) {} 
        
               fn nonsendmut_system(_ns: NonSendMut<R>) {} 
        
               fn read_component_system(_query: Query<&A>) {} 
        
               fn write_component_system(_query: Query<&mut A>) {} 
        
               fn with_filtered_component_system(_query: Query<&mut A, With<B>>) {} 
        
               fn without_filtered_component_system(_query: Query<&mut A, Without<B>>) {} 
        
               fn event_reader_system(_reader: EventReader<E>) {} 
        
               fn event_writer_system(_writer: EventWriter<E>) {} 
        
               fn event_resource_system(_events: ResMut<Events<E>>) {} 
        
               fn read_world_system(_world: &World) {} 
        
               fn write_world_system(_world: &mut World) {} 
        
               // Tests for conflict detection 
        
               #[test] 
        
               fn one_of_everything() { 
        
                   let mut world = World::new(); 
        
                   world.insert_resource(R); 
        
                   world.spawn(A); 
        
                   world.init_resource::<Events<E>>(); 
        
                   let mut test_stage = SystemStage::parallel(); 
        
                   test_stage 
        
                       // nonsendmut system deliberately conflicts with resmut system 
        
                       .add_system(resmut_system) 
        
                       .add_system(write_component_system) 
        
                       .add_system(event_writer_system); 
        
                   test_stage.run(&mut world); 
        
                   assert_eq!(test_stage.ambiguity_count(&world), 0); 
        
               } 
        
               #[test] 
        
               fn read_only() { 
        
                   let mut world = World::new(); 
        
                   world.insert_resource(R); 
        
                   world.insert_non_send_resource(R); 
        
                   world.spawn(A); 
        
                   world.init_resource::<Events<E>>(); 
        
                   let mut test_stage = SystemStage::parallel(); 
        
                   test_stage 
        
                       .add_system(empty_system) 
        
                       .add_system(empty_system) 
        
                       .add_system(res_system) 
        
                       .add_system(res_system) 
        
                       .add_system(nonsend_system) 
        
                       .add_system(nonsend_system) 
        
                       .add_system(read_component_system) 
        
                       .add_system(read_component_system) 
        
                       .add_system(event_reader_system) 
        
                       .add_system(event_reader_system) 
        
                       .add_system(read_world_system) 
        
                       .add_system(read_world_system); 
        
                   test_stage.run(&mut world); 
        
                   assert_eq!(test_stage.ambiguity_count(&world), 0); 
        
               } 
        
               #[test] 
        
               fn read_world() { 
        
                   let mut world = World::new(); 
        
                   world.insert_resource(R); 
        
                   world.spawn(A); 
        
                   world.init_resource::<Events<E>>(); 
        
                   let mut test_stage = SystemStage::parallel(); 
        
                   test_stage 
        
                       .add_system(resmut_system) 
        
                       .add_system(write_component_system) 
        
                       .add_system(event_writer_system) 
        
                       .add_system(read_world_system); 
        
                   test_stage.run(&mut world); 
        
                   assert_eq!(test_stage.ambiguity_count(&world), 3); 
        
               } 
        
               #[test] 
        
               fn resources() { 
        
                   let mut world = World::new(); 
        
                   world.insert_resource(R); 
        
                   let mut test_stage = SystemStage::parallel(); 
        
                   test_stage.add_system(resmut_system).add_system(res_system); 
        
                   test_stage.run(&mut world); 
        
                   assert_eq!(test_stage.ambiguity_count(&world), 1); 
        
               } 
        
               #[test] 
        
               fn nonsend() { 
        
                   let mut world = World::new(); 
        
                   world.insert_resource(R); 
        
                   world.insert_non_send_resource(R); 
        
                   let mut test_stage = SystemStage::parallel(); 
        
                   test_stage 
        
                       .add_system(nonsendmut_system) 
        
                       .add_system(nonsend_system); 
        
                   test_stage.run(&mut world); 
        
                   assert_eq!(test_stage.ambiguity_count(&world), 1); 
        
               } 
        
               #[test] 
        
               fn components() { 
        
                   let mut world = World::new(); 
        
                   world.spawn(A); 
        
                   let mut test_stage = SystemStage::parallel(); 
        
                   test_stage 
        
                       .add_system(read_component_system) 
        
                       .add_system(write_component_system); 
        
                   test_stage.run(&mut world); 
        
                   assert_eq!(test_stage.ambiguity_count(&world), 1); 
        
               } 
        
               #[test] 
        
               #[ignore = "Known failing but fix is non-trivial: https://github.com/bevyengine/bevy/issues/4381"] 
        
               fn filtered_components() { 
        
                   let mut world = World::new(); 
        
                   world.spawn(A); 
        
                   let mut test_stage = SystemStage::parallel(); 
        
                   test_stage 
        
                       .add_system(with_filtered_component_system) 
        
                       .add_system(without_filtered_component_system); 
        
                   test_stage.run(&mut world); 
        
                   assert_eq!(test_stage.ambiguity_count(&world), 0); 
        
               } 
        
               #[test] 
        
               fn events() { 
        
                   let mut world = World::new(); 
        
                   world.init_resource::<Events<E>>(); 
        
                   let mut test_stage = SystemStage::parallel(); 
        
                   test_stage 
        
                       // All of these systems clash 
        
                       .add_system(event_reader_system) 
        
                       .add_system(event_writer_system) 
        
                       .add_system(event_resource_system); 
        
                   test_stage.run(&mut world); 
        
                   assert_eq!(test_stage.ambiguity_count(&world), 3); 
        
               } 
        
               #[test] 
        
               fn exclusive() { 
        
                   let mut world = World::new(); 
        
                   world.insert_resource(R); 
        
                   world.spawn(A); 
        
                   world.init_resource::<Events<E>>(); 
        
                   let mut test_stage = SystemStage::parallel(); 
        
                   test_stage 
        
                       // All 3 of these conflict with each other 
        
                       .add_system(write_world_system) 
        
                       .add_system(write_world_system.at_end()) 
        
                       .add_system(res_system.at_start()) 
        
                       // These do not, as they're in different segments of the stage 
        
                       .add_system(write_world_system.at_start()) 
        
                       .add_system(write_world_system.before_commands()); 
        
                   test_stage.run(&mut world); 
        
                   assert_eq!(test_stage.ambiguity_count(&world), 3); 
        
               } 
        
               // Tests for silencing and resolving ambiguities 
        
               #[test] 
        
               fn before_and_after() { 
        
                   let mut world = World::new(); 
        
                   world.init_resource::<Events<E>>(); 
        
                   let mut test_stage = SystemStage::parallel(); 
        
                   test_stage 
        
                       .add_system(event_reader_system.before(event_writer_system)) 
        
                       .add_system(event_writer_system) 
        
                       .add_system(event_resource_system.after(event_writer_system)); 
        
                   test_stage.run(&mut world); 
        
                   assert_eq!(test_stage.ambiguity_count(&world), 0); 
        
               } 
        
               #[test] 
        
               fn ignore_all_ambiguities() { 
        
                   let mut world = World::new(); 
        
                   world.insert_resource(R); 
        
                   world.insert_non_send_resource(R); 
        
                   let mut test_stage = SystemStage::parallel(); 
        
                   test_stage 
        
                       .add_system(resmut_system.ignore_all_ambiguities()) 
        
                       .add_system(res_system) 
        
                       .add_system(nonsend_system); 
        
                   test_stage.run(&mut world); 
        
                   assert_eq!(test_stage.ambiguity_count(&world), 0); 
        
               } 
        
               #[test] 
        
               fn ambiguous_with_label() { 
        
                   let mut world = World::new(); 
        
                   world.insert_resource(R); 
        
                   world.insert_non_send_resource(R); 
        
                   #[derive(SystemLabel)] 
        
                   struct IgnoreMe; 
        
                   let mut test_stage = SystemStage::parallel(); 
        
                   test_stage 
        
                       .add_system(resmut_system.ambiguous_with(IgnoreMe)) 
        
                       .add_system(res_system.label(IgnoreMe)) 
        
                       .add_system(nonsend_system.label(IgnoreMe)); 
        
                   test_stage.run(&mut world); 
        
                   assert_eq!(test_stage.ambiguity_count(&world), 0); 
        
               } 
        
               #[test] 
        
               fn ambiguous_with_system() { 
        
                   let mut world = World::new(); 
        
                   let mut test_stage = SystemStage::parallel(); 
        
                   test_stage 
        
                       .add_system(write_component_system.ambiguous_with(read_component_system)) 
        
                       .add_system(read_component_system); 
        
                   test_stage.run(&mut world); 
        
                   assert_eq!(test_stage.ambiguity_count(&world), 0); 
        
               } 
        
               fn system_a(_res: ResMut<R>) {} 
        
               fn system_b(_res: ResMut<R>) {} 
        
               fn system_c(_res: ResMut<R>) {} 
        
               fn system_d(_res: ResMut<R>) {} 
        
               fn system_e(_res: ResMut<R>) {} 
        
               // Tests that the correct ambiguities were reported in the correct order. 
        
               #[test] 
        
               fn correct_ambiguities() { 
        
                   use super::*; 
        
                   let mut world = World::new(); 
        
                   world.insert_resource(R); 
        
                   let mut test_stage = SystemStage::parallel(); 
        
                   test_stage 
        
                       .add_system(system_a) 
        
                       .add_system(system_b) 
        
                       .add_system(system_c.ignore_all_ambiguities()) 
        
                       .add_system(system_d.ambiguous_with(system_b)) 
        
                       .add_system(system_e.after(system_a)); 
        
                   test_stage.run(&mut world); 
        
                   let ambiguities = test_stage.ambiguities(&world); 
        
                   assert_eq!( 
        
                       ambiguities, 
        
                       vec![ 
        
                           SystemOrderAmbiguity { 
        
                               system_names: [ 
        
                                   "bevy_ecs::schedule::ambiguity_detection::tests::system_a".to_string(), 
        
                                   "bevy_ecs::schedule::ambiguity_detection::tests::system_b".to_string() 
        
                               ], 
        
                               conflicts: vec!["bevy_ecs::schedule::ambiguity_detection::tests::R".to_string()], 
        
                               segment: SystemStageSegment::Parallel, 
        
                           }, 
        
                           SystemOrderAmbiguity { 
        
                               system_names: [ 
        
                                   "bevy_ecs::schedule::ambiguity_detection::tests::system_a".to_string(), 
        
                                   "bevy_ecs::schedule::ambiguity_detection::tests::system_d".to_string() 
        
                               ], 
        
                               conflicts: vec!["bevy_ecs::schedule::ambiguity_detection::tests::R".to_string()], 
        
                               segment: SystemStageSegment::Parallel, 
        
                           }, 
        
                           SystemOrderAmbiguity { 
        
                               system_names: [ 
        
                                   "bevy_ecs::schedule::ambiguity_detection::tests::system_b".to_string(), 
        
                                   "bevy_ecs::schedule::ambiguity_detection::tests::system_e".to_string() 
        
                               ], 
        
                               conflicts: vec!["bevy_ecs::schedule::ambiguity_detection::tests::R".to_string()], 
        
                               segment: SystemStageSegment::Parallel, 
        
                           }, 
        
                           SystemOrderAmbiguity { 
        
                               system_names: [ 
        
                                   "bevy_ecs::schedule::ambiguity_detection::tests::system_d".to_string(), 
        
                                   "bevy_ecs::schedule::ambiguity_detection::tests::system_e".to_string() 
        
                               ], 
        
                               conflicts: vec!["bevy_ecs::schedule::ambiguity_detection::tests::R".to_string()], 
        
                               segment: SystemStageSegment::Parallel, 
        
                           }, 
        
                       ] 
        
                   ); 
        
               } 
        
           }

with minimal changes

Make a method to convert the ambiguity conflicts to a string for easier verification of correct results.

alice-i-cecile

Nice to see these revived: thanks!

JoJoJet

I didn't know these got deleted, thanks! They were added in 0.9 (#6053), so looks like they only survived for one release before being yoten haha.

# Objective - Some of the old ambiguity tests didn't get ported over during schedule v3. ## Solution - Port over tests from https://github.com/bevyengine/bevy/blob/15ee98db8d1c6705111e0f11a8fc240ceaf9f2db/crates/bevy_ecs/src/schedule/ambiguity_detection.rs#L279-L612 with minimal changes - Make a method to convert the ambiguity conflicts to a string for easier verification of correct results.

port old ambiguity tests over

798fe16

alice-i-cecile added A-ECS Entities, components, systems, and events C-Code-Quality A section of code that is hard to understand or change labels Aug 29, 2023

alice-i-cecile approved these changes Aug 29, 2023

View reviewed changes

alice-i-cecile requested a review from maniwani August 29, 2023 12:29

JoJoJet approved these changes Aug 29, 2023

View reviewed changes

alice-i-cecile added this pull request to the merge queue Aug 29, 2023

alice-i-cecile added the S-Ready-For-Final-Review This PR has been approved by the community. It's ready for a maintainer to consider merging it label Aug 29, 2023

Merged via the queue into bevyengine:main with commit da9a070 Aug 29, 2023
24 checks passed

hymm deleted the port-old-ambiguity-tests branch August 30, 2023 02:04

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

port old ambiguity tests over #9617

port old ambiguity tests over #9617

hymm commented Aug 29, 2023

alice-i-cecile left a comment

JoJoJet left a comment

	#[cfg(test)]
	mod tests {
	// Required to make the derive macro behave
	use crate as bevy_ecs;
	use crate::event::Events;
	use crate::prelude::*;

	#[derive(Resource)]
	struct R;

	#[derive(Component)]
	struct A;

	#[derive(Component)]
	struct B;

	// An event type
	struct E;

	fn empty_system() {}
	fn res_system(_res: Res<R>) {}
	fn resmut_system(_res: ResMut<R>) {}
	fn nonsend_system(_ns: NonSend<R>) {}
	fn nonsendmut_system(_ns: NonSendMut<R>) {}
	fn read_component_system(_query: Query<&A>) {}
	fn write_component_system(_query: Query<&mut A>) {}
	fn with_filtered_component_system(_query: Query<&mut A, With<B>>) {}
	fn without_filtered_component_system(_query: Query<&mut A, Without<B>>) {}
	fn event_reader_system(_reader: EventReader<E>) {}
	fn event_writer_system(_writer: EventWriter<E>) {}
	fn event_resource_system(_events: ResMut<Events<E>>) {}
	fn read_world_system(_world: &World) {}
	fn write_world_system(_world: &mut World) {}

	// Tests for conflict detection

	#[test]
	fn one_of_everything() {
	let mut world = World::new();
	world.insert_resource(R);
	world.spawn(A);
	world.init_resource::<Events<E>>();

	let mut test_stage = SystemStage::parallel();
	test_stage
	// nonsendmut system deliberately conflicts with resmut system
	.add_system(resmut_system)
	.add_system(write_component_system)
	.add_system(event_writer_system);

	test_stage.run(&mut world);

	assert_eq!(test_stage.ambiguity_count(&world), 0);
	}

	#[test]
	fn read_only() {
	let mut world = World::new();
	world.insert_resource(R);
	world.insert_non_send_resource(R);
	world.spawn(A);
	world.init_resource::<Events<E>>();

	let mut test_stage = SystemStage::parallel();
	test_stage
	.add_system(empty_system)
	.add_system(empty_system)
	.add_system(res_system)
	.add_system(res_system)
	.add_system(nonsend_system)
	.add_system(nonsend_system)
	.add_system(read_component_system)
	.add_system(read_component_system)
	.add_system(event_reader_system)
	.add_system(event_reader_system)
	.add_system(read_world_system)
	.add_system(read_world_system);

	test_stage.run(&mut world);

	assert_eq!(test_stage.ambiguity_count(&world), 0);
	}

	#[test]
	fn read_world() {
	let mut world = World::new();
	world.insert_resource(R);
	world.spawn(A);
	world.init_resource::<Events<E>>();

	let mut test_stage = SystemStage::parallel();
	test_stage
	.add_system(resmut_system)
	.add_system(write_component_system)
	.add_system(event_writer_system)
	.add_system(read_world_system);

	test_stage.run(&mut world);

	assert_eq!(test_stage.ambiguity_count(&world), 3);
	}

	#[test]
	fn resources() {
	let mut world = World::new();
	world.insert_resource(R);

	let mut test_stage = SystemStage::parallel();
	test_stage.add_system(resmut_system).add_system(res_system);

	test_stage.run(&mut world);

	assert_eq!(test_stage.ambiguity_count(&world), 1);
	}

	#[test]
	fn nonsend() {
	let mut world = World::new();
	world.insert_resource(R);
	world.insert_non_send_resource(R);

	let mut test_stage = SystemStage::parallel();
	test_stage
	.add_system(nonsendmut_system)
	.add_system(nonsend_system);

	test_stage.run(&mut world);

	assert_eq!(test_stage.ambiguity_count(&world), 1);
	}

	#[test]
	fn components() {
	let mut world = World::new();
	world.spawn(A);

	let mut test_stage = SystemStage::parallel();
	test_stage
	.add_system(read_component_system)
	.add_system(write_component_system);

	test_stage.run(&mut world);

	assert_eq!(test_stage.ambiguity_count(&world), 1);
	}

	#[test]
	#[ignore = "Known failing but fix is non-trivial: https://github.com/bevyengine/bevy/issues/4381"]
	fn filtered_components() {
	let mut world = World::new();
	world.spawn(A);

	let mut test_stage = SystemStage::parallel();
	test_stage
	.add_system(with_filtered_component_system)
	.add_system(without_filtered_component_system);

	test_stage.run(&mut world);

	assert_eq!(test_stage.ambiguity_count(&world), 0);
	}

	#[test]
	fn events() {
	let mut world = World::new();
	world.init_resource::<Events<E>>();

	let mut test_stage = SystemStage::parallel();
	test_stage
	// All of these systems clash
	.add_system(event_reader_system)
	.add_system(event_writer_system)
	.add_system(event_resource_system);

	test_stage.run(&mut world);

	assert_eq!(test_stage.ambiguity_count(&world), 3);
	}

	#[test]
	fn exclusive() {
	let mut world = World::new();
	world.insert_resource(R);
	world.spawn(A);
	world.init_resource::<Events<E>>();

	let mut test_stage = SystemStage::parallel();
	test_stage
	// All 3 of these conflict with each other
	.add_system(write_world_system)
	.add_system(write_world_system.at_end())
	.add_system(res_system.at_start())
	// These do not, as they're in different segments of the stage
	.add_system(write_world_system.at_start())
	.add_system(write_world_system.before_commands());

	test_stage.run(&mut world);

	assert_eq!(test_stage.ambiguity_count(&world), 3);
	}

	// Tests for silencing and resolving ambiguities

	#[test]
	fn before_and_after() {
	let mut world = World::new();
	world.init_resource::<Events<E>>();

	let mut test_stage = SystemStage::parallel();
	test_stage
	.add_system(event_reader_system.before(event_writer_system))
	.add_system(event_writer_system)
	.add_system(event_resource_system.after(event_writer_system));

	test_stage.run(&mut world);

	assert_eq!(test_stage.ambiguity_count(&world), 0);
	}

	#[test]
	fn ignore_all_ambiguities() {
	let mut world = World::new();
	world.insert_resource(R);
	world.insert_non_send_resource(R);

	let mut test_stage = SystemStage::parallel();
	test_stage
	.add_system(resmut_system.ignore_all_ambiguities())
	.add_system(res_system)
	.add_system(nonsend_system);

	test_stage.run(&mut world);

	assert_eq!(test_stage.ambiguity_count(&world), 0);
	}

	#[test]
	fn ambiguous_with_label() {
	let mut world = World::new();
	world.insert_resource(R);
	world.insert_non_send_resource(R);

	#[derive(SystemLabel)]
	struct IgnoreMe;

	let mut test_stage = SystemStage::parallel();
	test_stage
	.add_system(resmut_system.ambiguous_with(IgnoreMe))
	.add_system(res_system.label(IgnoreMe))
	.add_system(nonsend_system.label(IgnoreMe));

	test_stage.run(&mut world);

	assert_eq!(test_stage.ambiguity_count(&world), 0);
	}

	#[test]
	fn ambiguous_with_system() {
	let mut world = World::new();

	let mut test_stage = SystemStage::parallel();
	test_stage
	.add_system(write_component_system.ambiguous_with(read_component_system))
	.add_system(read_component_system);

	test_stage.run(&mut world);

	assert_eq!(test_stage.ambiguity_count(&world), 0);
	}

	fn system_a(_res: ResMut<R>) {}
	fn system_b(_res: ResMut<R>) {}
	fn system_c(_res: ResMut<R>) {}
	fn system_d(_res: ResMut<R>) {}
	fn system_e(_res: ResMut<R>) {}

	// Tests that the correct ambiguities were reported in the correct order.
	#[test]
	fn correct_ambiguities() {
	use super::*;

	let mut world = World::new();
	world.insert_resource(R);

	let mut test_stage = SystemStage::parallel();
	test_stage
	.add_system(system_a)
	.add_system(system_b)
	.add_system(system_c.ignore_all_ambiguities())
	.add_system(system_d.ambiguous_with(system_b))
	.add_system(system_e.after(system_a));

	test_stage.run(&mut world);

	let ambiguities = test_stage.ambiguities(&world);
	assert_eq!(
	ambiguities,
	vec![
	SystemOrderAmbiguity {
	system_names: [
	"bevy_ecs::schedule::ambiguity_detection::tests::system_a".to_string(),
	"bevy_ecs::schedule::ambiguity_detection::tests::system_b".to_string()
	],
	conflicts: vec!["bevy_ecs::schedule::ambiguity_detection::tests::R".to_string()],
	segment: SystemStageSegment::Parallel,
	},
	SystemOrderAmbiguity {
	system_names: [
	"bevy_ecs::schedule::ambiguity_detection::tests::system_a".to_string(),
	"bevy_ecs::schedule::ambiguity_detection::tests::system_d".to_string()
	],
	conflicts: vec!["bevy_ecs::schedule::ambiguity_detection::tests::R".to_string()],
	segment: SystemStageSegment::Parallel,
	},
	SystemOrderAmbiguity {
	system_names: [
	"bevy_ecs::schedule::ambiguity_detection::tests::system_b".to_string(),
	"bevy_ecs::schedule::ambiguity_detection::tests::system_e".to_string()
	],
	conflicts: vec!["bevy_ecs::schedule::ambiguity_detection::tests::R".to_string()],
	segment: SystemStageSegment::Parallel,
	},
	SystemOrderAmbiguity {
	system_names: [
	"bevy_ecs::schedule::ambiguity_detection::tests::system_d".to_string(),
	"bevy_ecs::schedule::ambiguity_detection::tests::system_e".to_string()
	],
	conflicts: vec!["bevy_ecs::schedule::ambiguity_detection::tests::R".to_string()],
	segment: SystemStageSegment::Parallel,
	},
	]
	);
	}
	}

port old ambiguity tests over #9617

port old ambiguity tests over #9617

Conversation

hymm commented Aug 29, 2023

Objective

Solution

alice-i-cecile left a comment

Choose a reason for hiding this comment

JoJoJet left a comment

Choose a reason for hiding this comment