QTest Namespace

Funktionsdokumentation

template <typename T> void QTest::addColumn(const char *name, T *dummy = 0)

Fügt den aktuellen Testdaten eine Spalte vom Typ „ T “ hinzu. „ name “ ist der Name der Spalte. „ dummy “ ist eine Umgehungslösung für fehlerhafte Compiler und kann ignoriert werden.

Um die Spalte mit Werten zu füllen, kann ` newRow()` verwendet werden. Verwenden Sie ` QFETCH()`, um die Daten im eigentlichen Test abzurufen.

Beispiel:

    QTest::addColumn<int>("intval");
    QTest::addColumn<QString>("str");
    QTest::addColumn<double>("dbl");
    QTest::newRow("row1") << 1 << "hello" << 1.5;

Ein ausführlicheres Beispiel finden Sie unter „Datengesteuertes Testen “.

Siehe auch „ QTest::newRow()“, „ QFETCH()“ und „ QMetaType “.

QTestData &QTest::addRow(const char *format, ...)

Fügt den aktuellen Testdaten eine neue Zeile hinzu.

Die Argumente der Funktion werden zur Formatierung gemäß format an std::snprintf() übergeben. Hinweise und Einschränkungen finden Sie in der Dokumentation zu std::snprintf().

Die Testausgabe identifiziert den Testlauf anhand dieser Testdaten mit dem Namen, der sich aus dieser Formatierung ergibt.

Gibt eine QTestData-Referenz zurück, die zum Einlesen von Daten verwendet werden kann, wobei für jede Spalte der Tabelle ein Wert übergeben wird.

Beispiel:

    QTest::addColumn<int>("input");
    QTest::addColumn<QString>("output");
    QTest::addRow("%d", 0) << 0 << QString("0");
    QTest::addRow("%d", 1) << 1 << QString("1");

Ein ausführlicheres Beispiel finden Sie unter „Datengesteuertes Testen “.

Siehe auch newRow(), addColumn() und QFETCH().

const char *QTest::benchmarkMetricName(QTest::QBenchmarkMetric metric)

Gibt den Enum-Wert „ metric “ als Zeichenfolge zurück.

const char *QTest::benchmarkMetricUnit(QTest::QBenchmarkMetric metric)

Gibt die Maßeinheiten für die angegebene „ metric “ zurück.

QPointingDevice *QTest::createTouchDevice(QInputDevice::DeviceType devType = QInputDevice::DeviceType::TouchScreen, QInputDevice::Capabilities caps = QInputDevice::Capability::Position)

Erstellt ein Dummy-Touch-Gerät vom Typ „ devType “ mit den Funktionen „ caps “ zur Simulation von Touch-Ereignissen.

Das Touch-Gerät wird bei der Qt-Fenstersystemschnittstelle registriert. In der Regel sollten Sie `createTouchDevice()` verwenden, um eine ` QPointingDevice `-Mitgliedsvariable in Ihrer Testfallklasse zu initialisieren, dieselbe Instanz für alle Tests zu verwenden und sie zu löschen, wenn sie nicht mehr benötigt wird.

Siehe auch „ QTest::QTouchEventSequence “ und „ touchEvent()“.

const char *QTest::currentAppName()

Gibt den Namen der derzeit ausgeführten Binärdatei zurück.

const char *QTest::currentDataTag()

Gibt den Namen der aktuellen Testdaten zurück. Wenn dem Test keine Testdaten zugewiesen sind, gibt die Funktion „ nullptr “ zurück.

[since 6.11] const char *QTest::currentGlobalDataTag()

Gibt den Namen der aktuellen globalen Testdaten zurück. Wenn dem Test keine globalen Testdaten zugewiesen sind, gibt die Funktion „ nullptr “ zurück.

Diese Funktion wurde in Qt 6.11 eingeführt.

bool QTest::currentTestFailed()

Gibt „ true “ zurück, wenn die aktuelle Testfunktion fehlgeschlagen ist, andernfalls „false“.

Siehe auch QTest::currentTestResolved().

const char *QTest::currentTestFunction()

Gibt den Namen der Testfunktion zurück, die gerade ausgeführt wird.

Beispiel:

void MyTestClass::cleanup()
{
    if (qstrcmp(QTest::currentTestFunction(), "myDatabaseTest") == 0) {
        // clean up all database connections
        closeAllDatabases();
    }
}

[since 6.5] bool QTest::currentTestResolved()

Gibt „ true “ zurück, wenn die aktuelle Testfunktion fehlgeschlagen ist oder übersprungen wurde.

Dies gilt, wenn der Test fehlgeschlagen ist oder ein Überspringen ausgelöst wurde. Ist der Wert „true“, sollte die Testfunktion vorzeitig zurückkehren. Insbesondere beenden die Makros „ QTRY_* “ und die Test-Ereignisschleife ihre Schleifen vorzeitig, wenn sie während der Testfunktion (jedoch nicht während deren `cleanup()`) ausgeführt werden. Nachdem ein Test eine Hilfsfunktion aufgerufen hat, die die Makros dieses Moduls verwendet, kann er diese Funktion nutzen, um zu prüfen, ob er vorzeitig zurückkehren soll.

Diese Funktion wurde in Qt 6.5 eingeführt.

Siehe auch ` QTest::currentTestFailed()`.

[since 6.3] void QTest::failOnWarning(const QRegularExpression &messagePattern)

Für jede Warnung, die der Bedingung „ messagePattern “ entspricht, wird ein Testfehler an das Testprotokoll angehängt.

Die Testfunktion setzt die Ausführung fort, wenn ein Fehler hinzugefügt wird. Um den Test stattdessen abzubrechen, können Sie currentTestFailed() prüfen und vorzeitig zurückkehren, falls der Wert „ true “ ist.

Bei jeder Warnung führt das erste Muster, das übereinstimmt, zu einem Fehler, während die übrigen Muster ignoriert werden.

Alle Muster werden am Ende jeder Testfunktion gelöscht.

void FileTest::loadFiles()
{
    QTest::failOnWarning(QRegularExpression("^Laden fehlgeschlagen"));

    // Jedes dieser Muster führt zu einem Testfehler:
    qWarning() << "Failed to load image";
    qWarning() << "Failed to load video";
}

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

void FileTest::init()
{
    QTest::failOnWarning(
        QRegularExpression("QFile::.*: File(.*) already open"));
}

