Spaces:
Runtime error
Runtime error
| /** | |
| * Round-trip tests for the ABC parser and serializer. | |
| * | |
| * The grid rewrites the score, so a parse or spelling bug here silently | |
| * transposes the operator's music. The randomised block at the bottom is the | |
| * important half: the fixed cases only cover what I thought to write down, and | |
| * it was the random ones that found the accidental bugs. | |
| * | |
| * npm run test:abc | |
| */ | |
| import { unitsPerBar } from "@/lib/abc/model"; | |
| import type { AbcNote, AbcScore } from "@/lib/abc/model"; | |
| import { parseAbc } from "@/lib/abc/parse"; | |
| import { serializeAbc } from "@/lib/abc/serialize"; | |
| let fails = 0; | |
| const check = (label: string, ok: boolean, extra?: string) => { | |
| console.log((ok ? " ok " : " FAIL ") + label + (ok || !extra ? "" : "\n " + extra)); | |
| if (!ok) fails++; | |
| }; | |
| const SKELETON = `X:1 | |
| T:Your title | |
| M:4/4 | |
| L:1/8 | |
| K:G | |
| V:Vocal | |
| |: G2 A2 B2 d2 | e4 d4 :| | |
| V:Ins | |
| |: G,4 B,4 | C4 D4 :|`; | |
| const first = parseAbc(SKELETON); | |
| check("the skeleton parses", first.ok, first.ok ? "" : first.reason); | |
| if (!first.ok) process.exit(1); | |
| const s = first.score; | |
| check("two voices found", s.voices.length === 2 && s.voices[0].id === "Vocal" && s.voices[1].id === "Ins"); | |
| check("meter and unit read", s.meter[0] === 4 && s.meter[1] === 4 && s.unit[1] === 8); | |
| check("eight units to a bar", unitsPerBar(s) === 8); | |
| check("repeats were written out", s.repeatsExpanded); | |
| const vocal = s.notes.filter((n) => n.voice === 0).sort((a, b) => a.start - b.start); | |
| check("repeat doubled the vocal line", vocal.length === 12, `got ${vocal.length}`); | |
| check("the first pass spans two bars", vocal[5].start + vocal[5].duration === 16); | |
| check("G in the key of G is G4 = midi 67", vocal[0].midi === 67, `got ${vocal[0].midi}`); | |
| check("lower case d is an octave up from D", vocal[3].midi === 74, `got ${vocal[3].midi}`); | |
| check("the repeat starts where the first pass ended", vocal[6].start === 16, `got ${vocal[6].start}`); | |
| check( | |
| "the repeat replays the same pitches", | |
| vocal.slice(0, 6).map((n) => n.midi).join() === vocal.slice(6).map((n) => n.midi).join(), | |
| ); | |
| const ins = s.notes.filter((n) => n.voice === 1).sort((a, b) => a.start - b.start); | |
| check("G, is an octave below G", ins[0].midi === 55, `got ${ins[0].midi}`); | |
| // --- key signature and accidentals ------------------------------------------ | |
| const inG = parseAbc("X:1\nM:4/4\nL:1/8\nK:G\nV:1\nF4 f4 |"); | |
| check("the key signature sharpens F", inG.ok && inG.score.notes[0].midi === 66); | |
| const natural = parseAbc("X:1\nM:4/4\nL:1/8\nK:G\nV:1\n=F4 F4 |"); | |
| check( | |
| "a natural cancels it for the rest of the bar", | |
| natural.ok && natural.score.notes[0].midi === 65 && natural.score.notes[1].midi === 65, | |
| ); | |
| const nextBar = parseAbc("X:1\nM:4/4\nL:1/8\nK:G\nV:1\n=F4 z4 | F4 z4 |"); | |
| check("and the signature returns in the next bar", nextBar.ok && nextBar.score.notes[1].midi === 66); | |
| // --- lengths, ties, chords, rests ------------------------------------------- | |
| const lengths = parseAbc("X:1\nM:4/4\nL:1/8\nK:C\nV:1\nC C2 C/ C// C3/2 |"); | |
| check( | |
| "plain, doubled, halved, quartered and dotted lengths", | |
| lengths.ok && lengths.score.notes.map((n) => n.duration).join() === "1,2,0.5,0.25,1.5", | |
| ); | |
| const tied = parseAbc("X:1\nM:4/4\nL:1/8\nK:C\nV:1\nC4-C4 |"); | |
| check("a tie merges into one long note", tied.ok && tied.score.notes.length === 1 && tied.score.notes[0].duration === 8); | |
| const chord = parseAbc("X:1\nM:4/4\nL:1/8\nK:C\nV:1\n[CEG]4 |"); | |
| check( | |
| "a chord is three notes at one onset", | |
| chord.ok && chord.score.notes.length === 3 && chord.score.notes.every((n) => n.start === 0 && n.duration === 4), | |
| ); | |
| const rest = parseAbc("X:1\nM:4/4\nL:1/8\nK:C\nV:1\nz4 C4 |"); | |
| check("a rest advances time without a note", rest.ok && rest.score.notes.length === 1 && rest.score.notes[0].start === 4); | |
| // --- refusals --------------------------------------------------------------- | |
| // Refusing beats dropping: the grid writes the score back out, so anything it | |
| // cannot draw is something the operator would lose without being told. | |
| for (const [label, src] of [ | |
| ["a tuplet", "X:1\nK:C\nV:1\n(3CDE |"], | |
| ["a grace note", "X:1\nK:C\nV:1\n{g}C4 |"], | |
| ] as const) { | |
| const r = parseAbc(src); | |
| check(`${label} is refused rather than dropped`, !r.ok && Boolean(r.offending)); | |
| } | |
| // --- chord symbols ---------------------------------------------------------- | |
| // These are not exotic. YuE2 writes them on ordinary output, and refusing a | |
| // score for containing one made the grid useless on real material. | |
| const harmonised = parseAbc('X:1\nM:4/4\nL:1/8\nQ:1/4=96\nK:E\nV:Lead\n"G#m" B2 c2 "E" e4 | "A" a8 |'); | |
| check("a score with chord symbols parses", harmonised.ok, harmonised.ok ? "" : harmonised.reason); | |
| if (harmonised.ok) { | |
| check("every chord symbol is kept", harmonised.score.marks.length === 3, `got ${harmonised.score.marks.length}`); | |
| check("the sharp minor survives verbatim", harmonised.score.marks[0].text === "G#m"); | |
| check("each one is pinned to its onset", harmonised.score.marks.map((m) => m.start).join() === "0,4,8"); | |
| check("they are chords, not annotations", harmonised.score.marks.every((m) => !m.annotation)); | |
| check("the tempo is read", harmonised.score.tempo === 96, `got ${harmonised.score.tempo}`); | |
| } | |
| const annotated = parseAbc('X:1\nM:4/4\nL:1/8\nK:C\nV:1\n"^softly" C4 "Dm" D4 |'); | |
| check( | |
| "a placement prefix marks an annotation, not a chord", | |
| annotated.ok && annotated.score.marks[0].annotation === true && annotated.score.marks[1].annotation === false, | |
| ); | |
| // --- round trip ------------------------------------------------------------- | |
| const fingerprint = (score: AbcScore) => | |
| [ | |
| ...score.notes.map((n) => `${n.voice}:${n.start}:${n.duration}:${n.midi}`), | |
| ...score.marks.map((m) => `mark ${m.voice}:${m.start}:${m.text}`), | |
| ] | |
| .sort() | |
| .join("|"); | |
| function roundTrip(label: string, src: string) { | |
| const a = parseAbc(src); | |
| if (!a.ok) return check(`${label} parses`, false, a.reason); | |
| const text = serializeAbc(a.score); | |
| const b = parseAbc(text); | |
| if (!b.ok) return check(`${label} re-parses`, false, `${b.reason}\n${text}`); | |
| const same = fingerprint(a.score) === fingerprint(b.score); | |
| check(`${label} survives a round trip`, same, same ? "" : `\n${text}\nwas ${fingerprint(a.score)}\nnow ${fingerprint(b.score)}`); | |
| } | |
| roundTrip("the skeleton", SKELETON); | |
| roundTrip("chords and rests", "X:1\nM:4/4\nL:1/8\nK:C\nV:1\n[CEG]4 z2 D2 | C8 |"); | |
| roundTrip("accidentals", "X:1\nM:4/4\nL:1/8\nK:C\nV:1\n^C2 _D2 =E2 ^^F2 |"); | |
| roundTrip("a natural after an accidental", "X:1\nM:4/4\nL:1/8\nK:C\nV:1\n^F2 F2 =F2 F2 |"); | |
| roundTrip("naturals under a key signature", "X:1\nM:4/4\nL:1/8\nK:G\nV:1\n=F2 F2 =C2 C2 |"); | |
| roundTrip("wide octaves", "X:1\nM:4/4\nL:1/8\nK:C\nV:1\nC,,2 C,2 C2 c2 | c'2 c''2 z4 |"); | |
| roundTrip("short notes", "X:1\nM:4/4\nL:1/8\nK:C\nV:1\nC/ D/ E// F// G3/2 A/2 z2 |"); | |
| roundTrip("three four time", "X:1\nM:3/4\nL:1/8\nK:D\nV:1\nD2 F2 A2 | d6 |"); | |
| roundTrip("chord symbols", 'X:1\nM:4/4\nL:1/8\nK:E\nV:Lead\n"G#m" B2 c2 "E" e4 | "A" a8 |'); | |
| roundTrip("chord symbols on both voices", 'X:1\nM:4/4\nL:1/8\nK:C\nV:Vocal\n"C" C4 "F" F4 |\nV:Ins\n"C" C,8 |'); | |
| // The shape the real take had: chord symbols, repeats and two voices together. | |
| roundTrip( | |
| "a YuE2 shaped score", | |
| 'X:1\nT:Take\nM:4/4\nL:1/8\nQ:1/4=84\nK:E\nV:Vocal\n|: "G#m" B2 c2 B2 A2 | "E" e6 z2 :|\nV:Ins\n|: "G#m" E,4 G,4 | "E" E,8 :|', | |
| ); | |
| // --- randomised round trip --------------------------------------------------- | |
| function mulberry(seed: number) { | |
| return () => { | |
| seed |= 0; | |
| seed = (seed + 0x6d2b79f5) | 0; | |
| let t = Math.imul(seed ^ (seed >>> 15), 1 | seed); | |
| t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t; | |
| return ((t ^ (t >>> 14)) >>> 0) / 4294967296; | |
| }; | |
| } | |
| let fuzzFails = 0; | |
| let firstReport = ""; | |
| for (let trial = 0; trial < 500; trial++) { | |
| const rand = mulberry(trial * 7919 + 13); | |
| const lengths = [0.5, 1, 1.5, 2, 3, 4, 6, 8]; | |
| const keys = ["C", "G", "D", "F", "Bb", "Am"]; | |
| const key = keys[Math.floor(rand() * keys.length)]; | |
| const notes: AbcNote[] = []; | |
| const voiceCount = 1 + Math.floor(rand() * 2); | |
| let id = 0; | |
| for (let v = 0; v < voiceCount; v++) { | |
| let t = 0; | |
| const count = 1 + Math.floor(rand() * 10); | |
| for (let i = 0; i < count; i++) { | |
| t += Math.floor(rand() * 3) * 0.5; | |
| const duration = lengths[Math.floor(rand() * lengths.length)]; | |
| notes.push({ id: `f${id++}`, voice: v, start: t, duration, midi: 36 + Math.floor(rand() * 48), tied: false }); | |
| t += duration; | |
| } | |
| } | |
| const score: AbcScore = { | |
| header: ["X:1", "M:4/4", "L:1/8", `K:${key}`], | |
| voices: Array.from({ length: voiceCount }, (_, i) => ({ id: String(i + 1), rest: "" })), | |
| notes, | |
| marks: [], | |
| meter: [4, 4], | |
| unit: [1, 8], | |
| key, | |
| repeatsExpanded: false, | |
| tempo: 120, | |
| }; | |
| const text = serializeAbc(score); | |
| const back = parseAbc(text); | |
| const want = fingerprint(score); | |
| const got = back.ok ? fingerprint(back.score) : "PARSE FAILED"; | |
| if (want !== got) { | |
| if (!fuzzFails) firstReport = `\n first mismatch, trial ${trial}, key ${key}\n${text}\nwant ${want}\ngot ${got}`; | |
| fuzzFails++; | |
| } | |
| } | |
| check("500 random scores round trip", fuzzFails === 0, `${fuzzFails} mismatched${firstReport}`); | |
| console.log(fails ? `\n${fails} FAILURES` : "\nall assertions passed"); | |
| process.exit(fails ? 1 : 0); | |