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 pour les compilateurs bogués et peut être ignoré.

Pour remplir la colonne avec des valeurs, newRow() peut être utilisé. Utilisez QFETCH() pour récupérer les données dans le test actuel.

Exemple :

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

Voir Data Driven Testing pour un exemple plus complet.

Voir aussi 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. Voir la documentation de std::snprintf() pour 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 qui résulte de ce formatage.

Renvoie une référence QTestData qui peut être utilisée pour introduire des données, une valeur pour chaque 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");

Voir Data Driven Testing pour un exemple plus complet.

Voir aussi newRow(), addColumn() et QFETCH().

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

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

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

Renvoie les unités de mesure pour le site metric spécifié.

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

Crée un dispositif tactile fictif de type devType avec des capacités caps pour la simulation d'événements tactiles.

Le périphérique tactile sera enregistré avec l'interface du système de fenêtres Qt. Vous devriez généralement utiliser createTouchDevice() pour initialiser une variable membre 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 aussi QTest::QTouchEventSequence et touchEvent().

const char *QTest::currentAppName()

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

const char *QTest::currentDataTag()

Renvoie le nom des données de test actuelles. Si le test n'a pas de données de test assignées, la fonction renvoie nullptr.

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

Renvoie le nom des données de test globales actuelles. Si le test n'a pas de données de test globales assignées, 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 actuelle a échoué ou a été ignorée.

Ceci s'applique si le test a échoué ou a exercé un saut. Lorsque cette condition est remplie, la fonction de test doit être renvoyée plus tôt que prévu. En particulier, les macros QTRY_* et la boucle d'événements de test terminent leurs boucles plus tôt si elles sont exécutées pendant la fonction de test (mais pas son cleanup()). Après qu'un test a appelé une fonction d'aide qui utilise les macros de ce module, il peut utiliser cette fonction pour tester s'il faut retourner plus tôt.

Cette fonction a été introduite dans Qt 6.5.

Voir aussi QTest::currentTestFailed().

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

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

La fonction de test poursuit son exécution lorsqu'un échec est ajouté. Pour interrompre le test à la place, vous pouvez vérifier currentTestFailed() et retourner plus tôt si c'est le cas true.

Pour chaque avertissement, le premier motif qui correspond provoquera un échec, et les autres motifs seront ignorés.

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