Im gängigen Fall, bei dem bei jeder Warnung ein Test fehlschlagen soll, übergeben Sie keinen Parameter:

void FileTest::init()
{
    QTest::failOnWarning();
}

Diese Funktion wurde in Qt 6.3 eingeführt.

Siehe auch QTEST_FATAL_FAIL.

[since 6.8] void QTest::failOnWarning()

Fügt dem Testprotokoll einen Testfehler hinzu, sobald eine Warnung ausgegeben wird.

Diese Funktion wurde in Qt 6.8 eingeführt.

Siehe auch ` failOnWarning() (const char *)`.

[since 6.3] void QTest::failOnWarning(const char *message)

Fügt dem Testprotokoll einen Testfehler hinzu, wenn die Funktion „ message “ aufgerufen wird.

Diese Funktion wurde in Qt 6.3 eingeführt.

Siehe auch ` failOnWarning()`.

void QTest::ignoreMessage(QtMsgType type, const char *message)

Ignoriert Meldungen, die mit den Funktionen „ qDebug()“, „ qInfo()“ oder „ qWarning()“ erzeugt wurden. Wenn die Meldung „ message “ mit dem entsprechenden „ type “ ausgegeben wird, wird sie aus dem Testprotokoll entfernt. Wenn der Test abgeschlossen ist und die Meldung „ message “ nicht ausgegeben wurde, wird dem Testprotokoll ein Testfehler hinzugefügt.

Beispiel:

QDir dir;
QTest::ignoreMessage(QtWarningMsg, "QDir::mkdir: Empty or null file name(s)");
dir.mkdir("");

Das obige Beispiel testet, ob ` QDir::mkdir()` die richtige Warnung ausgibt, wenn es mit einem ungültigen Dateinamen aufgerufen wird.

void QTest::ignoreMessage(QtMsgType type, const QRegularExpression &messagePattern)

Ignoriert Meldungen, die mit den Funktionen „ qDebug()“, „ qInfo()“ oder „ qWarning()“ erzeugt wurden. Wenn eine Meldung ausgegeben wird, die dem Muster „ messagePattern “ mit dem entsprechenden „ type “ entspricht, wird sie aus dem Testprotokoll entfernt. Wenn der Test abgeschlossen ist und die Meldung nicht ausgegeben wurde, wird dem Testprotokoll ein Testfehler angehängt.

void QTest::keyClick(QWidget *widget, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)

Simuliert das Klicken auf „ key “ mit einem optionalen „ modifier “ auf einer „ widget “. Wenn „ delay “ größer als 0 ist, wartet der Test „ delay “ Millisekunden, bevor die Taste angeklickt wird.

Beispiele:

QTest::keyClick(myWidget, Qt::Key_Escape);

QTest::keyClick(myWidget, Qt::Key_Escape, Qt::ShiftModifier, 200);

Das erste Beispiel oben simuliert das Drücken der Taste „ escape “ auf myWidget ohne Tastaturmodifikatoren und ohne Verzögerung. Das zweite Beispiel simuliert das Drücken von shift-escape auf myWidget nach einer Verzögerung des Tests von 200 ms.

Siehe auch QTest::keyClicks().

void QTest::keyClick(QWidget *widget, char key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)

Simuliert das Klicken auf „ key “ mit einem optionalen „ modifier “ auf „ widget “. Ist „ delay “ größer als 0, wartet der Test „ delay “ Millisekunden, bevor die Taste angeklickt wird.

Beispiel:

QTest::keyClick(myWidget, 'a');

Das obige Beispiel simuliert das Klicken auf „ a “ unter myWidget ohne Tastaturmodifikatoren und ohne Verzögerung des Tests.

Siehe auch „ QTest::keyClicks()“.

void QTest::keyClick(QWindow *window, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)

Simuliert das Klicken auf „ key “ mit einem optionalen „ modifier “ auf einer „ window “. Ist „ delay “ größer als 0, wartet der Test „ delay “ Millisekunden, bevor die Taste angeklickt wird.

Beispiele:

QTest::keyClick(&myWindow, Qt::Key_Escape);
QTest::keyClick(&myWindow, Qt::Key_Escape, Qt::ShiftModifier, 200);

Das erste Beispiel oben simuliert das Drücken der Taste „ escape “ auf myWindow ohne Tastaturmodifikatoren und ohne Verzögerung. Das zweite Beispiel simuliert das Drücken von shift-escape auf myWindow nach einer Verzögerung des Tests von 200 ms.

Siehe auch QTest::keyClicks().

void QTest::keyClick(QWindow *window, char key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)

Simuliert das Klicken auf „ key “ mit einer optionalen Verzögerung von „ modifier “ auf der Seite window. Ist „ delay “ größer als 0, wartet der Test „ delay “ Millisekunden, bevor die Taste angeklickt wird.

Beispiel:

QWidget myWindow;
QTest::keyClick(&myWindow, Qt::Key_Tab);

Das obige Beispiel simuliert das Klicken auf „ a “ unter myWindow ohne Tastaturmodifikatoren und ohne Verzögerung des Tests.

Siehe auch „ QTest::keyClicks()“.

void QTest::keyClicks(QWidget *widget, const QString &sequence, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)

Simuliert das Klicken auf eine Tasten sequence auf einer Tastatur widget. Optional können eine Tastatur- modifier sowie eine delay (in Millisekunden) des Tests vor jedem Tastenklick angegeben werden.

Beispiel:

QTest::keyClicks(myWidget, "hello world");

Das obige Beispiel simuliert das Klicken der Tastenfolge, die „hello world“ darstellt, auf myWidget ohne Tastaturmodifikatoren und ohne Verzögerung des Tests.

Siehe auch QTest::keyClick().

void QTest::keyEvent(QTest::KeyAction action, QWidget *widget, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)

Sendet ein Qt-Tastenereignis an widget mit der angegebenen „ key “ und der zugehörigen „ action “. Optional können ein Tastatur modifier sowie eine „ delay “ (in Millisekunden) des Tests vor dem Senden des Ereignisses angegeben werden.

void QTest::keyEvent(QTest::KeyAction action, QWidget *widget, char ascii, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)

Sendet ein Qt-Tastenereignis an „ widget “ mit dem angegebenen Tasten ascii und dem zugehörigen „ action “. Optional können eine Tastatur modifier sowie eine „ delay “ (in Millisekunden) des Tests vor dem Senden des Ereignisses angegeben werden.

