init

venv/lib/python3.12/site-packages/PyQt5/Qt5/qml/QtTest/SignalSpy.qml

@@ -0,0 +1,268 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+import QtQuick 2.0
+import QtTest 1.1
+
+/*!
+    \qmltype SignalSpy
+    \inqmlmodule QtTest
+    \brief Enables introspection of signal emission.
+    \since 4.8
+    \ingroup qtquicktest
+
+    In the following example, a SignalSpy is installed to watch the
+    "clicked" signal on a user-defined Button type.  When the signal
+    is emitted, the \l count property on the spy will be increased.
+
+    \code
+    Button {
+        id: button
+        SignalSpy {
+            id: spy
+            target: button
+            signalName: "clicked"
+        }
+        TestCase {
+            name: "ButtonClick"
+            function test_click() {
+                compare(spy.count, 0)
+                button.clicked();
+                compare(spy.count, 1)
+            }
+        }
+    }
+    \endcode
+
+    The above style of test is suitable for signals that are emitted
+    synchronously.  For asynchronous signals, the wait() method can be
+    used to block the test until the signal occurs (or a timeout expires).
+
+    \sa {QtTest::TestCase}{TestCase}, {Qt Quick Test}
+*/
+
+Item {
+    id: spy
+    visible: false
+
+    TestUtil {
+        id: util
+    }
+    // Public API.
+    /*!
+        \qmlproperty object SignalSpy::target
+
+        This property defines the target object that will be used to
+        listen for emissions of the \l signalName signal.
+
+        \sa signalName, count
+    */
+    property var target: null
+    /*!
+        \qmlproperty string SignalSpy::signalName
+
+        This property defines the name of the signal on \l target to
+        listen for.
+
+        \sa target, count
+    */
+    property string signalName: ""
+    /*!
+        \qmlproperty int SignalSpy::count
+
+        This property defines the number of times that \l signalName has
+        been emitted from \l target since the last call to clear().
+
+        \sa target, signalName, clear()
+        \readonly
+    */
+    readonly property alias count: spy.qtest_count
+    /*!
+        \qmlproperty bool SignalSpy::valid
+
+        This property defines the current signal connection status. It will be true when the \l signalName of the \l target is connected successfully, otherwise it will be false.
+
+        \sa count, target, signalName, clear()
+        \readonly
+    */
+    readonly property alias valid:spy.qtest_valid
+    /*!
+        \qmlproperty list SignalSpy::signalArguments
+
+        This property holds a list of emitted signal arguments. Each emission of the signal will append one item to the list, containing the arguments of the signal.
+        When connecting to a new \l target or new \l signalName or calling the \l clear() method, the \l signalArguments will be reset to empty.
+
+        \sa signalName, clear()
+        \readonly
+    */
+    readonly property alias signalArguments:spy.qtest_signalArguments
+
+    /*!
+        \qmlmethod SignalSpy::clear()
+
+        Clears \l count to 0, resets \l valid to false and clears the \l signalArguments to empty.
+
+        \sa count, wait()
+    */
+    function clear() {
+        qtest_count = 0
+        qtest_expectedCount = 0
+        qtest_signalArguments = []
+    }
+
+    /*!
+        \qmlmethod SignalSpy::wait(timeout = 5000)
+
+        Waits for the signal \l signalName on \l target to be emitted,
+        for up to \a timeout milliseconds.  The test case will fail if
+        the signal is not emitted.
+
+        \code
+        SignalSpy {
+            id: spy
+            target: button
+            signalName: "clicked"
+        }
+
+        function test_async_click() {
+            ...
+            // do something that will cause clicked() to be emitted
+            ...
+            spy.wait()
+            compare(spy.count, 1)
+        }
+        \endcode
+
+        There are two possible scenarios: the signal has already been
+        emitted when wait() is called, or the signal has not yet been
+        emitted.  The wait() function handles the first scenario by immediately
+        returning if the signal has already occurred.
+
+        The clear() method can be used to discard information about signals
+        that have already occurred to synchronize wait() with future signal
+        emissions.
+
+        \sa clear(), TestCase::tryCompare()
+    */
+    function wait(timeout) {
+        if (timeout === undefined)
+            timeout = 5000
+        var expected = ++qtest_expectedCount
+        var i = 0
+        while (i < timeout && qtest_count < expected) {
+            qtest_results.wait(50)
+            i += 50
+        }
+        var success = (qtest_count >= expected)
+        if (!qtest_results.verify(success, "wait for signal " + signalName, util.callerFile(), util.callerLine()))
+            throw new Error("QtQuickTest::fail")
+    }
+
+    // Internal implementation detail follows.
+
+    TestResult { id: qtest_results }
+
+    onTargetChanged: {
+        qtest_update()
+    }
+    onSignalNameChanged: {
+        qtest_update()
+    }
+
+    /*! \internal */
+    property var qtest_prevTarget: null
+    /*! \internal */
+    property string qtest_prevSignalName: ""
+    /*! \internal */
+    property int qtest_expectedCount: 0
+    /*! \internal */
+    property var qtest_signalArguments:[]
+    /*! \internal */
+    property int qtest_count: 0
+    /*! \internal */
+    property bool qtest_valid:false
+    /*! \internal */
+
+    /*! \internal */
+    function qtest_update() {
+        if (qtest_prevTarget != null) {
+            var prevHandlerName = qtest_signalHandlerName(qtest_prevSignalName)
+            var prevFunc = qtest_prevTarget[prevHandlerName]
+            if (prevFunc)
+                prevFunc.disconnect(spy.qtest_activated)
+            qtest_prevTarget = null
+            qtest_prevSignalName = ""
+        }
+        if (target != null && signalName != "") {
+            // Look for the signal name in the object
+            var func = target[signalName]
+            if (typeof func !== "function") {
+                // If it is not a function, try looking for signal handler
+                // i.e. (onSignal) this is needed for cases where there is a property
+                // and a signal with the same name, e.g. Mousearea.pressed
+                func = target[qtest_signalHandlerName(signalName)]
+            }
+            if (func === undefined) {
+                spy.qtest_valid = false
+                console.log("Signal '" + signalName + "' not found")
+            } else {
+                qtest_prevTarget = target
+                qtest_prevSignalName = signalName
+                func.connect(spy.qtest_activated)
+                spy.qtest_valid = true
+                spy.qtest_signalArguments = []
+            }
+        } else {
+            spy.qtest_valid = false
+        }
+    }
+
+    /*! \internal */
+    function qtest_activated() {
+        ++qtest_count
+        spy.qtest_signalArguments[spy.qtest_signalArguments.length] = arguments
+    }
+
+    /*! \internal */
+    function qtest_signalHandlerName(sn) {
+        if (sn.substr(0, 2) === "on" && sn[2] === sn[2].toUpperCase())
+            return sn
+        return "on" + sn.substr(0, 1).toUpperCase() + sn.substr(1)
+    }
+}

