TestCase QML Type

Représente un cas de test unitaire. En savoir plus…

• Liste de tous les membres, y compris les membres hérités
• Membres obsolètes

Propriétés

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

Méthodes

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

Description détaillée

Introduction aux cas de test QML

Les cas de test sont écrits sous forme de fonctions JavaScript au sein d'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 permet de 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 fonctionnement des propriétés JavaScript, l'ordre dans lequel les fonctions de test sont trouvées est imprévisible. Pour améliorer la prévisibilité, le framework de test trie les fonctions par ordre croissant de nom. Cela peut s'avérer utile lorsqu'il y a deux tests qui doivent être exécutés dans un ordre précis.

Il est possible de fournir plusieurs types de TestCase. Le programme de test s’arrêtera une fois qu’ils auront tous été exécutés.

Tests pilotés par les données

Des données de table peuvent être fournies à un test à l’aide d’un nom de fonction se terminant par « _data ». Il est également possible d’utiliser la fonction ` init_data() ` pour fournir des données de test par défaut à toutes les fonctions de test ne disposant pas d’une 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 framework de test parcourra toutes les lignes du tableau et transmettra chaque ligne à la fonction de test. Comme illustré, les colonnes peuvent être extraites pour être utilisées dans le test. La colonne « tag » est particulière : elle est affichée par le framework de test lorsqu’une ligne échoue, afin d’aider le lecteur à identifier quel cas a échoué parmi un ensemble de tests qui, par ailleurs, ont tous réussi.

Tests de performance

Les fonctions dont le nom commence par « benchmark_ » seront exécutées plusieurs fois à l’aide du framework de benchmark Qt, et une valeur de temps moyenne sera rapportée pour ces exécutions. Cela équivaut à 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 `, faites précéder le nom de la fonction de test du préfixe « benchmark_once_ ».

Simulation d’événements clavier et souris

Les méthodes ` keyPress()`, ` keyRelease()` et ` keyClick()` peuvent être utilisées pour simuler des événements clavier au sein des tests unitaires. Les événements sont transmis à l’élément QML actuellement sélectionné. Vous pouvez passer soit une valeur de l’énumération `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 des événements de souris de la même manière.

Si votre test crée d’autres fenêtres, il est possible que celles-ci deviennent actives, détournant ainsi le focus de la fenêtre du TestCase. Pour vous assurer que la fenêtre du TestCase reste active, utilisez le code suivant :

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

Remarque : les événements clavier et souris ne peuvent être déclenchés qu’une fois la fenêtre principale affichée. Toute tentative de déclenchement d’événements avant cela é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 modèle courant dans les tests QML consiste à créer dynamiquement un élément, puis à 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 avec ce modèle est que tout échec de la fonction de test entraînera l’omission de l’appel à ` item.destroy() `, laissant l’élément présent dans la scène jusqu’à la fin du cas de test. Cela peut entraîner des interférences avec les tests ultérieurs ; par exemple, en bloquant des événements d’entrée ou en générant des sorties de débogage sans rapport avec le sujet, ce qui rend difficile le suivi de l’exécution du code.

En appelant plutôt ` createTemporaryQmlObject()`, on garantit que l’objet sera détruit à 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éparation des tests de la logique d’application

Dans la plupart des cas, il est préférable de séparer vos tests de la logique d’application en les répartissant dans des projets distincts 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

À présent, pour tester MyModule/MyButton.qml, créez une bibliothèque pour MyModule dans MyModule/CMakeLists.txt et liez-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 également SignalSpy et Qt Quick Test.

Documentation sur les propriétés

completed : bool

Cette propriété sera définie sur « true » une fois l'exécution du cas de test 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 utilisé pour la génération des rapports de résultats. La valeur par défaut est une chaîne vide.

TestCase {
    name: "ButtonTests"
    ...
}

running : bool

Cette propriété sera définie sur « true » pendant l'exécution du cas de test. Sa valeur initiale est « false », et elle redeviendra « false » une fois le cas de test terminé.

Voir également completed et when.

when : bool

Cette propriété doit être définie sur « true » lorsque l'application souhaite que les cas de test s'exécutent. La valeur par défaut est « true ». Dans l'exemple suivant, un test est exécuté lorsque l'utilisateur clique avec 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 fermera une fois que tous les types d'TestCase s auront été déclenchés et exécutés.

Voir également « completed ».

windowShown : bool

