Files
Chronos/tests/Titano.App.Tests/Library/ThumbnailCacheTests.cs
T
Claude 8d4b00aceb test(app): screen smoke tests and thumbnail decoding on Windows
Every screen is rendered from the --capture sample data in an off-screen
main window in both themes; thumbnails are decoded from embedded previews
with orientation. The sign-in flow now stores the login token on every
IServerApi, and thumbnail pending loads include index lookups so capture
waits for them. A cancelled-load test no longer depends on scheduling.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
2026-10-02 12:40:57 +00:00

170 lines
6.2 KiB
C#

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<int>();
using var cache = new ThumbnailCache<int, string>(3, (k, _) =>
{
loads.Add(k);
return Task.FromResult<string?>("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<int, string>(8, (k, _) =>
{
Interlocked.Increment(ref calls);
return k == 13 ? throw new IOException("unreadable") : Task.FromResult<string?>(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<IOException>(() => cache.GetAsync(13, CancellationToken.None));
await Assert.ThrowsAsync<IOException>(() => 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<int, string>(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<int, string>(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<OperationCanceledException>(() => 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<OperationCanceledException>(() => 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<int, string>(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<OperationCanceledException>(() => 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<int, string>(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)
{
}
}
}