From a62146235d86990319a86ef54ab95b9f79a58136 Mon Sep 17 00:00:00 2001 From: Tom Longhurst <30480171+thomhurst@users.noreply.github.com> Date: Tue, 3 Nov 2026 15:09:47 +0000 Subject: [PATCH] Fix session ownership of object tracker cleanup (#7475) --- src/TUnit.Core/Tracking/ObjectTracker.cs | 101 +++++++++++------- .../ObjectTrackerRollbackTests.cs | 52 ++++++++- .../StaticPropertyHandlerCleanupTests.cs | 11 +- 3 files changed, 122 insertions(+), 42 deletions(-) diff --git a/src/TUnit.Core/Tracking/ObjectTracker.cs b/src/TUnit.Core/Tracking/ObjectTracker.cs index aba391f19d4..3b2b5577c45 100644 --- a/src/TUnit.Core/Tracking/ObjectTracker.cs +++ b/src/TUnit.Core/Tracking/ObjectTracker.cs @@ -11,8 +11,7 @@ namespace TUnit.Core.Tracking; /// /// /// The static s_trackedObjects dictionary is shared across all tests. -/// Call at the end of a run session to -/// dispose any leftovers and release memory. +/// Each tracker owns its session references. Session cleanup releases only those references. /// internal class ObjectTracker(TrackableObjectGraphProvider trackableObjectGraphProvider, Disposer disposer) { @@ -20,8 +19,9 @@ internal class ObjectTracker(TrackableObjectGraphProvider trackableObjectGraphPr private static readonly ConcurrentDictionary s_trackedObjects = new(Helpers.ReferenceEqualityComparer.Instance); - // Serializes retiring a cached shared instance (count reached zero) with a running test taking - // a reference to it, so the instance is either retired or held, never both. + private readonly Dictionary _sessionReferences = new(Helpers.ReferenceEqualityComparer.Instance); + + // Keeps session ownership and global counts atomic with retirement and shared-instance holds. private static readonly object s_sharedInstanceLock = new(); // Collects errors from async disposal callbacks for post-session review @@ -34,24 +34,25 @@ internal class ObjectTracker(TrackableObjectGraphProvider trackableObjectGraphPr public static IReadOnlyCollection GetAsyncCallbackErrors() => s_asyncCallbackErrors.ToArray(); /// - /// Disposes any objects still tracked with a positive reference count, then clears all - /// static tracking state. Call at the end of a run session: every executed test has - /// already decremented its references by then, so anything still alive would otherwise - /// leak (e.g. its remaining consumers were cancelled or a path miscounted). Clearing also - /// ensures a subsequent run request in the same process starts with fresh state. - /// Intentionally an instance method despite operating on static state: disposal needs the - /// injected (for error logging), which only instances carry. + /// Releases this session's remaining references without retiring objects held by other sessions. /// - /// Any exceptions thrown by the disposals, or null if none. public async ValueTask?> DisposeAndClearStaticTrackingAsync() { List? exceptions = null; + object[] objects; + lock (s_sharedInstanceLock) + { + objects = _sessionReferences.Keys.ToArray(); + } - foreach (var kvp in s_trackedObjects) + foreach (var obj in objects) { try { - await DisposeUnleasedTrackedObjectAsync(kvp.Key).ConfigureAwait(false); + while (HasSessionReference(obj)) + { + await UntrackObjectAsync(obj).ConfigureAwait(false); + } } catch (Exception ex) { @@ -64,6 +65,11 @@ internal class ObjectTracker(TrackableObjectGraphProvider trackableObjectGraphPr return exceptions; } + private bool HasSessionReference(object obj) + { + lock (s_sharedInstanceLock) return _sessionReferences.ContainsKey(obj); + } + internal async ValueTask DisposeUnleasedTrackedObjectAsync(object obj) { lock (s_staticLeaseLock) @@ -71,7 +77,11 @@ internal async ValueTask DisposeUnleasedTrackedObjectAsync(object obj) // Static leases can outlive this session. Retiring a counter and acquiring a // lease must be atomic so a sweep cannot remove a newly protected counter. if (s_staticLeaseObjects.TryGetValue(obj, out var leases) && leases.Count > 0) return; - if (!s_trackedObjects.TryRemove(obj, out _) || IsExternallyOwned(obj)) return; + lock (s_sharedInstanceLock) + { + if (!s_trackedObjects.TryGetValue(obj, out var counter) || counter.CurrentCount > 0 + || !RemoveCounter(obj, counter) || IsExternallyOwned(obj)) return; + } } await disposer.DisposeAsync(obj).ConfigureAwait(false); } @@ -257,13 +267,13 @@ private static void RemoveObjectsNotIn(SortedList>? tracked // Released last: the test's own objects may depend on the shared instances it fetched. if (heldSharedInstances is { Count: > 0 }) { - cleanupExceptions = await UntrackBucketAsync(testContext, heldSharedInstances, cleanupExceptions).ConfigureAwait(false); + cleanupExceptions = await UntrackBucketAsync(testContext, heldSharedInstances, cleanupExceptions, sessionReference: false).ConfigureAwait(false); } return cleanupExceptions; } - private async ValueTask?> UntrackBucketAsync(TestContext? testContext, HashSet bucket, List? cleanupExceptions) + private async ValueTask?> UntrackBucketAsync(TestContext? testContext, HashSet bucket, List? cleanupExceptions, bool sessionReference = true) { List? disposalTasks = null; @@ -271,7 +281,7 @@ private static void RemoveObjectsNotIn(SortedList>? tracked { try { - var task = UntrackObject(obj, testContext); + var task = UntrackObject(obj, testContext, sessionReference); if (!task.IsCompletedSuccessfully) { @@ -315,7 +325,8 @@ internal void TrackStaticLeaseObject(object obj) lock (s_staticLeaseLock) { s_staticLeaseObjects.GetValue(obj, static _ => new()).Count++; - TrackObject(obj); + // The final static-property owner releases this lease, which may outlive this session. + TrackObject(obj, sessionReference: false); } } @@ -325,7 +336,7 @@ internal async ValueTask ReleaseStaticLeaseObjectAsync(object obj, Func /// The object to track - private void TrackObject(object? obj) + private void TrackObject(object? obj, bool sessionReference = true) { if (obj == null || ShouldSkipTracking(obj)) { return; } - var counter = GetOrCreateCounter(obj); - counter.Increment(); + lock (s_sharedInstanceLock) + { + if (sessionReference) + { + _sessionReferences.TryGetValue(obj, out var count); + _sessionReferences[obj] = count + 1; + } + GetOrCreateCounter(obj).Increment(); + } } /// @@ -397,7 +415,7 @@ private void TrackObject(object? obj) /// public ValueTask UntrackObjectAsync(object? obj) => UntrackObject(obj, testContext: null); - private async ValueTask UntrackObject(object? obj, TestContext? testContext) + private async ValueTask UntrackObject(object? obj, TestContext? testContext, bool sessionReference = true) { // Every disposable is counted, including externally owned objects. Ownership changes only // who disposes it, so each test always releases exactly the reference it took. @@ -408,22 +426,31 @@ private async ValueTask UntrackObject(object? obj, TestContext? testContext) var shouldDispose = false; - if (s_trackedObjects.TryGetValue(obj, out var counter)) + lock (s_sharedInstanceLock) { - int count; - try { count = counter.Decrement(); } - catch { s_trackedObjects.TryRemove(obj, out _); throw; } - - if (count < 0) + if (sessionReference) { - throw new InvalidOperationException("Reference count for object went below zero. This indicates a bug in the reference counting logic."); + if (!_sessionReferences.TryGetValue(obj, out var ownedCount)) return; + if (ownedCount == 1) _sessionReferences.Remove(obj); + else _sessionReferences[obj] = ownedCount - 1; } - - if (count == 0) + if (s_trackedObjects.TryGetValue(obj, out var counter)) { - shouldDispose = TestDataContainer.IsCached(obj) - ? TryRetireSharedInstance(obj, counter) - : RemoveCounter(obj, counter); + int count; + try { count = counter.Decrement(); } + catch { s_trackedObjects.TryRemove(obj, out _); throw; } + + if (count < 0) + { + throw new InvalidOperationException("Reference count for object went below zero. This indicates a bug in the reference counting logic."); + } + + if (count == 0) + { + shouldDispose = TestDataContainer.IsCached(obj) + ? TryRetireSharedInstance(obj, counter) + : RemoveCounter(obj, counter); + } } } @@ -640,7 +667,7 @@ private async ValueTask ReleaseRegistrationHoldsAsync(RegistrationHolds holds) // No longer changes: TryHoldForRegistration checks Released under the same lock. if (holds.Instances.Count > 0) { - await UntrackBucketAsync(testContext: null, holds.Instances, cleanupExceptions: null).ConfigureAwait(false); + await UntrackBucketAsync(testContext: null, holds.Instances, cleanupExceptions: null, sessionReference: false).ConfigureAwait(false); } } diff --git a/tests/TUnit.UnitTests/ObjectTrackerRollbackTests.cs b/tests/TUnit.UnitTests/ObjectTrackerRollbackTests.cs index 22a3f8cb88d..6151c5b76cf 100644 --- a/tests/TUnit.UnitTests/ObjectTrackerRollbackTests.cs +++ b/tests/TUnit.UnitTests/ObjectTrackerRollbackTests.cs @@ -145,6 +145,54 @@ public async Task Failed_First_Discovery_Leaves_Nothing_Tracked() await Assert.That(testContext.TrackedObjectsIfCreated?.Count ?? 0).IsEqualTo(0); } + [Test] + [Arguments(false)] + [Arguments(true)] + public async Task Session_Sweep_Preserves_Other_Sessions_References(bool shareObject) + { + var firstDiscoverer = new FakeDiscoverer(); + var secondDiscoverer = new FakeDiscoverer(); + var first = new ObjectTracker(new TrackableObjectGraphProvider(firstDiscoverer), GlobalContext.Current.Disposer); + var second = new ObjectTracker(new TrackableObjectGraphProvider(secondDiscoverer), GlobalContext.Current.Disposer); + var firstObject = new TrackedDisposable(); + var secondObject = shareObject ? firstObject : new TrackedDisposable(); + firstDiscoverer.Discover = context => Add(context, firstObject); + secondDiscoverer.Discover = context => Add(context, secondObject); + var firstContext = CreateContext(); + var secondContext = CreateContext(); + first.TrackObjects(firstContext); + second.TrackObjects(secondContext); + + await first.DisposeAndClearStaticTrackingAsync(); + + await Assert.That(firstObject.IsDisposed).IsEqualTo(!shareObject); + await Assert.That(secondObject.IsDisposed).IsFalse(); + // Late cleanup of a retired session must not release the other session's reference. + await first.UntrackObjects(firstContext); + await first.DisposeAndClearStaticTrackingAsync(); + await Assert.That(secondObject.IsDisposed).IsFalse(); + await second.UntrackObjects(secondContext); + await Assert.That(secondObject.DisposeCount).IsEqualTo(1); + await second.DisposeAndClearStaticTrackingAsync(); + await Assert.That(secondObject.DisposeCount).IsEqualTo(1); + } + + [Test] + public async Task Session_Sweep_Does_Not_Release_A_Static_Lease_That_Outlives_Its_Tracker() + { + var discoverer = new FakeDiscoverer(); + var tracker = new ObjectTracker(new TrackableObjectGraphProvider(discoverer), GlobalContext.Current.Disposer); + var resource = new TrackedDisposable(); + tracker.TrackStaticLeaseObject(resource); + discoverer.Discover = context => Add(context, resource); + tracker.TrackObjects(CreateContext()); + + await tracker.DisposeAndClearStaticTrackingAsync(); + await Assert.That(resource.IsDisposed).IsFalse(); + await tracker.ReleaseStaticLeaseObjectAsync(resource); + await Assert.That(resource.DisposeCount).IsEqualTo(1); + } + private static SortedList> Add(TestContext context, object obj, int depth = 0) { var tracked = context.TrackedObjects; @@ -169,7 +217,9 @@ private sealed class TrackedDisposable : IDisposable { public bool IsDisposed { get; private set; } - public void Dispose() => IsDisposed = true; + public int DisposeCount { get; private set; } + + public void Dispose() { IsDisposed = true; DisposeCount++; } } private sealed class FakeDiscoverer : IObjectGraphDiscoverer diff --git a/tests/TUnit.UnitTests/StaticPropertyHandlerCleanupTests.cs b/tests/TUnit.UnitTests/StaticPropertyHandlerCleanupTests.cs index 6c5bacecac1..638f5727858 100644 --- a/tests/TUnit.UnitTests/StaticPropertyHandlerCleanupTests.cs +++ b/tests/TUnit.UnitTests/StaticPropertyHandlerCleanupTests.cs @@ -222,12 +222,14 @@ public async Task Overlapping_Generated_Sessions_Keep_Fixtures_And_Scopes_Alive( } }; var first = CreateSession(); - var firstHandler = CreateInitializingHandler(first); + var firstTracker = new ObjectTracker(new(), GlobalContext.Current.Disposer); + var firstHandler = CreateInitializingHandler(first, firstTracker); await firstHandler.InitializeStaticPropertiesAsync([metadata], default); var resource = value!; await Assert.That(ObjectTracker.IsExternallyOwned(resource)).IsFalse(); var second = CreateSession(); - var secondHandler = CreateInitializingHandler(second); + var secondTracker = new ObjectTracker(new(), GlobalContext.Current.Disposer); + var secondHandler = CreateInitializingHandler(second, secondTracker); await secondHandler.InitializeStaticPropertiesAsync([metadata], default); await secondHandler.InitializeStaticPropertiesAsync([metadata], default); await Assert.That(initializations).IsEqualTo(1); @@ -243,6 +245,7 @@ public async Task Overlapping_Generated_Sessions_Keep_Fixtures_And_Scopes_Alive( var earlier = finishFirstSessionFirst ? firstHandler : secondHandler; var later = finishFirstSessionFirst ? secondHandler : firstHandler; await earlier.DisposeStaticPropertiesAsync([], []); + await (finishFirstSessionFirst ? firstTracker : secondTracker).DisposeAndClearStaticTrackingAsync(); await tracker.UntrackObjects(context); // Exercise the same sweep operation on these fixtures without touching other tests' trackers. await tracker.DisposeUnleasedTrackedObjectAsync(resource); @@ -521,8 +524,8 @@ public ValueTask EnsureInitializedAsync(T obj, CancellationToken cancellationToken = default) where T : notnull => new(obj); } - private static StaticPropertyHandler CreateInitializingHandler(TestSessionContext session) - => new(null!, new ObjectTracker(new(), GlobalContext.Current.Disposer), null!, new Lazy(() => new PropertyInjector(new Lazy(() => new PassthroughInitializationCallback()), session.Id)), + private static StaticPropertyHandler CreateInitializingHandler(TestSessionContext session, ObjectTracker? tracker = null) + => new(null!, tracker ?? new ObjectTracker(new(), GlobalContext.Current.Disposer), null!, new Lazy(() => new PropertyInjector(new Lazy(() => new PassthroughInitializationCallback()), session.Id)), new ObjectGraphDiscoveryService(), session); internal sealed class ThrowingReflectionFixture