Capítulo 2: Pruebas basadas en datos

Este capítulo muestra cómo ejecutar una prueba varias veces con diferentes datos de prueba.

Hasta ahora, hemos codificado los datos que queríamos probar en nuestra función de prueba. Si añadimos más datos de prueba, la función podría tener este aspecto:

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

Para evitar que la función se llene de código repetitivo, Qt Test permite añadir datos de prueba a una función de prueba. Todo lo que necesitamos es añadir otra ranura privada a nuestra clase de prueba:

class TestQString: public QObject
{
    Q_OBJECT

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

Escribir la función de datos

La función de datos asociada a una función de prueba tiene _data añadido a su nombre. Nuestra función de datos tiene este aspecto:

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";
}

En primer lugar, definimos los dos elementos de nuestra tabla de prueba utilizando la función QTest::addColumn(): una cadena de prueba y el resultado esperado de aplicar la función QString::toUpper() a esa cadena.

A continuación, añadimos algunos datos a la tabla utilizando la función QTest::newRow(). También podemos utilizar QTest::addRow() si necesitamos dar formato a algunos datos en el nombre de la fila, por ejemplo al generar muchas filas de datos de forma iterativa. Cada fila de datos se convertirá en una fila independiente en la tabla de prueba.

QTest::newRow() toma un argumento: un nombre que se asociará al conjunto de datos y se utilizará en el registro de prueba para identificar la fila de datos. QTest::addRow() toma una cadena de formato (printf-style) seguida de los parámetros que se representarán en lugar de los tokens de formato en la cadena de formato. A continuación, introducimos el conjunto de datos en la nueva fila de la tabla. Primero una cadena arbitraria, y luego el resultado esperado de aplicar la función QString::toUpper() a esa cadena.

Puedes pensar en los datos de prueba como una tabla bidimensional. En nuestro caso, tiene dos columnas llamadas string y result y tres filas. Además, a cada fila se le asocia un nombre y un índice:

Cuando se introducen datos en la fila, se comprueba que cada dato coincida con el tipo de la columna cuyo valor suministra. Si falla alguna afirmación, se interrumpe la prueba.

Los nombres de las filas y columnas, en la tabla de datos de una función de prueba dada, deben ser únicos: si dos filas comparten un nombre, o dos columnas comparten un nombre, se producirá una advertencia (desde Qt 6.5). Consulte qWarning() para saber cómo puede hacer que las advertencias se traten como errores y Test for Warnings para saber cómo conseguir que sus pruebas estén libres de otras advertencias.

Reescribiendo la función de prueba

Ahora podemos reescribir nuestra función de prueba:

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

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

La función TestQString::toUpper() se ejecutará tres veces, una por cada entrada de la tabla de prueba que creamos en la función TestQString::toUpper_data() asociada.

En primer lugar, obtenemos los dos elementos del conjunto de datos utilizando la macro QFETCH(). QFETCH() toma dos argumentos: El tipo de datos del elemento y el nombre del elemento. A continuación, realizamos la prueba utilizando la macro QCOMPARE().

De este modo, es muy fácil añadir nuevos datos a la prueba sin modificar la propia prueba.

Preparación del ejecutable independiente

Y de nuevo, para hacer de nuestro caso de prueba un ejecutable autónomo, se necesitan las dos líneas siguientes:

QTEST_MAIN(TestQString)
#include "testqstring.moc"

Como antes, la macro QTEST_MAIN() se expande a un simple método main() que ejecuta todas las funciones del test, y como tanto la declaración como la implementación de nuestra clase de test 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 usando 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(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})

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/tutorial2
INSTALLS += target

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

qmake
make

Ejecutar el ejecutable

Al ejecutar 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(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 *********