Bring in @payload's tests from #1076

Author: alec-deason

crates/bevy_transform/src/components/children.rs

@@ -4,7 +4,7 @@ use bevy_utils::HashMap;
 use smallvec::SmallVec;
 use std::ops::Deref;
 
-#[derive(Default, Clone, Debug, Reflect)]
+#[derive(Default, Clone, Debug, Reflect, PartialEq, Eq)]
 #[reflect(Component, MapEntities)]
 pub struct Children {
     order: SmallVec<[Entity; 8]>,
@@ -86,8 +86,11 @@ impl Children {
     }
 
     pub(crate) fn insert(&mut self, index: usize, entities: &[Entity]) {
+        let initial_count = self.order.len();
         self.extend(entities.iter().cloned());
-        let mut desired_index = index;
+        let actually_inserted = self.order.len() - initial_count;
+        let mut desired_index =
+            (index as i32 - (entities.len() as i32 - actually_inserted as i32)).max(0) as usize;
         for entity in entities {
             let current_index = self.uniqueness[entity];
             if current_index != desired_index {

crates/bevy_transform/src/hierarchy/child_builder.rs

@@ -226,15 +226,15 @@ mod tests {
         let child1 = child1.expect("child1 should exist");
         let child2 = child2.expect("child2 should exist");
         let child3 = child3.expect("child3 should exist");
-        let expected_children: SmallVec<[Entity; 8]> = smallvec![child1, child2, child3];
+        let expected_children = vec![child1, child2, child3];
 
         assert_eq!(
             world
                 .get::<Children>(parent)
                 .unwrap()
                 .iter()
-                .cloned()
-                .collect::<SmallVec<[Entity; 8]>>(),
+                .copied()
+                .collect::<Vec<_>>(),
             expected_children
         );
         assert_eq!(*world.get::<Parent>(child1).unwrap(), Parent(parent));
@@ -250,110 +250,117 @@ mod tests {
         );
     }
 
-    #[test]
-    fn push_and_insert_children() {
+    fn setup() -> (World, Resources, Commands, Vec<Entity>, Entity) {
         let mut world = World::default();
-        let mut resources = Resources::default();
-        let mut commands = Commands::default();
+        let resources = Resources::default();
+        let commands = Commands::default();
         let entities = world
-            .spawn_batch(vec![(1,), (2,), (3,), (4,), (5,)])
+            .spawn_batch(vec![(0,), (1,), (2,), (3,), (4,)])
             .collect::<Vec<Entity>>();
+        let parent = entities[0];
+        (world, resources, commands, entities, parent)
+    }
 
-        commands.push_children(entities[0], &entities[1..3]);
+    #[test]
+    fn push_children_adds_parent_component() {
+        let (mut world, mut resources, mut commands, child, parent) = setup();
+        commands.push_children(parent, &child[1..=2]);
         commands.apply(&mut world, &mut resources);
+        assert_eq!(world.get::<Parent>(child[2]).unwrap(), &Parent(parent));
+    }
 
-        let parent = entities[0];
-        let child1 = entities[1];
-        let child2 = entities[2];
-        let child3 = entities[3];
-        let child4 = entities[4];
-
-        let expected_children: SmallVec<[Entity; 8]> = smallvec![child1, child2];
+    #[test]
+    fn push_children_adds_previous_parent_component() {
+        let (mut world, mut resources, mut commands, child, parent) = setup();
+        commands.push_children(parent, &child[1..=2]);
+        commands.apply(&mut world, &mut resources);
         assert_eq!(
-            world
-                .get::<Children>(parent)
-                .unwrap()
-                .iter()
-                .cloned()
-                .collect::<SmallVec<[Entity; 8]>>(),
-            expected_children
+            world.get::<PreviousParent>(child[2]).unwrap(),
+            &PreviousParent(parent)
         );
-        assert_eq!(*world.get::<Parent>(child1).unwrap(), Parent(parent));
-        assert_eq!(*world.get::<Parent>(child2).unwrap(), Parent(parent));
+    }
 
+    #[test]
+    fn push_children_adds_children_component() {
+        let (mut world, mut resources, mut commands, child, parent) = setup();
+        commands.push_children(parent, &child[1..=2]);
+        commands.apply(&mut world, &mut resources);
         assert_eq!(
-            *world.get::<PreviousParent>(child1).unwrap(),
-            PreviousParent(parent)
+            world.get::<Children>(parent).unwrap(),
+            &Children::with(&child[1..=2])
         );
+    }
+
+    #[test]
+    fn push_children_keeps_children_unique() {
+        let (mut world, mut resources, mut commands, child, parent) = setup();
+        commands.push_children(parent, &child[1..=2]);
+        commands.apply(&mut world, &mut resources);
+        commands.push_children(parent, &child[1..=2]);
+        commands.apply(&mut world, &mut resources);
         assert_eq!(
-            *world.get::<PreviousParent>(child2).unwrap(),
-            PreviousParent(parent)
+            world.get::<Children>(parent).unwrap(),
+            &Children::with(&child[1..=2])
         );
+    }
 
-        commands.insert_children(parent, 1, &entities[3..]);
+    #[test]
+    fn insert_children_adds_parent_component() {
+        let (mut world, mut resources, mut commands, child, parent) = setup();
+        commands.insert_children(parent, 0, &child[1..=2]);
         commands.apply(&mut world, &mut resources);
+        assert_eq!(world.get::<Parent>(child[2]).unwrap(), &Parent(parent));
+    }
 
-        let expected_children: SmallVec<[Entity; 8]> = smallvec![child1, child3, child4, child2];
+    #[test]
+    fn insert_children_adds_previous_parent_component() {
+        let (mut world, mut resources, mut commands, child, parent) = setup();
+        commands.insert_children(parent, 0, &child[1..=2]);
+        commands.apply(&mut world, &mut resources);
         assert_eq!(
-            world
-                .get::<Children>(parent)
-                .unwrap()
-                .iter()
-                .cloned()
-                .collect::<SmallVec<[Entity; 8]>>(),
-            expected_children
+            world.get::<PreviousParent>(child[2]).unwrap(),
+            &PreviousParent(parent)
         );
-        assert_eq!(*world.get::<Parent>(child3).unwrap(), Parent(parent));
-        assert_eq!(*world.get::<Parent>(child4).unwrap(), Parent(parent));
+    }
+
+    #[test]
+    fn insert_children_adds_children_component() {
+        let (mut world, mut resources, mut commands, child, parent) = setup();
+        commands.insert_children(parent, 0, &child[1..=2]);
+        commands.apply(&mut world, &mut resources);
         assert_eq!(
-            *world.get::<PreviousParent>(child3).unwrap(),
-            PreviousParent(parent)
+            world.get::<Children>(parent).unwrap(),
+            &Children::with(&child[1..=2])
         );
+    }
+
+    #[test]
+    fn insert_children_keeps_children_unique() {
+        let (mut world, mut resources, mut commands, child, parent) = setup();
+        commands.insert_children(parent, 0, &child[1..=2]);
+        commands.apply(&mut world, &mut resources);
+        commands.insert_children(parent, 1, &child[1..=2]);
+        commands.apply(&mut world, &mut resources);
         assert_eq!(
-            *world.get::<PreviousParent>(child4).unwrap(),
-            PreviousParent(parent)
+            world.get::<Children>(parent).unwrap(),
+            &Children::with(&child[1..=2])
         );
     }
 
     #[test]
-    fn push_duplicate_children() {
-        let mut world = World::default();
-        let mut resources = Resources::default();
-        let mut commands = Commands::default();
-        let entities = world
-            .spawn_batch(vec![(1,), (2,), (3,)])
-            .collect::<Vec<Entity>>();
-
-        let parent = entities[0];
-        let child1 = entities[1];
-        let child2 = entities[2];
-
-        commands.push_children(parent, &[child1, child1, child2, child1]);
+    fn insert_children_keeps_children_order() {
+        let (mut world, mut resources, mut commands, child, parent) = setup();
+        commands.insert_children(parent, 0, &child[1..=2]);
         commands.apply(&mut world, &mut resources);
-
-        let expected_children: SmallVec<[Entity; 8]> = smallvec![child2, child1];
         assert_eq!(
-            world
-                .get::<Children>(parent)
-                .unwrap()
-                .iter()
-                .cloned()
-                .collect::<SmallVec<[Entity; 8]>>(),
-            expected_children
+            world.get::<Children>(parent).unwrap(),
+            &Children::with(&[child[1], child[2]])
         );
-
-        commands.push_children(parent, &[child2]);
+        commands.insert_children(parent, 1, &child[3..=4]);
         commands.apply(&mut world, &mut resources);
-
-        let expected_children: SmallVec<[Entity; 8]> = smallvec![child1, child2];
         assert_eq!(
-            world
-                .get::<Children>(parent)
-                .unwrap()
-                .iter()
-                .cloned()
-                .collect::<SmallVec<[Entity; 8]>>(),
-            expected_children
+            world.get::<Children>(parent).unwrap(),
+            &Children::with(&[child[1], child[3], child[4], child[2]])
         );
     }
 }