void FileTest::loadFiles() { QTest::failOnWarning(QRegularExpression("^Echec du chargement")) ; // Chacun de ces éléments entraînera un é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é, passez une expression régulière appropriée à cette fonction dans init():

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

Pour le cas courant d'échec sur n'importe quel avertissement, ne pas passer de paramètre :

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

Cette fonction a été introduite dans Qt 6.3.

Voir aussi QTEST_FATAL_FAIL.

[since 6.8] void QTest::failOnWarning()

Ajoute un échec de test au journal de test si un avertissement est émis.

Cette fonction a été introduite dans Qt 6.8.

Voir aussi failOnWarning(const char *).

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

Ajoute un échec de test au journal de test si l'adresse message est affichée.

Cette fonction a été introduite dans Qt 6.3.

Voir aussi failOnWarning().

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

Ignore les messages créés par qDebug(), qInfo() ou qWarning(). Si le message message avec le message type correspondant est émis, il sera supprimé du journal des tests. Si le test s'est terminé et que le message message n'a pas été envoyé, un échec du test est ajouté au journal du test.

Exemple :

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

L'exemple ci-dessus teste que QDir::mkdir() émet le bon avertissement lorsqu'il est invoqué avec un nom de fichier non valide.

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

Ignore les messages créés par qDebug(), qInfo() ou qWarning(). Si le message correspondant à messagePattern et à type est émis, il sera supprimé du journal des tests. Si le test s'est terminé et que le message n'a pas été émis, un échec du test est ajouté au journal du test.

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

Simule le clic de key avec une option modifier sur widget. Si delay est plus grand que 0, le test attendra delay millisecondes avant de cliquer sur la touche.

Exemples :

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

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

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

Voir aussi QTest::keyClicks().

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

Simule le clic de key avec une option modifier sur widget. Si delay est plus grand que 0, le test attendra delay millisecondes avant de cliquer sur la touche.

Exemple :

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

L'exemple ci-dessus simule le clic de a sur myWidget sans aucun modificateur de clavier et sans retard du test.

Voir aussi QTest::keyClicks().

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

Simule le clic de key avec une option modifier sur window. Si delay est plus grand que 0, le test attendra delay millisecondes avant de cliquer sur la touche.

Exemples :

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

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

Voir aussi QTest::keyClicks().

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

Simule le clic de key avec une option modifier sur window. Si delay est plus grand que 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 le clic de a sur myWindow sans aucun modificateur de clavier et sans retard du test.

Voir aussi QTest::keyClicks().

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

Simule le clic d'une sequence de touches sur une widget. En option, un clavier modifier peut être spécifié ainsi qu'une delay (en millisecondes) du test avant chaque clic de touche.

Exemple :

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

L'exemple ci-dessus simule le clic de la séquence de touches représentant "hello world" sur myWidget sans aucun modificateur de clavier et sans délai du test.

Voir aussi 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'adresse key donnée et une adresse action associée. En option, un clavier modifier peut être spécifié, 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 la touche donnée ascii et une action associée. En option, un clavier modifier peut être spécifié, 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'adresse key donnée et une adresse action associée. En option, un clavier modifier peut être spécifié, ainsi qu'un 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 la touche donnée ascii et une action associée. En option, un clavier modifier peut être spécifié, ainsi qu'un 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 une option modifier sur une touche widget. Si delay est plus grand que 0, le test attendra delay millisecondes avant d'appuyer sur la touche.

Voir aussi 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 une option modifier sur une touche widget. Si delay est plus grand que 0, le test attendra delay millisecondes avant d'appuyer sur la touche.

Voir aussi QTest::keyRelease() et QTest::keyClick().

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

Simule l'appui sur une touche key avec une option modifier sur une touche window. Si delay est plus grand que 0, le test attendra delay millisecondes avant d'appuyer sur la touche.

Voir aussi 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 une option modifier sur une touche window. Si delay est plus grand que 0, le test attendra delay millisecondes avant d'appuyer sur la touche.

Voir aussi 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'une clé key avec une option modifier sur une clé widget. Si delay est plus grand que 0, le test attendra delay millisecondes avant de libérer la clé.

Voir aussi 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 option modifier sur une clé widget. Si delay est plus grand que 0, le test attendra delay millisecondes avant de libérer la clé.

Voir aussi 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 une option modifier sur une clé window. Si delay est plus grand que 0, le test attendra delay millisecondes avant de libérer la clé.

Voir aussi 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 une option modifier sur une clé window. Si delay est plus grand que 0, le test attendra delay millisecondes avant de libérer la clé.

Voir aussi QTest::keyClick().

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

Simule le typage de keySequence en widget.

Voir aussi QTest::keyClick() et QTest::keyClicks().

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

Simule le typage de keySequence en window.

Voir aussi 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 le clic d'une souris button avec un modifier optionnel 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 spécifié avant d'appuyer 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 le clic d'une souris button avec un modificateur optionnel stateKey sur un 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 spécifié avant d'appuyer sur le bouton et de le relâcher.

Voir aussi 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 le double clic d'une souris button avec un modifier optionnel 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 spécifié avant chaque pression et relâchement.

Voir aussi 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 un modificateur optionnel stateKey sur 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 spécifié avant chaque pression et relâchement.

Voir aussi 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 donné, 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 adresse window. Si pos n'est pas spécifié, le pointeur de la souris se déplace vers le centre de la fenêtre. Si un delay (en millisecondes) est donné, le test 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 l'appui d'une souris button avec un modifier optionnel 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 spécifié avant d'appuyer.

Voir aussi 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'appui d'une souris button avec un modificateur optionnel stateKey sur un 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 spécifié avant d'appuyer.

Voir aussi 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'une souris button avec une option modifier sur une 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 spécifié avant de relâcher le bouton ; sinon, il attendra le temps par défaut (1 ms), qui peut être modifié par les arguments de la 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'une souris button avec un modificateur optionnel stateKey sur un bouton 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 spécifié avant de relâcher le bouton ; sinon, il attendra le temps par défaut (1 ms), qui peut être modifié par les arguments de la 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 aussi QTest::mousePress() et QTest::mouseClick().

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

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

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

Renvoie une référence QTestData qui peut être utilisée pour intégrer des données, une valeur pour chaque colonne du tableau.

Exemple :

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

Voir Data Driven Testing pour un exemple plus complet.

Voir aussi addRow(), addColumn() et QFETCH().

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

Exécute les tests déclarés dans testObject. En outre, 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.

Les arguments de ligne de commande argc et argv peuvent être fournis en option. Pour obtenir la liste des arguments reconnus, consultez Qt Test Arguments de ligne de commande.

L'exemple suivant exécute tous les tests de 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 la ligne de commande et exécute les tests, ce qui évite d'appeler explicitement cette fonction.

La valeur de retour de cette fonction est également le 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 pour l'enregistrement des résultats des tests dans des fichiers et l'exécution des fonctions de test individuelles ne se comporteront pas correctement.

Si vous avez créé les arguments par programme, plutôt que de les obtenir à partir des arguments de main(), il est probablement intéressant d'utiliser QTest::qExec(QObject *, const QStringList &) puisqu'il est sûr pour Unicode.

Voir aussi QTEST_MAIN(), QTEST_GUILESS_MAIN(), et QTEST_APPLESS_MAIN().

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

Se comporte de manière identique à qExec(QObject *, int, char**) mais prend un QStringList de arguments au lieu d'une liste de char**.

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

Extrait un répertoire des ressources sur le disque. Le contenu est extrait récursivement dans un dossier temporaire. Le contenu extrait est supprimé automatiquement dès que la dernière référence à la valeur de retour sort du champ d'application.

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

Renvoie le répertoire temporaire dans lequel les données ont été extraites ou 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 de cas de test pour le binaire actuel.

L'adresse name sera répertoriée lors de l'exécution du binaire de test par lots sans paramètres. L'exécution du binaire de test avec l'argv[1] de name entraînera l'appel de entryFunction.

Cette fonction a été introduite dans Qt 6.5.

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

Dort pour msecs, bloquant l'exécution du test.

Cette méthode ne traitera aucun événement et laissera votre test sans réponse. La communication réseau peut être interrompue pendant le sommeil. Utilisez QTest::qWait() pour une mise en veille non bloquante.

msecs doit être supérieur à 0ms.

Exemple :

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

Cette fonction a été introduite dans Qt 6.7.

Voir aussi QTest::qWait().

void QTest::qSleep(int ms)

Dort pendant ms millisecondes, bloquant ainsi l'exécution du test.

Équivalent à l'appel :

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

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

Attend msecs. Pendant cette 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 un maximum d'environ 12,5 secondes.

Les macros QTRY_* sont généralement un meilleur choix que qWait(). qWait() fait toujours une pause pendant la durée totale, ce qui peut laisser le test inactif et ralentir l'exécution.

Les macros QTRY_* interrogent la condition jusqu'à ce qu'elle réussisse 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 msecs. Équivalent à l'appel :

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 jusqu'à ce que deadline ait expiré ou jusqu'à ce que predicate renvoie un message vrai, selon ce qui se produit en premier.

Renvoie true si predicate est devenu vrai à un moment donné, sinon 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 un maximum de trois secondes.

Cette fonction a été introduite dans Qt 6.7.

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

Attend timeout millisecondes ou jusqu'à ce que predicate retourne vrai.

Cela équivaut à appeler :

qWaitFor(predicate, QDeadlineTimer(timeout));

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

Renvoie true si widget est actif dans les timeout millisecondes. Sinon, elle renvoie false.

Cette méthode est utile dans les tests qui appellent QWidget::show() et s'appuient sur le fait que le widget est réellement actif (c'est-à-dire qu'il est visible et qu'il a le focus) avant de continuer.

