From c01a0006072f68ec1f7775a7327b78e73d7e52b1 Mon Sep 17 00:00:00 2001
From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com>
Date: Thu, 2 Oct 2025 18:30:43 +0100
Subject: [PATCH 1/4] refactor: move object initialization into centralised
 location

---
 .../StaticPropertyReflectionInitializer.cs    |   6 -
 .../Strategies/NestedPropertyStrategy.cs      |  10 --
 .../PropertyInitializationOrchestrator.cs     |  13 +-
 TUnit.Engine/TestInitializer.cs               |  11 ++
 TUnit.TestProject/Bugs/3266/Tests.cs          | 133 ++++++++++++++++++
 5 files changed, 145 insertions(+), 28 deletions(-)
 create mode 100644 TUnit.TestProject/Bugs/3266/Tests.cs

diff --git a/TUnit.Core/StaticPropertyReflectionInitializer.cs b/TUnit.Core/StaticPropertyReflectionInitializer.cs
index 72bcca272c..aa31ab09ed 100644
--- a/TUnit.Core/StaticPropertyReflectionInitializer.cs
+++ b/TUnit.Core/StaticPropertyReflectionInitializer.cs
@@ -124,12 +124,6 @@ private static async Task InitializeStaticProperty(Type type, PropertyInfo prope
                 // Set the property value
                 property.SetValue(null, value);
 
-                // Initialize the value if it's an object
-                if (value != null)
-                {
-                    await ObjectInitializer.InitializeAsync(value);
-                }
-
                 // Only use the first value for static properties
                 break;
             }
diff --git a/TUnit.Engine/Services/PropertyInitialization/Strategies/NestedPropertyStrategy.cs b/TUnit.Engine/Services/PropertyInitialization/Strategies/NestedPropertyStrategy.cs
index a338122494..45be31469d 100644
--- a/TUnit.Engine/Services/PropertyInitialization/Strategies/NestedPropertyStrategy.cs
+++ b/TUnit.Engine/Services/PropertyInitialization/Strategies/NestedPropertyStrategy.cs
@@ -55,13 +55,6 @@ public async Task InitializePropertyAsync(PropertyInitializationContext context)
         // Get the injection plan for this type
         var plan = PropertyInjectionCache.GetOrCreatePlan(propertyType);
 
-        if (!plan.HasProperties)
-        {
-            // No nested properties to inject, just initialize the object
-            await ObjectInitializer.InitializeAsync(propertyValue);
-            return;
-        }
-
         // Recursively inject properties into the nested object
         if (SourceRegistrar.IsEnabled)
         {
@@ -71,9 +64,6 @@ public async Task InitializePropertyAsync(PropertyInitializationContext context)
         {
             await ProcessReflectionNestedProperties(context, propertyValue, plan);
         }
-
-        // Initialize the object after all properties are set
-        await ObjectInitializer.InitializeAsync(propertyValue);
     }
 
     /// <summary>
diff --git a/TUnit.Engine/Services/PropertyInitializationOrchestrator.cs b/TUnit.Engine/Services/PropertyInitializationOrchestrator.cs
index cad96d5cef..87f93e11b4 100644
--- a/TUnit.Engine/Services/PropertyInitializationOrchestrator.cs
+++ b/TUnit.Engine/Services/PropertyInitializationOrchestrator.cs
@@ -94,13 +94,6 @@ public async Task InitializeObjectWithPropertiesAsync(
         TestContextEvents events,
         ConcurrentDictionary<object, byte> visitedObjects)
     {
-        if (!plan.HasProperties)
-        {
-            // No properties to inject, just initialize the object
-            await ObjectInitializer.InitializeAsync(instance);
-            return;
-        }
-
         // Initialize properties based on the mode
         // Properties will be fully initialized (including nested initialization) by the strategies
         if (SourceRegistrar.IsEnabled)
@@ -113,10 +106,6 @@ await InitializePropertiesAsync(
             await InitializePropertiesAsync(
                 instance, plan.ReflectionProperties, objectBag, methodMetadata, events, visitedObjects);
         }
-
-        // Initialize the object itself after all its properties are fully initialized
-        // This ensures properties are available when IAsyncInitializer.InitializeAsync() is called
-        await ObjectInitializer.InitializeAsync(instance);
     }
 
     /// <summary>
@@ -180,4 +169,4 @@ private PropertyInitializationContext CreateContext(
     /// <summary>
     /// Gets the singleton instance of the orchestrator.
     /// </summary>
-}
\ No newline at end of file
+}
diff --git a/TUnit.Engine/TestInitializer.cs b/TUnit.Engine/TestInitializer.cs
index 1b3454853c..60050ccc75 100644
--- a/TUnit.Engine/TestInitializer.cs
+++ b/TUnit.Engine/TestInitializer.cs
@@ -56,5 +56,16 @@ await _propertyInjectionService.InjectPropertiesIntoObjectAsync(
 
         // Shouldn't retrack already tracked objects, but will track any new ones created during retries / initialization
         _objectTracker.TrackObjects(test.Context);
+
+        // Initialize in reverse order (most nested first)
+        await Initialize(test.Context.TrackedObjects);
+    }
+
+    private async Task Initialize(HashSet<object> objects)
+    {
+        foreach (var obj in objects.Reverse())
+        {
+            await ObjectInitializer.InitializeAsync(obj);
+        }
     }
 }
