QTest Namespace

Documentation de la fonction

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

Ajoute une colonne de type « T » aux données de test actuelles. « name » est le nom de la colonne. « dummy » est une solution de contournement destinée aux compilateurs présentant des bogues et peut être ignorée.

Pour remplir la colonne avec des valeurs, on peut utiliser ` newRow()`. Utilisez ` QFETCH()` pour récupérer les données lors du test proprement dit.

Exemple :

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

Voir « Tests pilotés par les données » pour un exemple plus complet.

Voir également QTest::newRow(), QFETCH() et QMetaType.

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

Ajoute une nouvelle ligne aux données de test actuelles.

Les arguments de la fonction sont transmis à std::snprintf() pour être formatés conformément à format. Consultez la documentation de std::snprintf() pour connaître les mises en garde et les limitations.

La sortie du test identifiera l'exécution du test avec ces données de test en utilisant le nom résultant de ce formatage.

Renvoie une référence QTestData pouvant être utilisée pour lire des données en continu, à raison d’une valeur par colonne du tableau.

Exemple :

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

Consultez la section « Tests pilotés par les données » pour un exemple plus complet.

Voir également newRow(), addColumn() et QFETCH().

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

Renvoie la valeur d'énumération « metric » sous forme de chaîne de caractères.

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

Renvoie les unités de mesure associées à l'metric spécifiée.

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

Crée un périphérique tactile fictif de type ` devType ` doté des capacités ` caps ` pour la simulation d'événements tactiles.

Le périphérique tactile sera enregistré auprès de l'interface du système de fenêtrage Qt. En règle générale, vous devez utiliser createTouchDevice() pour initialiser une variable membre de type QPointingDevice dans votre classe de cas de test, utiliser la même instance pour tous les tests et la supprimer lorsqu'elle n'est plus nécessaire.

Voir également QTest::QTouchEventSequence et touchEvent().

const char *QTest::currentAppName()

Renvoie le nom du fichier binaire en cours d'exécution.

const char *QTest::currentDataTag()

Renvoie le nom des données de test actuelles. Si aucune donnée de test n'est attribuée au test, la fonction renvoie « nullptr ».

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

Renvoie le nom des données de test globales actuelles. Si aucune donnée de test globale n'est attribuée au test, la fonction renvoie « nullptr ».

Cette fonction a été introduite dans Qt 6.11.

bool QTest::currentTestFailed()

Renvoie « true » si la fonction de test actuelle a échoué, sinon « false ».

Voir aussi QTest::currentTestResolved().

const char *QTest::currentTestFunction()

Renvoie le nom de la fonction de test en cours d'exécution.

Exemple :

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

[since 6.5] bool QTest::currentTestResolved()

Renvoie « true » si la fonction de test en cours a échoué ou a été ignorée.

Cela s'applique si le test a échoué ou a déclenché un saut. Lorsque cette valeur est vraie, la fonction de test doit s'arrêter prématurément. En particulier, les macros QTRY_* et la boucle d'événements de test terminent leurs boucles prématurément si elles sont exécutées pendant la fonction de test (mais pas pendant son cleanup()). Après qu'un test a appelé une fonction d'aide utilisant les macros de ce module, il peut utiliser cette fonction pour déterminer s'il doit se terminer prématurément.

Cette fonction a été introduite dans Qt 6.5.

Voir également QTest::currentTestFailed().

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

Ajoute un échec de test au journal des tests pour chaque avertissement correspondant à messagePattern.

La fonction de test poursuivra son exécution lorsqu’un échec est ajouté. Pour interrompre le test à la place, vous pouvez vérifier currentTestFailed() et quitter prématurément si la valeur est true.

Pour chaque avertissement, le premier motif correspondant provoquera un échec, et les motifs restants seront ignorés.

Tous les modèles sont effacés à la fin de chaque fonction de test.