void QTest::keyEvent(QTest::KeyAction action, QWindow *window, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)

Sendet ein Qt-Tastenereignis an „ window “ mit dem angegebenen „ key “ und dem zugehörigen „ action “. Optional können ein Tastatur modifier sowie eine „ delay “ (in Millisekunden) des Tests vor dem Senden des Ereignisses angegeben werden.

void QTest::keyEvent(QTest::KeyAction action, QWindow *window, char ascii, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)

Sendet ein Qt-Tastenereignis an window mit der angegebenen Tasten ascii und der zugehörigen action. Optional können ein Tastatur modifier sowie eine delay (in Millisekunden) des Tests vor dem Senden des Ereignisses angegeben werden.

void QTest::keyPress(QWidget *widget, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)

Simuliert das Drücken einer Taste „ key “ mit einem optionalen „ modifier “ auf einer Taste „ widget “. Ist „ delay “ größer als 0, wartet der Test „ delay “ Millisekunden, bevor die Taste gedrückt wird.

Siehe auch QTest::keyRelease() und QTest::keyClick().

void QTest::keyPress(QWidget *widget, char key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)

Simuliert das Drücken der Taste „ key “ mit einem optionalen „ modifier “ auf einer Taste „ widget “. Ist „ delay “ größer als 0, wartet der Test „ delay “ Millisekunden, bevor die Taste gedrückt wird.

Siehe auch QTest::keyRelease() und QTest::keyClick().

void QTest::keyPress(QWindow *window, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)

Simuliert das Drücken der Taste „ key “ mit einem optionalen „ modifier “ auf einer „ window “. Wenn „ delay “ größer als 0 ist, wartet der Test „ delay “ Millisekunden, bevor die Taste gedrückt wird.

Siehe auch QTest::keyRelease() und QTest::keyClick().

void QTest::keyPress(QWindow *window, char key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)

Simuliert das Drücken der Taste „ key “ mit einem optionalen „ modifier “ auf einer „ window “. Ist „ delay “ größer als 0, wartet der Test „ delay “ Millisekunden, bevor die Taste gedrückt wird.

Siehe auch QTest::keyRelease() und QTest::keyClick().

void QTest::keyRelease(QWidget *widget, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)

Simuliert das Freigeben eines „ key “ mit einem optionalen „ modifier “ auf einem „ widget “. Ist „ delay “ größer als 0, wartet der Test „ delay “ Millisekunden, bevor der Schlüssel freigegeben wird.

Siehe auch QTest::keyPress() und QTest::keyClick().

void QTest::keyRelease(QWidget *widget, char key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)

Simuliert das Freigeben eines „ key “ mit einer optionalen „ modifier “ auf einem „ widget “. Ist „ delay “ größer als 0, wartet der Test „ delay “ Millisekunden, bevor der Schlüssel freigegeben wird.

Siehe auch QTest::keyClick().

void QTest::keyRelease(QWindow *window, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)

Simuliert das Freigeben eines „ key “ mit einem optionalen „ modifier “ auf einem „ window “. Ist „ delay “ größer als 0, wartet der Test „ delay “ Millisekunden, bevor der Schlüssel freigegeben wird.

Siehe auch QTest::keyPress() und QTest::keyClick().

void QTest::keyRelease(QWindow *window, char key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)

Simuliert das Freigeben eines „ key “ mit einem optionalen „ modifier “ auf einem „ window “. Ist „ delay “ größer als 0, wartet der Test „ delay “ Millisekunden, bevor der Schlüssel freigegeben wird.

Siehe auch QTest::keyClick().

void QTest::keySequence(QWidget *widget, const QKeySequence &keySequence)

Simuliert die Eingabe von „ keySequence “ in „ widget “.

Siehe auch QTest::keyClick() und QTest::keyClicks().

void QTest::keySequence(QWindow *window, const QKeySequence &keySequence)

Simuliert die Eingabe von „ keySequence “ in „ window “.

Siehe auch QTest::keyClick() und QTest::keyClicks().

void QTest::mouseClick(QWidget *widget, Qt::MouseButton button, Qt::KeyboardModifiers modifier = Qt::KeyboardModifiers(), QPoint pos = QPoint(), int delay = -1)

Simuliert einen Mausklick button mit einer optionalen modifier auf einem widget. Die Position des Klicks wird durch pos definiert; die Standardposition ist die Mitte des Widgets. Wenn delay angegeben ist, wartet der Test die angegebene Anzahl von Millisekunden, bevor die Taste gedrückt und wieder losgelassen wird.

Siehe auch QTest::mousePress() und QTest::mouseRelease().

void QTest::mouseClick(QWindow *window, Qt::MouseButton button, Qt::KeyboardModifiers stateKey = Qt::KeyboardModifiers(), QPoint pos = QPoint(), int delay = -1)

Simuliert einen Mausklick button mit einem optionalen Modifikator „ stateKey “ auf einer window. Die Position des Klicks wird durch pos definiert; die Standardposition ist die Mitte des Fensters. Wenn delay angegeben wird, wartet der Test die angegebene Anzahl an Millisekunden, bevor die Taste gedrückt und wieder losgelassen wird.

Siehe auch QTest::mousePress() und QTest::mouseRelease().

void QTest::mouseDClick(QWidget *widget, Qt::MouseButton button, Qt::KeyboardModifiers modifier = Qt::KeyboardModifiers(), QPoint pos = QPoint(), int delay = -1)

Simuliert einen Doppelklick mit der Maus button mit einem optionalen modifier auf einem widget. Die Position des Klicks wird durch pos definiert; die Standardposition ist die Mitte des Widgets. Wenn delay angegeben ist, wartet der Test vor jedem Drücken und Loslassen die angegebene Anzahl von Millisekunden.

Siehe auch „ QTest::mouseClick()“.

void QTest::mouseDClick(QWindow *window, Qt::MouseButton button, Qt::KeyboardModifiers stateKey = Qt::KeyboardModifiers(), QPoint pos = QPoint(), int delay = -1)

Simuliert einen Doppelklick mit der Maus button mit einem optionalen Modifikator „ stateKey “ auf einer window. Die Position des Klicks wird durch pos definiert; die Standardposition ist die Mitte des Fensters. Wenn delay angegeben ist, wartet der Test vor jedem Drücken und Loslassen die angegebene Anzahl an Millisekunden.

