@iamsergio/qttest-utils 2.2.2 → 2.5.0

package/out/qttest.js

@@ -18,52 +18,58 @@ 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"));
 const cmake_1 = require("./cmake");
+const tap_parser_1 = require("tap-parser");
 var gLogFunction;
 function logMessage(message) {
     if (gLogFunction) {
         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;
+    /// 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;
     }
@@ -92,48 +98,46 @@ class QtTest {
     /**
      * 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,
+            });
+            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));
+                }
             });
         });
     }
@@ -177,27 +181,25 @@ 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"]);
+            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);
+                }
             });
         });
     }
@@ -211,64 +213,62 @@ class QtTest {
         return undefined;
     }
     /// Runs this test
-    runTest(slot, cwd = "") {
-        return __awaiter(this, void 0, void 0, function* () {
-            let args = [];
-            if (slot) {
-                // Runs a single Qt test instead
-                args = args.concat(slot.name);
-            }
-            else {
-                this.clearSubTestStates();
+    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 });
+            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());
+                });
             }
-            // 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", async (code) => {
+                /// Can code even be null ?
+                if (code == undefined)
+                    code = -1;
+                if (!slot) {
+                    this.lastExitCode = code;
                 }
-                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;
-                    }
-                    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);
-                        }
-                    }
-                    if (code === 0) {
-                        resolve(true);
+                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);
+                }
             });
         });
     }
@@ -292,43 +292,74 @@ 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 {
-                        // A fail line is something like:
-                        // at: MyTest::testF() (/some/path/qttest-utils/test/qt_test/test2.cpp:13)
-                        const pattern = /at:\s+(.+?)::(.+?)\(\)\s+\((.+?):(\d+)\)/gm;
-                        const matches = Array.from(data.matchAll(pattern));
-                        const failedResults = matches.map((match) => ({
-                            name: match[2],
-                            filePath: match[3],
-                            lineNumber: parseInt(match[4]),
-                        }));
-                        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;
+    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 {
-                    logMessage("ERROR: Failed to find slot with name " + failure.name);
+                    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;
+                                }
+                                // 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,
+                                    });
+                                }
+                            }
+                            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;
+            }
+            else {
+                logMessage("ERROR: Failed to find slot with name " + failure.name);
+            }
+        }
     }
 }
 exports.QtTest = QtTest;
@@ -336,6 +367,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;
@@ -346,10 +384,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 {
@@ -364,51 +400,43 @@ 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);
-                }
-            }
-            else {
-                logMessage("ERROR: Failed to retrieve ctests!");
+    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);
+                this.qtTestExecutables.push(qtest);
             }
-        });
+        }
+        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) {
@@ -423,19 +451,17 @@ 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) {