TestCase QML Type

Stellt einen Einheitstestfall dar. Mehr...

Import Statement: import QtTest
Inherits:

Item

Eigenschaften

Methoden

Detaillierte Beschreibung

Einführung in QML-Testfälle

Testfälle werden als JavaScript-Funktionen innerhalb eines TestCase-Typs geschrieben:

import QtQuick 2.0
import QtTest 1.2

TestCase {
    name: "MathTests"

    function test_math() {
        compare(2 + 2, 4, "2 + 2 = 4")
    }

    function test_fail() {
        compare(2 + 2, 5, "2 + 2 = 5")
    }
}

Funktionen, deren Namen mit "test_" beginnen, werden als auszuführende Testfälle behandelt. Die Eigenschaft name wird verwendet, um die Funktionen in der Ausgabe voranzustellen:

********* Start testing of MathTests *********
Config: Using QTest library 4.7.2, Qt 4.7.2
PASS   : MathTests::initTestCase()
FAIL!  : MathTests::test_fail() 2 + 2 = 5
   Actual (): 4
   Expected (): 5
   Loc: [/home/.../tst_math.qml(12)]
PASS   : MathTests::test_math()
PASS   : MathTests::cleanupTestCase()
Totals: 3 passed, 1 failed, 0 skipped
********* Finished testing of MathTests *********

Aufgrund der Funktionsweise von JavaScript-Eigenschaften ist die Reihenfolge, in der die Testfunktionen gefunden werden, nicht vorhersehbar. Um die Vorhersagbarkeit zu unterstützen, sortiert das Testframework die Funktionen in aufsteigender Reihenfolge ihres Namens. Dies kann hilfreich sein, wenn zwei Tests in der richtigen Reihenfolge ausgeführt werden müssen.

Es können mehrere TestCase-Typen angegeben werden. Das Testprogramm wird beendet, sobald alle Testfälle abgeschlossen sind. Wenn ein Testfall nicht ausgeführt werden muss (weil eine Vorbedingung fehlgeschlagen ist), dann kann optional auf true gesetzt werden.

Datengesteuerte Tests

Tabellendaten können einem Test mit einem Funktionsnamen übergeben werden, der mit "_data" endet. Alternativ dazu kann die Funktion init_data() verwendet werden, um Standard-Testdaten für alle Testfunktionen ohne eine passende "_data"-Funktion in einem TestCase-Typ bereitzustellen:

import QtQuick 2.0
import QtTest 1.2

TestCase {
    name: "DataTests"

    function init_data() {
      return [
           {tag:"init_data_1", a:1, b:2, answer: 3},
           {tag:"init_data_2", a:2, b:4, answer: 6}
      ];
    }

    function test_table_data() {
        return [
            {tag: "2 + 2 = 4", a: 2, b: 2, answer: 4 },
            {tag: "2 + 6 = 8", a: 2, b: 6, answer: 8 },
        ]
    }

    function test_table(data) {
        //data comes from test_table_data
        compare(data.a + data.b, data.answer)
    }

    function test_default_table(data) {
        //data comes from init_data
        compare(data.a + data.b, data.answer)
    }
}

Das Test-Framework iteriert über alle Zeilen der Tabelle und übergibt jede Zeile an die Testfunktion. Wie gezeigt, können die Spalten für die Verwendung im Test extrahiert werden. Die Spalte tag ist etwas Besonderes - sie wird vom Test-Framework gedruckt, wenn eine Zeile fehlschlägt, damit der Leser erkennen kann, welcher Fall in einer Reihe von ansonsten erfolgreichen Tests fehlgeschlagen ist.

Benchmarks

Funktionen, deren Namen mit "benchmark_" beginnen, werden mehrmals mit dem Qt-Benchmark-Framework ausgeführt, wobei ein durchschnittlicher Zeitwert für die Durchläufe angegeben wird. Dies ist äquivalent zur Verwendung des QBENCHMARK Makros in der C++ Version der QTestLib.

TestCase {
    id: top
    name: "CreateBenchmark"

    function benchmark_create_component() {
        let component = Qt.createComponent("item.qml")
        let obj = component.createObject(top)
        obj.destroy()
        component.destroy()
    }
}

RESULT : CreateBenchmark::benchmark_create_component:
     0.23 msecs per iteration (total: 60, iterations: 256)
PASS   : CreateBenchmark::benchmark_create_component()

Um den Effekt des QBENCHMARK_ONCE Makros zu erhalten, stellen Sie dem Namen der Testfunktion das Wort "benchmark_once_" voran.

Tastatur- und Mausereignisse simulieren

Die Methoden keyPress(), keyRelease() und keyClick() können verwendet werden, um Tastaturereignisse in Unit-Tests zu simulieren. Die Ereignisse werden an das aktuell fokussierte QML-Element übergeben. Sie können entweder einen Qt.Key enum Wert oder einen latin1 char (String der Länge eins) übergeben

Rectangle {
    width: 50; height: 50
    focus: true

    TestCase {
        name: "KeyClick"
        when: windowShown

        function test_key_click() {
            keyClick(Qt.Key_Left)
            keyClick("a")
            ...
        }
    }
}

