Back to Qt.io
Contact Us Blog Download Qt
Sur cette page

TestCase QML Type

Représente un cas de test unitaire. Plus...

Import Statement: import QtTest
Inherits:

Item

Propriétés

Méthodes

Description détaillée

Introduction aux cas de test QML

Les cas de test sont écrits sous forme de fonctions JavaScript dans un type TestCase :

import QtQuick 2.0
import QtTest 1.2

TestCase {
    name: "MathTests"

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

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

Les fonctions dont le nom commence par "test_" sont considérées comme des cas de test à exécuter. La propriété name est utilisée pour préfixer les fonctions dans la sortie :

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

En raison du mode de fonctionnement des propriétés JavaScript, l'ordre dans lequel les fonctions de test sont trouvées est imprévisible. Pour aider à la prévisibilité, le cadre de test triera les fonctions par ordre croissant de nom. Cela peut s'avérer utile lorsque deux tests doivent être exécutés dans l'ordre.

Plusieurs types de TestCase peuvent être fournis. Le programme de test se termine lorsque tous les tests sont terminés. Si un scénario de test n'a pas besoin d'être exécuté (parce qu'une condition préalable a échoué), alors optional peut être mis à vrai.

Tests basés sur des données

Les données d'un tableau peuvent être fournies à un test en utilisant un nom de fonction se terminant par "_data". Alternativement, la fonction init_data() peut être utilisée pour fournir des données de test par défaut pour toutes les fonctions de test sans fonction "_data" correspondante dans un type TestCase :

import QtQuick 2.0
import QtTest 1.2

TestCase {
    name: "DataTests"

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

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

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

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

Le cadre de test itère sur toutes les lignes du tableau et transmet chaque ligne à la fonction de test. Comme indiqué, les colonnes peuvent être extraites pour être utilisées dans le test. La colonne tag est spéciale - elle est imprimée par le cadre de test lorsqu'une ligne échoue, afin d'aider le lecteur à identifier le cas qui a échoué parmi un ensemble de tests qui ont par ailleurs réussi.

Critères de référence

Les fonctions dont le nom commence par "benchmark_" seront exécutées plusieurs fois avec le cadre de référence de Qt, avec une valeur moyenne de temps rapportée pour les exécutions. Ceci est équivalent à l'utilisation de la macro QBENCHMARK dans la version C++ de QTestLib.

TestCase {
    id: top
    name: "CreateBenchmark"

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

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

Pour obtenir l'effet de la macro QBENCHMARK_ONCE, préfixez le nom de la fonction de test par "benchmark_once_".

Simulation des événements du clavier et de la souris

Les méthodes keyPress(), keyRelease() et keyClick() peuvent être utilisées pour simuler des événements clavier dans les tests unitaires. Les événements sont transmis à l'élément QML en cours d'affichage. Vous pouvez passer soit une valeur de l'enum Qt.Key, soit un caractère latin1 (chaîne de longueur un).

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

    TestCase {
        name: "KeyClick"
        when: windowShown

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

Les méthodes mousePress(), mouseRelease(), mouseClick(), mouseDoubleClickSequence() et mouseMove() peuvent être utilisées pour simuler les événements de la souris de la même manière.

Si votre test crée d'autres fenêtres, il est possible que ces fenêtres deviennent actives et volent le focus de la fenêtre du TestCase. Pour s'assurer que la fenêtre du TestCase est active, utilisez le code suivant :

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

Remarque : les événements liés au clavier et à la souris ne peuvent être transmis qu'une fois la fenêtre principale affichée. Toute tentative de transmission d'événements avant cette date échouera. Utilisez les propriétés when et windowShown pour savoir quand la fenêtre principale a été affichée.

Gestion des objets de test créés dynamiquement

Un schéma typique des tests QML consiste à créer dynamiquement un élément et à le détruire à la fin de la fonction de test :

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

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

        // Test item...

        item.destroy();
    }
}

Le problème de ce schéma est que toute défaillance dans la fonction de test fera sauter l'appel à item.destroy(), laissant l'élément traîner dans la scène jusqu'à ce que le cas de test soit terminé. Cela peut entraîner des interférences avec les tests ultérieurs, par exemple en bloquant les événements d'entrée ou en produisant une sortie de débogage sans rapport qui rend difficile le suivi de l'exécution du code.

En appelant createTemporaryQmlObject() à la place, la destruction de l'objet est garantie à la fin de la fonction de test :

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

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

        // Test item...

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

Pour les objets créés via la fonction createObject() de Component, la fonction createTemporaryObject() peut être utilisée.

Séparer les tests de la logique de l'application

Dans la plupart des cas, vous voudrez séparer vos tests de la logique de l'application en les répartissant dans différents projets et en les reliant.

Par exemple, vous pourriez avoir la structure de projet suivante :

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

Pour tester MyModule/MyButton.qml, créez une bibliothèque pour MyModule dans MyModule/CMakeLists.txt et reliez-la à votre projet de test, tests/UnitQMLTests/CMakeLists.txt:

    ...
qt_add_library(MyModule STATIC)

qt6_add_qml_module(MyModule
    URI MyModule
    QML_FILES MyButton.qml
)
    ...
    ...
add_executable(TestMyApplication main.cpp
               setup.cpp setup.h)

add_test(NAME TestMyApplication COMMAND TestMyApplication)

target_link_libraries(TestMyApplication
    PRIVATE
        Qt6::QuickTest
        Qt6::Qml
        MyModule
        MyModuleplugin
)
    ...
#include <QtQuickTest/quicktest.h>
#include "setup.h"

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

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

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

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

#include <QObject>
#include <QQmlEngine>

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

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

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

qt_add_executable(MyApplication
    src/main.cpp
)

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

Ensuite, dans tests/tst_testqml.qml, vous pouvez importer MyModule/MyButton.qml:

import QtQuick
import QtQuick.Controls

import QtTest
import MyModule

Item {
    width: 800
    height: 600

    MyButton {
        id: myButton
        anchors.centerIn: parent
    }

    TestCase {
        name: "MyButton"
        when: windowShown

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

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

Voir aussi SignalSpy et Qt Quick Test.

Documentation sur les propriétés

completed : bool

Cette propriété prend la valeur "true" lorsque l'exécution du scénario de test est terminée. Les cas de test ne sont exécutés qu'une seule fois. La valeur initiale est false.

Voir également running et when.

name : string

Cette propriété définit le nom du cas de test pour la communication des résultats. La valeur par défaut est une chaîne vide.

TestCase {
    name: "ButtonTests"
    ...
}

optional : bool

Plusieurs types de TestCase peuvent être fournis dans une application de test. L'application se terminera une fois qu'ils auront tous été exécutés. Si un scénario de test n'a pas besoin d'être exécuté (parce qu'une condition préalable a échoué), cette propriété peut être fixée à true. La valeur par défaut est false.

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

Voir également when et completed.

running : bool

Cette propriété prend la valeur "true" pendant l'exécution du scénario de test. La valeur initiale est false, et la valeur redevient false une fois le scénario de test terminé.

Voir également completed et when.

when : bool

Cette propriété doit être définie à true lorsque l'application souhaite que les cas de test soient exécutés. La valeur par défaut est true. Dans l'exemple suivant, un test est exécuté lorsque l'utilisateur appuie sur le bouton de la souris :

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

    MouseArea {
        id: area
        anchors.fill: parent
    }

    property bool bar: true

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

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

L'application de test se termine lorsque tous les types de TestCase ont été déclenchés et exécutés. La propriété optional peut être utilisée pour exclure un type TestCase.

Voir également optional et completed.

windowShown : bool

Cette propriété sera fixée à true après l'affichage de la fenêtre de visualisation QML. Normalement, les scénarios de test s'exécutent dès que l'application de test est chargée et avant qu'une fenêtre ne soit affichée. Si le scénario de test implique des types visuels et des comportements, il peut être nécessaire de le retarder jusqu'à ce que la fenêtre soit affichée.

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

Documentation de la méthode

cleanup()

Cette fonction est appelée après chaque fonction de test exécutée dans le type TestCase. L'implémentation par défaut ne fait rien. L'application peut fournir sa propre implémentation pour effectuer le nettoyage après chaque fonction de test.

Voir aussi init() et cleanupTestCase().

cleanupTestCase()

Cette fonction est appelée après que toutes les autres fonctions de test du type TestCase ont été exécutées. L'implémentation par défaut ne fait rien. L'application peut fournir sa propre implémentation pour effectuer le nettoyage des cas de test.

Voir aussi initTestCase() et cleanup().

compare(actual, expected, message = "")

Échec du cas de test actuel si actual n'est pas identique à expected, et affichage de l'option message. Similaire à QCOMPARE(actual, expected) en C++.

Voir aussi tryCompare() et fuzzyCompare.

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

Cette fonction crée dynamiquement un objet QML à partir de l'adresse component et des options parent et properties spécifiées. L'objet renvoyé sera détruit (s'il ne l'était pas déjà) une fois que cleanup() aura fini de s'exécuter, ce qui signifie que les objets créés avec cette fonction sont garantis d'être détruits après chaque test, que les tests échouent ou non.

En cas d'erreur lors de la création de l'objet, null sera renvoyé.

Cette fonction appelle component.createObject() en interne.

Voir aussi Managing Dynamically Created Test Objects.

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

Cette fonction crée dynamiquement un objet QML à partir de la chaîne qml donnée avec la chaîne parent spécifiée. L'objet renvoyé sera détruit (s'il ne l'était pas déjà) une fois que cleanup() aura fini de s'exécuter, ce qui signifie que les objets créés avec cette fonction sont garantis d'être détruits après chaque test, que les tests échouent ou non.

En cas d'erreur lors de la création de l'objet, null sera renvoyé.

Si filePath est spécifié, il sera utilisé pour signaler les erreurs de l'objet créé.

Cette fonction appelle Qt.createQmlObject() en interne.

Voir aussi Managing Dynamically Created Test Objects.

expectFail(tag, message)

Dans un test piloté par les données, marque la ligne associée à tag comme devant échouer. Lorsque l'échec se produit, il affiche le message message, interrompt le test et indique que le test est réussi. Similaire à QEXPECT_FAIL(tag, message, Abort) en C++.

Si le test n'est pas basé sur des données, alors tag doit être défini comme une chaîne vide.

Voir aussi expectFailContinue().

expectFailContinue(tag, message)

Dans un test piloté par les données, marquez la ligne associée à tag comme devant échouer. Lorsque l'échec se produit, il affiche message, puis poursuit le test. Similaire à QEXPECT_FAIL(tag, message, Continue) en C++.

Si le test n'est pas piloté par les données, tag doit être défini comme une chaîne vide.

Voir aussi expectFail().

fail(message = "")

Échec du cas de test en cours, avec l'option message. Similaire à QFAIL(message) en C++.

[since 6.3] failOnWarning(message)

Ajoute un échec de test au journal de test pour chaque avertissement correspondant à message. La fonction de test poursuit son exécution lorsqu'un échec est ajouté.

message peut être soit une chaîne de caractères, soit une expression régulière fournissant un modèle de messages. Dans ce dernier cas, pour chaque avertissement rencontré, le premier motif qui correspond provoquera un échec, et les motifs restants seront ignorés.

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

Par exemple, l'extrait suivant échouera à un test si un avertissement contenant le texte "Quelque chose de grave s'est produit" est produit :

failOnWarning("Something bad happened")

L'extrait suivant échouera à un test si un avertissement correspondant au motif donné est rencontré :

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

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

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

Remarque : bien qu'il s'agisse d'un objet JavaScript RegExp, il ne sera pas interprété comme tel ; au lieu de cela, le motif sera transmis à QRegularExpression.

Remarque : ignoreMessage() a la priorité sur cette fonction, de sorte que tout avertissement correspondant à un motif donné à la fois à ignoreMessage() et à failOnWarning() sera ignoré.

Cette méthode a été introduite dans Qt 6.3.

Voir aussi QTest::failOnWarning() et warn().

QtObject findChild(parent, objectName)

Renvoie le premier enfant de parent avec objectName, ou null si aucun élément de ce type n'existe. Les enfants visuels et non visuels sont recherchés de manière récursive, les enfants visuels étant recherchés en premier.

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

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

Échec du cas de test actuel si la différence entre actual et expected est supérieure à delta, et affichage de la valeur optionnelle message. Similaire à qFuzzyCompare(actual, expected) en C++ mais avec une valeur delta obligatoire.

Cette fonction peut également être utilisée pour les comparaisons de couleurs si les valeurs actual et expected peuvent être converties en valeurs de couleurs. Si l'une des différences entre les valeurs des canaux RGBA est supérieure à delta, le test échoue.

Voir également tryCompare() et compare().

object grabImage(item)

Renvoie un objet image instantané de l'adresse item.

L'objet image retourné possède les propriétés suivantes :

  • width Retourne la largeur de l'image sous-jacente (depuis 5.10)
  • height Renvoie la hauteur de l'image sous-jacente (depuis 5.10)
  • size Renvoie la taille de l'image sous-jacente (depuis 5.10)

De plus, l'objet image retourné possède les méthodes suivantes :

  • red(x, y) renvoie la valeur du canal rouge du pixel à la position x, y
  • green(x, y) renvoie la valeur du canal vert du pixel à la position x, y
  • blue(x, y) Renvoie la valeur du canal bleu du pixel à la position x, y
  • alpha(x, y) Renvoie la valeur du canal alpha du pixel à la position x, y
  • pixel(x, y) Renvoie la valeur de la couleur du pixel à la position x, y
  • equals(image) Renvoie true si cette image est identique à l'image - voir QImage::operator== (depuis la version 5.6)

    Par exemple :

    let image = grabImage(rect);
compare(image.red(10, 10), 255);
compare(image.pixel(20, 20), Qt.rgba(255, 0, 0, 255));

rect.width += 10;
let newImage = grabImage(rect);
verify(!newImage.equals(image));
  • save(path) Enregistre l'image dans le chemin d'accès donné. Si l'image ne peut pas être sauvegardée, une exception sera levée. (depuis la version 5.10)

    Cela peut être utile pour effectuer une analyse post-mortem sur les tests qui échouent, par exemple :

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

ignoreWarning(message)

Marque message comme un message d'avertissement ignoré. Lorsqu'il se produit, l'avertissement n'est pas imprimé et le test est réussi. Si le message ne se produit pas, le test échoue. Similaire à QTest::ignoreMessage(QtWarningMsg, message) en C++.

Depuis Qt 5.12, message peut être soit une chaîne de caractères, soit une expression régulière fournissant un modèle de messages à ignorer.

Par exemple, l'extrait suivant ignorera un message d'avertissement sous forme de chaîne de caractères :

ignoreWarning("Something sort of bad happened")

Et l'extrait suivant ignorera une expression régulière correspondant à un certain nombre de messages d'avertissement possibles :

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

Remarque : bien qu'il s'agisse d'un objet JavaScript RegExp, il ne sera pas interprété comme tel ; le motif sera transmis à QRegularExpression.

Voir également warn().

init()

Cette fonction est appelée avant chaque fonction de test exécutée dans le type TestCase. L'implémentation par défaut ne fait rien. L'application peut fournir sa propre implémentation pour effectuer l'initialisation avant chaque fonction de test.

Voir aussi cleanup() et initTestCase().

initTestCase()

Cette fonction est appelée avant toute autre fonction de test dans le type TestCase. L'implémentation par défaut ne fait rien. L'application peut fournir sa propre implémentation pour effectuer l'initialisation du cas de test.

Voir aussi cleanupTestCase() et init().

bool isPolishScheduled(object itemOrWindow)

Si itemOrWindow est un Item, cette fonction renvoie true si updatePolish() n'a pas été appelé depuis le dernier appel à polish(), sinon elle renvoie false.

Depuis Qt 6.5, si itemOrWindow est un Window, cette fonction renvoie true si updatePolish() n'a pas été appelé sur un élément qu'il gère depuis le dernier appel à polish() sur ces éléments, sinon elle renvoie false.

Lors de l'affectation de valeurs à des propriétés en QML, toute mise en page que l'élément doit effectuer à la suite de l'affectation peut ne pas prendre effet immédiatement, mais peut être reportée jusqu'à ce que l'élément soit poli. Dans ce cas, vous pouvez utiliser cette fonction pour vous assurer que les éléments ont été polis avant que l'exécution du test ne se poursuive. Par exemple :

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

Sans l'appel à isPolishScheduled() ci-dessus, l'appel à waitForItemPolished() pourrait voir qu'aucun polissage n'a été programmé et donc passer instantanément, en supposant que l'élément a déjà été poli. Cette fonction permet de comprendre pourquoi un élément n'a pas été poli et permet aux tests d'échouer prématurément dans de telles circonstances.

Voir aussi waitForPolish(), QQuickItem::polish() et QQuickItem::updatePolish().

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

Simule le clic de key avec l'option modifiers sur l'élément en cours de focalisation. Si delay est supérieur à 0, le test attendra delay millisecondes.

L'événement sera envoyé à la fenêtre TestCase ou, en cas de fenêtres multiples, à la fenêtre active. Voir QGuiApplication::focusWindow() pour plus de détails.

Voir également keyPress() et keyRelease().

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

Simule l'appui d'un key avec l'option modifiers sur l'élément en cours de focalisation. Si delay est supérieur à 0, le test attendra delay millisecondes.

L'événement sera envoyé à la fenêtre TestCase ou, en cas de fenêtres multiples, à la fenêtre active. Voir QGuiApplication::focusWindow() pour plus de détails.

Remarque : à un moment donné, vous devez relâcher la touche en utilisant keyRelease().

Voir également keyRelease() et keyClick().

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

Simule le relâchement d'un key avec l'option modifiers sur l'élément en cours de focalisation. Si delay est supérieur à 0, le test attendra delay millisecondes.

L'événement sera envoyé à la fenêtre TestCase ou, en cas de fenêtres multiples, à la fenêtre active. Voir QGuiApplication::focusWindow() pour plus de détails.

Voir également keyPress() et keyClick().

keySequence(keySequence)

Simule la frappe de keySequence. La séquence de touches peut être définie comme l'une des séquences de standard keyboard shortcuts, ou peut être décrite par une chaîne de caractères contenant une séquence de quatre pressions de touches au maximum.

Chaque événement est envoyé à la fenêtre TestCase ou, en cas de fenêtres multiples, à la fenêtre active actuelle. Voir QGuiApplication::focusWindow() pour plus de détails.

Voir également keyPress(), keyRelease(), GNU Emacs Style Key Sequences, et Shortcut.sequence.

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

Simule le clic d'une souris button avec l'option modifiers sur une item. La position du clic est définie par x et y. Si x et y ne sont pas définis, la position sera le centre de item. 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.

La position donnée par x et y est transformée du système de coordonnées de item en coordonnées de fenêtre, puis livrée. Si item est masqué par un autre élément ou si un enfant de item occupe cette position, l'événement sera transmis à l'autre élément.

Voir aussi mousePress(), mouseRelease(), mouseDoubleClickSequence(), mouseMove(), mouseDrag() et mouseWheel().

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

Simule la séquence complète des événements générés par un double-clic de souris button avec modifiers optionnel sur item.

Cette méthode reproduit la séquence d'événements de la souris générés lorsqu'un utilisateur effectue un double clic : Appuyer-Relâcher-Appuyer-DoubleClic-Relâcher.

La position du clic est définie par x et y. Si x et y ne sont pas définis, la position sera le centre de item. Si delay est spécifié, le test attendra le nombre de millisecondes spécifié avant d'appuyer et de relâcher le bouton.

La position donnée par x et y est transformée du système de coordonnées de item en coordonnées de fenêtre, puis livrée. Si item est masqué par un autre élément ou si un enfant de item occupe cette position, l'événement sera transmis à l'autre élément.

Cette méthode Qt Qml a été introduite dans Qt 5.5.

Voir aussi mousePress(), mouseRelease(), mouseClick(), mouseMove(), mouseDrag() et mouseWheel().

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

Simule le déplacement de la souris sur un site item avec button enfoncé et modifiers en option. La position initiale du déplacement est définie par x et y, et la distance de déplacement est définie par dx et dy. Si delay est spécifié, le test attendra le nombre de millisecondes spécifié avant de relâcher le bouton.

La position donnée par x et y est transformée du système de coordonnées de item en coordonnées de la fenêtre, puis livrée. Si item est masqué par un autre élément ou si un enfant de item occupe cette position, l'événement sera transmis à l'autre élément.

Voir aussi mousePress(), mouseClick(), mouseDoubleClickSequence(), mouseMove(), mouseRelease() et mouseWheel().

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

Déplace le pointeur de la souris à la position donnée par x et y à l'intérieur de item, tout en maintenant buttons s'il est donné. Depuis Qt XML 6.0, si x et y ne sont pas définis, la position sera le centre de item.

Si un delay (en millisecondes) est indiqué, le test attendra avant de déplacer le pointeur de la souris.

La position donnée par x et y est transformée du système de coordonnées de item en coordonnées de fenêtre, puis livrée. Si item est masqué par un autre élément ou si un enfant de item occupe cette position, l'événement sera transmis à l'autre élément.

Voir aussi mousePress(), mouseRelease(), mouseClick(), mouseDoubleClickSequence(), mouseDrag() et mouseWheel().

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

Simule l'appui d'une souris button avec l'option modifiers sur une item. La position est définie par x et y. Si x ou y ne sont pas définis, la position sera le centre de item. Si delay est spécifié, le test attendra le nombre de millisecondes spécifié avant l'appui.

La position donnée par x et y est transformée du système de coordonnées de item en coordonnées de fenêtre, puis livrée. Si item est masqué par un autre élément ou si un enfant de item occupe cette position, l'événement sera transmis à l'autre élément.

Voir aussi mouseRelease(), mouseClick(), mouseDoubleClickSequence(), mouseMove(), mouseDrag() et mouseWheel().

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

Simule le relâchement d'une souris button avec l'option modifiers sur une item. La position du relâchement est définie par x et y. Si x ou y ne sont pas définis, la position sera le centre de item. Si delay est spécifié, le test attendra le nombre de millisecondes spécifié avant de relâcher le bouton.

La position donnée par x et y est transformée du système de coordonnées de item en coordonnées de fenêtre, puis livrée. Si item est masqué par un autre élément ou si un enfant de item occupe cette position, l'événement sera transmis à l'autre élément.

Voir aussi mousePress(), mouseClick(), mouseDoubleClickSequence(), mouseMove(), mouseDrag() et mouseWheel().

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

Simule la rotation de la roue de la souris sur un site item avec button enfoncé et modifiers en option. La position de la roue est définie par x et y. Si delay est spécifié, le test attendra le nombre de millisecondes spécifié avant de relâcher le bouton.

La position donnée par x et y est transformée à partir du système de coordonnées de item en coordonnées de fenêtre, puis livrée. Si item est masqué par un autre élément ou si un enfant de item occupe cette position, l'événement sera transmis à l'autre élément.

Les adresses xDelta et yDelta contiennent la distance de rotation de la roue en huitièmes de degré. Voir QWheelEvent::angleDelta() pour plus de détails.

Voir également mousePress(), mouseClick(), mouseDoubleClickSequence(), mouseMove(), mouseRelease(), mouseDrag() et QWheelEvent::angleDelta().

skip(message = "")

Sauter le cas de test actuel et imprimer l'option message. S'il s'agit d'un test piloté par les données, seule la ligne en cours est ignorée. Similaire à QSKIP(message) en C++.

sleep(ms)

Dort pendant ms millisecondes sans traiter les événements Qt XML.

Voir aussi wait() et waitForRendering().

TouchEventSequence touchEvent(object item)

Commence une séquence d'événements tactiles à travers un écran tactile simulé (QPointingDevice). Les événements sont transmis à la fenêtre contenant item.

L'objet renvoyé est utilisé pour énumérer les événements à délivrer par l'intermédiaire d'un seul QTouchEvent. Sauf indication contraire, les touches sont transmises à la fenêtre contenant le site TestCase.

Rectangle {
    width: 640; height: 480

    MultiPointTouchArea {
        id: area
        anchors.fill: parent

        property bool touched: false

        onPressed: touched = true
    }

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

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

Voir également TouchEventSequence::press(), TouchEventSequence::move(), TouchEventSequence::release(), TouchEventSequence::stationary(), TouchEventSequence::commit() et QInputDevice::DeviceType.

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

Échec du cas de test actuel si l'adresse property spécifiée sur obj n'est pas la même que expected, et affichage de l'adresse optionnelle message. Le test sera répété plusieurs fois jusqu'à ce que le délai timeout (en millisecondes) soit atteint.

Cette fonction est destinée à tester des applications dans lesquelles une propriété change de valeur en fonction d'événements asynchrones. Utilisez compare() pour tester les changements de propriété synchrones.

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

SignalSpy::wait() fournit une méthode alternative pour attendre l'émission d'un signal.

Voir également compare() et SignalSpy::wait().

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

Échec du cas de test actuel si function n'est pas évalué à true avant que le délai spécifié timeout (en millisecondes) ne se soit écoulé. La fonction est évaluée plusieurs fois jusqu'à ce que le délai soit atteint. Un message optionnel message est affiché en cas d'échec.

Cette fonction est destinée à tester des applications dans lesquelles une condition change en fonction d'événements asynchrones. Utilisez verify() pour tester les changements de conditions synchrones et tryCompare() pour tester les changements de propriétés asynchrones.

Par exemple, dans le code ci-dessous, il n'est pas possible d'utiliser tryCompare(), car la propriété currentItem peut être null pendant une courte période :

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

À la place, nous pouvons utiliser tryVerify() pour vérifier d'abord que currentItem n'est pas null, et utiliser ensuite une comparaison régulière :

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

Voir aussi verify(), compare(), tryCompare() et SignalSpy::wait().

verify(condition, message = "")

Échec du cas de test actuel si condition est faux, et affichage de l'option message. Similaire à QVERIFY(condition) ou QVERIFY2(condition, message) en C++.

wait(ms)

Attend ms millisecondes pendant le traitement des événements Qt.

Remarque : cette méthode utilise un minuteur précis pour effectuer l'attente proprement dite. L'événement que vous attendez peut ne pas l'être. En particulier, toutes les animations ainsi que le type QML Timer peuvent utiliser des minuteries précises ou grossières, en fonction de divers facteurs. Pour un timer grossier, il faut s'attendre à une dérive d'environ 5% par rapport au timer précis utilisé par TestCase::wait(). Qt ne peut cependant pas donner de garanties solides sur la dérive, car le système d'exploitation n'offre généralement pas de garanties solides sur les temporisateurs.

Voir aussi sleep(), waitForRendering(), et Qt::TimerType.

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

Si windowOrItem est un élément, cette fonction attend timeout millisecondes ou jusqu'à ce que isPolishScheduled(windowOrItem) renvoie false. Renvoie true si isPolishScheduled(windowOrItem) renvoie false dans les timeout millisecondes, sinon renvoie false.

Si windowOrItem est une fenêtre, cette fonction attend timeout pendant quelques millisecondes ou jusqu'à ce que isPolishScheduled() renvoie false pour tous les éléments gérés par la fenêtre. Renvoie true si isPolishScheduled() renvoie false pour tous les éléments dans un délai de timeout millisecondes, sinon renvoie false.

Cette méthode a été introduite dans Qt 6.5.

Voir aussi isPolishScheduled(), QQuickItem::polish() et QQuickItem::updatePolish().

waitForRendering(item, timeout = 5000)

Attend timeout millisecondes ou jusqu'à ce que item soit rendu par le moteur de rendu. Retourne vrai si item est rendu dans timeout millisecondes, sinon retourne faux. La valeur par défaut de timeout est 5000.

Voir aussi sleep() et wait().

warn(message)

Imprime message comme message d'avertissement. Similaire à qWarning(message) en C++.

Voir aussi ignoreWarning().

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