En esta página

Qt Test Buenas prácticas

Recomendamos añadir pruebas de Qt Test para la corrección de errores y la incorporación de nuevas funcionalidades. Antes de intentar corregir un error, añade una prueba de regresión (a ser posible automática) que falle antes de la corrección, mostrando el error, y que pase después de la corrección. Mientras desarrollas nuevas funcionalidades, añade pruebas para verificar que funcionan según lo previsto.

Cumplir con un conjunto de normas de codificación aumentará la probabilidad de que las pruebas automáticas de Qt funcionen de forma fiable en todos los entornos. Por ejemplo, algunas pruebas necesitan leer datos del disco. Si no se establecen normas sobre cómo hacerlo, algunas pruebas no serán portables. Por ejemplo, una prueba que da por hecho que sus archivos de datos de prueba se encuentran en el directorio de trabajo actual solo funciona en una compilación «in-source». En una compilación «shadow» (fuera del directorio de código fuente), la prueba no encontrará sus datos.

Las siguientes secciones contienen directrices para escribir pruebas de Qt Test:

Se deben tener en cuenta los consejos sobre consideraciones de seguridad junto con estas buenas prácticas.

Principios generales

Las siguientes secciones ofrecen directrices generales para escribir pruebas unitarias:

Verifica las pruebas

Escribe y confirma tus pruebas junto con tu corrección o nueva funcionalidad en una nueva rama. Una vez que hayas terminado, puedes hacer un «checkout» de la rama en la que se basa tu trabajo y, a continuación, incorporar a esta rama los archivos de prueba correspondientes a tus nuevas pruebas. Esto te permite verificar que las pruebas fallan en la rama anterior y que, por lo tanto, realmente detectan un error o comprueban una nueva funcionalidad.

Por ejemplo, el flujo de trabajo para corregir un error en la clase ` QDateTime ` podría ser así si utilizas el sistema de control de versiones Git:

  1. Crea una rama para tu corrección y prueba: git checkout -b fix-branch dev
  2. Escribe una prueba y corrige el error.
  3. Compila y prueba tanto la corrección como la nueva prueba, para verificar que la nueva prueba se supera con la corrección.
  4. Añade la corrección y la prueba a tu rama: git add tests/auto/corelib/time/qdatetime/tst_qdatetime.cpp src/corelib/time/qdatetime.cpp
  5. Confirma la corrección y la prueba en tu rama: git commit -m 'Fix bug in QDateTime'
  6. Para comprobar que la prueba realmente detecta el problema para el que necesitabas la corrección, haz un checkout de la rama en la que basaste tu propia rama: git checkout dev
  7. Copia solo el archivo de prueba de la rama de corrección: git checkout fix-branch -- tests/auto/corelib/time/qdatetime/tst_qdatetime.cpp

    El resto del árbol de código fuente permanece en «dev», sin la corrección, pero con la nueva prueba lista para probarla.

  8. Compila y ejecuta la prueba para comprobar que falla en «dev» y que, por lo tanto, detecta efectivamente un error.
  9. Ahora puedes volver a la rama «fix»: git checkout fix-branch
  10. Como alternativa, puedes restaurar tu árbol de trabajo a un estado limpio en «dev»: git checkout HEAD -- tests/auto/corelib/time/qdatetime/tst_qdatetime.cpp

Cuando revises un cambio, puedes adaptar este flujo de trabajo para comprobar que el cambio incluye efectivamente una prueba para el problema que soluciona.

Asigna nombres descriptivos a las funciones de prueba

Es importante nombrar los casos de prueba. El nombre de la prueba aparece en el informe de fallos de una ejecución de pruebas. En el caso de las pruebas basadas en datos, el nombre de la fila de datos también aparece en el informe de fallos. Unos buenos nombres pueden dar a quienes lean el informe una primera indicación de qué ha fallado.

Los nombres de las funciones de prueba deben dejar claro qué es lo que la función está intentando probar. No utilices simplemente el identificador del sistema de seguimiento de errores, ya que los identificadores quedan obsoletos si se sustituye dicho sistema. Además, los desarrolladores que trabajan sin conexión no pueden acceder a tu sistema de seguimiento de errores y es posible que algunos de estos sistemas no sean accesibles para todos los usuarios. Cuando el informe de error pueda ser de interés para futuros lectores del código de prueba, puedes mencionarlo en un comentario junto a la parte relevante de la prueba.

