using Febe.Core.Simulation; namespace Febe.Tests.Engine; [TestClass] public sealed class VirtualClockTests { private static readonly DateTimeOffset Start = new(2026, 10, 14, 10, 0, 0, TimeSpan.Zero); [TestMethod] public async Task DelaysCompleteOnlyWhenTimeReachesThem() { var clock = new VirtualClock(Start); var late = clock.Delay(TimeSpan.FromMinutes(10), CancellationToken.None); var early = clock.Delay(TimeSpan.FromMinutes(5), CancellationToken.None); Assert.AreEqual(2, clock.PendingTimers); Assert.IsFalse(early.IsCompleted); clock.Advance(TimeSpan.FromMinutes(6)); await early; Assert.IsFalse(late.IsCompleted); Assert.AreEqual(Start.AddMinutes(6), clock.Now); clock.Advance(TimeSpan.FromMinutes(10)); await late; Assert.AreEqual(0, clock.PendingTimers); } [TestMethod] public async Task ACancelledDelayLeavesTheQueue() { var clock = new VirtualClock(Start); using var cts = new CancellationTokenSource(); var delay = clock.Delay(TimeSpan.FromHours(1), cts.Token); Assert.AreEqual(1, clock.PendingTimers); await cts.CancelAsync(); Assert.AreEqual(0, clock.PendingTimers); await Assert.ThrowsAsync(() => delay); } [TestMethod] public async Task RunUntilJumpsFromTimerToTimerWhileTheActorWaits() { var clock = new VirtualClock(Start); var seen = new List(); using var cts = new CancellationTokenSource(); async Task Actor() { for (var i = 0; i < 5; i++) { await Task.Yield(); await clock.Delay(TimeSpan.FromMinutes(30), cts.Token); seen.Add(clock.Now); } await clock.Delay(TimeSpan.FromDays(10), cts.Token); } var actor = Actor(); await clock.RunUntilAsync(Start.AddHours(2), CancellationToken.None, actor); Assert.AreEqual(Start.AddHours(2), clock.Now); CollectionAssert.AreEqual(new[] { Start.AddMinutes(30), Start.AddMinutes(60), Start.AddMinutes(90), Start.AddMinutes(120) }, seen); await clock.RunUntilAsync(Start.AddHours(3), CancellationToken.None, actor); Assert.HasCount(5, seen); await cts.CancelAsync(); await Assert.ThrowsAsync(() => actor); } [TestMethod] public async Task AFailingActorStopsTheRun() { var clock = new VirtualClock(Start); async Task Actor() { await clock.Delay(TimeSpan.FromMinutes(1), CancellationToken.None); throw new InvalidOperationException("guasto"); } var actor = Actor(); await Assert.ThrowsAsync(() => clock.RunUntilAsync(Start.AddHours(1), CancellationToken.None, actor)); } [TestMethod] public async Task ATimerCancelledFromThePoolNeverEndsTheRunEarly() { // As EngineHost.OnBreakerChanged does: a pool thread cancels the actor's pending timer (here as soon as it is // registered, so that it often lands between the driver's look at the actors and its decision). for (var i = 0; i < 20_000; i++) { var clock = new VirtualClock(Start); using var session = new CancellationTokenSource(); using var end = new CancellationTokenSource(); var oneMinuteLater = false; var stop = 0; Task? canceller = null; async Task Actor() { canceller = Task.Run(() => { while (clock.PendingTimers == 0 && Volatile.Read(ref stop) == 0) { Thread.SpinWait(20); } session.Cancel(); }); try { await clock.Delay(TimeSpan.FromSeconds(5), session.Token); } catch (OperationCanceledException) { } await clock.Delay(TimeSpan.FromMinutes(1), CancellationToken.None); oneMinuteLater = true; await clock.Delay(TimeSpan.FromDays(10), end.Token); } var actor = Actor(); bool reached; DateTimeOffset at; try { await clock.RunUntilAsync(Start.AddHours(1), CancellationToken.None, actor); reached = Volatile.Read(ref oneMinuteLater); at = clock.Now; } finally { // Lets the actor end in every case (also when the driver left it behind), so nothing keeps running. Volatile.Write(ref stop, 1); await canceller!; await end.CancelAsync(); for (var spin = 0; !actor.IsCompleted && spin < 1000; spin++) { clock.AdvanceTo(clock.Now.AddDays(1)); await Task.WhenAny(actor, Task.Delay(1)); } } Assert.IsTrue(reached, $"Run {i}: the driver returned while the actor was running, and skipped its timer."); Assert.AreEqual(Start.AddHours(1), at); Assert.IsTrue(actor.IsCanceled, $"Run {i}: the actor ends on its last timer, cancelled here."); } } [TestMethod] public async Task AutoAdvanceMovesTimeAtOnceAndRoundsToMilliseconds() { var clock = new VirtualClock(Start) { AutoAdvance = true }; await clock.Delay(TimeSpan.FromTicks(1), CancellationToken.None); Assert.AreEqual(Start.AddMilliseconds(1), clock.Now); await clock.Delay(TimeSpan.FromSeconds(4), CancellationToken.None); Assert.AreEqual(Start.AddMilliseconds(4001), clock.Now); } }