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

279 lines
14 KiB
C#

using System.Text.Json;
using GAJ3T.MusicGen.RiffGrooveBuilder.Core.Articulations;
using GAJ3T.MusicGen.RiffGrooveBuilder.Core.Composition;
using GAJ3T.MusicGen.RiffGrooveBuilder.Generation.Midi;
using GAJ3T.MusicGen.RiffGrooveBuilder.UnitTests.Articulations;
using Melanchall.DryWetMidi.Core;
using MusicalComposition = GAJ3T.MusicGen.RiffGrooveBuilder.Core.Composition.Composition;
namespace GAJ3T.MusicGen.RiffGrooveBuilder.UnitTests.Midi;
public sealed class MidiFileBuilderTests
{
[Fact]
public void TypeOneResolutionNamedTracksMetadataAndTrailingRestRoundTrip()
{
var (composition, plan) = MidiTestData.Arrangement();
var file = MidiTestData.RoundTrip(MidiFileBuilder.Build(composition, plan));
Assert.Equal(MidiFileFormat.MultiTrack, file.OriginalFormat);
Assert.Equal(960, Assert.IsType<TicksPerQuarterNoteTimeDivision>(file.TimeDivision).TicksPerQuarterNote);
var tracks = file.Chunks.Cast<TrackChunk>().ToArray();
Assert.Equal(new[] { "Conductor", "Lead" }, tracks.Select(t => Assert.Single(t.Events.OfType<SequenceTrackNameEvent>()).Text));
Assert.Equal(500_000, Assert.Single(tracks[0].Events.OfType<SetTempoEvent>()).MicrosecondsPerQuarterNote);
var meter = Assert.Single(tracks[0].Events.OfType<TimeSignatureEvent>());
Assert.Equal(4, meter.Numerator);
Assert.Equal(4, meter.Denominator);
Assert.All(MidiTestData.Absolute(tracks[0]).Where(e => e.Event is not EndOfTrackEvent), e => Assert.Equal(0, e.Tick));
Assert.All(tracks, t =>
{
Assert.Single(t.Events.OfType<EndOfTrackEvent>());
Assert.IsType<EndOfTrackEvent>(t.Events.Last());
Assert.Equal(15_360, MidiTestData.Absolute(t).Last().Tick);
});
Assert.Equal(960, MidiTestData.Absolute(tracks[1]).Single(e => e.Event is NoteOffEvent).Tick);
Assert.Equal(0, (int)Assert.Single(tracks[1].Events.OfType<NoteOffEvent>()).Velocity);
}
[Theory]
[InlineData(120, 500000)]
[InlineData(123, 487805)]
[InlineData(128, 468750)]
[InlineData(256, 234375)]
[InlineData(512, 117188)]
[InlineData(60000000, 1)]
public void TempoUsesNearestIntegerMidpointAwayFromZero(double bpm, long expected)
{
var (original, plan) = MidiTestData.Arrangement();
var composition = new MusicalComposition(bpm, original.Meter, original.Key, original.Bars, original.Tracks);
var file = MidiTestData.RoundTrip(MidiFileBuilder.Build(composition, plan));
Assert.Equal(expected, Assert.Single(file.Chunks.OfType<TrackChunk>().First().Events.OfType<SetTempoEvent>()).MicrosecondsPerQuarterNote);
}
[Fact]
public void LowerTempoBoundaryIsRepresentableWithoutClamping()
{
var (original, plan) = MidiTestData.Arrangement();
var composition = new MusicalComposition(60_000_000d / 0xFFFFFF, original.Meter, original.Key, original.Bars, original.Tracks);
Assert.Empty(CompositionValidator.Validate(composition));
var file = MidiTestData.RoundTrip(MidiFileBuilder.Build(composition, plan));
Assert.Equal(0xFFFFFF, Assert.Single(file.Chunks.OfType<TrackChunk>().First().Events.OfType<SetTempoEvent>()).MicrosecondsPerQuarterNote);
}
[Theory]
[InlineData(0)]
[InlineData(-120)]
[InlineData(double.NaN)]
[InlineData(double.PositiveInfinity)]
[InlineData(double.NegativeInfinity)]
[InlineData(60000001)]
[InlineData(3)]
public void InvalidTempoFailsBeforeSerialization(double bpm)
{
var (original, plan) = MidiTestData.Arrangement();
var composition = new MusicalComposition(bpm, original.Meter, original.Key, original.Bars, original.Tracks);
Assert.Contains("tempoBpm", Assert.Throws<ArgumentException>(() => MidiFileBuilder.Build(composition, plan)).Message);
}
[Theory]
[InlineData(0.75)]
[InlineData(16777215.25)]
public void RoundingDoesNotAdmitTemposOutsideExistingUnroundedCoreRange(double quotient)
{
var (original, plan) = MidiTestData.Arrangement();
var composition = new MusicalComposition(60_000_000d / quotient,
original.Meter, original.Key, original.Bars, original.Tracks);
Assert.Contains("tempoBpm", Assert.Throws<ArgumentException>(() => MidiFileBuilder.Build(composition, plan)).Message);
}
[Theory]
[InlineData(3, 8)]
[InlineData(7, 16)]
[InlineData(255, 1)]
[InlineData(4, 128)]
public void LibraryTakesActualDenominatorNotExponent(int numerator, int denominator)
{
var composition = new MusicalComposition(120, new(numerator, denominator), new(4, KeyMode.Minor), 1,
[new(TrackRole.Lead, [new(64, BeatFraction.Zero, new(4, denominator), 96, Articulation.Sustain)])]);
var plan = MidiTestData.Plan(composition);
var file = MidiTestData.RoundTrip(MidiFileBuilder.Build(composition, plan));
var meter = Assert.Single(file.Chunks.OfType<TrackChunk>().First().Events.OfType<TimeSignatureEvent>());
Assert.Equal(numerator, (int)meter.Numerator);
Assert.Equal(denominator, (int)meter.Denominator);
Assert.All(file.Chunks.Cast<TrackChunk>(), t => Assert.Equal(composition.MusicalExtent.ToTicks(), MidiTestData.Absolute(t).Last().Tick));
}
[Fact]
public void CoreDenominator256FailsClearlyWithoutByteWrapOrCoreChange()
{
var composition = new MusicalComposition(120, new(4, 256), new(4, KeyMode.Minor), 1,
[new(TrackRole.Lead, [new(64, BeatFraction.Zero, new(1, 64), 96, Articulation.Sustain)])]);
Assert.Empty(CompositionValidator.Validate(composition));
var plan = MidiTestData.Plan(composition);
var error = Assert.Throws<NotSupportedException>(() => MidiFileBuilder.Build(composition, plan));
Assert.Contains("/256", error.Message);
Assert.Contains("1..128", error.Message);
}
[Theory]
[InlineData(0x0FFFFFFF, true)]
[InlineData(0x10000000, false)]
public void GlobalConductorEndGapEnforcesFourByteVlq(long endTick, bool accepted)
{
var composition = SyntheticProfiles.Model(SyntheticProfiles.Note(articulation: Articulation.PalmMute));
var profile = SyntheticProfiles.Switched(advance: endTick - 15_360).Build();
var plan = MidiTestData.Plan(composition, profile);
Assert.Equal(endTick, plan.EndTick);
if (!accepted)
{
Assert.Contains("four-byte VLQ", Assert.Throws<ArgumentOutOfRangeException>(() => MidiFileBuilder.Build(composition, plan)).Message);
return;
}
var file = MidiTestData.RoundTrip(MidiFileBuilder.Build(composition, plan));
Assert.All(file.Chunks.Cast<TrackChunk>(), t => Assert.Equal(endTick, MidiTestData.Absolute(t).Last().Tick));
Assert.Equal(endTick, file.Chunks.Cast<TrackChunk>().First().Events.Last().DeltaTime);
}
[Fact]
public void DeltaConversionIsCheckedAndRejectsBackwardTime()
{
Assert.Equal(0, MidiFileBuilder.DeltaTicks(long.MaxValue, long.MaxValue));
Assert.Equal(0x0FFFFFFF, MidiFileBuilder.DeltaTicks(long.MaxValue, long.MaxValue - 0x0FFFFFFF));
Assert.Throws<ArgumentOutOfRangeException>(() => MidiFileBuilder.DeltaTicks(0, 1));
Assert.Throws<ArgumentOutOfRangeException>(() => MidiFileBuilder.DeltaTicks(0x10000000, 0));
Assert.Throws<OverflowException>(() => MidiFileBuilder.DeltaTicks(long.MaxValue, -1));
}
[Fact]
public void NullInvalidAndMismatchedCompositionFailWithoutDefaults()
{
var (composition, plan) = MidiTestData.Arrangement();
Assert.Throws<ArgumentNullException>(() => MidiFileBuilder.Build(null!, plan));
Assert.Throws<ArgumentNullException>(() => MidiFileBuilder.Build(composition, null!));
Assert.Throws<ArgumentException>(() => MidiFileBuilder.Build(new(120, new(4, 4), composition.Key, 4, []), plan));
Assert.Contains("extent", Assert.Throws<ArgumentException>(() => MidiFileBuilder.Build(
new(120, composition.Meter, composition.Key, 5, composition.Tracks), plan)).Message);
Assert.Contains("roles", Assert.Throws<ArgumentException>(() => MidiFileBuilder.Build(
new(120, composition.Meter, composition.Key, 4, [new(TrackRole.Bass, composition.Tracks[0].Notes)]), plan)).Message);
Assert.Contains("disagree", Assert.Throws<ArgumentException>(() => MidiFileBuilder.Build(
SyntheticProfiles.Model(SyntheticProfiles.Note(pitch: 65)), plan)).Message);
Assert.Contains("disagree", Assert.Throws<ArgumentException>(() => MidiFileBuilder.Build(
SyntheticProfiles.Model(SyntheticProfiles.Note(start: 1)), plan)).Message);
Assert.Throws<OperationCanceledException>(() => MidiFileBuilder.Build(composition, plan, new CancellationToken(true)));
}
[Fact]
public void SameTickMomentaryReleaseResetNewStateAndNotesKeepStableOrder()
{
var composition = SyntheticProfiles.Model(
SyntheticProfiles.Note(0, 1, articulation: Articulation.PalmMute),
SyntheticProfiles.Note(1, 1, articulation: Articulation.PalmMute));
var profile = SyntheticProfiles.Switched(StateBehavior.Momentary, advance: 0, duration: 30, cc: true).Build();
var plan = MidiTestData.Plan(composition, profile);
var track = MidiTestData.RoundTrip(MidiFileBuilder.Build(composition, plan)).Chunks.Cast<TrackChunk>().Last();
var boundary = MidiTestData.Absolute(track).Where(e => e.Tick == 960).Select(e => e.Event).ToArray();
Assert.Collection(boundary,
e => Assert.Equal(11, (int)Assert.IsType<NoteOffEvent>(e).NoteNumber),
e => Assert.Equal(64, (int)Assert.IsType<NoteOffEvent>(e).NoteNumber),
e => Assert.Equal(0, (int)Assert.IsType<ControlChangeEvent>(e).ControlValue),
e => Assert.Equal(100, (int)Assert.IsType<ControlChangeEvent>(e).ControlValue),
e => Assert.Equal(11, (int)Assert.IsType<NoteOnEvent>(e).NoteNumber),
e => Assert.Equal(64, (int)Assert.IsType<NoteOnEvent>(e).NoteNumber));
}
[Fact]
public void ExactRationalTripletsRetainTheirPlannedTicksAfterReadBack()
{
var composition = SyntheticProfiles.Model(Enumerable.Range(0, 12)
.Select(i => new MusicalNote(64, new(i, 3), new(1, 3), 96, Articulation.Sustain)).ToArray());
var plan = MidiTestData.Plan(composition);
var track = MidiTestData.RoundTrip(MidiFileBuilder.Build(composition, plan)).Chunks.Cast<TrackChunk>().Last();
var events = MidiTestData.Absolute(track);
Assert.Equal(Enumerable.Range(0, 12).Select(i => i * 320L),
events.Where(e => e.Event is NoteOnEvent).Select(e => e.Tick));
Assert.Equal(Enumerable.Range(1, 12).Select(i => i * 320L),
events.Where(e => e.Event is NoteOffEvent).Select(e => e.Tick));
}
[Fact]
public void FinalResetPulseTailExtendsEveryTrackWithoutSourceMutation()
{
var composition = SyntheticProfiles.Model(SyntheticProfiles.Note(0, 16, articulation: Articulation.PalmMute));
var data = SyntheticProfiles.Switched(advance: 120, duration: 30, cc: true) with
{
Reset = Articulation.Sustain,
FinalControllers = [new(20, 0)]
};
var plan = MidiTestData.Plan(composition, data.Build());
Assert.Equal(15_480, plan.MusicalEndTick);
Assert.Equal(15_510, plan.EndTick);
var before = JsonSerializer.Serialize(new { composition, plan });
var first = MidiFileBuilder.Build(composition, plan);
var second = MidiFileBuilder.Build(composition, plan);
Assert.Equal(before, JsonSerializer.Serialize(new { composition, plan }));
Assert.Equal(MidiTestData.Bytes(first), MidiTestData.Bytes(second));
var file = MidiTestData.RoundTrip(first);
Assert.All(file.Chunks.Cast<TrackChunk>(), t => Assert.Equal(15_510, MidiTestData.Absolute(t).Last().Tick));
var tail = MidiTestData.Absolute(file.Chunks.Cast<TrackChunk>().Last()).Where(e => e.Tick >= 15_480).ToArray();
Assert.Collection(tail,
e => Assert.IsType<NoteOffEvent>(e.Event),
e => Assert.Equal(0, (int)Assert.IsType<ControlChangeEvent>(e.Event).ControlValue),
e => Assert.Equal(10, (int)Assert.IsType<NoteOnEvent>(e.Event).NoteNumber),
e => Assert.Equal(10, (int)Assert.IsType<NoteOffEvent>(e.Event).NoteNumber),
e => Assert.IsType<EndOfTrackEvent>(e.Event));
}
[Fact]
public void PinnedLibraryDoesNotEnforceSmfVlqLimitItself()
{
Assert.Equal(new Version(8, 0, 3, 0), typeof(MidiFile).Assembly.GetName().Version);
Assert.Empty(typeof(EndOfTrackEvent).GetConstructors());
Assert.Equal(typeof(byte), typeof(TimeSignatureEvent).GetProperty(nameof(TimeSignatureEvent.Denominator))!.PropertyType);
var file = new MidiFile(new TrackChunk(new ControlChangeEvent { DeltaTime = 0x10000000 }));
using var stream = new MemoryStream();
file.Write(stream, MidiFileFormat.MultiTrack);
Assert.True(stream.Length > 0);
Assert.Throws<ArgumentOutOfRangeException>(() => MidiFileBuilder.DeltaTicks(0x10000000, 0));
}
}
internal static class MidiTestData
{
internal static (MusicalComposition Composition, MidiEventPlan Plan) Arrangement()
{
var composition = SyntheticProfiles.Model(SyntheticProfiles.Note());
return (composition, Plan(composition));
}
internal static MidiEventPlan Plan(MusicalComposition composition, InstrumentProfile? profile = null)
{
var result = ArticulationPlanner.Plan(composition, [profile ?? new SyntheticProfiles.Data().Build()], allowSynthetic: true);
Assert.True(result.Success, string.Join("; ", result.Diagnostics));
return result.Plan!;
}
internal static byte[] Bytes(MidiFile file)
{
using var stream = new MemoryStream();
file.Write(stream, MidiFileFormat.MultiTrack);
return stream.ToArray();
}
internal static MidiFile RoundTrip(MidiFile file)
{
using var stream = new MemoryStream(Bytes(file));
return Read(stream);
}
internal static MidiFile Read(Stream stream) => MidiFile.Read(stream, new ReadingSettings
{
EndOfTrackStoringPolicy = EndOfTrackStoringPolicy.Store,
MissedEndOfTrackPolicy = MissedEndOfTrackPolicy.Abort
});
internal static (long Tick, MidiEvent Event)[] Absolute(TrackChunk track)
{
long tick = 0;
return track.Events.Select(e => (Tick: tick = checked(tick + e.DeltaTime), Event: e)).ToArray();
}
}