void FileTest::loadFiles()
{
    QTest::failOnWarning(QRegularExpression("^Échec du chargement"));

    // Chacun de ces éléments entraînera l'échec du test :
    qWarning() << "Failed to load image";
    qWarning() << "Failed to load video";
}

Pour faire échouer tous les tests qui déclenchent un avertissement donné, transmettez une expression régulière appropriée à cette fonction dans init():

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

Dans le cas courant où l’on souhaite faire échouer le test pour n’importe quel avertissement, ne passez aucun paramètre :

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

Cette fonction a été introduite dans Qt 6.3.

Voir également QTEST_FATAL_FAIL.

[since 6.8] void QTest::failOnWarning()

Ajoute un échec de test au journal des tests si un avertissement est généré.

Cette fonction a été introduite dans Qt 6.8.

Voir également failOnWarning(const char *).

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

Ajoute un échec de test au journal des tests si la méthode ` message ` est appelée.

Cette fonction a été introduite dans Qt 6.3.

Voir également failOnWarning().

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

Ignore les messages générés par les fonctions qDebug(), qInfo() ou qWarning(). Si l'message, avec l'type correspondante, est générée, elle sera supprimée du journal de test. Si le test est terminé et que l'message n'a pas été générée, un échec de test est ajouté au journal de test.

Exemple :

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

L'exemple ci-dessus vérifie que la fonction ` QDir::mkdir()` affiche l'avertissement approprié lorsqu'elle est appelée avec un nom de fichier non valide.

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

Ignore les messages générés par les fonctions ` qDebug()`, ` qInfo()` ou ` qWarning()`. Si le message correspondant à ` messagePattern ` et dont le ` type ` est associé est affiché, il sera supprimé du journal de test. Si le test est terminé et que le message n'a pas été affiché, un échec de test est ajouté à la fin du journal de test.

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

Simule un clic sur key avec, en option, une valeur de modifier sur widget. Si delay est supérieur à 0, le test attendra delay millisecondes avant d'enclencher la touche.

Exemples :

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

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

Le premier exemple ci-dessus simule un clic sur la touche escape sur myWidget sans aucun modificateur de clavier et sans délai. Le deuxième exemple simule un clic sur shift-escape sur myWidget après un délai de 200 ms dans le test.

Voir également QTest::keyClicks().

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

Simule un clic sur key avec, en option, une valeur modifier sur widget. Si delay est supérieur à 0, le test attendra delay millisecondes avant d'enclencher la touche.

Exemple :

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

L'exemple ci-dessus simule un clic sur a à l'adresse myWidget sans aucun modificateur de clavier et sans délai du test.

Voir également QTest::keyClicks().

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

Simule un clic sur key avec, en option, un délai de modifier sur window. Si delay est supérieur à 0, le test attendra delay millisecondes avant d’enclencher la touche.

Exemples :

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

Le premier exemple ci-dessus simule un clic sur la touche escape sur myWindow sans aucun modificateur de clavier et sans délai. Le deuxième exemple simule un clic sur shift-escape sur myWindow après un délai de 200 ms dans le test.

Voir également QTest::keyClicks().

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

Simule un clic sur key avec, en option, une modifier sur window. Si delay est supérieur à 0, le test attendra delay millisecondes avant de cliquer sur la touche.

Exemple :

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

L'exemple ci-dessus simule un clic sur a à l'adresse myWindow sans aucun modificateur de clavier et sans délai du test.

Voir également QTest::keyClicks().

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

Simule le clic sur une sequence de touches d'un widget. Il est également possible de spécifier un modifier de clavier ainsi qu'un delay (en millisecondes) du test avant chaque clic sur une touche.

Exemple :

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

L’exemple ci-dessus simule l’enchaînement de touches correspondant à « hello world » sur myWidget sans aucun modificateur de clavier et sans délai de test.

Voir également QTest::keyClick().

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

Envoie un événement de touche Qt à widget avec l'key indiquée et l'action associé. Il est possible de spécifier, de manière facultative, un modifier de clavier, ainsi qu'un delay (en millisecondes) du test avant l'envoi de l'événement.

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

