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

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

L'approche pour stocker une série d'événements et les rejouer est assez similaire à l'approche expliquée dans le chapitre 2. Tout ce que vous avez à faire est d'ajouter une fonction de données à votre classe de test :

class TestGui: public QObject
{
    Q_OBJECT

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

Écrire 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 la liste d'événements sur un QWidget. Notez que le type du premier élément est QTestEventList.

Un QTestEventList peut être rempli d'événements GUI 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 est constituée d'un simple clic sur la touche "a". Nous ajoutons l'événement à la liste à l'aide de la fonction QTestEventList::addKeyClick(). Nous utilisons ensuite la fonction QTest::newRow() pour donner un nom à l'ensemble de données, et nous introduisons la liste des événements et le résultat attendu dans le tableau.

La deuxième liste se compose de deux clics de touche : un "a" suivi d'un "retour arrière". Nous utilisons à nouveau QTestEventList::addKeyClick() pour ajouter les événements à la liste et QTest::newRow() pour placer 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 maintenant ê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(). QFETCH() prend deux arguments : le type de données de l'élément et le nom de l'élément. Nous créons ensuite un widget QLineEdit et appliquons la liste des événements à ce widget à l'aide de la fonction QTestEventList::simulate().

Enfin, nous utilisons la macro QCOMPARE() pour vérifier si le texte de l'édition de ligne est conforme aux attentes.

Préparation de l'exécutable autonome

Comme précédemment, pour faire de notre scénario 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 puisque la déclaration et l'implémentation de notre classe de test sont dans un fichier .cpp, nous devons également inclure le fichier moc généré pour faire fonctionner l'introspection de Qt Test.

Création de l'exécutable

Vous pouvez construire l'exécutable du scénario de test en utilisant CMake ou qmake.

Construire avec CMake

Configurez vos paramètres de construction 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, à partir de la ligne de commande, exécutez cmake ou utilisez le script de commodité qt-cmake situé dans Qt-prefix/<version>/<platform>/bin/qt-cmake:

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

Ensuite, lancez votre outil de génération préféré pour construire l'exécutable. Ici, nous utilisons Ninja :

ninja

Construire avec qmake

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

QT += widgets testlib

SOURCES = testgui.cpp

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

Ensuite, exécutez qmake, et enfin, exécutez make pour construire votre exécutable :

qmake
make

Exécution de l'exécutable

L'exécution de l'exécutable résultant devrait vous donner la sortie suivante :

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