TestCase QML Type

Stellt einen Unit-Testfall dar. Mehr...

• Liste aller Mitglieder, einschließlich geerbter Mitglieder
• Veraltete Elemente

Eigenschaften

• completed : bool
• name : string
• running : bool
• when : bool
• windowShown : bool

Methoden

• cleanup()
• cleanupTestCase()
• compare(actual, expected, message)
• QtObject createTemporaryObject(Component component, QtObject parent, var properties)
• QtObject createTemporaryQmlObject(string qml, QtObject parent, string filePath)
• expectFail(tag, message)
• expectFailContinue(tag, message)
• fail(message)
• failOnWarning(message) (since 6.3)
• QtObject findChild(parent, objectName)
• fuzzyCompare(actual, expected, delta, message)
• QtObject grabImage(Item item)
• ignoreWarning(message)
• init()
• initTestCase()
• bool isPolishScheduled(object itemOrWindow)
• keyClick(key, modifiers, delay)
• keyPress(key, modifiers, delay)
• keyRelease(key, modifiers, delay)
• keySequence(keySequence)
• mouseClick(item, x, y, button, modifiers, delay)
• mouseDoubleClickSequence(item, x, y, button, modifiers, delay)
• mouseDrag(item, x, y, dx, dy, button, modifiers, delay)
• mouseMove(item, x, y, delay, buttons)
• mousePress(item, x, y, button, modifiers, delay)
• mouseRelease(item, x, y, button, modifiers, delay)
• mouseWheel(item, x, y, xDelta, yDelta, button, modifiers, delay)
• skip(message)
• sleep(ms)
• TouchEventSequence touchEvent(object item)
• tryCompare(obj, property, expected, timeout, message)
• tryVerify(function, timeout, message)
• verify(condition, message)
• wait(ms)
• bool waitForPolish(object windowOrItem, int timeout) (since 6.5)
• waitForRendering(item, timeout)
• warn(message)

Ausführliche 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 den Funktionen in der Ausgabe ein Präfix 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 Vorhersehbarkeit zu verbessern, sortiert das Test-Framework die Funktionen in aufsteigender Reihenfolge nach ihrem Namen. Dies kann hilfreich sein, wenn zwei Tests in einer bestimmten Reihenfolge ausgeführt werden müssen.

Es können mehrere „TestCase“-Typen angegeben werden. Das Testprogramm wird beendet, sobald alle abgeschlossen sind.

Datengesteuerte Tests

Tabellendaten können einem Test über einen Funktionsnamen bereitgestellt werden, der mit „_data“ endet. Alternativ kann die Funktion „ init_data() “ verwendet werden, um Standardtestdaten für alle Testfunktionen bereitzustellen, für die kein entsprechender „_data“-Funktionsname in einem TestCase-Typ vorhanden ist:

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 durchläuft alle Zeilen der Tabelle und übergibt jede Zeile an die Testfunktion. Wie gezeigt, können die Spalten zur Verwendung im Test extrahiert werden. Die Spalte „ tag “ hat eine besondere Funktion – sie wird vom Test-Framework ausgegeben, wenn eine Zeile fehlschlägt, um dem Leser zu helfen, den fehlgeschlagenen Fall in einer Reihe von ansonsten erfolgreichen Tests zu identifizieren.

Benchmarks

Funktionen, deren Namen mit „benchmark_“ beginnen, werden mehrfach mit dem Qt-Benchmark-Framework ausgeführt, wobei ein durchschnittlicher Zeitwert für die Durchläufe gemeldet wird. Dies entspricht der Verwendung des Makros „ QBENCHMARK “ in der C++-Version von 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 Makros „ QBENCHMARK_ONCE “ zu erzielen, muss dem Namen der Testfunktion das Präfix „benchmark_once_“ vorangestellt werden.

Simulieren von Tastatur- und Mausereignissen