Envoie un événement de touche Qt à widget avec l'ascii de touche indiquée et l'action associée. Il est possible de spécifier, de manière facultative, un modifier de clavier, ainsi qu'un delay (en millisecondes) du test avant l'envoi de l'événement.

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

Envoie un événement de touche Qt à window avec l'key fournie et l'action associée. Il est possible de spécifier, de manière facultative, une modifier du clavier, ainsi qu'une delay (en millisecondes) du test avant l'envoi de l'événement.

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

Envoie un événement de touche Qt à window avec l'ascii de touche indiquée et l'action associée. Il est possible de spécifier, de manière facultative, un modifier de clavier, ainsi qu'une delay (en millisecondes) du test avant l'envoi de l'événement.

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

Simule l'appui sur une touche key avec, en option, une modifier sur une widget. Si delay est supérieur à 0, le test attendra delay millisecondes avant d'appuyer sur la touche.

Voir également QTest::keyRelease() et QTest::keyClick().

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

Simule l'appui sur une touche key avec, en option, une modifier sur un widget. Si delay est supérieur à 0, le test attendra delay millisecondes avant d'appuyer sur la touche.

Voir également QTest::keyRelease() et QTest::keyClick().

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

Simule l'actionnement d'une touche key avec, en option, un modifier sur une window. Si delay est supérieur à 0, le test attendra delay millisecondes avant d'appuyer sur la touche.

Voir également QTest::keyRelease() et QTest::keyClick().

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

Simule l'appui sur une touche key avec, en option, un délai modifier sur une page window. Si delay est supérieur à 0, le test attendra delay millisecondes avant d'appuyer sur la touche.

Voir également QTest::keyRelease() et QTest::keyClick().

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

Simule la libération d'un objet ` key ` avec un délai d'attente facultatif ` modifier ` sur un ` widget`. Si ` delay ` est supérieur à 0, le test attendra ` delay ` millisecondes avant de libérer la clé.

Voir également QTest::keyPress() et QTest::keyClick().

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

Simule la libération d'une clé « key » avec une durée d'attente facultative « modifier » sur une « widget ». Si « delay » est supérieur à 0, le test attendra « delay » millisecondes avant de libérer la clé.

Voir également QTest::keyClick().

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

Simule la libération d'une clé « key » avec un délai de libération facultatif « modifier » sur une clé « window ». Si « delay » est supérieur à 0, le test attendra « delay » millisecondes avant de libérer la clé.

Voir également QTest::keyPress() et QTest::keyClick().

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

Simule la libération d'une clé « key » avec un délai d'attente facultatif « modifier » sur un « window ». Si « delay » est supérieur à 0, le test attendra « delay » millisecondes avant de libérer la clé.

Voir également QTest::keyClick().

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

Simule la saisie de l'adresse keySequence dans le champ widget.

Voir également QTest::keyClick() et QTest::keyClicks().

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

Simule la saisie de « keySequence » dans window.

Voir également QTest::keyClick() et QTest::keyClicks().

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

Simule un clic de souris button avec, en option, un modifier sur un widget. La position du clic est définie par pos; la position par défaut est le centre du widget. Si delay est spécifié, le test attendra le nombre de millisecondes indiqué avant d'enclencher et de relâcher le bouton.

Voir également QTest::mousePress() et QTest::mouseRelease().

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

Simule un clic de souris button avec, en option, le modificateur stateKey sur une window. La position du clic est définie par pos; la position par défaut est le centre de la fenêtre. Si delay est spécifié, le test attendra le nombre de millisecondes indiqué avant d’enfoncer et avant de relâcher le bouton.

Voir également QTest::mousePress() et QTest::mouseRelease().

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

Simule un double-clic de souris button avec, en option, un modifier sur une widget. La position du clic est définie par pos; la position par défaut est le centre du widget. Si delay est spécifié, le test attendra le nombre de millisecondes indiqué avant chaque pression et relâchement.

