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(() => ((IList)first.Tracks).Clear()); Assert.Throws(() => ((IList)first.Tracks[0].Notes).Clear()); Assert.Throws(() => ((IList)first.Tracks[2].Hits).Clear()); Assert.Throws(() => ((IList)first.DefaultsApplied).Clear()); var notes = new List { 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 { track }; var defaults = new List { 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(() => ((IList)parsed.DrumPatterns[0].Beats).Clear()); Assert.Throws(() => ((IList)parsed.PitchedPatterns).Clear()); } private static void AssertDrum(IReadOnlyList 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); } } }