Die Methoden mousePress(), mouseRelease(), mouseClick(), mouseDoubleClickSequence() und mouseMove() können verwendet werden, um Mausereignisse auf ähnliche Weise zu simulieren.

Wenn Ihr Test andere Fenster erstellt, ist es möglich, dass diese Fenster aktiv werden und den Fokus vom TestCase-Fenster stehlen. Um sicherzustellen, dass das Fenster von TestCase aktiv ist, verwenden Sie den folgenden Code:

testCase.Window.window.requestActivate()
tryCompare(testCase.Window.window, "active", true)

Hinweis: Tastatur- und Mausereignisse können erst ausgelöst werden, wenn das Hauptfenster angezeigt wird. Versuche, Ereignisse vorher zu übermitteln, schlagen fehl. Verwenden Sie die Eigenschaften when und windowShown, um festzustellen, wann das Hauptfenster eingeblendet wurde.

Verwalten von dynamisch erstellten Testobjekten

Ein typisches Muster bei QML-Tests besteht darin, ein Objekt dynamisch zu erstellen und es am Ende der Testfunktion zu zerstören:

TestCase {
    id: testCase
    name: "MyTest"
    when: windowShown

    function test_click() {
        let item = Qt.createQmlObject("import QtQuick 2.0; Item {}", testCase);
        verify(item);

        // Test item...

        item.destroy();
    }
}

Das Problem bei diesem Muster ist, dass jeder Fehler in der Testfunktion dazu führt, dass der Aufruf von item.destroy() übersprungen wird und das Objekt in der Szene verbleibt, bis der Testfall abgeschlossen ist. Dies kann zu Störungen bei zukünftigen Tests führen, z. B. durch das Blockieren von Eingabeereignissen oder das Erzeugen unzusammenhängender Debug-Ausgaben, die es schwierig machen, die Ausführung des Codes zu verfolgen.

Wenn Sie stattdessen createTemporaryQmlObject() aufrufen, wird das Objekt am Ende der Testfunktion garantiert zerstört:

TestCase {
    id: testCase
    name: "MyTest"
    when: windowShown

    function test_click() {
        let item = createTemporaryQmlObject("import QtQuick 2.0; Item {}", testCase);
        verify(item);

        // Test item...

        // Don't need to worry about destroying "item" here.
    }
}

Für Objekte, die über die Funktion createObject() von Component erzeugt werden, kann die Funktion createTemporaryObject() verwendet werden.

Trennung von Tests und Anwendungslogik

In den meisten Fällen werden Sie Ihre Tests von der Anwendungslogik trennen wollen, indem Sie sie in verschiedene Projekte aufteilen und diese miteinander verknüpfen.

Sie könnten zum Beispiel die folgende Projektstruktur haben:

.
| — CMakeLists.txt
| — main.cpp
| - main.qml
| — MyModule
    | — MyButton.qml
    | — CMakeLists.txt
| — tests
    | — tst_testqml.qml
    | — main.cpp
    | — setup.cpp
    | — setup.h

Um MyModule/MyButton.qml zu testen, erstellen Sie eine Bibliothek für MyModule in MyModule/CMakeLists.txt und verknüpfen sie mit Ihrem Testprojekt tests/UnitQMLTests/CMakeLists.txt:

    ...
qt_add_library(MyModule STATIC)

qt6_add_qml_module(MyModule
    URI MyModule
    QML_FILES MyButton.qml
)
    ...
#include <QtQuickTest/quicktest.h>
#include "setup.h"

QUICK_TEST_MAIN_WITH_SETUP(TestQML, Setup)
#include "setup.h"

void Setup::applicationAvailable()
{
    // custom code that doesn't require QQmlEngine
}

void Setup::qmlEngineAvailable(QQmlEngine *engine)
{
    // add import paths
}

void Setup::cleanupTestCase()
{
    // custom code to clean up before destruction starts
}
#ifndef SETUP_H
#define SETUP_H

#include <QObject>
#include <QQmlEngine>

class Setup : public QObject
{
    Q_OBJECT
public:
    Setup() = default;

public slots:
    void applicationAvailable();
    void qmlEngineAvailable(QQmlEngine *engine);
    void cleanupTestCase();
};

#endif // SETUP_H
    ...
add_subdirectory(MyModule)
add_subdirectory(tests)

qt_add_executable(MyApplication
    src/main.cpp
)

qt_add_qml_module(MyApplication
    URI MyApplication
    QML_FILES main.qml
)
    ...

In tests/tst_testqml.qml können Sie dann MyModule/MyButton.qml importieren:

import QtQuick
import QtQuick.Controls

import QtTest
import MyModule

Item {
    width: 800
    height: 600

    MyButton {
        id: myButton
        anchors.centerIn: parent
    }

    TestCase {
        name: "MyButton"
        when: windowShown

        function test_clickToExpand() {
            const widthBeforeClick = myButton.width;
            mouseClick(myButton);
            const widthAfterClick = myButton.width;
            verify(widthBeforeClick < widthAfterClick);
        }
    }
}
import QtQuick
import QtQuick.Controls

