167 lines
7.7 KiB
C#
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));
|
|
});
|
|
}
|
|
}
|