Added split-tests for notation legend

src.compiler/csharp/CSharpAstTransformer.ts

@@ -495,6 +495,8 @@ export default class CSharpAstTransformer {
                 }
             } else if (ts.isVariableStatement(s)) {
                 this.visitTestClassProperty(csClass, s);
+            } else if (ts.isFunctionDeclaration(s)) {
+                this.visitTestClassMethod(csClass, s);
             } else {
                 this._context.addTsNodeDiagnostics(
                     s,
@@ -507,6 +509,40 @@ export default class CSharpAstTransformer {
         this._csharpFile.namespace.declarations.push(csClass);
     }
 
+    private visitTestClassMethod(parent: cs.ClassDeclaration, d: ts.FunctionDeclaration) {
+        const signature = this._context.typeChecker.getSignatureFromDeclaration(d);
+        const returnType = this._context.typeChecker.getReturnTypeOfSignature(signature!);
+
+        const csMethod: cs.MethodDeclaration = {
+            parent: parent,
+            nodeType: cs.SyntaxKind.MethodDeclaration,
+            isAbstract: false,
+            isOverride: false,
+            isStatic: false,
+            isVirtual: false,
+            name: this._context.toPascalCase((d.name as ts.Identifier).text),
+            parameters: [],
+            returnType: this.createUnresolvedTypeNode(null, d.type ?? d, returnType),
+            visibility: this.mapVisibility(d.modifiers),
+            tsNode: d,
+            skipEmit: this.shouldSkip(d)
+        };
+        csMethod.isAsync =
+            !!d.modifiers &&
+            !!d.modifiers.find(m => m.kind === ts.SyntaxKind.AsyncKeyword);
+
+        const type = this._context.typeChecker.getTypeAtLocation(d.name!);
+        csMethod.returnType.parent = csMethod;
+
+        d.parameters.forEach(p => csMethod.parameters.push(this.makeParameter(csMethod, p)));
+        this._declarationOrAssignmentTypeStack.push(type);
+        csMethod.body = this.visitBlock(csMethod, d.body as ts.Block);
+        this._declarationOrAssignmentTypeStack.pop();
+
+        parent.members.push(csMethod);
+        this._context.registerSymbol(csMethod);
+    }
+
     private visitTestMethod(parent: cs.ClassDeclaration, d: ts.CallExpression) {
         const csMethod: cs.MethodDeclaration = {
             parent: parent,

test/visualTests/VisualTestHelper.ts

@@ -73,7 +73,13 @@ export class VisualTestHelper {
             settings.core.engine = 'html5';
             settings.core.enableLazyLoading = false;
 
-            const referenceFileData = await TestPlatform.loadFile(`test-data/visual-tests/${referenceFileName}`);
+            let referenceFileData: Uint8Array;
+            try {
+                referenceFileData = await TestPlatform.loadFile(`test-data/visual-tests/${referenceFileName}`);
+            }
+            catch (e) {
+                referenceFileData = new Uint8Array(0);
+            }
 
             const renderElement = document.createElement('div');
             renderElement.style.width = '1300px';
@@ -153,22 +159,31 @@ export class VisualTestHelper {
         className: string
     ): Promise<HTMLCanvasElement> {
         return new Promise<HTMLCanvasElement>((resolve, reject) => {
-            const img = new Image();
-            img.src = 'data:image/png;base64,' + btoa(data.reduce((p, d) => p + String.fromCharCode(d), ''));
-            img.onload = function () {
+            if (data.length === 0) {
                 const canvas = document.createElement('canvas');
                 canvas.classList.add(className);
-                canvas.width = img.naturalWidth;
-                canvas.height = img.naturalHeight;
+                canvas.width = 1;
+                canvas.height = 1;
                 canvas.dataset.filename = filename.split('/').slice(-1)[0];
-                const context = canvas.getContext('2d')!;
-                context.drawImage(img, 0, 0);
-
                 resolve(canvas);
-            };
-            img.onerror = function (e) {
-                reject(e);
-            };
+            } else {
+                const img = new Image();
+                img.src = 'data:image/png;base64,' + btoa(data.reduce((p, d) => p + String.fromCharCode(d), ''));
+                img.onload = function () {
+                    const canvas = document.createElement('canvas');
+                    canvas.classList.add(className);
+                    canvas.width = img.naturalWidth;
+                    canvas.height = img.naturalHeight;
+                    canvas.dataset.filename = filename.split('/').slice(-1)[0];
+                    const context = canvas.getContext('2d')!;
+                    context.drawImage(img, 0, 0);
+
+                    resolve(canvas);
+                };
+                img.onerror = function (e) {
+                    reject(e);
+                };
+            }
         });
     }
 
@@ -316,7 +331,7 @@ export class VisualTestHelper {
                     if (!result.pass) {
                         let percentDifferenceText = percentDifference.toFixed(2);
                         result.message = `Difference between original and new image is too big: ${match.differentPixels}/${totalPixels} (${percentDifferenceText}%)`;
-                        await VisualTestHelper.saveFiles(expectedFileName, expected, actual, diff);
+                        await VisualTestHelper.saveFiles(expectedFileName, expected, oldActual, diff);
                     } else if (sizeMismatch) {
                         result.message = `Image sizes do not match: ${expected.width}/${expected.height} vs ${oldActual.width}/${oldActual.height}`;
                         result.pass = false;
@@ -427,13 +442,13 @@ export class VisualTestHelper {
         diffToggleLabel.style.position = "absolute";
         diffToggleLabel.style.left = "0";
         diffToggleLabel.style.bottom = "0";
-        
+
         const diffToggle = document.createElement('input');
         diffToggle.type = 'checkbox';
         diffToggleLabel.appendChild(diffToggle);
         diffToggleLabel.appendChild(document.createTextNode('Show Diff'));
-        diffToggle.onchange = ()=> {
-            if(diffToggle.checked) {
+        diffToggle.onchange = () => {
+            if (diffToggle.checked) {
                 df.style.display = 'block';
             } else {
                 df.style.display = 'none';
@@ -464,7 +479,7 @@ export class VisualTestHelper {
             const data = new FormData();
             data.append('name', name);
             data.append('expected', expectedData, VisualTestHelper.createFileName(name, 'expected'));
-            data.append('actual', actualData, VisualTestHelper.createFileName(name, 'actual'));
+            data.append('actual', actualData, VisualTestHelper.createFileName(name, ''));
             data.append('diff', diffData, VisualTestHelper.createFileName(name, 'diff'));
             x.send(data);
         });
@@ -489,11 +504,15 @@ export class VisualTestHelper {
             oldName = oldName.substr(i + 1);
         }
 
+        if(part.length > 0) {
+            part = `-${part}`;
+        }
+
         i = oldName.lastIndexOf('.');
         if (i >= 0) {
-            oldName = oldName.substr(0, i) + '-' + part + oldName.substr(i);
+            oldName = oldName.substr(0, i) + part + oldName.substr(i);
         } else {
-            oldName += '-' + part;
+            oldName += part;
         }
         return oldName;
     }

test/visualTests/features/EffectsAndAnnotations.test.ts

@@ -2,86 +2,86 @@ import { VisualTestHelper } from '@test/visualTests/VisualTestHelper';
 
 describe('EffectsAndAnnotationsTests', () => {
     it('markers', async () => {
-        await VisualTestHelper.runVisualTest('features/effects-and-annotations/markers.gp5');
+        await VisualTestHelper.runVisualTest('effects-and-annotations/markers.gp5');
     });
 
     it('tempo', async () => {
-        await VisualTestHelper.runVisualTest('features/effects-and-annotations/tempo.gp5');
+        await VisualTestHelper.runVisualTest('effects-and-annotations/tempo.gp5');
     });
 
     it('text', async () => {
-        await VisualTestHelper.runVisualTest('features/effects-and-annotations/text.gp5');
+        await VisualTestHelper.runVisualTest('effects-and-annotations/text.gp5');
     });
 
     it('chords', async () => {
-        await VisualTestHelper.runVisualTest('features/effects-and-annotations/chords.gp5');
+        await VisualTestHelper.runVisualTest('effects-and-annotations/chords.gp5');
     });
 
     it('vibrato', async () => {
-        await VisualTestHelper.runVisualTest('features/effects-and-annotations/vibrato.gp5');
+        await VisualTestHelper.runVisualTest('effects-and-annotations/vibrato.gp5');
     });
 
     it('dynamics', async () => {
-        await VisualTestHelper.runVisualTest('features/effects-and-annotations/dynamics.gp5');
+        await VisualTestHelper.runVisualTest('effects-and-annotations/dynamics.gp5');
     });
 
     it('tap', async () => {
-        await VisualTestHelper.runVisualTest('features/effects-and-annotations/tap.gp5');
+        await VisualTestHelper.runVisualTest('effects-and-annotations/tap.gp5');
     });
 
     it('fade-in', async () => {
-        await VisualTestHelper.runVisualTest('features/effects-and-annotations/fade-in.gp5');
+        await VisualTestHelper.runVisualTest('effects-and-annotations/fade-in.gp5');
     });
 
     it('let-ring', async () => {
-        await VisualTestHelper.runVisualTest('features/effects-and-annotations/let-ring.gp5');
+        await VisualTestHelper.runVisualTest('effects-and-annotations/let-ring.gp5');
     });
 
     it('palm-mute', async () => {
-        await VisualTestHelper.runVisualTest('features/effects-and-annotations/palm-mute.gp5');
+        await VisualTestHelper.runVisualTest('effects-and-annotations/palm-mute.gp5');
     });
 
     it('bends', async () => {
-        await VisualTestHelper.runVisualTest('features/effects-and-annotations/bends.gp');
+        await VisualTestHelper.runVisualTest('effects-and-annotations/bends.gp');
     });
 
     it('tremolo-bar', async () => {
-        await VisualTestHelper.runVisualTest('features/effects-and-annotations/tremolo-bar.gp');
+        await VisualTestHelper.runVisualTest('effects-and-annotations/tremolo-bar.gp');
     });
 
     it('tremolo-picking', async () => {
-        await VisualTestHelper.runVisualTest('features/effects-and-annotations/tremolo-picking.gp5');
+        await VisualTestHelper.runVisualTest('effects-and-annotations/tremolo-picking.gp5');
     });
 
     it('brush', async () => {
-        await VisualTestHelper.runVisualTest('features/effects-and-annotations/brush.gp5');
+        await VisualTestHelper.runVisualTest('effects-and-annotations/brush.gp5');
     });
 
     it('slides', async () => {
-        await VisualTestHelper.runVisualTest('features/effects-and-annotations/slides.gp5');
+        await VisualTestHelper.runVisualTest('effects-and-annotations/slides.gp5');
     });
 
     it('trill', async () => {
-        await VisualTestHelper.runVisualTest('features/effects-and-annotations/trill.gp5');
+        await VisualTestHelper.runVisualTest('effects-and-annotations/trill.gp5');
     });
 
     it('pickStroke', async () => {
-        await VisualTestHelper.runVisualTest('features/effects-and-annotations/pick-stroke.gp5');
+        await VisualTestHelper.runVisualTest('effects-and-annotations/pick-stroke.gp5');
     });
 
     it('tuplets', async () => {
-        await VisualTestHelper.runVisualTest('features/effects-and-annotations/tuplets.gp5');
+        await VisualTestHelper.runVisualTest('effects-and-annotations/tuplets.gp5');
     });
 
     it('tuplets-advanced', async () => {
-        await VisualTestHelper.runVisualTest('features/effects-and-annotations/tuplets-advanced.gp', undefined, [0,1,2]);
+        await VisualTestHelper.runVisualTest('effects-and-annotations/tuplets-advanced.gp', undefined, [0,1,2]);
     });
 
     it('fingering', async () => {
-        await VisualTestHelper.runVisualTest('features/effects-and-annotations/fingering.gpx');
+        await VisualTestHelper.runVisualTest('effects-and-annotations/fingering.gpx');
     });
 
     it('triplet-feel', async () => {
-        await VisualTestHelper.runVisualTest('features/effects-and-annotations/triplet-feel.gpx');
+        await VisualTestHelper.runVisualTest('effects-and-annotations/triplet-feel.gpx');
     });
 });

test/visualTests/features/General.test.ts

@@ -1,48 +1,25 @@
-import { StaveProfile, LayoutMode } from '@src/DisplaySettings';
+import { StaveProfile } from '@src/DisplaySettings';
 import { Settings } from '@src/Settings';
 import { VisualTestHelper } from '@test/visualTests/VisualTestHelper';
-import { TestPlatform } from '@test/TestPlatform';
-import { ScoreLoader } from '@src/importer/ScoreLoader';
-import { Score } from '@src/model/Score';
 
 describe('GeneralTests', () => {
     it('song-details', async () => {
-        await VisualTestHelper.runVisualTest('features/general/song-details.gp5');
+        await VisualTestHelper.runVisualTest('general/song-details.gp5');
     });
 
     it('repeats', async () => {
         let settings: Settings = new Settings();
         settings.display.staveProfile = StaveProfile.Score;
-        await VisualTestHelper.runVisualTest('features/general/repeats.gp5', settings);
+        await VisualTestHelper.runVisualTest('general/repeats.gp5', settings);
     });
 
     it('alternate-endings', async () => {
         let settings: Settings = new Settings();
         settings.display.staveProfile = StaveProfile.Score;
-        await VisualTestHelper.runVisualTest('features/general/alternate-endings.gp5', settings);
+        await VisualTestHelper.runVisualTest('general/alternate-endings.gp5', settings);
     });
 
     it('tuning', async () => {
-        await VisualTestHelper.runVisualTest('features/general/tuning.gp5');
-    });
-
-    it('notation-legend-default', async () => {
-        let settings: Settings = new Settings();
-        settings.display.layoutMode = LayoutMode.Horizontal;
-        const inputFileData = await TestPlatform.loadFile(`test-data/visual-tests/features/general/notation-legend.gp`);
-        const referenceFileName = `features/general/notation-legend-default.png`;
-        let score: Score = ScoreLoader.loadScoreFromBytes(inputFileData, settings);
-
-        await VisualTestHelper.runVisualTestScore(score, referenceFileName, settings, [0]);
-    });
-
-    it('notation-legend-songbook', async () => {
-        let settings: Settings = new Settings();
-        settings.display.layoutMode = LayoutMode.Horizontal;
-        settings.setSongBookModeSettings();
-        const inputFileData = await TestPlatform.loadFile(`test-data/visual-tests/features/general/notation-legend.gp`);
-        const referenceFileName = `features/general/notation-legend-songbook.png`;
-        let score: Score = ScoreLoader.loadScoreFromBytes(inputFileData, settings);
-        await VisualTestHelper.runVisualTestScore(score, referenceFileName, settings, [0]);
+        await VisualTestHelper.runVisualTest('general/tuning.gp5');
     });
 });

test/visualTests/features/GuitarTabs.test.ts

@@ -8,20 +8,20 @@ describe('GuitarTabsTests', () => {
         let settings: Settings = new Settings();
         settings.display.staveProfile = StaveProfile.Tab;
         settings.notation.rhythmMode = TabRhythmMode.ShowWithBars;
-        await VisualTestHelper.runVisualTest('features/guitar-tabs/rhythm.gp5', settings);
+        await VisualTestHelper.runVisualTest('guitar-tabs/rhythm.gp5', settings);
     });
 
     it('rhythm-with-beams', async () => {
         let settings: Settings = new Settings();
         settings.display.staveProfile = StaveProfile.Tab;
         settings.notation.rhythmMode = TabRhythmMode.ShowWithBeams;
-        await VisualTestHelper.runVisualTest('features/guitar-tabs/rhythm-with-beams.gp5', settings);
+        await VisualTestHelper.runVisualTest('guitar-tabs/rhythm-with-beams.gp5', settings);
     });
 
     it('string-variations', async () => {
         let settings: Settings = new Settings();
         settings.display.staveProfile = StaveProfile.Tab;
-        await VisualTestHelper.runVisualTest('features/guitar-tabs/string-variations.gp5', settings);
+        await VisualTestHelper.runVisualTest('guitar-tabs/string-variations.gp5', settings);
     });
 
 });

test/visualTests/features/Layout.test.ts

@@ -4,43 +4,43 @@ import { VisualTestHelper } from '@test/visualTests/VisualTestHelper';
 
 describe('LayoutTests', () => {
     it('pageLayout', async () => {
-        await VisualTestHelper.runVisualTest('features/layout/page-layout.gp5');
+        await VisualTestHelper.runVisualTest('layout/page-layout.gp5');
     });
 
     it('multi-track', async () => {
-        await VisualTestHelper.runVisualTest('features/layout/multi-track.gp5', undefined, [0, 3]);
+        await VisualTestHelper.runVisualTest('layout/multi-track.gp5', undefined, [0, 3]);
     });
 
     it('multi-voice', async () => {
-        await VisualTestHelper.runVisualTest('features/layout/multi-voice.gp5');
+        await VisualTestHelper.runVisualTest('layout/multi-voice.gp5');
     });
 
     it('page-layout-5barsperrow', async () => {
         let settings: Settings = new Settings();
         settings.display.layoutMode = LayoutMode.Page;
         settings.display.barsPerRow = 5;
-        await VisualTestHelper.runVisualTest('features/layout/page-layout-5barsperrow.gp5', settings);
+        await VisualTestHelper.runVisualTest('layout/page-layout-5barsperrow.gp5', settings);
     });
 
     it('page-layout-bar5to8', async () => {
         let settings: Settings = new Settings();
         settings.display.layoutMode = LayoutMode.Page;
         settings.display.startBar = 5;
         settings.display.barCount = 4;
-        await VisualTestHelper.runVisualTest('features/layout/page-layout-5to8.gp5', settings);
+        await VisualTestHelper.runVisualTest('layout/page-layout-5to8.gp5', settings);
     });
 
     it('horizontal-layout', async () => {
         let settings: Settings = new Settings();
         settings.display.layoutMode = LayoutMode.Horizontal;
-        await VisualTestHelper.runVisualTest('features/layout/horizontal-layout.gp5', settings);
+        await VisualTestHelper.runVisualTest('layout/horizontal-layout.gp5', settings);
     });
 
     it('horizontal-layout-bar5to8', async () => {
         let settings: Settings = new Settings();
         settings.display.layoutMode = LayoutMode.Horizontal;
         settings.display.startBar = 5;
         settings.display.barCount = 4;
-        await VisualTestHelper.runVisualTest('features/layout/horizontal-layout-5to8.gp5', settings);
+        await VisualTestHelper.runVisualTest('layout/horizontal-layout-5to8.gp5', settings);
     });
 });