243 lines
12 KiB
C#
243 lines
12 KiB
C#
using System.Text.Json;
|
|
using GAJ3T.MusicGen.RiffGrooveBuilder.Core.Composition;
|
|
using Model = GAJ3T.MusicGen.RiffGrooveBuilder.Core.Composition.Composition;
|
|
|
|
namespace GAJ3T.MusicGen.RiffGrooveBuilder.UnitTests.Composition;
|
|
|
|
public sealed class CompositionPlannerTests
|
|
{
|
|
[Fact]
|
|
public void AcceptanceExampleHasExactCountsPitchArticulationAndCompleteTiming()
|
|
{
|
|
var result = CompositionPlanner.Plan(DescriptionParserTests.Example);
|
|
Assert.True(result.Success, string.Join("; ", result.Diagnostics));
|
|
Assert.Empty(result.Diagnostics);
|
|
var composition = result.Composition!;
|
|
Assert.Equal(new BeatFraction(16), composition.MusicalExtent);
|
|
Assert.Equal(15_360, composition.MusicalExtent.ToTicks());
|
|
Assert.Equal(new[] { TrackRole.Lead, TrackRole.Bass, TrackRole.Drums }, composition.Tracks.Select(track => track.Role));
|
|
var lead = composition.Tracks[0];
|
|
Assert.Equal(32, lead.Notes.Count);
|
|
for (var i = 0; i < lead.Notes.Count; i++)
|
|
{
|
|
Assert.Equal(new MusicalNote(64, new(i, 2), new(1, 2), 96, Articulation.PalmMute), lead.Notes[i]);
|
|
Assert.Equal(i * 480, lead.Notes[i].Start.ToTicks());
|
|
Assert.Equal(480, lead.Notes[i].Duration.ToTicks());
|
|
}
|
|
var bass = composition.Tracks[1];
|
|
Assert.Equal(4, bass.Notes.Count);
|
|
for (var i = 0; i < 4; i++)
|
|
{
|
|
Assert.Equal(new MusicalNote(40, new(i * 4), new(4), 96, Articulation.Sustain), bass.Notes[i]);
|
|
Assert.Equal(i * 3840, bass.Notes[i].Start.ToTicks());
|
|
Assert.Equal(3840, bass.Notes[i].Duration.ToTicks());
|
|
}
|
|
var hits = composition.Tracks[2].Hits;
|
|
Assert.Equal(48, hits.Count);
|
|
AssertDrum(hits, DrumVoice.Kick, 8, [0, 1920], 960);
|
|
AssertDrum(hits, DrumVoice.Snare, 8, [960, 2880], 960);
|
|
AssertDrum(hits, DrumVoice.ClosedHiHat, 32, [0, 480, 960, 1440, 1920, 2400, 2880, 3360], 480);
|
|
Assert.All(composition.Tracks, track => Assert.All(track.Notes, note => Assert.True(note.Start + note.Duration <= composition.MusicalExtent)));
|
|
Assert.All(hits, hit => Assert.True(hit.Start + hit.Duration <= composition.MusicalExtent));
|
|
Assert.Empty(CompositionValidator.Validate(composition));
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("quarter notes", 4, 960)]
|
|
[InlineData("eighth notes", 8, 480)]
|
|
[InlineData("sixteenth notes", 16, 240)]
|
|
[InlineData("sustained root notes", 1, 3840)]
|
|
public void RepeatedPitchedPatternsNeverDrift(string pattern, int perBar, int duration)
|
|
{
|
|
var composition = CompositionPlanner.Plan($"257 bars: {pattern} bass").Composition!;
|
|
var notes = Assert.Single(composition.Tracks).Notes;
|
|
Assert.Equal(257 * perBar, notes.Count);
|
|
for (var i = 0; i < notes.Count; i++)
|
|
{
|
|
Assert.Equal((long)i * duration, notes[i].Start.ToTicks());
|
|
Assert.Equal(duration, notes[i].Duration.ToTicks());
|
|
}
|
|
Assert.Equal(257L * 3840, (notes[^1].Start + notes[^1].Duration).ToTicks());
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("quarter notes", 4, 960)]
|
|
[InlineData("eighth notes", 8, 480)]
|
|
[InlineData("sixteenth notes", 16, 240)]
|
|
public void HiHatSubdivisionsNeverDrift(string pattern, int perBar, int duration)
|
|
{
|
|
var composition = CompositionPlanner.Plan($"101 bars: closed hi-hat {pattern}").Composition!;
|
|
var hits = Assert.Single(composition.Tracks).Hits;
|
|
Assert.Equal(101 * perBar, hits.Count);
|
|
for (var i = 0; i < hits.Count; i++)
|
|
{
|
|
Assert.Equal((long)i * duration, hits[i].Start.ToTicks());
|
|
Assert.Equal(duration, hits[i].Duration.ToTicks());
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void NonFourFourUsesDenominatorBeatsNotQuarterBeats()
|
|
{
|
|
var composition = CompositionPlanner.Plan("3/8, 2 bars: kick on beats 1 and 3, snare on beat 2, closed hi-hat eighth notes").Composition!;
|
|
Assert.Equal(new BeatFraction(3, 2), composition.Meter.BarLength);
|
|
Assert.Equal(2880, composition.MusicalExtent.ToTicks());
|
|
var hits = Assert.Single(composition.Tracks).Hits;
|
|
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.All(hits, hit => Assert.Equal(480, hit.Duration.ToTicks()));
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("3/4, lead", 24, 11520)]
|
|
[InlineData("6/8, lead", 24, 11520)]
|
|
[InlineData("5/16, bass", 4, 4800)]
|
|
public void PitchedOnlyMetersDoNotRequireDrumDefaults(string text, int count, long extent)
|
|
{
|
|
var result = CompositionPlanner.Plan(text);
|
|
Assert.True(result.Success);
|
|
Assert.Equal(count, Assert.Single(result.Composition!.Tracks).Notes.Count);
|
|
Assert.Equal(extent, result.Composition.MusicalExtent.ToTicks());
|
|
}
|
|
|
|
[Fact]
|
|
public void ExplicitGlobalsAndIndependentRoleModifiersArePreserved()
|
|
{
|
|
var composition = CompositionPlanner.Plan("7 bars, 90 bpm, 3/4, in Db major: lead sustain quarter notes, bass palm mute sustained").Composition!;
|
|
Assert.Equal(90, composition.TempoBpm);
|
|
Assert.Equal(7, composition.Bars);
|
|
Assert.Equal(new TimeSignature(3, 4), composition.Meter);
|
|
Assert.Equal(new MusicalKey(1, KeyMode.Major), composition.Key);
|
|
Assert.All(composition.Tracks[0].Notes, note =>
|
|
{
|
|
Assert.Equal(61, note.Pitch);
|
|
Assert.Equal(Articulation.Sustain, note.Articulation);
|
|
});
|
|
Assert.All(composition.Tracks[1].Notes, note =>
|
|
{
|
|
Assert.Equal(37, note.Pitch);
|
|
Assert.Equal(new BeatFraction(3), note.Duration);
|
|
Assert.Equal(Articulation.PalmMute, note.Articulation);
|
|
});
|
|
Assert.Equal(4, composition.DefaultsApplied.Count);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("B# major", 60, 36)]
|
|
[InlineData("Cb minor", 71, 47)]
|
|
[InlineData("F♯ minor", 66, 42)]
|
|
public void RootOctavesFollowNormalizedPitchClass(string key, int lead, int bass)
|
|
{
|
|
var composition = CompositionPlanner.Plan($"{key}: lead and bass").Composition!;
|
|
Assert.All(composition.Tracks[0].Notes, note => Assert.Equal(lead, note.Pitch));
|
|
Assert.All(composition.Tracks[1].Notes, note => Assert.Equal(bass, note.Pitch));
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("bass", TrackRole.Bass, 4)]
|
|
[InlineData("lead guitar", TrackRole.Lead, 32)]
|
|
[InlineData("kick on beat 1", TrackRole.Drums, 4)]
|
|
[InlineData("drums kick on beat 1", TrackRole.Drums, 4)]
|
|
public void SelectedRolesAndExplicitDrumSubsetsDoNotExpand(string text, TrackRole role, int events)
|
|
{
|
|
var track = Assert.Single(CompositionPlanner.Plan(text).Composition!.Tracks);
|
|
Assert.Equal(role, track.Role);
|
|
Assert.Equal(events, track.Notes.Count + track.Hits.Count);
|
|
if (role == TrackRole.Drums) Assert.All(track.Hits, hit => Assert.Equal(DrumVoice.Kick, hit.Voice));
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("3/8 quarter notes lead", "unrepresentable_pattern")]
|
|
[InlineData("1/256 eighth notes lead", "unrepresentable_pattern")]
|
|
[InlineData("5/16 closed hi-hat eighth notes", "unrepresentable_pattern")]
|
|
[InlineData("3/8 drums", "explicit_drums_required")]
|
|
[InlineData("4 bars lead with vibrato", "unsupported_text")]
|
|
[InlineData("3/8 kick on beat 4", "invalid_beat")]
|
|
[InlineData("2147483647 bars lead", "event_limit_exceeded")]
|
|
[InlineData("255/1 2147483647 bars sixteenth notes bass", "event_limit_exceeded")]
|
|
public void PlanningFailuresExposeNoPartialComposition(string text, string code)
|
|
{
|
|
var result = CompositionPlanner.Plan(text);
|
|
Assert.False(result.Success);
|
|
Assert.Null(result.Composition);
|
|
Assert.Contains(result.Diagnostics, error => error.Code == code && error.Message.Length > 0);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("100000 bars sustained lead")]
|
|
[InlineData("100000 bars kick on beat 1")]
|
|
[InlineData("12500 bars eighth notes lead")]
|
|
[InlineData("10000 bars sustained lead, sustained bass, closed hi-hat eighth notes")]
|
|
public void ExactCombinedEventLimitIsAccepted(string text)
|
|
{
|
|
var result = CompositionPlanner.Plan(text);
|
|
Assert.True(result.Success, string.Join("; ", result.Diagnostics));
|
|
Assert.Equal(100_000, result.Composition!.Tracks.Sum(track => track.Notes.Count + track.Hits.Count));
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("100001 bars sustained lead")]
|
|
[InlineData("100001 bars kick on beat 1")]
|
|
[InlineData("9091 bars sustained lead, eighth notes bass, kick on beats 1 and 3")]
|
|
[InlineData("100000 bars sustained lead and bass")]
|
|
[InlineData("12501 bars eighth notes lead")]
|
|
public void LimitExceededIsSpecificAndNeverTruncated(string text)
|
|
{
|
|
var result = CompositionPlanner.Plan(text);
|
|
Assert.False(result.Success);
|
|
Assert.Null(result.Composition);
|
|
Assert.Equal("event_limit_exceeded", Assert.Single(result.Diagnostics).Code);
|
|
}
|
|
|
|
[Fact]
|
|
public void ResultsAreDeterministicAndCollectionSnapshotsAreIndependent()
|
|
{
|
|
var first = CompositionPlanner.Plan(DescriptionParserTests.Example).Composition!;
|
|
var second = CompositionPlanner.Plan(DescriptionParserTests.Example).Composition!;
|
|
Assert.Equal(JsonSerializer.Serialize(first), JsonSerializer.Serialize(second));
|
|
Assert.NotSame(first.Tracks, second.Tracks);
|
|
Assert.NotSame(first.DefaultsApplied, second.DefaultsApplied);
|
|
Assert.NotSame(first.Tracks[0].Notes, second.Tracks[0].Notes);
|
|
Assert.Throws<NotSupportedException>(() => ((IList<TrackPlan>)first.Tracks).Clear());
|
|
Assert.Throws<NotSupportedException>(() => ((IList<MusicalNote>)first.Tracks[0].Notes).Clear());
|
|
Assert.Throws<NotSupportedException>(() => ((IList<DrumHit>)first.Tracks[2].Hits).Clear());
|
|
Assert.Throws<NotSupportedException>(() => ((IList<AppliedDefault>)first.DefaultsApplied).Clear());
|
|
|
|
var notes = new List<MusicalNote> { new(64, new(0), new(1), 96, Articulation.Sustain) };
|
|
var track = new TrackPlan(TrackRole.Lead, notes);
|
|
notes.Clear();
|
|
Assert.Single(track.Notes);
|
|
var tracks = new List<TrackPlan> { track };
|
|
var defaults = new List<AppliedDefault> { new("bars", "4") };
|
|
var composition = new Model(120, new(4, 4), new(4, KeyMode.Minor), 4, tracks, defaults);
|
|
tracks.Clear();
|
|
defaults.Clear();
|
|
Assert.Single(composition.Tracks);
|
|
Assert.Single(composition.DefaultsApplied);
|
|
}
|
|
|
|
[Fact]
|
|
public void ParsedPlanCanBeReusedWithoutSharedMutableState()
|
|
{
|
|
var parsed = DescriptionParser.Parse(DescriptionParserTests.Example).Description!;
|
|
var first = CompositionPlanner.Plan(parsed).Composition!;
|
|
var second = CompositionPlanner.Plan(parsed).Composition!;
|
|
Assert.Equal(JsonSerializer.Serialize(first), JsonSerializer.Serialize(second));
|
|
Assert.NotSame(first.Tracks[2].Hits, second.Tracks[2].Hits);
|
|
Assert.Throws<NotSupportedException>(() => ((IList<int>)parsed.DrumPatterns[0].Beats).Clear());
|
|
Assert.Throws<NotSupportedException>(() => ((IList<PitchedPattern>)parsed.PitchedPatterns).Clear());
|
|
}
|
|
|
|
private static void AssertDrum(IReadOnlyList<DrumHit> hits, DrumVoice voice, int count, long[] startsInBar, long duration)
|
|
{
|
|
var selected = hits.Where(hit => hit.Voice == voice).ToArray();
|
|
Assert.Equal(count, selected.Length);
|
|
for (var i = 0; i < count; i++)
|
|
{
|
|
Assert.Equal((i / startsInBar.Length) * 3840 + startsInBar[i % startsInBar.Length], selected[i].Start.ToTicks());
|
|
Assert.Equal(duration, selected[i].Duration.ToTicks());
|
|
Assert.Equal(96, selected[i].Velocity);
|
|
}
|
|
}
|
|
}
|