Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
101 changes: 64 additions & 37 deletions src/TUnit.Core/Tracking/ObjectTracker.cs
Original file line number Diff line number Diff line change
Expand Up @@ -11,17 +11,17 @@ namespace TUnit.Core.Tracking;
/// </summary>
/// <remarks>
/// The static <c>s_trackedObjects</c> dictionary is shared across all tests.
/// Call <see cref="DisposeAndClearStaticTrackingAsync"/> 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.
/// </remarks>
internal class ObjectTracker(TrackableObjectGraphProvider trackableObjectGraphProvider, Disposer disposer)
{
// Use ReferenceEqualityComparer to prevent objects with custom Equals from sharing state
private static readonly ConcurrentDictionary<object, Counter> 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<object, int> _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
Expand All @@ -34,24 +34,25 @@ internal class ObjectTracker(TrackableObjectGraphProvider trackableObjectGraphPr
public static IReadOnlyCollection<Exception> GetAsyncCallbackErrors() => s_asyncCallbackErrors.ToArray();

/// <summary>
/// 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 <see cref="Disposer"/> (for error logging), which only instances carry.
/// Releases this session's remaining references without retiring objects held by other sessions.
/// </summary>
/// <returns>Any exceptions thrown by the disposals, or null if none.</returns>
public async ValueTask<List<Exception>?> DisposeAndClearStaticTrackingAsync()
{
List<Exception>? 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)
{
Expand All @@ -64,14 +65,23 @@ 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)
{
// 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);
}
Expand Down Expand Up @@ -257,21 +267,21 @@ private static void RemoveObjectsNotIn(SortedList<int, HashSet<object>>? 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<List<Exception>?> UntrackBucketAsync(TestContext? testContext, HashSet<object> bucket, List<Exception>? cleanupExceptions)
private async ValueTask<List<Exception>?> UntrackBucketAsync(TestContext? testContext, HashSet<object> bucket, List<Exception>? cleanupExceptions, bool sessionReference = true)
{
List<Task>? disposalTasks = null;

foreach (var obj in bucket)
{
try
{
var task = UntrackObject(obj, testContext);
var task = UntrackObject(obj, testContext, sessionReference);

if (!task.IsCompletedSuccessfully)
{
Expand Down Expand Up @@ -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);
}
}

Expand All @@ -325,7 +336,7 @@ internal async ValueTask ReleaseStaticLeaseObjectAsync(object obj, Func<ValueTas
try
{
// Keep sweep protection while asynchronous fixture teardown is in progress.
await UntrackObjectAsync(obj).ConfigureAwait(false);
await UntrackObject(obj, testContext: null, sessionReference: false).ConfigureAwait(false);
}
catch (Exception ex)
{
Expand Down Expand Up @@ -377,15 +388,22 @@ public void TrackStaticProperties()
/// For backward compatibility - adds to existing tracked objects for the context.
/// </summary>
/// <param name="obj">The object to track</param>
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();
}
}

/// <summary>
Expand All @@ -397,7 +415,7 @@ private void TrackObject(object? obj)
/// </summary>
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.
Expand All @@ -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);
}
}
}

Expand Down Expand Up @@ -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);
}
}

Expand Down
52 changes: 51 additions & 1 deletion tests/TUnit.UnitTests/ObjectTrackerRollbackTests.cs
Original file line number Diff line number Diff line change
Expand Up @@ -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<int, HashSet<object>> Add(TestContext context, object obj, int depth = 0)
{
var tracked = context.TrackedObjects;
Expand All @@ -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
Expand Down
11 changes: 7 additions & 4 deletions tests/TUnit.UnitTests/StaticPropertyHandlerCleanupTests.cs
Original file line number Diff line number Diff line change
Expand Up @@ -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);
Expand All @@ -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);
Expand Down Expand Up @@ -521,8 +524,8 @@ public ValueTask<T> EnsureInitializedAsync<T>(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<PropertyInjector>(() => new PropertyInjector(new Lazy<IInitializationCallback>(() => 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<PropertyInjector>(() => new PropertyInjector(new Lazy<IInitializationCallback>(() => new PassthroughInitializationCallback()), session.Id)),
new ObjectGraphDiscoveryService(), session);

internal sealed class ThrowingReflectionFixture
Expand Down
Loading