- Tests for undo after adopted changes, run ending, saver retries and stop, the local source refusing unsaved writes, re-solves without decoding and equal to a fresh preparation, 1:1 pictures, waveform, crop margins and the values of the Optimise toast; the Windows smoke test checks Render, Batch, the waveform, 1:1, the window title and the hidden idle job bar. - The capture sample has a manual value and camera keyframes; the capture adds the overlays, the waveform, the Optimise toast and Export.html's tool state. - Crop margins live in a WPF-free class; a discarded change stops retrying. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
204 lines
6.9 KiB
C#
204 lines
6.9 KiB
C#
using System.Collections.Concurrent;
|
|
using Titano.App.Editor;
|
|
using Titano.Core.Project;
|
|
using Titano.Testing;
|
|
|
|
namespace Titano.App.Tests.Editor;
|
|
|
|
/// <summary>Debouncing and cancellation of preview work, and the coalescing project writer.</summary>
|
|
public sealed class SchedulingTests
|
|
{
|
|
[Test]
|
|
public async Task OnlyTheLastOfRapidRequestsRuns()
|
|
{
|
|
using var runner = new LatestRunner(TimeSpan.FromMilliseconds(80));
|
|
var ran = new ConcurrentQueue<int>();
|
|
var tasks = Enumerable.Range(0, 10).Select(i => runner.Schedule(_ =>
|
|
{
|
|
ran.Enqueue(i);
|
|
return Task.CompletedTask;
|
|
})).ToList();
|
|
await Task.WhenAll(tasks);
|
|
Assert.SequenceEqual([9], ran);
|
|
}
|
|
|
|
[Test]
|
|
public async Task ANewRequestCancelsTheRunningOne()
|
|
{
|
|
using var runner = new LatestRunner(TimeSpan.Zero);
|
|
var started = new TaskCompletionSource();
|
|
var cancelled = false;
|
|
var first = runner.Schedule(async token =>
|
|
{
|
|
started.SetResult();
|
|
try
|
|
{
|
|
await Task.Delay(Timeout.Infinite, token);
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
cancelled = true;
|
|
throw;
|
|
}
|
|
});
|
|
await started.Task;
|
|
var second = runner.Schedule(_ => Task.CompletedTask);
|
|
await Task.WhenAll(first, second);
|
|
Assert.True(cancelled, "the superseded run saw its token cancelled");
|
|
Assert.True(first.IsCompletedSuccessfully, "a superseded run ends quietly");
|
|
}
|
|
|
|
[Test]
|
|
public async Task ImmediateRequestsSkipTheDelay()
|
|
{
|
|
using var runner = new LatestRunner(TimeSpan.FromSeconds(30));
|
|
var ran = false;
|
|
await runner.Schedule(_ =>
|
|
{
|
|
ran = true;
|
|
return Task.CompletedTask;
|
|
}, immediate: true).WaitAsync(TimeSpan.FromSeconds(10));
|
|
Assert.True(ran);
|
|
}
|
|
|
|
[Test]
|
|
public async Task FailuresSurfaceFromTheRun()
|
|
{
|
|
using var runner = new LatestRunner(TimeSpan.Zero);
|
|
await Assert.ThrowsAsync<InvalidOperationException>(() => runner.Schedule(_ => throw new InvalidOperationException("broken")));
|
|
}
|
|
|
|
[Test]
|
|
public async Task CancelStopsThePendingRequest()
|
|
{
|
|
using var runner = new LatestRunner(TimeSpan.FromMilliseconds(200));
|
|
var ran = false;
|
|
var run = runner.Schedule(_ =>
|
|
{
|
|
ran = true;
|
|
return Task.CompletedTask;
|
|
});
|
|
runner.Cancel();
|
|
await run;
|
|
Assert.False(ran);
|
|
}
|
|
|
|
[Test]
|
|
public async Task TheSaverWritesTheNewestProjectOnce()
|
|
{
|
|
var saved = new List<int?>();
|
|
var saver = new ProjectSaver(p =>
|
|
{
|
|
saved.Add(p.HeroFrame);
|
|
return Task.CompletedTask;
|
|
}, TimeSpan.FromMilliseconds(50));
|
|
for (var i = 0; i < 5; i++) saver.Schedule(new ProjectSettings { HeroFrame = i });
|
|
await saver.FlushAsync();
|
|
Assert.SequenceEqual([(int?)4], saved);
|
|
Assert.False(saver.HasPendingChanges);
|
|
}
|
|
|
|
[Test]
|
|
public async Task FlushSkipsTheDelay()
|
|
{
|
|
var saved = 0;
|
|
var saver = new ProjectSaver(_ =>
|
|
{
|
|
saved++;
|
|
return Task.CompletedTask;
|
|
}, TimeSpan.FromMinutes(5));
|
|
saver.Schedule(new ProjectSettings());
|
|
await saver.FlushAsync().WaitAsync(TimeSpan.FromSeconds(10));
|
|
Assert.Equal(1, saved);
|
|
}
|
|
|
|
[Test]
|
|
public async Task AFailedWriteIsRetriedUntilStored()
|
|
{
|
|
var attempts = 0;
|
|
var stored = new List<int?>();
|
|
var failures = new List<int>();
|
|
var saver = new ProjectSaver(p =>
|
|
{
|
|
if (++attempts <= 2) throw new System.IO.IOException("offline");
|
|
stored.Add(p.HeroFrame);
|
|
return Task.CompletedTask;
|
|
}, TimeSpan.Zero);
|
|
saver.Failed += (_, count) => failures.Add(count);
|
|
// Without a delay the first write happens at once and fails; the flush retries at once and fails again.
|
|
saver.Schedule(new ProjectSettings { HeroFrame = 7 });
|
|
Assert.False(await saver.FlushAsync());
|
|
Assert.True(saver.HasPendingChanges, "kept pending after a failure");
|
|
Assert.NotNull(saver.LastError);
|
|
Assert.True(await saver.FlushAsync().WaitAsync(TimeSpan.FromSeconds(10)), "a flush skips the retry delay");
|
|
Assert.SequenceEqual([(int?)7], stored);
|
|
Assert.SequenceEqual([1, 2], failures, "failures in a row are counted");
|
|
Assert.False(saver.HasPendingChanges);
|
|
Assert.Null(saver.LastError);
|
|
}
|
|
|
|
[Test]
|
|
public async Task ARetryWritesTheNewestChange()
|
|
{
|
|
var fail = true;
|
|
var stored = new List<int?>();
|
|
var saver = new ProjectSaver(p =>
|
|
{
|
|
if (fail) throw new System.IO.IOException("offline");
|
|
stored.Add(p.HeroFrame);
|
|
return Task.CompletedTask;
|
|
}, TimeSpan.Zero);
|
|
saver.Schedule(new ProjectSettings { HeroFrame = 1 });
|
|
Assert.False(await saver.FlushAsync());
|
|
saver.Schedule(new ProjectSettings { HeroFrame = 2 });
|
|
fail = false;
|
|
Assert.True(await saver.FlushAsync());
|
|
Assert.SequenceEqual([(int?)2], stored, "the newer project contains the failed one");
|
|
}
|
|
|
|
[Test]
|
|
public async Task StopDropsThePendingChange()
|
|
{
|
|
var saved = 0;
|
|
var saver = new ProjectSaver(_ =>
|
|
{
|
|
saved++;
|
|
throw new System.IO.IOException("offline");
|
|
}, TimeSpan.Zero);
|
|
saver.Schedule(new ProjectSettings { HeroFrame = 1 });
|
|
Assert.False(await saver.FlushAsync());
|
|
var attempts = saved;
|
|
saver.Stop();
|
|
Assert.True(await saver.FlushAsync().WaitAsync(TimeSpan.FromSeconds(10)), "nothing pending after a stop");
|
|
saver.Schedule(new ProjectSettings { HeroFrame = 2 });
|
|
Assert.False(saver.HasPendingChanges, "a stopped saver takes no new change");
|
|
Assert.Equal(attempts, saved);
|
|
}
|
|
|
|
[Test]
|
|
public async Task FlushWithNothingPendingIsStored()
|
|
{
|
|
var saver = new ProjectSaver(_ => Task.CompletedTask, TimeSpan.FromMinutes(5));
|
|
Assert.True(await saver.FlushAsync().WaitAsync(TimeSpan.FromSeconds(10)));
|
|
}
|
|
|
|
[Test]
|
|
public async Task AChangeDuringAWriteIsWrittenAfterIt()
|
|
{
|
|
var gate = new TaskCompletionSource();
|
|
var saved = new List<int?>();
|
|
var saver = new ProjectSaver(async p =>
|
|
{
|
|
saved.Add(p.HeroFrame);
|
|
if (saved.Count == 1) await gate.Task;
|
|
}, TimeSpan.Zero);
|
|
saver.Schedule(new ProjectSettings { HeroFrame = 1 });
|
|
while (saved.Count == 0) await Task.Delay(5);
|
|
saver.Schedule(new ProjectSettings { HeroFrame = 2 });
|
|
saver.Schedule(new ProjectSettings { HeroFrame = 3 });
|
|
gate.SetResult();
|
|
await saver.FlushAsync();
|
|
Assert.SequenceEqual([(int?)1, 3], saved);
|
|
}
|
|
}
|