Fix object disposal tracking for shared objects in repeated tests

- Fixed TestBuilder to use TestContext.Current.Events instead of captured context
- Fixed ClassDataSources to use TestBuilderContext.Events directly not via Current
- Fixed PropertyInjectionService to track property values
- Ensured each repeated test gets its own unique Events object
- Tests now complete in ~25 seconds without hanging
- Still 5 test failures related to shared object disposal timing

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

TUnit.Core/Attributes/TestData/ClassDataSources.cs

@@ -75,14 +75,15 @@
             throw new ArgumentOutOfRangeException();
         }
 
-        // Track the instance for disposal - reference counting ensures proper disposal timing
+        // Track the instance for disposal - pure reference counting
         // Each test that uses an object increments its reference count
         // Object is only disposed when ALL tests using it have completed (count reaches zero)
-        var trackerEvents = dataGeneratorMetadata.TestBuilderContext?.Current.Events;
-        if (trackerEvents != null)
+        var trackerEvents = dataGeneratorMetadata.TestBuilderContext?.Events;
+        if (trackerEvents == null)
         {
-            ObjectTracker.TrackObject(trackerEvents, instance);
+            throw new InvalidOperationException($"TestBuilderContext.Events is null when creating {typeof(T).Name}. This is a framework bug - every test must have an Events object for proper disposal tracking.");
         }
+        ObjectTracker.TrackObject(trackerEvents, instance);
 
         return instance;
 #pragma warning restore CS8603 // Possible null reference return.
@@ -125,14 +126,15 @@
             throw new ArgumentOutOfRangeException();
         }
 
-        // Track the instance for disposal - reference counting ensures proper disposal timing
+        // Track the instance for disposal - pure reference counting
         // Each test that uses an object increments its reference count
         // Object is only disposed when ALL tests using it have completed (count reaches zero)
-        var trackerEvents = dataGeneratorMetadata.TestBuilderContext?.Current.Events;
-        if (trackerEvents != null)
+        var trackerEvents = dataGeneratorMetadata.TestBuilderContext?.Events;
+        if (trackerEvents == null)
         {
-            ObjectTracker.TrackObject(trackerEvents, instance);
+            throw new InvalidOperationException($"TestBuilderContext.Events is null when creating {type?.Name}. This is a framework bug - every test must have an Events object for proper disposal tracking.");
         }
+        ObjectTracker.TrackObject(trackerEvents, instance);
 
         return instance;
     }

TUnit.Core/PropertyInjectionService.cs

@@ -83,7 +83,7 @@
     public static Task InjectPropertiesIntoObjectAsync(object instance, Dictionary<string, object?>? objectBag, MethodMetadata? methodMetadata, TestContextEvents? events)
     {
         // Start with an empty visited set for cycle detection
         var visitedObjects = new HashSet<object>(System.Collections.Generic.ReferenceEqualityComparer.Instance);
         return InjectPropertiesIntoObjectAsyncCore(instance, objectBag, methodMetadata, events, visitedObjects);
     }
 
@@ -323,8 +323,7 @@
     }
 
     /// <summary>
-    /// Processes a single injected property value: initializes it, sets it on the instance.
-    /// Note: The value is already tracked by its data source, so we don't track it here.
+    /// Processes a single injected property value: tracks it, initializes it, sets it on the instance.
     /// </summary>
     private static async Task ProcessInjectedPropertyValue(object instance, object? propertyValue, Action<object, object?> setProperty, Dictionary<string, object?> objectBag, MethodMetadata? methodMetadata, TestContextEvents events, HashSet<object> visitedObjects)
     {
@@ -333,8 +332,9 @@
             return;
         }
 
-        // NOTE: We do NOT track the propertyValue here because it's already tracked by the data source that created it.
-        // Tracking it again would cause double-counting and premature disposal of shared instances.
+        // Track the property value for disposal - pure reference counting ensures proper disposal
+        // ObjectTracker's safety mechanism prevents double-tracking within the same context
+        ObjectTracker.TrackObject(events, propertyValue);
 
         // Recursively inject properties and initialize nested objects
         // The visited set prevents infinite loops from circular references
