Chapitre 1 : Écrire un test unitaire

Ce premier chapitre montre comment écrire un test unitaire simple et comment exécuter le cas de test en tant qu'exécutable autonome.

Écrire un test

Supposons que vous souhaitiez tester le comportement de notre classe QString. Tout d'abord, vous avez besoin d'une classe qui contient vos fonctions de test. Cette classe doit hériter de QObject:

#include <QTest>

class TestQString: public QObject
{
    Q_OBJECT
private slots:
    void toUpper();
};

Vous devez ensuite implémenter la fonction de test elle-même. L'implémentation pourrait ressembler à ceci :

void TestQString::toUpper()
{
    QString str = "Hello";
    QVERIFY(str.toUpper() == "HELLO");
}

La macro QVERIFY() évalue l'expression passée en argument. Si l'expression est évaluée comme vraie, l'exécution de la fonction de test se poursuit. Dans le cas contraire, un message décrivant l'échec est ajouté au journal de test et la fonction de test cesse de s'exécuter.

Toutefois, si vous souhaitez obtenir un message plus détaillé dans le journal des tests, vous devez plutôt utiliser la macro QCOMPARE() :

void TestQString::toUpper()
{
    QString str = "Hello";
    QCOMPARE(str.toUpper(), QString("HELLO"));
}

Si les chaînes ne sont pas égales, le contenu des deux chaînes est ajouté au journal de test, ce qui permet de voir immédiatement pourquoi la comparaison a échoué.

Préparation de l'exécutable autonome

Enfin, 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"

La macro QTEST_MAIN() se développe en une simple méthode main() qui exécute toutes les fonctions de test. Notez que si 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 Test fonctionne.

Création de l'exécutable

Vous pouvez construire l'exécutable du cas 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(tutorial1 LANGUAGES CXX)

find_package(Qt6 REQUIRED COMPONENTS Core Gui Test Widgets)

qt_standard_project_setup()

qt_add_executable(tutorial1
    testqstring.cpp
)

set_target_properties(tutorial1 PROPERTIES
    WIN32_EXECUTABLE TRUE
    MACOSX_BUNDLE TRUE
)

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

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

qt_generate_deploy_app_script(
    TARGET tutorial1
    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/tutorial1
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()
PASS   : TestQString::cleanupTestCase()
Totals: 3 passed, 0 failed, 0 skipped
********* Finished testing of TestQString *********

Félicitations ! Vous venez d'écrire et d'exécuter votre premier test unitaire en utilisant le framework Qt Test.