Del mismo modo, al escribir pruebas basadas en datos, asigna nombres descriptivos a los casos de prueba que indiquen en qué aspecto de la funcionalidad se centra cada uno. No te limites a numerar el caso de prueba ni utilices identificadores del sistema de seguimiento de errores. Quien lea el resultado de la prueba no tendrá ni idea de qué significan los números o los identificadores. Puedes añadir un comentario en la línea de la prueba que mencione el identificador del sistema de seguimiento de errores, cuando sea pertinente. Es mejor evitar los espacios en blanco y los caracteres que puedan ser significativos para los intérpretes de la línea de comandos en los que quieras ejecutar las pruebas. Esto facilita especificar la prueba y la etiqueta en la línea de comandos de tu programa de pruebas; por ejemplo, para limitar una ejecución de pruebas a un solo caso de prueba.

Escribe funciones de prueba autónomas

Dentro de un programa de pruebas, las funciones de prueba deben ser independientes entre sí y no deben depender de que se hayan ejecutado funciones de prueba anteriores. Puedes comprobarlo ejecutando la función de prueba por sí sola con ` tst_foo testname`. En el caso de las pruebas basadas en datos, del mismo modo, evita las dependencias entre las filas de la tabla de datos de la prueba, de modo que se pueda utilizar ` tst_foo function:tag ` para ejecutar una sola fila de forma aislada (por ejemplo, para investigar por qué falla).

No reutilices instancias de la clase sometida a prueba en varias pruebas. Las instancias de prueba (por ejemplo, widgets) no deben ser variables de miembro de las pruebas, sino que es preferible instanciarlas en la pila para garantizar una limpieza adecuada incluso si una prueba falla, de modo que las pruebas no interfieran entre sí.

Si tu prueba implica realizar cambios globales, asegúrate de que se restaure el estado anterior al final de la prueba, tanto si pasa como si falla. Dado que un fallo impide que se ejecute el código posterior a la comprobación fallida, la restauración al final de la prueba no funciona cuando esta falla. La forma más sólida de restaurar el estado incluso en caso de fallo es instanciar un objeto RAII (la adquisición de recursos es la inicialización) cuyo destructor restaure el estado anterior. A menudo, esto se puede hacer cómodamente utilizando ` qScopeGuard()`, por ejemplo

const auto restoreDefaultLocale = qScopeGuard([prior = QLocale()]() {
    QLocale::setDefault(prior);
});

antes de la primera llamada a ` QLocale::setDefault()` en una prueba que necesite controlar la configuración regional utilizada por el código sometido a prueba.

Evita las dependencias externas

Las funciones de prueba también deben evitar cualquier dependencia de recursos externos. Dicha dependencia puede provocar que la prueba falle si ese recurso no está disponible temporalmente. Incluso cuando está disponible, el recurso puede bloquear el acceso del sistema de pruebas; por ejemplo, cuando las pruebas se ejecutan con frecuencia, el recurso puede interpretar la prueba como una carga indeseada para su servicio.

Omitir la prueba cuando no se puede acceder al recurso podría ocultar un problema que se habría detectado si se hubiera ejecutado la prueba, lo que la convierte en una solución inadecuada para estos problemas. Es mejor crear una réplica local del recurso, con características suficientes para los fines de la prueba.

Las dependencias externas también plantean problemas a los desarrolladores que trabajan sin conexión, así como a la hora de realizar pruebas en un entorno aislado, como una máquina virtual aislada, al evaluar cambios en el código procedentes de fuentes no fiables. Consulte «Qt Test: Security Considerations» para conocer otras cuestiones relacionadas.

Prueba la pila completa

Si una API se implementa mediante backends acoplables o específicos de una plataforma que realizan el trabajo pesado, asegúrate de escribir pruebas que cubran las rutas de código hasta llegar a los backends. Probar las partes de la API de la capa superior utilizando un backend simulado es una buena forma de aislar los errores de la capa de la API de los backends, pero es complementario a las pruebas que ejecutan la implementación real con datos que reflejan fielmente las condiciones del mundo real.

Haz que las pruebas se completen rápidamente

