Chapitre 4 : Rejouer des événements de l'interface graphique

Dans ce chapitre, nous allons vous montrer comment simuler un événement d'interface graphique, comment stocker une série d'événements d'interface graphique et comment les rejouer sur un widget.

La méthode permettant de stocker une série d'événements et de les rejouer est assez similaire à celle expliquée au chapitre 2. Il vous suffit d'ajouter une fonction de données à votre classe de test :

class TestGui: public QObject
{
    Q_OBJECT

private slots:
    void testGui_data();
    void testGui();
};

Écriture de la fonction de données

Comme précédemment, la fonction de données associée à une fonction de test porte le même nom, suivi de « _data ».

void TestGui::testGui_data()
{
    QTest::addColumn<QTestEventList>("events");
    QTest::addColumn<QString>("expected");

    QTestEventList list1;
    list1.addKeyClick('a');
    QTest::newRow("char") << list1 << "a";

    QTestEventList list2;
    list2.addKeyClick('a');
    list2.addKeyClick(Qt::Key_Backspace);
    QTest::newRow("there+back-again") << list2 << "";
}

Tout d’abord, nous définissons les éléments du tableau à l’aide de la fonction ` QTest::addColumn()` : une liste d’événements GUI et le résultat attendu de l’application de cette liste d’événements sur une ` QWidget`. Notez que le type du premier élément est ` QTestEventList`.

Un ` QTestEventList ` peut être rempli d’événements d’interface graphique qui peuvent être stockés en tant que données de test pour une utilisation ultérieure, ou être rejoués sur n’importe quel ` QWidget`.

Dans notre fonction de données actuelle, nous créons deux éléments ` QTestEventList `. La première liste se compose d’un simple clic sur la touche « a ». Nous ajoutons l’événement à la liste à l’aide de la fonction ` QTestEventList::addKeyClick()`. Ensuite, nous utilisons la fonction ` QTest::newRow()` pour attribuer un nom à l’ensemble de données, puis nous transmettons la liste des événements et le résultat attendu dans le tableau.

La deuxième liste comprend deux pressions de touche : une touche « a » suivie d’une touche « retour arrière ». Là encore, nous utilisons la fonction QTestEventList::addKeyClick() pour ajouter les événements à la liste, puis la fonction QTest::newRow() pour insérer la liste des événements et le résultat attendu dans le tableau avec un nom associé.

Réécriture de la fonction de test

Notre test peut désormais être réécrit :

void TestGui::testGui()
{
    QFETCH(QTestEventList, events);
    QFETCH(QString, expected);

    QLineEdit lineEdit;

    events.simulate(&lineEdit);

    QCOMPARE(lineEdit.text(), expected);
}

La fonction TestGui::testGui() sera exécutée deux fois, une fois pour chaque entrée des données de test que nous avons créées dans la fonction associée TestGui::testGui_data().

Tout d’abord, nous récupérons les deux éléments de l’ensemble de données à l’aide de la macro ` QFETCH()`. La fonction ` QFETCH()` prend deux arguments : le type de données de l’élément et le nom de l’élément. Ensuite, nous créons un ` QLineEdit` et appliquons la liste d’événements à ce widget à l’aide de la fonction ` QTestEventList::simulate()`.

Enfin, nous utilisons la macro QCOMPARE() pour vérifier si le texte du champ de saisie correspond bien à ce qui est attendu.

Préparation de l’exécutable autonome

Comme précédemment, pour faire de notre cas de test un exécutable autonome, les deux lignes suivantes sont nécessaires :

QTEST_MAIN(TestGui)
#include "testgui.moc"

La macro QTEST_MAIN() se développe en une simple méthode main() qui exécute toutes les fonctions de test, et comme la déclaration et l’implémentation de notre classe de test se trouvent toutes deux dans un fichier .cpp, nous devons également inclure le fichier moc généré pour que l’introspection de Qt fonctionne.

Compilation de l'exécutable

Vous pouvez compiler l'exécutable du cas de test à l'aide de CMake ou de qmake.

Compilation avec CMake

Configurez vos paramètres de compilation dans votre fichier CMakeLists.txt :

# Copyright (C) 2022 The Qt Company Ltd.
# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause

cmake_minimum_required(VERSION 3.16)
project(tutorial4 LANGUAGES CXX)

find_package(Qt6 REQUIRED COMPONENTS Core Gui Test Widgets)

qt_standard_project_setup()

qt_add_executable(tutorial4
    testgui.cpp
)

set_target_properties(tutorial4 PROPERTIES
    WIN32_EXECUTABLE TRUE
    MACOSX_BUNDLE TRUE
)

target_link_libraries(tutorial4 PRIVATE
    Qt6::Core
    Qt6::Gui
    Qt6::Test
    Qt6::Widgets
)

install(TARGETS tutorial4
    BUNDLE  DESTINATION .
    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
)

qt_generate_deploy_app_script(
    TARGET tutorial4
    OUTPUT_SCRIPT deploy_script
    NO_UNSUPPORTED_PLATFORM_ERROR
)
install(SCRIPT ${deploy_script})

Ensuite, depuis la ligne de commande, exécutez soit « cmake », soit le script de raccourci « qt-cmake » situé dans « Qt-prefix/<version>/<platform>/bin/qt-cmake » :

<Qt-prefix>/<version>/<platform>/bin/qt-cmake <source-dir> <build-dir> -G Ninja

Lancez ensuite votre outil de génération préféré pour compiler l'exécutable. Ici, nous utilisons Ninja :

ninja

Compilation avec qmake

Configurez vos paramètres de compilation dans votre fichier ` .pro ` :

QT += widgets testlib

SOURCES = testgui.cpp

# install
target.path = $$[QT_INSTALL_EXAMPLES]/qtestlib/tutorial4
INSTALLS += target

Ensuite, exécutez ` qmake`, puis enfin ` make ` pour compiler votre exécutable :

qmake
make

Exécution du fichier exécutable

L'exécution du fichier exécutable obtenu devrait vous donner le résultat suivant :

********* Start testing of TestGui *********
Config: Using QtTest library %VERSION%, Qt %VERSION%
PASS   : TestGui::initTestCase()
PASS   : TestGui::testGui(char)
PASS   : TestGui::testGui(there+back-again)
PASS   : TestGui::cleanupTestCase()
Totals: 4 passed, 0 failed, 0 skipped, 0 blacklisted, 18ms
********* Finished testing of TestGui *********