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
103 lines
3.6 KiB
C#
103 lines
3.6 KiB
C#
using Titano.Testing;
|
|
|
|
namespace Titano.Tools.Tests;
|
|
|
|
/// <summary>
|
|
/// The in-house runner reports what a test class did, not how reflection called it (BRIEF §20.1). The nested classes
|
|
/// are fixtures: assembly discovery leaves them out, and each test hands one to the runner.
|
|
/// </summary>
|
|
public sealed class TestRunnerTests(TestContext context)
|
|
{
|
|
public sealed class SkippingConstructor
|
|
{
|
|
public SkippingConstructor() => TestContext.Skip("no server configured");
|
|
|
|
[Test]
|
|
public void Body() => Assert.Fail("the body ran after the constructor skipped");
|
|
}
|
|
|
|
public sealed class FailingConstructor
|
|
{
|
|
public FailingConstructor(TestContext context) => Assert.Fail($"{context.TestName} could not start its fixture");
|
|
|
|
[Test]
|
|
public void Body() => Assert.Fail("the body ran after the constructor failed");
|
|
}
|
|
|
|
public sealed class ThrowingFieldInitializer
|
|
{
|
|
private readonly string _root = Environment.GetEnvironmentVariable("TITANO_NO_SUCH_VARIABLE") ?? throw new InvalidOperationException("no root folder");
|
|
|
|
[Test]
|
|
public void Body() => Assert.Fail("the body ran with " + _root);
|
|
}
|
|
|
|
public sealed class BesideOthers
|
|
{
|
|
[Test]
|
|
public async Task SeesItsOwnContext(TestContext context)
|
|
{
|
|
Assert.Same(context, TestContext.Current);
|
|
Assert.False(context.IsSerial);
|
|
await Task.Yield();
|
|
Assert.Same(context, await Task.Run(() => TestContext.Current));
|
|
}
|
|
}
|
|
|
|
[Serial]
|
|
public sealed class Alone
|
|
{
|
|
[Test]
|
|
public void KnowsItRunsAlone(TestContext context) => Assert.True(context.IsSerial && TestContext.Current == context);
|
|
}
|
|
|
|
private static async Task<TestResult> RunAsync<T>()
|
|
{
|
|
var test = TestRunner.Discover(typeof(T)).Single();
|
|
return await TestRunner.ExecuteAsync(test);
|
|
}
|
|
|
|
[Test]
|
|
public void NestedFixturesAreNotDiscoveredWithTheAssembly()
|
|
{
|
|
var names = TestRunner.Discover(typeof(TestRunnerTests).Assembly).Select(t => t.FullName).ToList();
|
|
Assert.Contains(typeof(TestRunnerTests).FullName + "." + nameof(NestedFixturesAreNotDiscoveredWithTheAssembly), names);
|
|
Assert.False(names.Any(n => n.Contains('+', StringComparison.Ordinal)), "a nested class would run as a real test");
|
|
}
|
|
|
|
[Test]
|
|
public async Task ASkipInTheConstructorSkipsTheTest()
|
|
{
|
|
var result = await RunAsync<SkippingConstructor>();
|
|
Assert.Equal(TestOutcome.Skipped, result.Outcome);
|
|
Assert.Equal("no server configured", result.Message);
|
|
}
|
|
|
|
[Test]
|
|
public async Task AFailureInTheConstructorKeepsItsMessage()
|
|
{
|
|
var result = await RunAsync<FailingConstructor>();
|
|
Assert.Equal(TestOutcome.Failed, result.Outcome);
|
|
Assert.Equal(typeof(FailingConstructor).FullName + ".Body could not start its fixture", result.Message);
|
|
Assert.Contains(nameof(FailingConstructor), result.StackTrace);
|
|
}
|
|
|
|
[Test]
|
|
public async Task AnExceptionInAFieldInitializerIsReportedAsItself()
|
|
{
|
|
var result = await RunAsync<ThrowingFieldInitializer>();
|
|
Assert.Equal(TestOutcome.Failed, result.Outcome);
|
|
Assert.Equal("System.InvalidOperationException: no root folder", result.Message);
|
|
}
|
|
|
|
[Test]
|
|
public async Task TheCurrentContextFollowsEachTestAndItsTasks()
|
|
{
|
|
var parallel = await RunAsync<BesideOthers>();
|
|
Assert.Equal(TestOutcome.Passed, parallel.Outcome, parallel.Message);
|
|
var alone = await RunAsync<Alone>();
|
|
Assert.Equal(TestOutcome.Passed, alone.Outcome, alone.Message);
|
|
Assert.Same(context, TestContext.Current);
|
|
}
|
|
}
|