Las pruebas no deben suponer una pérdida de tiempo por ser innecesariamente repetitivas, por utilizar volúmenes de datos de prueba excesivamente grandes o por introducir tiempos de inactividad innecesarios.

Esto es especialmente cierto en el caso de las pruebas unitarias, en las que cada segundo adicional de tiempo de ejecución de una prueba unitaria hace que las pruebas de integración continua (CI) de una rama en múltiples objetivos tarden más tiempo. Recuerda que las pruebas unitarias son independientes de las pruebas de carga y fiabilidad, en las que se esperan mayores volúmenes de datos de prueba y ejecuciones de prueba más largas.

Las pruebas de referencia, que suelen ejecutar la misma prueba varias veces, deben ubicarse en un directorio independiente tests/benchmarks y no deben mezclarse con las pruebas unitarias funcionales.

Utiliza pruebas basadas en datos

Las pruebas basadas en datos facilitan la incorporación de nuevas pruebas para las condiciones límite detectadas en informes de errores posteriores.

Utilizar una prueba basada en datos en lugar de probar varios elementos de forma secuencial en una prueba evita la repetición de código muy similar y garantiza que se prueben los casos posteriores incluso cuando los anteriores fallen. Además, fomenta las pruebas sistemáticas y uniformes, ya que se aplican las mismas pruebas a cada muestra de datos.

Cuando una prueba está basada en datos, puedes especificar su etiqueta de datos junto con el nombre de la función de prueba, como function:tag, en la línea de comandos de la prueba para ejecutar la prueba solo en un caso de prueba específico, en lugar de en todos los casos de prueba de la función. Esto se puede utilizar tanto para una etiqueta de datos global como para una etiqueta local, que identifica una fila de los propios datos de la función; incluso se pueden combinar como function:global:local.

Utiliza herramientas de cobertura

Utiliza una herramienta de cobertura, como Coco o gcov, para ayudarte a escribir pruebas que cubran el mayor número posible de sentencias, ramificaciones y condiciones de la función o clase que se está probando. Cuanto antes se haga esto en el ciclo de desarrollo de una nueva funcionalidad, más fácil será detectar regresiones más adelante, cuando se refactorice el código.

Selecciona los mecanismos adecuados para excluir pruebas

Es importante seleccionar el mecanismo adecuado para excluir las pruebas no aplicables.

Utiliza ` QSKIP()` para gestionar los casos en los que, en tiempo de ejecución, se detecte que toda una función de prueba no es aplicable en el entorno de prueba actual. Cuando solo se deba omitir una parte de una función de prueba, se puede utilizar una instrucción condicional, opcionalmente con una llamada a ` qDebug() ` para informar del motivo por el que se omite la parte no aplicable.

Cuando hay fallos de prueba conocidos que deberían solucionarse en algún momento, se recomienda utilizar ` QEXPECT_FAIL `, ya que permite ejecutar el resto de la prueba, siempre que sea posible. Además, verifica que el problema sigue existiendo e informa al responsable del mantenimiento del código si lo soluciona sin darse cuenta, una ventaja de la que se beneficia incluso al utilizar el indicador ` Abort `.

Las funciones de prueba o las filas de datos de una prueba basada en datos pueden limitarse a plataformas concretas o a características específicas que se habiliten mediante ` #if`. Sin embargo, hay que tener en cuenta las limitaciones de moc al utilizar ` #if ` para omitir funciones de prueba. El preprocesador ` moc ` no tiene acceso a todas las macros ` builtin ` del compilador que suelen utilizarse para la detección de características del compilador. Por lo tanto, moc podría obtener un resultado diferente para una condición del preprocesador respecto al que ve el resto del código. Esto puede dar lugar a que moc genere metadatos para un slot de prueba que el compilador real omite, u omita los metadatos para un slot de prueba que en realidad se compila en la clase. En el primer caso, la prueba intentará ejecutar una ranura que no está implementada. En el segundo caso, la prueba no intentará ejecutar una ranura de prueba aunque debería hacerlo.

Si un programa de pruebas completo no es aplicable a una plataforma específica o a menos que se habilite una característica concreta, lo mejor es utilizar la configuración de compilación del directorio principal para evitar compilar la prueba. Por ejemplo, si la prueba tests/auto/gui/someclass no es válida para macOS, incluye su incorporación como subdirectorio en tests/auto/gui/CMakeLists.txt dentro de una comprobación de plataforma:

if(NOT APPLE)
    add_subdirectory(someclass)
endif

o, si se utiliza qmake, añade la siguiente línea a tests/auto/gui.pro:

mac*: SUBDIRS -= someclass

Véase también «Omitir pruebas con QSKIP».

Evita Q_ASSERT

La macro « Q_ASSERT » provoca que un programa se interrumpa siempre que la condición verificada sea « false », pero solo si el software se ha compilado en modo de depuración. Tanto en las compilaciones de lanzamiento como en las de depuración y lanzamiento, « Q_ASSERT » no tiene ningún efecto.

Q_ASSERT debe evitarse porque hace que las pruebas se comporten de forma diferente dependiendo de si se está probando una compilación de depuración, y porque provoca que una prueba se interrumpa inmediatamente, omitiendo todas las funciones de prueba restantes y devolviendo resultados de prueba incompletos o malformados.

Además, omite cualquier operación de desmontaje o limpieza que debiera realizarse al final de la prueba y, por lo tanto, podría dejar el espacio de trabajo en un estado desordenado, lo que podría causar complicaciones para pruebas posteriores.

En lugar de ` Q_ASSERT`, deben utilizarse las variantes de macro ` QCOMPARE()` o ` QVERIFY()`. Estas hacen que la prueba actual informe de un fallo y finalice, pero permiten que se ejecuten las funciones de prueba restantes y que todo el programa de pruebas finalice con normalidad. ` QVERIFY2()` permite incluso que se registre un mensaje de error descriptivo en el registro de pruebas.

Cómo escribir pruebas fiables

Las siguientes secciones ofrecen directrices para escribir pruebas fiables:

Evita los efectos secundarios en los pasos de verificación

Al realizar pasos de verificación en una prueba automática utilizando ` QCOMPARE()`, ` QVERIFY()`, etc., se deben evitar los efectos secundarios. Los efectos secundarios en los pasos de verificación pueden hacer que una prueba resulte difícil de entender. Además, pueden provocar fácilmente que una prueba falle de formas difíciles de diagnosticar cuando se modifica la prueba para utilizar QTRY_VERIFY(), QTRY_COMPARE() o QBENCHMARK. Estas funciones pueden ejecutar la expresión pasada repetidamente, repitiendo así cualquier efecto secundario.

Cuando los efectos secundarios sean inevitables, asegúrate de que se restablezca el estado anterior al final de la función de prueba, incluso si esta falla. Esto suele requerir el uso de una clase RAII (véase «Escribir funciones de prueba autónomas » más arriba) o de un método « cleanup() ». No te limites a colocar el código de restauración al final de la prueba. Si una parte de la prueba falla, dicho código se omitirá y no se restablecerá el estado anterior.

Evita los tiempos de espera fijos

Evita utilizar tiempos de espera codificados de forma rígida, como ` QTest::qWait()` para esperar a que se cumplan ciertas condiciones. Considera la posibilidad de utilizar la clase ` QSignalSpy `, las macros ` QTRY_VERIFY()` o ` QTRY_COMPARE()`, o la clase ` QSignalSpy ` junto con las variantes de la macro ` QTRY_ `.

La función qWait() se puede utilizar para establecer un retraso de duración fija entre la ejecución de una acción y la espera a que se complete algún comportamiento asíncrono desencadenado por dicha acción. Por ejemplo, cambiar el estado de un widget y, a continuación, esperar a que el widget se vuelva a dibujar. Sin embargo, estos tiempos de espera suelen provocar fallos cuando una prueba escrita en una estación de trabajo se ejecuta en un dispositivo, donde el comportamiento esperado puede tardar más en completarse. Aumentar el tiempo de espera fijo a un valor varias veces mayor de lo necesario en la plataforma de prueba más lenta no es una buena solución, ya que ralentiza la ejecución de la prueba en todas las plataformas, especialmente en el caso de las pruebas basadas en tablas.

Si el código sometido a prueba emite señales Qt al completarse el comportamiento asíncrono, un enfoque más adecuado es utilizar la clase QSignalSpy para notificar a la función de prueba que ya se puede realizar el paso de verificación.