Voir également QTest::mouseClick().

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

Simule un double-clic de souris button avec, en option, le modificateur stateKey sur une window. La position du clic est définie par pos; la position par défaut est le centre de la fenêtre. Si delay est spécifié, le test attendra le nombre de millisecondes indiqué avant chaque pression et relâchement.

Voir également QTest::mouseClick().

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

Déplace le pointeur de la souris vers un « widget ». Si « pos » n'est pas spécifié, le pointeur de la souris se déplace vers le centre du widget. Si un « delay » (en millisecondes) est indiqué, le test attendra avant de déplacer le pointeur de la souris.

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

Déplace le pointeur de la souris vers une coordonnée window. Si pos n'est pas spécifiée, le pointeur de la souris se déplace vers le centre de la fenêtre. Si une valeur delay (en millisecondes) est fournie, la fonction attendra avant de déplacer le pointeur de la souris.

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

Simule un clic de souris button avec, en option, un modifier sur un widget. La position est définie par pos; la position par défaut est le centre du widget. Si delay est spécifié, le test attendra le nombre de millisecondes indiqué avant d'effectuer le clic.

Voir également QTest::mouseRelease() et QTest::mouseClick().

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

Simule l'button d'un clic de souris avec, éventuellement, le modificateur « stateKey » sur une fenêtre window. La position est définie par pos; la position par défaut est le centre de la fenêtre. Si delay est spécifié, le test attendra le nombre de millisecondes indiqué avant d'effectuer le clic.

Voir également QTest::mouseRelease() et QTest::mouseClick().

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

Simule le relâchement d'button de souris avec un délai de relâchement ( modifier ) facultatif sur un widget. La position du relâchement est définie par pos; la position par défaut est le centre du widget. Si delay est spécifié, le test attendra le nombre de millisecondes indiqué avant de relâcher le bouton ; sinon, il attendra un délai par défaut (1 ms), qui peut être redéfini via des arguments de ligne de commande.

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);

Voir également QTest::mousePress() et QTest::mouseClick().

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

Simule le relâchement d'un bouton de souris button avec, éventuellement, le modificateur stateKey sur une fenêtre window. La position du relâchement est définie par pos; la position par défaut est le centre de la fenêtre. Si delay est spécifié, le test attendra le nombre de millisecondes indiqué avant de relâcher le bouton ; sinon, il attendra un délai par défaut (1 ms), qui peut être redéfini via des arguments de ligne de commande.

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);

Voir également QTest::mousePress() et QTest::mouseClick().

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

Ajoute une nouvelle ligne aux données de test actuelles.

Le résultat du test identifiera l'exécution de test associée à ces données de test sous le nom « dataTag ».

Renvoie une référence QTestData pouvant être utilisée pour charger des données en continu, à raison d’une valeur par colonne du tableau.

Exemple :

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

Voir « Tests pilotés par les données » pour un exemple plus complet.

Voir également addRow(), addColumn() et QFETCH().

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

Exécute les tests déclarés dans ` testObject`. De plus, les slots privés ` initTestCase()`, ` cleanupTestCase()`, ` init() ` et ` cleanup() ` sont exécutés s'ils existent. Voir « Création d'un test » pour plus de détails.

En option, les arguments de ligne de commande argc et argv peuvent être fournis. Pour obtenir la liste des arguments reconnus, consultez la section « Arguments de ligne de commande deQt Test ».

L'exemple suivant exécutera tous les tests contenus dans MyTestObject:

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

Cette fonction renvoie 0 si aucun test n’a échoué, ou une valeur différente de 0 si un ou plusieurs tests ont échoué ou en cas d’exceptions non gérées. (Les tests ignorés n’influencent pas la valeur de retour.)

Pour les applications de test autonomes, la macro de commodité QTEST_MAIN() peut être utilisée pour déclarer une fonction main() qui analyse les arguments de ligne de commande et exécute les tests, évitant ainsi d’avoir à appeler explicitement cette fonction.