Siehe auch „ QTest::mouseClick()“.

void QTest::mouseMove(QWidget *widget, QPoint pos = QPoint(), int delay = -1)

Bewegt den Mauszeiger an eine Koordinate „ widget “. Wenn „ pos “ nicht angegeben ist, wird der Mauszeiger in die Mitte des Widgets bewegt. Wenn eine Verzögerung „ delay “ (in Millisekunden) angegeben wird, wartet das Skript, bevor der Mauszeiger bewegt wird.

void QTest::mouseMove(QWindow *window, QPoint pos = QPoint(), int delay = -1)

Bewegt den Mauszeiger an eine Koordinate „ window “. Wenn „ pos “ nicht angegeben ist, wird der Mauszeiger in die Mitte des Fensters bewegt. Wenn eine Verzögerung „ delay “ (in Millisekunden) angegeben wird, wartet die Funktion, bevor der Mauszeiger bewegt wird.

void QTest::mousePress(QWidget *widget, Qt::MouseButton button, Qt::KeyboardModifiers modifier = Qt::KeyboardModifiers(), QPoint pos = QPoint(), int delay = -1)

Simuliert das Drücken einer Maus button mit einem optionalen modifier auf einem widget. Die Position wird durch pos definiert; die Standardposition ist die Mitte des Widgets. Wenn delay angegeben wird, wartet der Test die angegebene Anzahl an Millisekunden, bevor der Klick ausgelöst wird.

Siehe auch QTest::mouseRelease() und QTest::mouseClick().

void QTest::mousePress(QWindow *window, Qt::MouseButton button, Qt::KeyboardModifiers stateKey = Qt::KeyboardModifiers(), QPoint pos = QPoint(), int delay = -1)

Simuliert das Drücken einer Maus button, optional mit dem Modifikator „ stateKey “, auf einem „ window “. Die Position wird durch „ pos “ definiert; die Standardposition ist die Mitte des Fensters. Wenn „ delay “ angegeben wird, wartet der Test die angegebene Anzahl von Millisekunden, bevor die Taste gedrückt wird.

Siehe auch „ QTest::mouseRelease()“ und „ QTest::mouseClick()“.

void QTest::mouseRelease(QWidget *widget, Qt::MouseButton button, Qt::KeyboardModifiers modifier = Qt::KeyboardModifiers(), QPoint pos = QPoint(), int delay = -1)

Simuliert das Loslassen einer Maus button, wobei optional ein modifier auf einem widget verwendet werden kann. Die Position des Loslassens wird durch pos definiert; die Standardposition ist die Mitte des Widgets. Wenn „ delay “ angegeben wird, wartet der Test die angegebene Zeit in Millisekunden ab, bevor die Taste losgelassen wird; andernfalls wartet er eine Standardzeit (1 ms), die über Befehlszeilenargumente überschrieben werden kann.

QSignalSpy doubleClickSpy(target, &TargetClass::doubleClicked);
const QPoint p(1, 2);
QTest::mousePress(&myWindow, Qt::LeftButton, Qt::NoModifier, p);
QVERIFY(target.isPressed());
QTest::mouseRelease(&myWindow, Qt::LeftButton, Qt::NoModifier, p, 10);
QCOMPARE(target.isPressed(), false);
QTest::mousePress(&myWindow, Qt::LeftButton, Qt::NoModifier, p, 10);
QCOMPARE(target.pressCount(), 2);
QTest::mouseRelease(&myWindow, Qt::LeftButton, Qt::NoModifier, p, 10);
QCOMPARE(doubleClickSpy.count(), 1);

Siehe auch QTest::mousePress() und QTest::mouseClick().

void QTest::mouseRelease(QWindow *window, Qt::MouseButton button, Qt::KeyboardModifiers stateKey = Qt::KeyboardModifiers(), QPoint pos = QPoint(), int delay = -1)

Simuliert das Loslassen einer Maus- button -Taste mit einem optionalen Modifikator „ stateKey “ auf einem „ window “. Die Position des Loslassens wird durch „ pos “ definiert; die Standardposition ist die Mitte des Fensters. Wenn „ delay “ angegeben wird, wartet der Test die angegebene Zeit in Millisekunden ab, bevor die Taste losgelassen wird; andernfalls wartet er eine Standardzeit (1 ms), die über Befehlszeilenargumente überschrieben werden kann.

QSignalSpy doubleClickSpy(target, &TargetClass::doubleClicked);
const QPoint p(1, 2);
QTest::mousePress(&myWindow, Qt::LeftButton, Qt::NoModifier, p);
QVERIFY(target.isPressed());
QTest::mouseRelease(&myWindow, Qt::LeftButton, Qt::NoModifier, p, 10);
QCOMPARE(target.isPressed(), false);
QTest::mousePress(&myWindow, Qt::LeftButton, Qt::NoModifier, p, 10);
QCOMPARE(target.pressCount(), 2);
QTest::mouseRelease(&myWindow, Qt::LeftButton, Qt::NoModifier, p, 10);
QCOMPARE(doubleClickSpy.count(), 1);

Siehe auch QTest::mousePress() und QTest::mouseClick().

QTestData &QTest::newRow(const char *dataTag)

Fügt den aktuellen Testdaten eine neue Zeile hinzu.

Die Testausgabe identifiziert den Testlauf mit diesen Testdaten anhand des Namens „ dataTag “.

Gibt eine QTestData-Referenz zurück, die zum Einlesen von Daten verwendet werden kann, wobei für jede Spalte der Tabelle ein Wert bereitgestellt wird.

Beispiel:

void MyTestClass::addSingleStringRows()
{
    QTest::addColumn<QString>("aString");
    QTest::newRow("just.hello") << QString("hello");
    QTest::newRow("a.null.string") << QString();
}

Ein ausführlicheres Beispiel finden Sie unter „Datengesteuertes Testen “.

Siehe auch „ addRow()“, „ addColumn()“ und „ QFETCH()“.

int QTest::qExec(QObject *testObject, int argc = 0, char **argv = nullptr)

Führt die in ` testObject` deklarierten Tests aus. Zudem werden die privaten Slots ` initTestCase()`, ` cleanupTestCase()`, ` init() ` und ` cleanup() ` ausgeführt, sofern sie vorhanden sind. Weitere Informationen finden Sie unter „Erstellen eines Tests “.