diff --git a/TUnit.TestProject/Bugs/3266/Tests.cs b/TUnit.TestProject/Bugs/3266/Tests.cs
new file mode 100644
index 0000000000..f18ef81aed
--- /dev/null
+++ b/TUnit.TestProject/Bugs/3266/Tests.cs
@@ -0,0 +1,133 @@
+using TUnit.Core;
+using TUnit.Core.Interfaces;
+using TUnit.TestProject.Attributes;
+
+namespace TUnit.TestProject.Bugs.Bug3266;
+
+// Mock test container - shared per test session
+public class PulsarTestContainer : IAsyncInitializer, IAsyncDisposable
+{
+    public bool IsInitialized { get; private set; }
+    public bool IsDisposed { get; private set; }
+
+    public Task InitializeAsync()
+    {
+        IsInitialized = true;
+        return Task.CompletedTask;
+    }
+
+    public ValueTask DisposeAsync()
+    {
+        IsDisposed = true;
+        return default;
+    }
+}
+
+// Mock connection class - depends on PulsarTestContainer being initialized
+public class PulsarConnection : IAsyncInitializer, IAsyncDisposable
+{
+    [ClassDataSource<PulsarTestContainer>(Shared = SharedType.PerTestSession)]
+    public required PulsarTestContainer Container { get; init; }
+
+    public bool IsInitialized { get; private set; }
+    public bool IsDisposed { get; private set; }
+
+    public Task InitializeAsync()
+    {
+        // This should fail if Container.InitializeAsync() hasn't been called yet
+        if (!Container.IsInitialized)
+        {
+            throw new InvalidOperationException(
+                "PulsarConnection.InitializeAsync() called before nested Container property was initialized!");
+        }
+
+        IsInitialized = true;
+        return Task.CompletedTask;
+    }
+
+    public ValueTask DisposeAsync()
+    {
+        IsDisposed = true;
+        return default;
+    }
+}
+
+// Mock web app factory - also depends on PulsarTestContainer
+public class WebAppFactory : IAsyncInitializer, IAsyncDisposable
+{
+    [ClassDataSource<PulsarTestContainer>(Shared = SharedType.PerTestSession)]
+    public required PulsarTestContainer Container { get; init; }
+
+    public bool IsInitialized { get; private set; }
+    public bool IsDisposed { get; private set; }
+
+    public Task InitializeAsync()
+    {
+        // This should fail if Container.InitializeAsync() hasn't been called yet
+        if (!Container.IsInitialized)
+        {
+            throw new InvalidOperationException(
+                "WebAppFactory.InitializeAsync() called before nested Container property was initialized!");
+        }
+
+        IsInitialized = true;
+        return Task.CompletedTask;
+    }
+
+    public ValueTask DisposeAsync()
+    {
+        IsDisposed = true;
+        return default;
+    }
+}
+
+// Base abstract class with WebAppFactory property
+public abstract class AbstractClassA
+{
+    [ClassDataSource<WebAppFactory>(Shared = SharedType.None)]
+    public required WebAppFactory WebApp { get; init; }
+}
+
+// Middle abstract class with PulsarConnection property
+public abstract class AbstractClassB : AbstractClassA
+{
+    [ClassDataSource<PulsarConnection>(Shared = SharedType.None)]
+    public required PulsarConnection Connection { get; init; }
+}
+
+// Concrete test class - reproduces issue #3266
+[EngineTest(ExpectedResult.Pass)]
+[NotInParallel]
+public class Issue3266ReproTest : AbstractClassB
+{
+    [Test]
+    public async Task NestedPropertiesShouldBeInitializedBeforeParentInitializeAsync()
+    {
+        // Verify all nested containers are initialized
+        await Assert.That(Connection.Container.IsInitialized)
+            .IsTrue()
+            .Because("PulsarConnection's Container should be initialized");
+
+        await Assert.That(WebApp.Container.IsInitialized)
+            .IsTrue()
+            .Because("WebAppFactory's Container should be initialized");
+
+        // Verify parent objects are initialized
+        await Assert.That(Connection.IsInitialized)
+            .IsTrue()
+            .Because("PulsarConnection should be initialized");
+
+        await Assert.That(WebApp.IsInitialized)
+            .IsTrue()
+            .Because("WebAppFactory should be initialized");
+    }
+
+    [Test]
+    public async Task BothPropertiesShouldShareTheSameContainer()
+    {
+        // Since both use SharedType.PerTestSession, they should get the same instance
+        await Assert.That(Connection.Container)
+            .IsSameReferenceAs(WebApp.Container)
+            .Because("Both properties should share the same PulsarTestContainer instance");
+    }
+}