Cette fonction a été introduite dans Qt 6.10.

Voir aussi qWaitForWindowExposed() et QWidget::isActiveWindow().

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

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

Cette méthode est utile dans les tests qui appellent QWindow::show() et s'appuient sur le fait que la fenêtre est réellement active (c'est-à-dire qu'elle est visible et qu'elle a le focus) avant de continuer.

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'attente 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'attente par défaut de 5 secondes.

Cette fonction a été introduite dans Qt 6.10.

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

L'adresse timeout est exprimée en millisecondes.

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

L'adresse timeout est exprimée en millisecondes.

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

Renvoie true si widget est exposé dans les timeout millisecondes. Sinon, elle renvoie false.

Cette méthode est utile dans les tests qui appellent QWidget::show() et s'appuient sur le fait que le widget est effectivement visible avant de continuer.

Cette fonction a été introduite dans Qt 6.10.

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

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

Renvoie true, si window est exposé à l'intérieur de timeout. Sinon, renvoie false.

Cette méthode est utile dans les tests qui appellent QWindow::show() et s'appuient sur le fait que la fenêtre est effectivement 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'attente 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'attente par défaut de 5 secondes.

Cette fonction a été introduite dans Qt 6.10.

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

L'adresse timeout est exprimée en millisecondes.

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

