Cubase-MCP-GAJ3T.MusicGen.R.../tests/GAJ3T.MusicGen.RiffGrooveBu.../Articulations/DocumentedProfileTests.cs

243 lines
12 KiB
C#

using System.Text;
using System.Text.Json;
using System.Text.Json.Nodes;
using System.Text.Json.Serialization;
using GAJ3T.MusicGen.RiffGrooveBuilder.Core.Articulations;
using GAJ3T.MusicGen.RiffGrooveBuilder.Core.Composition;
using GAJ3T.MusicGen.RiffGrooveBuilder.Generation.Profiles;
using MusicalComposition = GAJ3T.MusicGen.RiffGrooveBuilder.Core.Composition.Composition;
namespace GAJ3T.MusicGen.RiffGrooveBuilder.UnitTests.Articulations;
public sealed class DocumentedProfileTests
{
[Theory]
[InlineData("aglp", "Ample Guitar LP", 40, 86, 1, "7b28b62f3c25ecb774227b15beab06f5e0f0c944f35db9e82121028017f9cedb",
"AGLP-Prison_Break.zip", "3837")]
[InlineData("ame", "Ample Metal Eclipse", 36, 84, 64, "ab482f08b0546eca0a4233b8be3776c411b77f3dca96979f529debc2dfc0c4ca",
"AME-Eclipse.zip", "3720")]
[InlineData("agm", "Ample Guitar M", 40, 84, 1, "449bd7b8bca7771dbf8e08e0029d2bbe999f991efe441d7900ee93da29dd86a4",
"AGM-Dear_Ben.zip", "28798")]
[InlineData("agt", "Ample Guitar T", 40, 84, 1, "2e5696d750841a47061d37737ec7d8435cb4e30756cda15596d1f89ff87810dd",
"AGT-Wish_You_Were_Here.zip", "3840")]
public void EveryAdmittedMappingHasExactNumericFactsAndVendorAnchors(string code, string name,
int minimum, int maximum, int sustainMinimum, string hash, string sample, string anchorTick)
{
var catalog = InstrumentProfileCatalog.LoadEmbedded();
var profile = catalog.SelectInstrument(TrackRole.Lead, "ample-" + code).Profile!;
Assert.Equal($"ample-{code}-documented-defaults-2026-10-20", profile.Id);
Assert.Equal(name, profile.ProductName);
Assert.Equal(TrackRole.Lead, profile.Role);
Assert.Equal(MappingVerification.Documented, profile.Evidence.Status);
Assert.Equal($"https://www.amplesound.net/en/Main_Panel_Manual-{code.ToUpperInvariant()}.pdf",
profile.Evidence.Source);
Assert.Contains(hash, profile.Evidence.VerificationRecord);
Assert.Contains("https://www.amplesound.net/dl0822/ds/" + sample, profile.Evidence.VerificationRecord);
Assert.Contains(anchorTick, profile.Evidence.VerificationRecord);
Assert.Contains("480 PPQ", profile.Evidence.VerificationRecord);
Assert.Contains("2026-10-20", profile.Evidence.VerificationRecord);
Assert.Contains("PDF pp.6-7", profile.Evidence.VerificationRecord);
Assert.Equal("documented defaults; installed version unknown", profile.ProductVersion);
Assert.Equal("published-defaults-2026-10-20.1", profile.MappingVersion);
Assert.Equal(minimum, profile.MinimumPitch);
Assert.Equal(maximum, profile.MaximumPitch);
Assert.Equal(0, profile.Channel);
Assert.Null(profile.InitialArticulation);
Assert.Null(profile.FinalResetArticulation);
Assert.Empty(profile.InitialControllers);
Assert.Empty(profile.FinalControllers);
Assert.Equal(2, profile.Rules.Count);
foreach (var (articulation, pitch, low, high) in new[]
{
(Articulation.Sustain, 24, sustainMinimum, 126), (Articulation.PalmMute, 26, 1, 127)
})
{
var rule = Assert.Single(profile.Rules, r => r.Articulation == articulation);
Assert.Equal(StateBehavior.Latched, rule.Behavior);
Assert.Equal(new KeyswitchAction(pitch, 100, 120, 30), rule.Keyswitch);
Assert.Equal(low, rule.Velocity.Minimum);
Assert.Equal(high, rule.Velocity.Maximum);
Assert.Null(rule.Velocity.OutputVelocity);
Assert.Empty(rule.Controllers);
Assert.Null(rule.Voice);
Assert.Null(rule.DrumPitch);
}
var notes = Assert.IsType<MappingCompatibilityNotes>(profile.CompatibilityNotes);
Assert.Contains("Non-versioned", notes.VersionScope);
Assert.Contains("installed", notes.VersionScope);
Assert.Contains("MIDI Guitar mode disabled", notes.ConfigurationRequirements);
Assert.Contains("unknown", notes.ConfigurationRequirements);
Assert.Contains("channel 0", notes.RoutingPolicy);
Assert.Contains("120-tick advance and 30-tick", notes.TimingPolicy);
Assert.Contains("NOT a vendor minimum", notes.TimingPolicy);
Assert.Empty(InstrumentProfileValidator.Validate(profile));
var changed = notes with { TimingPolicy = "Changed copy" };
Assert.NotEqual(changed.TimingPolicy, profile.CompatibilityNotes!.TimingPolicy);
}
[Theory]
[InlineData("ample-amr", TrackRole.Bass)]
[InlineData("toontrack-sd3", TrackRole.Drums)]
public void UnsupportedSourcesRemainUnavailableWithoutSubstitution(string instrumentId, TrackRole role)
{
var catalog = InstrumentProfileCatalog.LoadEmbedded();
var result = catalog.SelectInstrument(role, instrumentId);
Assert.False(result.Success);
Assert.Equal("mapping_unavailable", Assert.Single(result.Diagnostics).Code);
Assert.Contains("numeric mapping evidence", result.Diagnostics[0].Message);
Assert.Empty(Assert.Single(catalog.Instruments, i => i.Instrument.Id == instrumentId).Profiles);
}
[Theory]
[InlineData(false)]
[InlineData(true)]
public void MissingOrNullDocumentedNotesFailInsteadOfAcquiringDefaults(bool remove)
{
var json = Embedded();
if (remove)
json[0]!.AsObject().Remove("compatibilityNotes");
else
json[0]!["compatibilityNotes"] = null;
Assert.Contains("missing_compatibility_notes", Assert.Throws<InvalidDataException>(() => Load(json)).Message);
}
[Theory]
[InlineData("versionScope")]
[InlineData("configurationRequirements")]
[InlineData("routingPolicy")]
[InlineData("timingPolicy")]
public void EachDocumentedNoteIsRequiredInSerializedData(string field)
{
var json = Embedded();
json[0]!["compatibilityNotes"]!.AsObject().Remove(field);
Assert.Contains("Malformed", Assert.Throws<InvalidDataException>(() => Load(json)).Message);
json = Embedded();
json[0]!["compatibilityNotes"]![field] = " ";
Assert.Contains("invalid_compatibility_notes", Assert.Throws<InvalidDataException>(() => Load(json)).Message);
}
[Theory]
[InlineData("instrumentId", "does-not-exist", "unknown_instrument")]
[InlineData("role", "Drums", "profile_role_mismatch")]
[InlineData("productName", "Other product", "profile_product_mismatch")]
public void DocumentedAdmissionStillRequiresExactBinding(string field, string value, string diagnostic)
{
var json = Embedded();
json[0]![field] = value;
Assert.Contains(diagnostic, Assert.Throws<InvalidDataException>(() => Load(json)).Message);
}
[Fact]
public void LegacyVerifiedJsonWithoutNotesStillLoadsUnchanged()
{
var json = Embedded();
foreach (var profile in json)
{
profile!["evidence"]!["status"] = "Verified";
profile.AsObject().Remove("compatibilityNotes");
}
Assert.All(Load(json).Profiles, p =>
{
Assert.Equal(MappingVerification.Verified, p.Evidence.Status);
Assert.Null(p.CompatibilityNotes);
});
}
[Theory]
[InlineData("Synthetic")]
[InlineData("Unverified")]
public void DocumentedSourcesAndNotesCannotLaunderRejectedStatuses(string status)
{
var json = Embedded();
json[0]!["evidence"]!["status"] = status;
Assert.Contains("unverified_profile", Assert.Throws<InvalidDataException>(() => Load(json)).Message);
}
[Theory]
[InlineData("ample-aglp", 39)]
[InlineData("ample-aglp", 87)]
[InlineData("ample-ame", 35)]
[InlineData("ample-ame", 85)]
[InlineData("ample-agm", 39)]
[InlineData("ample-agm", 85)]
[InlineData("ample-agt", 39)]
[InlineData("ample-agt", 85)]
[InlineData("ample-abj", 34)]
[InlineData("ample-abj", 77)]
public void NumericPlayableRangeBoundariesAreEnforcedBeforePlanning(string instrumentId, int pitch)
{
var profile = InstrumentProfileCatalog.LoadEmbedded().Profiles.Single(p => p.InstrumentId == instrumentId);
var model = new MusicalComposition(120, new(4, 4), new(4, KeyMode.Minor), 1,
[new(profile.Role, [SyntheticProfiles.Note(pitch: pitch)])]);
var result = ArticulationPlanner.Plan(model, [profile]);
Assert.False(result.Success);
Assert.Null(result.Plan);
Assert.Equal("pitch_out_of_profile_range", Assert.Single(result.Diagnostics).Code);
}
[Fact]
public void AbjSharedVendorAnchorAdmitsOnlySustainAndDisclosesItsExactLimits()
{
var profile = InstrumentProfileCatalog.LoadEmbedded().SelectInstrument(TrackRole.Bass, "ample-abj").Profile!;
Assert.Equal("ample-abj-documented-defaults-2026-10-20", profile.Id);
Assert.Equal("Ample Bass J", profile.ProductName);
Assert.Equal(MappingVerification.Documented, profile.Evidence.Status);
Assert.Equal("https://www.amplesound.net/en/Main_Panel_Manual-ABJ.pdf", profile.Evidence.Source);
foreach (var fact in new[] { "9291c4e3027ac1469bd845bb04614f5a2754bd35a4f017bcfd7cdb75db335e7e",
"https://www.amplesound.net/en/download.asp", "ABJ ABP", "AB-Articulations.zip",
"c3efc1dc787c59a00be7405687488317efaf952822aededf54b9e19f4e145cb7",
"AB-Articulations/4.2 Articulations & Poly Legato.mid", "track 1 ABP", "3720/off 4080",
"NOT an independently ABJ-named performance" })
Assert.Contains(fact, profile.Evidence.VerificationRecord);
Assert.Equal(35, profile.MinimumPitch);
Assert.Equal(76, profile.MaximumPitch);
Assert.Equal(1, profile.Channel);
Assert.Null(profile.InitialArticulation);
Assert.Null(profile.FinalResetArticulation);
Assert.Empty(profile.InitialControllers);
Assert.Empty(profile.FinalControllers);
var rule = Assert.Single(profile.Rules);
Assert.Equal(Articulation.Sustain, rule.Articulation);
Assert.Equal(StateBehavior.Latched, rule.Behavior);
Assert.Equal(new KeyswitchAction(24, 100, 120, 30), rule.Keyswitch);
Assert.Equal(new VelocityLayer(1, 125, null), rule.Velocity);
Assert.Null(rule.Voice);
Assert.Null(rule.DrumPitch);
Assert.Empty(rule.Controllers);
Assert.Contains("PalmMute are rejected", profile.CompatibilityNotes!.ConfigurationRequirements);
Assert.Contains("NOT a mandatory receiver channel", profile.CompatibilityNotes.RoutingPolicy);
Assert.Empty(InstrumentProfileValidator.Validate(profile));
}
[Fact]
public void AgmAndAgtProvenanceIncludesIndependentAbsoluteAndNamedTabControlAnchors()
{
var catalog = InstrumentProfileCatalog.LoadEmbedded();
var agm = catalog.SelectInstrument(TrackRole.Lead, "ample-agm").Profile!;
foreach (var fact in new[] { "AGM-Rylynn/AGM3-Rylynn.mid", "32215/off 32335",
"AGM-Dear Ben/AGM-Dear Ben Tempo 74.mid", "28798/off 28858", "30238/off 30298" })
Assert.Contains(fact, agm.Evidence.VerificationRecord);
var agt = catalog.SelectInstrument(TrackRole.Lead, "ample-agt").Profile!;
foreach (var fact in new[] { "https://www.amplesound.net/en/tutorial-b.asp", "6.3 Tab Play Toggle",
"MIDI note A6", "AGT-Wish_You_Were_Here/AGT3-Wish You Were Here Tempo 62.mid",
"105 velocity 80", "3840/off 4320", "C0=105-(6*12+9)=24", "NOT a label inferred",
"82a9b42109519d20d9340c6c6cdb972a66663482df483fd0bf5034b84b5d9262" })
Assert.Contains(fact, agt.Evidence.VerificationRecord);
Assert.Contains("NOT a direct Sustain/PM performance", agt.CompatibilityNotes!.VersionScope);
Assert.DoesNotContain(agt.Rules, r => r.Keyswitch?.Pitch == 105);
}
private static JsonArray Embedded()
{
var options = new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase };
options.Converters.Add(new JsonStringEnumConverter());
return JsonSerializer.SerializeToNode(InstrumentProfileCatalog.LoadEmbedded().Profiles, options)!.AsArray();
}
private static InstrumentProfileCatalog Load(JsonArray json)
{
using var stream = new MemoryStream(Encoding.UTF8.GetBytes(json.ToJsonString()));
return InstrumentProfileCatalog.Load(stream);
}
}