venv/lib/python3.12/site-packages/PyQt5/Qt5/qml/QtTest/plugins.qmltypes

@@ -0,0 +1,364 @@
+import QtQuick.tooling 1.2
+
+// This file describes the plugin-supplied types contained in the library.
+// It is used for QML tooling purposes only.
+//
+// This file was auto-generated by qmltyperegistrar.
+
+Module {
+    dependencies: ["QtQuick 2.0", "QtQuick.Window 2.0"]
+    Component {
+        file: "quicktestevent_p.h"
+        name: "QQuickTouchEventSequence"
+        Method {
+            name: "press"
+            type: "QObject*"
+            Parameter { name: "touchId"; type: "int" }
+            Parameter { name: "item"; type: "QObject"; isPointer: true }
+            Parameter { name: "x"; type: "double" }
+            Parameter { name: "y"; type: "double" }
+        }
+        Method {
+            name: "move"
+            type: "QObject*"
+            Parameter { name: "touchId"; type: "int" }
+            Parameter { name: "item"; type: "QObject"; isPointer: true }
+            Parameter { name: "x"; type: "double" }
+            Parameter { name: "y"; type: "double" }
+        }
+        Method {
+            name: "release"
+            type: "QObject*"
+            Parameter { name: "touchId"; type: "int" }
+            Parameter { name: "item"; type: "QObject"; isPointer: true }
+            Parameter { name: "x"; type: "double" }
+            Parameter { name: "y"; type: "double" }
+        }
+        Method {
+            name: "stationary"
+            type: "QObject*"
+            Parameter { name: "touchId"; type: "int" }
+        }
+        Method { name: "commit"; type: "QObject*" }
+    }
+    Component {
+        file: "quicktestevent_p.h"
+        name: "QuickTestEvent"
+        exports: ["QtTest/TestEvent 1.0", "QtTest/TestEvent 1.2"]
+        exportMetaObjectRevisions: [0, 2]
+        Property { name: "defaultMouseDelay"; type: "int"; isReadonly: true }
+        Method {
+            name: "keyPress"
+            type: "bool"
+            Parameter { name: "key"; type: "int" }
+            Parameter { name: "modifiers"; type: "int" }
+            Parameter { name: "delay"; type: "int" }
+        }
+        Method {
+            name: "keyRelease"
+            type: "bool"
+            Parameter { name: "key"; type: "int" }
+            Parameter { name: "modifiers"; type: "int" }
+            Parameter { name: "delay"; type: "int" }
+        }
+        Method {
+            name: "keyClick"
+            type: "bool"
+            Parameter { name: "key"; type: "int" }
+            Parameter { name: "modifiers"; type: "int" }
+            Parameter { name: "delay"; type: "int" }
+        }
+        Method {
+            name: "keyPressChar"
+            type: "bool"
+            Parameter { name: "character"; type: "string" }
+            Parameter { name: "modifiers"; type: "int" }
+            Parameter { name: "delay"; type: "int" }
+        }
+        Method {
+            name: "keyReleaseChar"
+            type: "bool"
+            Parameter { name: "character"; type: "string" }
+            Parameter { name: "modifiers"; type: "int" }
+            Parameter { name: "delay"; type: "int" }
+        }
+        Method {
+            name: "keyClickChar"
+            type: "bool"
+            Parameter { name: "character"; type: "string" }
+            Parameter { name: "modifiers"; type: "int" }
+            Parameter { name: "delay"; type: "int" }
+        }
+        Method {
+            name: "keySequence"
+            revision: 2
+            type: "bool"
+            Parameter { name: "keySequence"; type: "QVariant" }
+        }
+        Method {
+            name: "mousePress"
+            type: "bool"
+            Parameter { name: "item"; type: "QObject"; isPointer: true }
+            Parameter { name: "x"; type: "double" }
+            Parameter { name: "y"; type: "double" }
+            Parameter { name: "button"; type: "int" }
+            Parameter { name: "modifiers"; type: "int" }
+            Parameter { name: "delay"; type: "int" }
+        }
+        Method {
+            name: "mouseRelease"
+            type: "bool"
+            Parameter { name: "item"; type: "QObject"; isPointer: true }
+            Parameter { name: "x"; type: "double" }
+            Parameter { name: "y"; type: "double" }
+            Parameter { name: "button"; type: "int" }
+            Parameter { name: "modifiers"; type: "int" }
+            Parameter { name: "delay"; type: "int" }
+        }
+        Method {
+            name: "mouseClick"
+            type: "bool"
+            Parameter { name: "item"; type: "QObject"; isPointer: true }
+            Parameter { name: "x"; type: "double" }
+            Parameter { name: "y"; type: "double" }
+            Parameter { name: "button"; type: "int" }
+            Parameter { name: "modifiers"; type: "int" }
+            Parameter { name: "delay"; type: "int" }
+        }
+        Method {
+            name: "mouseDoubleClick"
+            type: "bool"
+            Parameter { name: "item"; type: "QObject"; isPointer: true }
+            Parameter { name: "x"; type: "double" }
+            Parameter { name: "y"; type: "double" }
+            Parameter { name: "button"; type: "int" }
+            Parameter { name: "modifiers"; type: "int" }
+            Parameter { name: "delay"; type: "int" }
+        }
+        Method {
+            name: "mouseDoubleClickSequence"
+            type: "bool"
+            Parameter { name: "item"; type: "QObject"; isPointer: true }
+            Parameter { name: "x"; type: "double" }
+            Parameter { name: "y"; type: "double" }
+            Parameter { name: "button"; type: "int" }
+            Parameter { name: "modifiers"; type: "int" }
+            Parameter { name: "delay"; type: "int" }
+        }
+        Method {
+            name: "mouseMove"
+            type: "bool"
+            Parameter { name: "item"; type: "QObject"; isPointer: true }
+            Parameter { name: "x"; type: "double" }
+            Parameter { name: "y"; type: "double" }
+            Parameter { name: "delay"; type: "int" }
+            Parameter { name: "buttons"; type: "int" }
+        }
+        Method {
+            name: "mouseWheel"
+            type: "bool"
+            Parameter { name: "item"; type: "QObject"; isPointer: true }
+            Parameter { name: "x"; type: "double" }
+            Parameter { name: "y"; type: "double" }
+            Parameter { name: "buttons"; type: "int" }
+            Parameter { name: "modifiers"; type: "int" }
+            Parameter { name: "xDelta"; type: "int" }
+            Parameter { name: "yDelta"; type: "int" }
+            Parameter { name: "delay"; type: "int" }
+        }
+        Method {
+            name: "touchEvent"
+            type: "QQuickTouchEventSequence*"
+            Parameter { name: "item"; type: "QObject"; isPointer: true }
+        }
+        Method { name: "touchEvent"; type: "QQuickTouchEventSequence*" }
+    }
+    Component {
+        file: "quicktestresultforeign_p.h"
+        name: "QuickTestResult"
+        exports: [
+            "QtTest/TestResult 1.0",
+            "QtTest/TestResult 1.1",
+            "QtTest/TestResult 1.13"
+        ]
+        exportMetaObjectRevisions: [0, 1, 13]
+        Enum {
+            name: "RunMode"
+            values: ["RepeatUntilValidMeasurement", "RunOnce"]
+        }
+        Property { name: "testCaseName"; type: "string" }
+        Property { name: "functionName"; type: "string" }
+        Property { name: "dataTag"; type: "string" }
+        Property { name: "failed"; type: "bool"; isReadonly: true }
+        Property { name: "skipped"; type: "bool" }
+        Property { name: "passCount"; type: "int"; isReadonly: true }
+        Property { name: "failCount"; type: "int"; isReadonly: true }
+        Property { name: "skipCount"; type: "int"; isReadonly: true }
+        Property { name: "functionsToRun"; type: "QStringList"; isReadonly: true }
+        Property { name: "tagsToRun"; type: "QStringList"; isReadonly: true }
+        Signal { name: "programNameChanged" }
+        Method { name: "reset" }
+        Method { name: "startLogging" }
+        Method { name: "stopLogging" }
+        Method { name: "initTestTable" }
+        Method { name: "clearTestTable" }
+        Method { name: "finishTestData" }
+        Method { name: "finishTestDataCleanup" }
+        Method { name: "finishTestFunction" }
+        Method {
+            name: "stringify"
+            Parameter { name: "args"; type: "QQmlV4Function"; isPointer: true }
+        }
+        Method {
+            name: "fail"
+            Parameter { name: "message"; type: "string" }
+            Parameter { name: "location"; type: "QUrl" }
+            Parameter { name: "line"; type: "int" }
+        }
+        Method {
+            name: "verify"
+            type: "bool"
+            Parameter { name: "success"; type: "bool" }
+            Parameter { name: "message"; type: "string" }
+            Parameter { name: "location"; type: "QUrl" }
+            Parameter { name: "line"; type: "int" }
+        }
+        Method {
+            name: "compare"
+            type: "bool"
+            Parameter { name: "success"; type: "bool" }
+            Parameter { name: "message"; type: "string" }
+            Parameter { name: "val1"; type: "QVariant" }
+            Parameter { name: "val2"; type: "QVariant" }
+            Parameter { name: "location"; type: "QUrl" }
+            Parameter { name: "line"; type: "int" }
+        }
+        Method {
+            name: "fuzzyCompare"
+            type: "bool"
+            Parameter { name: "actual"; type: "QVariant" }
+            Parameter { name: "expected"; type: "QVariant" }
+            Parameter { name: "delta"; type: "double" }
+        }
+        Method {
+            name: "skip"
+            Parameter { name: "message"; type: "string" }
+            Parameter { name: "location"; type: "QUrl" }
+            Parameter { name: "line"; type: "int" }
+        }
+        Method {
+            name: "expectFail"
+            type: "bool"
+            Parameter { name: "tag"; type: "string" }
+            Parameter { name: "comment"; type: "string" }
+            Parameter { name: "location"; type: "QUrl" }
+            Parameter { name: "line"; type: "int" }
+        }
+        Method {
+            name: "expectFailContinue"
+            type: "bool"
+            Parameter { name: "tag"; type: "string" }
+            Parameter { name: "comment"; type: "string" }
+            Parameter { name: "location"; type: "QUrl" }
+            Parameter { name: "line"; type: "int" }
+        }
+        Method {
+            name: "warn"
+            Parameter { name: "message"; type: "string" }
+            Parameter { name: "location"; type: "QUrl" }
+            Parameter { name: "line"; type: "int" }
+        }
+        Method {
+            name: "ignoreWarning"
+            Parameter { name: "message"; type: "QJSValue" }
+        }
+        Method {
+            name: "wait"
+            Parameter { name: "ms"; type: "int" }
+        }
+        Method {
+            name: "sleep"
+            Parameter { name: "ms"; type: "int" }
+        }
+        Method {
+            name: "waitForRendering"
+            type: "bool"
+            Parameter { name: "item"; type: "QQuickItem"; isPointer: true }
+            Parameter { name: "timeout"; type: "int" }
+        }
+        Method {
+            name: "waitForRendering"
+            type: "bool"
+            Parameter { name: "item"; type: "QQuickItem"; isPointer: true }
+        }
+        Method { name: "startMeasurement" }
+        Method { name: "beginDataRun" }
+        Method { name: "endDataRun" }
+        Method { name: "measurementAccepted"; type: "bool" }
+        Method { name: "needsMoreMeasurements"; type: "bool" }
+        Method {
+            name: "startBenchmark"
+            Parameter { name: "runMode"; type: "RunMode" }
+            Parameter { name: "tag"; type: "string" }
+        }
+        Method { name: "isBenchmarkDone"; type: "bool" }
+        Method { name: "nextBenchmark" }
+        Method { name: "stopBenchmark" }
+        Method {
+            name: "grabImage"
+            type: "QObject*"
+            Parameter { name: "item"; type: "QQuickItem"; isPointer: true }
+        }
+        Method {
+            name: "findChild"
+            revision: 1
+            type: "QObject*"
+            Parameter { name: "parent"; type: "QObject"; isPointer: true }
+            Parameter { name: "objectName"; type: "string" }
+        }
+        Method {
+            name: "isPolishScheduled"
+            revision: 13
+            type: "bool"
+            Parameter { name: "item"; type: "QQuickItem"; isPointer: true }
+        }
+        Method {
+            name: "waitForItemPolished"
+            revision: 13
+            type: "bool"
+            Parameter { name: "item"; type: "QQuickItem"; isPointer: true }
+            Parameter { name: "timeout"; type: "int" }
+        }
+    }
+    Component {
+        file: "quicktestutil_p.h"
+        name: "QuickTestUtil"
+        exports: ["QtTest/TestUtil 1.0"]
+        exportMetaObjectRevisions: [0]
+        Property { name: "printAvailableFunctions"; type: "bool"; isReadonly: true }
+        Property { name: "dragThreshold"; type: "int"; isReadonly: true }
+        Method {
+            name: "typeName"
+            type: "QJSValue"
+            Parameter { name: "v"; type: "QVariant" }
+        }
+        Method {
+            name: "compare"
+            type: "bool"
+            Parameter { name: "act"; type: "QVariant" }
+            Parameter { name: "exp"; type: "QVariant" }
+        }
+        Method {
+            name: "callerFile"
+            type: "QJSValue"
+            Parameter { name: "frameIndex"; type: "int" }
+        }
+        Method { name: "callerFile"; type: "QJSValue" }
+        Method {
+            name: "callerLine"
+            type: "int"
+            Parameter { name: "frameIndex"; type: "int" }
+        }
+        Method { name: "callerLine"; type: "int" }
+    }
+}