Button {
    width: 50
    height: 50
    onClicked: width = 100
}

Siehe auch SignalSpy und Qt Quick Test.

Property-Dokumentation

completed : bool

Diese Eigenschaft wird auf true gesetzt, sobald der Testfall vollständig ausgeführt wurde. Testfälle werden nur einmal ausgeführt. Der Anfangswert ist false.

Siehe auch running und when.


name : string

Diese Eigenschaft definiert den Namen des Testfalls für die Ergebnismeldung. Der Standardwert ist eine leere Zeichenkette.

TestCase {
    name: "ButtonTests"
    ...
}

optional : bool

In einer Testanwendung können mehrere TestCase Typen angegeben werden. Die Anwendung wird beendet, sobald sie alle abgeschlossen sind. Wenn ein Testfall nicht ausgeführt werden muss (weil eine Vorbedingung fehlgeschlagen ist), dann kann diese Eigenschaft auf true gesetzt werden. Der Standardwert ist false.

TestCase {
    when: false
    optional: true
    function test_not_run() {
        verify(false)
    }
}

Siehe auch when und completed.


running : bool

Diese Eigenschaft wird auf true gesetzt, während der Testfall ausgeführt wird. Der Anfangswert ist false, und der Wert wird wieder auf false gesetzt, sobald der Testfall abgeschlossen ist.

Siehe auch completed und when.


when : bool

Diese Eigenschaft sollte auf true gesetzt werden, wenn die Anwendung möchte, dass die Testfälle ausgeführt werden. Der Standardwert ist true. Im folgenden Beispiel wird ein Test ausgeführt, wenn der Benutzer die Maustaste drückt:

Rectangle {
    id: foo
    width: 640; height: 480
    color: "cyan"

    MouseArea {
        id: area
        anchors.fill: parent
    }

    property bool bar: true

    TestCase {
        name: "ItemTests"
        when: area.pressed
        id: test1

        function test_bar() {
            verify(bar)
        }
    }
}

Die Testanwendung wird beendet, sobald alle TestCase Typen ausgelöst und ausgeführt worden sind. Die Eigenschaft optional kann verwendet werden, um einen TestCase Typ auszuschließen.

Siehe auch optional und completed.


windowShown : bool

Diese Eigenschaft wird auf true gesetzt, nachdem das QML-Anzeigefenster angezeigt worden ist. Normalerweise werden Testfälle ausgeführt, sobald die Testanwendung geladen ist und bevor ein Fenster angezeigt wird. Wenn der Testfall visuelle Typen und Verhaltensweisen beinhaltet, muss er möglicherweise bis nach der Anzeige des Fensters verzögert werden.

Button {
    id: button
    onClicked: text = "Clicked"
    TestCase {
        name: "ClickTest"
        when: windowShown
        function test_click() {
            button.clicked();
            compare(button.text, "Clicked");
        }
    }
}

Dokumentation der Methode

cleanup()

Diese Funktion wird nach jeder Testfunktion aufgerufen, die im Typ TestCase ausgeführt wird. Die Standardimplementierung tut nichts. Die Anwendung kann ihre eigene Implementierung bereitstellen, um die Bereinigung nach jeder Testfunktion durchzuführen.

Siehe auch init() und cleanupTestCase().


cleanupTestCase()

Diese Funktion wird aufgerufen, nachdem alle anderen Testfunktionen des Typs TestCase abgeschlossen sind. Die Standardimplementierung tut nichts. Die Anwendung kann ihre eigene Implementierung zur Verfügung stellen, um die Bereinigung von Testfällen durchzuführen.

Siehe auch initTestCase() und cleanup().


compare(actual, expected, message = "")

Schlägt den aktuellen Testfall fehl, wenn actual nicht mit expected übereinstimmt, und zeigt das optionale message an. Ähnlich wie QCOMPARE(actual, expected) in C++.

Siehe auch tryCompare() und fuzzyCompare.


object createTemporaryObject(Component component, object parent, object properties)

Diese Funktion erstellt dynamisch ein QML-Objekt aus dem angegebenen component mit den angegebenen optionalen parent und properties. Das zurückgegebene Objekt wird zerstört (falls es das nicht schon war), nachdem cleanup() die Ausführung beendet hat. Das bedeutet, dass mit dieser Funktion erstellte Objekte garantiert nach jedem Test zerstört werden, unabhängig davon, ob die Tests fehlschlagen oder nicht.

Wenn bei der Erstellung des Objekts ein Fehler auftrat, wird null zurückgegeben.

Diese Funktion ruft intern component.createObject() auf.

Siehe auch Managing Dynamically Created Test Objects.


object createTemporaryQmlObject(string qml, object parent, string filePath)

Diese Funktion erzeugt dynamisch ein QML-Objekt aus dem angegebenen qml String mit dem angegebenen parent. Das zurückgegebene Objekt wird zerstört (falls es das nicht schon war), nachdem cleanup() die Ausführung beendet hat. Das bedeutet, dass Objekte, die mit dieser Funktion erstellt wurden, garantiert nach jedem Test zerstört werden, unabhängig davon, ob die Tests fehlschlagen oder nicht.