Cette propriété sera définie sur « true » une fois que la fenêtre d'affichage QML aura été affichée. En règle générale, les cas de test s'exécutent dès le chargement de l'application de test et avant l'affichage de la fenêtre. Si le cas de test implique des éléments visuels et des comportements, il peut être nécessaire de retarder son exécution 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 des opérations de nettoyage après chaque fonction de test.

Voir également ` init()` et ` cleanupTestCase()`.

cleanupTestCase()

Cette fonction est appelée une fois que toutes les autres fonctions de test du type « TestCase » se sont 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 également ` initTestCase()` et ` cleanup()`.

compare(actual, expected, message = "")

Fait échouer le cas de test en cours si actual n'est pas identique à expected, et affiche le message facultatif message. Similaire à QCOMPARE(actual, expected) en C++.

Voir également tryCompare() et fuzzyCompare.

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

Cette fonction crée dynamiquement un objet QML à partir de l'component donné, avec les paramètres facultatifs parent et properties spécifiés. L'objet renvoyé sera détruit (s'il ne l'était pas déjà) une fois l'exécution de cleanup() terminée, ce qui signifie que les objets créés à l'aide de cette fonction sont garantis d'être détruits après chaque test, que ceux-ci échouent ou non.

Si une erreur s’est produite lors de la création de l’objet, la valeur null sera renvoyée.

Cette fonction appelle en interne la fonction component.createObject().

Voir également Managing Dynamically Created Test Objects.

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

Cette fonction crée dynamiquement un objet QML à partir de la chaîne « qml » fournie, avec les paramètres spécifiés dans « parent ». L'objet renvoyé sera détruit (s'il ne l'était pas déjà) une fois l'exécution de « cleanup() » terminée, ce qui signifie que les objets créés à l'aide de cette fonction sont garantis d'être détruits après chaque test, que ceux-ci échouent ou non.

Si une erreur s’est produite lors de la création de l’objet, null sera renvoyée.

Si filePath est spécifié, il sera utilisé pour le rapport d’erreurs concernant l’objet créé.

Cette fonction appelle en interne la fonction ` Qt.createQmlObject()`.

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, affiche l'message, interrompt le test et marque le test comme réussi. Similaire à QEXPECT_FAIL(tag, message, Abort) en C++.

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

Voir également expectFailContinue().

expectFailContinue(tag, message)

Dans un test basé sur des données, marque la ligne associée à tag comme devant échouer. Lorsque l'échec se produit, affiche l'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 sur une chaîne vide.

Voir également expectFail().

fail(message = "")

Fait échouer le cas de test actuel, avec l'option message. Similaire à QFAIL(message) en C++.

[since 6.3] failOnWarning(message)

Ajoute un échec de test au journal des tests 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 définissant un modèle de messages. Dans ce dernier cas, pour chaque avertissement rencontré, le premier modèle correspondant provoquera un échec, et les modèles restants seront ignorés.

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

Par exemple, l’extrait de code suivant fera échouer un test si un avertissement contenant le texte « Something bad happened » est généré :

failOnWarning("Something bad happened")

L'extrait de code suivant fera échouer un test si un avertissement correspondant au modèle donné est rencontré :

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

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

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

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

Voir également 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 tous parcourus de manière récursive, les enfants visuels étant traités en premier.

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

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

Fait échouer le cas de test en cours si la différence entre actual et expected est supérieure à delta, et affiche le message facultatif message. Similaire à qFuzzyCompare(actual, expected) en C++, mais avec une valeur delta obligatoire.

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

Voir également tryCompare() et compare().

QtObject grabImage(Item item)

Renvoie un objet image de type « snapshot » correspondant à l'item.

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

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

De plus, l’objet image renvoyé dispose des méthodes suivantes :

• red(x, y) Renvoie la valeur du canal rouge du pixel situé à la position x, y
• green(x, y) Renvoie la valeur du canal vert du pixel situé aux coordonnées x, y
• blue(x, y) Renvoie la valeur du canal bleu du pixel situé aux coordonnées x, y
• alpha(x, y) Renvoie la valeur du canal alpha du pixel situé à la position x, y
• pixel(x, y) Renvoie la valeur de couleur du pixel situé à 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 à l'emplacement indiqué. Si l'image ne peut pas être enregistrée, une exception sera levée. (depuis la version 5.10)

  Cela peut être utile pour effectuer une analyse a posteriori des tests ayant échoué, 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é. Lorsque ce message apparaît, l'avertissement n'est pas affiché et le test est réussi. Si le message n'apparaît 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 définissant un modèle de messages à ignorer.

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