venv/lib/python3.12/site-packages/PyQt5/Qt5/qml/QtTest/qmldir

@@ -0,0 +1,8 @@
+module QtTest
+plugin qmltestplugin
+classname QTestQmlModule
+typeinfo plugins.qmltypes
+TestCase 1.0 TestCase.qml
+TestCase 1.2 TestCase.qml
+SignalSpy 1.0 SignalSpy.qml
+depends QtQuick.Window 2.0

venv/lib/python3.12/site-packages/PyQt5/Qt5/qml/QtTest/testlogger.js

@@ -0,0 +1,96 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+.pragma library
+
+// We need a global place to store the results that can be
+// shared between multiple TestCase instances.  Because QML
+// creates a separate scope for every inclusion of this file,
+// we hijack the global "Qt" object to store our data.
+function log_init_results()
+{
+    if (!Qt.testResults) {
+        Qt.testResults = {
+            reportedStart: false,
+            nextId: 0,
+            testCases: []
+        }
+    }
+}
+
+function log_register_test(name)
+{
+    log_init_results()
+    var testId = Qt.testResults.nextId++
+    Qt.testResults.testCases.push(testId)
+    return testId
+}
+
+function log_optional_test(testId)
+{
+    log_init_results()
+    var index = Qt.testResults.testCases.indexOf(testId)
+    if (index >= 0)
+        Qt.testResults.testCases.splice(index, 1)
+}
+
+function log_mandatory_test(testId)
+{
+    log_init_results()
+    var index = Qt.testResults.testCases.indexOf(testId)
+    if (index == -1)
+        Qt.testResults.testCases.push(testId)
+}
+
+function log_start_test()
+{
+    log_init_results()
+    if (Qt.testResults.reportedStart)
+        return false
+    Qt.testResults.reportedStart = true
+    return true
+}
+
+function log_complete_test(testId)
+{
+    var index = Qt.testResults.testCases.indexOf(testId)
+    if (index >= 0)
+        Qt.testResults.testCases.splice(index, 1)
+    return Qt.testResults.testCases.length > 0
+}