L'adresse timeout est exprimée en millisecondes.

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

Renvoie true, si widget est la fenêtre de focus dans timeout. Sinon, renvoie false.

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

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 principale de timeout. Sinon, renvoie false.

Cette méthode est utile dans les tests qui appellent QWindow::show() et qui dépendent de la focalisation de la fenêtre (pour recevoir des événements clavier par exemple) avant de continuer.

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'attente 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'attente 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 du benchmark pour cette fonction de test à result.

Utilisez cette fonction si vous souhaitez communiquer les résultats du 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 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 rapportés précédemment.

Notez que l'argument de ligne de commande -iterations n'a aucun effet sur les fonctions de test sans la macro QBENCHMARK.

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

Active (enable = true) ou désactive ( enable = false) le lancement en cas d'échec de QCOMPARE()/QVERIFY() (par opposition au simple retour du contexte de la fonction immédiatement environnante).

La fonction est comptabilisée par référence : 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 aussi 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 sur QSKIP() (par opposition au simple retour du contexte de la fonction immédiatement environnante).

La fonction est comptée par référence : 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 aussi setThrowOnFail(), ThrowOnSkipEnabler, ThrowOnSkipDisabler, et QTEST_THROW_ON_SKIP.

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

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

length est la longueur de la chaîne ba.

char *toString(QSizePolicy sp)

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

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

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

Vous pouvez ajouter des spécialisations ou des surcharges de cette fonction à votre test pour activer la sortie verbose.

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 toString() pour une classe appelée MyPoint. Chaque fois qu'une comparaison de 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 surcharge (Qt ≥ 5.5) :

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

Voir aussi QCOMPARE().

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 aussi QTest::toHexRepresentation().

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

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

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

Renvoie une représentation textuelle de l'adresse character.

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

Renvoie une représentation textuelle de l'adresse date.

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 touches ks.

Cette fonction a été introduite dans Qt 6.5.

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

Renvoie une représentation textuelle de l'adresse string.

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

Renvoie une représentation textuelle de l'adresse point.

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

Renvoie une représentation textuelle de l'adresse point.

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

Renvoie une représentation textuelle de l'adresse rectangle.

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

Renvoie une représentation textuelle de l'adresse rectangle.

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

Renvoie une représentation textuelle de l'adresse size.

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

Renvoie une représentation textuelle de l'adresse size.

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

Renvoie une représentation textuelle de l'adresse string.

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

Renvoie une représentation textuelle de l'adresse string.

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

Renvoie une représentation textuelle de l'adresse time.

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

Renvoie une représentation textuelle de l'adresse url.

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

Renvoie une représentation textuelle de l'adresse uuid.

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

Renvoie une représentation textuelle de l'adresse variant.

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 pair.

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

Renvoie une représentation textuelle de l'adresse tuple.

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

Renvoie une chaîne de caractères contenant nullptr.

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

Crée et renvoie un QTouchEventSequence pour le device afin de simuler les événements du widget.

Lors de l'ajout d'événements tactiles à la séquence, widget sera également utilisé pour traduire 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 enregistrés dans le système d'événements lorsque le destructeur de QTouchEventSequence est appelé (c'est-à-dire lorsque l'objet renvoyé sort du champ d'application), à moins que autoCommit ne soit défini comme faux. Lorsque autoCommit est faux, commit() doit être appelé manuellement.

createTouchDevice() peut être appelé pour créer un dispositif tactile de test à utiliser avec cette fonction.

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

Crée et renvoie un QTouchEventSequence pour le device afin de simuler les événements du window.

Lors de l'ajout d'événements tactiles à la séquence, window sera également utilisé pour traduire 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 enregistrés dans le système d'événements lorsque le destructeur de QTouchEventSequence est appelé (c'est-à-dire lorsque l'objet renvoyé sort du champ d'application), à moins que autoCommit ne soit défini comme faux. Lorsque autoCommit est faux, commit() doit être appelé manuellement.

createTouchDevice() peut être appelé pour créer un dispositif 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 roue dans window à la position pos dans les coordonnées locales de la fenêtre. angleDelta contient l'angle de rotation de la roue. Une valeur positive signifie une rotation vers l'avant, et une valeur négative signifie une rotation vers l'arrière. pixelDelta contient la distance de défilement en pixels sur 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.