119 lines
6.2 KiB
C#
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);
|
|
}
|
|
}
|