La valeur de retour de cette fonction correspond également au code de sortie de l’application de test lorsque la macro QTEST_MAIN() est utilisée.

Pour les applications de test autonomes, cette fonction ne doit pas être appelée plus d’une fois, car les options de ligne de commande permettant d’enregistrer la sortie des tests dans des fichiers et d’exécuter des fonctions de test individuelles ne fonctionneront pas correctement.

Si vous avez créé les arguments par programmation, plutôt que de les récupérer à partir des arguments de ` main()`, il peut être intéressant d’utiliser `QTest::qExec(QObject *, const QStringList &)`, car cette fonction est compatible Unicode.

Voir également QTEST_MAIN(), QTEST_GUILESS_MAIN() et QTEST_APPLESS_MAIN().

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

Se comporte exactement comme qExec(QObject *, int, char**), mais prend une liste de type QStringList de arguments au lieu d'une liste de type char**.

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

Extrait un répertoire des ressources vers le disque. Le contenu est extrait de manière récursive vers un dossier temporaire. Le contenu extrait est supprimé automatiquement dès que la dernière référence à la valeur de retour sort de la portée.

dirName est le nom du répertoire à extraire des ressources.

Renvoie le répertoire temporaire dans lequel les données ont été extraites ou la valeur null en cas d'erreur.

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

Enregistre le test name, avec la fonction d'entrée entryFunction, dans un registre central des cas de test pour le binaire actuel.

L'name apparaîtra dans la liste lors de l'exécution du binaire de test par lots sans paramètre. L'exécution du binaire de test avec l'argument argv[1] défini sur name entraînera l'appel de la fonction entryFunction.

Cette fonction a été introduite dans Qt 6.5.

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

Mise en attente pendant msecs, ce qui bloque l'exécution du test.

Cette méthode n'effectuera aucun traitement d'événement et rendra votre test inactif. La communication réseau risque d'expirer pendant la mise en veille. Utilisez QTest::qWait() pour effectuer une mise en veille non bloquante.

msecs La valeur doit être supérieure à 0 ms.

Exemple :

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

Cette fonction a été introduite dans Qt 6.7.

Voir également QTest::qWait().

void QTest::qSleep(int ms)

Mise en attente pendant ms e de milliseconde, ce qui bloque l'exécution du test.

Équivaut à appeler :

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

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

Attend la fin de msecs. Pendant l'attente, les événements seront traités et votre test restera réactif aux événements de l'interface utilisateur ou aux communications réseau.

Exemple :

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

Le code ci-dessus attendra que le serveur réseau réponde pendant une durée maximale d’environ 12,5 secondes.

Les macros QTRY_* constituent généralement un meilleur choix que qWait(). En effet, qWait() met toujours le test en pause pendant toute la durée du délai d’expiration, ce qui peut le laisser inactif et ralentir son exécution.

Les macros ` QTRY_* ` vérifient la condition jusqu’à ce qu’elle soit remplie ou que le délai d’attente expire. Votre test se poursuit donc dès que possible et reste plus fiable. Si la condition échoue toujours, les macros doublent le délai d’attente une fois et signalent la nouvelle valeur afin que vous puissiez l’ajuster.

Par exemple, réécrivez le code ci-dessus comme suit :

QTRY_VERIFY_WITH_TIMEOUT(!myNetworkServerNotResponding(), 12.5s);

Cette fonction a été introduite dans Qt 6.7.

Voir également QTest::qSleep(), QSignalSpy::wait() et QTRY_VERIFY_WITH_TIMEOUT().

void QTest::qWait(int msecs)

Attend la valeur « msecs ». Équivaut à l'appel suivant :

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

Attend que la durée de validité de ` deadline ` soit écoulée, ou que ` predicate ` renvoie `true`, selon la première éventualité.

Renvoie true si predicate a renvoyé la valeur « true » à un moment quelconque, sinon renvoie false.