Wenn bei der Erstellung des Objekts ein Fehler auftrat, wird null zurückgegeben.

Wenn filePath angegeben ist, wird es für die Fehlerberichterstattung für das erstellte Objekt verwendet.

Diese Funktion ruft intern Qt.createQmlObject() auf.

Siehe auch Managing Dynamically Created Test Objects.


expectFail(tag, message)

In einem datengesteuerten Test markiert die Funktion die Zeile, die mit tag verknüpft ist, als fehlgeschlagen zu erwarten. Wenn der Fehler auftritt, zeigen Sie message an, brechen den Test ab und kennzeichnen den Test als bestanden. Ähnlich wie QEXPECT_FAIL(tag, message, Abort) in C++.

Wenn der Test nicht datengesteuert ist, muss tag auf einen leeren String gesetzt werden.

Siehe auch expectFailContinue().


expectFailContinue(tag, message)

Markiert in einem datengesteuerten Test die Zeile, die mit tag verknüpft ist, als voraussichtlich fehlgeschlagen. Wenn der Fehler auftritt, wird message angezeigt, und dann wird der Test fortgesetzt. Ähnlich wie QEXPECT_FAIL(tag, message, Continue) in C++.

Wenn der Test nicht datengesteuert ist, muss tag auf einen leeren String gesetzt werden.

Siehe auch expectFail().


fail(message = "")

Schlägt den aktuellen Testfall fehl, mit dem optionalen message. Ähnlich wie QFAIL(message) in C++.


[since 6.3] failOnWarning(message)

Hängt für jede Warnung, die mit message übereinstimmt, einen Testfehler an das Testprotokoll an. Die Testfunktion wird weiter ausgeführt, wenn ein Fehler hinzugefügt wird.

message kann entweder eine Zeichenkette oder ein regulärer Ausdruck sein, der ein Muster von Meldungen enthält. Im letzteren Fall führt das erste übereinstimmende Muster bei jeder aufgetretenen Warnung zu einem Fehler, während die übrigen Muster ignoriert werden.

Alle Muster werden am Ende jeder Testfunktion gelöscht.

Der folgende Ausschnitt schlägt beispielsweise fehl, wenn eine Warnung mit dem Text "Something bad happened" ausgegeben wird:

failOnWarning("Something bad happened")

Das folgende Snippet schlägt einen Test fehl, wenn eine Warnung auftritt, die dem angegebenen Muster entspricht:

failOnWarning(/[0-9]+ bad things happened/)

Um jeden Test, der eine bestimmte Warnung auslöst, fehlschlagen zu lassen, übergeben Sie einen geeigneten regulären Ausdruck in init() an diese Funktion:

function init() {
    failOnWarning(/.?/)
}

Hinweis: Obwohl es sich um ein JavaScript RegExp-Objekt handelt, wird es nicht als solches interpretiert; stattdessen wird das Muster an QRegularExpression übergeben.

Hinweis: ignoreMessage() hat Vorrang vor dieser Funktion, so dass alle Warnungen, die mit einem Muster übereinstimmen, das sowohl an ignoreMessage() als auch an failOnWarning() übergeben wurde, ignoriert werden.

Diese Methode wurde in Qt 6.3 eingeführt.

Siehe auch QTest::failOnWarning() und warn().


QtObject findChild(parent, objectName)

Gibt das erste Kind von parent mit objectName zurück, oder null, wenn kein solches Element existiert. Sowohl visuelle als auch nicht-visuelle Kinder werden rekursiv durchsucht, wobei die visuellen Kinder zuerst durchsucht werden.

compare(findChild(item, "childObject"), expectedChildObject);

fuzzyCompare(actual, expected, delta, message = "")

Schlägt den aktuellen Testfall fehl, wenn die Differenz zwischen actual und expected größer als delta ist, und zeigt das optionale message an. Ähnlich wie qFuzzyCompare(actual, expected) in C++, aber mit einem erforderlichen delta Wert.

Diese Funktion kann auch für Farbvergleiche verwendet werden, wenn sowohl die Werte actual als auch expected in Farbwerte umgewandelt werden können. Wenn eine der Differenzen für RGBA-Kanalwerte größer als delta ist, schlägt der Test fehl.

Siehe auch tryCompare() und compare().


object grabImage(item)

Gibt ein Snapshot-Bildobjekt des angegebenen item zurück.

Das zurückgegebene Bildobjekt hat die folgenden Eigenschaften:

  • width Gibt die Breite des zugrunde liegenden Bildes zurück (seit 5.10)
  • height Gibt die Höhe des zugrunde liegenden Bildes zurück (seit 5.10)
  • size Gibt die Größe des zugrunde liegenden Bildes zurück (seit 5.10)

