using Chronos.Data.Archiving; using Chronos.Testing; namespace Chronos.Data.Tests.Archiving; /// Several photos of a pass at once (owner review 1, R2), their results taken in order. public sealed class OrderedWorkTests { [Test] public async Task ResultsAreTakenInOrderWhateverFinishesFirst() { var taken = new List(); await using (var work = new OrderedWork(4, n => { taken.Add(n); return ValueTask.CompletedTask; }, CancellationToken.None)) { for (var i = 0; i < 24; i++) { var n = i; // The later items are the quicker ones. await work.AddAsync(_ => { Thread.Sleep((24 - n) * 2); return n; }); if (n % 5 == 0) await work.AddAsync(1000 + n); } await work.CompleteAsync(); } int[] expected = [.. Enumerable.Range(0, 24).SelectMany(n => n % 5 == 0 ? new[] { n, 1000 + n } : [n])]; Assert.SequenceEqual(expected, taken); } [Test] public async Task ExactlyTheParallelismRunsAtOnceAndOneRunsInline() { var running = 0; var peak = 0; await using (var work = new OrderedWork(3, _ => ValueTask.CompletedTask, CancellationToken.None)) { for (var i = 0; i < 12; i++) { await work.AddAsync(_ => { var now = Interlocked.Increment(ref running); int seen; while ((seen = Volatile.Read(ref peak)) < now && Interlocked.CompareExchange(ref peak, now, seen) != seen) { } // Each waits for two others, which proves three run together whatever the load (the pool adds threads). SpinWait.SpinUntil(() => Volatile.Read(ref peak) >= 3, TimeSpan.FromSeconds(10)); Thread.Sleep(2); Interlocked.Decrement(ref running); return 0; }); } await work.CompleteAsync(); } Assert.Equal(3, peak); var caller = Environment.CurrentManagedThreadId; var threads = new List(); await using (var single = new OrderedWork(1, _ => ValueTask.CompletedTask, CancellationToken.None)) { for (var i = 0; i < 3; i++) { await single.AddAsync(_ => { threads.Add(Environment.CurrentManagedThreadId); return 0; }); } await single.CompleteAsync(); } Assert.SequenceEqual([caller, caller, caller], threads); } [Test] public async Task AFailureStopsTheWorkStillRunningBeforeThePassEnds() { var started = 0; var finished = 0; var stopped = 0; var taken = new List(); var work = new OrderedWork(4, n => { taken.Add(n); return ValueTask.CompletedTask; }, CancellationToken.None); var failure = await Assert.ThrowsAsync(async () => { try { for (var i = 0; i < 8; i++) { var n = i; await work.AddAsync(ct => { Interlocked.Increment(ref started); try { if (n == 2) throw new InvalidDataException("damaged photo"); if (n > 2) { // The photos after the damaged one take long, until the pass stops them. if (ct.WaitHandle.WaitOne(TimeSpan.FromSeconds(10))) Interlocked.Increment(ref stopped); ct.ThrowIfCancellationRequested(); } return n; } finally { Interlocked.Increment(ref finished); } }); } await work.CompleteAsync(); } finally { await work.DisposeAsync(); } }); Assert.Equal("damaged photo", failure.Message); Assert.SequenceEqual([0, 1], taken); // Nothing the pass started outlives it. Assert.Equal(Volatile.Read(ref started), Volatile.Read(ref finished)); Assert.Equal(Volatile.Read(ref started) - 3, Volatile.Read(ref stopped)); } }