test: add test cases for new calculations

Danielku15 · Danielku15 · commit e7d0027dc85b · 2026-02-01T15:09:32.000+01:00
diff --git a/packages/alphatab/src/model/ModelUtils.ts b/packages/alphatab/src/model/ModelUtils.ts
@@ -968,20 +968,20 @@ export class ModelUtils {
         [2, AccidentalType.DoubleSharp]
     ]);
 
-    private static readonly _forcedAccidentalOffsetByMode = new Map<NoteAccidentalMode, number | null>([
+    private static readonly _forcedAccidentalOffsetByMode = new Map<NoteAccidentalMode, number>([
         [NoteAccidentalMode.ForceSharp, 1],
         [NoteAccidentalMode.ForceDoubleSharp, 2],
         [NoteAccidentalMode.ForceFlat, -1],
         [NoteAccidentalMode.ForceDoubleFlat, -2],
         [NoteAccidentalMode.ForceNatural, 0],
         [NoteAccidentalMode.ForceNone, 0],
-        [NoteAccidentalMode.Default, null]
+        [NoteAccidentalMode.Default, Number.NaN]
     ]);
 
     private static _buildKeySignatureAccidentalByDegree(): number[][] {
         const lookup: number[][] = [];
         for (let ks = -7; ks <= 7; ks++) {
-            const row = new Array<number>(7).fill(0);
+            const row = [0, 0, 0, 0, 0, 0, 0];
             if (ks > 0) {
                 for (let i = 0; i < ks; i++) {
                     row[ModelUtils._sharpKeySignatureOrder[i]] = 1;
@@ -1008,10 +1008,12 @@ export class ModelUtils {
         const chroma = ModelUtils.flooredDivision(noteValue, 12);
 
         const preferred = ModelUtils._getPreferredSpellingForKeySignature(keySignature, chroma);
-        const desiredOffset = ModelUtils._forcedAccidentalOffsetByMode.get(accidentalMode) ?? null;
+        const desiredOffset = ModelUtils._forcedAccidentalOffsetByMode.has(accidentalMode)
+            ? ModelUtils._forcedAccidentalOffsetByMode.get(accidentalMode)!
+            : Number.NaN;
 
         let spelling: SpellingBase = preferred;
-        if (desiredOffset !== null) {
+        if (!Number.isNaN(desiredOffset)) {
             const candidates = ModelUtils._spellingCandidates[chroma];
             const exact = candidates.find(c => c.accidentalOffset === desiredOffset);
             if (exact) {
@@ -1085,7 +1087,9 @@ export class ModelUtils {
     }
 
     public static accidentalOffsetToType(offset: number): AccidentalType {
-        return ModelUtils._accidentalOffsetToType.get(offset) ?? AccidentalType.None;
+        return ModelUtils._accidentalOffsetToType.has(offset)
+            ? ModelUtils._accidentalOffsetToType.get(offset)!
+            : AccidentalType.None;
     }
 
     private static _getPreferredSpellingForKeySignature(keySignature: KeySignature, chroma: number): SpellingBase {
diff --git a/packages/alphatab/src/rendering/glyphs/NumberedBeatGlyph.ts b/packages/alphatab/src/rendering/glyphs/NumberedBeatGlyph.ts
@@ -232,9 +232,9 @@ export class NumberedBeatGlyph extends BeatOnNoteGlyphBase {
                 if (note.isDead) {
                     numberWithinOctave = 'X';
                 } else {
-                    const ks = this.renderer.bar.keySignature as number;
+                    const ks = this.renderer.bar.keySignature;
                     const kst = this.renderer.bar.keySignatureType;
-                    const ksi = ks + 7;
+                    const ksi = (ks as number) + 7;
 
                     const oneNoteValues =
                         kst === KeySignatureType.Minor
diff --git a/packages/alphatab/test/model/AccidentalResolutionEdge.test.ts b/packages/alphatab/test/model/AccidentalResolutionEdge.test.ts
@@ -0,0 +1,59 @@
+import { AccidentalType } from '@coderline/alphatab/model/AccidentalType';
+import { KeySignature } from '@coderline/alphatab/model/KeySignature';
+import { ModelUtils } from '@coderline/alphatab/model/ModelUtils';
+import { NoteAccidentalMode } from '@coderline/alphatab/model/NoteAccidentalMode';
+import { expect } from 'chai';
+
+describe('AccidentalResolutionEdgeTests', () => {
+    it('spells B# in C# major for pitch C natural', () => {
+        const ks = KeySignature.CSharp;
+        const noteValue = 60; // C4
+        const spelling = ModelUtils.resolveSpelling(ks, noteValue, NoteAccidentalMode.Default);
+        expect(spelling.degree).to.equal(6); // B
+        expect(spelling.accidentalOffset).to.equal(1); // B#
+        const accidental = ModelUtils.computeAccidentalForSpelling(ks, NoteAccidentalMode.Default, spelling, false, null);
+        expect(accidental).to.equal(AccidentalType.None);
+    });
+
+    it('spells Fb in Cb major for pitch E natural', () => {
+        const ks = KeySignature.Cb;
+        const noteValue = 64; // E4
+        const spelling = ModelUtils.resolveSpelling(ks, noteValue, NoteAccidentalMode.Default);
+        expect(spelling.degree).to.equal(3); // F
+        expect(spelling.accidentalOffset).to.equal(-1); // Fb
+        const accidental = ModelUtils.computeAccidentalForSpelling(ks, NoteAccidentalMode.Default, spelling, false, null);
+        expect(accidental).to.equal(AccidentalType.None);
+    });
+
+    it('forces double sharp spelling when requested', () => {
+        const ks = KeySignature.C;
+        const noteValue = 62; // D
+        const spelling = ModelUtils.resolveSpelling(ks, noteValue, NoteAccidentalMode.ForceDoubleSharp);
+        expect(spelling.degree).to.equal(0); // C
+        expect(spelling.accidentalOffset).to.equal(2); // C##
+        const accidental = ModelUtils.computeAccidentalForSpelling(
+            ks,
+            NoteAccidentalMode.ForceDoubleSharp,
+            spelling,
+            false,
+            null
+        );
+        expect(accidental).to.equal(AccidentalType.DoubleSharp);
+    });
+
+    it('forces double flat spelling when requested', () => {
+        const ks = KeySignature.C;
+        const noteValue = 62; // D
+        const spelling = ModelUtils.resolveSpelling(ks, noteValue, NoteAccidentalMode.ForceDoubleFlat);
+        expect(spelling.degree).to.equal(2); // E
+        expect(spelling.accidentalOffset).to.equal(-2); // Ebb
+        const accidental = ModelUtils.computeAccidentalForSpelling(
+            ks,
+            NoteAccidentalMode.ForceDoubleFlat,
+            spelling,
+            false,
+            null
+        );
+        expect(accidental).to.equal(AccidentalType.DoubleFlat);
+    });
+});
diff --git a/packages/alphatab/test/model/AccidentalResolutionTests.test.ts b/packages/alphatab/test/model/AccidentalResolutionTests.test.ts
@@ -0,0 +1,129 @@
+import { AccidentalType } from '@coderline/alphatab/model/AccidentalType';
+import { KeySignature } from '@coderline/alphatab/model/KeySignature';
+import { ModelUtils } from '@coderline/alphatab/model/ModelUtils';
+import { NoteAccidentalMode } from '@coderline/alphatab/model/NoteAccidentalMode';
+import { expect } from 'chai';
+
+describe('AccidentalResolutionTests', () => {
+    const degreeSemitones = [0, 2, 4, 5, 7, 9, 11];
+
+    function noteValueForDegree(keySignature: KeySignature, degree: number, octave: number): number {
+        const ksOffset = ModelUtils.getKeySignatureAccidentalOffset(keySignature, degree);
+        const baseSemitone = degreeSemitones[degree] + ksOffset;
+        return (octave + 1) * 12 + baseSemitone;
+    }
+
+    const allKeySignatures: KeySignature[] = [
+        KeySignature.Cb,
+        KeySignature.Gb,
+        KeySignature.Db,
+        KeySignature.Ab,
+        KeySignature.Eb,
+        KeySignature.Bb,
+        KeySignature.F,
+        KeySignature.C,
+        KeySignature.G,
+        KeySignature.D,
+        KeySignature.A,
+        KeySignature.E,
+        KeySignature.B,
+        KeySignature.FSharp,
+        KeySignature.CSharp
+    ];
+
+    it('diatonic notes require no accidental in each key signature', () => {
+        for (const ks of allKeySignatures) {
+            for (let degree = 0; degree < 7; degree++) {
+                const noteValue = noteValueForDegree(ks, degree, 4);
+                const spelling = ModelUtils.resolveSpelling(ks, noteValue, NoteAccidentalMode.Default);
+                expect(spelling.degree, `ks=${ks} degree=${degree}`).to.equal(degree);
+                expect(spelling.accidentalOffset, `ks=${ks} degree=${degree}`).to.equal(
+                    ModelUtils.getKeySignatureAccidentalOffset(ks, degree)
+                );
+
+                const accidental = ModelUtils.computeAccidentalForSpelling(
+                    ks,
+                    NoteAccidentalMode.Default,
+                    spelling,
+                    false,
+                    null
+                );
+                expect(accidental, `ks=${ks} degree=${degree}`).to.equal(AccidentalType.None);
+            }
+        }
+    });
+
+    it('spells E# in F# major for pitch F natural', () => {
+        const ks = KeySignature.FSharp;
+        const noteValue = 65; // F natural
+        const spelling = ModelUtils.resolveSpelling(ks, noteValue, NoteAccidentalMode.Default);
+        expect(spelling.degree).to.equal(2); // E
+        expect(spelling.accidentalOffset).to.equal(1); // E#
+        const accidental = ModelUtils.computeAccidentalForSpelling(ks, NoteAccidentalMode.Default, spelling, false, null);
+        expect(accidental).to.equal(AccidentalType.None);
+    });
+
+    it('spells Cb in Cb major for pitch B natural', () => {
+        const ks = KeySignature.Cb;
+        const noteValue = 59; // B natural
+        const spelling = ModelUtils.resolveSpelling(ks, noteValue, NoteAccidentalMode.Default);
+        expect(spelling.degree).to.equal(0); // C
+        expect(spelling.accidentalOffset).to.equal(-1); // Cb
+        const accidental = ModelUtils.computeAccidentalForSpelling(ks, NoteAccidentalMode.Default, spelling, false, null);
+        expect(accidental).to.equal(AccidentalType.None);
+    });
+
+    it('forces flat spelling preference when requested', () => {
+        const ks = KeySignature.C;
+        const noteValue = 61; // C# / Db
+        const spelling = ModelUtils.resolveSpelling(ks, noteValue, NoteAccidentalMode.ForceFlat);
+        expect(spelling.degree).to.equal(1); // D
+        expect(spelling.accidentalOffset).to.equal(-1); // Db
+        const accidental = ModelUtils.computeAccidentalForSpelling(ks, NoteAccidentalMode.ForceFlat, spelling, false, null);
+        expect(accidental).to.equal(AccidentalType.Flat);
+    });
+
+    it('forces sharp spelling preference when requested', () => {
+        const ks = KeySignature.C;
+        const noteValue = 61; // C# / Db
+        const spelling = ModelUtils.resolveSpelling(ks, noteValue, NoteAccidentalMode.ForceSharp);
+        expect(spelling.degree).to.equal(0); // C
+        expect(spelling.accidentalOffset).to.equal(1); // C#
+        const accidental = ModelUtils.computeAccidentalForSpelling(ks, NoteAccidentalMode.ForceSharp, spelling, false, null);
+        expect(accidental).to.equal(AccidentalType.Sharp);
+    });
+
+    it('force natural displays a natural accidental when key signature would otherwise apply one', () => {
+        const ks = KeySignature.D; // F#, C#
+        const noteValue = 65; // F natural
+        const spelling = ModelUtils.resolveSpelling(ks, noteValue, NoteAccidentalMode.ForceNatural);
+        expect(spelling.degree).to.equal(3); // F
+        expect(spelling.accidentalOffset).to.equal(0); // natural
+        const accidental = ModelUtils.computeAccidentalForSpelling(ks, NoteAccidentalMode.ForceNatural, spelling, false, null);
+        expect(accidental).to.equal(AccidentalType.Natural);
+    });
+
+    it('force none suppresses accidentals regardless of spelling', () => {
+        const ks = KeySignature.C;
+        const noteValue = 61; // C#
+        const spelling = ModelUtils.resolveSpelling(ks, noteValue, NoteAccidentalMode.ForceNone);
+        const accidental = ModelUtils.computeAccidentalForSpelling(ks, NoteAccidentalMode.ForceNone, spelling, false, null);
+        expect(accidental).to.equal(AccidentalType.None);
+    });
+
+    it('no accidental when current accidental already matches', () => {
+        const ks = KeySignature.C;
+        const noteValue = 61; // C#
+        const spelling = ModelUtils.resolveSpelling(ks, noteValue, NoteAccidentalMode.Default);
+        const accidental = ModelUtils.computeAccidentalForSpelling(ks, NoteAccidentalMode.Default, spelling, false, 1);
+        expect(accidental).to.equal(AccidentalType.None);
+    });
+
+    it('quarter tone accidentals are chosen when quarter bend is true', () => {
+        const ks = KeySignature.C;
+        const noteValue = 61; // C# -> requires sharp
+        const spelling = ModelUtils.resolveSpelling(ks, noteValue, NoteAccidentalMode.Default);
+        const accidental = ModelUtils.computeAccidentalForSpelling(ks, NoteAccidentalMode.Default, spelling, true, null);
+        expect(accidental).to.equal(AccidentalType.SharpQuarterNoteUp);
+    });
+});
diff --git a/packages/alphatab/test/model/KeySignatureUtils.test.ts b/packages/alphatab/test/model/KeySignatureUtils.test.ts
@@ -0,0 +1,41 @@
+import { KeySignature } from '@coderline/alphatab/model/KeySignature';
+import { KeySignatureType } from '@coderline/alphatab/model/KeySignatureType';
+import { ModelUtils } from '@coderline/alphatab/model/ModelUtils';
+import { expect } from 'chai';
+
+describe('KeySignatureUtilsTests', () => {
+    it('sharp key signatures apply accidentals in F C G D A E B order', () => {
+        const ksG = KeySignature.G; // 1 sharp -> F#
+        expect(ModelUtils.getKeySignatureAccidentalOffset(ksG, 3)).to.equal(1); // F
+        expect(ModelUtils.getKeySignatureAccidentalOffset(ksG, 0)).to.equal(0); // C
+        expect(ModelUtils.getKeySignatureAccidentalOffset(ksG, 6)).to.equal(0); // B
+
+        const ksD = KeySignature.D; // 2 sharps -> F#, C#
+        expect(ModelUtils.getKeySignatureAccidentalOffset(ksD, 3)).to.equal(1); // F
+        expect(ModelUtils.getKeySignatureAccidentalOffset(ksD, 0)).to.equal(1); // C
+        expect(ModelUtils.getKeySignatureAccidentalOffset(ksD, 4)).to.equal(0); // G
+    });
+
+    it('flat key signatures apply accidentals in B E A D G C F order', () => {
+        const ksF = KeySignature.F; // 1 flat -> Bb
+        expect(ModelUtils.getKeySignatureAccidentalOffset(ksF, 6)).to.equal(-1); // B
+        expect(ModelUtils.getKeySignatureAccidentalOffset(ksF, 2)).to.equal(0); // E
+
+        const ksBb = KeySignature.Bb; // 2 flats -> Bb, Eb
+        expect(ModelUtils.getKeySignatureAccidentalOffset(ksBb, 6)).to.equal(-1); // B
+        expect(ModelUtils.getKeySignatureAccidentalOffset(ksBb, 2)).to.equal(-1); // E
+        expect(ModelUtils.getKeySignatureAccidentalOffset(ksBb, 5)).to.equal(0); // A
+    });
+
+    it('major tonic degree matches expected scale degree', () => {
+        expect(ModelUtils.getKeySignatureTonicDegree(KeySignature.C, KeySignatureType.Major)).to.equal(0); // C
+        expect(ModelUtils.getKeySignatureTonicDegree(KeySignature.G, KeySignatureType.Major)).to.equal(4); // G
+        expect(ModelUtils.getKeySignatureTonicDegree(KeySignature.Eb, KeySignatureType.Major)).to.equal(2); // Eb
+    });
+
+    it('minor tonic degree matches expected scale degree', () => {
+        expect(ModelUtils.getKeySignatureTonicDegree(KeySignature.C, KeySignatureType.Minor)).to.equal(5); // A
+        expect(ModelUtils.getKeySignatureTonicDegree(KeySignature.G, KeySignatureType.Minor)).to.equal(2); // E
+        expect(ModelUtils.getKeySignatureTonicDegree(KeySignature.Bb, KeySignatureType.Minor)).to.equal(4); // G (relative minor)
+    });
+});
diff --git a/packages/alphatab/test/model/NoteSteps.test.ts b/packages/alphatab/test/model/NoteSteps.test.ts
@@ -0,0 +1,44 @@
+import { Clef } from '@coderline/alphatab/model/Clef';
+import { KeySignature } from '@coderline/alphatab/model/KeySignature';
+import { ModelUtils } from '@coderline/alphatab/model/ModelUtils';
+import { NoteAccidentalMode } from '@coderline/alphatab/model/NoteAccidentalMode';
+import { AccidentalHelper } from '@coderline/alphatab/rendering/utils/AccidentalHelper';
+import { expect } from 'chai';
+
+describe('NoteStepsTests', () => {
+    it('calculates known steps for C4 in G2 and F4 clef', () => {
+        const spelling = ModelUtils.resolveSpelling(KeySignature.C, 60, NoteAccidentalMode.Default); // C4
+        const stepsG2 = AccidentalHelper.calculateNoteSteps(Clef.G2, spelling);
+        const stepsF4 = AccidentalHelper.calculateNoteSteps(Clef.F4, spelling);
+
+        expect(stepsG2).to.equal(10);
+        expect(stepsF4).to.equal(-2);
+    });
+
+    it('octave shift changes steps by 7', () => {
+        const spellingC4 = ModelUtils.resolveSpelling(KeySignature.C, 60, NoteAccidentalMode.Default); // C4
+        const spellingC5 = ModelUtils.resolveSpelling(KeySignature.C, 72, NoteAccidentalMode.Default); // C5
+        const stepsC4 = AccidentalHelper.calculateNoteSteps(Clef.G2, spellingC4);
+        const stepsC5 = AccidentalHelper.calculateNoteSteps(Clef.G2, spellingC5);
+        expect(stepsC4 - stepsC5).to.equal(7);
+    });
+
+    it('adjacent diatonic degrees differ by one step', () => {
+        const spellingC4 = ModelUtils.resolveSpelling(KeySignature.C, 60, NoteAccidentalMode.Default); // C4
+        const spellingD4 = ModelUtils.resolveSpelling(KeySignature.C, 62, NoteAccidentalMode.Default); // D4
+        const stepsC4 = AccidentalHelper.calculateNoteSteps(Clef.G2, spellingC4);
+        const stepsD4 = AccidentalHelper.calculateNoteSteps(Clef.G2, spellingD4);
+        expect(stepsC4 - stepsD4).to.equal(1);
+    });
+
+    it('same pitch with different spelling yields different steps', () => {
+        const noteValue = 61; // C# / Db
+        const spellingSharp = ModelUtils.resolveSpelling(KeySignature.C, noteValue, NoteAccidentalMode.ForceSharp);
+        const spellingFlat = ModelUtils.resolveSpelling(KeySignature.C, noteValue, NoteAccidentalMode.ForceFlat);
+
+        const stepsSharp = AccidentalHelper.calculateNoteSteps(Clef.G2, spellingSharp);
+        const stepsFlat = AccidentalHelper.calculateNoteSteps(Clef.G2, spellingFlat);
+
+        expect(stepsSharp - stepsFlat).to.equal(1); // C# (degree 0) above Db (degree 1)
+    });
+});
diff --git a/packages/alphatab/test/model/NoteStepsAdditional.test.ts b/packages/alphatab/test/model/NoteStepsAdditional.test.ts
@@ -0,0 +1,26 @@
+import { Clef } from '@coderline/alphatab/model/Clef';
+import { KeySignature } from '@coderline/alphatab/model/KeySignature';
+import { ModelUtils } from '@coderline/alphatab/model/ModelUtils';
+import { NoteAccidentalMode } from '@coderline/alphatab/model/NoteAccidentalMode';
+import { AccidentalHelper } from '@coderline/alphatab/rendering/utils/AccidentalHelper';
+import { expect } from 'chai';
+
+describe('NoteStepsAdditionalTests', () => {
+    it('same pitch yields different steps across clefs', () => {
+        const spelling = ModelUtils.resolveSpelling(KeySignature.C, 60, NoteAccidentalMode.Default); // C4
+        const stepsG2 = AccidentalHelper.calculateNoteSteps(Clef.G2, spelling);
+        const stepsC4 = AccidentalHelper.calculateNoteSteps(Clef.C4, spelling);
+        expect(stepsG2 - stepsC4).to.equal(8);
+    });
+
+    it('enharmonic spelling changes steps (C# vs Db)', () => {
+        const noteValue = 61; // C#/Db
+        const spellingSharp = ModelUtils.resolveSpelling(KeySignature.C, noteValue, NoteAccidentalMode.ForceSharp);
+        const spellingFlat = ModelUtils.resolveSpelling(KeySignature.C, noteValue, NoteAccidentalMode.ForceFlat);
+
+        const stepsSharp = AccidentalHelper.calculateNoteSteps(Clef.G2, spellingSharp);
+        const stepsFlat = AccidentalHelper.calculateNoteSteps(Clef.G2, spellingFlat);
+
+        expect(stepsSharp - stepsFlat).to.equal(1);
+    });
+});
diff --git a/packages/alphatab/test/model/QuarterToneAccidentals.test.ts b/packages/alphatab/test/model/QuarterToneAccidentals.test.ts
diff --git a/packages/transpiler/src/csharp/CSharpAstTransformer.ts b/packages/transpiler/src/csharp/CSharpAstTransformer.ts