Zusätzlich hat das zurückgegebene Bildobjekt die folgenden Methoden:

  • red(x, y) Gibt den Rotkanalwert des Pixels an der Position x, y zurück
  • green(x, y) Gibt den Wert des grünen Kanals des Pixels an der Position x, y zurück
  • blue(x, y) Gibt den Wert des blauen Kanals des Pixels an der Position x, y zurück
  • alpha(x, y) Gibt den Alphakanalwert des Pixels an der Position x, y zurück
  • pixel(x, y) Gibt den Farbwert des Pixels an der Position x, y zurück
  • equals(image) Gibt true zurück, wenn dieses Bild mit image identisch ist - siehe QImage::operator== (seit 5.6)

    Zum Beispiel:

    let image = grabImage(rect);
    compare(image.red(10, 10), 255);
    compare(image.pixel(20, 20), Qt.rgba(255, 0, 0, 255));
    
    rect.width += 10;
    let newImage = grabImage(rect);
    verify(!newImage.equals(image));
  • save(path) Speichert das Bild unter dem angegebenen Pfad. Wenn das Bild nicht gespeichert werden kann, wird eine Ausnahme geworfen. (seit 5.10)

    Dies kann nützlich sein, um z.B. eine Postmortem-Analyse von fehlgeschlagenen Tests durchzuführen:

    let image = grabImage(rect);
    try {
        compare(image.width, 100);
    } catch (ex) {
        image.save("debug.png");
        throw ex;
    }

ignoreWarning(message)

Markiert message als eine ignorierte Warnmeldung. Wenn sie auftritt, wird die Warnung nicht gedruckt und der Test ist bestanden. Wenn die Meldung nicht auftritt, schlägt der Test fehl. Ähnlich wie QTest::ignoreMessage(QtWarningMsg, message) in C++.

Seit Qt 5.12 kann message entweder eine Zeichenkette oder ein regulärer Ausdruck sein, der ein Muster von zu ignorierenden Meldungen enthält.

Zum Beispiel ignoriert das folgende Snippet eine String-Warnmeldung:

ignoreWarning("Something sort of bad happened")

Und das folgende Snippet ignoriert einen regulären Ausdruck, der auf eine Reihe von möglichen Warnmeldungen passt:

ignoreWarning(new RegExp("[0-9]+ bad things happened"))

Hinweis: Obwohl es sich um ein JavaScript-RegExp-Objekt handelt, wird es nicht als solches interpretiert; stattdessen wird das Muster an QRegularExpression übergeben.

Siehe auch warn().


init()

Diese Funktion wird vor jeder Testfunktion aufgerufen, die im Typ TestCase ausgeführt wird. Die Standardimplementierung tut nichts. Die Anwendung kann ihre eigene Implementierung bereitstellen, um die Initialisierung vor jeder Testfunktion durchzuführen.

Siehe auch cleanup() und initTestCase().


initTestCase()

Diese Funktion wird vor allen anderen Testfunktionen des Typs TestCase aufgerufen. Die Standardimplementierung tut nichts. Die Anwendung kann ihre eigene Implementierung zur Durchführung der Testfallinitialisierung bereitstellen.

Siehe auch cleanupTestCase() und init().


bool isPolishScheduled(object itemOrWindow)

Wenn itemOrWindow ein Item ist, gibt diese Funktion true zurück, wenn updatePolish() seit dem letzten Aufruf von polish() nicht aufgerufen wurde, andernfalls gibt sie false zurück.

Seit Qt 6.5, wenn itemOrWindow ein Window ist, gibt diese Funktion true zurück, wenn updatePolish() seit dem letzten Aufruf von polish() auf keinem von ihr verwalteten Element aufgerufen wurde, andernfalls gibt sie false zurück.

Bei der Zuweisung von Werten zu Eigenschaften in QML wird das Layout des Elements als Ergebnis der Zuweisung möglicherweise nicht sofort wirksam, sondern kann verschoben werden, bis das Element poliert ist. In diesen Fällen können Sie diese Funktion verwenden, um sicherzustellen, dass die Elemente poliert wurden, bevor die Ausführung des Tests fortgesetzt wird. Ein Beispiel:

verify(isPolishScheduled(item))
verify(waitForItemPolished(item))

Ohne den obigen Aufruf von isPolishScheduled() würde der Aufruf von waitForItemPolished() möglicherweise feststellen, dass kein Polieren geplant war, und daher den Test sofort bestehen, in der Annahme, dass das Objekt bereits poliert wurde. Diese Funktion macht deutlich, warum ein Objekt nicht poliert wurde, und ermöglicht es, dass Tests unter solchen Umständen frühzeitig fehlschlagen.

Siehe auch waitForPolish(), QQuickItem::polish(), und QQuickItem::updatePolish().


keyClick(key, modifiers = Qt.NoModifier, delay = -1)

Simuliert das Anklicken von key mit optionalem modifiers auf dem aktuell fokussierten Element. Wenn delay größer als 0 ist, wartet der Test auf delay Millisekunden.

Das Ereignis wird an das Fenster TestCase oder, im Falle mehrerer Fenster, an das aktuell aktive Fenster gesendet. Siehe QGuiApplication::focusWindow() für weitere Einzelheiten.

