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(() => MidiFileWriter.Write(null!, composition, plan)); using var readOnly = new MemoryStream([], writable: false); Assert.Throws(() => MidiFileWriter.Write(readOnly, composition, plan)); var disposed = new MemoryStream(); disposed.Dispose(); Assert.Throws(() => MidiFileWriter.Write(disposed, composition, plan)); using var failing = new ObservedStream(failAfter: 20); var error = Assert.Throws(() => 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(() => MidiFileWriter.Write(stream, null!, plan)); Assert.Empty(stream.ToArray()); Assert.Throws(() => 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(() => 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(() => 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(() => MidiFileWriter.Publish(path, stream => { stage = Assert.IsType(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(() => 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(() => MidiFileWriter.WriteFile(path, composition, plan)); using var stream = new MemoryStream(); Assert.Throws(() => 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(stream).Name; stream.WriteByte(42); if (cancel) cancellation.Cancel(); else throw original; }, cancellation.Token)); if (cancel) Assert.IsType(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(() => MidiFileWriter.Cleanup(stage, original)); Assert.Contains(stage, error.Message); Assert.Same(original, error.InnerExceptions[0]); Assert.IsType(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(() => MidiFileWriter.CompleteStage(stream, _ => { if (cancel) cancellation.Cancel(); else throw original; }, cancellation.Token)); if (cancel) Assert.IsType(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(() => 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(() => 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(() => MidiFileWriter.WriteFile(Path.Combine(directory, name), composition, plan)); Assert.Empty(Directory.GetFiles(directory)); } [Fact] public void MissingParentDirectoryDestinationPreflightAndCancellationDoNotCreateOutputs() { var (composition, plan) = MidiTestData.Arrangement(); Assert.Throws(() => MidiFileWriter.WriteFile(Path.Combine(directory, "absent", "song.mid"), composition, plan)); Assert.Throws(() => MidiFileWriter.WriteFile(directory, composition, plan)); Assert.Throws(() => MidiFileWriter.WriteFile(directory + Path.DirectorySeparatorChar, composition, plan)); var path = Path.Combine(directory, "song.mid"); Assert.Throws(() => MidiFileWriter.WriteFile(path, null!, plan)); Assert.Throws(() => 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); } } }