Qt Quick Test

Introduction

Qt Quick Test est un cadre de test unitaire pour les applications QML. Les cas de test sont écrits sous forme de fonctions JavaScript à l'intérieur d'un type TestCase:

import QtQuick 2.3
import QtTest 1.0

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. Voir la documentation des types TestCase et SignalSpy pour plus d'informations sur l'écriture des cas de test.

Utilisation du module

API QML

Les types QML de Qt Quick Test sont disponibles par le biais de l'importation QtTest. Pour utiliser les types, ajoutez l'instruction d'importation suivante à votre fichier .qml :

import QtTest

API C++

L'utilisation du site C++ API nécessite l'établissement d'un lien avec la bibliothèque de modules, soit directement, soit par l'intermédiaire d'autres dépendances. Plusieurs outils de construction disposent d'un support dédié à cet effet, notamment CMake et qmake.

Construction avec CMake

Utilisez la commande find_package() pour localiser les composants des modules nécessaires dans le paquetage Qt6 :

find_package(Qt6 REQUIRED COMPONENTS QuickTest)
target_link_libraries(mytarget PRIVATE Qt6::QuickTest)

Voir aussi l'aperçu de la construction avec CMake.

Construire avec qmake

Il y a deux façons d'établir un lien avec la bibliothèque C++ correspondante. Si votre projet de test utilise un QML TestCase, vous devriez déjà avoir la ligne suivante dans votre fichier de projet :

CONFIG += qmltestcase

Le test sera alors lié à la bibliothèque C++ QtQuickTest.

Si vous avez un projet de test C++ uniquement, vous pouvez ajouter la ligne suivante à votre fichier de projet :

QT += qmltest

Exécution des tests

Les cas de test sont lancés par un harnais C++ composé du code suivant :

#include <QtQuickTest>
QUICK_TEST_MAIN(example)

Où "exemple" est l'identifiant à utiliser pour identifier de manière unique cet ensemble de tests.

cmake_minimum_required(VERSION 3.2)

project(tst_example LANGUAGES CXX)

enable_testing()

find_package(Qt6 REQUIRED COMPONENTS QuickTest Qml)

#[[The test harness scans the specified source directory recursively
for "tst_*.qml" files. By default, it looks in the current directory,
which is usually where the executable is. This command makes it look
in the project's source directory instead.]]
add_definitions(-DQUICK_TEST_SOURCE_DIR="${CMAKE_CURRENT_SOURCE_DIR}")

qt_standard_project_setup(REQUIRES 6.6)

add_executable(tst_example tst_example.cpp)

add_test(NAME tst_example COMMAND tst_example)

target_link_libraries(tst_example
    PRIVATE
    Qt6::QuickTest
    Qt6::Qml
)

TEMPLATE = app
TARGET = tst_example
CONFIG += warn_on qmltestcase
SOURCES += tst_example.cpp

IMPORTPATH += $$PWD/../imports/my_module1 $$PWD/../imports/my_module2

Le test harness recherche récursivement les fichiers "tst_*.qml" dans le répertoire source spécifié. Si QUICK_TEST_SOURCE_DIR n'est pas défini, le répertoire courant sera analysé lors de l'exécution du harnais. D'autres fichiers *.qml peuvent apparaître pour les composants QML auxiliaires utilisés par le test.

L'option de ligne de commande -input peut être définie au moment de l'exécution pour exécuter les cas de test à partir d'un répertoire différent. Cela peut être nécessaire pour exécuter des tests sur un dispositif cible où le nom du répertoire compilé fait référence à un hôte. C'est le cas par exemple :

tst_example -input /mnt/SDCard/qmltests

Il est également possible d'exécuter un seul fichier à l'aide de l'option -input. Par exemple, il est également possible d'exécuter un seul fichier à l'aide de l'option :

tst_example -input data/test.qml

tst_example -input <full_path>/test.qml

Si votre scénario de test nécessite des importations QML, vous pouvez les ajouter en tant qu'options -import à la ligne de commande du programme de test.

L'option de ligne de commande -functions renvoie une liste des fonctions de test en cours. Il est possible d'exécuter une seule fonction de test en utilisant le nom de la fonction de test comme argument. Par exemple, l'option de ligne de commande

tst_example Test_Name::function1

L'option de ligne de commande -help renvoie toutes les options disponibles.

tst_example -help

Exécution du code C++ avant les tests QML

La macro QUICK_TEST_MAIN_WITH_SETUP peut être utilisée pour exécuter du code C++ avant l'exécution d'un test QML. Cela peut s'avérer utile pour définir les propriétés du contexte sur le moteur QML, entre autres choses.

La macro est identique à QUICK_TEST_MAIN, sauf qu'elle prend un argument de type supplémentaire. Le cadre de test appellera les slots et les fonctions invocables avec les noms suivants :

L'exemple suivant montre comment la macro peut être utilisée pour définir les propriétés du contexte sur le moteur QML :

// src_qmltest_qquicktest.cpp
#include <QtQuickTest>
#include <QQmlEngine>
#include <QQmlContext>
#include <QGuiApplication>

class Setup : public QObject
{
    Q_OBJECT

public:
    Setup() {}

public slots:
    void applicationAvailable()
    {
        // Initialization that only requires the QGuiApplication object to be available
    }

    void qmlEngineAvailable(QQmlEngine *engine)
    {
        // Initialization requiring the QQmlEngine to be constructed
        engine->rootContext()->setContextProperty("myContextProperty", QVariant(true));
    }

    void cleanupTestCase()
    {
        // Implement custom resource cleanup
    }
};

QUICK_TEST_MAIN_WITH_SETUP(mytest, Setup)

#include "src_qmltest_qquicktest.moc"

L'inclusion .moc est basée sur le nom du fichier .cpp. Par exemple, dans l'exemple ci-dessus, le fichier .cpp est nommé src_qmltest_qquicktest.cpp. Si le fichier s'appelait MyTest.cpp, l'inclusion serait :

#include "MyTest.moc"

Référence

• QML Types
• C++ API

Licences

Qt Quick Qt Test est disponible sous licence commerciale auprès de The Qt Company. En outre, il est disponible sous des licences de logiciel libre. Depuis Qt 5.4, ces licences de logiciel libre sont la GNU Lesser General Public License, version 3, ou la GNU General Public License, version 2. Voir Qt Licensing pour plus de détails.