ignoreWarning("Something sort of bad happened")

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

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

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 également ` cleanup()` et ` initTestCase()`.

initTestCase()

Cette fonction est appelée avant toutes les autres fonctions de test du type « TestCase ». L'implémentation par défaut ne fait rien. L'application peut fournir sa propre implémentation pour effectuer l'initialisation des cas de test.

Voir également ` cleanupTestCase()` et ` init()`.

bool isPolishScheduled(object itemOrWindow)

Si itemOrWindow est un Item, cette fonction renvoie true si updatePolish() n'a pas été appelée sur cet objet 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, tout ajustement de mise en page que l’élément doit effectuer à la suite de cette affectation peut ne pas prendre effet immédiatement, mais être reporté jusqu’à ce que l’élément soit « polished ». Dans ces cas, vous pouvez utiliser cette fonction pour vous assurer que les éléments ont bien été « polished » 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 constater qu’aucun polissage n’était prévu et donc réussir instantanément, en supposant que l’élément ait déjà été poli. Cette fonction explique clairement pourquoi un élément n’a pas été poli et permet aux tests d’échouer rapidement dans de telles circonstances.

Voir également waitForPolish(), QQuickItem::polish() et QQuickItem::updatePolish().

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

Simule un clic sur key avec, en option, l'modifiers sur l'élément actuellement sélectionné. Si delay est supérieur à 0, le test attendra delay millisecondes.

Pour plus d’informations sur les formats de durée acceptés ( key ), consultez Simulating Keyboard and Mouse Events.

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

Voir également keyPress() et keyRelease().

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

Simule l'key d'un bouton avec, en option, l'modifiers sur l'élément actuellement sélectionné. Si delay est supérieur à 0, le test attendra delay millisecondes.

Pour plus d’informations sur les formats d’ key s acceptés, consultez Simulating Keyboard and Mouse Events.

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

Remarque : à un moment donné, vous devrez relâcher la touche à l’aide de la fonction keyRelease().

Voir également keyRelease() et keyClick().

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

Simule le relâchement d'un « key » avec une valeur facultative « modifiers » sur l'élément actuellement sélectionné. Si « delay » est supérieur à 0, le test attendra « delay » millisecondes.

Pour plus d’informations sur les formats d’ key s acceptés, voir Simulating Keyboard and Mouse Events.

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

Voir également keyPress() et keyClick().

keySequence(keySequence)

Simule la saisie de keySequence. La séquence de touches peut être définie comme l'une des valeurs suivantes : standard keyboard shortcuts, ou bien elle 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 doit être envoyé à la fenêtre TestCase ou, en cas de fenêtres multiples, à la fenêtre actuellement active. 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 un clic de souris button avec, en option, modifiers sur une page item. La position du clic est définie par x et y. Si x et y ne sont pas définis, la position correspondra au centre de item. Si delay est spécifié, le test attendra le nombre de millisecondes indiqué avant d’enfoncer et de relâcher le bouton.

La position fournie par x et y est convertie du système de coordonnées de item en coordonnées de fenêtre, puis transmise. Si item est masqué par un autre élément, ou si un enfant de item occupe cette position, l’événement sera alors transmis à cet autre élément à la place.

Voir également 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 d'événements générés par un double-clic de souris button, avec un « modifiers » facultatif sur un item.

Cette méthode reproduit la séquence d’événements de souris générée lorsqu’un utilisateur effectue un double-clic : Appui-Relâchement-Appui-Double-clic-Relâchement.

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

La position fournie par x et y est convertie du système de coordonnées de item en coordonnées de fenêtre, puis transmise. Si item est masqué par un autre élément, ou si un enfant de item occupe cette position, l’événement sera alors transmis à l’autre élément à la place.

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

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

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

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

La position fournie par x et y est convertie du système de coordonnées de item en coordonnées de fenêtre, puis transmise. Si item est masqué par un autre élément, ou si un enfant de item occupe cette position, l’événement sera alors transmis à cet autre élément à la place.

Voir également 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 vers la position indiquée par x et y au sein de item, tout en maintenant la touche buttons enfoncée si elle est spécifiée. Depuis Qt 6.0, si x et y ne sont pas définis, la position correspondra au centre de item.

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

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

