using System.Collections.Concurrent; using System.IO; using Titano.App.Library; using Titano.Testing; namespace Titano.App.Tests.Library; public sealed class ThumbnailCacheTests { private static readonly TimeSpan Wait = TimeSpan.FromSeconds(10); [Test] public async Task LeastRecentlyUsedEntriesAreEvicted() { var loads = new ConcurrentBag(); using var cache = new ThumbnailCache(3, (k, _) => { loads.Add(k); return Task.FromResult("img" + k); }); Assert.Equal("img1", await cache.GetAsync(1, CancellationToken.None)); await cache.GetAsync(2, CancellationToken.None); await cache.GetAsync(3, CancellationToken.None); Assert.True(cache.TryGet(1, out _)); // 1 becomes the most recent await cache.GetAsync(4, CancellationToken.None); // evicts 2 Assert.Equal(3, cache.Count); Assert.False(cache.TryGet(2, out _)); Assert.True(cache.TryGet(1, out var one)); Assert.Equal("img1", one); Assert.True(cache.TryGet(3, out _)); Assert.True(cache.TryGet(4, out _)); await cache.GetAsync(1, CancellationToken.None); Assert.Equal(4, loads.Count); // the cached key was not decoded again cache.Capacity = 1; Assert.Equal(1, cache.Count); Assert.True(cache.TryGet(1, out _)); } [Test] public async Task MissingThumbnailsAreCachedButFailuresAreNot() { var calls = 0; using var cache = new ThumbnailCache(8, (k, _) => { Interlocked.Increment(ref calls); return k == 13 ? throw new IOException("unreadable") : Task.FromResult(null); }); Assert.Null(await cache.GetAsync(1, CancellationToken.None)); Assert.Null(await cache.GetAsync(1, CancellationToken.None)); Assert.True(cache.TryGet(1, out var none)); Assert.Null(none); await Assert.ThrowsAsync(() => cache.GetAsync(13, CancellationToken.None)); await Assert.ThrowsAsync(() => cache.GetAsync(13, CancellationToken.None)); Assert.Equal(3, calls); Assert.Equal(0, cache.PendingLoads); } [Test] public async Task ConcurrentRequestsShareOneLoad() { var release = new TaskCompletionSource(); var calls = 0; using var cache = new ThumbnailCache(8, async (k, ct) => { Interlocked.Increment(ref calls); await release.Task.WaitAsync(ct); return "img" + k; }); var a = cache.GetAsync(7, CancellationToken.None); var b = cache.GetAsync(7, CancellationToken.None); release.SetResult(); Assert.Equal("img7", await a.WaitAsync(Wait)); Assert.Equal("img7", await b.WaitAsync(Wait)); Assert.Equal(1, calls); } [Test] public async Task ALoadStopsWhenEveryRequestIsCancelled() { var started = new TaskCompletionSource(); var observed = new TaskCompletionSource(); using var cache = new ThumbnailCache(8, async (_, ct) => { started.TrySetResult(); try { await Task.Delay(Timeout.Infinite, ct); } catch (OperationCanceledException) { observed.TrySetResult(); throw; } return "never"; }); using var first = new CancellationTokenSource(); using var second = new CancellationTokenSource(); var a = cache.GetAsync(5, first.Token); var b = cache.GetAsync(5, second.Token); await started.Task.WaitAsync(Wait); first.Cancel(); await Assert.ThrowsAsync(() => a); Assert.False(observed.Task.IsCompleted, "the load must continue while another card still waits"); Assert.Equal(1, cache.PendingLoads); second.Cancel(); await Assert.ThrowsAsync(() => b); await observed.Task.WaitAsync(Wait); Assert.Equal(0, cache.PendingLoads); Assert.False(cache.TryGet(5, out _)); } [Test] public async Task ALoadAfterACancelledOneStartsFresh() { var attempts = 0; var blocked = true; using var cache = new ThumbnailCache(8, async (k, ct) => { Interlocked.Increment(ref attempts); if (Volatile.Read(ref blocked)) await Task.Delay(Timeout.Infinite, ct); return "img" + k; }); using var scrolledAway = new CancellationTokenSource(); var first = cache.GetAsync(9, scrolledAway.Token); scrolledAway.Cancel(); await Assert.ThrowsAsync(() => first); Volatile.Write(ref blocked, false); Assert.Equal("img9", await cache.GetAsync(9, CancellationToken.None).WaitAsync(Wait)); // The cancelled load may have stopped before it reached the decoder. Assert.InRange(Volatile.Read(ref attempts), 1, 2); Assert.Equal(0, cache.PendingLoads); } [Test] public async Task LoadsRunConcurrentlyUpToTheLimit() { var running = 0; var peak = 0; var gate = new TaskCompletionSource(); using var cache = new ThumbnailCache(64, async (k, ct) => { var now = Interlocked.Increment(ref running); InterlockedMax(ref peak, now); await gate.Task.WaitAsync(ct); Interlocked.Decrement(ref running); return "img" + k; }, maxConcurrentLoads: 2); var tasks = Enumerable.Range(0, 10).Select(i => cache.GetAsync(i, CancellationToken.None)).ToList(); await Task.Delay(100); Assert.LessOrEqual(Volatile.Read(ref running), 2); gate.SetResult(); await Task.WhenAll(tasks).WaitAsync(Wait); Assert.LessOrEqual(peak, 2); Assert.Equal(10, cache.Count); } private static void InterlockedMax(ref int target, int value) { int current; while ((current = Volatile.Read(ref target)) < value && Interlocked.CompareExchange(ref target, value, current) != current) { } } }