Siehe auch keyPress() und keyRelease().


keyPress(key, modifiers = Qt.NoModifier, delay = -1)

Simuliert das Drücken einer key mit optionaler modifiers auf das aktuell fokussierte Element. Wenn delay größer als 0 ist, wartet der Test auf delay Millisekunden.

Das Ereignis wird an das Fenster TestCase oder, im Falle mehrerer Fenster, an das aktuell aktive Fenster gesendet. Siehe QGuiApplication::focusWindow() für weitere Einzelheiten.

Hinweis: Zu einem bestimmten Zeitpunkt sollten Sie die Taste mit keyRelease() loslassen.

Siehe auch keyRelease() und keyClick().


keyRelease(key, modifiers = Qt.NoModifier, delay = -1)

Simuliert das Loslassen einer key mit optionalem modifiers auf dem aktuell fokussierten Element. Wenn delay größer als 0 ist, wartet der Test auf delay Millisekunden.

Das Ereignis wird an das Fenster TestCase oder, im Falle mehrerer Fenster, an das aktuell aktive Fenster gesendet. Siehe QGuiApplication::focusWindow() für weitere Einzelheiten.

Siehe auch keyPress() und keyClick().


keySequence(keySequence)

Simuliert das Tippen von keySequence. Die Tastenfolge kann auf eine der standard keyboard shortcuts festgelegt werden, oder sie kann mit einem String beschrieben werden, der eine Folge von bis zu vier Tastendrücken enthält.

Jedes Ereignis wird an das Fenster TestCase oder, bei mehreren Fenstern, an das aktuell aktive Fenster gesendet. Siehe QGuiApplication::focusWindow() für weitere Einzelheiten.

Siehe auch keyPress(), keyRelease(), GNU Emacs Style Key Sequences, und Shortcut.sequence.


mouseClick(item, x = item.width / 2, y = item.height / 2, button = Qt.LeftButton, modifiers = Qt.NoModifier, delay = -1)

Simuliert einen Mausklick button mit optionalem modifiers auf item. Die Position des Klicks wird durch x und y definiert. Wenn x und y nicht definiert sind, ist die Position die Mitte von item. Wenn delay angegeben ist, wartet der Test die angegebene Anzahl von Millisekunden, bevor die Taste gedrückt und wieder losgelassen wird.

Die durch x und y angegebene Position wird aus dem Koordinatensystem von item in Fensterkoordinaten umgewandelt und dann ausgegeben. Wenn item von einem anderen Element verdeckt wird oder ein untergeordnetes Element von item diese Position einnimmt, wird das Ereignis stattdessen an das andere Element weitergeleitet.

Siehe auch mousePress(), mouseRelease(), mouseDoubleClickSequence(), mouseMove(), mouseDrag(), und mouseWheel().


mouseDoubleClickSequence(item, x = item.width / 2, y = item.height / 2, button = Qt.LeftButton, modifiers = Qt.NoModifier, delay = -1)

Simuliert die vollständige Abfolge von Ereignissen, die durch einen Doppelklick einer Maus button mit optionalem modifiers auf ein item erzeugt werden.

Diese Methode reproduziert die Abfolge der Mausereignisse, die erzeugt werden, wenn ein Benutzer einen Doppelklick ausführt: Drücken-Freigeben-Drücken-Doppelklick-Freigeben.

Die Position des Klicks wird durch x und y definiert. Wenn x und y nicht definiert sind, ist die Position die Mitte von item. Wenn delay angegeben ist, wartet der Test die angegebene Anzahl von Millisekunden, bevor die Taste gedrückt und losgelassen wird.

Die durch x und y angegebene Position wird aus dem Koordinatensystem von item in Fensterkoordinaten umgewandelt und dann ausgegeben. Wenn item von einem anderen Element verdeckt wird oder ein untergeordnetes Element von item diese Position einnimmt, wird das Ereignis stattdessen an das andere Element weitergeleitet.

Diese QML-Methode wurde in Qt 5.5 eingeführt.

Siehe auch mousePress(), mouseRelease(), mouseClick(), mouseMove(), mouseDrag(), und mouseWheel().


mouseDrag(item, x, y, dx, dy, button = Qt.LeftButton, modifiers = Qt.NoModifier, delay = -1)

Simuliert das Ziehen der Maus auf einem item mit gedrückter button und optionalem modifiers. Die anfängliche Ziehposition wird durch x und y definiert, die Ziehdistanz durch dx und dy. Wenn delay angegeben ist, wartet der Test die angegebene Anzahl von Millisekunden, bevor die Taste losgelassen wird.

Die durch x und y angegebene Position wird aus dem Koordinatensystem von item in Fensterkoordinaten umgewandelt und dann ausgegeben. Wenn item von einem anderen Element verdeckt wird oder ein untergeordnetes Element von item diese Position einnimmt, wird das Ereignis stattdessen an das andere Element weitergeleitet.

Siehe auch mousePress(), mouseClick(), mouseDoubleClickSequence(), mouseMove(), mouseRelease(), und mouseWheel().


