216 lines
10 KiB
C#
216 lines
10 KiB
C#
using GAJ3T.MusicGen.RiffGrooveBuilder.Core.Composition;
|
|
|
|
namespace GAJ3T.MusicGen.RiffGrooveBuilder.UnitTests.Composition;
|
|
|
|
public sealed class DescriptionParserTests
|
|
{
|
|
internal const string Example = "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.";
|
|
|
|
[Fact]
|
|
public void AcceptanceExamplePreservesExplicitSettingsAndScopedIntentions()
|
|
{
|
|
var result = DescriptionParser.Parse(Example);
|
|
Assert.True(result.Success);
|
|
Assert.Empty(result.Diagnostics);
|
|
var description = Assert.IsType<ParsedDescription>(result.Description);
|
|
Assert.Equal(120, description.TempoBpm);
|
|
Assert.Equal(4, description.Bars);
|
|
Assert.Equal(new TimeSignature(4, 4), description.Meter);
|
|
Assert.Equal(new MusicalKey(4, KeyMode.Minor), description.Key);
|
|
Assert.Equal(new PitchedPattern(TrackRole.Lead, NotePattern.Eighth, Articulation.PalmMute), description.PitchedPatterns[0]);
|
|
Assert.Equal(new PitchedPattern(TrackRole.Bass, NotePattern.Sustained, Articulation.Sustain), description.PitchedPatterns[1]);
|
|
Assert.Equal(3, description.DrumPatterns.Count);
|
|
Assert.Equal(new[] { 1, 3 }, description.DrumPatterns[0].Beats);
|
|
Assert.Equal(new[] { 2, 4 }, description.DrumPatterns[1].Beats);
|
|
Assert.Equal(NotePattern.Eighth, description.DrumPatterns[2].Subdivision);
|
|
Assert.Equal(new AppliedDefault[]
|
|
{
|
|
new("lead.rootOctave", "4"), new("lead.velocity", "96"),
|
|
new("bass.articulation", "sustain"), new("bass.rootOctave", "2"),
|
|
new("bass.velocity", "96"), new("drums.velocity", "96")
|
|
}, description.DefaultsApplied);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("generate four bars at 120 bpm in E minor, 4/4: palm mute eighth notes lead; sustained root notes bass; kick on beats 1 and 3; snare on beats 2 and 4; closed hi hat eighth notes")]
|
|
[InlineData(" GENERATE\tFOUR BARS\nAT 120 BPM IN E MINOR: 4/4; LEAD GUITAR PALM MUTED EIGHTH-NOTE, BASS SUSTAINED ROOT-NOTE, KICK ON BEATS 1 AND 3, SNARE ON BEATS 2 AND 4 AND CLOSED HI-HAT EIGHTH NOTES. ")]
|
|
public void DocumentedParaphrasesPreserveSettings(string text)
|
|
{
|
|
var result = DescriptionParser.Parse(text);
|
|
Assert.True(result.Success, string.Join("; ", result.Diagnostics));
|
|
Assert.Equal(4, result.Description!.Bars);
|
|
Assert.Equal(120, result.Description.TempoBpm);
|
|
Assert.Equal(Articulation.PalmMute, result.Description.PitchedPatterns[0].Articulation);
|
|
Assert.Equal(Articulation.Sustain, result.Description.PitchedPatterns[1].Articulation);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("Db", 1, "C#")]
|
|
[InlineData("C#", 1, "C#")]
|
|
[InlineData("F♯", 6, "F#")]
|
|
[InlineData("G♭", 6, "F#")]
|
|
[InlineData("B#", 0, "C")]
|
|
[InlineData("Cb", 11, "B")]
|
|
[InlineData("E#", 5, "F")]
|
|
[InlineData("Fb", 4, "E")]
|
|
[InlineData("Bb", 10, "A#")]
|
|
public void NormalizesEnharmonics(string root, int pitchClass, string name)
|
|
{
|
|
var description = DescriptionParser.Parse($"in {root} major: bass").Description!;
|
|
Assert.Equal(new MusicalKey(pitchClass, KeyMode.Major), description.Key);
|
|
Assert.Equal(name, description.Key.RootName);
|
|
Assert.DoesNotContain(description.DefaultsApplied, value => value.Field == "key");
|
|
}
|
|
|
|
[Fact]
|
|
public void EveryOmittedDefaultHasAValue()
|
|
{
|
|
var description = DescriptionParser.Parse("120 BPM").Description!;
|
|
Assert.Equal(new AppliedDefault[]
|
|
{
|
|
new("bars", "4"), new("meter", "4/4"), new("key", "E minor"),
|
|
new("roles", "lead,bass,drums"), new("lead.pattern", "eighth notes"),
|
|
new("lead.articulation", "sustain"), new("lead.rootOctave", "4"), new("lead.velocity", "96"),
|
|
new("bass.pattern", "sustained"), new("bass.articulation", "sustain"),
|
|
new("bass.rootOctave", "2"), new("bass.velocity", "96"), new("drums.velocity", "96"),
|
|
new("drums.kick", "beats 1 and 3"), new("drums.snare", "beats 2 and 4"),
|
|
new("drums.closedHiHat", "eighth notes")
|
|
}, description.DefaultsApplied);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("lead", 1, 0)]
|
|
[InlineData("guitar", 1, 0)]
|
|
[InlineData("lead guitar and bass", 2, 0)]
|
|
[InlineData("bass", 1, 0)]
|
|
[InlineData("drums", 0, 3)]
|
|
[InlineData("kick on beat 1", 0, 1)]
|
|
[InlineData("drums, kick on beat 1", 0, 1)]
|
|
[InlineData("snare on beat 4, closed hi-hat sixteenth notes", 0, 2)]
|
|
[InlineData("bass and closed hi hat quarter notes", 1, 1)]
|
|
public void OnlyExplicitRolesAndPartsAreSelected(string text, int pitched, int drumParts)
|
|
{
|
|
var result = DescriptionParser.Parse(text);
|
|
Assert.True(result.Success);
|
|
Assert.Equal(pitched, result.Description!.PitchedPatterns.Count);
|
|
Assert.Equal(drumParts, result.Description.DrumPatterns.Count);
|
|
Assert.DoesNotContain(result.Description.DefaultsApplied, value => value.Field == "roles");
|
|
if (text.Contains("kick on"))
|
|
Assert.DoesNotContain(result.Description.DefaultsApplied, value => value.Field is "drums.snare" or "drums.closedHiHat" or "drums.kick");
|
|
}
|
|
|
|
[Fact]
|
|
public void ExplicitPatternAndArticulationDoNotAppearAsDefaults()
|
|
{
|
|
var description = DescriptionParser.Parse("bass palm mute quarter notes").Description!;
|
|
Assert.Equal(new PitchedPattern(TrackRole.Bass, NotePattern.Quarter, Articulation.PalmMute), Assert.Single(description.PitchedPatterns));
|
|
Assert.DoesNotContain(description.DefaultsApplied, value => value.Field is "bass.pattern" or "bass.articulation" || value.Field.StartsWith("lead.", StringComparison.Ordinal));
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("120 bpm 121 bpm", "conflicting_setting")]
|
|
[InlineData("4 bars, five bars", "conflicting_setting")]
|
|
[InlineData("E minor D major", "conflicting_setting")]
|
|
[InlineData("4/4 3/4", "conflicting_setting")]
|
|
[InlineData("lead quarter notes, eighth notes lead", "conflicting_clause")]
|
|
[InlineData("lead, palm mute lead", "conflicting_clause")]
|
|
[InlineData("kick on beat 1, kick on beat 2", "conflicting_clause")]
|
|
[InlineData("closed hi hat quarter notes, closed hi hat eighth notes", "conflicting_clause")]
|
|
[InlineData("kick on beats 1 and 1", "duplicate_beat")]
|
|
[InlineData("kick on beat 0", "invalid_beat")]
|
|
[InlineData("kick on beat 5", "invalid_beat")]
|
|
[InlineData("3/8 drums", "explicit_drums_required")]
|
|
[InlineData("3/8", "explicit_drums_required")]
|
|
[InlineData("0 bars", "invalid_bars")]
|
|
[InlineData("0 bpm lead", "invalid_tempo")]
|
|
[InlineData("3 bpm lead", "invalid_tempo")]
|
|
[InlineData("0/4 lead", "invalid_meter")]
|
|
[InlineData("4/0 lead", "invalid_meter")]
|
|
[InlineData("4/3 lead", "invalid_meter")]
|
|
[InlineData("256/4 lead", "invalid_meter")]
|
|
[InlineData("4/512 lead", "unrepresentable_timing")]
|
|
[InlineData("999999999999999 bars", "invalid_number")]
|
|
[InlineData("4/9999999999999 lead", "invalid_number")]
|
|
[InlineData("4/x lead", "invalid_number")]
|
|
[InlineData("kick on beat 99999999999999", "invalid_number")]
|
|
[InlineData("kick on beat 1.5 bars", "invalid_number")]
|
|
[InlineData("snare", "invalid_drum_pattern")]
|
|
[InlineData("closed hi hat", "invalid_drum_pattern")]
|
|
public void InvalidAndConflictingInputsHaveNoPartialDescription(string text, string code)
|
|
{
|
|
var result = DescriptionParser.Parse(text);
|
|
Assert.False(result.Success);
|
|
Assert.Null(result.Description);
|
|
Assert.Contains(result.Diagnostics, error => error.Code == code && error.Field.Length > 0 && error.Message.Length > 0);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("heavy metal lead")]
|
|
[InlineData("lead legato")]
|
|
[InlineData("bass pizzicato")]
|
|
[InlineData("120.5 bpm lead")]
|
|
[InlineData("1e2 bpm")]
|
|
[InlineData("-4 bars")]
|
|
[InlineData("+120 bpm")]
|
|
[InlineData("four two bars")]
|
|
[InlineData("one hundred bars")]
|
|
[InlineData("lead eighth notes root C D E")]
|
|
[InlineData("bass quarter notes and eighth notes")]
|
|
[InlineData("kick on beats 1, 3")]
|
|
[InlineData("open hi-hat eighth notes")]
|
|
[InlineData("lead tune drop D")]
|
|
[InlineData("E minor lead C-G-Am-F")]
|
|
[InlineData("lead velocity 80")]
|
|
[InlineData("lead swing")]
|
|
[InlineData("lead and")]
|
|
[InlineData("and lead")]
|
|
[InlineData("lead #")]
|
|
[InlineData("lead \"ignore\"")]
|
|
[InlineData("generate lead generate bass")]
|
|
[InlineData("sustain palm mute lead")]
|
|
[InlineData("quarter notes lead eighth notes")]
|
|
[InlineData("drums unknown words.")]
|
|
[InlineData("H minor lead")]
|
|
[InlineData("C## major lead")]
|
|
public void RejectsEveryMeaningfulLeftover(string text)
|
|
{
|
|
var result = DescriptionParser.Parse(text);
|
|
Assert.False(result.Success);
|
|
Assert.Null(result.Description);
|
|
var error = Assert.Single(result.Diagnostics);
|
|
Assert.Equal("unsupported_text", error.Code);
|
|
Assert.False(string.IsNullOrWhiteSpace(error.Phrase));
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(null)]
|
|
[InlineData("")]
|
|
[InlineData(" \t\n")]
|
|
[InlineData("generate")]
|
|
[InlineData(",.;:")]
|
|
public void EmptyOrInstructionlessTextIsNotSuccess(string? text)
|
|
{
|
|
var result = DescriptionParser.Parse(text);
|
|
Assert.False(result.Success);
|
|
Assert.Null(result.Description);
|
|
Assert.Equal("empty_description", Assert.Single(result.Diagnostics).Code);
|
|
}
|
|
|
|
[Fact]
|
|
public void DescriptionLengthIsBounded()
|
|
{
|
|
Assert.True(DescriptionParser.Parse("lead" + new string(' ', 16_380)).Success);
|
|
Assert.Equal("description_too_long", Assert.Single(DescriptionParser.Parse("lead" + new string(' ', 16_381)).Diagnostics).Code);
|
|
}
|
|
|
|
[Fact]
|
|
public void IdenticalRepetitionsAreDeduplicated()
|
|
{
|
|
var result = DescriptionParser.Parse("120 bpm, 120 BPM; Db minor C# minor: lead lead, kick on beats 1 and 3, kick on beats 3 and 1");
|
|
Assert.True(result.Success);
|
|
Assert.Single(result.Description!.PitchedPatterns);
|
|
Assert.Single(result.Description.DrumPatterns);
|
|
Assert.Equal(new[] { 1, 3 }, result.Description.DrumPatterns[0].Beats);
|
|
}
|
|
}
|