Chapitre 2 : Test piloté par les données

Ce chapitre montre comment exécuter un test plusieurs fois avec des données différentes.

Jusqu'à présent, nous avons codé en dur les données que nous voulions tester dans notre fonction de test. Si nous ajoutons d'autres données de test, la fonction pourrait ressembler à ceci :

QCOMPARE(QString("hello").toUpper(), QString("HELLO"));
QCOMPARE(QString("Hello").toUpper(), QString("HELLO"));
QCOMPARE(QString("HellO").toUpper(), QString("HELLO"));
QCOMPARE(QString("HELLO").toUpper(), QString("HELLO"));

Pour éviter que la fonction ne soit encombrée de code répétitif, Qt Test prend en charge l'ajout de données de test à une fonction de test. Tout ce dont nous avons besoin, c'est d'ajouter un autre slot privé à notre classe de test :

class TestQString: public QObject
{
    Q_OBJECT

private slots:
    void toUpper_data();
    void toUpper();
};

Écriture de la fonction de données

La fonction de données associée à une fonction de test porte le nom _data. Notre fonction de données ressemble à ceci :

void TestQString::toUpper_data()
{
    QTest::addColumn<QString>("string");
    QTest::addColumn<QString>("result");

    QTest::newRow("all-lower") << "hello" << "HELLO";
    QTest::newRow("mixed")     << "Hello" << "HELLO";
    QTest::newRow("all-upper") << "HELLO" << "HELLO";
}

Tout d'abord, nous définissons les deux éléments de notre tableau de test à l'aide de la fonction QTest::addColumn() : une chaîne de test et le résultat attendu de l'application de la fonction QString::toUpper() à cette chaîne.

Ensuite, nous ajoutons des données au tableau à l'aide de la fonction QTest::newRow(). Nous pouvons également utiliser QTest::addRow() si nous devons formater certaines données dans le nom de la ligne, par exemple lorsque nous générons de nombreuses lignes de données de manière itérative. Chaque ligne de données deviendra une ligne distincte dans le tableau de test.

QTest::newRow() prend un argument : un nom qui sera associé à l'ensemble de données et utilisé dans le journal de test pour identifier la ligne de données. QTest::addRow() prend une chaîne de format (printf-style) suivie des paramètres à représenter à la place des jetons de formatage dans la chaîne de format. Ensuite, nous introduisons l'ensemble des données dans la nouvelle ligne du tableau. D'abord une chaîne arbitraire, puis le résultat attendu de l'application de la fonction QString::toUpper() à cette chaîne.

Vous pouvez considérer les données de test comme un tableau à deux dimensions. Dans notre cas, il comporte deux colonnes appelées string et result et trois lignes. En outre, un nom et un index sont associés à chaque ligne :

Lorsque les données sont introduites dans la ligne, chaque donnée est vérifiée pour correspondre au type de la colonne dont elle fournit la valeur. Si l'une des affirmations échoue, le test est interrompu.

Les noms des lignes et des colonnes, dans le tableau de données d'une fonction de test donnée, doivent être uniques : si deux lignes partagent un même nom, ou si deux colonnes partagent un même nom, un avertissement sera produit (depuis Qt Test 6.5). Voir qWarning() pour savoir comment faire en sorte que les avertissements soient traités comme des erreurs et Test for Warnings pour savoir comment faire en sorte que vos tests soient exempts d'autres avertissements.

Réécriture de la fonction de test

Notre fonction de test peut maintenant être réécrite :

void TestQString::toUpper()
{
    QFETCH(QString, string);
    QFETCH(QString, result);

    QCOMPARE(string.toUpper(), result);
}

La fonction TestQString::toUpper() sera exécutée trois fois, une fois pour chaque entrée du tableau de test que nous avons créé dans la fonction TestQString::toUpper_data() associée.

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. Ensuite, nous effectuons le test à l'aide de la macro QCOMPARE().

Cette approche permet d'ajouter très facilement de nouvelles données au test sans modifier le test lui-même.

Préparation de l'exécutable autonome

Une fois encore, pour faire de notre scénario de test un exécutable autonome, les deux lignes suivantes sont nécessaires :

QTEST_MAIN(TestQString)
#include "testqstring.moc"

Comme précédemment, la macro QTEST_MAIN() se développe en une simple méthode main() qui exécute toutes les fonctions du 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 que l'introspection de Qt fonctionne.

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(tutorial2 LANGUAGES CXX)

find_package(Qt6 REQUIRED COMPONENTS Core Gui Test Widgets)

qt_standard_project_setup()

qt_add_executable(tutorial2
    testqstring.cpp
)

set_target_properties(tutorial2 PROPERTIES
    WIN32_EXECUTABLE TRUE
    MACOSX_BUNDLE TRUE
)

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

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

qt_generate_deploy_app_script(
    TARGET tutorial2
    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 = testqstring.cpp

# install
target.path = $$[QT_INSTALL_EXAMPLES]/qtestlib/tutorial2
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 TestQString *********
Config: Using QtTest library %VERSION%, Qt %VERSION%
PASS   : TestQString::initTestCase()
PASS   : TestQString::toUpper(all-lower)
PASS   : TestQString::toUpper(mixed)
PASS   : TestQString::toUpper(all-upper)
PASS   : TestQString::cleanupTestCase()
Totals: 5 passed, 0 failed, 0 skipped, 0 blacklisted, 0ms
********* Finished testing of TestQString *********