com.wallstop-studios.unity-helpers 2.0.0-rc81.9 → 2.0.1

package/Tests/Runtime/Integrations/Zenject/RelationalComponentsZenjectTests.cs

@@ -11,32 +11,19 @@ namespace WallstopStudios.UnityHelpers.Tests.Integrations.Zenject
     using WallstopStudios.UnityHelpers.Core.Attributes;
     using WallstopStudios.UnityHelpers.Integrations.Zenject;
     using WallstopStudios.UnityHelpers.Tags;
+    using WallstopStudios.UnityHelpers.Tests.TestUtils;
 
-    public sealed class RelationalComponentsZenjectTests
+    public sealed class RelationalComponentsZenjectTests : CommonTestBase
     {
         private DiContainer Container;
 
         [SetUp]
         public void Setup()
         {
+            ReflexTestSupport.EnsureReflexSettings();
             Container = new DiContainer();
         }
 
-        private readonly List<GameObject> _spawned = new();
-
-        [TearDown]
-        public void Cleanup()
-        {
-            for (int i = 0; i < _spawned.Count; i++)
-            {
-                if (_spawned[i] != null)
-                {
-                    UnityEngine.Object.DestroyImmediate(_spawned[i]);
-                }
-            }
-            _spawned.Clear();
-        }
-
         [Test]
         public void ContainerExtensionsUseBoundAssigner()
         {
@@ -57,14 +44,12 @@ namespace WallstopStudios.UnityHelpers.Tests.Integrations.Zenject
                 Is.SameAs(tester),
                 "Assigner should receive the same component instance"
             );
-            Assert.That(
-                tester.parentBody,
-                Is.Not.Null,
+            Assert.IsTrue(
+                tester.parentBody != null,
                 "ParentComponent assignment should set parentBody"
             );
-            Assert.That(
-                tester.childCollider,
-                Is.Not.Null,
+            Assert.IsTrue(
+                tester.childCollider != null,
                 "ChildComponent assignment should set childCollider"
             );
         }
@@ -76,14 +61,12 @@ namespace WallstopStudios.UnityHelpers.Tests.Integrations.Zenject
 
             Container.AssignRelationalComponents(tester);
 
-            Assert.That(
-                tester.parentBody,
-                Is.Not.Null,
+            Assert.IsTrue(
+                tester.parentBody != null,
                 "Fallback should assign parentBody without a bound assigner"
             );
-            Assert.That(
-                tester.childCollider,
-                Is.Not.Null,
+            Assert.IsTrue(
+                tester.childCollider != null,
                 "Fallback should assign childCollider without a bound assigner"
             );
         }
@@ -92,126 +75,194 @@ namespace WallstopStudios.UnityHelpers.Tests.Integrations.Zenject
         public System.Collections.IEnumerator SceneInitializerAssignsActiveSceneComponents()
         {
             AttributeMetadataCache cache = CreateCacheFor(typeof(ZenjectRelationalTester));
-            try
-            {
-                Container.BindInstance(cache);
-                RecordingAssigner assigner = new();
-                Container.Bind<IRelationalComponentAssigner>().FromInstance(assigner);
-                Container.BindInstance(RelationalSceneAssignmentOptions.Default);
-                Container.BindInterfacesTo<RelationalComponentSceneInitializer>().AsSingle();
-
-                Scene scene = SceneManager.CreateScene("ZenjectTestScene_Active");
-                SceneManager.SetActiveScene(scene);
-                ZenjectRelationalTester tester = CreateHierarchy();
-                GameObject root = tester.transform.root.gameObject;
-                SceneManager.MoveGameObjectToScene(root, scene);
-                yield return null;
-
-                IInitializable initializer = Container.Resolve<IInitializable>();
-                initializer.Initialize();
-                yield return null;
-
-                Assert.That(
-                    assigner.CallCount,
-                    Is.EqualTo(1),
-                    "Initializer should invoke assigner exactly once for the tester component"
-                );
-                Assert.That(
-                    assigner.LastComponent,
-                    Is.SameAs(tester),
-                    "Initializer should target the created tester instance"
-                );
-            }
-            finally
-            {
-                if (cache != null)
-                {
-                    UnityEngine.Object.DestroyImmediate(cache);
-                }
-            }
+            Container.BindInstance(cache);
+            RecordingAssigner assigner = new();
+            Container.Bind<IRelationalComponentAssigner>().FromInstance(assigner);
+            Container.BindInstance(RelationalSceneAssignmentOptions.Default);
+            Container.BindInterfacesTo<RelationalComponentSceneInitializer>().AsSingle();
+
+            Scene scene = CreateTempScene("ZenjectTestScene_Active");
+            ZenjectRelationalTester tester = CreateHierarchy();
+            GameObject root = tester.transform.root.gameObject;
+            SceneManager.MoveGameObjectToScene(root, scene);
+            yield return null;
+
+            IInitializable initializer = Container.Resolve<IInitializable>();
+            initializer.Initialize();
+            yield return null;
+
+            Assert.That(
+                assigner.CallCount,
+                Is.EqualTo(1),
+                "Initializer should invoke assigner exactly once for the tester component"
+            );
+            Assert.That(
+                assigner.LastComponent,
+                Is.SameAs(tester),
+                "Initializer should target the created tester instance"
+            );
         }
 
         [UnityTest]
         public System.Collections.IEnumerator SceneInitializerSkipsInactiveWhenOptionDisabled()
         {
             AttributeMetadataCache cache = CreateCacheFor(typeof(ZenjectRelationalTester));
-            try
-            {
-                Container.BindInstance(cache);
-                RecordingAssigner assigner = new();
-                Container.Bind<IRelationalComponentAssigner>().FromInstance(assigner);
-                Container.BindInstance(new RelationalSceneAssignmentOptions(false));
-                Container.BindInterfacesTo<RelationalComponentSceneInitializer>().AsSingle();
-
-                Scene scene = SceneManager.CreateScene("ZenjectTestScene_InactiveFalse");
-                SceneManager.SetActiveScene(scene);
-                ZenjectRelationalTester tester = CreateHierarchy();
-                tester.gameObject.SetActive(false);
-                GameObject root = tester.transform.root.gameObject;
-                SceneManager.MoveGameObjectToScene(root, scene);
-                yield return null;
-
-                IInitializable initializer = Container.Resolve<IInitializable>();
-                initializer.Initialize();
-                yield return null;
-
-                Assert.That(
-                    assigner.CallCount,
-                    Is.EqualTo(0),
-                    "Initializer should skip inactive tester when IncludeInactive is false"
-                );
-            }
-            finally
-            {
-                if (cache != null)
-                {
-                    UnityEngine.Object.DestroyImmediate(cache);
-                }
-            }
+            Container.BindInstance(cache);
+            RecordingAssigner assigner = new();
+            Container.Bind<IRelationalComponentAssigner>().FromInstance(assigner);
+            Container.BindInstance(new RelationalSceneAssignmentOptions(false));
+            Container.BindInterfacesTo<RelationalComponentSceneInitializer>().AsSingle();
+
+            Scene scene = CreateTempScene("ZenjectTestScene_InactiveFalse");
+            ZenjectRelationalTester tester = CreateHierarchy();
+            tester.gameObject.SetActive(false);
+            GameObject root = tester.transform.root.gameObject;
+            SceneManager.MoveGameObjectToScene(root, scene);
+            yield return null;
+
+            IInitializable initializer = Container.Resolve<IInitializable>();
+            initializer.Initialize();
+            yield return null;
+
+            Assert.That(
+                assigner.CallCount,
+                Is.EqualTo(0),
+                "Initializer should skip inactive tester when IncludeInactive is false"
+            );
         }
 
         [UnityTest]
         public System.Collections.IEnumerator SceneInitializerIncludesInactiveWhenOptionEnabled()
         {
             AttributeMetadataCache cache = CreateCacheFor(typeof(ZenjectRelationalTester));
-            try
-            {
-                Container.BindInstance(cache);
-                RecordingAssigner assigner = new();
-                Container.Bind<IRelationalComponentAssigner>().FromInstance(assigner);
-                Container.BindInstance(new RelationalSceneAssignmentOptions(true));
-                Container.BindInterfacesTo<RelationalComponentSceneInitializer>().AsSingle();
-
-                Scene scene = SceneManager.CreateScene("ZenjectTestScene_InactiveTrue");
-                SceneManager.SetActiveScene(scene);
-                ZenjectRelationalTester tester = CreateHierarchy();
-                tester.gameObject.SetActive(false);
-                GameObject root = tester.transform.root.gameObject;
-                SceneManager.MoveGameObjectToScene(root, scene);
-                yield return null;
-
-                IInitializable initializer = Container.Resolve<IInitializable>();
-                initializer.Initialize();
-                yield return null;
-
-                Assert.That(
-                    assigner.CallCount,
-                    Is.EqualTo(1),
-                    "Initializer should include inactive tester when IncludeInactive is true"
-                );
-                Assert.That(
-                    assigner.LastComponent,
-                    Is.SameAs(tester),
-                    "Initializer should target the inactive tester component"
-                );
-            }
-            finally
-            {
-                if (cache != null)
-                {
-                    UnityEngine.Object.DestroyImmediate(cache);
-                }
-            }
+            Container.BindInstance(cache);
+            RecordingAssigner assigner = new();
+            Container.Bind<IRelationalComponentAssigner>().FromInstance(assigner);
+            Container.BindInstance(new RelationalSceneAssignmentOptions(true));
+            Container.BindInterfacesTo<RelationalComponentSceneInitializer>().AsSingle();
+
+            Scene scene = CreateTempScene("ZenjectTestScene_InactiveTrue");
+            ZenjectRelationalTester tester = CreateHierarchy();
+            tester.gameObject.SetActive(false);
+            GameObject root = tester.transform.root.gameObject;
+            SceneManager.MoveGameObjectToScene(root, scene);
+            yield return null;
+
+            IInitializable initializer = Container.Resolve<IInitializable>();
+            initializer.Initialize();
+            yield return null;
+
+            Assert.That(
+                assigner.CallCount,
+                Is.EqualTo(1),
+                "Initializer should include inactive tester when IncludeInactive is true"
+            );
+            Assert.That(
+                assigner.LastComponent,
+                Is.SameAs(tester),
+                "Initializer should target the inactive tester component"
+            );
+        }
+
+        [UnityTest]
+        public System.Collections.IEnumerator SceneInitializerUsesMultiPassWhenConfigured()
+        {
+            AttributeMetadataCache cache = CreateCacheFor(typeof(ZenjectRelationalTester));
+            Container.BindInstance(cache);
+            RecordingAssigner assigner = new();
+            Container.Bind<IRelationalComponentAssigner>().FromInstance(assigner);
+            Container.BindInstance(
+                new RelationalSceneAssignmentOptions(true, useSinglePassScan: false)
+            );
+            Container.BindInterfacesTo<RelationalComponentSceneInitializer>().AsSingle();
+
+            Scene scene = CreateTempScene("ZenjectMultiPassScene");
+            ZenjectRelationalTester tester = CreateHierarchy();
+            SceneManager.MoveGameObjectToScene(tester.transform.root.gameObject, scene);
+            yield return null;
+
+            IInitializable initializer = Container.Resolve<IInitializable>();
+            initializer.Initialize();
+            yield return null;
+
+            Assert.That(
+                assigner.CallCount,
+                Is.EqualTo(1),
+                "Multi-pass configuration should assign each relational component once"
+            );
+            Assert.That(
+                assigner.LastComponent,
+                Is.SameAs(tester),
+                "Multi-pass configuration should target the tester in the active scene"
+            );
+        }
+
+        [UnityTest]
+        public System.Collections.IEnumerator SceneLoadListenerAssignsAdditiveSceneSinglePass()
+        {
+            AttributeMetadataCache cache = CreateCacheFor(typeof(ZenjectRelationalTester));
+            RelationalComponentAssigner assigner = new(cache);
+            RelationalSceneAssignmentOptions options = new(
+                includeInactive: true,
+                useSinglePassScan: true
+            );
+            RelationalSceneLoadListener listener = new(assigner, cache, options);
+            listener.Initialize();
+            TrackDisposable(listener);
+
+            Scene additive = CreateTempScene("Zenject_Additive_Runtime_Single", setActive: false);
+
+            ZenjectRelationalTester tester = CreateHierarchy();
+            GameObject root = tester.transform.root.gameObject;
+            SceneManager.MoveGameObjectToScene(root, additive);
+
+            yield return null;
+
+            listener.OnSceneLoaded(additive, LoadSceneMode.Additive);
+            yield return null;
+
+            Assert.IsTrue(
+                tester.parentBody != null,
+                "Scene load listener should assign parentBody in single-pass mode"
+            );
+            Assert.IsTrue(
+                tester.childCollider != null,
+                "Scene load listener should assign childCollider in single-pass mode"
+            );
+        }
+
+        [UnityTest]
+        public System.Collections.IEnumerator SceneLoadListenerAssignsAdditiveSceneMultiPass()
+        {
+            AttributeMetadataCache cache = CreateCacheFor(typeof(ZenjectRelationalTester));
+            RelationalComponentAssigner assigner = new(cache);
+            RelationalSceneAssignmentOptions options = new(
+                includeInactive: true,
+                useSinglePassScan: false
+            );
+            RelationalSceneLoadListener listener = new(assigner, cache, options);
+            listener.Initialize();
+            TrackDisposable(listener);
+
+            Scene additive = CreateTempScene("Zenject_Additive_Runtime_Multi", setActive: false);
+
+            ZenjectRelationalTester tester = CreateHierarchy();
+            GameObject root = tester.transform.root.gameObject;
+            SceneManager.MoveGameObjectToScene(root, additive);
+
+            yield return null;
+
+            listener.OnSceneLoaded(additive, LoadSceneMode.Additive);
+            yield return null;
+
+            Assert.IsTrue(
+                tester.parentBody != null,
+                "Scene load listener should assign parentBody in multi-pass mode"
+            );
+            Assert.IsTrue(
+                tester.childCollider != null,
+                "Scene load listener should assign childCollider in multi-pass mode"
+            );
         }
 
         [Test]
@@ -219,14 +270,12 @@ namespace WallstopStudios.UnityHelpers.Tests.Integrations.Zenject
         {
             ZenjectRelationalTester tester = CreateHierarchy();
             Container.AssignRelationalHierarchy(tester.gameObject, includeInactiveChildren: false);
-            Assert.That(
-                tester.parentBody,
-                Is.Not.Null,
+            Assert.IsTrue(
+                tester.parentBody != null,
                 "AssignRelationalHierarchy should assign parentBody"
             );
-            Assert.That(
-                tester.childCollider,
-                Is.Not.Null,
+            Assert.IsTrue(
+                tester.childCollider != null,
                 "AssignRelationalHierarchy should assign childCollider"
             );
         }
@@ -235,46 +284,35 @@ namespace WallstopStudios.UnityHelpers.Tests.Integrations.Zenject
         public System.Collections.IEnumerator SceneInitializerIgnoresNonActiveScenes()
         {
             AttributeMetadataCache cache = CreateCacheFor(typeof(ZenjectRelationalTester));
-            try
-            {
-                RecordingAssigner assigner = new();
-                Container.BindInstance(cache);
-                Container.Bind<IRelationalComponentAssigner>().FromInstance(assigner);
-                Container.BindInstance(new RelationalSceneAssignmentOptions(true));
-                Container.BindInterfacesTo<RelationalComponentSceneInitializer>().AsSingle();
-
-                Scene active = SceneManager.CreateScene("ZenjectActiveScene_Sep");
-                SceneManager.SetActiveScene(active);
-                ZenjectRelationalTester testerA = CreateHierarchy();
-                SceneManager.MoveGameObjectToScene(testerA.transform.root.gameObject, active);
-
-                Scene secondary = SceneManager.CreateScene("ZenjectSecondaryScene_Sep");
-                ZenjectRelationalTester testerB = CreateHierarchy();
-                SceneManager.MoveGameObjectToScene(testerB.transform.root.gameObject, secondary);
-                yield return null;
-
-                IInitializable initializer = Container.Resolve<IInitializable>();
-                initializer.Initialize();
-                yield return null;
-
-                Assert.That(
-                    assigner.CallCount,
-                    Is.EqualTo(1),
-                    "Initializer should only process components from the active scene"
-                );
-                Assert.That(
-                    assigner.LastComponent,
-                    Is.SameAs(testerA),
-                    "Active scene tester should be assigned"
-                );
-            }
-            finally
-            {
-                if (cache != null)
-                {
-                    UnityEngine.Object.DestroyImmediate(cache);
-                }
-            }
+            RecordingAssigner assigner = new();
+            Container.BindInstance(cache);
+            Container.Bind<IRelationalComponentAssigner>().FromInstance(assigner);
+            Container.BindInstance(new RelationalSceneAssignmentOptions(true));
+            Container.BindInterfacesTo<RelationalComponentSceneInitializer>().AsSingle();
+
+            Scene active = CreateTempScene("ZenjectActiveScene_Sep");
+            ZenjectRelationalTester testerA = CreateHierarchy();
+            SceneManager.MoveGameObjectToScene(testerA.transform.root.gameObject, active);
+
+            Scene secondary = CreateTempScene("ZenjectSecondaryScene_Sep", setActive: false);
+            ZenjectRelationalTester testerB = CreateHierarchy();
+            SceneManager.MoveGameObjectToScene(testerB.transform.root.gameObject, secondary);
+            yield return null;
+
+            IInitializable initializer = Container.Resolve<IInitializable>();
+            initializer.Initialize();
+            yield return null;
+
+            Assert.That(
+                assigner.CallCount,
+                Is.EqualTo(1),
+                "Initializer should only process components from the active scene"
+            );
+            Assert.That(
+                assigner.LastComponent,
+                Is.SameAs(testerA),
+                "Active scene tester should be assigned"
+            );
         }
 
         [Test]
@@ -298,24 +336,20 @@ namespace WallstopStudios.UnityHelpers.Tests.Integrations.Zenject
                 rootTester.gameObject,
                 includeInactiveChildren: false
             );
-            Assert.That(
-                rootTester.parentBody,
-                Is.Not.Null,
+            Assert.IsTrue(
+                rootTester.parentBody != null,
                 "Root tester should be assigned even when includeInactiveChildren is false"
             );
-            Assert.That(
-                rootTester.childCollider,
-                Is.Not.Null,
+            Assert.IsTrue(
+                rootTester.childCollider != null,
                 "Root tester should be assigned even when includeInactiveChildren is false"
             );
-            Assert.That(
-                subTester.parentBody,
-                Is.Null,
+            Assert.IsTrue(
+                subTester.parentBody == null,
                 "Inactive sub tester should be skipped when includeInactiveChildren is false"
             );
-            Assert.That(
-                subTester.childCollider,
-                Is.Null,
+            Assert.IsTrue(
+                subTester.childCollider == null,
                 "Inactive sub tester should be skipped when includeInactiveChildren is false"
             );
 
@@ -324,14 +358,12 @@ namespace WallstopStudios.UnityHelpers.Tests.Integrations.Zenject
                 rootTester.gameObject,
                 includeInactiveChildren: true
             );
-            Assert.That(
-                subTester.parentBody,
-                Is.Not.Null,
+            Assert.IsTrue(
+                subTester.parentBody != null,
                 "Inactive sub tester should be assigned when includeInactiveChildren is true"
             );
-            Assert.That(
-                subTester.childCollider,
-                Is.Not.Null,
+            Assert.IsTrue(
+                subTester.childCollider != null,
                 "Inactive sub tester should be assigned when includeInactiveChildren is true"
             );
         }
@@ -377,14 +409,12 @@ namespace WallstopStudios.UnityHelpers.Tests.Integrations.Zenject
                 Is.SameAs(instance),
                 "Instantiate should target the created tester instance"
             );
-            Assert.That(
-                instance.parentBody,
-                Is.Not.Null,
+            Assert.IsTrue(
+                instance.parentBody != null,
                 "ParentComponent should be assigned from override parent"
             );
-            Assert.That(
-                instance.childCollider,
-                Is.Not.Null,
+            Assert.IsTrue(
+                instance.childCollider != null,
                 "ChildComponent should be assigned from prefab child collider"
             );
         }
@@ -403,14 +433,12 @@ namespace WallstopStudios.UnityHelpers.Tests.Integrations.Zenject
             );
             Track(instance.gameObject);
 
-            Assert.That(
-                instance.parentBody,
-                Is.Not.Null,
+            Assert.IsTrue(
+                instance.parentBody != null,
                 "ParentComponent should be assigned from override parent without a bound assigner"
             );
-            Assert.That(
-                instance.childCollider,
-                Is.Not.Null,
+            Assert.IsTrue(
+                instance.childCollider != null,
                 "ChildComponent should be assigned without a bound assigner"
             );
         }
@@ -429,14 +457,12 @@ namespace WallstopStudios.UnityHelpers.Tests.Integrations.Zenject
             );
             Track(instance.gameObject);
 
-            Assert.That(
-                instance.parentBody,
-                Is.Not.Null,
+            Assert.IsTrue(
+                instance.parentBody != null,
                 "ParentComponent should be assigned from override parent"
             );
-            Assert.That(
-                instance.childCollider,
-                Is.Not.Null,
+            Assert.IsTrue(
+                instance.childCollider != null,
                 "ChildComponent should be assigned from prefab child collider"
             );
         }
@@ -485,27 +511,22 @@ namespace WallstopStudios.UnityHelpers.Tests.Integrations.Zenject
             return tester;
         }
 
-        private GameObject Track(GameObject gameObject)
+        private AttributeMetadataCache CreateCacheFor(Type componentType)
         {
-            _spawned.Add(gameObject);
-            return gameObject;
-        }
-
-        private static AttributeMetadataCache CreateCacheFor(Type componentType)
-        {
-            AttributeMetadataCache cache =
-                ScriptableObject.CreateInstance<AttributeMetadataCache>();
+            AttributeMetadataCache cache = Track(
+                ScriptableObject.CreateInstance<AttributeMetadataCache>()
+            );
 
             AttributeMetadataCache.RelationalFieldMetadata[] fields =
             {
-                new AttributeMetadataCache.RelationalFieldMetadata(
+                new(
                     nameof(ZenjectRelationalTester.parentBody),
                     AttributeMetadataCache.RelationalAttributeKind.Parent,
                     AttributeMetadataCache.FieldKind.Single,
                     typeof(Rigidbody).AssemblyQualifiedName,
                     isInterface: false
                 ),
-                new AttributeMetadataCache.RelationalFieldMetadata(
+                new(
                     nameof(ZenjectRelationalTester.childCollider),
                     AttributeMetadataCache.RelationalAttributeKind.Child,
                     AttributeMetadataCache.FieldKind.Single,
@@ -516,10 +537,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Integrations.Zenject
 
             AttributeMetadataCache.RelationalTypeMetadata[] relationalTypes =
             {
-                new AttributeMetadataCache.RelationalTypeMetadata(
-                    componentType.AssemblyQualifiedName,
-                    fields
-                ),
+                new(componentType.AssemblyQualifiedName, fields),
             };
 
             cache._relationalTypeMetadata = relationalTypes;

package/Tests/Runtime/Performance/RandomPerformanceTests.cs

@@ -41,7 +41,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Performance
             BenchmarkReadmeUpdater.UpdateSection(
                 "RANDOM_BENCHMARKS",
                 tableLines,
-                "RANDOM_PERFORMANCE.md"
+                "Docs/RANDOM_PERFORMANCE.md"
             );
 
             void LogRow(string row)

package/Tests/Runtime/Performance/SpatialTree2DPerformanceTests.cs

@@ -294,7 +294,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Performance
             BenchmarkReadmeUpdater.UpdateSection(
                 "SPATIAL_TREE_BENCHMARKS",
                 finalReadmeLines,
-                "SPATIAL_TREE_2D_PERFORMANCE.md"
+                "Docs/SPATIAL_TREE_2D_PERFORMANCE.md"
             );
 
             yield break;
@@ -428,6 +428,11 @@ namespace WallstopStudios.UnityHelpers.Tests.Performance
                 return lines;
             }
 
+            // Add an intermediate heading so tab headers (####) increment correctly from h3.
+            lines.Add("### Datasets");
+
+            lines.Add(string.Empty);
+
             lines.Add("<!-- tabs:start -->");
 
             lines.Add(string.Empty);