Chapitre 2 : Tests pilotés par les données

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

Jusqu’à présent, nous avons codé en dur les données que nous souhaitions tester dans notre fonction de test. Si nous ajoutons davantage de 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. Il suffit 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 suffixe « _data » ajouté à son nom. Notre fonction de données se présente ainsi :

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 table 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 à la table à l’aide de la fonction ` QTest::newRow()`. Nous pouvons également utiliser ` QTest::addRow()` si nous avons besoin de formater certaines données dans le nom de la ligne, par exemple lors de la génération itérative de nombreuses lignes de données. Chaque ligne de données deviendra une ligne distincte dans la table 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 (de typeprintf) suivie des paramètres à représenter à la place des marqueurs de formatage dans la chaîne de format. Ensuite, nous transmettons l’ensemble de données dans la nouvelle ligne de la table. 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 bidimensionnel. Dans notre cas, il comporte deux colonnes intitulées « string » et « result », ainsi que trois lignes. De plus, un nom et un index sont associés à chaque ligne :

Lorsque les données sont transmises en continu dans la ligne, chaque donnée est vérifiée pour s'assurer qu'elle correspond au type de la colonne à laquelle elle est associée. Si une vérification échoue, le test est interrompu.

Les noms des lignes et des colonnes, dans la table de données d'une fonction de test donnée, doivent être uniques : si deux lignes partagent un nom, ou si deux colonnes partagent un nom, un avertissement sera généré (depuis Qt 6.5). Consultez qWarning() pour savoir comment faire en sorte que les avertissements soient traités comme des erreurs, et la section « Test for Warnings » pour savoir comment éliminer les autres avertissements de vos tests.

Réécriture de la fonction de test

Notre fonction de test peut désormais ê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 de la table de test que nous avons créée dans la fonction associée TestQString::toUpper_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 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 cas 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 de test. De plus, 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(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, depuis la ligne de commande, exécutez soit ` cmake `, soit le script pratique ` 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 = testqstring.cpp

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

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

qmake
make

Exécution de l'exécutable

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

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