using Chronos.App.Settings; using Chronos.Testing; namespace Chronos.App.Tests.Settings; /// /// Settings › Archive never shows a read of the archive's settings that overlapped an edit being written: on a slow share /// that read can hold archive.json as it was before the edit, and would undo the edit on the rows and in this PC's /// defaults while the archive keeps it. Its reader waits for the edits instead and reads again, so the read is done only /// once the rows show what the archive holds. /// public sealed class ArchiveReadGateTests { [Test] public void AReadWithNoEditMeanwhileIsShown() { var gate = new ArchiveReadGate(); Assert.True(gate.IsCurrent(gate.BeginRead())); Assert.True(gate.WrittenAsync().IsCompleted, "no edit is being written"); // An edit written and ended before the read began is in the file it reads. gate.BeginWrite(); gate.EndWrite(); Assert.True(gate.IsCurrent(gate.BeginRead())); Assert.True(gate.WrittenAsync().IsCompleted); } [Test] public void AReadThatAnEditOverlapsWaitsForTheEditAndReadsAgain() { // Settings is shown and reads archive.json; the user commits a template before the read answers. var gate = new ArchiveReadGate(); var read = gate.BeginRead(); gate.BeginWrite(); Assert.False(gate.IsCurrent(read), "the read may hold the file before the edit"); var written = gate.WrittenAsync(); Assert.False(written.IsCompleted, "the edit is still being written"); gate.EndWrite(); Assert.True(written.IsCompleted, "the reader reads again once the edit is written"); Assert.True(gate.IsCurrent(gate.BeginRead())); // The edit began and ended while the read was out: the reader reads again at once. read = gate.BeginRead(); gate.BeginWrite(); gate.EndWrite(); Assert.False(gate.IsCurrent(read)); Assert.True(gate.WrittenAsync().IsCompleted); Assert.True(gate.IsCurrent(gate.BeginRead())); } [Test] public void AReadBegunWhileAnEditIsWrittenIsNeverShown() { // The rows are read again (a folder change, the screen shown) while an edit is still being written. var gate = new ArchiveReadGate(); gate.BeginWrite(); var read = gate.BeginRead(); Assert.False(gate.IsCurrent(read)); var written = gate.WrittenAsync(); gate.EndWrite(); Assert.False(gate.IsCurrent(read), "it began before the edit was written"); Assert.True(written.IsCompleted); Assert.True(gate.IsCurrent(gate.BeginRead())); } [Test] public async Task AReaderGoesOnOnlyOnceTheLastOfSeveralEditsIsWrittenAndNeverInsideIt() { // A proxy size and a thumbnail size picked one after the other, both overlapping a read. var gate = new ArchiveReadGate(); var read = gate.BeginRead(); gate.BeginWrite(); gate.BeginWrite(); Assert.False(gate.IsCurrent(read)); var written = gate.WrittenAsync(); Assert.Same(written, gate.WrittenAsync()); gate.EndWrite(); Assert.False(written.IsCompleted, "another edit is still being written"); // The reader goes on once the last edit ends, never inside its EndWrite: the writer finishes first. var thread = Environment.CurrentManagedThreadId; var ending = false; var inside = written.ContinueWith(_ => ending && Environment.CurrentManagedThreadId == thread, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default); ending = true; gate.EndWrite(); ending = false; Assert.True(written.IsCompleted); Assert.False(await inside, "the reader did not go on inside EndWrite"); Assert.True(gate.IsCurrent(gate.BeginRead())); Assert.Throws(() => gate.EndWrite()); } }