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 que programme 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 contenant vos fonctions de test. Cette classe doit hériter de ` QObject` :

#include <QTest>

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

Ensuite, vous devez 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 qui lui est transmise en argument. Si l’expression renvoie `true`, 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 l’exécution de la fonction de test s’arrête.

Mais si vous souhaitez un résultat plus détaillé dans le journal de test, vous devriez plutôt utiliser la macro QCOMPARE() :

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

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

Préparation de l’exécutable autonome

Enfin, pour faire de notre cas 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 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 scénario 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(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, depuis la ligne de commande, exécutez soit ` cmake `, soit 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

Lancez ensuite l'outil de génération de votre choix 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/tutorial1
INSTALLS += target

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

qmake
make

Exécution du fichier exécutable

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

********* 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 à l’aide du framework Qt Test.