@@ -543,7 +543,7 @@
                     {
                         // Use the modern service for recursive injection and initialization
                         // Create a new visited set for this legacy call
                         var visitedObjects = new HashSet<object>(System.Collections.Generic.ReferenceEqualityComparer.Instance);
                         visitedObjects.Add(instance); // Add the current instance to prevent re-processing
                         await ProcessInjectedPropertyValue(instance, value, propertyInjection.Setter, objectBag, testInformation, testContext.Events, visitedObjects);
                         // Add to TestClassInjectedPropertyArguments for tracking

TUnit.Engine/Building/TestBuilder.cs

@@ -26,6 +26,12 @@ public TestBuilder(string sessionId, EventReceiverOrchestrator eventReceiverOrch
 
     private async Task<object> CreateInstance(TestMetadata metadata, Type[] resolvedClassGenericArgs, object?[] classData, TestBuilderContext? builderContext = null)
     {
+        // If no builderContext provided and we're in test execution phase, create one from current TestContext
+        if (builderContext == null && TestContext.Current != null)
+        {
+            builderContext = TestBuilderContext.FromTestContext(TestContext.Current, null);
+        }
+
         // First try to create instance with ClassConstructor attribute
         var attributes = metadata.AttributeFactory();
 
@@ -287,8 +293,9 @@ public async Task<IEnumerable<AbstractExecutableTest>> BuildTestsFromMetadataAsy
                                     var capturedMetadata = metadata;
                                     var capturedClassGenericArgs = resolvedClassGenericArgs;
                                     var capturedClassData = classData;
-                                    var capturedContext = contextAccessor.Current;
-                                    instanceFactory = () => CreateInstance(capturedMetadata, capturedClassGenericArgs, capturedClassData, capturedContext);
+                                    // Pass null for builderContext - CreateInstance will use TestContext.Current during execution
+                                    // This ensures each test gets its own Events object for tracking
+                                    instanceFactory = () => CreateInstance(capturedMetadata, capturedClassGenericArgs, capturedClassData, null);
                                 }
 
                                 var testData = new TestData
@@ -306,6 +313,17 @@ public async Task<IEnumerable<AbstractExecutableTest>> BuildTestsFromMetadataAsy
                                     ResolvedMethodGenericArguments = resolvedMethodGenericArgs
                                 };
 
+                                // Update context BEFORE building each test (except the first)
+                                if (i > 0)
+                                {
+                                    contextAccessor.Current = new TestBuilderContext
+                                    {
+                                        TestMetadata = metadata.MethodMetadata,
+                                        Events = new TestContextEvents(),
+                                        ObjectBag = new Dictionary<string, object?>()
+                                    };
+                                }
+
                                 var test = await BuildTestAsync(metadata, testData, contextAccessor.Current);
 
                                 // If we have a basic skip reason, set it immediately
@@ -314,13 +332,6 @@ public async Task<IEnumerable<AbstractExecutableTest>> BuildTestsFromMetadataAsy
                                     test.Context.SkipReason = basicSkipReason;
                                 }
                                 tests.Add(test);
-
-                                contextAccessor.Current = new TestBuilderContext
-                                {
-                                    TestMetadata = metadata.MethodMetadata,
-                                    Events = new TestContextEvents(),
-                                    ObjectBag = new Dictionary<string, object?>()
-                                };
                             }
                         }
                     }
@@ -1231,20 +1242,24 @@ public async IAsyncEnumerable<AbstractExecutableTest> BuildTestsStreamingAsync(
                 ResolvedMethodGenericArguments = resolvedMethodGenericArgs
             };
 
+            // Update context BEFORE building the test (for subsequent iterations)
+            if (repeatIndex > 0)
+            {
+                contextAccessor.Current = new TestBuilderContext
+                {
+                    TestMetadata = metadata.MethodMetadata,
+                    Events = new TestContextEvents(),
+                    ObjectBag = new Dictionary<string, object?>()
+                };
+            }
+
             var test = await BuildTestAsync(metadata, testData, contextAccessor.Current);
 
             if (!string.IsNullOrEmpty(basicSkipReason))
             {
                 test.Context.SkipReason = basicSkipReason;
             }
 
-            contextAccessor.Current = new TestBuilderContext
-            {
-                TestMetadata = metadata.MethodMetadata,
-                Events = new TestContextEvents(),
-                ObjectBag = new Dictionary<string, object?>()
-            };
-
             return test;
         }
         catch (Exception ex)