Merge branch 'topic/fix_tests_windows' into 'master'

Fix GNATtest integration and testing on Windows

See merge request eng/ide/ada_language_server!1369

Author: eliericha

Makefile

@@ -10,12 +10,21 @@ BUILD_DATE ?=
 # Location of home dir for tests
 export ALS_HOME=$(ROOTDIR)/testsuite
 
+# Exectuable extension
+ifeq ($(OS),)
+  # Not Windows
+  EXE=""
+else
+  # Windows
+  EXE=.exe
+endif
+
 # Command to run for tests
-export ALS=$(ROOTDIR)/.obj/server/ada_language_server
+export ALS=$(ROOTDIR)/.obj/server/ada_language_server$(EXE)
 
 # Tester files
-TESTER=$(ROOTDIR)/.obj/tester/tester-run
-CODEC_TEST=.obj/codec_test/codec_test
+TESTER=$(ROOTDIR)/.obj/tester/tester-run$(EXE)
+CODEC_TEST=.obj/codec_test/codec_test$(EXE)
 
 # Env variable to set for update VS Code test references
 MOCHA_ALS_UPDATE=
@@ -156,7 +165,6 @@ endif
 
 vscode-test:
 	# Run the VS Code integration testsuite.
-	echo $(GPR_PROJECT_PATH)
 	MOCHA_ALS_UPDATE=$(MOCHA_ALS_UPDATE) cd integration/vscode/ada; LD_LIBRARY_PATH= npm run test
 
 vscode-package:

integration/vscode/ada/package.json