Exemple :

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

Le code ci-dessus attendra que l’objet soit prêt, pendant trois secondes au maximum.

Cette fonction a été introduite dans Qt 6.7.

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

Attend pendant timeout millisecondes ou jusqu’à ce que la fonction predicate renvoie la valeur « true ».

Cela revient à appeler :

qWaitFor(predicate, QDeadlineTimer(timeout));

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

Renvoie ` true ` si ` widget ` est actif dans un délai de ` timeout ` millisecondes. Sinon, renvoie ` false`.

Cette méthode est utile dans les tests qui appellent ` QWidget::show()` et qui s'assurent que le widget est bien actif (c'est-à-dire visible et sélectionné) avant de poursuivre.

Cette fonction a été introduite dans Qt 6.10.

Voir également qWaitForWindowExposed() et QWidget::isActiveWindow().

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

Renvoie ` true` si ` window ` est active dans ` timeout`. Sinon, renvoie ` false`.

Cette méthode est utile dans les tests qui appellent ` QWindow::show()` et qui s'assurent que la fenêtre est bien active (c'est-à-dire visible et active) avant de poursuivre.

Cette fonction a été introduite dans Qt 6.10.

Voir également qWaitForWindowExposed(), qWaitForWindowFocused() et QWindow::isActive().

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

Cette fonction utilise le délai d'expiration par défaut de 5 secondes.

Cette fonction a été introduite dans Qt 6.10.

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

Cette fonction utilise le délai d'expiration par défaut de 5 secondes.

Cette fonction a été introduite dans Qt 6.10.

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

L'timeout e est exprimée en millisecondes.

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

L'timeout e est exprimée en millisecondes.

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

Renvoie ` true ` si ` widget ` est visible dans un délai de ` timeout ` millisecondes. Sinon, renvoie ` false`.

Cette méthode est utile dans les tests qui appellent ` QWidget::show()` et qui s’assurent que le widget est bien visible avant de poursuivre.

Cette fonction a été introduite dans Qt 6.10.

Voir également qWaitForWindowActive(), QWidget::isVisible() et QWindow::isExposed().

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

Renvoie ` true` si ` window ` est accessible au sein de ` timeout`. Sinon, renvoie ` false`.

Cette méthode est utile dans les tests qui appellent ` QWindow::show()` et qui s’assurent que la fenêtre est bien visible avant de poursuivre.

Cette fonction a été introduite dans Qt 6.10.

Voir également qWaitForWindowActive() et QWindow::isExposed().

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

Cette fonction utilise le délai d'expiration par défaut de 5 secondes.

Cette fonction a été introduite dans Qt 6.10.

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

Cette fonction utilise le délai d'expiration par défaut de 5 secondes.

Cette fonction a été introduite dans Qt 6.10.

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

L'timeout e est exprimée en millisecondes.

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

L'timeout e est exprimée en millisecondes.

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

Renvoie ` true` si ` widget ` est la fenêtre active au sein de ` timeout`. Sinon, renvoie ` false`.

Cette méthode est utile dans les tests qui appellent ` QWidget::show()` et qui s'assurent que le widget a le focus (pour recevoir des événements clavier, par exemple) avant de poursuivre.

Cette fonction a été introduite dans Qt 6.7.

Voir également qWaitForWindowExposed(), qWaitForWindowActive() et QGuiApplication::focusWindow().

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

Renvoie ` true` si ` window ` est la fenêtre active au sein de ` timeout`. Sinon, renvoie ` false`.

Cette méthode est utile dans les tests qui appellent ` QWindow::show()` et qui s'assurent que la fenêtre a le focus (pour recevoir des événements clavier, par exemple) avant de poursuivre.

Cette fonction a été introduite dans Qt 6.7.

Voir également qWaitForWindowExposed(), qWaitForWindowActive() et QGuiApplication::focusWindow().

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

Cette fonction utilise le délai d'expiration par défaut de 5 secondes.