mouseMove(item, x = item.width / 2, y = item.height / 2, delay = -1, buttons = Qt.NoButton)

Bewegt den Mauszeiger an die durch x und y angegebene Position innerhalb von item, während buttons gehalten wird, falls angegeben. Seit Qt 6.0, wenn x und y nicht definiert sind, ist die Position das Zentrum von item.

Wenn eine delay (in Millisekunden) angegeben wird, wartet der Test, bevor der Mauszeiger bewegt wird.

Die von x und y angegebene Position wird aus dem Koordinatensystem von item in Fensterkoordinaten umgewandelt und dann übergeben. Wenn item von einem anderen Element verdeckt wird oder ein untergeordnetes Element von item diese Position einnimmt, wird das Ereignis stattdessen an das andere Element weitergeleitet.

Siehe auch mousePress(), mouseRelease(), mouseClick(), mouseDoubleClickSequence(), mouseDrag(), und mouseWheel().


mousePress(item, x = item.width / 2, y = item.height / 2, button = Qt.LeftButton, modifiers = Qt.NoModifier, delay = -1)

Simuliert das Drücken einer Maus button mit optionalem modifiers auf item. Die Position wird durch x und y definiert. Wenn x oder y nicht definiert sind, ist die Position das Zentrum von item. Wenn delay angegeben ist, wartet der Test die angegebene Anzahl von Millisekunden vor dem Drücken.

Die durch x und y angegebene Position wird aus dem Koordinatensystem von item in Fensterkoordinaten umgewandelt und dann ausgegeben. Wenn item von einem anderen Element verdeckt wird oder ein untergeordnetes Element von item diese Position einnimmt, wird das Ereignis stattdessen an das andere Element übermittelt.

Siehe auch mouseRelease(), mouseClick(), mouseDoubleClickSequence(), mouseMove(), mouseDrag(), und mouseWheel().


mouseRelease(item, x = item.width / 2, y = item.height / 2, button = Qt.LeftButton, modifiers = Qt.NoModifier, delay = -1)

Simuliert das Loslassen einer Maus button mit dem optionalen modifiers auf einem item. Die Position des Loslassens wird durch x und y definiert. Wenn x oder y nicht definiert sind, ist die Position die Mitte von item. Wenn delay angegeben ist, wartet der Test die angegebene Anzahl von Millisekunden, bevor die Taste losgelassen wird.

Die durch x und y angegebene Position wird aus dem Koordinatensystem von item in Fensterkoordinaten umgewandelt und dann ausgegeben. Wenn item von einem anderen Element verdeckt wird oder ein untergeordnetes Element von item diese Position einnimmt, wird das Ereignis stattdessen an das andere Element weitergeleitet.

Siehe auch mousePress(), mouseClick(), mouseDoubleClickSequence(), mouseMove(), mouseDrag(), und mouseWheel().


mouseWheel(item, x, y, xDelta, yDelta, button = Qt.LeftButton, modifiers = Qt.NoModifier, delay = -1)

Simuliert das Drehen des Mausrads auf einem item mit gedrücktem button und optionalem modifiers. Die Position des Radereignisses wird durch x und y definiert. Wenn delay angegeben ist, wartet der Test die angegebene Anzahl von Millisekunden, bevor er die Taste loslässt.

Die durch x und y angegebene Position wird aus dem Koordinatensystem von item in Fensterkoordinaten umgewandelt und dann ausgegeben. Wenn item von einem anderen Element verdeckt wird oder ein untergeordnetes Element von item diese Position einnimmt, wird das Ereignis stattdessen an das andere Element weitergeleitet.

xDelta und yDelta enthalten den Abstand der Radumdrehung in Achtelgraden. Siehe QWheelEvent::angleDelta() für weitere Einzelheiten.

Siehe auch mousePress(), mouseClick(), mouseDoubleClickSequence(), mouseMove(), mouseRelease(), mouseDrag(), und QWheelEvent::angleDelta().


skip(message = "")

Überspringt den aktuellen Testfall und gibt den optionalen message aus. Handelt es sich um einen datengesteuerten Test, so wird nur die aktuelle Zeile übersprungen. Ähnlich wie QSKIP(message) in C++.


sleep(ms)

Schläft für ms Millisekunden, ohne Qt-Ereignisse zu verarbeiten.

Siehe auch wait() und waitForRendering().


TouchEventSequence touchEvent(object item)

Beginnt eine Sequenz von Berührungsereignissen durch einen simulierten Touchscreen (QPointingDevice). Die Ereignisse werden an das Fenster geliefert, das item enthält.

Das zurückgegebene Objekt wird zum Aufzählen von Ereignissen verwendet, die über ein einzelnes QTouchEvent geliefert werden. Berührungen werden an das Fenster geliefert, das TestCase enthält, sofern nicht anders angegeben.

Rectangle {
    width: 640; height: 480

    MultiPointTouchArea {
        id: area
        anchors.fill: parent

        property bool touched: false

        onPressed: touched = true
    }

    TestCase {
        name: "ItemTests"
        when: windowShown
        id: test1

        function test_touch() {
            let touch = touchEvent(area);
            touch.press(0, area, 10, 10);
            touch.commit();
            verify(area.touched);
        }
    }
}

