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

167 lines
7.7 KiB
C#

using GAJ3T.MusicGen.RiffGrooveBuilder.Core.Composition;
using Model = GAJ3T.MusicGen.RiffGrooveBuilder.Core.Composition.Composition;
namespace GAJ3T.MusicGen.RiffGrooveBuilder.UnitTests.Composition;
public sealed class CompositionValidatorTests
{
private static MusicalNote Note(int pitch = 64, int velocity = 96,
BeatFraction? start = null, BeatFraction? duration = null, Articulation articulation = Articulation.Sustain) =>
new(pitch, start ?? new(0), duration ?? new(1), velocity, articulation);
private static Model ModelOf(IEnumerable<TrackPlan>? tracks = null, double tempo = 120,
int bars = 4, TimeSignature? meter = null, MusicalKey? key = null) =>
new(tempo, meter ?? new(4, 4), key ?? new(4, KeyMode.Minor), bars,
tracks ?? [new TrackPlan(TrackRole.Lead, [Note()])]);
[Fact]
public void AcceptsValidMusicalValuesWithoutAnyProductMapping()
{
Assert.Empty(CompositionValidator.Validate(ModelOf()));
Assert.Empty(CompositionValidator.Validate(ModelOf(tempo: 137, meter: new(3, 8))));
Assert.Empty(CompositionValidator.Validate(ModelOf(meter: new(255, 256), tracks:
[new TrackPlan(TrackRole.Bass, [Note(pitch: 0, velocity: 1, duration: new(1, 64))])])));
Assert.Empty(CompositionValidator.Validate(ModelOf(tracks: [new TrackPlan(TrackRole.Lead,
[Note(pitch: 127, velocity: 127, articulation: Articulation.PalmMute)])])));
}
[Theory]
[InlineData(0)]
[InlineData(-1)]
[InlineData(double.NaN)]
[InlineData(double.PositiveInfinity)]
[InlineData(double.NegativeInfinity)]
[InlineData(double.Epsilon)]
[InlineData(3)]
[InlineData(60000001)]
public void RejectsInvalidOrUnrepresentableTempo(double tempo) =>
AssertCode(ModelOf(tempo: tempo), "invalid_tempo");
[Theory]
[InlineData(60000000)]
[InlineData(60000000d / 16777215d)]
[InlineData(137)]
public void AcceptsSmfTempoBoundariesAndQuantizableTempo(double tempo) =>
Assert.Empty(CompositionValidator.Validate(ModelOf(tempo: tempo)));
[Theory]
[InlineData(0)]
[InlineData(-1)]
[InlineData(int.MinValue)]
public void RejectsNonpositiveBars(int bars) => AssertCode(ModelOf(bars: bars), "invalid_bars");
[Theory]
[InlineData(0, 4, "invalid_meter")]
[InlineData(256, 4, "invalid_meter")]
[InlineData(4, 0, "invalid_meter")]
[InlineData(4, -4, "invalid_meter")]
[InlineData(4, 3, "invalid_meter")]
[InlineData(4, 512, "unrepresentable_timing")]
[InlineData(4, 1073741824, "unrepresentable_timing")]
public void ValidatesMeterFieldsAndDenominatorBeats(int numerator, int denominator, string code) =>
AssertCode(ModelOf(meter: new(numerator, denominator)), code);
[Theory]
[InlineData(-1)]
[InlineData(12)]
public void RejectsInvalidKey(int pitchClass) =>
AssertCode(ModelOf(key: new(pitchClass, KeyMode.Minor)), "invalid_key");
[Fact]
public void RejectsUndefinedKeyMode() => AssertCode(ModelOf(key: new(4, (KeyMode)99)), "invalid_key");
[Theory]
[InlineData(-1)]
[InlineData(128)]
public void RejectsOutOfRangePitch(int pitch) =>
AssertCode(ModelOf([new TrackPlan(TrackRole.Lead, [Note(pitch: pitch)])]), "invalid_pitch");
[Theory]
[InlineData(0)]
[InlineData(-1)]
[InlineData(128)]
public void RejectsOutOfRangeVelocityOnBothKinds(int velocity)
{
AssertCode(ModelOf([new TrackPlan(TrackRole.Lead, [Note(velocity: velocity)])]), "invalid_velocity");
AssertCode(ModelOf([new TrackPlan(TrackRole.Drums, hits: [new(DrumVoice.Kick, new(0), new(1), velocity)])]), "invalid_velocity");
}
[Fact]
public void RejectsInvalidStartDurationAndExtent()
{
AssertCode(ModelOf([new TrackPlan(TrackRole.Lead, [Note(start: new(-1))])]), "invalid_start");
AssertCode(ModelOf([new TrackPlan(TrackRole.Lead, [Note(duration: new(0))])]), "invalid_duration");
AssertCode(ModelOf([new TrackPlan(TrackRole.Lead, [Note(duration: new(-1))])]), "invalid_duration");
AssertCode(ModelOf([new TrackPlan(TrackRole.Lead, [Note(start: new(16))])]), "event_out_of_bounds");
AssertCode(ModelOf([new TrackPlan(TrackRole.Lead, [Note(start: new(15), duration: new(2))])]), "event_out_of_bounds");
AssertCode(ModelOf([new TrackPlan(TrackRole.Drums, hits: [new(DrumVoice.Snare, new(15), new(2), 96)])]), "event_out_of_bounds");
Assert.Empty(CompositionValidator.Validate(ModelOf([new TrackPlan(TrackRole.Lead, [Note(start: new(15))])])));
}
[Fact]
public void RejectsUnrepresentableStartOrDuration()
{
AssertCode(ModelOf([new TrackPlan(TrackRole.Lead, [Note(start: new(1, 7))])]), "unrepresentable_timing");
AssertCode(ModelOf([new TrackPlan(TrackRole.Lead, [Note(duration: new(1, 7))])]), "unrepresentable_timing");
}
[Fact]
public void RejectsOverflowInsteadOfWrapping()
{
AssertCode(ModelOf([new TrackPlan(TrackRole.Lead, [Note(start: new(long.MaxValue))])]), "arithmetic_overflow");
AssertCode(ModelOf([new TrackPlan(TrackRole.Lead, [Note(duration: new(long.MaxValue))])]), "arithmetic_overflow");
}
[Fact]
public void RequiresDistinctSelectedNonemptyRolesAndCorrectEventKinds()
{
AssertCode(ModelOf([]), "invalid_roles");
AssertCode(ModelOf([new TrackPlan(TrackRole.Lead)]), "empty_track");
AssertCode(ModelOf([new TrackPlan((TrackRole)99, [Note()])]), "invalid_roles");
AssertCode(ModelOf([new TrackPlan(TrackRole.Lead, [Note()]), new TrackPlan(TrackRole.Lead, [Note()])]), "invalid_roles");
AssertCode(ModelOf([new TrackPlan(TrackRole.Drums, [Note()])]), "event_kind_mismatch");
AssertCode(ModelOf([new TrackPlan(TrackRole.Bass, hits: [new(DrumVoice.Kick, new(0), new(1), 96)])]), "event_kind_mismatch");
AssertCode(ModelOf([new TrackPlan(TrackRole.Lead, [Note(articulation: (Articulation)99)])]), "invalid_articulation");
AssertCode(ModelOf([new TrackPlan(TrackRole.Drums, hits: [new((DrumVoice)99, new(0), new(1), 96)])]), "invalid_drum_voice");
}
[Fact]
public void NullModelsAndElementsHaveActionableDiagnostics()
{
Assert.Equal("invalid_composition", Assert.Single(CompositionValidator.Validate(null)).Code);
AssertCode(ModelOf([null!]), "invalid_track");
AssertCode(ModelOf([new TrackPlan(TrackRole.Lead, [null!])]), "invalid_note");
AssertCode(ModelOf([new TrackPlan(TrackRole.Drums, hits: [null!])]), "invalid_hit");
}
[Fact]
public void ManualModelsRespectExactCombinedEventLimit()
{
var notes = Enumerable.Repeat(Note(), 50_000).ToArray();
var hits = Enumerable.Repeat(new DrumHit(DrumVoice.Kick, new(0), new(1), 96), 50_000).ToArray();
var model = ModelOf([new TrackPlan(TrackRole.Lead, notes), new TrackPlan(TrackRole.Drums, hits: hits)]);
Assert.Empty(CompositionValidator.Validate(model));
AssertCode(ModelOf([new TrackPlan(TrackRole.Lead, notes.Append(Note())), new TrackPlan(TrackRole.Drums, hits: hits)]),
"event_limit_exceeded");
}
[Fact]
public void DeclaredMusicalExtentPreservesTrailingRests()
{
var composition = ModelOf([new TrackPlan(TrackRole.Drums, hits: [new(DrumVoice.Kick, new(0), new(1), 96)])]);
Assert.Empty(CompositionValidator.Validate(composition));
Assert.Equal(new BeatFraction(16), composition.MusicalExtent);
}
private static void AssertCode(Model model, string code)
{
var errors = CompositionValidator.Validate(model);
Assert.Contains(errors, error => error.Code == code);
Assert.All(errors, error =>
{
Assert.False(string.IsNullOrWhiteSpace(error.Field));
Assert.False(string.IsNullOrWhiteSpace(error.Message));
});
}
}