Cette fonction a été introduite dans Qt 6.10.

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

Cette fonction utilise le délai d'expiration par défaut de 5 secondes.

Cette fonction a été introduite dans Qt 6.10.

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

Définit le résultat de référence de cette fonction de test sur result.

Utilisez cette fonction si vous souhaitez générer des rapports sur les résultats de benchmark sans utiliser la macro QBENCHMARK. Utilisez metric pour spécifier comment Qt Test doit interpréter les résultats.

Le contexte du résultat sera le nom de la fonction de test et toute balise de données provenant de la fonction _data. Cette fonction ne peut être appelée qu'une seule fois dans chaque fonction de test ; les appels suivants remplaceront les résultats précédemment rapportés.

Notez que l’argument de ligne de commande -iterations n’a aucun effet sur les fonctions de test ne comportant pas la macro QBENCHMARK.

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

Active (enable = true) ou désactive (enable = false) le lancement d’une exception en cas d’échec des fonctions QCOMPARE() /QVERIFY() (au lieu de simplement revenir au contexte de la fonction immédiatement supérieure).

Cette fonctionnalité utilise un compteur de références : si vous appelez cette fonction N fois avec true, vous devez l'appeler N fois avec false pour revenir à votre point de départ.

Cet appel n’a aucun effet lorsque la macro C++ QTEST_THROW_ON_FAIL est définie.

Cette fonction a été introduite dans Qt 6.8.

Voir également setThrowOnSkip(), ThrowOnFailEnabler, ThrowOnFailDisabler et QTEST_THROW_ON_FAIL.

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

Active (enable = true) ou désactive (enable = false) le lancement d’une exception lors de l’appel à ` QSKIP()` (au lieu de simplement retourner au contexte de la fonction immédiatement supérieure).

Cette fonctionnalité utilise un compteur de références : si vous appelez cette fonction N fois avec ` true`, vous devez l'appeler N fois avec ` false ` pour revenir à votre point de départ.

Cet appel n’a aucun effet lorsque la macro C++ QTEST_THROW_ON_SKIP est définie.

Cette fonction a été introduite dans Qt 6.8.

Voir également setThrowOnFail(), ThrowOnSkipEnabler, ThrowOnSkipDisabler et QTEST_THROW_ON_SKIP.

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

Renvoie un pointeur vers une chaîne de caractères correspondant à la chaîne ba, représentée sous la forme d’une séquence de caractères hexadécimaux séparés par des espaces. Si la chaîne d’entrée est jugée trop longue, elle est tronquée. Une troncature est indiquée dans la chaîne renvoyée par des points de suspension à la fin. L’appelant est propriétaire du pointeur renvoyé et doit s’assurer qu’il soit ultérieurement transmis à l’opérateur delete[].

length est la longueur de la chaîne ba.

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

Renvoie une représentation textuelle de value. Cette fonction est utilisée par QCOMPARE() pour afficher des informations détaillées en cas d'échec d'un test.

Vous pouvez ajouter des spécialisations ou des surcharges de cette fonction à votre test pour activer l'affichage détaillé.

Exemple de spécialisation (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());
    }
}

L'exemple ci-dessus définit une spécialisation de toString() pour une classe appelée MyPoint. Chaque fois qu'une comparaison entre deux instances de MyPoint échoue, QCOMPARE() appellera cette fonction pour afficher le contenu de MyPoint dans le journal de test.

Même exemple, mais avec la surcharge (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()) + ')');
}

Voir également QCOMPARE().

char *toString(QSizePolicy sp)

Renvoie une représentation textuelle de la politique de taille sp.

char *toString(QSizePolicy::ControlType ct)

Renvoie une représentation textuelle du type de contrôle ct.

char *toString(QSizePolicy::ControlTypes cts)

Renvoie une représentation textuelle des types de contrôle cts.

char *toString(QSizePolicy::Policy p)

Renvoie une représentation textuelle de la politique p.

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

