Cubase-MCP-GAJ3T.MusicGen.R.../tests/GAJ3T.MusicGen.RiffGrooveBu.../Midi/MidiFileWriterTests.cs

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);
}
}
}