@iamsergio/qttest-utils 2.5.0 → 2.6.1

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## [2.6.1](https://github.com/KDAB/qttest-utils/compare/v2.6.0...v2.6.1) (2026-04-05)
+
+
+### Bug Fixes
+
+* Improve gtest vs qttest detection ([75b2f57](https://github.com/KDAB/qttest-utils/commit/75b2f575962edc2e78737dc8615c5476bd62e8b2))
+* Improve gtest vs qttest detection ([cb26f31](https://github.com/KDAB/qttest-utils/commit/cb26f316de3e882802e2c81df9c517e6658f9821))
+
+## [2.6.0](https://github.com/KDAB/qttest-utils/compare/v2.5.0...v2.6.0) (2026-04-05)
+
+
+### Features
+
+* propagate CTest ENVIRONMENT to spawned test processes ([ea24d96](https://github.com/KDAB/qttest-utils/commit/ea24d96545c3ac9d68fc9cfea8ab6b372055b804))
+* propagate CTest ENVIRONMENT to spawned test processes ([6a68cc7](https://github.com/KDAB/qttest-utils/commit/6a68cc7db40f53f3631579477deb780d36b36685))
+
+
+### Bug Fixes
+
+* made eslint pass ([6740d61](https://github.com/KDAB/qttest-utils/commit/6740d618843a9a0a55fd73b7cc9e0c9f2412788e))
+
 ## [2.5.0](https://github.com/KDAB/qttest-utils/compare/v2.4.4...v2.5.0) (2026-04-04)
 
 

package/out/cmake.d.ts

@@ -20,6 +20,7 @@ export declare class CMakeTests {
 export declare class CMakeTest {
     command: string[];
     cwd: string;
+    environment: string[];
     id(): string;
     label(): string;
     executablePath(): string;

package/out/cmake.js

@@ -28,7 +28,7 @@ class CMakeTests {
      */
     async tests() {
         // TODO: Check if folder exists
-        if (this.buildDirPath.length == 0) {
+        if (this.buildDirPath.length === 0) {
             console.error("Could not find out cmake build dir");
             return undefined;
         }
@@ -43,7 +43,7 @@ class CMakeTests {
             });
             child.on("close", (code) => {
                 if (code === 0) {
-                    if (output.length == 0) {
+                    if (output.length === 0) {
                         console.error("ctestJsonToList: Empty json output. Command was ctest --show-only=json-v1 , in " +
                             this.buildDirPath);
                         reject(new Error("Failed to get ctest JSON output"));
@@ -68,20 +68,76 @@ class CMakeTests {
             let test = new CMakeTest();
             test.command = testJSON.command;
             test.cwd = testJSON.cwd;
+            // Extract environment information if present in ctest JSON.
+            // ctest may expose environment as `environment` (string or array),
+            // or embed it into `properties` either as an object or array.
+            try {
+                let envArr = undefined;
+                if (testJSON.environment) {
+                    envArr = Array.isArray(testJSON.environment)
+                        ? testJSON.environment
+                        : [testJSON.environment];
+                }
+                if (!envArr && testJSON.properties) {
+                    const props = testJSON.properties;
+                    // properties might be an object with ENVIRONMENT key or an array of {name,value} entries
+                    if (!Array.isArray(props) && props.ENVIRONMENT) {
+                        const val = props.ENVIRONMENT;
+                        if (typeof val === "string") {
+                            envArr = [val];
+                        }
+                        else if (Array.isArray(val)) {
+                            envArr = val;
+                        }
+                    }
+                    else if (Array.isArray(props)) {
+                        for (const p of props) {
+                            if (!p || !p.name) {
+                                continue;
+                            }
+                            if (p.name === "ENVIRONMENT" || p.name === "Environment") {
+                                const v = p.value;
+                                if (typeof v === "string") {
+                                    envArr = [v];
+                                }
+                                else if (Array.isArray(v)) {
+                                    envArr = v;
+                                }
+                                break;
+                            }
+                        }
+                    }
+                }
+                if (envArr) {
+                    test.environment = envArr;
+                }
+            }
+            catch (e) {
+                try {
+                    (0, qttest_1.logMessage)("ctest: failed to parse environment for test: " +
+                        JSON.stringify(testJSON) +
+                        " error: " +
+                        e);
+                }
+                catch (_) { }
+            }
             return test;
         });
         // filter invalid tests:
         tests = tests.filter((test) => {
             // pretty print test
-            if (!test.command || test.command.length == 0)
+            if (!test.command || test.command.length === 0) {
                 return false;
+            }
             let testExecutablePath = test.executablePath();
             let baseName = path_1.default.basename(testExecutablePath).toLowerCase();
-            if (baseName.endsWith(".exe"))
+            if (baseName.endsWith(".exe")) {
                 baseName = baseName.substring(0, baseName.length - 4);
+            }
             // People doing complicated things in add_test()
-            if (baseName == "ctest" || baseName === "cmake")
+            if (baseName === "ctest" || baseName === "cmake") {
                 return false;
+            }
             return true;
         });
         return tests;
@@ -90,16 +146,19 @@ class CMakeTests {
     /// codemodel should have a "projects" key at root.
     targetNameForExecutable(executable, codemodel, workaround = false) {
         let projects = codemodel["projects"];
-        if (!projects)
+        if (!projects) {
             return undefined;
+        }
         for (let project of projects) {
             let targets = project["targets"];
-            if (!targets)
+            if (!targets) {
                 continue;
+            }
             for (let target of targets) {
                 let artifacts = target["artifacts"];
-                if (!artifacts)
+                if (!artifacts) {
                     continue;
+                }
                 for (let artifact of artifacts) {
                     if (artifact.endsWith(".exe")) {
                         artifact = artifact.substring(0, artifact.length - 4);
@@ -120,18 +179,21 @@ class CMakeTests {
     /// If workaround is true, then we workaround microsoft/vscode-cmake-tools-api/issues/7 where
     /// the basename is correct but the path is bogus, and we only compare the basenames
     filenamesAreEqual(file1, file2, workaround = false) {
-        if (file1.endsWith(".exe"))
+        if (file1.endsWith(".exe")) {
             file1 = file1.substring(0, file1.length - 4);
-        if (file2.endsWith(".exe"))
+        }
+        if (file2.endsWith(".exe")) {
             file2 = file2.substring(0, file2.length - 4);
+        }
         file1 = file1.replace(/\\/g, "/");
         file2 = file2.replace(/\\/g, "/");
         if (process.platform === "win32") {
             file1 = file1.toLowerCase();
             file2 = file2.toLowerCase();
         }
-        if (file1 == file2)
+        if (file1 === file2) {
             return true;
+        }
         if (!workaround) {
             // files aren't equal!
             return false;
@@ -142,7 +204,7 @@ class CMakeTests {
             return false;
         }
         /// Compare only basename, since path is bogus
-        return path_1.default.basename(file1, ".exe") == path_1.default.basename(file2, ".exe");
+        return path_1.default.basename(file1, ".exe") === path_1.default.basename(file2, ".exe");
     }
     /// Returns the list of .cpp files for the specified executable
     /// codemodel is the CMake codemodel JSON object
@@ -150,20 +212,24 @@ class CMakeTests {
     /// @param workaround If true, worksaround https://github.com/microsoft/vscode-cmake-tools-api/issues/7
     cppFilesForExecutable(executable, codemodel, workaround = false) {
         let projects = codemodel["projects"];
-        if (!projects)
+        if (!projects) {
             return [];
+        }
         for (let project of projects) {
             let targets = project["targets"];
-            if (!targets)
+            if (!targets) {
                 continue;
+            }
             for (let target of targets) {
                 let sourceDir = target["sourceDirectory"];
                 let artifacts = target["artifacts"];
-                if (!artifacts || !sourceDir)
+                if (!artifacts || !sourceDir) {
                     continue;
+                }
                 let targetType = target["type"];
-                if (targetType != "EXECUTABLE")
+                if (targetType !== "EXECUTABLE") {
                     continue;
+                }
                 for (let artifact of artifacts) {
                     if (artifact.endsWith(".exe")) {
                         artifact = artifact.substring(0, artifact.length - 4);
@@ -172,14 +238,17 @@ class CMakeTests {
                     artifact = artifact.replace(/\\/g, "/");
                     if (this.filenamesAreEqual(executable, artifact, workaround)) {
                         let fileGroups = target["fileGroups"];
-                        if (!fileGroups)
+                        if (!fileGroups) {
                             continue;
+                        }
                         for (let fileGroup of fileGroups) {
-                            if (fileGroup["language"] != "CXX" || fileGroup["isGenerated"])
+                            if (fileGroup["language"] !== "CXX" || fileGroup["isGenerated"]) {
                                 continue;
+                            }
                             let sources = fileGroup["sources"];
-                            if (!sources)
+                            if (!sources) {
                                 continue;
+                            }
                             let cppFiles = [];
                             for (let source of sources) {
                                 if (!source.endsWith("mocs_compilation.cpp")) {
@@ -202,6 +271,7 @@ exports.CMakeTests = CMakeTests;
 class CMakeTest {
     command = [];
     cwd = "";
+    environment = [];
     id() {
         return this.command.join(",");
     }

package/out/example.js

@@ -10,13 +10,13 @@ const qttest_1 = require("./qttest");
 const fs_1 = __importDefault(require("fs"));
 async function example() {
     const args = process.argv.slice(2);
-    if (args.length != 1) {
+    if (args.length !== 1) {
         console.error("ERROR: Expected a single argument with the build-dir with cmake tests!");
         process.exit(2);
     }
     let buildDirPath = args[0];
     if (!fs_1.default.existsSync(buildDirPath)) {
-        console.error('Directory does not exist!');
+        console.error("Directory does not exist!");
         process.exit(1);
     }
     let qt = new qttest_1.QtTests();
@@ -36,13 +36,23 @@ async function example() {
     console.log("\nRunning tests...");
     for (var executable of qt.qtTestExecutables) {
         await executable.runTest();
-        if (executable.lastExitCode === 0)
+        if (executable.lastExitCode === 0) {
             console.log("    PASS: " + executable.filename);
-        else
-            console.log("    FAIL: " + executable.filename + "; code=" + executable.lastExitCode);
+        }
+        else {
+            console.log("    FAIL: " +
+                executable.filename +
+                "; code=" +
+                executable.lastExitCode);
+        }
         for (let slot of executable.slots) {
             if (slot.lastTestFailure) {
-                console.log("        failed slot=" + slot.name + "; path=" + slot.lastTestFailure.filePath + "; line=" + slot.lastTestFailure.lineNumber);
+                console.log("        failed slot=" +
+                    slot.name +
+                    "; path=" +
+                    slot.lastTestFailure.filePath +
+                    "; line=" +
+                    slot.lastTestFailure.lineNumber);
             }
             else {
                 console.log("        pass: " + slot.name);
@@ -53,15 +63,19 @@ async function example() {
     console.log("\nRunning single tests...");
     let slot = qt.qtTestExecutables[1].slots[0];
     await slot.runTest();
-    if (slot.lastTestFailure)
+    if (slot.lastTestFailure) {
         console.log("    FAIL:" + JSON.stringify(slot.lastTestFailure));
-    else
+    }
+    else {
         console.log("    PASS:");
+    }
     let slot2 = qt.qtTestExecutables[1].slots[2];
     await slot2.runTest();
-    if (slot2.lastTestFailure)
+    if (slot2.lastTestFailure) {
         console.log("    FAIL:" + JSON.stringify(slot2.lastTestFailure));
-    else
+    }
+    else {
         console.log("    PASS");
+    }
 }
 example();

package/out/index.js

@@ -6,6 +6,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const cmake_1 = require("./cmake");
 const qttest_1 = require("./qttest");
 const qttest = {
-    QtTests: qttest_1.QtTests, QtTest: qttest_1.QtTest, QtTestSlot: qttest_1.QtTestSlot, CMakeTests: cmake_1.CMakeTests, CMakeTest: cmake_1.CMakeTest
+    QtTests: qttest_1.QtTests,
+    QtTest: qttest_1.QtTest,
+    QtTestSlot: qttest_1.QtTestSlot,
+    CMakeTests: cmake_1.CMakeTests,
+    CMakeTest: cmake_1.CMakeTest,
 };
 exports.default = qttest;

package/out/qttest.d.ts

@@ -10,6 +10,7 @@ export declare class QtTest {
     verbose: boolean;
     vscodeTestItem: any | undefined;
     slots: QtTestSlot[] | null;
+    environment: string[];
     lastExitCode: number;
     outputFunc: LoggerFunction | undefined;
     constructor(filename: string, buildDirPath: string);
@@ -17,6 +18,7 @@ export declare class QtTest {
     get label(): string;
     relativeFilename(): string;
     filenameWithoutExtension(): string;
+    private buildSpawnEnv;
     /**
      * Calls "./yourqttest -functions" and stores the results in the slots property.
      */
@@ -30,6 +32,7 @@ export declare class QtTest {
      */
     linksToQtTestLib(): Promise<boolean> | undefined;
     isQtTestViaHelp(): Promise<boolean | undefined>;
+    isGTest(): Promise<boolean>;
     slotByName(name: string): QtTestSlot | undefined;
     runTest(slot?: QtTestSlot, cwd?: string): Promise<boolean>;
     tapOutputFileName(slot?: QtTestSlot): string;

package/out/qttest.js

@@ -65,6 +65,8 @@ class QtTest {
     vscodeTestItem;
     /// The list of individual runnable test slots
     slots = null;
+    /// Environment variables coming from CTest (array of "VAR=VALUE")
+    environment = [];
     /// Set after running
     lastExitCode = 0;
     /// Allows the caller to receive the output of the test process
@@ -82,8 +84,9 @@ class QtTest {
     relativeFilename() {
         let result = path_1.default.relative(process.cwd(), this.filename);
         // strip .exe, as we only use this for tests
-        if (result.endsWith(".exe"))
+        if (result.endsWith(".exe")) {
             result = result.slice(0, -4);
+        }
         // normalize slashes
         result = result.replace(/\\/g, "/");
         return result;
@@ -91,14 +94,32 @@ class QtTest {
     /// returns filename without .exe extension
     filenameWithoutExtension() {
         let result = this.filename;
-        if (result.endsWith(".exe"))
+        if (result.endsWith(".exe")) {
             result = result.slice(0, -4);
+        }
         return result;
     }
+    buildSpawnEnv() {
+        const env = Object.assign({}, process.env);
+        if (this.environment && Array.isArray(this.environment)) {
+            for (const kv of this.environment) {
+                const idx = kv.indexOf("=");
+                if (idx > -1) {
+                    env[kv.substring(0, idx)] = kv.substring(idx + 1);
+                }
+            }
+        }
+        return env;
+    }
     /**
      * Calls "./yourqttest -functions" and stores the results in the slots property.
      */
     async parseAvailableSlots() {
+        if (await this.isGTest()) {
+            logMessage("qttest: Skipping -functions for GTest executable: " + this.filename);
+            this.slots = [];
+            return;
+        }
         let slotNames = [];
         let output = "";
         let err = "";
@@ -109,6 +130,7 @@ class QtTest {
             }
             const child = (0, child_process_1.spawn)(this.filename, ["-functions"], {
                 cwd: this.buildDirPath,
+                env: this.buildSpawnEnv(),
             });
             child.stdout.on("data", (chunk) => {
                 output += chunk.toString();
@@ -154,8 +176,9 @@ class QtTest {
             return undefined;
         }
         return new Promise((resolve, reject) => {
-            if (this.verbose)
+            if (this.verbose) {
                 logMessage("qttest: Running ldd on " + this.filename);
+            }
             const child = (0, child_process_1.spawn)("ldd", [this.filename]);
             let output = "";
             let result = false;
@@ -166,8 +189,9 @@ class QtTest {
                         result = true;
                     }
                 }
-                if (this.verbose)
+                if (this.verbose) {
                     logMessage(chunk.toString());
+                }
             });
             child.on("exit", (code) => {
                 if (code === 0) {
@@ -183,7 +207,9 @@ class QtTest {
     /// Note that if this is not a QtTest it might not run help and instead execute the test itself
     async isQtTestViaHelp() {
         return await new Promise((resolve, reject) => {
-            const child = (0, child_process_1.spawn)(this.filename, ["-help"]);
+            const child = (0, child_process_1.spawn)(this.filename, ["-help"], {
+                env: this.buildSpawnEnv(),
+            });
             let output = "";
             let result = false;
             child.stdout.on("data", (chunk) => {
@@ -203,12 +229,41 @@ class QtTest {
             });
         });
     }
+    /// Returns whether this executable is a Google Test by running it with --help
+    /// and checking if the output contains the GTest banner
+    async isGTest() {
+        return await new Promise((resolve) => {
+            if (!fs.existsSync(this.filename)) {
+                resolve(false);
+                return;
+            }
+            const child = (0, child_process_1.spawn)(this.filename, ["--help"], {
+                env: this.buildSpawnEnv(),
+            });
+            let output = "";
+            let found = false;
+            child.stdout.on("data", (chunk) => {
+                if (!found) {
+                    if (chunk
+                        .toString()
+                        .includes("This program contains tests written using Google Test")) {
+                        found = true;
+                    }
+                }
+            });
+            child.on("exit", () => {
+                resolve(found);
+            });
+        });
+    }
     slotByName(name) {
-        if (!this.slots)
+        if (!this.slots) {
             return undefined;
+        }
         for (let slot of this.slots) {
-            if (slot.name == name)
+            if (slot.name === name) {
                 return slot;
+            }
         }
         return undefined;
     }
@@ -234,22 +289,28 @@ class QtTest {
                 args.join(" ") +
                 " with cwd=" +
                 cwdDir);
-            const child = (0, child_process_1.spawn)(this.filename, args, { cwd: cwdDir });
+            const child = (0, child_process_1.spawn)(this.filename, args, {
+                cwd: cwdDir,
+                env: this.buildSpawnEnv(),
+            });
             if (this.outputFunc) {
                 // Callers wants the process output:
                 child.stdout.on("data", (chunk) => {
-                    if (this.outputFunc)
+                    if (this.outputFunc) {
                         this.outputFunc(chunk.toString());
+                    }
                 });
                 child.stderr.on("data", (chunk) => {
-                    if (this.outputFunc)
+                    if (this.outputFunc) {
                         this.outputFunc(chunk.toString());
+                    }
                 });
             }
             child.on("exit", async (code) => {
                 /// Can code even be null ?
-                if (code == undefined)
+                if (code === undefined || code === null) {
                     code = -1;
+                }
                 if (!slot) {
                     this.lastExitCode = code;
                 }
@@ -303,13 +364,15 @@ class QtTest {
                 else {
                     let failedResults = [];
                     try {
-                        const tap_events = tap_parser_1.Parser.parse(data);
-                        for (let event of tap_events) {
+                        const tapEvents = tap_parser_1.Parser.parse(data);
+                        for (let event of tapEvents) {
                             try {
-                                if (event.length < 2)
+                                if (event.length < 2) {
                                     continue;
-                                if (event.at(0) != "assert")
+                                }
+                                if (event.at(0) !== "assert") {
                                     continue;
+                                }
                                 var obj = event.at(1);
                                 let pass = obj["ok"] === true;
                                 let xfail = !pass && obj["todo"] !== false;
@@ -348,7 +411,7 @@ class QtTest {
             });
         });
         for (let failure of failures) {
-            if (slot && slot.name != failure.name) {
+            if (slot && slot.name !== failure.name) {
                 // We executed a single slot, ignore anything else
                 continue;
             }
@@ -407,6 +470,8 @@ class QtTests {
         if (ctests) {
             for (let ctest of ctests) {
                 let qtest = new QtTest(ctest.executablePath(), buildDirPath);
+                // Propagate environment from CTest metadata
+                qtest.environment = ctest.environment;
                 this.qtTestExecutables.push(qtest);
             }
         }
@@ -453,8 +518,9 @@ class QtTests {
     }
     async dumpTestSlots() {
         for (var ex of this.qtTestExecutables) {
-            if (!ex.slots)
+            if (!ex.slots) {
                 await ex.parseAvailableSlots();
+            }
             console.log(ex.filename);
             if (ex.slots) {
                 for (let slot of ex.slots) {

package/out/test.js

@@ -10,23 +10,64 @@ const qttest_1 = require("./qttest");
 async function runTests(buildDirPath) {
     let qt = new qttest_1.QtTests();
     await qt.discoverViaCMake(buildDirPath);
-    let expected_executables = [
+    // Verify that environment properties from CTest were discovered for test1
+    const test1Exe = qt.qtTestExecutables.find((e) => e.filenameWithoutExtension().endsWith("test1"));
+    if (!test1Exe) {
+        console.error("Expected to find test1 executable after discovery");
+        process.exit(1);
+    }
+    if (!test1Exe.environment || !test1Exe.environment.includes("MY_ENV=VALUE")) {
+        console.error("Expected test1 to have environment MY_ENV=VALUE, got: " +
+            JSON.stringify(test1Exe.environment));
+        process.exit(1);
+    }
+    let expectedExecutables = [
         "test/qt_test/build-dev/test1",
         "test/qt_test/build-dev/test2",
         "test/qt_test/build-dev/test3",
         "test/qt_test/build-dev/non_qttest",
+        "test/qt_test/build-dev/test_gtest",
     ];
-    if (qt.qtTestExecutables.length != expected_executables.length) {
-        console.error("Expected 3 executables, got " + qt.qtTestExecutables.length);
+    if (qt.qtTestExecutables.length !== expectedExecutables.length) {
+        console.error("Expected " +
+            expectedExecutables.length +
+            " executables, got " +
+            qt.qtTestExecutables.length);
+        process.exit(1);
+    }
+    // Verify that test_gtest is detected as a GTest
+    const gtestExe = qt.qtTestExecutables.find((e) => e.filenameWithoutExtension().endsWith("test_gtest"));
+    if (!gtestExe) {
+        console.error("Expected to find test_gtest executable after discovery");
         process.exit(1);
     }
+    if (!(await gtestExe.isGTest())) {
+        console.error("Expected test_gtest to be detected as a GTest");
+        process.exit(1);
+    }
+    console.log("PASS: test_gtest detected as GTest");
+    // Verify that test_gtest has no slots after parseAvailableSlots (GTest is skipped)
+    await gtestExe.parseAvailableSlots();
+    if (!gtestExe.slots || gtestExe.slots.length !== 0) {
+        console.error("Expected test_gtest to have 0 slots, got " +
+            (gtestExe.slots?.length ?? "null"));
+        process.exit(1);
+    }
+    console.log("PASS: test_gtest has 0 slots (no children)");
+    // Verify that a QtTest is not detected as a GTest
+    if (await test1Exe.isGTest()) {
+        console.error("Expected test1 to NOT be detected as a GTest");
+        process.exit(1);
+    }
+    console.log("PASS: test1 (QtTest) not misdetected as GTest");
     await qt.removeNonLinking();
     /// On macOS and Windows we don't have ldd or equivalent, so we can't check if the test links to QtTest
     /// Use the help way instead
     await qt.removeByRunningHelp();
-    /// Remove the non-qttest executable from qt.qtTestExecutables
-    qt.qtTestExecutables = qt.qtTestExecutables.filter((e) => !e.filenameWithoutExtension().endsWith("non_qttest"));
-    if (qt.qtTestExecutables.length != 3) {
+    /// Remove the non-qttest and gtest executables from qt.qtTestExecutables
+    qt.qtTestExecutables = qt.qtTestExecutables.filter((e) => !e.filenameWithoutExtension().endsWith("non_qttest") &&
+        !e.filenameWithoutExtension().endsWith("test_gtest"));
+    if (qt.qtTestExecutables.length !== 3) {
         console.error("Expected 3 executables, at this point got " +
             qt.qtTestExecutables.length);
         process.exit(1);
@@ -34,8 +75,8 @@ async function runTests(buildDirPath) {
     // 1. Test that the executable test names are correct:
     var i = 0;
     for (var executable of qt.qtTestExecutables) {
-        let expected = expected_executables[i];
-        if (executable.relativeFilename() != expected) {
+        let expected = expectedExecutables[i];
+        if (executable.relativeFilename() !== expected) {
             console.error("Expected executable " +
                 expected +
                 ", got " +
@@ -46,7 +87,7 @@ async function runTests(buildDirPath) {
     }
     // 2. Test that the discovered slots are correct:
     await qt.dumpTestSlots();
-    let expected_slots = {
+    let expectedSlots = {
         "test/qt_test/build-dev/test1": ["testA", "testB", "testC", "testXFAIL"],
         "test/qt_test/build-dev/test2": [
             "testD",
@@ -60,25 +101,25 @@ async function runTests(buildDirPath) {
     for (var executable of qt.qtTestExecutables) {
         var i = 0;
         for (let slot of executable.slots) {
-            let expected_slot = expected_slots[executable.relativeFilename()][i];
-            if (slot.name != expected_slot) {
-                console.error("Expected slot " + expected_slot + ", got " + slot.name);
+            let expectedSlot = expectedSlots[executable.relativeFilename()][i];
+            if (slot.name !== expectedSlot) {
+                console.error("Expected slot " + expectedSlot + ", got " + slot.name);
                 process.exit(1);
             }
             i++;
         }
     }
     // 3. Run the tests:
-    let expected_success = [true, false, false];
+    let expectedSuccess = [true, false, false];
     var i = 0;
     for (var executable of qt.qtTestExecutables) {
         await executable.runTest();
         let wasSuccess = executable.lastExitCode === 0;
-        if (wasSuccess && !expected_success[i]) {
+        if (wasSuccess && !expectedSuccess[i]) {
             console.error("Expected test to fail: " + executable.filename);
             process.exit(1);
         }
-        else if (!wasSuccess && expected_success[i]) {
+        else if (!wasSuccess && expectedSuccess[i]) {
             console.error("Expected test to pass: " + executable.filename);
             process.exit(1);
         }
@@ -105,7 +146,7 @@ async function runTests(buildDirPath) {
     }
     // 5. Test executablesContainingSlot
     let executables = qt.executablesContainingSlot("testB");
-    if (executables.length != 1) {
+    if (executables.length !== 1) {
         console.error("Expected 1 executable, got " + executables.length);
         process.exit(1);
     }
@@ -114,13 +155,13 @@ async function runTests(buildDirPath) {
         process.exit(1);
     }
     executables = qt.executablesContainingSlot("non_existing");
-    if (executables.length != 0) {
+    if (executables.length !== 0) {
         console.error("Expected 0 executables, got " + executables.length);
         process.exit(1);
     }
     // 6. Run a slot that has XFAIL
     slot = qt.qtTestExecutables[0].slots[3];
-    if (slot.name != "testXFAIL") {
+    if (slot.name !== "testXFAIL") {
         console.error("Expected slot name to be testXFAIL");
         process.exit(1);
     }
@@ -131,7 +172,7 @@ async function runTests(buildDirPath) {
     }
     // 7. Run a slot that has XPASS
     slot = qt.qtTestExecutables[1].slots[3];
-    if (slot.name != "testXPASS") {
+    if (slot.name !== "testXPASS") {
         console.error("Expected slot name to be testXPASS");
         process.exit(1);
     }
@@ -142,7 +183,7 @@ async function runTests(buildDirPath) {
     }
     // 8. Run a slot that has both XFAIL and FAIL
     slot = qt.qtTestExecutables[1].slots[4];
-    if (slot.name != "testMixXFAILWithFAIL") {
+    if (slot.name !== "testMixXFAILWithFAIL") {
         console.error("Expected slot name to be testMixXFAILWithFAIL");
         process.exit(1);
     }
@@ -158,29 +199,29 @@ async function runCodeModelTests(codeModelFile) {
     let codemodelJson = JSON.parse(codemodelStr);
     let cmake = new cmake_1.CMakeTests("random");
     let files = cmake.cppFilesForExecutable("/vscode-qttest/test/qt_test/build-dev/test1", codemodelJson);
-    if (files.length != 1) {
+    if (files.length !== 1) {
         console.error("Expected 1 file, got " + files.length);
         process.exit(1);
     }
     let expected = "/vscode-qttest/test/qt_test/test1.cpp";
     let got = files[0].replace(/\\/g, "/");
-    if (got != expected) {
+    if (got !== expected) {
         console.error("Expected " + expected + ", got " + got);
         process.exit(1);
     }
     let targetName = cmake.targetNameForExecutable("/vscode-qttest/test/qt_test/build-dev/test1", codemodelJson);
-    if (targetName != "test1") {
+    if (targetName !== "test1") {
         console.error("Expected test1, got " + targetName);
         process.exit(1);
     }
     // test windows back slashes:
     files = cmake.cppFilesForExecutable("/vscode-qttest/test/qt_test/build-dev/test2", codemodelJson);
-    if (files.length != 1) {
+    if (files.length !== 1) {
         console.error("Expected 1 file, got " + files.length);
         process.exit(1);
     }
     targetName = cmake.targetNameForExecutable("/vscode-qttest/test/qt_test/build-dev/test2", codemodelJson);
-    if (targetName != "test2") {
+    if (targetName !== "test2") {
         console.error("Expected test2, got " + targetName);
         process.exit(1);
     }
@@ -205,7 +246,7 @@ async function runCodeModelTests(codeModelFile) {
     }
     targetName = cmake.targetNameForExecutable("/vscode-qttest/test/qt_test/build-dev/test3", codemodelJson, 
     /*workaround=*/ true);
-    if (targetName != "test3") {
+    if (targetName !== "test3") {
         console.error("Expected null, got " + targetName);
         process.exit(1);
     }

package/out/utils.js

@@ -87,7 +87,9 @@ function executableFiles(folderPath) {
         if (info.isDirectory()) {
             executables = executables.concat(executableFiles(childPath));
         }
-        else if (info.isFile() && !isLibrary(path_1.default.basename(childPath)) && isExecutable(childPath)) {
+        else if (info.isFile() &&
+            !isLibrary(path_1.default.basename(childPath)) &&
+            isExecutable(childPath)) {
             executables.push(childPath);
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iamsergio/qttest-utils",
-  "version": "2.5.0",
+  "version": "2.6.1",
   "description": "API for listing QtTest executables from a build directory and which individual test slots each executable contains. Useful for a Text Explorer VSCode extension.",
   "repository": {
     "type": "git",
@@ -8,7 +8,9 @@
   },
   "scripts": {
     "build": "tsc",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "format:check": "prettier --check \"src/**/*.ts\"",
+    "format:fix": "prettier --write \"src/**/*.ts\""
   },
   "main": "out/index.js",
   "typings": "./out/index.d.ts",
@@ -30,10 +32,13 @@
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
+    "eslint": "^10.2.0",
+    "prettier": "3.8.1",
     "ts-node": "^10.9.2",
-    "typescript": "^5.7.2"
+    "typescript": "^6.0.2",
+    "typescript-eslint": "^8.0.0"
   },
   "dependencies": {
-    "tap-parser": "^16.0.1"
+    "tap-parser": "^18.3.0"
   }
 }