Renvoie une représentation textuelle du tableau d'octets ba.

Voir également QTest::toHexRepresentation().

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

Renvoie une représentation textuelle de l'erreur CBOR indiquée c.

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

Renvoie une représentation textuelle de l'character on fournie.

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

Renvoie une représentation textuelle de l'date on fournie.

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

Renvoie une représentation textuelle de la date et de l'heure spécifiées par ` dateTime`.

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

Renvoie une représentation textuelle de la séquence de clés « ks ».

Cette fonction a été introduite dans Qt 6.5.

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

Renvoie une représentation textuelle de l'string on fournie.

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

Renvoie une représentation textuelle de l'point on fournie.

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

Renvoie une représentation textuelle de l'point on fournie.

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

Renvoie une représentation textuelle de l'rectangle on fournie.

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

Renvoie une représentation textuelle de l'rectangle on fournie.

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

Renvoie une représentation textuelle de l'size on fournie.

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

Renvoie une représentation textuelle de l'size on fournie.

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

Renvoie une représentation textuelle de l'string.

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

Renvoie une représentation textuelle de l'string on fournie.

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

Renvoie une représentation textuelle de l'time on fournie.

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

Renvoie une représentation textuelle de l'url on fournie.

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

Renvoie une représentation textuelle de l'uuid on fournie.

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

Renvoie une représentation textuelle de l'variant on fournie.

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

Renvoie une représentation textuelle du vecteur 2D v.

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

Renvoie une représentation textuelle du vecteur 3D v.

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

Renvoie une représentation textuelle du vecteur 4D v.

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

Renvoie une représentation textuelle de l'pair.

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

Renvoie une représentation textuelle de l'tuple on fournie.

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

Renvoie une chaîne contenant « nullptr ».

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

Crée et renvoie un objet ` QTouchEventSequence ` pour l'device, afin de simuler des événements pour ` widget`.

Lors de l’ajout d’événements tactiles à la séquence, widget sera également utilisé pour convertir la position fournie en coordonnées d’écran, à moins qu’un autre widget ne soit fourni dans les appels respectifs à press(), move(), etc.

Les événements tactiles sont transmis au système d’événements lorsque le destructeur de l’ QTouchEventSequence est appelé (c’est-à-dire lorsque l’objet renvoyé sort de sa portée), sauf si autoCommit est défini sur false. Lorsque autoCommit est défini sur false, la fonction commit() doit être appelée manuellement.

createTouchDeviceLa fonction () peut être appelée pour créer un périphérique tactile de test à utiliser avec cette fonction.

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

Crée et renvoie un objet ` QTouchEventSequence ` pour l'device, afin de simuler des événements pour ` window`.

Lors de l’ajout d’événements tactiles à la séquence, window sera également utilisé pour convertir la position fournie en coordonnées d’écran, à moins qu’une autre fenêtre ne soit fournie dans les appels respectifs à press(), move(), etc.

Les événements tactiles sont transmis au système d’événements lorsque le destructeur de l’ QTouchEventSequence est appelé (c’est-à-dire lorsque l’objet renvoyé sort de sa portée), sauf si autoCommit est défini sur false. Lorsque autoCommit est à false, commit() doit être appelé manuellement.

createTouchDeviceLa fonction () peut être appelée pour créer un périphérique tactile de test à utiliser avec cette fonction.

[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)

Simule un événement de molette dans ` window ` à la position ` pos ` selon les coordonnées locales de la fenêtre. ` angleDelta ` contient l'angle de rotation de la molette. Une valeur positive correspond à une rotation vers l'avant, tandis qu'une valeur négative correspond à une rotation vers l'arrière. ` pixelDelta ` contient la distance de défilement en pixels à l'écran. Cette valeur peut être nulle. Les états du clavier au moment de l'événement sont spécifiés par ` stateKey`. La phase de défilement de l'événement est spécifiée par ` phase`.

Cette fonction a été introduite dans Qt 6.8.