Optional können die Befehlszeilenargumente „ argc “ und „ argv “ angegeben werden. Eine Liste der unterstützten Argumente finden Sie unter „Qt Test -Befehlszeilenargumente“.

Das folgende Beispiel führt alle Tests in „ MyTestObject “ aus:

MyTestObject test1;
QTest::qExec(&test1);

Diese Funktion gibt 0 zurück, wenn kein Test fehlgeschlagen ist, oder einen Wert ungleich 0, wenn ein oder mehrere Tests fehlgeschlagen sind oder im Falle von unbehandelten Ausnahmen. (Übersprungene Tests haben keinen Einfluss auf den Rückgabewert.)

Für eigenständige Testanwendungen kann das Komfortmakro ` QTEST_MAIN()` verwendet werden, um eine `main()`-Funktion zu deklarieren, die die Befehlszeilenargumente auswertet und die Tests ausführt, wodurch der explizite Aufruf dieser Funktion entfällt.

Der Rückgabewert dieser Funktion ist auch der Beendigungscode der Testanwendung, wenn das Makro ` QTEST_MAIN()` verwendet wird.

Bei eigenständigen Testanwendungen sollte diese Funktion nicht mehr als einmal aufgerufen werden, da sich die Befehlszeilenoptionen zum Protokollieren der Testausgabe in Dateien und zum Ausführen einzelner Testfunktionen sonst nicht korrekt verhalten.

Wenn Sie die Argumente programmgesteuert erstellt haben – im Gegensatz zum Abrufen aus den Argumenten von ` main()` – ist es wahrscheinlich sinnvoll, `QTest::qExec(QObject *, const QStringList &)` zu verwenden, da diese Funktion Unicode-sicher ist.

Siehe auch QTEST_MAIN(), QTEST_GUILESS_MAIN() und QTEST_APPLESS_MAIN().

int QTest::qExec(QObject *testObject, const QStringList &arguments)

Verhält sich identisch wie qExec(QObject *, int, char**), akzeptiert jedoch eine Liste „ QStringList “ vom Typ „ arguments “ anstelle einer Liste vom Typ „ char** “.

QSharedPointer<QTemporaryDir> QTest::qExtractTestData(const QString &dirName)

Extrahiert ein Verzeichnis aus den Ressourcen auf die Festplatte. Der Inhalt wird rekursiv in einen temporären Ordner extrahiert. Der extrahierte Inhalt wird automatisch entfernt, sobald die letzte Referenz auf den Rückgabewert den Gültigkeitsbereich verlässt.

dirName ist der Name des Verzeichnisses, das aus den Ressourcen extrahiert werden soll.

Gibt das temporäre Verzeichnis zurück, in das die Daten extrahiert wurden, oder bei Fehlern den Wert „null“.

[since 6.5] void QTest::qRegisterTestCase(const QString &name, QTest::TestEntryFunction entryFunction)

Registriert den Test name mit der Einstiegsfunktion entryFunction in einem zentralen Testfallregister für die aktuelle Binärdatei.

Der Test name wird angezeigt, wenn die Batch-Test-Binärdatei ohne Parameter ausgeführt wird. Wird die Test-Binärdatei mit dem Wert von argv[1] gleich name ausgeführt, wird entryFunction aufgerufen.

Diese Funktion wurde in Qt 6.5 eingeführt.

[since 6.7] void QTest::qSleep(std::chrono::milliseconds msecs)

Wartet für msecs und blockiert dabei die Ausführung des Tests.

Diese Methode führt keine Ereignisverarbeitung durch und lässt Ihren Test unresponsive. Während des Pausierens kann es zu einem Timeout bei der Netzwerkkommunikation kommen. Verwenden Sie QTest::qWait(), um nicht blockierend zu pausieren.

msecs muss größer als 0 ms sein.

Beispiel:

using namespace std::chrono_literals;
QTest::qSleep(250ms);

Diese Funktion wurde in Qt 6.7 eingeführt.

Siehe auch ` QTest::qWait()`.

void QTest::qSleep(int ms)

Wartet ms Millisekunden und blockiert dabei die Ausführung des Tests.

Entspricht dem Aufruf von:

QTest::qSleep(std::chrono::milliseconds{ms});

[since 6.7] void QTest::qWait(std::chrono::milliseconds msecs)

Wartet auf „ msecs “. Während der Wartezeit werden Ereignisse verarbeitet, und Ihr Test reagiert weiterhin auf Ereignisse der Benutzeroberfläche oder auf Netzwerkkommunikation.

Beispiel:

    using namespace std::chrono_literals;
    int i = 0;
    while (myNetworkServerNotResponding() && i++ < 50)
        QTest::qWait(250ms);

Der obige Code wartet maximal etwa 12,5 Sekunden lang, bis der Netzwerkserver antwortet.

Die „ QTRY_* “-Makros sind in der Regel die bessere Wahl als „qWait()“. „qWait()“ pausiert immer für die gesamte Timeout-Dauer, was dazu führen kann, dass der Test untätig bleibt und die Ausführung verlangsamt wird.

Die Makros „ QTRY_* “ prüfen die Bedingung so lange, bis sie erfüllt ist oder das Timeout abläuft. Ihr Test wird daher so schnell wie möglich fortgesetzt und bleibt zuverlässiger. Falls die Bedingung weiterhin nicht erfüllt ist, verdoppeln die Makros das Timeout einmalig und melden den neuen Wert, damit Sie ihn anpassen können.

Schreiben Sie beispielsweise den obigen Code wie folgt um:

QTRY_VERIFY_WITH_TIMEOUT(!myNetworkServerNotResponding(), 12.5s);

Diese Funktion wurde in Qt 6.7 eingeführt.

Siehe auch „ QTest::qSleep()“, „ QSignalSpy::wait()“ und „ QTRY_VERIFY_WITH_TIMEOUT()“.

void QTest::qWait(int msecs)

Wartet auf ` msecs`. Entspricht dem Aufruf von:

QTest::qWait(std::chrono::milliseconds{msecs});

[since 6.7] template <typename Functor> bool QTest::qWaitFor(Functor predicate, QDeadlineTimer deadline = QDeadlineTimer( defaultTryTimeout.load(std::memory_order_relaxed)))

Wartet, bis „ deadline “ abgelaufen ist oder bis „ predicate “ den Wert „true“ zurückgibt – je nachdem, was zuerst eintritt.

