295 lines
13 KiB
C#
295 lines
13 KiB
C#
using GAJ3T.MusicGen.RiffGrooveBuilder.Generation.Midi;
|
|
using GAJ3T.MusicGen.RiffGrooveBuilder.Core.Composition;
|
|
using GAJ3T.MusicGen.RiffGrooveBuilder.UnitTests.Articulations;
|
|
using Melanchall.DryWetMidi.Core;
|
|
|
|
namespace GAJ3T.MusicGen.RiffGrooveBuilder.UnitTests.Midi;
|
|
|
|
public sealed class MidiFileWriterTests : IDisposable
|
|
{
|
|
private readonly string directory = Path.Combine(AppContext.BaseDirectory, "midi-writer-" + Guid.NewGuid().ToString("N"));
|
|
|
|
public MidiFileWriterTests() => Directory.CreateDirectory(directory);
|
|
|
|
[Fact]
|
|
public void BorrowedWritableStreamStaysOpenAndReadsBack()
|
|
{
|
|
var (composition, plan) = MidiTestData.Arrangement();
|
|
using var stream = new MemoryStream();
|
|
MidiFileWriter.Write(stream, composition, plan);
|
|
Assert.True(stream.CanWrite);
|
|
stream.Position = 0;
|
|
var read = MidiTestData.Read(stream);
|
|
Assert.Equal(MidiFileFormat.MultiTrack, read.OriginalFormat);
|
|
Assert.Equal(2, read.Chunks.Count);
|
|
Assert.True(stream.CanWrite);
|
|
}
|
|
|
|
[Fact]
|
|
public void BorrowedNonseekableStreamIsSupported()
|
|
{
|
|
var (composition, plan) = MidiTestData.Arrangement();
|
|
using var stream = new ObservedStream();
|
|
MidiFileWriter.Write(stream, composition, plan);
|
|
Assert.False(stream.Closed);
|
|
using var bytes = new MemoryStream(stream.Bytes);
|
|
Assert.Equal(2, MidiTestData.Read(bytes).Chunks.Count);
|
|
}
|
|
|
|
[Fact]
|
|
public void InvalidReadOnlyDisposedAndFailingStreamsAreTruthful()
|
|
{
|
|
var (composition, plan) = MidiTestData.Arrangement();
|
|
Assert.Throws<ArgumentNullException>(() => MidiFileWriter.Write(null!, composition, plan));
|
|
using var readOnly = new MemoryStream([], writable: false);
|
|
Assert.Throws<ArgumentException>(() => MidiFileWriter.Write(readOnly, composition, plan));
|
|
var disposed = new MemoryStream();
|
|
disposed.Dispose();
|
|
Assert.Throws<ArgumentException>(() => MidiFileWriter.Write(disposed, composition, plan));
|
|
using var failing = new ObservedStream(failAfter: 20);
|
|
var error = Assert.Throws<IOException>(() => MidiFileWriter.Write(failing, composition, plan));
|
|
Assert.Equal("synthetic stream failure", error.Message);
|
|
Assert.False(failing.Closed);
|
|
Assert.NotEmpty(failing.Bytes);
|
|
}
|
|
|
|
[Fact]
|
|
public void StreamPreflightFailureOrPrecancellationWritesNothing()
|
|
{
|
|
var (composition, plan) = MidiTestData.Arrangement();
|
|
using var stream = new MemoryStream();
|
|
Assert.Throws<ArgumentNullException>(() => MidiFileWriter.Write(stream, null!, plan));
|
|
Assert.Empty(stream.ToArray());
|
|
Assert.Throws<OperationCanceledException>(() => MidiFileWriter.Write(stream, composition, plan, new CancellationToken(true)));
|
|
Assert.Empty(stream.ToArray());
|
|
Assert.True(stream.CanWrite);
|
|
}
|
|
|
|
[Fact]
|
|
public void CancellationObservedAfterSynchronousWriteLeavesBorrowedPartialOrCompleteBytes()
|
|
{
|
|
var (composition, plan) = MidiTestData.Arrangement();
|
|
using var cancellation = new CancellationTokenSource();
|
|
using var stream = new ObservedStream(afterWrite: cancellation.Cancel);
|
|
Assert.Throws<OperationCanceledException>(() => MidiFileWriter.Write(stream, composition, plan, cancellation.Token));
|
|
Assert.NotEmpty(stream.Bytes);
|
|
Assert.False(stream.Closed);
|
|
}
|
|
|
|
[Fact]
|
|
public void ActualFileIsReadableAndPreexistingDestinationNeverChanges()
|
|
{
|
|
var (composition, plan) = MidiTestData.Arrangement();
|
|
var path = Path.Combine(directory, "song.mid");
|
|
var unrelated = Path.Combine(directory, ".unrelated.stage");
|
|
File.WriteAllText(unrelated, "keep");
|
|
MidiFileWriter.WriteFile(path, composition, plan);
|
|
var before = File.ReadAllBytes(path);
|
|
using (var stream = File.OpenRead(path))
|
|
Assert.Equal(MidiFileFormat.MultiTrack, MidiTestData.Read(stream).OriginalFormat);
|
|
Assert.Throws<IOException>(() => MidiFileWriter.WriteFile(path, composition, plan));
|
|
Assert.Equal(before, File.ReadAllBytes(path));
|
|
Assert.Equal("keep", File.ReadAllText(unrelated));
|
|
Assert.Equal(2, Directory.GetFiles(directory).Length);
|
|
}
|
|
|
|
[Fact]
|
|
public void CollisionAfterStagingUsesAtomicNoOverwriteMoveAndRemovesOnlyOwnedStage()
|
|
{
|
|
var path = Path.Combine(directory, "collision.mid");
|
|
string? stage = null;
|
|
Assert.Throws<IOException>(() => MidiFileWriter.Publish(path, stream =>
|
|
{
|
|
stage = Assert.IsType<FileStream>(stream).Name;
|
|
Assert.Equal(directory, Path.GetDirectoryName(stage));
|
|
Assert.NotEqual(path, stage);
|
|
stream.WriteByte(42);
|
|
File.WriteAllText(path, "racing owner");
|
|
}, CancellationToken.None));
|
|
Assert.Equal("racing owner", File.ReadAllText(path));
|
|
Assert.False(File.Exists(stage));
|
|
Assert.Single(Directory.GetFiles(directory));
|
|
}
|
|
|
|
[Fact]
|
|
public void LateDirectoryCollisionAlsoPreservesDestinationAndCleansOnlyStage()
|
|
{
|
|
var path = Path.Combine(directory, "racing-directory.mid");
|
|
Assert.Throws<IOException>(() => MidiFileWriter.Publish(path, stream =>
|
|
{
|
|
stream.WriteByte(42);
|
|
Directory.CreateDirectory(path);
|
|
}, CancellationToken.None));
|
|
Assert.True(Directory.Exists(path));
|
|
Assert.Empty(Directory.GetFiles(directory));
|
|
}
|
|
|
|
[Fact]
|
|
public void UnrepresentablePlanNeverCreatesStageOrTouchesBorrowedBytes()
|
|
{
|
|
var composition = SyntheticProfiles.Model(SyntheticProfiles.Note(articulation: Articulation.PalmMute));
|
|
var plan = MidiTestData.Plan(composition, SyntheticProfiles.Switched(advance: 0x10000000).Build());
|
|
var path = Path.Combine(directory, "too-long.mid");
|
|
Assert.Throws<ArgumentOutOfRangeException>(() => MidiFileWriter.WriteFile(path, composition, plan));
|
|
using var stream = new MemoryStream();
|
|
Assert.Throws<ArgumentOutOfRangeException>(() => MidiFileWriter.Write(stream, composition, plan));
|
|
Assert.Empty(stream.ToArray());
|
|
Assert.Empty(Directory.GetFileSystemEntries(directory));
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(false)]
|
|
[InlineData(true)]
|
|
public void FailedOrCancelledStagingCleansOwnedFileAndPreservesOtherFiles(bool cancel)
|
|
{
|
|
var path = Path.Combine(directory, "failed.mid");
|
|
var unrelated = Path.Combine(directory, ".other-request.stage");
|
|
File.WriteAllText(unrelated, "keep");
|
|
using var cancellation = new CancellationTokenSource();
|
|
string? stage = null;
|
|
var original = new IOException("synthetic staging failure");
|
|
var error = Record.Exception(() => MidiFileWriter.Publish(path, stream =>
|
|
{
|
|
stage = Assert.IsType<FileStream>(stream).Name;
|
|
stream.WriteByte(42);
|
|
if (cancel) cancellation.Cancel();
|
|
else throw original;
|
|
}, cancellation.Token));
|
|
if (cancel) Assert.IsType<OperationCanceledException>(error);
|
|
else Assert.Same(original, error);
|
|
Assert.False(File.Exists(stage));
|
|
Assert.False(File.Exists(path));
|
|
Assert.Equal("keep", File.ReadAllText(unrelated));
|
|
Assert.Single(Directory.GetFiles(directory));
|
|
}
|
|
|
|
[Fact]
|
|
public void CleanupFailureExplicitlyRetainsOriginalErrorAndOwnedPath()
|
|
{
|
|
var stage = Path.Combine(directory, ".locked-owned.stage");
|
|
var original = new OperationCanceledException("original cancellation");
|
|
using (var locked = new FileStream(stage, FileMode.CreateNew, FileAccess.Write, FileShare.None))
|
|
{
|
|
var error = Assert.Throws<AggregateException>(() => MidiFileWriter.Cleanup(stage, original));
|
|
Assert.Contains(stage, error.Message);
|
|
Assert.Same(original, error.InnerExceptions[0]);
|
|
Assert.IsType<IOException>(error.InnerExceptions[1]);
|
|
Assert.True(File.Exists(stage));
|
|
}
|
|
File.Delete(stage);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(false)]
|
|
[InlineData(true)]
|
|
public void StageCloseFailureIsReportedWithoutHidingOriginalWriteOrCancellation(bool cancel)
|
|
{
|
|
using var cancellation = new CancellationTokenSource();
|
|
var original = new IOException("original write error");
|
|
var close = new IOException("synthetic close error");
|
|
var stream = new CloseFailingStream(close);
|
|
var error = Assert.Throws<AggregateException>(() => MidiFileWriter.CompleteStage(stream, _ =>
|
|
{
|
|
if (cancel) cancellation.Cancel();
|
|
else throw original;
|
|
}, cancellation.Token));
|
|
if (cancel) Assert.IsType<OperationCanceledException>(error.InnerExceptions[0]);
|
|
else Assert.Same(original, error.InnerExceptions[0]);
|
|
Assert.Same(close, error.InnerExceptions[1]);
|
|
Assert.False(stream.CanWrite);
|
|
}
|
|
|
|
[Fact]
|
|
public void StageCloseFailureAloneDoesNotBecomeSuccess()
|
|
{
|
|
var close = new IOException("synthetic close error");
|
|
var stream = new CloseFailingStream(close);
|
|
Assert.Same(close, Assert.Throws<IOException>(() =>
|
|
MidiFileWriter.CompleteStage(stream, _ => { }, CancellationToken.None)));
|
|
Assert.False(stream.CanWrite);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("")]
|
|
[InlineData("relative.mid")]
|
|
[InlineData(@"C:drive-relative.mid")]
|
|
public void DestinationRequiresExplicitAbsoluteFilePath(string path)
|
|
{
|
|
var (composition, plan) = MidiTestData.Arrangement();
|
|
Assert.ThrowsAny<ArgumentException>(() => MidiFileWriter.WriteFile(path, composition, plan));
|
|
Assert.Empty(Directory.GetFiles(directory));
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("CON.mid")]
|
|
[InlineData("aux.mid")]
|
|
[InlineData("COM1.mid")]
|
|
[InlineData("LPT9.mid")]
|
|
[InlineData("song.mid:stream")]
|
|
[InlineData("song.mid.")]
|
|
[InlineData("song.mid ")]
|
|
[InlineData("bad?.mid")]
|
|
public void InvalidReservedAndAlternateStreamNamesFailBeforeStaging(string name)
|
|
{
|
|
var (composition, plan) = MidiTestData.Arrangement();
|
|
Assert.Throws<ArgumentException>(() => MidiFileWriter.WriteFile(Path.Combine(directory, name), composition, plan));
|
|
Assert.Empty(Directory.GetFiles(directory));
|
|
}
|
|
|
|
[Fact]
|
|
public void MissingParentDirectoryDestinationPreflightAndCancellationDoNotCreateOutputs()
|
|
{
|
|
var (composition, plan) = MidiTestData.Arrangement();
|
|
Assert.Throws<DirectoryNotFoundException>(() => MidiFileWriter.WriteFile(Path.Combine(directory, "absent", "song.mid"), composition, plan));
|
|
Assert.Throws<IOException>(() => MidiFileWriter.WriteFile(directory, composition, plan));
|
|
Assert.Throws<ArgumentException>(() => MidiFileWriter.WriteFile(directory + Path.DirectorySeparatorChar, composition, plan));
|
|
var path = Path.Combine(directory, "song.mid");
|
|
Assert.Throws<ArgumentNullException>(() => MidiFileWriter.WriteFile(path, null!, plan));
|
|
Assert.Throws<OperationCanceledException>(() => MidiFileWriter.WriteFile(path, composition, plan, new CancellationToken(true)));
|
|
Assert.Empty(Directory.GetFileSystemEntries(directory));
|
|
}
|
|
|
|
public void Dispose() => Directory.Delete(directory, recursive: true);
|
|
|
|
private sealed class CloseFailingStream(Exception error) : MemoryStream
|
|
{
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
base.Dispose(disposing);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
private sealed class ObservedStream(int failAfter = int.MaxValue, Action? afterWrite = null) : Stream
|
|
{
|
|
private readonly MemoryStream inner = new();
|
|
public byte[] Bytes => inner.ToArray();
|
|
public bool Closed { get; private set; }
|
|
public override bool CanRead => false;
|
|
public override bool CanSeek => false;
|
|
public override bool CanWrite => !Closed;
|
|
public override long Length => throw new NotSupportedException();
|
|
public override long Position { get => throw new NotSupportedException(); set => throw new NotSupportedException(); }
|
|
public override void Write(byte[] buffer, int offset, int count)
|
|
{
|
|
if (inner.Length + count > failAfter)
|
|
{
|
|
inner.Write(buffer, offset, checked((int)(failAfter - inner.Length)));
|
|
throw new IOException("synthetic stream failure");
|
|
}
|
|
inner.Write(buffer, offset, count);
|
|
afterWrite?.Invoke();
|
|
}
|
|
public override void Flush() { }
|
|
public override int Read(byte[] buffer, int offset, int count) => throw new NotSupportedException();
|
|
public override long Seek(long offset, SeekOrigin origin) => throw new NotSupportedException();
|
|
public override void SetLength(long value) => throw new NotSupportedException();
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
Closed = true;
|
|
if (disposing) inner.Dispose();
|
|
base.Dispose(disposing);
|
|
}
|
|
}
|
|
}
|