Si no hay señales de Qt, utiliza las macros ` QTRY_COMPARE() ` y ` QTRY_VERIFY() `, que comprueban periódicamente una condición especificada hasta que se cumple o se alcanza un tiempo de espera máximo. Estas macros evitan que la prueba tarde más de lo necesario, al tiempo que evitan fallos cuando las pruebas se desarrollan en sistemas más rápidos y posteriormente se ejecutan en otros más lentos.

Si no hay señales de Qt y estás escribiendo la prueba como parte del desarrollo de una nueva API, plantéate si la API podría beneficiarse de la incorporación de una señal que notifique la finalización del comportamiento asíncrono. Si esto facilitara tus pruebas, también podría resultar útil para quienes utilicen tu API.

Cuidado con el comportamiento dependiente del tiempo

Algunas estrategias de prueba son vulnerables al comportamiento dependiente del tiempo de ciertas clases, lo que puede dar lugar a pruebas que fallan solo en determinadas plataformas o que no devuelven resultados consistentes.

Un ejemplo de ello son los widgets de introducción de texto, que a menudo cuentan con un cursor parpadeante que puede hacer que las comparaciones de mapas de bits capturados tengan éxito o fracasen, dependiendo del estado del cursor en el momento de la captura. Esto, a su vez, puede depender de la velocidad del equipo que ejecuta la prueba.

Al probar clases que cambian de estado en función de eventos de temporizador, es necesario tener en cuenta el comportamiento basado en el temporizador al realizar los pasos de verificación. Debido a la variedad de comportamientos dependientes del tiempo, no existe una solución genérica única para este problema de pruebas.

En el caso de los widgets de introducción de texto, entre las posibles soluciones se incluyen desactivar el parpadeo del cursor (si la API ofrece esa función), esperar a que el cursor se encuentre en un estado conocido antes de capturar un mapa de bits (por ejemplo, suscribiéndose a una señal adecuada si la API la proporciona), o excluir el área que contiene el cursor de la comparación de mapas de bits.

Evitar la captura y comparación de mapas de bits

Aunque a veces es necesario verificar los resultados de las pruebas mediante la captura y comparación de mapas de bits, este proceso puede resultar bastante frágil y laborioso.

Por ejemplo, un widget concreto puede tener un aspecto diferente en distintas plataformas o con distintos estilos de widget, por lo que puede ser necesario crear mapas de bits de referencia varias veces y mantenerlos posteriormente a medida que evoluciona el conjunto de plataformas compatibles con Qt. Por lo tanto, realizar cambios que afecten al mapa de bits implica tener que recrear los mapas de bits esperados en cada plataforma compatible, lo que requeriría acceso a cada una de ellas.

Las comparaciones de mapas de bits también pueden verse influidas por factores como la resolución de pantalla del equipo de prueba, la profundidad de bits, el tema activo, la combinación de colores, el estilo de los widgets, la configuración regional activa (símbolos de moneda, dirección del texto, etc.), el tamaño de la fuente, los efectos de transparencia y la elección del gestor de ventanas.

Siempre que sea posible, utiliza medios programáticos, como la verificación de las propiedades de objetos y variables, en lugar de capturar y comparar mapas de bits.

Mejora de la salida de las pruebas

Las siguientes secciones ofrecen directrices para generar resultados de prueba legibles y útiles:

Comprobación de advertencias

Al igual que al compilar tu software, si la salida de las pruebas está repleta de advertencias, te resultará más difícil detectar aquella que realmente sea una pista de la aparición de un error. Por lo tanto, es aconsejable revisar periódicamente los registros de las pruebas en busca de advertencias y otras salidas superfluas, e investigar sus causas. Cuando sean indicios de un error, puedes hacer que las advertencias provoquen el fallo de la prueba.

Cuando el código sometido a prueba deba generar mensajes, como advertencias sobre un uso incorrecto, también es importante comprobar que los genera cuando se utiliza de esa manera. Puedes comprobar si el código sometido a prueba genera los mensajes esperados, producidos por qWarning(), qDebug(), qInfo() y funciones similares, utilizando QTest::ignoreMessage(). Esto verificará que se genera el mensaje y lo filtrará de la salida de la ejecución de la prueba. Si no se genera el mensaje, la prueba fallará.

