add more tests to printing and conversions

Author: makspll

crates/bevy_mod_scripting_core/src/bindings/pretty_print.rs

@@ -366,7 +366,7 @@ impl DisplayWithWorld for ReflectBaseType {
 impl DisplayWithWorld for TypeId {
     fn display_with_world(&self, world: WorldGuard) -> String {
         if *self == TypeId::of::<FakeType>() {
-            return "Dynamic Type".to_owned();
+            return "Unknown Type".to_owned();
         } else if *self == TypeId::of::<World>() {
             // does not implement Reflect, so we do this manually
             return "World".to_owned();
@@ -485,3 +485,113 @@ impl<T: DisplayWithWorld> DisplayWithWorld for Vec<T> {
         string
     }
 }
+
+#[cfg(test)]
+mod test {
+    use bevy::prelude::AppTypeRegistry;
+
+    use crate::bindings::{
+        function::script_function::AppScriptFunctionRegistry, AppReflectAllocator,
+        ReflectAllocationId, WorldAccessGuard,
+    };
+
+    use super::*;
+
+    fn setup_world() -> World {
+        let mut world = World::default();
+
+        let type_registry = AppTypeRegistry::default();
+        world.insert_resource(type_registry);
+
+        let allocator = AppReflectAllocator::default();
+        world.insert_resource(allocator);
+
+        let script_function_registry = AppScriptFunctionRegistry::default();
+        world.insert_resource(script_function_registry);
+
+        world
+    }
+
+    #[test]
+    fn test_type_id() {
+        let mut world = setup_world();
+        let world = WorldGuard::new(WorldAccessGuard::new(&mut world));
+
+        let type_id = TypeId::of::<usize>();
+        assert_eq!(type_id.display_with_world(world.clone()), "usize");
+        assert_eq!(type_id.display_value_with_world(world.clone()), "usize");
+        assert_eq!(type_id.display_without_world(), format!("{:?}", type_id));
+
+        let type_id = TypeId::of::<FakeType>();
+        assert_eq!(type_id.display_with_world(world.clone()), "Unknown Type");
+        assert_eq!(
+            type_id.display_value_with_world(world.clone()),
+            "Unknown Type"
+        );
+        assert_eq!(type_id.display_without_world(), format!("{:?}", type_id));
+    }
+
+    #[test]
+    fn test_reflect_base_type() {
+        let mut world = setup_world();
+        let world = WorldGuard::new(WorldAccessGuard::new(&mut world));
+
+        let type_id = TypeId::of::<usize>();
+
+        assert_eq!(
+            ReflectBaseType {
+                base_id: ReflectBase::Owned(ReflectAllocationId::new(0)),
+                type_id,
+            }
+            .display_with_world(world.clone()),
+            "Allocation(0)(usize)"
+        );
+
+        assert_eq!(
+            ReflectBaseType {
+                base_id: ReflectBase::Owned(ReflectAllocationId::new(0)),
+                type_id,
+            }
+            .display_value_with_world(world.clone()),
+            "Allocation(0)(usize)"
+        );
+
+        assert_eq!(
+            ReflectBaseType {
+                base_id: ReflectBase::Owned(ReflectAllocationId::new(0)),
+                type_id,
+            }
+            .display_without_world(),
+            format!("Allocation(0)({:?})", type_id)
+        );
+    }
+
+    #[test]
+    fn test_reflect_reference() {
+        let mut world = setup_world();
+
+        let world = WorldGuard::new(WorldAccessGuard::new(&mut world));
+
+        let type_id = TypeId::of::<usize>();
+
+        let allocator = world.allocator();
+        let mut allocator_write = allocator.write();
+        let reflect_reference = ReflectReference::new_allocated(2usize, &mut allocator_write);
+        drop(allocator_write);
+
+        assert_eq!(
+            reflect_reference.display_with_world(world.clone()),
+            "<Reference to Allocation(0)(usize) -> usize>"
+        );
+
+        assert_eq!(
+            reflect_reference.display_value_with_world(world.clone()),
+            "Reflect(usize(2))"
+        );
+
+        assert_eq!(
+            reflect_reference.display_without_world(),
+            format!("<Reference to Allocation(0)({:?})>", type_id)
+        );
+    }
+}

crates/bevy_mod_scripting_core/src/bindings/script_value.rs

@@ -182,3 +182,35 @@ impl TryFrom<ScriptValue> for ParsedPath {
         })
     }
 }
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_script_value_to_parsed_path() {
+        let value = ScriptValue::String("test".into());
+        let parsed_path = ParsedPath::from(vec![OffsetAccess {
+            access: bevy::reflect::Access::Field("test".to_owned().into()),
+            offset: Some(4),
+        }]);
+        assert_eq!(parsed_path, ParsedPath::try_from(value).unwrap());
+
+        let value = ScriptValue::String("_0".into());
+        let parsed_path = ParsedPath::from(vec![OffsetAccess {
+            access: bevy::reflect::Access::TupleIndex(0),
+            offset: Some(1),
+        }]);
+        assert_eq!(parsed_path, ParsedPath::try_from(value).unwrap());
+
+        let value = ScriptValue::Integer(0);
+        let parsed_path = ParsedPath::from(vec![OffsetAccess {
+            access: bevy::reflect::Access::ListIndex(0),
+            offset: Some(1),
+        }]);
+        assert_eq!(parsed_path, ParsedPath::try_from(value).unwrap());
+
+        let value = ScriptValue::Float(0.0);
+        assert!(ParsedPath::try_from(value).is_err());
+    }
+}