Fix race condition in pure reference counting object disposal system

TUnit.Core.SourceGenerator/CodeGenerators/StaticPropertyInitializationGenerator.cs

@@ -314,11 +314,13 @@ private static void GenerateAsyncDataSourceGeneratorWithProperty(CodeWriter writ
     {
         var generatorCode = CodeGenerationHelpers.GenerateAttributeInstantiation(attr);
         writer.AppendLine($"var generator = {generatorCode};");
+        writer.AppendLine("// Use the global static property context for disposal tracking");
+        writer.AppendLine("var globalContext = global::TUnit.Core.TestSessionContext.GlobalStaticPropertyContext;");
         writer.AppendLine("var metadata = new global::TUnit.Core.DataGeneratorMetadata");
         writer.AppendLine("{");
         writer.Indent();
         writer.AppendLine("Type = global::TUnit.Core.Enums.DataGeneratorType.Property,");
-        writer.AppendLine("TestBuilderContext = null,");
+        writer.AppendLine("TestBuilderContext = new global::TUnit.Core.TestBuilderContextAccessor(globalContext),");
         writer.AppendLine("MembersToGenerate = new global::TUnit.Core.MemberMetadata[] { propertyMetadata },");
         writer.AppendLine("TestInformation = null,");
         writer.AppendLine("TestSessionId = global::TUnit.Core.TestSessionContext.Current?.Id ?? \"static-property-init\",");

TUnit.Core/Attributes/TestData/ClassDataSources.cs

@@ -14,9 +14,24 @@ private ClassDataSources()
 
     public static readonly GetOnlyDictionary<string, ClassDataSources> SourcesPerSession = new();
 
-    public static ClassDataSources Get(string sessionId) => SourcesPerSession.GetOrAdd(sessionId, _ => new());
+    public static ClassDataSources Get(string sessionId)
+    {
+        var isNew = false;
+        var result = SourcesPerSession.GetOrAdd(sessionId, _ =>
+        {
+            isNew = true;
+            return new ClassDataSources();
+        });
+
+        if (isNew)
+        {
+            Console.WriteLine($"[ClassDataSources] Created new ClassDataSources for session {sessionId}");
+        }
+
+        return result;
+    }
 
-    public (T, SharedType, string) GetItemForIndexAsync<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicMethods)] T>(int index, Type? testClassType, SharedType[] sharedTypes, string[] keys, DataGeneratorMetadata dataGeneratorMetadata) where T : new()
+    public (T, SharedType, string) GetItemForIndexAsync<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicMethods)] T>(int index, Type testClassType, SharedType[] sharedTypes, string[] keys, DataGeneratorMetadata dataGeneratorMetadata) where T : new()
     {
         var shared = sharedTypes.ElementAtOrDefault(index);
 
@@ -37,82 +52,30 @@ private string GetKey(int index, SharedType[] sharedTypes, string[] keys)
         return keys.ElementAtOrDefault(keyedIndex) ?? throw new ArgumentException($"Key at index {keyedIndex} not found");
     }
 
-    public T Get<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicMethods)] T>(SharedType sharedType, Type? testClassType, string key, DataGeneratorMetadata dataGeneratorMetadata)
+    public T Get<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicMethods)] T>(SharedType sharedType, Type testClassType, string key, DataGeneratorMetadata dataGeneratorMetadata)
     {
-#pragma warning disable CS8603 // Possible null reference return.
-        if (sharedType == SharedType.None)
-        {
-            return Create<T>(dataGeneratorMetadata);
-        }
-
-        if (sharedType == SharedType.PerTestSession)
-        {
-            return (T) TestDataContainer.GetGlobalInstance(typeof(T), () => Create(typeof(T), dataGeneratorMetadata));
-        }
-
-        if (sharedType == SharedType.PerClass)
-        {
-            if (testClassType == null)
-            {
-                throw new InvalidOperationException($"Cannot use SharedType.PerClass without a test class type. This may occur during static property initialization.");
-            }
-            return (T) TestDataContainer.GetInstanceForClass(testClassType, typeof(T), () => Create(typeof(T), dataGeneratorMetadata));
-        }
-
-        if (sharedType == SharedType.Keyed)
+        return sharedType switch
         {
-            return (T) TestDataContainer.GetInstanceForKey(key, typeof(T), () => Create(typeof(T), dataGeneratorMetadata));
-        }
-
-        if (sharedType == SharedType.PerAssembly)
-        {
-            if (testClassType == null)
-            {
-                throw new InvalidOperationException($"Cannot use SharedType.PerAssembly without a test class type. This may occur during static property initialization.");
-            }
-            return (T) TestDataContainer.GetInstanceForAssembly(testClassType.Assembly, typeof(T), () => Create(typeof(T), dataGeneratorMetadata));
-        }
-#pragma warning restore CS8603 // Possible null reference return.
-
-        throw new ArgumentOutOfRangeException();
+            SharedType.None => Create<T>(dataGeneratorMetadata),
+            SharedType.PerTestSession => (T) TestDataContainer.GetGlobalInstance(typeof(T), _ => Create(typeof(T), dataGeneratorMetadata))!,
+            SharedType.PerClass => (T) TestDataContainer.GetInstanceForClass(testClassType, typeof(T), _ => Create(typeof(T), dataGeneratorMetadata))!,
+            SharedType.Keyed => (T) TestDataContainer.GetInstanceForKey(key, typeof(T), _ => Create(typeof(T), dataGeneratorMetadata))!,
+            SharedType.PerAssembly => (T) TestDataContainer.GetInstanceForAssembly(testClassType.Assembly, typeof(T), _ => Create(typeof(T), dataGeneratorMetadata))!,
+            _ => throw new ArgumentOutOfRangeException()
+        };
     }
 