Die Methoden „ keyPress()“, „ keyRelease()“ und „ keyClick()“ können verwendet werden, um Tastaturereignisse innerhalb von Unit-Tests zu simulieren. Die Ereignisse werden an das aktuell fokussierte QML-Element übermittelt. Sie können entweder einen Wert aus der Enumeration „Qt.Key“ oder ein „latin1“-Zeichen (Zeichenkette 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 auf ähnliche Weise zur Simulation von Mausereignissen verwendet werden.

Wenn Ihr Test weitere Fenster erstellt, kann es vorkommen, dass diese Fenster aktiv werden und dem Fenster des TestCase den Fokus entziehen. Um sicherzustellen, dass das Fenster des 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 wurde. Versuche, Ereignisse vor diesem Zeitpunkt auszulösen, schlagen fehl. Verwenden Sie die Eigenschaften „ when “ und „ windowShown “, um zu verfolgen, wann das Hauptfenster angezeigt wurde.

Verwaltung dynamisch erstellter Testobjekte

Ein typisches Muster bei QML-Tests besteht darin, ein Element dynamisch zu erstellen und es am Ende der Testfunktion wieder zu löschen:

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 besteht darin, dass Fehler in der Testfunktion dazu führen, dass der Aufruf von ` item.destroy() ` übersprungen wird, wodurch das Element so lange in der Szene verbleibt, bis der Testfall beendet ist. Dies kann zu Störungen bei zukünftigen Tests führen, beispielsweise durch das Blockieren von Eingabeereignissen oder das Erzeugen irrelevanter Debug-Ausgaben, die es erschweren, die Ausführung des Codes nachzuvollziehen.

Durch den Aufruf von ` createTemporaryQmlObject()` wird hingegen sichergestellt, dass das Objekt am Ende der Testfunktion zerstört wird:

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` erstellt wurden, kann die Funktion ` createTemporaryObject()` verwendet werden.

Tests von der Anwendungslogik trennen

In den meisten Fällen ist es sinnvoll, die Tests von der Anwendungslogik zu trennen, indem man sie in verschiedene Projekte aufteilt und miteinander verknüpft.

Beispielsweise könnten Sie folgende Projektstruktur verwenden:

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

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

    ...
qt_add_library(MyModule STATIC)

qt6_add_qml_module(MyModule
    URI MyModule
    QML_FILES MyButton.qml
)
    ...

    ...
add_executable(TestMyApplication main.cpp
               setup.cpp setup.h)

add_test(NAME TestMyApplication COMMAND TestMyApplication)

target_link_libraries(TestMyApplication
    PRIVATE
        Qt6::QuickTest
        Qt6::Qml
        MyModule
        MyModuleplugin
)
    ...

#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
)
    ...

Anschließend können Sie in „ tests/tst_testqml.qml “ die Datei „ 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.

Dokumentation zu Eigenschaften

completed : bool

Diese Eigenschaft wird auf „true“ gesetzt, sobald die Ausführung des Testfalls abgeschlossen ist. Testfälle werden nur einmal ausgeführt. Der Anfangswert ist „false“.

Siehe auch running und when.

name : string

Diese Eigenschaft legt den Namen des Testfalls für die Ergebnisauswertung fest. Der Standardwert ist eine leere Zeichenkette.

TestCase {
    name: "ButtonTests"
    ...
}

running : bool

Diese Eigenschaft wird während der Ausführung des Testfalls auf „true“ gesetzt. Der Anfangswert ist „false“, und der Wert wird nach Abschluss des Testfalls wieder auf „false“ gesetzt.

Siehe auch completed und when.

when : bool

Diese Eigenschaft sollte auf „true“ gesetzt werden, wenn die Anwendung die Ausführung der Testfälle wünscht. 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 wurden.

Siehe auch „ completed “.

windowShown : bool

Diese Eigenschaft wird auf „true“ gesetzt, sobald das QML-Anzeigefenster eingeblendet wurde. Normalerweise werden Testfälle ausgeführt, sobald die Testanwendung geladen ist und noch bevor ein Fenster angezeigt wird. Wenn der Testfall visuelle Elemente und Verhaltensweisen umfasst, muss seine Ausführung möglicherweise bis nach der Einblendung 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");
        }
    }
}

Methodendokumentation

cleanup()

Diese Funktion wird nach jeder Testfunktion aufgerufen, die vom Typ „ TestCase “ ausgeführt wird. Die Standardimplementierung führt keine Aktion aus. Die Anwendung kann eine eigene Implementierung bereitstellen, um nach jeder Testfunktion Aufräumarbeiten durchzuführen.

Siehe auch „ init()“ und „ cleanupTestCase()“.

cleanupTestCase()

Diese Funktion wird aufgerufen, nachdem alle anderen Testfunktionen des Typs „ TestCase “ abgeschlossen sind. Die Standardimplementierung führt keine Aktion aus. Die Anwendung kann eine eigene Implementierung bereitstellen, um die Bereinigung der Testfälle durchzuführen.

Siehe auch „ initTestCase()“ und „ cleanup()“.

compare(actual, expected, message = "")

Der aktuelle Testfall schlägt fehl, wenn actual nicht mit expected übereinstimmt, und es wird die optionale Meldung message angezeigt. Ähnlich wie bei QCOMPARE(actual, expected) in C++.

Siehe auch tryCompare() und fuzzyCompare.

QtObject createTemporaryObject(Component component, QtObject parent, var properties)

Diese Funktion erstellt dynamisch ein QML-Objekt aus dem angegebenen ` component ` mit den optionalen Parametern ` parent ` und ` properties`. Das zurückgegebene Objekt wird (sofern es nicht bereits zerstört wurde) nach Abschluss der Ausführung von ` cleanup()` zerstört, was bedeutet, dass mit dieser Funktion erstellte Objekte garantiert nach jedem Test zerstört werden, unabhängig davon, ob die Tests fehlschlagen oder nicht.

Sollte beim Erstellen des Objekts ein Fehler aufgetreten sein, wird ` null ` zurückgegeben.

Diese Funktion ruft intern ` component.createObject()` auf.

Siehe auch ` Managing Dynamically Created Test Objects`.

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

Diese Funktion erstellt dynamisch ein QML-Objekt aus der angegebenen Zeichenfolge „ qml “ mit dem angegebenen „ parent “. Das zurückgegebene Objekt wird (sofern es nicht bereits zerstört wurde) nach Abschluss der Ausführung von „ cleanup()“ zerstört, was bedeutet, dass mit dieser Funktion erstellte Objekte garantiert nach jedem Test zerstört werden, unabhängig davon, ob die Tests fehlschlagen oder nicht.

Sollte beim Erstellen des Objekts ein Fehler aufgetreten sein, wird „ null “ zurückgegeben.

Wird ` filePath ` angegeben, wird dieser Wert für die Fehlermeldung des erstellten Objekts verwendet.

Diese Funktion ruft intern ` Qt.createQmlObject()` auf.

Siehe auch ` Managing Dynamically Created Test Objects`.

expectFail(tag, message)

Bei einem datengesteuerten Test wird die Zeile, die mit „ tag “ verknüpft ist, als voraussichtlich fehlgeschlagen markiert. Wenn der Fehler auftritt, wird die „ message “ angezeigt, der Test abgebrochen und der Test als bestanden markiert. Ähnlich wie bei „ QEXPECT_FAIL(tag, message, Abort) “ in C++.

Wenn es sich nicht um einen datengesteuerten Test handelt, muss ` tag ` auf eine leere Zeichenkette gesetzt werden.

Siehe auch expectFailContinue().

expectFailContinue(tag, message)

Bei einem datengesteuerten Test wird die Zeile, die mit tag verknüpft ist, als „erwartet fehlgeschlagen“ markiert. Wenn der Fehler auftritt, wird die Meldung „ message “ angezeigt, und der Test wird fortgesetzt. Ähnlich wie bei „ QEXPECT_FAIL(tag, message, Continue) “ in C++.

Wenn es sich nicht um einen datengesteuerten Test handelt, muss ` tag ` auf eine leere Zeichenkette gesetzt werden.

Siehe auch ` expectFail()`.

fail(message = "")

Lässt den aktuellen Testfall mit dem optionalen Parameter „ message “ scheitern. Ähnlich wie „ QFAIL(message) “ in C++.

[since 6.3] failOnWarning(message)

Fügt für jede Warnung, die mit message übereinstimmt, einen Testfehler zum Testprotokoll hinzu. Die Testfunktion setzt die Ausführung fort, wenn ein Fehler hinzugefügt wird.

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

Alle Muster werden am Ende jeder Testfunktion gelöscht.

Beispielsweise führt der folgende Codeausschnitt zu einem Testfehler, wenn eine Warnung mit dem Text „Something bad happened“ ausgegeben wird:

failOnWarning("Something bad happened")

Der folgende Codeausschnitt führt zu einem Testfehler, sobald eine Warnung auftritt, die dem angegebenen Muster entspricht:

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

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

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

Diese Methode wurde in Qt 6.3 eingeführt.

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

QtObject findChild(parent, objectName)

Gibt das erste untergeordnete Element von ` parent ` mit ` objectName` zurück oder ` null `, falls kein solches Element vorhanden ist. Dabei werden sowohl visuelle als auch nicht-visuelle untergeordnete Elemente rekursiv durchsucht, wobei visuelle untergeordnete Elemente zuerst durchsucht werden.

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

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

Der aktuelle Testfall wird als fehlgeschlagen gewertet, wenn die Differenz zwischen actual und expected größer ist als delta, und es wird die optionale Meldung message ausgegeben. Ähnlich wie qFuzzyCompare(actual, expected) in C++, jedoch mit einem erforderlichen Wert für delta.

Diese Funktion kann auch für Farbvergleiche verwendet werden, wenn sowohl der Wert von „ actual “ als auch der von „ expected “ in Farbwerte umgewandelt werden können. Ist einer der Unterschiede bei den RGBA-Kanalwerten größer als „ delta “, schlägt der Test fehl.

Siehe auch tryCompare() und compare().

QtObject grabImage(Item item)

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

Das zurückgegebene Bildobjekt verfügt über 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)

Darüber hinaus verfügt das zurückgegebene Bildobjekt über die folgenden Methoden:

• red(x, y) Gibt den Wert des Rotkanals des Pixels an der Position x, y zurück
• green(x, y) Gibt den Wert des Grünkanals 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 Wert des Alphakanals 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 dem Bild identisch ist – siehe QImage::operator== (seit 5.6)

  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 ausgelöst. (seit 5.10)

  Dies kann nützlich sein, um eine Post-Mortem-Analyse bei fehlgeschlagenen Tests durchzuführen, zum Beispiel:

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

ignoreWarning(message)

Kennzeichnet „ message “ als zu ignorierende Warnmeldung. Tritt diese Meldung auf, wird die Warnung nicht ausgegeben und der Test wird bestanden. Tritt die Meldung nicht auf, wird der Test nicht bestanden. Ä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 für zu ignorierende Meldungen angibt.

Beispielsweise ignoriert der folgende Codeausschnitt eine Warnmeldung in Form einer Zeichenkette:

ignoreWarning("Something sort of bad happened")

Und der folgende Codeausschnitt ignoriert einen regulären Ausdruck, der mit einer Reihe möglicher Warnmeldungen übereinstimmt:

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

Siehe auch ` warn()`.

init()

Diese Funktion wird vor jeder Testfunktion aufgerufen, die im Typ „ TestCase “ ausgeführt wird. Die Standardimplementierung führt keine Aktion aus. Die Anwendung kann eine eigene Implementierung bereitstellen, um vor jeder Testfunktion eine Initialisierung durchzuführen.

Siehe auch „ cleanup()“ und „ initTestCase()“.

initTestCase()

Diese Funktion wird vor allen anderen Testfunktionen des Typs „ TestCase “ aufgerufen. Die Standardimplementierung führt keine Aktion aus. Die Anwendung kann eine eigene Implementierung bereitstellen, um die Initialisierung der Testfälle durchzuführen.

Siehe auch „ cleanupTestCase()“ und „ init()“.

bool isPolishScheduled(object itemOrWindow)

Wenn „ itemOrWindow “ ein „ Item “ ist, gibt diese Funktion „ true “ zurück, sofern „ updatePolish()“ seit dem letzten Aufruf von „ polish()“ nicht auf dieses Objekt angewendet wurde; andernfalls wird „ false “ zurückgegeben.

Seit Qt 6.5 gibt diese Funktion, wenn „ itemOrWindow “ ein „ Window “ ist, „ true “ zurück, sofern „ updatePolish()“ seit dem letzten Aufruf von „ polish()“ für die von ihm verwalteten Elemente nicht auf eines dieser Elemente angewendet wurde; andernfalls wird „ false “ zurückgegeben.

Beim Zuweisen von Werten zu Eigenschaften in QML werden Layout-Änderungen, die das Element infolge der Zuweisung vornehmen muss, möglicherweise nicht sofort wirksam, sondern können stattdessen aufgeschoben werden, bis das Element „polished“ ist. In diesen Fällen können Sie diese Funktion verwenden, um sicherzustellen, dass Elemente „polished“ sind, bevor die Ausführung des Tests fortgesetzt wird. Zum Beispiel:

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

Ohne den obigen Aufruf von ` isPolishScheduled() ` könnte der Aufruf von ` waitForItemPolished() ` feststellen, dass keine Aufbereitung geplant war, und daher sofort erfolgreich sein – unter der Annahme, dass das Element bereits aufbereitet wurde. Diese Funktion macht deutlich, warum ein Element nicht aufbereitet 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 einen Klick auf key mit optionaler modifiers auf das Element, das derzeit den Fokus hat. Wenn delay größer als 0 ist, wartet der Test delay Millisekunden.

Weitere Informationen zu den zulässigen Formaten für „ key “ finden Sie unter Simulating Keyboard and Mouse Events.

Das Ereignis wird an das Fenster „ TestCase “ oder, bei mehreren Fenstern, an das aktuell aktive Fenster gesendet. Weitere Details finden Sie unter QGuiApplication::focusWindow().

Siehe auch keyPress() und keyRelease().

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

Simuliert das Drücken der Taste „ key “ mit optionaler „ modifiers “ auf dem Element, das derzeit den Fokus hat. Ist „ delay “ größer als 0, wartet der Test „ delay “ Millisekunden.

Weitere Informationen zu den zulässigen Formaten für „ key “ finden Sie unter „ Simulating Keyboard and Mouse Events “.

Das Ereignis wird an das Fenster „ TestCase “ oder, bei mehreren Fenstern, an das aktuell aktive Fenster gesendet. Weitere Details finden Sie unter QGuiApplication::focusWindow().

Hinweis: Zu einem späteren Zeitpunkt sollten Sie die Taste mit ` keyRelease()` wieder freigeben.

Siehe auch keyRelease() und keyClick().

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

Simuliert das Loslassen einer „ key “-Taste mit optionaler „ modifiers “-Einstellung für das Element, das derzeit im Fokus steht. Ist „ delay “ größer als 0, wartet der Test „ delay “ Millisekunden.

Weitere Informationen zu den zulässigen Formaten für „ key “ finden Sie unter Simulating Keyboard and Mouse Events.

Das Ereignis wird an das Fenster „ TestCase “ oder, bei mehreren Fenstern, an das aktuell aktive Fenster gesendet. Weitere Details finden Sie unter QGuiApplication::focusWindow().

Siehe auch keyPress() und keyClick().

keySequence(keySequence)

Simuliert die Tastenfolge „ keySequence “. Die Tastenfolge kann auf eine der folgenden Optionen eingestellt werden: „ standard keyboard shortcuts “ oder durch eine Zeichenkette beschrieben werden, die eine Abfolge von bis zu vier Tastenanschlägen enthält.

Jedes Ereignis wird an das Fenster „ TestCase “ gesendet oder, bei mehreren Fenstern, an das aktuell aktive Fenster. Weitere Details finden Sie unter „ QGuiApplication::focusWindow()“.

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 optionaler modifiers auf einer item. Die Position des Klicks wird durch x und y definiert. Sind x und y nicht definiert, liegt die Position in der Mitte von item. Ist delay angegeben, wartet der Test die angegebene Anzahl an 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 anschließend übermittelt. 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 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 gesamte Abfolge von Ereignissen, die durch einen Doppelklick mit der Maus button ausgelöst wird, mit optionaler modifiers auf einer item.

Diese Methode reproduziert die Abfolge von Mausereignissen, die bei einem Doppelklick eines Benutzers ausgelöst werden: Drücken-Loslassen-Drücken-Doppelklick-Loslassen.

Die Position des Klicks wird durch x und y definiert. Sind x und y nicht definiert, entspricht die Position der Mitte von item. Ist delay angegeben, 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 anschließend übermittelt. 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.

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 einer item bei gedrückter button und optional modifiers. Die Startposition für das Ziehen wird durch x und y definiert, die Ziehdistanz durch dx und dy. Wenn delay angegeben ist, wartet der Test die angegebene Anzahl an Millisekunden, bevor die Taste losgelassen wird.

Die durch x und y angegebene Position wird aus dem Koordinatensystem von item in Fensterkoordinaten umgewandelt und anschließend übermittelt. 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 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 Position, die durch x und y innerhalb von item angegeben wird, während buttons gehalten wird, sofern angegeben. Seit Qt 6.0 gilt: Wenn x und y nicht definiert sind, ist die Position die Mitte von item.

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

Die durch ` x ` und ` y ` angegebene Position wird aus dem Koordinatensystem von ` item ` in Fensterkoordinaten umgewandelt und anschließend übermittelt. 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 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 einer item. Die Position wird durch x und y definiert. Wenn x oder y nicht definiert sind, entspricht die Position der Mitte von item. Wenn delay angegeben ist, wartet der Test die angegebene Anzahl von Millisekunden, bevor der Klick ausgelöst wird.

Die durch x und y angegebene Position wird aus dem Koordinatensystem von item in Fensterkoordinaten umgewandelt und anschließend übermittelt. 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 optionalem modifiers auf einem item. Die Position des Loslassens wird durch x und y definiert. Wenn x oder y nicht definiert sind, entspricht die Position der 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 übermittelt. 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 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 einer item, wobei button gedrückt gehalten wird und optional modifiers. Die Position des Mausrad-Ereignisses wird durch x und y definiert. Wenn delay angegeben ist, wartet der Test die angegebene Anzahl an Millisekunden, bevor die Taste losgelassen wird.

Die durch x und y angegebene Position wird aus dem Koordinatensystem von item in Fensterkoordinaten umgewandelt und anschließend übermittelt. 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.

Die Parameter „ xDelta “ und „ yDelta “ enthalten den Drehwinkel des Rads in Achtelgrad. Weitere Details finden Sie unter QWheelEvent::angleDelta().

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

skip(message = "")

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

sleep(ms)

Wartet ms Millisekunden, ohne Qt-Ereignisse zu verarbeiten.

Siehe auch wait() und waitForRendering().

TouchEventSequence touchEvent(object item)

Startet eine Abfolge von Berührungsereignissen über einen simulierten Touchscreen (QPointingDevice). Die Ereignisse werden an das Fenster übermittelt, das item enthält.

Das zurückgegebene Objekt dient dazu, die Ereignisse aufzulisten, die über ein einzelnes ` QTouchEvent` übermittelt werden sollen. Berührungen werden an das Fenster übermittelt, 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 wird als fehlgeschlagen gewertet, wenn die unter obj angegebene „ property “ nicht mit expected übereinstimmt, und die optionale Meldung „ message “ wird angezeigt. Der Test wird so oft wiederholt, bis die unter timeout festgelegte Zeit (in Millisekunden) erreicht ist.

Diese Funktion ist für das Testen von Anwendungen vorgesehen, bei denen sich der Wert einer Eigenschaft aufgrund asynchroner Ereignisse ändert. Verwenden Sie „ compare()“ zum Testen synchroner Eigenschaftsänderungen.

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 die Ausgabe eines Signals zu warten.

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

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

Der aktuelle Testfall gilt als fehlgeschlagen, wenn „ function “ nicht zu „ true “ ausgewertet wird, bevor die angegebene Zeit „ timeout “ (in Millisekunden) abgelaufen ist. Die Funktion wird so lange mehrfach ausgewertet, bis das Timeout erreicht ist. Bei einem Fehlschlag wird ein optionaler Fehlertext „ message “ angezeigt.

Diese Funktion ist für das Testen von Anwendungen vorgesehen, bei denen sich eine Bedingung aufgrund asynchroner Ereignisse ändert. Verwenden Sie „ verify()“ zum Testen synchroner Bedingungsä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 möglicherweise den Wert ` null ` annimmt:

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

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

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

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

verify(condition, message = "")

Lässt den aktuellen Testfall fehlschlagen, wenn „ condition “ falsch ist, und zeigt die optionale Meldung „ message “ an. Ähnlich wie „ QVERIFY(condition) “ oder „ QVERIFY2(condition, message) “ in C++.

wait(ms)

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

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 timeout Millisekunden lang oder bis isPolishScheduled(windowOrItem) den Wert false zurückgibt. Gibt true zurück, wenn isPolishScheduled(windowOrItem) innerhalb von timeout Millisekunden den Wert false zurückgibt, andernfalls wird false zurückgegeben.

Wenn „ windowOrItem “ ein Fenster ist, wartet diese Funktion „ timeout “ Millisekunden lang oder bis „ isPolishScheduled() “ für alle vom Fenster verwalteten Elemente „ false “ 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 timeout Millisekunden oder so lange, bis das item vom Renderer gerendert wurde. Gibt „true“ zurück, wenn item innerhalb von timeout Millisekunden gerendert wurde, andernfalls „false“. Der Standardwert für timeout beträgt 5000.

Siehe auch „ sleep()“ und „ wait()“.

warn(message)

Gibt „ message “ als Warnmeldung aus. Ähnlich wie „ qWarning(message) “ in C++.

Siehe auch ignoreWarning().