Gibt „ true “ zurück, wenn „ predicate “ zu irgendeinem Zeitpunkt „true“ zurückgegeben hat; andernfalls wird „ false “ zurückgegeben.

Beispiel:

    MyObject obj;
    obj.startup();
    using namespace std::chrono_literals;
    const bool result = QTest::qWaitFor([&obj]() { return obj.isReady(); },
                                        QDeadlineTimer(3s));

Der obige Code wartet maximal drei Sekunden lang darauf, dass das Objekt bereit ist.

Diese Funktion wurde in Qt 6.7 eingeführt.

template <typename Functor> bool QTest::qWaitFor(Functor predicate, int timeout)

Wartet timeout Millisekunden oder bis die Funktion „ predicate “ den Wert „true“ zurückgibt.

Dies entspricht dem Aufruf von:

qWaitFor(predicate, QDeadlineTimer(timeout));

[since 6.10] bool QTest::qWaitForWindowActive(QWidget *widget, QDeadlineTimer timeout)

Gibt „ true “ zurück, wenn „ widget “ innerhalb von „ timeout “ Millisekunden aktiv ist. Andernfalls wird „ false “ zurückgegeben.

Die Methode ist nützlich in Tests, die ` QWidget::show()` aufrufen und davon ausgehen, dass das Widget tatsächlich aktiv ist (d. h. sichtbar ist und den Fokus hat), bevor sie fortfahren.

Diese Funktion wurde in Qt 6.10 eingeführt.

Siehe auch „ qWaitForWindowExposed()“ und „ QWidget::isActiveWindow()“.

[since 6.10] bool QTest::qWaitForWindowActive(QWindow *window, QDeadlineTimer timeout)

Gibt „ true “ zurück, wenn „ window “ innerhalb von „ timeout “ aktiv ist. Andernfalls wird „ false “ zurückgegeben.

Die Methode ist nützlich in Tests, die ` QWindow::show()` aufrufen und darauf angewiesen sind, dass das Fenster tatsächlich aktiv ist (d. h. sichtbar ist und den Fokus hat), bevor sie fortfahren.

Diese Funktion wurde in Qt 6.10 eingeführt.

Siehe auch „ qWaitForWindowExposed()“, „ qWaitForWindowFocused()“ und „ QWindow::isActive()“.

[since 6.10] bool QTest::qWaitForWindowActive(QWidget *widget)

Diese Funktion verwendet die Standard-Zeitüberschreitung von 5 Sekunden.

Diese Funktion wurde in Qt 6.10 eingeführt.

[since 6.10] bool QTest::qWaitForWindowActive(QWindow *window)

Diese Funktion verwendet die Standard-Zeitüberschreitung von 5 Sekunden.

Diese Funktion wurde in Qt 6.10 eingeführt.

bool QTest::qWaitForWindowActive(QWidget *widget, int timeout)

Die Funktion „ timeout “ gibt den Wert in Millisekunden zurück.

bool QTest::qWaitForWindowActive(QWindow *window, int timeout)

Die Funktion „ timeout “ gibt den Wert in Millisekunden zurück.

[since 6.10] bool QTest::qWaitForWindowExposed(QWidget *widget, QDeadlineTimer timeout)

Gibt ` true ` zurück, wenn ` widget ` innerhalb von ` timeout ` Millisekunden sichtbar ist. Andernfalls wird ` false` zurückgegeben.

Die Methode ist nützlich in Tests, die ` QWidget::show()` aufrufen und darauf angewiesen sind, dass das Widget tatsächlich sichtbar ist, bevor sie fortfahren.

Diese Funktion wurde in Qt 6.10 eingeführt.

Siehe auch „ qWaitForWindowActive()“, „ QWidget::isVisible()“ und „ QWindow::isExposed()“.

[since 6.10] bool QTest::qWaitForWindowExposed(QWindow *window, QDeadlineTimer timeout)

Gibt „ true “ zurück, wenn „ window “ innerhalb von „ timeout “ verfügbar ist. Andernfalls wird „ false “ zurückgegeben.

Die Methode ist nützlich in Tests, die ` QWindow::show()` aufrufen und darauf angewiesen sind, dass das Fenster tatsächlich sichtbar ist, bevor sie fortfahren.

Diese Funktion wurde in Qt 6.10 eingeführt.

Siehe auch „ qWaitForWindowActive()“ und „ QWindow::isExposed()“.

[since 6.10] bool QTest::qWaitForWindowExposed(QWidget *widget)

Diese Funktion verwendet die Standard-Zeitüberschreitung von 5 Sekunden.

Diese Funktion wurde in Qt 6.10 eingeführt.

[since 6.10] bool QTest::qWaitForWindowExposed(QWindow *window)

Diese Funktion verwendet die Standard-Zeitüberschreitung von 5 Sekunden.

Diese Funktion wurde in Qt 6.10 eingeführt.

bool QTest::qWaitForWindowExposed(QWidget *widget, int timeout)

Die „ timeout “ wird in Millisekunden angegeben.

bool QTest::qWaitForWindowExposed(QWindow *window, int timeout)

Die „ timeout “ wird in Millisekunden angegeben.

[since 6.7] bool QTest::qWaitForWindowFocused(QWidget *widget, QDeadlineTimer timeout)

Gibt „ true “ zurück, wenn „ widget “ das Fokusfenster innerhalb von „ timeout “ ist. Andernfalls wird „ false “ zurückgegeben.

Die Methode ist nützlich in Tests, die ` QWidget::show()` aufrufen und darauf angewiesen sind, dass das Widget den Fokus hat (z. B. zum Empfangen von Tastaturereignissen), bevor sie fortfahren.

Diese Funktion wurde in Qt 6.7 eingeführt.

Siehe auch qWaitForWindowExposed(), qWaitForWindowActive() und QGuiApplication::focusWindow().

[since 6.7] bool QTest::qWaitForWindowFocused(QWindow *window, QDeadlineTimer timeout)

Gibt ` true` zurück, wenn ` window ` das Fokusfenster innerhalb von ` timeout` ist. Andernfalls wird ` false` zurückgegeben.

Die Methode ist nützlich in Tests, die ` QWindow::show()` aufrufen und darauf angewiesen sind, dass das Fenster den Fokus hat (z. B. zum Empfangen von Tastaturereignissen), bevor sie fortfahren.

Diese Funktion wurde in Qt 6.7 eingeführt.