@@ -635,14 +635,14 @@
         "vscode-tmgrammar-test": "0.1.1"
     },
     "scripts": {
-        "check-licenses": "npx license-checker-rseidelsohn --summary --onlyAllow '0BSD;Apache-2.0;BSD-2-Clause;BSD-3-Clause;BlueOak-1.0.0;CC0-1.0;GPL-3.0;GPL-3.0-or-later;ISC;MIT;Python-2.0;Zlib'",
+        "check-licenses": "npx license-checker-rseidelsohn --summary --onlyAllow \"0BSD;Apache-2.0;BSD-2-Clause;BSD-3-Clause;BlueOak-1.0.0;CC0-1.0;GPL-3.0;GPL-3.0-or-later;ISC;MIT;Python-2.0;Zlib\"",
         "vscode:prepublish": "npm run esbuild-base -- --minify",
         "esbuild-base": "esbuild ./src/extension.ts --bundle --outfile=out/src/extension.js --external:vscode --format=cjs --platform=node",
         "compile": "node ./node_modules/typescript/bin/tsc",
         "watch": "node ./node_modules/typescript/bin/tsc -watch",
         "pretest": "npm run compile",
-        "lint": "eslint './src/**/*.{js,ts,tsx}' --quiet --fix",
-        "cilint": "eslint './src/**/*.{js,ts,tsx}'",
+        "lint": "eslint \"./src/**/*.{js,ts,tsx}\" --quiet --fix",
+        "cilint": "eslint \"./src/**/*.{js,ts,tsx}\"",
         "test": "node ./out/test/runTest.js"
     },
     "dependencies": {

integration/vscode/ada/src/gnattest.ts

@@ -78,8 +78,8 @@ export async function initializeTestView(
 */
 function startTestRun(
     controller: vscode.TestController,
-    projectFile: string,
-    gnattestPath: string
+    projectFileFullPath: string,
+    gnattestFullPath: string
 ) {
     // terminal ID to seperate between each run
     let terminal_id = 0;
@@ -91,12 +91,12 @@ function startTestRun(
             const tests = gatherChildTestItems(controller.items);
             const terminal_name = 'Test_terminal_' + terminal_id.toString();
             // Run all tests handler
-            handleRunAll(tests, run, terminal_name, gnattestPath);
+            handleRunAll(tests, run, terminal_name, gnattestFullPath);
             terminal_id++;
             // Parse the results when the terminal is closed
             vscode.window.onDidCloseTerminal(async (terminal) => {
                 if (terminal.name == terminal_name) {
-                    const file = await readResultFile(path.join(gnattestPath, 'result.txt'));
+                    const file = await readResultFile(path.join(gnattestFullPath, 'result.txt'));
                     if (file != undefined) {
                         parseResults(tests, run, file);
                     }
@@ -110,12 +110,12 @@ function startTestRun(
             // create a temporary terminal to execute the command lines then close it.
             const terminalName = 'Test_terminal_' + terminal_id.toString();
             // test unit run handler
-            handleUnitRun(tests, run, terminalName, gnattestPath);
+            handleUnitRun(tests, run, terminalName, gnattestFullPath);
             terminal_id++;
             // Parse the results when the terminal is closed
             vscode.window.onDidCloseTerminal(async (terminal) => {
                 if (terminal.name == terminalName) {
-                    const file = await readResultFile(path.join(gnattestPath, 'result.txt'));
+                    const file = await readResultFile(path.join(gnattestFullPath, 'result.txt'));
                     if (file != undefined) {
                         parseResults(tests, run, file);
                     }
@@ -135,15 +135,15 @@ function startTestRun(
     // Tests Configuration Handler to Generates Tests for a Project.
     testRunProfile.configureHandler = () => {
         const terminal = vscode.window.createTerminal('Test Terminal');
-        terminal.sendText('gnattest -P ' + projectFile);
+        terminal.sendText('gnattest -P ' + projectFileFullPath);
         terminal.sendText('exit');
     };
     // Refresh Button to re discover the tests on the project.
     controller.refreshHandler = async () => {
         controller.items.forEach((item) => {
             controller.items.delete(item.id);
         });
-        await discoverTests(controller, gnattestPath);
+        await discoverTests(controller, gnattestFullPath);
     };
 }
 
@@ -240,7 +240,7 @@ export function getParentTestSourceName(item: vscode.TestItem) {
 */
 export async function readResultFile(resultPath: string) {
     if (vscode.workspace.workspaceFolders !== undefined) {
-        if (pathExists(resultPath)) {
+        if (pathIsReadable(resultPath)) {
             const file = await vscode.workspace.fs.readFile(vscode.Uri.file(resultPath));
             return file.toString();
         }
@@ -293,14 +293,12 @@ export function parseResults(
 /*
     Return the tests structure stored in gnattest.xml file
 */
-export async function readXMLfile(harnessPath: string): Promise<string | undefined> {
+export async function readXMLfile(harnessFullPath: string): Promise<string | undefined> {
     if (vscode.workspace.workspaceFolders !== undefined) {
-        const mainPath = vscode.workspace.workspaceFolders[0].uri.path;
-        const fullHarnessPath = path.join(mainPath, harnessPath);
         let file;
-        if (pathExists(fullHarnessPath)) {
+        if (pathIsReadable(harnessFullPath)) {
             file = await vscode.workspace.fs.readFile(
-                vscode.Uri.file(path.join(fullHarnessPath, 'gnattest.xml'))
+                vscode.Uri.file(path.join(harnessFullPath, 'gnattest.xml'))
             );
         }
         return file?.toString().replace(/>\s+</g, '><').trim();
@@ -311,10 +309,10 @@ export async function readXMLfile(harnessPath: string): Promise<string | undefin
 /*
     Discover tests by parsing the xml input
 */
-export async function discoverTests(controller: vscode.TestController, gnattestPath: string) {
+export async function discoverTests(controller: vscode.TestController, gnattestFullPath: string) {
     if (vscode.workspace.workspaceFolders !== undefined) {
-        const mainPath = vscode.workspace.workspaceFolders[0].uri.path;
-        const file = await readXMLfile(path.join(gnattestPath, 'harness'));
+        const mainPath = vscode.workspace.workspaceFolders[0].uri.fsPath;
+        const file = await readXMLfile(path.join(gnattestFullPath, 'harness'));
         const options = {
             ignoreAttributes: false,
             attributeNamePrefix: '@_',
@@ -423,10 +421,11 @@ function findFile(name: string, directory: string): string {
     return '';
 }
 
-/*
-    Checking if a path/file exists
-*/
-export function pathExists(p: string): boolean {
+/**
+ * @param p - path to file or directory
+ * @returns true if the path exists and access rights allow reading it, otherwise false
+ */
+export function pathIsReadable(p: string): boolean {
     try {
         fs.accessSync(p);
     } catch (err) {

integration/vscode/ada/src/helpers.ts

@@ -205,15 +205,8 @@ type ExecutablesResponse = {
  * @returns a string contains the path of the project file
  */
 export async function getProjectFile(client: LanguageClient): Promise<string> {
-    const configValue: string | undefined = vscode.workspace
-        .getConfiguration('ada')
-        .get('projectFile');
-    if (configValue != undefined && configValue != '') {
-        return configValue;
-    } else {
-        const result: ProjectFileResponse = await client.sendRequest('$/glsProjectFile');
-        return result.projectFile;
-    }
+    const result: ProjectFileResponse = await client.sendRequest('$/glsProjectFile');
+    return result.projectFile;
 }
 
 /**

integration/vscode/ada/test/suite/general/tasks.test.ts

@@ -1,5 +1,6 @@
 import * as vscode from 'vscode';
 import * as assert from 'assert';
+import * as path from 'path';
 import { suite, test } from 'mocha';
 import { contextClients } from '../../../src/extension';
 import { activate } from '../utils';
@@ -43,15 +44,19 @@ suite('GPR Tasks Provider', function () {
     test('Tasks resolving', async () => {
         const prov = new GprTaskProvider(contextClients.adaClient);
         const task = new vscode.Task(
-            { type: 'gpr', main: 'src/program.adb' },
+            { type: 'gpr', main: path.join('src', 'program.adb') },
             'build main',
             'tasks'
         );
         const workspace = vscode.workspace.workspaceFolders?.at(0)?.uri.fsPath;
         if (workspace == undefined) {
             throw new Error('No workspace found');
         }
-        const expectedCmd = `gprbuild -d -P ${workspace}/default.gpr src/program.adb `;
+        const expectedCmd =
+            'gprbuild -d -P ' +
+            path.join(workspace, 'default.gpr') +
+            ' ' +
+            path.join('src', 'program.adb ');
         const resolved = await prov.resolveTask(task);
         assert.notStrictEqual(resolved, undefined);
         if (resolved != undefined && resolved.execution) {

integration/vscode/ada/test/suite/gnattest/gnattest.test.ts

@@ -5,7 +5,7 @@ import * as cp from 'child_process';
 import { suite, test } from 'mocha';
 import * as gnattest from '../../../src/gnattest';
 import { contextClients } from '../../../src/extension';
-import { getProjectFile } from '../../../src/helpers';
+import { getObjectDir, getProjectFile } from '../../../src/helpers';
 import { activate, assertEqualToFileContent } from '../utils';
 
 suite('GNATtest Integration Tests', function () {
@@ -14,20 +14,14 @@ suite('GNATtest Integration Tests', function () {
     });
     test('Generate Tests', async () => {
         await contextClients.adaClient.onReady();
-        const projectFile = vscode.workspace.asRelativePath(
-            await getProjectFile(contextClients.adaClient)
-        );
-        if (vscode.workspace.workspaceFolders) {
-            const fpath = path.join(vscode.workspace.workspaceFolders[0].uri.path, projectFile);
-            cp.execSync('gnattest -P ' + fpath, { timeout: 60000 });
-        } else {
-            throw new Error('No workspace folder found for the specified URI');
-        }
+        const projectFile = await getProjectFile(contextClients.adaClient);
+        // Generate tests and redirect the stderr to stdout if command failed
+        cp.execSync('gnattest -P ' + projectFile + ' 2>&1', { timeout: 60000 });
     });
     test('Build & Run the tests', () => {
         if (vscode.workspace.workspaceFolders) {
             const ext: string = process.platform == 'win32' ? '.exe' : '';
-            const cwd = vscode.workspace.workspaceFolders[0].uri.path;
+            const cwd = vscode.workspace.workspaceFolders[0].uri.fsPath;
 
             cp.execSync(
                 'gprbuild -P ' + path.join(cwd, 'obj', 'gnattest', 'harness', 'test_driver.gpr'),
@@ -46,7 +40,7 @@ suite('GNATtest Integration Tests', function () {
     test('Expected Tests discovered', async () => {
         const root = await gnattest.discoverTests(
             gnattest.controller,
-            path.join('obj', 'gnattest')
+            path.join(await getObjectDir(contextClients.adaClient), 'gnattest')
         );
         assert.notStrictEqual(root, undefined);
         const tests = gnattest.gatherChildTestItems(gnattest.controller.items);
@@ -57,7 +51,7 @@ suite('GNATtest Integration Tests', function () {
     });
     test('Read & Parse & compare the results', async () => {
         if (vscode.workspace.workspaceFolders) {
-            const cwd = vscode.workspace.workspaceFolders[0].uri.path;
+            const cwd = vscode.workspace.workspaceFolders[0].uri.fsPath;
             const resultPath = path.join(cwd, 'obj', 'gnattest', 'result.txt');
             const result = await gnattest.readResultFile(resultPath);
             assert.notStrictEqual(

integration/vscode/ada/test/suite/utils.ts

@@ -17,6 +17,9 @@ import { existsSync, readFileSync, writeFileSync } from 'fs';
  * @param expectedUri - path to the file containing the expected output
  */
 export function assertEqualToFileContent(actual: string, expectedUri: vscode.Uri) {
+    // Normalize the actual string
+    actual = normalizeLineEndings(actual);
+
     if (update()) {
         writeFileSync(expectedUri.fsPath, actual);
     } else {
@@ -25,10 +28,15 @@ export function assertEqualToFileContent(actual: string, expectedUri: vscode.Uri
         }
 
         const expected: string = readFileSync(expectedUri.fsPath, 'utf-8');
+
         assert.strictEqual(actual, expected);
     }
 }
 
+export function normalizeLineEndings(str: string, lineEnding = '\n'): string {
+    return str.replace(/\r?\n/g, lineEnding);
+}
+
 /**
  *
  * @returns true if the testsuite is running in update mode, i.e. the