Si un mensaje esperado solo se muestra cuando Qt se compila en modo de depuración, utiliza QLibraryInfo::isDebugBuild() para determinar si las bibliotecas de Qt se compilaron en modo de depuración. No basta con utilizar #ifdef QT_DEBUG, ya que solo te indicará si la prueba se compiló en modo de depuración, lo que no garantiza que las bibliotecas de Qt también se hayan compilado en modo de depuración.

Tus pruebas pueden verificar que no activan llamadas a ` qWarning()` llamando a ` QTest::failOnWarning()`. Sin ningún parámetro (desde Qt 6.8), esto hace que la prueba falle si se genera una advertencia, mostrando dicha advertencia. Opcionalmente, puedes pasar a ` failOnWarning() ` un mensaje de advertencia que se quiera comprobar o un ` QRegularExpression ` con el que compararlo, para limitar este comportamiento a las advertencias que coincidan. (Estas versiones filtradas se introdujeron en Qt 6.3.)

También puedes configurar la variable de entorno QT_FATAL_WARNINGS para que las advertencias se traten como errores fatales. Consulta qWarning() para obtener más detalles; esto no es específico de las autopruebas. Si, de otro modo, las advertencias se perderían entre los extensos registros de pruebas, ejecutar ocasionalmente las pruebas con esta variable de entorno activada puede ayudarte a encontrar y eliminar cualquier advertencia que surja.

Evita mostrar mensajes de depuración en las autopruebas

Las autopruebas que superan la ejecución no deberían generar ninguna advertencia ni mensaje de depuración sin gestionar. Esto permitirá que CI Gate trate las nuevas advertencias o mensajes de depuración como fallos de prueba. Al igual que ocurre con las advertencias de los compiladores al compilar el código, si las advertencias son poco frecuentes, constituyen pistas útiles sobre posibles problemas; pero si son habituales, pueden ocultar cuestiones importantes a los desarrolladores que prueban sus cambios.

Añadir mensajes de depuración durante el desarrollo está bien, pero estos deben desactivarse o eliminarse antes de que se incorpore una prueba al código.

Escribe código de diagnóstico bien estructurado

Cualquier salida de diagnóstico que resulte útil en caso de que falle una prueba debe formar parte de la salida habitual de la prueba, en lugar de estar comentada, desactivada mediante directivas del preprocesador o activada únicamente en compilaciones de depuración. Si una prueba falla durante la integración continua, disponer de toda la salida de diagnóstico relevante en los registros de CI podría ahorrarte mucho tiempo en comparación con habilitar el código de diagnóstico y volver a realizar la prueba. Especialmente si el fallo se produjo en una plataforma que no tienes en tu ordenador.

Los mensajes de diagnóstico en las pruebas deben utilizar los mecanismos de salida de Qt, como qDebug() y qWarning(), en lugar de los mecanismos de salida de stdio.h o iostream.h. Estos últimos eluden la gestión de mensajes de Qt e impiden que la opción de línea de comandos -silent suprima los mensajes de diagnóstico. Esto podría dar lugar a que mensajes de fallo importantes quedaran ocultos entre un gran volumen de salida de depuración.

Escribir código que se pueda probar

Las siguientes secciones ofrecen directrices para escribir código que sea fácil de probar:

Romper las dependencias

La idea de las pruebas unitarias es utilizar cada clase de forma aislada. Dado que muchas clases instancian otras clases, no es posible instanciar una clase por separado. Por lo tanto, debes utilizar una técnica denominada «inyección de dependencias» que separa la creación de objetos de su uso. Una fábrica se encarga de construir árboles de objetos. Otros objetos manipulan estos objetos a través de interfaces abstractas.

Esta técnica funciona bien para aplicaciones basadas en datos. En el caso de las aplicaciones con interfaz gráfica de usuario (GUI), este enfoque puede resultar complicado, ya que los objetos se crean y destruyen con frecuencia. Para verificar el comportamiento correcto de las clases que dependen de interfaces abstractas, se puede recurrir a la simulación (mocking). Por ejemplo, véase el marco Googletest Mocking (gMock).

Compilar todas las clases en bibliotecas

En proyectos de tamaño pequeño a mediano, un script de compilación suele enumerar todos los archivos fuente y, a continuación, compila el ejecutable de una sola vez. Esto significa que los scripts de compilación para las pruebas deben volver a enumerar los archivos fuente necesarios.

