En esta página

Capítulo 2: Pruebas basadas en datos

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

Hasta ahora, habíamos codificado de forma estática 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 sature de código repetitivo, « Qt Test » permite añadir datos de prueba a una función de prueba. Solo tenemos que añadir otro campo privado 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 lleva « _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 al aplicar la función QString::toUpper() a dicha 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 del 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 de 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 pruebas para identificar la fila de datos. QTest::addRow() toma una cadena de formato (al estilo deprintf) seguida de los parámetros que se representarán en lugar de los tokens de formato de la cadena de formato. A continuación, introducimos el conjunto de datos en la nueva fila de la tabla. Primero, una cadena arbitraria; y, a continuación, el resultado esperado al aplicar la función QString::toUpper() a esa cadena.

Puedes imaginar 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:

índicenombrecadenaresultado
0todo en minúsculas«hola»HOLA
1mezclado«Hola»HOLA
2todo en mayúsculas«HOLA»HOLA

Cuando los datos se introducen en la fila, se comprueba que cada dato coincida con el tipo de la columna a la que corresponde. Si falla alguna comprobación, la prueba se interrumpe.

Los nombres de las filas y columnas, en la tabla de datos de una función de prueba determinada, deben ser únicos: si dos filas comparten un nombre, o dos columnas comparten un nombre, se generará una advertencia (desde Qt 6.5). Consulta qWarning() para saber cómo hacer que las advertencias se traten como errores y «Comprobación de advertencias» para saber cómo eliminar otras advertencias de tus pruebas.

Reescritura de 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 hemos creado en la función asociada `TestQString::toUpper_data()`.

En primer lugar, recuperamos 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()`.

Este enfoque facilita enormemente la incorporación de nuevos datos a la prueba sin necesidad de modificar la propia prueba.

Preparación del ejecutable independiente

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

QTEST_MAIN(TestQString)
#include "testqstring.moc"

Al igual que antes, la macro QTEST_MAIN() se expande a un sencillo método main() que ejecuta todas las funciones de prueba, y dado que tanto la declaración como la implementación de nuestra clase de prueba se encuentran en un archivo .cpp, también debemos incluir el archivo moc generado para que funcione la introspección de Qt.

Compilación del ejecutable

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

Compilación 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, ejecuta « cmake » o utiliza el script de conveniencia « qt-cmake », que se encuentra en « Qt-prefix/<version>/<platform>/bin/qt-cmake »:

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

A continuación, ejecuta tu herramienta generadora preferida para compilar el ejecutable. En este caso, utilizamos Ninja:

ninja

Compilación con qmake

Configura los ajustes 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 compilar tu ejecutable:

qmake
make

Ejecución del ejecutable

Al ejecutar el ejecutable resultante deberías obtener 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 *********

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.