Cubase-MCP-GAJ3T.MusicGen.R.../tests/GAJ3T.MusicGen.RiffGrooveBu.../Composition/CompositionPipelineTests.cs

119 lines
6.2 KiB
C#

using System.Text.Json;
using GAJ3T.MusicGen.RiffGrooveBuilder.Core.Composition;
namespace GAJ3T.MusicGen.RiffGrooveBuilder.IntegrationTests.Composition;
public sealed class CompositionPipelineTests
{
[Fact]
public void DocumentedDescriptionTraversesRealParserPlannerValidator()
{
const string text = "Generate 4 bars at 120 BPM in E minor, 4/4: palm-muted eighth-note lead guitar, sustained root-note bass, kick on beats 1 and 3, snare on beats 2 and 4, and closed hi-hat eighth notes.";
var parsed = DescriptionParser.Parse(text);
Assert.True(parsed.Success);
var result = CompositionPlanner.Plan(parsed.Description!);
Assert.True(result.Success);
Assert.Empty(result.Diagnostics);
var model = result.Composition!;
Assert.Empty(CompositionValidator.Validate(model));
Assert.Equal(120, model.TempoBpm);
Assert.Equal(4, model.Bars);
Assert.Equal(new TimeSignature(4, 4), model.Meter);
Assert.Equal(new MusicalKey(4, KeyMode.Minor), model.Key);
Assert.Equal(15_360, model.MusicalExtent.ToTicks());
Assert.Equal(3, model.Tracks.Count);
var lead = Assert.Single(model.Tracks, track => track.Role == TrackRole.Lead);
var bass = Assert.Single(model.Tracks, track => track.Role == TrackRole.Bass);
var drums = Assert.Single(model.Tracks, track => track.Role == TrackRole.Drums);
Assert.Empty(lead.Hits);
Assert.Empty(bass.Hits);
Assert.Empty(drums.Notes);
Assert.Equal(32, lead.Notes.Count);
Assert.Equal(4, bass.Notes.Count);
Assert.Equal(48, drums.Hits.Count);
Assert.Equal(6, model.DefaultsApplied.Count);
for (var bar = 0; bar < 4; bar++)
{
for (var i = 0; i < 8; i++)
{
var note = lead.Notes[bar * 8 + i];
Assert.Equal(64, note.Pitch);
Assert.Equal(96, note.Velocity);
Assert.Equal(Articulation.PalmMute, note.Articulation);
Assert.Equal(bar * 3840 + i * 480, note.Start.ToTicks());
Assert.Equal(480, note.Duration.ToTicks());
}
Assert.Equal(40, bass.Notes[bar].Pitch);
Assert.Equal(Articulation.Sustain, bass.Notes[bar].Articulation);
Assert.Equal(bar * 3840, bass.Notes[bar].Start.ToTicks());
Assert.Equal(3840, bass.Notes[bar].Duration.ToTicks());
var barHits = drums.Hits.Where(hit => hit.Start >= new BeatFraction(bar * 4) &&
hit.Start < new BeatFraction((bar + 1) * 4)).ToArray();
Assert.Equal(new long[] { bar * 3840, bar * 3840 + 1920 },
barHits.Where(hit => hit.Voice == DrumVoice.Kick).Select(hit => hit.Start.ToTicks()));
Assert.Equal(new long[] { bar * 3840 + 960, bar * 3840 + 2880 },
barHits.Where(hit => hit.Voice == DrumVoice.Snare).Select(hit => hit.Start.ToTicks()));
Assert.Equal(Enumerable.Range(0, 8).Select(i => (long)bar * 3840 + i * 480),
barHits.Where(hit => hit.Voice == DrumVoice.ClosedHiHat).Select(hit => hit.Start.ToTicks()));
Assert.All(barHits, hit => Assert.Equal(hit.Voice == DrumVoice.ClosedHiHat ? 480 : 960, hit.Duration.ToTicks()));
}
Assert.Equal(JsonSerializer.Serialize(model), JsonSerializer.Serialize(CompositionPlanner.Plan(text).Composition));
}
[Theory]
[InlineData("bass", TrackRole.Bass, 4)]
[InlineData("palm mute sixteenth notes lead", TrackRole.Lead, 64)]
[InlineData("drums, kick on beats 1 and 3", TrackRole.Drums, 8)]
public void ExplicitRolesAndDrumSubsetsStayExplicit(string text, TrackRole role, int count)
{
var parsed = DescriptionParser.Parse(text);
Assert.True(parsed.Success);
var result = CompositionPlanner.Plan(parsed.Description!);
Assert.True(result.Success);
var track = Assert.Single(result.Composition!.Tracks);
Assert.Equal(role, track.Role);
Assert.Equal(count, track.Notes.Count + track.Hits.Count);
Assert.Empty(CompositionValidator.Validate(result.Composition));
if (role == TrackRole.Drums)
Assert.All(track.Hits, hit => Assert.Equal(DrumVoice.Kick, hit.Voice));
}
[Fact]
public void DocumentedThreeEightDescriptionRetainsDenominatorBeatTiming()
{
var parsed = DescriptionParser.Parse("3/8, 2 bars: kick on beats 1 and 3, snare on beat 2, closed hi-hat eighth notes");
Assert.True(parsed.Success);
var result = CompositionPlanner.Plan(parsed.Description!);
Assert.True(result.Success);
var model = result.Composition!;
Assert.Empty(CompositionValidator.Validate(model));
Assert.Equal(2880, model.MusicalExtent.ToTicks());
var hits = Assert.Single(model.Tracks).Hits;
Assert.Equal(12, hits.Count);
Assert.All(hits, hit => Assert.Equal(480, hit.Duration.ToTicks()));
Assert.Equal(new long[] { 0, 960, 1440, 2400 },
hits.Where(hit => hit.Voice == DrumVoice.Kick).Select(hit => hit.Start.ToTicks()));
Assert.Equal(new long[] { 480, 1920 },
hits.Where(hit => hit.Voice == DrumVoice.Snare).Select(hit => hit.Start.ToTicks()));
Assert.DoesNotContain(model.DefaultsApplied, item => item.Field.StartsWith("drums.", StringComparison.Ordinal) && item.Field != "drums.velocity");
}
[Theory]
[InlineData("lead legato", "unsupported_text")]
[InlineData("3/8 drums", "explicit_drums_required")]
[InlineData("3/8 kick on beat 4", "invalid_beat")]
[InlineData("3/8 quarter notes lead", "unrepresentable_pattern")]
[InlineData("100001 bars kick on beat 1", "event_limit_exceeded")]
public void RealPipelineFailuresAreActionableAndHaveNoPartialComposition(string text, string code)
{
var result = CompositionPlanner.Plan(text);
Assert.False(result.Success);
Assert.Null(result.Composition);
var diagnostic = Assert.Single(result.Diagnostics);
Assert.Equal(code, diagnostic.Code);
Assert.False(string.IsNullOrWhiteSpace(diagnostic.Field));
Assert.False(string.IsNullOrWhiteSpace(diagnostic.Message));
if (code == "unsupported_text") Assert.Contains("legato", diagnostic.Phrase);
}
}