test: run process-wide tests serially and report constructor failures as themselves

Four App tests switched the process-wide UI language inside parallel classes, so
another class's English assertion, or its constructor's reset to English, could
land in the middle of them; they now live in the serial ArchiveLanguageTests and
ImportLanguageTests. The App and Core test programs fail a test that leaves
English outside a serial class at the switch, through the new
TestContext.Current and TestContext.IsSerial.

The FrameWindow cancellation test counted unobserved task exceptions while other
classes ran beside it; it moves to the serial FrameWindowIsolationTests, and both
unobserved-exception tests drain the finalizer queue before they start counting.

The runner unwrapped TargetInvocationException only around the test method: a
skip or an assertion thrown by a test class constructor or field initializer was
reported as a failure reading "Exception has been thrown by the target of an
invocation". Constructors are unwrapped the same way now. TestRunner.Discover(Type)
and ExecuteAsync are public, so Tools.Tests checks the runner with nested fixtures.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
This commit is contained in:
Claude committed 2026-10-12 10:05:37 +00:00
1 parent c11c996bc6
commit 2f978d1c80
13 files changed
+381 -167

No files matched your search

@@ -0,0 +1,67 @@
using Titano.Core.Imaging;
using Titano.Testing;
using static Titano.Core.Tests.Decoding.FrameWindowTests;
namespace Titano.Core.Tests.Decoding;
/// <summary>
/// <see cref="FrameWindow"/> cancellation (BRIEF §20.4 cancellation gate). Unobserved task exceptions are counted
/// process-wide, so the class is serial: a faulted task another test left behind would otherwise be blamed on it.
/// </summary>
[Serial]
public sealed class FrameWindowIsolationTests(TestContext context)
{
[Test]
[Timeout(10_000)]
public async Task CancellationLeavesNoSpillFileAndNoUnobservedErrors()
{
// Faulted tasks the earlier tests left for the finalizer are reported now, before this test starts counting.
GC.Collect();
GC.WaitForPendingFinalizers();
var unobserved = 0;
void OnUnobserved(object? sender, UnobservedTaskExceptionEventArgs e) => Interlocked.Increment(ref unobserved);
TaskScheduler.UnobservedTaskException += OnUnobserved;
try
{
var dir = context.CreateTempDirectory();
var source = new Source();
string? spill;
using var cts = new CancellationTokenSource();
var window = new FrameWindow(50, source.Load, new FrameWindowOptions { Behind = 3, Ahead = 2, MemoryBudget = 2 * FrameBytes, SpillDirectory = dir });
try
{
for (var i = 0; i < 6; i++)
{
window.MoveTo(i);
using var a = await window.GetAsync(i);
if (i > 0)
{
using var b = await window.GetAsync(i - 1);
}
}
spill = window.SpillPath;
Assert.NotNull(spill);
Assert.FileExists(spill!);
source.Delay = TimeSpan.FromSeconds(30);
window.MoveTo(20);
var pending = window.GetAsync(20, cts.Token);
cts.CancelAfter(50);
await Assert.ThrowsAsync<OperationCanceledException>(async () => await pending);
}
finally
{
await window.DisposeAsync();
}
Assert.FileMissing(spill!);
Assert.Equal(0, source.Live());
await Assert.ThrowsAsync<OperationCanceledException>(async () => await window.GetAsync(1));
}
finally
{
GC.Collect();
GC.WaitForPendingFinalizers();
TaskScheduler.UnobservedTaskException -= OnUnobserved;
}
Assert.Equal(0, unobserved);
}
}