-    public object Get(SharedType sharedType, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicMethods)] Type type, Type? testClassType, string? key, DataGeneratorMetadata dataGeneratorMetadata)
+    public object? Get(SharedType sharedType, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicMethods)] Type type, Type testClassType, string? key, DataGeneratorMetadata dataGeneratorMetadata)
     {
-        if (sharedType == SharedType.None)
-        {
-            return Create(type, dataGeneratorMetadata);
-        }
-
-        if (sharedType == SharedType.PerTestSession)
-        {
-            return TestDataContainer.GetGlobalInstance(type, () => Create(type, dataGeneratorMetadata));
-        }
-
-        if (sharedType == SharedType.PerClass)
-        {
-            if (testClassType == null)
-            {
-                throw new InvalidOperationException($"Cannot use SharedType.PerClass without a test class type. This may occur during static property initialization.");
-            }
-            return TestDataContainer.GetInstanceForClass(testClassType, type, () => Create(type, dataGeneratorMetadata));
-        }
-
-        if (sharedType == SharedType.Keyed)
+        return sharedType switch
         {
-            return TestDataContainer.GetInstanceForKey(key!, type, () => Create(type, dataGeneratorMetadata));
-        }
-
-        if (sharedType == SharedType.PerAssembly)
-        {
-            if (testClassType == null)
-            {
-                throw new InvalidOperationException($"Cannot use SharedType.PerAssembly without a test class type. This may occur during static property initialization.");
-            }
-            return TestDataContainer.GetInstanceForAssembly(testClassType.Assembly, type, () => Create(type, dataGeneratorMetadata));
-        }
-
-        throw new ArgumentOutOfRangeException();
+            SharedType.None => Create(type, dataGeneratorMetadata),
+            SharedType.PerTestSession => TestDataContainer.GetGlobalInstance(type, _ => Create(type, dataGeneratorMetadata)),
+            SharedType.PerClass => TestDataContainer.GetInstanceForClass(testClassType, type, _ => Create(type, dataGeneratorMetadata)),
+            SharedType.Keyed => TestDataContainer.GetInstanceForKey(key!, type, _ => Create(type, dataGeneratorMetadata)),
+            SharedType.PerAssembly => TestDataContainer.GetInstanceForAssembly(testClassType.Assembly, type, _ => Create(type, dataGeneratorMetadata)),
+            _ => throw new ArgumentOutOfRangeException()
+        };
     }
 
     [return: NotNull]
@@ -125,17 +88,7 @@ private static object Create([DynamicallyAccessedMembers(DynamicallyAccessedMemb
     {
         try
         {
-            var instance = Activator.CreateInstance(type)!;
-
-            // Track the created object
-            var trackerEvents2 = dataGeneratorMetadata.TestBuilderContext?.Current.Events;
-
-            if (trackerEvents2 != null)
-            {
-                ObjectTracker.TrackObject(trackerEvents2, instance);
-            }
-
-            return instance;
+            return Activator.CreateInstance(type)!;
         }
         catch (TargetInvocationException targetInvocationException)
         {

TUnit.Core/Attributes/TestData/DependencyInjectionDataSourceSourceAttribute.cs

@@ -16,7 +16,7 @@ public abstract class DependencyInjectionDataSourceAttribute<TScope> : UntypedDa
             {
                 if (scope is IAsyncDisposable asyncDisposable)
                 {
-                    await asyncDisposable.DisposeAsync();
+                    await asyncDisposable.DisposeAsync().ConfigureAwait(false);
                 }
                 else if (scope is IDisposable disposable)
                 {