Siehe auch TouchEventSequence::press(), TouchEventSequence::move(), TouchEventSequence::release(), TouchEventSequence::stationary(), TouchEventSequence::commit(), und QInputDevice::DeviceType.


tryCompare(obj, property, expected, timeout = 5000, message = "")

Der aktuelle Testfall schlägt fehl, wenn die auf obj angegebene property nicht mit expected übereinstimmt, und zeigt die optionale message an. Der Test wird mehrmals wiederholt, bis die timeout (in Millisekunden) erreicht ist.

Diese Funktion ist für das Testen von Anwendungen gedacht, bei denen eine Eigenschaft ihren Wert auf der Grundlage asynchroner Ereignisse ändert. Verwenden Sie compare(), um synchrone Eigenschaftsänderungen zu testen.

tryCompare(img, "status", BorderImage.Ready)
compare(img.width, 120)
compare(img.height, 120)
compare(img.horizontalTileMode, BorderImage.Stretch)
compare(img.verticalTileMode, BorderImage.Stretch)

SignalSpy::wait() bietet eine alternative Methode, um auf ein Signal zu warten, das ausgesendet wird.

Siehe auch compare() und SignalSpy::wait().


tryVerify(function, timeout = 5000, message = "")

Der aktuelle Testfall schlägt fehl, wenn function nicht nach true ausgewertet wird, bevor die angegebene Zeitspanne timeout (in Millisekunden) verstrichen ist. Die Funktion wird mehrfach ausgewertet, bis die Zeitüberschreitung erreicht ist. Bei einem Fehlschlag wird eine optionale message angezeigt.

Diese Funktion ist für das Testen von Anwendungen gedacht, bei denen sich eine Bedingung aufgrund von asynchronen Ereignissen ändert. Verwenden Sie verify() zum Testen synchroner Zustandsänderungen und tryCompare() zum Testen asynchroner Eigenschaftsänderungen.

Im folgenden Code ist es beispielsweise nicht möglich, tryCompare() zu verwenden, da die Eigenschaft currentItem für einen kurzen Zeitraum null sein könnte:

tryCompare(listView.currentItem, "text", "Hello");

Stattdessen können wir tryVerify() verwenden, um zunächst zu prüfen, ob currentItem nicht null ist, und anschließend einen regulären Vergleich verwenden:

tryVerify(function(){ return listView.currentItem })
compare(listView.currentItem.text, "Hello")

Siehe auch verify(), compare(), tryCompare(), und SignalSpy::wait().


verify(condition, message = "")

Schlägt den aktuellen Testfall fehl, wenn condition falsch ist, und zeigt den optionalen message an. Ähnlich wie QVERIFY(condition) oder QVERIFY2(condition, message) in C++.


wait(ms)

Wartet auf ms Millisekunden während der Verarbeitung von Qt-Ereignissen.

Hinweis: Diese Methode verwendet einen präzisen Timer, um das eigentliche Warten durchzuführen. Das Ereignis, auf das Sie warten, kann es nicht sein. Insbesondere können alle Animationen sowie der Timer QML-Typ entweder präzise oder grobe Timer verwenden, abhängig von verschiedenen Faktoren. Bei einem groben Timer müssen Sie mit einer Abweichung von etwa 5% gegenüber dem präzisen Timer rechnen, der von TestCase::wait() verwendet wird. Qt kann allerdings keine festen Garantien für die Drift geben, da das Betriebssystem in der Regel keine festen Garantien für Timer bietet.

Siehe auch sleep(), waitForRendering(), und Qt::TimerType.


[since 6.5] bool waitForPolish(object windowOrItem, int timeout = 5000)

Wenn windowOrItem ein Item ist, wartet diese Funktion für timeout Millisekunden oder bis isPolishScheduled(windowOrItem) false zurückgibt. Gibt true zurück, wenn isPolishScheduled(windowOrItem) innerhalb von timeout Millisekunden false zurückgibt, andernfalls gibt sie false zurück.

Wenn windowOrItem ein Fenster ist, wartet diese Funktion für timeout Millisekunden oder bis isPolishScheduled() false für alle von dem Fenster verwalteten Elemente zurückgibt. Gibt true zurück, wenn isPolishScheduled() für alle Elemente innerhalb von timeout Millisekunden false zurückgibt, andernfalls false.

Diese Methode wurde in Qt 6.5 eingeführt.

Siehe auch isPolishScheduled(), QQuickItem::polish(), und QQuickItem::updatePolish().


waitForRendering(item, timeout = 5000)

Wartet auf timeout Millisekunden oder bis item vom Renderer gerendert wird. Gibt true zurück, wenn item in timeout Millisekunden gerendert wird, andernfalls false. Der Standardwert von timeout ist 5000.

Siehe auch sleep() und wait().


warn(message)

Druckt message als Warnmeldung. Ähnlich wie qWarning(message) in C++.

Siehe auch ignoreWarning().


© 2025 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.