Resulta más sencillo enumerar los archivos fuente y los encabezados una sola vez en un script para compilar una biblioteca estática. De este modo, la función ` main() ` se vinculará a la biblioteca estática para compilar el ejecutable, y las pruebas se vincularán a las bibliotecas estáticas.

En los proyectos en los que se utilizan los mismos archivos fuente para compilar varios programas, puede resultar más adecuado compilar las clases compartidas en una biblioteca de enlace dinámico (u objeto compartido) que cada programa, incluidos los programas de prueba, pueda cargar en tiempo de ejecución. Una vez más, tener el código compilado en una biblioteca ayuda a evitar la duplicación en la descripción de qué componentes hay que combinar para crear los distintos programas.

Configuración de los equipos de prueba

En las siguientes secciones se tratan los problemas habituales derivados de la configuración de los equipos de prueba:

Todos estos problemas suelen resolverse mediante un uso adecuado de la virtualización.

Salvapantallas

Los salvapantallas pueden interferir en algunas de las pruebas de las clases de la interfaz gráfica de usuario (GUI), lo que da lugar a resultados poco fiables. Se deben desactivar los salvapantallas para garantizar que los resultados de las pruebas sean coherentes y fiables.

Cuadros de diálogo del sistema

Los cuadros de diálogo que aparecen de forma inesperada por parte del sistema operativo u otras aplicaciones en ejecución pueden robar el foco de entrada a los widgets implicados en una prueba automática, lo que provoca fallos irreproducibles.

Entre los ejemplos de problemas habituales se incluyen los cuadros de diálogo de notificación de actualizaciones en línea en macOS, las falsas alarmas de los antivirus, las tareas programadas como las actualizaciones de firmas de virus, las actualizaciones de software enviadas a las estaciones de trabajo y los programas de chat que abren ventanas emergentes en la parte superior de la pila.

Uso de la pantalla

Algunas pruebas utilizan la pantalla, el ratón y el teclado del equipo de pruebas, por lo que pueden fallar si el equipo se está utilizando para otra cosa al mismo tiempo o si se ejecutan varias pruebas en paralelo.

El sistema de integración continua (CI) utiliza máquinas de prueba dedicadas para evitar este problema, pero si no dispones de una máquina de prueba dedicada, es posible que puedas resolverlo ejecutando las pruebas en una segunda pantalla.

En Unix, también se pueden ejecutar las pruebas en un servidor X anidado o virtual, como Xephyr. Por ejemplo, para ejecutar el conjunto completo de pruebas en Xephyr, ejecuta los siguientes comandos:

Xephyr :1 -ac -screen 1920x1200 >/dev/null 2>&1 &
sleep 5
DISPLAY=:1 icewm >/dev/null 2>&1 &
cd tests/auto
make
DISPLAY=:1 make -k -j1 check

Los usuarios de controladores binarios de NVIDIA deben tener en cuenta que es posible que Xephyr no pueda proporcionar extensiones GLX. Forzar el uso de la biblioteca libGL de Mesa podría ayudar:

export LD_PRELOAD=/usr/lib/mesa-diverted/x86_64-linux-gnu/libGL.so.1

Sin embargo, cuando las pruebas se ejecutan en Xephyr y en el servidor X real con versiones diferentes de libGL, la caché de disco de QML puede provocar que las pruebas se cuelguen. Para evitarlo, utiliza QML_DISABLE_DISK_CACHE=1.

Como alternativa, utiliza el complemento «offscreen»:

TESTARGS="-platform offscreen" make check -k -j1

Gestores de ventanas

En Unix, al menos dos pruebas automáticas (tst_examples y tst_gestures) requieren que se esté ejecutando un gestor de ventanas. Por lo tanto, si ejecutas estas pruebas en un servidor X anidado, también debes ejecutar un gestor de ventanas en ese servidor X.

El gestor de ventanas debe estar configurado para colocar automáticamente todas las ventanas en la pantalla. Algunos gestores de ventanas, como Tab Window Manager (twm), disponen de un modo para colocar manualmente las nuevas ventanas, lo que impide que el conjunto de pruebas se ejecute sin la intervención del usuario.

Nota: Tab Window Manager no es adecuado para ejecutar el conjunto completo de autopruebas de Qt, ya que la autoprueba « tst_gestures » hace que olvide su configuración y vuelva a la colocación manual de ventanas.

© 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.