Siehe auch qWaitForWindowExposed(), qWaitForWindowActive() und QGuiApplication::focusWindow().

[since 6.10] bool QTest::qWaitForWindowFocused(QWidget *widget)

Diese Funktion verwendet die Standard-Zeitüberschreitung von 5 Sekunden.

Diese Funktion wurde in Qt 6.10 eingeführt.

[since 6.10] bool QTest::qWaitForWindowFocused(QWindow *window)

Diese Funktion verwendet die Standard-Zeitüberschreitung von 5 Sekunden.

Diese Funktion wurde in Qt 6.10 eingeführt.

void QTest::setBenchmarkResult(qreal result, QTest::QBenchmarkMetric metric)

Legt das Benchmark-Ergebnis für diese Testfunktion auf „ result “ fest.

Verwenden Sie diese Funktion, wenn Sie Benchmark-Ergebnisse melden möchten, ohne das QBENCHMARK-Makro zu verwenden. Verwenden Sie „ metric “, um festzulegen, wie „ Qt Test “ die Ergebnisse interpretieren soll.

Der Kontext für das Ergebnis besteht aus dem Namen der Testfunktion und etwaigen Daten-Tags aus der _data-Funktion. Diese Funktion kann in jeder Testfunktion nur einmal aufgerufen werden; nachfolgende Aufrufe ersetzen die zuvor gemeldeten Ergebnisse.

Beachten Sie, dass das Befehlszeilenargument -iterations bei Testfunktionen ohne das QBENCHMARK-Makro keine Wirkung hat.

[noexcept, since 6.8] void QTest::setThrowOnFail(bool enable)

Aktiviert (enable = true) oder deaktiviert (enable = false) das Auslösen eines Fehlers bei Fehlern in QCOMPARE()/QVERIFY() (im Gegensatz zum bloßen Zurückkehren aus dem unmittelbar umgebenden Funktionskontext).

Die Funktion arbeitet mit Referenzzählung: Wenn Sie diese Funktion N-mal mit ` true` aufrufen, müssen Sie sie N-mal mit ` false ` aufrufen, um wieder an den Ausgangspunkt zurückzukehren.

Dieser Aufruf hat keine Auswirkung, wenn das C++-Makro „ QTEST_THROW_ON_FAIL “ definiert ist.

Diese Funktion wurde in Qt 6.8 eingeführt.

Siehe auch „ setThrowOnSkip()“, „ ThrowOnFailEnabler “, „ ThrowOnFailDisabler “ und „ QTEST_THROW_ON_FAIL “.

[noexcept, since 6.8] void QTest::setThrowOnSkip(bool enable)

Aktiviert (enable = true) oder deaktiviert (enable = false) das Auslösen eines Ausnahmes in „ QSKIP()“ (im Gegensatz zum bloßen Verlassen des unmittelbar übergeordneten Funktionskontexts).

Die Funktion arbeitet mit Referenzzählung: Wenn Sie diese Funktion N-mal mit ` true` aufrufen, müssen Sie sie N-mal mit ` false ` aufrufen, um wieder an den Ausgangspunkt zurückzukehren.

Dieser Aufruf hat keine Wirkung, wenn das C++-Makro „ QTEST_THROW_ON_SKIP “ definiert ist.

Diese Funktion wurde in Qt 6.8 eingeführt.

Siehe auch setThrowOnFail(), ThrowOnSkipEnabler, ThrowOnSkipDisabler und QTEST_THROW_ON_SKIP.

char *QTest::toHexRepresentation(const char *ba, qsizetype length)

Gibt einen Zeiger auf eine Zeichenkette zurück, die der Zeichenkette „ ba “ entspricht, dargestellt als durch Leerzeichen getrennte Folge von Hexadezimalzeichen. Wird die Eingabe als zu lang angesehen, wird sie gekürzt. Eine Kürzung wird in der zurückgegebenen Zeichenkette durch drei Punkte am Ende gekennzeichnet. Der Aufrufer ist Eigentümer des zurückgegebenen Zeigers und muss sicherstellen, dass dieser später an den Operator `delete[]` übergeben wird.

length ist die Länge der Zeichenkette ba.

template <typename T> char *QTest::toString(const T &value)

Gibt eine textuelle Darstellung von ` value` zurück. Diese Funktion wird von ` QCOMPARE()` verwendet, um im Falle eines Testfehlers ausführliche Informationen auszugeben.

Sie können Spezialisierungen oder Überladungen dieser Funktion in Ihren Test einfügen, um eine ausführliche Ausgabe zu ermöglichen.

Beispiel für die Spezialisierung (Qt ≤ 5.4):

namespace QTest {
    template<>
    char *toString(const MyPoint &point)
    {
        const QByteArray ba("MyPoint("
                            + QByteArray::number(point.x()) + ", "
                            + QByteArray::number(point.y()) + ')');
        return qstrdup(ba.data());
    }
}

Das obige Beispiel definiert eine toString()-Spezialisierung für eine Klasse namens „ MyPoint “. Immer wenn ein Vergleich zweier Instanzen von „ MyPoint “ fehlschlägt, ruft „ QCOMPARE()“ diese Funktion auf, um den Inhalt von „ MyPoint “ im Testprotokoll auszugeben.

Dasselbe Beispiel, jedoch mit Überladung (Qt ≥ 5.5):

char *toString(const MyPoint &point) // should be inside the same namespace as MyPoint
{
    return QTest::toString("MyPoint(" +
                           QByteArray::number(point.x()) + ", " +
                           QByteArray::number(point.y()) + ')');
}

Siehe auch QCOMPARE().

char *toString(QSizePolicy sp)

Gibt eine textuelle Darstellung der Größenrichtlinie „ sp “ zurück.

char *toString(QSizePolicy::ControlType ct)

Gibt eine textuelle Darstellung des Steuerelementtyps „ ct “ zurück.

char *toString(QSizePolicy::ControlTypes cts)

Gibt eine textuelle Darstellung der Steuerelementtypen zurück: cts.

char *toString(QSizePolicy::Policy p)

Gibt eine textuelle Darstellung der Richtlinie „ p “ zurück.

char *QTest::toString(const QByteArray &ba)

Gibt eine textuelle Darstellung des Byte-Arrays „ ba “ zurück.

Siehe auch ` QTest::toHexRepresentation()`.

char *QTest::toString(const QCborError &c)

Gibt eine textuelle Darstellung des angegebenen CBOR-Fehler c s zurück.

