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