diff --git a/src/TUnit.Core/ContextProvider.cs b/src/TUnit.Core/ContextProvider.cs
index f90f0579c0d..03a7b8b3e6f 100644
--- a/src/TUnit.Core/ContextProvider.cs
+++ b/src/TUnit.Core/ContextProvider.cs
@@ -122,7 +122,8 @@ public TestContext CreateTestContext(
Type classType,
TestBuilderContext testBuilderContext,
TestDetails testDetails,
- CancellationToken cancellationToken)
+ CancellationToken cancellationToken,
+ bool registerAsTest = true)
{
var classContext = GetOrCreateClassContext(classType);
@@ -133,7 +134,8 @@ public TestContext CreateTestContext(
TestDetails = testDetails,
};
- classContext.AddTest(testContext);
+ if (registerAsTest)
+ classContext.AddTest(testContext);
return testContext;
}
diff --git a/src/TUnit.Core/Services/IContextProvider.cs b/src/TUnit.Core/Services/IContextProvider.cs
index 512d7bc7c05..b1577bc5333 100644
--- a/src/TUnit.Core/Services/IContextProvider.cs
+++ b/src/TUnit.Core/Services/IContextProvider.cs
@@ -38,12 +38,14 @@ ClassHookContext GetOrCreateClassContext(
///
/// Creates a test context. is assigned before the context
/// becomes observable via so hooks never see a
- /// partially-built context.
+ /// partially-built context. Cleanup-only contexts pass as false
+ /// to stay out of the class and session test lists.
///
TestContext CreateTestContext(
[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicMethods)]
Type classType,
TestBuilderContext testBuilderContext,
TestDetails testDetails,
- CancellationToken cancellationToken);
+ CancellationToken cancellationToken,
+ bool registerAsTest = true);
}
diff --git a/src/TUnit.Engine/Building/RowCleanupOwner.cs b/src/TUnit.Engine/Building/RowCleanupOwner.cs
new file mode 100644
index 00000000000..1214bb39fdf
--- /dev/null
+++ b/src/TUnit.Engine/Building/RowCleanupOwner.cs
@@ -0,0 +1,115 @@
+using System.Collections.Concurrent;
+using TUnit.Core;
+
+namespace TUnit.Engine.Building;
+
+///
+/// Owns a row's cleanup until one test or the session claims it. A row that never reaches
+/// either owner is released by the builder's finally block, including failed factories.
+///
+internal sealed class RowCleanupOwner
+{
+ private readonly TestBuilderContext _context;
+ private readonly TestContextEvents _cleanup;
+ private int _claimedOrReleased;
+
+ private RowCleanupOwner(TestBuilderContext context, TestContextEvents events)
+ {
+ _context = context with { };
+ if (context.HasStateBag)
+ _context.StateBag = new ConcurrentDictionary(context.StateBag);
+ _cleanup = new TestContextEvents
+ {
+ OnDispose = events.OnDispose?.Clone(),
+ DataRowScopes = events.DataRowScopes?.Clone()
+ };
+ }
+
+ internal static RowCleanupOwner? Capture(TestBuilderContext context)
+ => context.EventsIfCreated is { } events && (events.OnDispose is not null || events.DataRowScopes is not null)
+ ? new(context, events)
+ : null;
+
+ internal void ClaimTo(TestBuilderContext target, bool bindState = false)
+ {
+ if (Interlocked.Exchange(ref _claimedOrReleased, 1) != 0)
+ return;
+
+ if (_cleanup.DataRowScopes is { } scopes)
+ target.Events.AddDataRowScopes(scopes);
+ if (_cleanup.OnDispose is not { } onDispose)
+ return;
+
+ if (!bindState)
+ {
+ (target.Events.OnDispose ??= new()).AddMissingFrom(onDispose);
+ return;
+ }
+
+ // A discarded method row's callbacks need its state, while metadata and services
+ // come from the test that eventually owns cleanup. No lifecycle handlers follow it.
+ foreach (var callback in onDispose.InvocationList)
+ {
+ (target.Events.OnDispose ??= new()).Add(async (_, owner) =>
+ {
+ var context = new TestContext(owner.TestDetails.TestName, owner.ServiceProvider,
+ owner.ClassContext, _context, owner.CancellationToken);
+ context.Metadata.TestDetails = owner.TestDetails;
+ try
+ {
+ await callback.InvokeAsync(context, context);
+ }
+ finally
+ {
+ context.RemoveFromRegistry();
+ context.Dispose();
+ }
+ }, callback.Order);
+ }
+ }
+
+ internal void ClaimForSession()
+ {
+ if (Interlocked.Exchange(ref _claimedOrReleased, 1) == 0)
+ TestSessionContext.DeferOnDisposeToSessionEnd(_cleanup);
+ }
+
+ internal async ValueTask?> ReleaseAsync(
+ Func createContext, List? exceptions = null)
+ {
+ if (Interlocked.Exchange(ref _claimedOrReleased, 1) != 0)
+ return exceptions;
+
+ if (_cleanup.OnDispose is { } onDispose)
+ {
+ TestContext? context = null;
+ try
+ {
+ context = createContext(_context);
+ foreach (var callback in onDispose.InvocationList)
+ {
+ try
+ {
+ await callback.InvokeAsync(context, context).ConfigureAwait(false);
+ }
+ catch (Exception exception)
+ {
+ (exceptions ??= []).Add(exception);
+ }
+ }
+ }
+ catch (Exception exception)
+ {
+ (exceptions ??= []).Add(exception);
+ }
+ finally
+ {
+ context?.RemoveFromRegistry();
+ context?.Dispose();
+ }
+ }
+ if (_cleanup.DataRowScopes is { } scopes)
+ exceptions = await scopes.CompleteAsync(exceptions).ConfigureAwait(false);
+ return exceptions;
+ }
+}
diff --git a/src/TUnit.Engine/Building/TestBuilder.cs b/src/TUnit.Engine/Building/TestBuilder.cs
index 8cc14cb7680..8556ade57d1 100644
--- a/src/TUnit.Engine/Building/TestBuilder.cs
+++ b/src/TUnit.Engine/Building/TestBuilder.cs
@@ -332,6 +332,7 @@ public async ValueTask> BuildTestsFromMetada
// constraints: fail this row only, as reflection mode does when it resolves
// the row's type arguments, and keep building the remaining rows.
var (reportedException, rowData) = UnpackConstraintViolation(ex, metadata.MethodMetadata.Parameters);
+ unclaimedClassRow.ClaimCleanupTo(contextAccessor.Current);
tests.Add(CreateFailedTestForDataRowError(metadata, reportedException, classDataAttributeIndex, classDataLoopIndex, methodDataAttributeIndex, methodDataLoopIndex, i, unclaimedClassRow.WithLentObjects(classData), rowData, contextAccessor.Current));
continue;
}
@@ -369,6 +370,8 @@ public async ValueTask> BuildTestsFromMetada
}
}
+ unclaimedClassRow.ClaimCleanupTo(contextAccessor.Current);
+
Type[] resolvedClassGenericArgs;
Type[] resolvedMethodGenericArgs;
@@ -508,7 +511,6 @@ public async ValueTask> BuildTestsFromMetada
// and tracks any objects that a temporary instance used.
var lentClassRowObjects = unclaimedClassRow.TakeLentObjects();
var skippedRowContext = unclaimedClassRow.CreateEnumerationFailureContext(contextAccessor.Current);
- unclaimedClassRow.Clear();
Type[] resolvedClassGenericArgs;
Exception? genericResolutionException = null;
@@ -565,6 +567,7 @@ public async ValueTask> BuildTestsFromMetada
var failureContext = ReferenceEquals(contextAccessor.Current, classEnumerationContext)
? unclaimedClassRow.CreateEnumerationFailureContext(classEnumerationContext)
: contextAccessor.Current;
+ unclaimedClassRow.ClaimCleanupTo(failureContext);
contextAccessor.Current = failureContext;
var failedTest = CreateFailedTestForDataGenerationError(metadata, ex,
new TestDataCombination(), methodData: unclaimedClassRow.TakeLentObjects(),
@@ -575,6 +578,9 @@ public async ValueTask> BuildTestsFromMetada
finally
{
await DisposeInstanceForMethodDataSourcesAsync(instanceForMethodDataSources);
+ if (await unclaimedClassRow.ReleaseAsync(CreateCleanupContext) is { Count: > 0 } cleanupErrors)
+ tests.Add(CreateFailedTestForDataGenerationError(metadata, new AggregateException(cleanupErrors),
+ new TestDataCombination { ClassDataSourceIndex = classDataAttributeIndex, ClassLoopIndex = classDataLoopIndex }));
contextAccessor.Current = classSourceContext;
}
}
@@ -673,8 +679,19 @@ public async ValueTask> BuildTestsFromMetada
tests.Add(failedTest);
return tests;
}
+ finally
+ {
+ if (activeClassRow is not null && await activeClassRow.ReleaseAsync(CreateCleanupContext) is { Count: > 0 } cleanupErrors)
+ tests.Add(CreateFailedTestForDataGenerationError(metadata, new AggregateException(cleanupErrors)));
+ }
return tests;
+
+ TestContext CreateCleanupContext(TestBuilderContext rowContext)
+ {
+ var details = CreateFailedTestDetails(metadata, TestIdentifierService.GenerateFailedTestId(metadata, new TestDataCombination()), []);
+ return CreateFailedTestContext(metadata, details, rowContext, registerAsTest: false);
+ }
}
private readonly struct BuildContextLease(TestBuildContext buildContext) : IDisposable
@@ -1049,7 +1066,8 @@ public ValueTask MoveNextAsync()
/// When the row needs a temporary instance for an instance method data source, that instance is built
/// from these objects and disposed once the method rows are read, so no test may receive them. They
/// are lent to the instance instead, and the next test built from the row tracks them without
- /// receiving them, so they are still disposed.
+ /// receiving them, so they are still disposed. Their cleanup owner is claimed by the session,
+ /// keeping constructor scopes alive while later method rows still borrow those objects.
///
internal sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? metadata, TestBuilderContext rowContext, TestBuilderContext? enumerationContext = null)
{
@@ -1065,8 +1083,23 @@ internal sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? met
: null;
private TestBuilderContext _rowContext = rowContext;
// Snapshot before any method factory can mutate the class subscriptions.
- private TestContextEvents? _events = rowContext.EventsIfCreated?.Clone();
- private TestContextEvents? _rejectedCleanup;
+ private TestContextEvents? _lifecycleEvents = LifecycleEvents(rowContext);
+ private RowCleanupOwner? _cleanup = RowCleanupOwner.Capture(rowContext);
+ private List? _rejectedCleanup;
+ private bool _pending = true;
+
+ private static TestContextEvents? LifecycleEvents(TestBuilderContext context)
+ {
+ return context.EventsIfCreated is { } events ? new TestContextEvents
+ {
+ OnTestRegistered = events.OnTestRegistered?.Clone(),
+ OnInitialize = events.OnInitialize?.Clone(),
+ OnTestStart = events.OnTestStart?.Clone(),
+ OnTestEnd = events.OnTestEnd?.Clone(),
+ OnTestSkipped = events.OnTestSkipped?.Clone(),
+ OnTestRetry = events.OnTestRetry?.Clone()
+ } : null;
+ }
///
/// Takes the unclaimed objects, or fetches a new row from when a
@@ -1078,10 +1111,14 @@ internal sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? met
{
ApplySavedContextTo(context);
var row = (data, _metadata);
- Clear();
+ _data = null;
+ _metadata = null;
return new ValueTask<(object?[] Data, TestDataRowMetadata? Metadata)>(row);
}
+ if (_pending)
+ throw new InvalidOperationException("The previous class row must be claimed or returned before fetching another row.");
+
return FetchAsync(classDataFactory, context);
async ValueTask<(object?[] Data, TestDataRowMetadata? Metadata)> FetchAsync(Func> factory, TestBuilderContext target)
@@ -1095,7 +1132,13 @@ internal sealed class UnclaimedClassRow(object?[] data, TestDataRowMetadata? met
{
_rowContext.StateBag = new ConcurrentDictionary(target.StateBag);
}
- _events = target.EventsIfCreated?.Clone();
+ _lifecycleEvents = LifecycleEvents(target);
+ _cleanup = RowCleanupOwner.Capture(target);
+ _pending = true;
+ // Class cleanup stays with its owner until a test claims the row. Method
+ // factories see the lifecycle subscriptions, but own separate cleanup.
+ if (target.EventsIfCreated is not null)
+ target.Events = _lifecycleEvents!.Clone();
return row;
}
}
@@ -1126,14 +1169,10 @@ private void ApplySavedContextTo(TestBuilderContext context)
}
}
}
- if (_events is { } savedEvents)
+ if (_lifecycleEvents is { } savedEvents)
{
context.Events = savedEvents.Clone();
}
- if (_rejectedCleanup is { } cleanup)
- {
- context.Events.AddCleanupFrom(cleanup);
- }
}
///
@@ -1143,45 +1182,54 @@ public void Return(object?[] data, TestDataRowMetadata? metadata, TestBuilderCon
{
_data = data;
_metadata = metadata;
- // Only cleanup follows a rejected method row. Its other lifecycle handlers must
- // never become constructor subscriptions on later compatible rows.
- if (rejectedContext.EventsIfCreated is { } rejectedEvents)
- {
- var cleanup = _rejectedCleanup ??= new();
- if (rejectedEvents.DataRowScopes is { } scopes)
- cleanup.AddDataRowScopes(scopes);
-
- // Constructor callbacks already belong to the saved class row. Bind only
- // method-row callbacks to their own state, rather than the next test's bag.
- var callbacks = rejectedEvents.OnDispose?.InvocationList
- .Where(invocation => _events?.OnDispose?.InvocationList.Contains(invocation) != true
- && cleanup.OnDispose?.InvocationList.Contains(invocation) != true)
- .ToArray();
- if (callbacks is { Length: > 0 })
- {
- var saved = rejectedContext with { StateBag = new(rejectedContext.StateBag) };
- foreach (var callback in callbacks)
- {
- (cleanup.OnDispose ??= new()).Add(async (_, owner) =>
- {
- // Rejected rows have no executable test. Give their cleanup a
- // context with the owning state and the final test's metadata.
- var context = new TestContext(owner.TestDetails.TestName, owner.ServiceProvider,
- owner.ClassContext, saved, owner.CancellationToken);
- context.Metadata.TestDetails = owner.TestDetails;
- try
- {
- await callback.InvokeAsync(context, context);
- }
- finally
- {
- context.RemoveFromRegistry();
- context.Dispose();
- }
- }, callback.Order);
- }
- }
+ if (RowCleanupOwner.Capture(rejectedContext) is { } methodCleanup)
+ {
+ (_rejectedCleanup ??= []).Add(methodCleanup);
+ }
+ }
+
+ /// Claims class and method cleanup for one executable (including failed) row.
+ public void ClaimCleanupTo(TestBuilderContext target)
+ {
+ if (!_pending)
+ return;
+
+ // Capture the method's cleanup before adding the class row's subscriptions.
+ var methodCleanup = RowCleanupOwner.Capture(target);
+ if (methodCleanup is not null)
+ {
+ target.Events.OnDispose = null;
+ target.Events.DataRowScopes = null;
+ }
+ _cleanup?.ClaimTo(target);
+ if (_rejectedCleanup is not null)
+ {
+ foreach (var cleanup in _rejectedCleanup)
+ cleanup.ClaimTo(target, bindState: true);
+ _rejectedCleanup = null;
+ }
+ methodCleanup?.ClaimTo(target);
+ _pending = false;
+ _data = null;
+ _metadata = null;
+ }
+
+ /// Releases only rows that no executable test or session claimed.
+ public async ValueTask?> ReleaseAsync(Func createContext)
+ {
+ List? exceptions = null;
+ if (_cleanup is not null)
+ exceptions = await _cleanup.ReleaseAsync(createContext, exceptions);
+ if (_rejectedCleanup is not null)
+ {
+ foreach (var cleanup in _rejectedCleanup)
+ exceptions = await cleanup.ReleaseAsync(createContext, exceptions);
+ _rejectedCleanup = null;
}
+ _pending = false;
+ _data = null;
+ _metadata = null;
+ return exceptions;
}
///
@@ -1189,9 +1237,10 @@ public void Return(object?[] data, TestDataRowMetadata? metadata, TestBuilderCon
///
public void TransferCleanupTo(TestBuilderContext target)
{
- if (_data is not null)
+ if (_pending)
{
ApplySavedContextTo(target);
+ ClaimCleanupTo(target);
}
}
@@ -1214,15 +1263,6 @@ internal TestBuilderContext CreateEnumerationFailureContext(TestBuilderContext e
return failureContext;
}
- /// Marks the unclaimed objects as held by a test.
- public void Clear()
- {
- _data = null;
- _metadata = null;
- _lent = null;
- _rejectedCleanup = null;
- }
-
///
/// Marks the unclaimed objects as used by a temporary instance, so no test receives them, but the
/// next test tracks them through or .
@@ -1231,15 +1271,12 @@ public void LendToTemporaryInstance(TestBuilderContext? lifetimeContext = null)
{
_lent = _data;
// Method rows share this constructor row until session end.
- if (lifetimeContext is not null && _events is not null)
- {
- lifetimeContext.Events.AddCleanupFrom(_events);
- }
+ if (lifetimeContext is not null)
+ _cleanup?.ClaimTo(lifetimeContext);
else
- {
- TestSessionContext.DeferOnDisposeToSessionEnd(_events);
- }
- _events = null;
+ _cleanup?.ClaimForSession();
+ _pending = false;
+ _lifecycleEvents = null;
_data = null;
_metadata = null;
}
@@ -1916,7 +1953,7 @@ private async ValueTask InitializeAttributesCoreAsync(Attribute[] a
return attributes;
}
- private TestContext CreateFailedTestContext(TestMetadata metadata, TestDetails testDetails, TestBuilderContext? rowContext)
+ private TestContext CreateFailedTestContext(TestMetadata metadata, TestDetails testDetails, TestBuilderContext? rowContext, bool registerAsTest = true)
{
var builderContext = new TestBuilderContext { TestMetadata = metadata.MethodMetadata };
if (rowContext is not null)
@@ -1929,7 +1966,8 @@ private TestContext CreateFailedTestContext(TestMetadata metadata, TestDetails t
metadata.TestClassType,
builderContext,
testDetails,
- CancellationToken.None);
+ CancellationToken.None,
+ registerAsTest);
return context;
}
diff --git a/tests/TUnit.UnitTests/ClassRowCleanupTests.cs b/tests/TUnit.UnitTests/ClassRowCleanupTests.cs
index 83c2e2c4627..3d2398cf0b5 100644
--- a/tests/TUnit.UnitTests/ClassRowCleanupTests.cs
+++ b/tests/TUnit.UnitTests/ClassRowCleanupTests.cs
@@ -14,7 +14,9 @@ public async Task EmptyRefetchedConstructorStateDoesNotCaptureRejectedMethodStat
{
var data = new object?[] { new object() };
var row = new TestBuilder.UnclaimedClassRow(data, null, CreateContext());
- await row.TakeOrFetchAsync(() => throw new InvalidOperationException("Must reuse first row"), CreateContext());
+ var first = CreateContext();
+ await row.TakeOrFetchAsync(() => throw new InvalidOperationException("Must reuse first row"), first);
+ row.ClaimCleanupTo(first);
var rejected = CreateContext();
if (removesInheritedKey)
@@ -49,7 +51,9 @@ public async Task RefetchedRejectedConstructorReplaysOnlyItsOwnStateChanges(bool
enumeration.CopyStateBagTo(original);
var data = new object?[] { new object() };
var row = new TestBuilder.UnclaimedClassRow(data, null, original, enumeration);
- await row.TakeOrFetchAsync(() => throw new InvalidOperationException("Must reuse first row"), CreateContext());
+ var first = CreateContext();
+ await row.TakeOrFetchAsync(() => throw new InvalidOperationException("Must reuse first row"), first);
+ row.ClaimCleanupTo(first);
var rejected = CreateContext();
rejected.StateBag["method-row"] = new object();
@@ -128,6 +132,7 @@ ValueTask RejectedLifecycle(object sender, TestContext context)
row.TransferCleanupTo(owner);
else
await row.TakeOrFetchAsync(() => throw new InvalidOperationException("Must reuse constructor"), owner);
+ row.ClaimCleanupTo(owner);
// Neither returning a rejected row nor taking the next one may release its class resource early.
await Assert.That(constructorDisposals).IsEqualTo(0);
await Assert.That(rejectedDisposals).IsEqualTo(0);
@@ -239,6 +244,7 @@ public async Task ClaimedRowDoesNotTransferCleanupToLaterSkippedTest()
var row = new TestBuilder.UnclaimedClassRow([new object()], null, original);
var runnable = CreateContext();
await row.TakeOrFetchAsync(() => throw new InvalidOperationException("Must use saved row"), runnable);
+ row.ClaimCleanupTo(runnable);
var skipped = CreateContext();
row.TransferCleanupTo(skipped);
@@ -261,7 +267,6 @@ public async Task UnclaimedRowTransfersCleanupToSkippedTest()
var row = new TestBuilder.UnclaimedClassRow([new object()], null, original);
var skipped = CreateContext();
row.TransferCleanupTo(skipped);
- row.Clear();
await DisposeRow(skipped);
await Assert.That(disposals).IsEqualTo(1);
}
@@ -311,6 +316,7 @@ public async Task EnumerationFailureOnlyDisposesUnclaimedClassScope(bool claimed
if (claimed)
{
await row.TakeOrFetchAsync(() => throw new InvalidOperationException("Must use saved row"), runnable);
+ row.ClaimCleanupTo(runnable);
}
// MoveNext throws after yielding a row (or before yielding any rows).
@@ -437,6 +443,166 @@ public async Task NonRunnableRowsPreservePublicCallbacksAndState(bool factoryThr
}
}
+ [Test]
+ public async Task CleanupOwnerCanOnlyBeClaimedOnce()
+ {
+ var original = CreateContext();
+ var disposals = 0;
+ (original.Events.DataRowScopes ??= new()).Register(new CallbackScope(() =>
+ {
+ disposals++;
+ return default;
+ }));
+ var cleanup = RowCleanupOwner.Capture(original)!;
+ var first = CreateContext();
+ var second = CreateContext();
+ cleanup.ClaimTo(first);
+ cleanup.ClaimTo(second);
+ await cleanup.ReleaseAsync(_ => throw new InvalidOperationException("Claimed rows cannot release here"));
+ await DisposeRow(second);
+ await Assert.That(disposals).IsEqualTo(0);
+ await DisposeRow(first);
+ await DisposeRow(first);
+ await Assert.That(disposals).IsEqualTo(1);
+ }
+
+ [Test]
+ public async Task UnclaimedRejectedRowsReleaseEveryCleanupOnceEvenWhenCallbacksThrow()
+ {
+ var original = CreateContext();
+ var classDisposals = 0;
+ var methodDisposals = 0;
+ var callbacks = 0;
+ (original.Events.DataRowScopes ??= new()).Register(new CallbackScope(() =>
+ {
+ classDisposals++;
+ return default;
+ }));
+ var data = new object?[] { new object() };
+ var row = new TestBuilder.UnclaimedClassRow(data, null, original);
+ for (var i = 0; i < 2; i++)
+ {
+ var rejected = CreateContext();
+ await row.TakeOrFetchAsync(() => throw new InvalidOperationException("Must reuse class row"), rejected);
+ var resource = new object();
+ rejected.StateBag["resource"] = resource;
+ rejected.Events.OnDispose += async (_, context) =>
+ {
+ await Assert.That(context.StateBag.Items["resource"]).IsSameReferenceAs(resource);
+ callbacks++;
+ throw new InvalidOperationException("Cleanup failure");
+ };
+ (rejected.Events.DataRowScopes ??= new()).Register(new CallbackScope(() =>
+ {
+ methodDisposals++;
+ return default;
+ }));
+ row.Return(data, null, rejected);
+ }
+ var errors = await row.ReleaseAsync(CreateCleanupContext);
+ await Assert.That(errors!.Count).IsEqualTo(2);
+ await Assert.That(await row.ReleaseAsync(CreateCleanupContext)).IsNull();
+ await Assert.That(classDisposals).IsEqualTo(1);
+ await Assert.That(methodDisposals).IsEqualTo(2);
+ await Assert.That(callbacks).IsEqualTo(2);
+ var later = CreateContext();
+ row.ClaimCleanupTo(later);
+ await DisposeRow(later);
+ await Assert.That(classDisposals).IsEqualTo(1);
+ }
+
+ [Test]
+ public async Task EmptyMethodSourceWithoutSkipReleasesUnclaimedClassCallbacks()
+ {
+ var current = TestContext.Current!;
+ var builder = (ITestBuilder)current.ServiceProvider.GetService(typeof(ITestBuilder))!;
+ var source = new PublicCleanupSource();
+ var metadata = new TestMetadata
+ {
+ TestClassType = typeof(ClassRowCleanupTests),
+ TestMethodName = nameof(EmptyMethodSourceWithoutSkipReleasesUnclaimedClassCallbacks),
+ TestName = "Unclaimed row cleanup regression",
+ FilePath = "Unknown",
+ LineNumber = 0,
+ AttributeFactory = () => [],
+ MethodMetadata = current.TestDetails.MethodMetadata,
+ DataSources = [new EmptySource()],
+ ClassDataSources = [source],
+ PropertyDataSources = [],
+ InstanceFactory = (_, _) => new ClassRowCleanupTests(),
+ InvokeTypedTest = (_, _, _) => ValueTask.CompletedTask
+ };
+ var tests = (await builder.BuildTestsFromMetadataAsync(metadata, new TestBuildingContext(false, null))).ToArray();
+ await Assert.That(current.ClassContext.Tests.Any(test => test.TestDetails.TestName == metadata.TestName)).IsFalse();
+ await Assert.That(tests.Length).IsEqualTo(0);
+ await Assert.That(source.Callbacks).IsEqualTo(1);
+ }
+
+ [Test]
+ public async Task UnclaimedCleanupFailuresHaveDistinctClassRowIds()
+ {
+ var current = TestContext.Current!;
+ var builder = (ITestBuilder)current.ServiceProvider.GetService(typeof(ITestBuilder))!;
+ var metadata = new TestMetadata
+ {
+ TestClassType = typeof(ClassRowCleanupTests),
+ TestMethodName = nameof(UnclaimedCleanupFailuresHaveDistinctClassRowIds),
+ TestName = "Unclaimed cleanup failure IDs",
+ FilePath = "Unknown",
+ LineNumber = 0,
+ AttributeFactory = () => [],
+ MethodMetadata = current.TestDetails.MethodMetadata,
+ DataSources = [new EmptySource()],
+ ClassDataSources = [new FailingCleanupSource(), new FailingCleanupSource()],
+ PropertyDataSources = [],
+ InstanceFactory = (_, _) => new ClassRowCleanupTests(),
+ InvokeTypedTest = (_, _, _) => ValueTask.CompletedTask
+ };
+ var tests = (await builder.BuildTestsFromMetadataAsync(metadata, new TestBuildingContext(false, null))).ToArray();
+ try
+ {
+ await Assert.That(tests.Length).IsEqualTo(4);
+ await Assert.That(tests.Select(test => test.Context.TestDetails.TestId).Distinct().Count()).IsEqualTo(4);
+ }
+ finally
+ {
+ foreach (var test in tests)
+ {
+ test.Context.RemoveFromRegistry();
+ test.Context.Dispose();
+ }
+ }
+ }
+
+ private sealed class FailingCleanupSource : Attribute, IDataSourceAttribute
+ {
+ public bool SkipIfEmpty { get; set; }
+ public bool DeferEnumeration { get; set; }
+
+ public async IAsyncEnumerable>> GetDataRowsAsync(DataGeneratorMetadata metadata)
+ {
+ await Task.CompletedTask;
+ for (var i = 0; i < 2; i++)
+ {
+ yield return () =>
+ {
+ metadata.TestBuilderContext.Current.Events.OnDispose += (_, _) =>
+ throw new InvalidOperationException("Class row cleanup failed");
+ return Task.FromResult