char *QTest::toString(const QChar &character)

Gibt eine textuelle Darstellung des angegebenen „ character “ zurück.

char *QTest::toString(const QDate &date)

Gibt eine textuelle Darstellung des angegebenen ` date` zurück.

char *QTest::toString(const QDateTime &dateTime)

Gibt eine textuelle Darstellung des durch ` dateTime` angegebenen Datums und der Uhrzeit zurück.

[since 6.5] char *QTest::toString(const QKeySequence &ks)

Gibt eine textuelle Darstellung der Schlüsselsequenz „ ks “ zurück.

Diese Funktion wurde in Qt 6.5 eingeführt.

char *QTest::toString(const QLatin1StringView &string)

Gibt eine textuelle Darstellung des angegebenen ` string` zurück.

char *QTest::toString(const QPoint &point)

Gibt eine textuelle Darstellung des angegebenen ` point` zurück.

char *QTest::toString(const QPointF &point)

Gibt eine textuelle Darstellung des angegebenen „ point “ zurück.

char *QTest::toString(const QRect &rectangle)

Gibt eine textuelle Darstellung des angegebenen ` rectangle` zurück.

char *QTest::toString(const QRectF &rectangle)

Gibt eine textuelle Darstellung des angegebenen „ rectangle “ zurück.

char *QTest::toString(const QSize &size)

Gibt eine textuelle Darstellung der angegebenen ` size` zurück.

char *QTest::toString(const QSizeF &size)

Gibt eine textuelle Darstellung des angegebenen ` size` zurück.

char *QTest::toString(const QString &string)

Gibt eine textuelle Darstellung der angegebenen ` string` zurück.

char *QTest::toString(const QStringView &string)

Gibt eine textuelle Darstellung des angegebenen ` string` zurück.

char *QTest::toString(const QTime &time)

Gibt eine textuelle Darstellung des angegebenen ` time` zurück.

char *QTest::toString(const QUrl &url)

Gibt eine textuelle Darstellung des angegebenen „ url “ zurück.

char *QTest::toString(const QUuid &uuid)

Gibt eine textuelle Darstellung des angegebenen ` uuid` zurück.

char *QTest::toString(const QVariant &variant)

Gibt eine textuelle Darstellung des angegebenen „ variant “ zurück.

char *QTest::toString(const QVector2D &v)

Gibt eine textuelle Darstellung des 2D-Vektors v zurück.

char *QTest::toString(const QVector3D &v)

Gibt eine textuelle Darstellung des 3D-Vektors „ v “ zurück.

char *QTest::toString(const QVector4D &v)

Gibt eine textuelle Darstellung des 4D-Vektors ` v` zurück.

template <typename T1, typename T2> char *QTest::toString(const std::pair<T1, T2> &pair)

Gibt eine textuelle Darstellung von „ pair “ zurück.

template <typename... Types> char *QTest::toString(const std::tuple<Types...> &tuple)

Gibt eine textuelle Darstellung des angegebenen „ tuple “ zurück.

char *QTest::toString(std::nullptr_t)

Gibt eine Zeichenfolge zurück, die „ nullptr “ enthält.

QTest::QTouchEventWidgetSequence QTest::touchEvent(QWidget *widget, QPointingDevice *device, bool autoCommit = true)

Erstellt und gibt ein ` QTouchEventSequence ` für das ` device ` zurück, um Ereignisse für ` widget` zu simulieren.

Beim Hinzufügen von Touch-Ereignissen zur Sequenz wird „ widget “ außerdem verwendet, um die angegebene Position in Bildschirmkoordinaten umzuwandeln, sofern in den jeweiligen Aufrufen von „press()“, „move()“ usw. kein anderes Widget angegeben wird.

Die Touch-Ereignisse werden an das Ereignissystem übergeben, wenn der Destruktor von ` QTouchEventSequence ` aufgerufen wird (d. h. wenn der Gültigkeitsbereich des zurückgegebenen Objekts endet), es sei denn, ` autoCommit ` ist auf `false` gesetzt. Wenn ` autoCommit ` auf `false` gesetzt ist, muss `commit()` manuell aufgerufen werden.

createTouchDevice() kann aufgerufen werden, um ein Test-Touch-Gerät zur Verwendung mit dieser Funktion zu erstellen.

QTest::QTouchEventSequence QTest::touchEvent(QWindow *window, QPointingDevice *device, bool autoCommit = true)

Erstellt und gibt ein ` QTouchEventSequence ` für das ` device ` zurück, um Ereignisse für ` window` zu simulieren.

Beim Hinzufügen von Touch-Ereignissen zur Sequenz wird „ window “ außerdem verwendet, um die übergebene Position in Bildschirmkoordinaten umzuwandeln, sofern in den jeweiligen Aufrufen von „press()“, „move()“ usw. kein anderes Fenster angegeben wird.

Die Touch-Ereignisse werden an das Ereignissystem übergeben, wenn der Destruktor von ` QTouchEventSequence ` aufgerufen wird (d. h., wenn der Gültigkeitsbereich des zurückgegebenen Objekts endet), es sei denn, ` autoCommit ` ist auf `false` gesetzt. Wenn ` autoCommit ` auf `false` gesetzt ist, muss `commit()` manuell aufgerufen werden.

createTouchDevice() kann aufgerufen werden, um ein Test-Touch-Gerät zur Verwendung mit dieser Funktion zu erstellen.

[since 6.8] void QTest::wheelEvent(QWindow *window, QPointF pos, QPoint angleDelta, QPoint pixelDelta = QPoint(0, 0), Qt::KeyboardModifiers stateKey = Qt::NoModifier, Qt::ScrollPhase phase = Qt::NoScrollPhase)

Simuliert ein Radereignis innerhalb von „ window “ an der Position „ pos “ in lokalen Fensterkoordinaten. „ angleDelta “ enthält den Drehwinkel des Rads. Ein positiver Wert bedeutet eine Drehung nach vorne, ein negativer Wert eine Drehung nach hinten. „ pixelDelta “ enthält die Bildlaufdistanz in Pixeln auf dem Bildschirm. Dieser Wert kann null sein. Die Tastaturzustände zum Zeitpunkt des Ereignisses werden durch „ stateKey “ angegeben. Die Bildlaufphase des Ereignisses wird durch „ phase “ angegeben.

Diese Funktion wurde in Qt 6.8 eingeführt.