Voir également 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 un clic de souris button avec, en option, un modifiers sur une item. La position est définie par x et y. Si x ou y ne sont pas définis, la position correspondra au centre de item. Si delay est spécifié, le test attendra le nombre de millisecondes indiqué avant d'effectuer le clic.

La position fournie par x et y est convertie du système de coordonnées de item en coordonnées de fenêtre, puis transmise. Si item est masqué par un autre élément, ou si un enfant de item occupe cette position, l’événement sera alors transmis à cet autre élément à la place.

Voir également 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'un bouton de souris button avec, en option, l'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 correspondra au centre de item. Si delay est spécifié, le test attendra le nombre de millisecondes indiqué avant de relâcher le bouton.

La position fournie par x et y est convertie du système de coordonnées de item en coordonnées de fenêtre, puis transmise. Si item est masqué par un autre élément, ou si un enfant de item occupe cette position, l’événement sera alors transmis à cet autre élément à la place.

Voir également 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 molette de la souris sur un élément item, avec la touche button enfoncée et, en option, modifiers. La position de l'événement de molette est définie par x et y. Si delay est spécifié, le test attendra le nombre de millisecondes indiqué avant de relâcher le bouton.

La position fournie par x et y est convertie du système de coordonnées de item en coordonnées de fenêtre, puis transmise. Si item est masqué par un autre élément, ou si un enfant de item occupe cette position, l’événement sera alors transmis à cet autre élément à la place.

Les paramètres xDelta et yDelta contiennent la distance de rotation de la molette exprimée 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 = "")

Ignore le cas de test en cours et affiche le message facultatif message. S'il s'agit d'un test basé sur des données, seule la ligne en cours est ignorée. Similaire à la fonction QSKIP(message) en C++.

sleep(ms)

Mise en attente pendant ms millisecondes sans traiter les événements Qt.

Voir également wait() et waitForRendering().

TouchEventSequence touchEvent(object item)

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

L'objet renvoyé permet de répertorier les événements à transmettre via un seul QTouchEvent. Les touches sont transmises à la fenêtre contenant le TestCase, sauf indication contraire.

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

Fait échouer le cas de test en cours si l'property spécifiée sur obj ne correspond pas à celle de expected, et affiche le message facultatif message. Le test sera réessayé plusieurs fois jusqu'à ce que le délai timeout (en millisecondes) soit atteint.

Cette fonction est destinée au test d’applications dans lesquelles la valeur d’une propriété change 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() offre une méthode alternative pour attendre l’émission d’un signal.

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

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

Le cas de test en cours échoue si la fonction function ne renvoie pas la valeur true avant l'expiration du délai spécifié ( timeout, en millisecondes). La fonction est évaluée plusieurs fois jusqu'à ce que le délai d'expiration soit atteint. Un message d'erreur facultatif ( message ) s'affiche en cas d'échec.

Cette fonction est destinée au test d’applications dans lesquelles une condition évolue en fonction d’événements asynchrones. Utilisez ` verify()` pour tester les changements de condition synchrones, et ` tryCompare()` pour tester les changements de propriété 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 un court instant :

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

À la place, on peut utiliser tryVerify() pour vérifier d’abord que currentItem n’est pas null, puis effectuer une comparaison classique par la suite :

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

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

verify(condition, message = "")

Fait échouer le cas de test en cours si ` condition ` est faux, et affiche le message facultatif ` message`. Similaire à ` QVERIFY(condition) ` ou ` QVERIFY2(condition, message) ` en C++.

wait(ms)

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

Voir également sleep(), waitForRendering() et Qt::TimerType.

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

Si windowOrItem est un Item, cette fonction attend timeout millisecondes ou jusqu’à ce que isPolishScheduled(windowOrItem) renvoie false. Elle renvoie true si isPolishScheduled(windowOrItem) renvoie false dans un délai de timeout millisecondes, sinon elle renvoie false.

Si windowOrItem est une fenêtre, cette fonction attend timeout 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 également isPolishScheduled(), QQuickItem::polish() et QQuickItem::updatePolish().

waitForRendering(item, timeout = 5000)

Attend timeout millisecondes ou jusqu’à ce que l’ item soit affiché par le moteur de rendu. Renvoie « true » si item est affiché en timeout millisecondes, sinon renvoie « false ». La valeur par défaut de timeout est 5000.

Voir également sleep() et wait().

warn(message)

Affiche le message d'avertissement « message ». Similaire à « qWarning(message) » en C++.

Voir aussi ignoreWarning().