@iamsergio/qttest-utils 2.3.0 → 2.6.0

package/out/qttest.js

@@ -18,27 +18,29 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QtTests = exports.QtTestSlot = exports.QtTest = exports.logMessage = void 0;
+exports.QtTests = exports.QtTestSlot = exports.QtTest = void 0;
+exports.logMessage = logMessage;
 const child_process_1 = require("child_process");
 const path_1 = __importDefault(require("path"));
 const fs = __importStar(require("fs"));
@@ -50,21 +52,26 @@ function logMessage(message) {
         gLogFunction(message);
     }
 }
-exports.logMessage = logMessage;
 /**
  * Represents a single QtTest executable.
  * Supports listing the individual test slots
  */
 class QtTest {
+    filename;
+    buildDirPath;
+    /// If true, will print more verbose output
+    verbose = false;
+    /// Allows vscode extensions to associate with a test item
+    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
+    outputFunc = undefined;
     constructor(filename, buildDirPath) {
-        /// If true, will print more verbose output
-        this.verbose = false;
-        /// The list of individual runnable test slots
-        this.slots = null;
-        /// Set after running
-        this.lastExitCode = 0;
-        /// Allows the caller to receive the output of the test process
-        this.outputFunc = undefined;
         this.filename = filename;
         this.buildDirPath = buildDirPath;
     }
@@ -77,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;
@@ -86,55 +94,67 @@ 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.
      */
-    parseAvailableSlots() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let slotNames = [];
-            let output = "";
-            let err = "";
-            yield new Promise((resolve, reject) => {
-                if (!fs.existsSync(this.filename)) {
-                    reject(new Error("qttest: File doesn't exit: " + this.filename));
-                    return;
-                }
-                const child = (0, child_process_1.spawn)(this.filename, ["-functions"], {
-                    cwd: this.buildDirPath,
-                });
-                child.stdout.on("data", (chunk) => {
-                    output += chunk.toString();
-                });
-                child.stderr.on("data", (chunk) => {
-                    err += chunk.toString();
-                });
-                child.on("exit", (code) => {
-                    if (code === 0) {
-                        slotNames = slotNames.concat(output.split("\n"));
-                        slotNames = slotNames.map((entry) => entry.trim().replace("()", ""));
-                        slotNames = slotNames.filter((entry) => entry.length > 0);
-                        if (slotNames.length > 0) {
-                            this.slots = [];
-                            for (var slotName of slotNames) {
-                                var slot = new QtTestSlot(slotName, this);
-                                this.slots.push(slot);
-                            }
+    async parseAvailableSlots() {
+        let slotNames = [];
+        let output = "";
+        let err = "";
+        await new Promise((resolve, reject) => {
+            if (!fs.existsSync(this.filename)) {
+                reject(new Error("qttest: File doesn't exit: " + this.filename));
+                return;
+            }
+            const child = (0, child_process_1.spawn)(this.filename, ["-functions"], {
+                cwd: this.buildDirPath,
+                env: this.buildSpawnEnv(),
+            });
+            child.stdout.on("data", (chunk) => {
+                output += chunk.toString();
+            });
+            child.stderr.on("data", (chunk) => {
+                err += chunk.toString();
+            });
+            child.on("exit", (code) => {
+                if (code === 0) {
+                    slotNames = slotNames.concat(output.split("\n"));
+                    slotNames = slotNames.map((entry) => entry.trim().replace("()", ""));
+                    slotNames = slotNames.filter((entry) => entry.length > 0);
+                    if (slotNames.length > 0) {
+                        this.slots = [];
+                        for (var slotName of slotNames) {
+                            var slot = new QtTestSlot(slotName, this);
+                            this.slots.push(slot);
                         }
-                        resolve(slotNames);
-                    }
-                    else {
-                        reject(new Error("qttest: Failed to run -functions, stdout=" +
-                            output +
-                            "; stderr=" +
-                            err +
-                            "; code=" +
-                            code));
                     }
-                });
+                    resolve(slotNames);
+                }
+                else {
+                    reject(new Error("qttest: Failed to run -functions, stdout=" +
+                        output +
+                        "; stderr=" +
+                        err +
+                        "; code=" +
+                        code));
+                }
             });
         });
     }
@@ -151,8 +171,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;
@@ -163,8 +184,9 @@ class QtTest {
                         result = true;
                     }
                 }
-                if (this.verbose)
+                if (this.verbose) {
                     logMessage(chunk.toString());
+                }
             });
             child.on("exit", (code) => {
                 if (code === 0) {
@@ -178,98 +200,104 @@ class QtTest {
     }
     /// Returns whether this test is a QtTest by running it with -help and checking if the help text looks familiar
     /// Note that if this is not a QtTest it might not run help and instead execute the test itself
-    isQtTestViaHelp() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield new Promise((resolve, reject) => {
-                const child = (0, child_process_1.spawn)(this.filename, ["-help"]);
-                let output = "";
-                let result = false;
-                child.stdout.on("data", (chunk) => {
-                    if (!result) {
-                        if (chunk.toString().includes("[testfunction[:testdata]]")) {
-                            result = true;
-                        }
-                    }
-                });
-                child.on("exit", (code) => {
-                    if (code === 0) {
-                        resolve(result);
-                    }
-                    else {
-                        resolve(false);
+    async isQtTestViaHelp() {
+        return await new Promise((resolve, reject) => {
+            const child = (0, child_process_1.spawn)(this.filename, ["-help"], {
+                env: this.buildSpawnEnv(),
+            });
+            let output = "";
+            let result = false;
+            child.stdout.on("data", (chunk) => {
+                if (!result) {
+                    if (chunk.toString().includes("[testfunction[:testdata]]")) {
+                        result = true;
                     }
-                });
+                }
+            });
+            child.on("exit", (code) => {
+                if (code === 0) {
+                    resolve(result);
+                }
+                else {
+                    resolve(false);
+                }
             });
         });
     }
     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;
     }
     /// Runs this test
-    runTest(slot_1) {
-        return __awaiter(this, arguments, void 0, function* (slot, cwd = "") {
-            let args = [];
-            if (slot) {
-                // Runs a single Qt test instead
-                args = args.concat(slot.name);
-            }
-            else {
-                this.clearSubTestStates();
-            }
-            // log to file and to stdout
-            args = args.concat("-o").concat(this.tapOutputFileName(slot) + ",tap");
-            args = args.concat("-o").concat(this.txtOutputFileName(slot) + ",txt");
-            args = args.concat("-o").concat("-,txt");
-            return yield new Promise((resolve, reject) => {
-                let cwdDir = cwd.length > 0 ? cwd : this.buildDirPath;
-                logMessage("Running " +
-                    this.filename +
-                    " " +
-                    args.join(" ") +
-                    " with cwd=" +
-                    cwdDir);
-                const child = (0, child_process_1.spawn)(this.filename, args, { cwd: cwdDir });
-                if (this.outputFunc) {
-                    // Callers wants the process output:
-                    child.stdout.on("data", (chunk) => {
-                        if (this.outputFunc)
-                            this.outputFunc(chunk.toString());
-                    });
-                    child.stderr.on("data", (chunk) => {
-                        if (this.outputFunc)
-                            this.outputFunc(chunk.toString());
-                    });
-                }
-                child.on("exit", (code) => __awaiter(this, void 0, void 0, function* () {
-                    /// Can code even be null ?
-                    if (code == undefined)
-                        code = -1;
-                    if (!slot) {
-                        this.lastExitCode = code;
+    async runTest(slot, cwd = "") {
+        let args = [];
+        if (slot) {
+            // Runs a single Qt test instead
+            args = args.concat(slot.name);
+        }
+        else {
+            this.clearSubTestStates();
+        }
+        // log to file and to stdout
+        args = args.concat("-o").concat(this.tapOutputFileName(slot) + ",tap");
+        args = args.concat("-o").concat(this.txtOutputFileName(slot) + ",txt");
+        args = args.concat("-o").concat("-,txt");
+        return await new Promise((resolve, reject) => {
+            let cwdDir = cwd.length > 0 ? cwd : this.buildDirPath;
+            logMessage("Running " +
+                this.filename +
+                " " +
+                args.join(" ") +
+                " with 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) {
+                        this.outputFunc(chunk.toString());
                     }
-                    if (this.slots && this.slots.length > 0) {
-                        /// When running a QtTest executable, let's check which sub-tests failed
-                        /// (So VSCode can show some error icon for each fail)
-                        try {
-                            yield this.updateSubTestStates(cwdDir, slot);
-                        }
-                        catch (e) {
-                            logMessage("Failed to update sub-test states: " + e);
-                        }
+                });
+                child.stderr.on("data", (chunk) => {
+                    if (this.outputFunc) {
+                        this.outputFunc(chunk.toString());
                     }
-                    if (code === 0) {
-                        resolve(true);
+                });
+            }
+            child.on("exit", async (code) => {
+                /// Can code even be null ?
+                if (code === undefined || code === null) {
+                    code = -1;
+                }
+                if (!slot) {
+                    this.lastExitCode = code;
+                }
+                if (this.slots && this.slots.length > 0) {
+                    /// When running a QtTest executable, let's check which sub-tests failed
+                    /// (So VSCode can show some error icon for each fail)
+                    try {
+                        await this.updateSubTestStates(cwdDir, slot);
                     }
-                    else {
-                        resolve(false);
+                    catch (e) {
+                        logMessage("Failed to update sub-test states: " + e);
                     }
-                }));
+                }
+                if (code === 0) {
+                    resolve(true);
+                }
+                else {
+                    resolve(false);
+                }
             });
         });
     }
@@ -293,76 +321,76 @@ class QtTest {
             }
         }
     }
-    updateSubTestStates(cwdDir, slot) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let tapFileName = cwdDir + "/" + this.tapOutputFileName(slot);
-            var failures = yield new Promise((resolve, reject) => {
-                fs.readFile(tapFileName, "utf8", (error, data) => {
-                    if (error) {
-                        logMessage("ERROR: Failed to read log file");
-                        reject(error);
-                    }
-                    else {
-                        let failedResults = [];
-                        try {
-                            const tap_events = tap_parser_1.Parser.parse(data);
-                            for (let event of tap_events) {
-                                try {
-                                    if (event.length < 2)
-                                        continue;
-                                    if (event.at(0) != "assert")
-                                        continue;
-                                    var obj = event.at(1);
-                                    let pass = obj["ok"] === true;
-                                    let xfail = !pass && obj["todo"] !== false;
-                                    if (xfail) {
-                                        // This is a QEXPECT_FAIL test, all good.
-                                        // QtTest outputs it as "todo"
-                                        continue;
+    async updateSubTestStates(cwdDir, slot) {
+        let tapFileName = cwdDir + "/" + this.tapOutputFileName(slot);
+        var failures = await new Promise((resolve, reject) => {
+            fs.readFile(tapFileName, "utf8", (error, data) => {
+                if (error) {
+                    logMessage("ERROR: Failed to read log file");
+                    reject(error);
+                }
+                else {
+                    let failedResults = [];
+                    try {
+                        const tapEvents = tap_parser_1.Parser.parse(data);
+                        for (let event of tapEvents) {
+                            try {
+                                if (event.length < 2) {
+                                    continue;
+                                }
+                                if (event.at(0) !== "assert") {
+                                    continue;
+                                }
+                                var obj = event.at(1);
+                                let pass = obj["ok"] === true;
+                                let xfail = !pass && obj["todo"] !== false;
+                                if (xfail) {
+                                    // This is a QEXPECT_FAIL test, all good.
+                                    // QtTest outputs it as "todo"
+                                    continue;
+                                }
+                                // There's an QEXPECT_FAIL but test passed, not good.
+                                let xpass = pass && obj["todo"].includes("returned TRUE unexpectedly");
+                                if (!pass || xpass) {
+                                    // We found a failure
+                                    var name = obj["name"].replace(/\(.*\)/, "");
+                                    var filename = "";
+                                    var lineNumber = -1;
+                                    if (obj["diag"]) {
+                                        filename = obj["diag"]["file"];
+                                        lineNumber = obj["diag"]["line"];
                                     }
-                                    // There's an QEXPECT_FAIL but test passed, not good.
-                                    let xpass = pass && obj["todo"].includes("returned TRUE unexpectedly");
-                                    if (!pass || xpass) {
-                                        // We found a failure
-                                        var name = obj["name"].replace(/\(.*\)/, "");
-                                        var filename = "";
-                                        var lineNumber = -1;
-                                        if (obj["diag"]) {
-                                            filename = obj["diag"]["file"];
-                                            lineNumber = obj["diag"]["line"];
-                                        }
-                                        else {
-                                            // A XPASS for example misses file:line info. Nothing we can do, it's a Qt bug arguably.
-                                        }
-                                        failedResults.push({
-                                            name: name,
-                                            filePath: filename,
-                                            lineNumber: lineNumber,
-                                        });
+                                    else {
+                                        // A XPASS for example misses file:line info. Nothing we can do, it's a Qt bug arguably.
                                     }
+                                    failedResults.push({
+                                        name: name,
+                                        filePath: filename,
+                                        lineNumber: lineNumber,
+                                    });
                                 }
-                                catch (e) { }
                             }
+                            catch (e) { }
                         }
-                        catch (e) { }
-                        resolve(failedResults);
                     }
-                });
-            });
-            for (let failure of failures) {
-                if (slot && slot.name != failure.name) {
-                    // We executed a single slot, ignore anything else
-                    continue;
-                }
-                let failedSlot = this.slotByName(failure.name);
-                if (failedSlot) {
-                    failedSlot.lastTestFailure = failure;
+                    catch (e) { }
+                    resolve(failedResults);
                 }
-                else {
-                    logMessage("ERROR: Failed to find slot with name " + failure.name);
-                }
-            }
+            });
         });
+        for (let failure of failures) {
+            if (slot && slot.name !== failure.name) {
+                // We executed a single slot, ignore anything else
+                continue;
+            }
+            let failedSlot = this.slotByName(failure.name);
+            if (failedSlot) {
+                failedSlot.lastTestFailure = failure;
+            }
+            else {
+                logMessage("ERROR: Failed to find slot with name " + failure.name);
+            }
+        }
     }
 }
 exports.QtTest = QtTest;
@@ -370,6 +398,13 @@ exports.QtTest = QtTest;
  * Represents a single Qt test slot
  */
 class QtTestSlot {
+    name;
+    // The QTest executable this slot belongs to
+    parentQTest;
+    /// Allows vscode extensions to associate with a test item
+    vscodeTestItem;
+    /// Set after running
+    lastTestFailure;
     constructor(name, parent) {
         this.name = name;
         this.parentQTest = parent;
@@ -380,10 +415,8 @@ class QtTestSlot {
     get absoluteFilePath() {
         return this.parentQTest.filename;
     }
-    runTest() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.parentQTest.runTest(this);
-        });
+    async runTest() {
+        return this.parentQTest.runTest(this);
     }
     command() {
         return {
@@ -398,51 +431,45 @@ exports.QtTestSlot = QtTestSlot;
  * Represents the list of all QtTest executables in your project
  */
 class QtTests {
-    constructor() {
-        this.qtTestExecutables = [];
-    }
-    discoverViaCMake(buildDirPath) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var cmake = new cmake_1.CMakeTests(buildDirPath);
-            let ctests = yield cmake.tests();
-            if (ctests) {
-                for (let ctest of ctests) {
-                    let qtest = new QtTest(ctest.executablePath(), buildDirPath);
-                    this.qtTestExecutables.push(qtest);
-                }
+    qtTestExecutables = [];
+    async discoverViaCMake(buildDirPath) {
+        var cmake = new cmake_1.CMakeTests(buildDirPath);
+        let ctests = await cmake.tests();
+        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);
             }
-            else {
-                logMessage("ERROR: Failed to retrieve ctests!");
-            }
-        });
+        }
+        else {
+            logMessage("ERROR: Failed to retrieve ctests!");
+        }
     }
     /// Removes any executable (from the list) that doesn't link to libQtTest.so
     /// This heuristic tries to filter-out doctest and other non-Qt tests
     /// Only implemented for linux for now
-    removeNonLinking() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let isLinux = process.platform === "linux";
-            if (!isLinux) {
-                return;
-            }
-            let acceptedExecutables = [];
-            for (let ex of this.qtTestExecutables) {
-                let linksToQt = yield ex.linksToQtTestLib();
-                // undefined or true is accepted
-                if (linksToQt !== false) {
-                    acceptedExecutables.push(ex);
-                }
-                this.qtTestExecutables = acceptedExecutables;
+    async removeNonLinking() {
+        let isLinux = process.platform === "linux";
+        if (!isLinux) {
+            return;
+        }
+        let acceptedExecutables = [];
+        for (let ex of this.qtTestExecutables) {
+            let linksToQt = await ex.linksToQtTestLib();
+            // undefined or true is accepted
+            if (linksToQt !== false) {
+                acceptedExecutables.push(ex);
             }
-        });
+            this.qtTestExecutables = acceptedExecutables;
+        }
     }
     setLogFunction(func) {
         gLogFunction = func;
     }
-    removeByRunningHelp() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.qtTestExecutables = this.qtTestExecutables.filter((ex) => __awaiter(this, void 0, void 0, function* () { return yield ex.isQtTestViaHelp(); }));
-        });
+    async removeByRunningHelp() {
+        this.qtTestExecutables = this.qtTestExecutables.filter(async (ex) => await ex.isQtTestViaHelp());
     }
     /// Removes any executable (from the list) that matches the specified regex
     removeMatching(regex) {
@@ -457,19 +484,18 @@ class QtTests {
             console.log(ex.filename);
         }
     }
-    dumpTestSlots() {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (var ex of this.qtTestExecutables) {
-                if (!ex.slots)
-                    yield ex.parseAvailableSlots();
-                console.log(ex.filename);
-                if (ex.slots) {
-                    for (let slot of ex.slots) {
-                        console.log("    - " + slot.name);
-                    }
+    async dumpTestSlots() {
+        for (var ex of this.qtTestExecutables) {
+            if (!ex.slots) {
+                await ex.parseAvailableSlots();
+            }
+            console.log(ex.filename);
+            if (ex.slots) {
+                for (let slot of ex.slots) {
+                    console.log("    - " + slot.name);
                 }
             }
-        });
+        }
     }
     /// Returns all executables that contain a Qt test slot with the specified name
     executablesContainingSlot(slotName) {