Capítulo 1: Escribir una prueba unitaria

Este primer capítulo muestra cómo escribir una prueba unitaria sencilla y cómo ejecutar el caso de prueba como un ejecutable independiente.

Cómo escribir una prueba

Supongamos que desea probar el comportamiento de nuestra clase QString. Primero, necesitas una clase que contenga tus funciones de prueba. Esta clase tiene que heredar de QObject:

#include <QTest>

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

Luego necesitas implementar la función de prueba. La implementación podría ser así:

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

La macro QVERIFY() evalúa la expresión pasada como argumento. Si la expresión es verdadera, continúa la ejecución de la función de prueba. En caso contrario, se añade al registro de la prueba un mensaje que describe el fallo y la función de prueba deja de ejecutarse.

Pero si desea una salida más verbosa en el registro de la prueba, debe utilizar la macro QCOMPARE() en su lugar:

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

Si las cadenas no son iguales, el contenido de ambas cadenas se añade al registro de la prueba, haciendo inmediatamente visible por qué falló la comparación.

Preparación del ejecutable independiente

Por último, para convertir nuestro caso de prueba en un ejecutable independiente, se necesitan las dos líneas siguientes:

QTEST_MAIN(TestQString)
#include "testqstring.moc"

La macro QTEST_MAIN() se expande a un simple método main() que ejecuta todas las funciones de prueba. Ten en cuenta que si tanto la declaración como la implementación de nuestra clase de prueba están en un archivo .cpp, también necesitamos incluir el archivo moc generado para que funcione la introspección de Qt.

Construir el ejecutable

Puedes construir el ejecutable del caso de prueba utilizando CMake o qmake.

Construir con CMake

Configura los parámetros de compilación en tu archivo 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})

A continuación, desde la línea de comandos, ejecute cmake o utilice el script de conveniencia qt-cmake ubicado en Qt-prefix/<version>/<platform>/bin/qt-cmake:

<Qt-prefix>/<version>/<platform>/bin/qt-cmake <source-dir> <build-dir> -G Ninja

A continuación, ejecute su herramienta generadora preferida para construir el ejecutable. Aquí, estamos usando Ninja:

ninja

Compilación con qmake

Configura los parámetros de compilación en tu archivo .pro:

QT += widgets testlib

SOURCES = testqstring.cpp

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

A continuación, ejecute qmake y, por último, ejecute make para crear el ejecutable:

qmake
make

Ejecutar el ejecutable

Si ejecutas el ejecutable resultante, obtendrás el siguiente resultado:

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

¡Enhorabuena! Acaba de escribir y ejecutar su primera prueba unitaria utilizando el framework Qt Test.