From 28fad9f5f0a74db0322c14d831ff0cfc25e08068 Mon Sep 17 00:00:00 2001
From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com>
Date: Thu, 2 Oct 2025 18:33:07 +0100
Subject: [PATCH 2/4] refactor: rename method and improve clarity in object
 initialization

---
 TUnit.Engine/TestInitializer.cs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/TUnit.Engine/TestInitializer.cs b/TUnit.Engine/TestInitializer.cs
index 60050ccc75..360de3c37b 100644
--- a/TUnit.Engine/TestInitializer.cs
+++ b/TUnit.Engine/TestInitializer.cs
@@ -57,13 +57,13 @@ await _propertyInjectionService.InjectPropertiesIntoObjectAsync(
         // Shouldn't retrack already tracked objects, but will track any new ones created during retries / initialization
         _objectTracker.TrackObjects(test.Context);
 
-        // Initialize in reverse order (most nested first)
-        await Initialize(test.Context.TrackedObjects);
+        await InitializeTrackedObjects(test.Context);
     }
 
-    private async Task Initialize(HashSet<object> objects)
+    private async Task InitializeTrackedObjects(TestContext testContext)
     {
-        foreach (var obj in objects.Reverse())
+        // Initialize in reverse order (most nested first)
+        foreach (var obj in testContext.TrackedObjects.Reverse())
         {
             await ObjectInitializer.InitializeAsync(obj);
         }

From d029a641081b9b05332e9cd01028033d1ffd3975 Mon Sep 17 00:00:00 2001
From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com>
Date: Thu, 2 Oct 2025 19:16:00 +0100
Subject: [PATCH 3/4] refactor: remove ObjectInitializationService and
 streamline test initialization process

---
 .idea/.idea.TUnit/.idea/workspace.xml         |  18 ++-
 .../Framework/TUnitServiceProvider.cs         |   4 +-
 .../Services/DataSourceInitializer.cs         |  10 +-
 .../Services/ObjectInitializationService.cs   | 127 ------------------
 TUnit.Engine/TestInitializer.cs               |  25 +---
 5 files changed, 20 insertions(+), 164 deletions(-)
 delete mode 100644 TUnit.Engine/Services/ObjectInitializationService.cs

diff --git a/.idea/.idea.TUnit/.idea/workspace.xml b/.idea/.idea.TUnit/.idea/workspace.xml
index 82352ed992..80e9f39bf6 100644
--- a/.idea/.idea.TUnit/.idea/workspace.xml
+++ b/.idea/.idea.TUnit/.idea/workspace.xml
@@ -54,15 +54,21 @@
     <option name="LAST_RESOLUTION" value="IGNORE" />
   </component>
   <component name="HighlightingSettingsPerFile">
-    <setting file="mock://C:/git/TUnit/TUnit.Engine/Scheduling/TestScheduler.cs" root0="SKIP_HIGHLIGHTING" />
-    <setting file="file://$PROJECT_DIR$/TUnit.Engine/TrackableObjectGraphProvider.cs" root0="FORCE_HIGHLIGHTING" />
+    <setting file="file://$USER_HOME$/AppData/Local/Temp/SourceGeneratedDocuments/0CC7810EAB1F5E3E2B7BD713/TUnit.Assertions.SourceGenerator/TUnit.Assertions.SourceGenerator.Generators.AssertionMethodGenerator/CancellationTokenAssertionExtensions.g.cs" root0="FORCE_HIGHLIGHTING" />
+    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/DecompilerCache/decompiler/9a53c2c7156f4e7193f32fcc340ad65e6710/72/87d31d7d/Transaction.cs" root0="FORCE_HIGHLIGHTING" />
+    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/SourcesCache/2854ce6d56c18d0d837d3a3ef9c4f2c7c77691fa3528c8394986ac7ce7719/StackFrameIterator.cs" root0="FORCE_HIGHLIGHTING" />
+    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/SourcesCache/5d96a7a86ada1efba5ead3923ad2191c35df280a4dfc916a6b33294ff83a/Transaction.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/SourcesCache/d5561f79efcdcb327a3e980623699d6a9c240ed13dc902d741aaae1447bf852/Transaction.cs" root0="FORCE_HIGHLIGHTING" />
+    <setting file="mock://C:/git/TUnit/TUnit.Engine/Services/TestExecution/TestCoordinator.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="mock://C:/git/TUnit/TUnit.TestProject/Bugs/3219/ClassDataSourceRetryTests.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="file://$PROJECT_DIR$/TUnit.TestProject/TransactionTest.cs" root0="FORCE_HIGHLIGHTING" />
   </component>
   <component name="MetaFilesCheckinStateConfiguration" checkMetaFiles="false" />
-  <component name="PropertiesComponent"><![CDATA[{
-  "keyToString": {
-    "node.js.selected.package.tslint": "(autodetect)"
+  <component name="PropertiesComponent">{
+  &quot;keyToString&quot;: {
+    &quot;node.js.selected.package.tslint&quot;: &quot;(autodetect)&quot;
   }
-}]]></component>
+}</component>
   <component name="TaskManager">
     <servers />
   </component>
diff --git a/TUnit.Engine/Framework/TUnitServiceProvider.cs b/TUnit.Engine/Framework/TUnitServiceProvider.cs
index 6f974166a3..ee34998f8a 100644
--- a/TUnit.Engine/Framework/TUnitServiceProvider.cs
+++ b/TUnit.Engine/Framework/TUnitServiceProvider.cs
@@ -52,7 +52,6 @@ public ITestExecutionFilter? Filter
     public PropertyInjectionService PropertyInjectionService { get; }
     public DataSourceInitializer DataSourceInitializer { get; }
     public ObjectRegistrationService ObjectRegistrationService { get; }
-    public ObjectInitializationService ObjectInitializationService { get; }
     public bool AfterSessionHooksFailed { get; set; }
 
     public TUnitServiceProvider(IExtension extension,
@@ -89,7 +88,6 @@ public TUnitServiceProvider(IExtension extension,
 
         // NEW: Separate registration and execution services (replaces TestObjectInitializer)
         ObjectRegistrationService = Register(new ObjectRegistrationService(PropertyInjectionService));
-        ObjectInitializationService = Register(new ObjectInitializationService());
 
         // Initialize the circular dependencies
         PropertyInjectionService.Initialize(ObjectRegistrationService);
@@ -157,7 +155,7 @@ public TUnitServiceProvider(IExtension extension,
         // Create test finder service after discovery service so it can use its cache
         TestFinder = Register<ITestFinder>(new TestFinder(DiscoveryService));
 
-        var testInitializer = new TestInitializer(EventReceiverOrchestrator, ObjectInitializationService, PropertyInjectionService, objectTracker);
+        var testInitializer = new TestInitializer(EventReceiverOrchestrator, PropertyInjectionService, objectTracker);
 
         // Create the new TestCoordinator that orchestrates the granular services
         var testCoordinator = Register<ITestCoordinator>(
diff --git a/TUnit.Engine/Services/DataSourceInitializer.cs b/TUnit.Engine/Services/DataSourceInitializer.cs
index 8c53f413c7..f8f3d459c4 100644
--- a/TUnit.Engine/Services/DataSourceInitializer.cs
+++ b/TUnit.Engine/Services/DataSourceInitializer.cs
@@ -14,7 +14,7 @@ internal sealed class DataSourceInitializer
     private readonly Dictionary<object, Task> _initializationTasks = new();
     private readonly object _lock = new();
     private PropertyInjectionService? _propertyInjectionService;
-    
+
     public void Initialize(PropertyInjectionService propertyInjectionService)
     {
         _propertyInjectionService = propertyInjectionService;
@@ -77,14 +77,12 @@ private async Task InitializeDataSourceAsync(
                 await _propertyInjectionService.InjectPropertiesIntoObjectAsync(
                     dataSource, objectBag, methodMetadata, events);
             }
-            
+
             // Step 2: IAsyncInitializer
             if (dataSource is IAsyncInitializer asyncInitializer)
             {
-                await asyncInitializer.InitializeAsync();
+                await ObjectInitializer.InitializeAsync(asyncInitializer);
             }
-
-            // Note: Tracking is now handled by ObjectRegistrationService during registration phase
         }
         catch (Exception ex)
         {
@@ -103,4 +101,4 @@ public void ClearCache()
             _initializationTasks.Clear();
         }
     }
-}
\ No newline at end of file
+}
diff --git a/TUnit.Engine/Services/ObjectInitializationService.cs b/TUnit.Engine/Services/ObjectInitializationService.cs
deleted file mode 100644
index eed87564f3..0000000000
--- a/TUnit.Engine/Services/ObjectInitializationService.cs
+++ /dev/null
@@ -1,127 +0,0 @@
-using TUnit.Core;
-using TUnit.Core.Interfaces;
-using TUnit.Core.PropertyInjection;
-
-namespace TUnit.Engine.Services;
-
-/// <summary>
-/// Handles object initialization during the test execution phase.
-/// Responsibility: Call IAsyncInitializer.InitializeAsync() ONLY.
-/// Does NOT inject properties or track objects - that's already done during registration.
-/// </summary>
-internal sealed class ObjectInitializationService
-{
-    /// <summary>
-    /// Initializes an object by calling IAsyncInitializer.InitializeAsync() if implemented.
-    /// This is called during test execution, after registration phase is complete.
-    /// Recursively initializes all nested properties that implement IAsyncInitializer.
-    /// </summary>
-    public async Task InitializeAsync(object instance)
-    {
-        if (instance == null)
-        {
-            throw new ArgumentNullException(nameof(instance));
-        }
-
-#if NETSTANDARD2_0
-        var visitedObjects = new HashSet<object>(new ReferenceEqualityComparer());
-#else
-        var visitedObjects = new HashSet<object>(ReferenceEqualityComparer.Instance);
-#endif
-        await InitializeAsyncCore(instance, visitedObjects);
-    }
-
-    /// <summary>
-    /// Core initialization logic with cycle detection.
-    /// Recursively initializes an object and all its nested properties.
-    /// IMPORTANT: Nested properties are initialized FIRST (depth-first),
-    /// so they are ready before the parent's InitializeAsync is called.
-    /// </summary>
-    private async Task InitializeAsyncCore(object instance, HashSet<object> visitedObjects)
-    {
-        if (instance == null || !visitedObjects.Add(instance))
-        {
-            return; // Already visited or null - prevent cycles
-        }
-
-        // First, recursively initialize nested properties (depth-first)
-        // This ensures dependencies are ready before parent initialization
-        await InitializeNestedPropertiesAsync(instance, visitedObjects);
-
-        // Then call IAsyncInitializer on current instance
-        // At this point, all nested properties are fully initialized
-        if (instance is IAsyncInitializer asyncInitializer)
-        {
-            await asyncInitializer.InitializeAsync();
-        }
-    }
-
-    /// <summary>
-    /// Recursively initializes nested property values IN PARALLEL.
-    /// This ensures deeply nested objects are also initialized during execution phase,
-    /// and properties at the same level are initialized concurrently for performance.
-    /// </summary>
-    private async Task InitializeNestedPropertiesAsync(object instance, HashSet<object> visitedObjects)
-    {
-        var plan = PropertyInjectionCache.GetOrCreatePlan(instance.GetType());
-        if (!plan.HasProperties)
-        {
-            return;
-        }
-
-        var initializationTasks = new List<Task>();
-
-        if (SourceRegistrar.IsEnabled)
-        {
-            // Source-generated mode - initialize properties in parallel
-            foreach (var metadata in plan.SourceGeneratedProperties)
-            {
-                if (metadata.ContainingType == null)
-                {
-                    continue;
-                }
-
-                var property = metadata.ContainingType.GetProperty(metadata.PropertyName);
-                if (property != null && property.CanRead)
-                {
-                    var propertyValue = property.GetValue(instance);
-                    if (propertyValue != null)
-                    {
-                        // Recursively initialize nested property and its children (in parallel)
-                        initializationTasks.Add(InitializeAsyncCore(propertyValue, visitedObjects));
-                    }
-                }
-            }
-        }
-        else
-        {
-            // Reflection mode - initialize properties in parallel
-            foreach (var (property, _) in plan.ReflectionProperties)
-            {
-                var propertyValue = property.GetValue(instance);
-                if (propertyValue != null)
-                {
-                    // Recursively initialize nested property and its children (in parallel)
-                    initializationTasks.Add(InitializeAsyncCore(propertyValue, visitedObjects));
-                }
-            }
-        }
-
-        // Wait for all property initializations to complete
-        if (initializationTasks.Count > 0)
-        {
-            await Task.WhenAll(initializationTasks);
-        }
-    }
-
-#if NETSTANDARD2_0
-    /// <summary>
-    /// Reference equality comparer for .NET Standard 2.0 compatibility.
-    /// </summary>
-    private sealed class ReferenceEqualityComparer : IEqualityComparer<object>
-    {
-        public new bool Equals(object? x, object? y) => ReferenceEquals(x, y);
-        public int GetHashCode(object obj) => System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode(obj);
-    }
-#endif
-}
\ No newline at end of file
diff --git a/TUnit.Engine/TestInitializer.cs b/TUnit.Engine/TestInitializer.cs
index 360de3c37b..c8eec1d4e9 100644
--- a/TUnit.Engine/TestInitializer.cs
+++ b/TUnit.Engine/TestInitializer.cs
@@ -8,17 +8,14 @@ namespace TUnit.Engine;
 internal class TestInitializer
 {
     private readonly EventReceiverOrchestrator _eventReceiverOrchestrator;
-    private readonly ObjectInitializationService _objectInitializationService;
     private readonly PropertyInjectionService _propertyInjectionService;
     private readonly ObjectTracker _objectTracker;
 
     public TestInitializer(EventReceiverOrchestrator eventReceiverOrchestrator,
-        ObjectInitializationService objectInitializationService,
         PropertyInjectionService propertyInjectionService,
         ObjectTracker objectTracker)
     {
         _eventReceiverOrchestrator = eventReceiverOrchestrator;
-        _objectInitializationService = objectInitializationService;
         _propertyInjectionService = propertyInjectionService;
         _objectTracker = objectTracker;
     }
@@ -27,31 +24,12 @@ public async Task InitializeTest(AbstractExecutableTest test, CancellationToken
     {
         var testClassInstance = test.Context.TestDetails.ClassInstance;
 
-        // Step 1: Inject properties into test class instance
-        // This sets pre-resolved properties that were created during registration phase
         await _propertyInjectionService.InjectPropertiesIntoObjectAsync(
             testClassInstance,
             test.Context.ObjectBag,
             test.Context.TestDetails.MethodMetadata,
             test.Context.Events);
 
-        // Step 2: Initialize test method arguments
-        // Method arguments were already registered (property injection + tracking) during test discovery
-        // Now we need to call IAsyncInitializer on them before test execution
-        var methodArguments = test.Context.TestDetails.TestMethodArguments;
-        if (methodArguments != null && methodArguments.Length > 0)
-        {
-            var argumentTasks = methodArguments
-                .Where(arg => arg != null)
-                .Select(arg => _objectInitializationService.InitializeAsync(arg!))
-                .ToArray();
-            await Task.WhenAll(argumentTasks);
-        }
-
-        // Step 3: Call IAsyncInitializer on test class (execution-phase initialization)
-        await _objectInitializationService.InitializeAsync(testClassInstance);
-
-        // Step 4: Initialize and register all eligible objects including event receivers
         await _eventReceiverOrchestrator.InitializeAllEligibleObjectsAsync(test.Context, cancellationToken).ConfigureAwait(false);
 
         // Shouldn't retrack already tracked objects, but will track any new ones created during retries / initialization
@@ -67,5 +45,8 @@ private async Task InitializeTrackedObjects(TestContext testContext)
         {
             await ObjectInitializer.InitializeAsync(obj);
         }
+
+        // Finally, ensure the test class itself is initialized
+        await ObjectInitializer.InitializeAsync(testContext.TestDetails.ClassInstance);
     }
 }

From 7f5e0df96888a7e4c6a4c8b73f609893d4212dad Mon Sep 17 00:00:00 2001
From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com>
Date: Thu, 2 Oct 2025 19:59:26 +0100
Subject: [PATCH 4/4] refactor: replace HashSet with ConcurrentDictionary for
 tracked objects and update related methods

---
 TUnit.Core/TestContext.cs                     |  2 +-
 TUnit.Core/Tracking/ObjectTracker.cs          | 13 +++-
 .../Tracking/TrackableObjectGraphProvider.cs  | 68 +++++++------------
 .../Framework/TUnitServiceProvider.cs         |  2 +-
 .../Services/EventReceiverOrchestrator.cs     | 20 ++----
 TUnit.Engine/TestInitializer.cs               | 11 +--
 6 files changed, 49 insertions(+), 67 deletions(-)

diff --git a/TUnit.Core/TestContext.cs b/TUnit.Core/TestContext.cs
index c32c5f1e9c..62bc086615 100644
--- a/TUnit.Core/TestContext.cs
+++ b/TUnit.Core/TestContext.cs
@@ -316,7 +316,7 @@ public async Task ReregisterTestWithArguments(object?[]? methodArguments = null,
 
     internal AbstractExecutableTest InternalExecutableTest { get; set; } = null!;
 
-    internal HashSet<object> TrackedObjects { get; } = [];
+    internal ConcurrentDictionary<int, HashSet<object>> TrackedObjects { get; } = [];
 
     public DateTimeOffset? TestEnd { get; set; }
 
diff --git a/TUnit.Core/Tracking/ObjectTracker.cs b/TUnit.Core/Tracking/ObjectTracker.cs
index 03a95eb161..3626d9e890 100644
--- a/TUnit.Core/Tracking/ObjectTracker.cs
+++ b/TUnit.Core/Tracking/ObjectTracker.cs
@@ -13,9 +13,14 @@ internal class ObjectTracker(TrackableObjectGraphProvider trackableObjectGraphPr
 
     public void TrackObjects(TestContext testContext)
     {
-        var objects = trackableObjectGraphProvider.GetTrackableObjects(testContext);
+        var alreadyTracked = testContext.TrackedObjects.SelectMany(x => x.Value).ToHashSet();
 
-        foreach (var obj in objects)
+        var newTrackableObjects = trackableObjectGraphProvider.GetTrackableObjects(testContext)
+            .SelectMany(x => x.Value)
+            .Except(alreadyTracked)
+            .ToHashSet();
+
+        foreach (var obj in newTrackableObjects)
         {
             TrackObject(obj);
         }
@@ -23,7 +28,9 @@ public void TrackObjects(TestContext testContext)
 
     public async ValueTask UntrackObjects(TestContext testContext, List<Exception> cleanupExceptions)
     {
-        foreach (var obj in testContext.TrackedObjects)
+        foreach (var obj in testContext.TrackedObjects
+                     .SelectMany(x => x.Value)
+                     .ToHashSet())
         {
             try
             {
diff --git a/TUnit.Core/Tracking/TrackableObjectGraphProvider.cs b/TUnit.Core/Tracking/TrackableObjectGraphProvider.cs
index 2f07634d82..5e103f8086 100644
--- a/TUnit.Core/Tracking/TrackableObjectGraphProvider.cs
+++ b/TUnit.Core/Tracking/TrackableObjectGraphProvider.cs
@@ -1,3 +1,4 @@
+using System.Collections.Concurrent;
 using TUnit.Core.PropertyInjection;
 using TUnit.Core.StaticProperties;
 
@@ -5,7 +6,7 @@ namespace TUnit.Core.Tracking;
 
 internal class TrackableObjectGraphProvider
 {
-    public IEnumerable<object> GetTrackableObjects(TestContext testContext)
+    public ConcurrentDictionary<int, HashSet<object>> GetTrackableObjects(TestContext testContext)
     {
         var visitedObjects = testContext.TrackedObjects;
 
@@ -13,42 +14,39 @@ public IEnumerable<object> GetTrackableObjects(TestContext testContext)
 
         foreach (var classArgument in testDetails.TestClassArguments)
         {
-            if (classArgument != null && visitedObjects.Add(classArgument))
+            if (classArgument != null && visitedObjects.GetOrAdd(0, []).Add(classArgument))
             {
-                yield return classArgument;
-
-                foreach (var nested in GetNestedTrackableObjects(classArgument, visitedObjects))
-                {
-                    yield return nested;
-                }
+                AddNestedTrackableObjects(classArgument, visitedObjects, 1);
             }
         }
 
         foreach (var methodArgument in testDetails.TestMethodArguments)
         {
-            if (methodArgument != null && visitedObjects.Add(methodArgument))
+            if (methodArgument != null && visitedObjects.GetOrAdd(0, []).Add(methodArgument))
             {
-                yield return methodArgument;
-
-                foreach (var nested in GetNestedTrackableObjects(methodArgument, visitedObjects))
-                {
-                    yield return nested;
-                }
+                AddNestedTrackableObjects(methodArgument, visitedObjects, 1);
             }
         }
 
         foreach (var property in testDetails.TestClassInjectedPropertyArguments.Values)
         {
-            if (property != null && visitedObjects.Add(property))
+            if (property != null && visitedObjects.GetOrAdd(0, []).Add(property))
             {
-                yield return property;
-
-                foreach (var nested in GetNestedTrackableObjects(property, visitedObjects))
-                {
-                    yield return nested;
-                }
+                AddNestedTrackableObjects(property, visitedObjects, 1);
             }
         }
+
+        return visitedObjects;
+    }
+
+    private static void AddToLevel(Dictionary<int, List<object>> objectsByLevel, int level, object obj)
+    {
+        if (!objectsByLevel.TryGetValue(level, out var list))
+        {
+            list = [];
+            objectsByLevel[level] = list;
+        }
+        list.Add(obj);
     }
 
     /// <summary>
@@ -65,14 +63,8 @@ public IEnumerable<object> GetStaticPropertyTrackableObjects()
         }
     }
 
-    private IEnumerable<object> GetNestedTrackableObjects(object obj, HashSet<object> visitedObjects)
+    private void AddNestedTrackableObjects(object obj, ConcurrentDictionary<int, HashSet<object>> visitedObjects, int currentDepth)
     {
-        // Prevent infinite recursion on circular references
-        if (!visitedObjects.Add(obj))
-        {
-            yield break;
-        }
-
         var plan = PropertyInjectionCache.GetOrCreatePlan(obj.GetType());
 
         if(!SourceRegistrar.IsEnabled)
@@ -87,22 +79,17 @@ private IEnumerable<object> GetNestedTrackableObjects(object obj, HashSet<object
                 }
 
                 // Check if already visited before yielding to prevent duplicates
-                if (!visitedObjects.Add(value))
+                if (!visitedObjects.GetOrAdd(currentDepth, []).Add(value))
                 {
                     continue;
                 }
 
-                yield return value;
-
                 if (!PropertyInjectionCache.HasInjectableProperties(value.GetType()))
                 {
                     continue;
                 }
 
-                foreach (var nested in GetNestedTrackableObjects(value, visitedObjects))
-                {
-                    yield return nested;
-                }
+                AddNestedTrackableObjects(value, visitedObjects, currentDepth + 1);
             }
         }
         else
@@ -124,22 +111,17 @@ private IEnumerable<object> GetNestedTrackableObjects(object obj, HashSet<object
                 }
 
                 // Check if already visited before yielding to prevent duplicates
-                if (!visitedObjects.Add(value))
+                if (!visitedObjects.GetOrAdd(currentDepth, []).Add(value))
                 {
                     continue;
                 }
 
-                yield return value;
-
                 if (!PropertyInjectionCache.HasInjectableProperties(value.GetType()))
                 {
                     continue;
                 }
 
-                foreach (var nested in GetNestedTrackableObjects(value, visitedObjects))
-                {
-                    yield return nested;
-                }
+                AddNestedTrackableObjects(value, visitedObjects, currentDepth + 1);
             }
         }
     }
diff --git a/TUnit.Engine/Framework/TUnitServiceProvider.cs b/TUnit.Engine/Framework/TUnitServiceProvider.cs
index ee34998f8a..7f7fefa267 100644
--- a/TUnit.Engine/Framework/TUnitServiceProvider.cs
+++ b/TUnit.Engine/Framework/TUnitServiceProvider.cs
@@ -113,7 +113,7 @@ public TUnitServiceProvider(IExtension extension,
 
         CancellationToken = Register(new EngineCancellationToken());
 
-        EventReceiverOrchestrator = Register(new EventReceiverOrchestrator(Logger));
+        EventReceiverOrchestrator = Register(new EventReceiverOrchestrator(Logger, trackableObjectGraphProvider));
         HookCollectionService = Register<IHookCollectionService>(new HookCollectionService(EventReceiverOrchestrator));
 
         ParallelLimitLockProvider = Register(new ParallelLimitLockProvider());
diff --git a/TUnit.Engine/Services/EventReceiverOrchestrator.cs b/TUnit.Engine/Services/EventReceiverOrchestrator.cs
index 9b53c54c27..eebc31be2c 100644
--- a/TUnit.Engine/Services/EventReceiverOrchestrator.cs
+++ b/TUnit.Engine/Services/EventReceiverOrchestrator.cs
@@ -4,6 +4,7 @@
 using TUnit.Core.Data;
 using TUnit.Core.Helpers;
 using TUnit.Core.Interfaces;
+using TUnit.Core.Tracking;
 using TUnit.Engine.Events;
 using TUnit.Engine.Extensions;
 using TUnit.Engine.Logging;
@@ -16,6 +17,7 @@ internal sealed class EventReceiverOrchestrator : IDisposable
 {
     private readonly EventReceiverRegistry _registry = new();
     private readonly TUnitFrameworkLogger _logger;
+    private readonly TrackableObjectGraphProvider _trackableObjectGraphProvider;
 
     // Track which assemblies/classes/sessions have had their "first" event invoked
     private ThreadSafeDictionary<string, Task> _firstTestInAssemblyTasks = new();
@@ -33,25 +35,22 @@ internal sealed class EventReceiverOrchestrator : IDisposable
     // Track registered First event receiver types to avoid duplicate registrations
     private readonly ConcurrentHashSet<Type> _registeredFirstEventReceiverTypes = new();
 
-    public EventReceiverOrchestrator(TUnitFrameworkLogger logger)
+    public EventReceiverOrchestrator(TUnitFrameworkLogger logger, TrackableObjectGraphProvider trackableObjectGraphProvider)
     {
         _logger = logger;
+        _trackableObjectGraphProvider = trackableObjectGraphProvider;
     }
 
-    public async ValueTask InitializeAllEligibleObjectsAsync(TestContext context, CancellationToken cancellationToken)
+    public void RegisterReceivers(TestContext context, CancellationToken cancellationToken)
     {
         var eligibleObjects = context.GetEligibleEventObjects().ToArray();
 
-        // Only initialize and register objects that haven't been processed yet
-        var newObjects = new List<object>();
         var objectsToRegister = new List<object>();
 
         foreach (var obj in eligibleObjects)
         {
             if (_initializedObjects.Add(obj)) // Add returns false if already present
             {
-                newObjects.Add(obj);
-
                 // For First event receivers, only register one instance per type
                 var objType = obj.GetType();
                 bool isFirstEventReceiver = obj is IFirstTestInTestSessionEventReceiver ||
@@ -80,15 +79,6 @@ obj is IFirstTestInAssemblyEventReceiver ||
             // Register only the objects that should be registered
             _registry.RegisterReceivers(objectsToRegister);
         }
-
-        if (newObjects.Count > 0)
-        {
-            // Initialize all new objects (even if not registered)
-            foreach (var obj in newObjects)
-            {
-                await ObjectInitializer.InitializeAsync(obj, cancellationToken);
-            }
-        }
     }
 
 
diff --git a/TUnit.Engine/TestInitializer.cs b/TUnit.Engine/TestInitializer.cs
index c8eec1d4e9..09e5859366 100644
--- a/TUnit.Engine/TestInitializer.cs
+++ b/TUnit.Engine/TestInitializer.cs
@@ -30,7 +30,7 @@ await _propertyInjectionService.InjectPropertiesIntoObjectAsync(
             test.Context.TestDetails.MethodMetadata,
             test.Context.Events);
 
-        await _eventReceiverOrchestrator.InitializeAllEligibleObjectsAsync(test.Context, cancellationToken).ConfigureAwait(false);
+        _eventReceiverOrchestrator.RegisterReceivers(test.Context, cancellationToken);
 
         // Shouldn't retrack already tracked objects, but will track any new ones created during retries / initialization
         _objectTracker.TrackObjects(test.Context);
@@ -40,10 +40,13 @@ await _propertyInjectionService.InjectPropertiesIntoObjectAsync(
 
     private async Task InitializeTrackedObjects(TestContext testContext)
     {
-        // Initialize in reverse order (most nested first)
-        foreach (var obj in testContext.TrackedObjects.Reverse())
+        // Initialize by level (deepest first), with objects at the same level in parallel
+        var levels = testContext.TrackedObjects.Keys.OrderByDescending(level => level);
+
+        foreach (var level in levels)
         {
-            await ObjectInitializer.InitializeAsync(obj);
+            var objectsAtLevel = testContext.TrackedObjects[level];
+            await Task.WhenAll(objectsAtLevel.Select(obj => ObjectInitializer.InitializeAsync(obj).AsTask()));
         }
 
         // Finally, ensure the test class itself is initialized