QTest Namespace
El espacio de nombres QTest contiene todas las funciones y declaraciones relacionadas con Qt Test. Más información...
| Encabezado: | #include <QTest> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Test) target_link_libraries(mytarget PRIVATE Qt6::Test) |
| qmake: | QT += testlib |
Clases
| class | QTouchEventSequence |
| class | QTouchEventWidgetSequence |
(since 6.8) class | ThrowOnFailDisabler |
(since 6.8) class | ThrowOnFailEnabler |
(since 6.8) class | ThrowOnSkipDisabler |
(since 6.8) class | ThrowOnSkipEnabler |
Tipos
| enum | KeyAction { Press, Release, Click, Shortcut } |
| enum | MouseAction { MousePress, MouseRelease, MouseClick, MouseDClick, MouseMove } |
| enum | QBenchmarkMetric { FramesPerSecond, BitsPerSecond, BytesPerSecond, WalltimeMilliseconds, WalltimeNanoseconds, …, EmulationFaults } |
| enum | TestFailMode { Abort, Continue } |
Variables
(since 6.11) std::atomic<std::chrono::milliseconds> | defaultTryTimeout |
Funciones
| void | addColumn(const char *name, T *dummy = 0) |
| QTestData & | addRow(const char *format, ...) |
| const char * | benchmarkMetricName(QTest::QBenchmarkMetric metric) |
| const char * | benchmarkMetricUnit(QTest::QBenchmarkMetric metric) |
| QPointingDevice * | createTouchDevice(QInputDevice::DeviceType devType = QInputDevice::DeviceType::TouchScreen, QInputDevice::Capabilities caps = QInputDevice::Capability::Position) |
| const char * | currentAppName() |
| const char * | currentDataTag() |
(since 6.11) const char * | currentGlobalDataTag() |
| bool | currentTestFailed() |
| const char * | currentTestFunction() |
(since 6.5) bool | currentTestResolved() |
(since 6.3) void | failOnWarning(const QRegularExpression &messagePattern) |
(since 6.8) void | failOnWarning() |
(since 6.3) void | failOnWarning(const char *message) |
| void | ignoreMessage(QtMsgType type, const char *message) |
| void | ignoreMessage(QtMsgType type, const QRegularExpression &messagePattern) |
| void | keyClick(QWidget *widget, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1) |
| void | keyClick(QWidget *widget, char key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1) |
| void | keyClick(QWindow *window, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1) |
| void | keyClick(QWindow *window, char key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1) |
| void | keyClicks(QWidget *widget, const QString &sequence, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1) |
| void | keyEvent(QTest::KeyAction action, QWidget *widget, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1) |
| void | keyEvent(QTest::KeyAction action, QWidget *widget, char ascii, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1) |
| void | keyEvent(QTest::KeyAction action, QWindow *window, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1) |
| void | keyEvent(QTest::KeyAction action, QWindow *window, char ascii, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1) |
| void | keyPress(QWidget *widget, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1) |
| void | keyPress(QWidget *widget, char key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1) |
| void | keyPress(QWindow *window, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1) |
| void | keyPress(QWindow *window, char key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1) |
| void | keyRelease(QWidget *widget, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1) |
| void | keyRelease(QWidget *widget, char key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1) |
| void | keyRelease(QWindow *window, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1) |
| void | keyRelease(QWindow *window, char key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1) |
| void | keySequence(QWidget *widget, const QKeySequence &keySequence) |
| void | keySequence(QWindow *window, const QKeySequence &keySequence) |
| void | mouseClick(QWidget *widget, Qt::MouseButton button, Qt::KeyboardModifiers modifier = Qt::KeyboardModifiers(), QPoint pos = QPoint(), int delay = -1) |
| void | mouseClick(QWindow *window, Qt::MouseButton button, Qt::KeyboardModifiers stateKey = Qt::KeyboardModifiers(), QPoint pos = QPoint(), int delay = -1) |
| void | mouseDClick(QWidget *widget, Qt::MouseButton button, Qt::KeyboardModifiers modifier = Qt::KeyboardModifiers(), QPoint pos = QPoint(), int delay = -1) |
| void | mouseDClick(QWindow *window, Qt::MouseButton button, Qt::KeyboardModifiers stateKey = Qt::KeyboardModifiers(), QPoint pos = QPoint(), int delay = -1) |
| void | mouseMove(QWidget *widget, QPoint pos = QPoint(), int delay = -1) |
| void | mouseMove(QWindow *window, QPoint pos = QPoint(), int delay = -1) |
| void | mousePress(QWidget *widget, Qt::MouseButton button, Qt::KeyboardModifiers modifier = Qt::KeyboardModifiers(), QPoint pos = QPoint(), int delay = -1) |
| void | mousePress(QWindow *window, Qt::MouseButton button, Qt::KeyboardModifiers stateKey = Qt::KeyboardModifiers(), QPoint pos = QPoint(), int delay = -1) |
| void | mouseRelease(QWidget *widget, Qt::MouseButton button, Qt::KeyboardModifiers modifier = Qt::KeyboardModifiers(), QPoint pos = QPoint(), int delay = -1) |
| void | mouseRelease(QWindow *window, Qt::MouseButton button, Qt::KeyboardModifiers stateKey = Qt::KeyboardModifiers(), QPoint pos = QPoint(), int delay = -1) |
| QTestData & | newRow(const char *dataTag) |
| int | qExec(QObject *testObject, int argc = 0, char **argv = nullptr) |
| int | qExec(QObject *testObject, const QStringList &arguments) |
| QSharedPointer<QTemporaryDir> | qExtractTestData(const QString &dirName) |
(since 6.5) void | qRegisterTestCase(const QString &name, QTest::TestEntryFunction entryFunction) |
(since 6.7) void | qSleep(std::chrono::milliseconds msecs) |
| void | qSleep(int ms) |
(since 6.7) void | qWait(std::chrono::milliseconds msecs) |
| void | qWait(int msecs) |
(since 6.7) bool | qWaitFor(Functor predicate, QDeadlineTimer deadline = QDeadlineTimer( defaultTryTimeout.load(std::memory_order_relaxed))) |
| bool | qWaitFor(Functor predicate, int timeout) |
(since 6.10) bool | qWaitForWindowActive(QWidget *widget, QDeadlineTimer timeout) |
(since 6.10) bool | qWaitForWindowActive(QWindow *window, QDeadlineTimer timeout) |
(since 6.10) bool | qWaitForWindowActive(QWidget *widget) |
(since 6.10) bool | qWaitForWindowActive(QWindow *window) |
| bool | qWaitForWindowActive(QWidget *widget, int timeout) |
| bool | qWaitForWindowActive(QWindow *window, int timeout) |
(since 6.10) bool | qWaitForWindowExposed(QWidget *widget, QDeadlineTimer timeout) |
(since 6.10) bool | qWaitForWindowExposed(QWindow *window, QDeadlineTimer timeout) |
(since 6.10) bool | qWaitForWindowExposed(QWidget *widget) |
(since 6.10) bool | qWaitForWindowExposed(QWindow *window) |
| bool | qWaitForWindowExposed(QWidget *widget, int timeout) |
| bool | qWaitForWindowExposed(QWindow *window, int timeout) |
(since 6.7) bool | qWaitForWindowFocused(QWidget *widget, QDeadlineTimer timeout) |
(since 6.7) bool | qWaitForWindowFocused(QWindow *window, QDeadlineTimer timeout) |
(since 6.10) bool | qWaitForWindowFocused(QWidget *widget) |
(since 6.10) bool | qWaitForWindowFocused(QWindow *window) |
| void | setBenchmarkResult(qreal result, QTest::QBenchmarkMetric metric) |
(since 6.8) void | setThrowOnFail(bool enable) |
(since 6.8) void | setThrowOnSkip(bool enable) |
| char * | toHexRepresentation(const char *ba, qsizetype length) |
| char * | toString(const T &value) |
| char * | toString(QSizePolicy sp) |
| char * | toString(QSizePolicy::ControlType ct) |
| char * | toString(QSizePolicy::ControlTypes cts) |
| char * | toString(QSizePolicy::Policy p) |
| char * | toString(const QByteArray &ba) |
| char * | toString(const QCborError &c) |
| char * | toString(const QChar &character) |
| char * | toString(const QDate &date) |
| char * | toString(const QDateTime &dateTime) |
(since 6.5) char * | toString(const QKeySequence &ks) |
| char * | toString(const QLatin1StringView &string) |
| char * | toString(const QPoint &point) |
| char * | toString(const QPointF &point) |
| char * | toString(const QRect &rectangle) |
| char * | toString(const QRectF &rectangle) |
| char * | toString(const QSize &size) |
| char * | toString(const QSizeF &size) |
| char * | toString(const QString &string) |
| char * | toString(const QStringView &string) |
| char * | toString(const QTime &time) |
| char * | toString(const QUrl &url) |
| char * | toString(const QUuid &uuid) |
| char * | toString(const QVariant &variant) |
| char * | toString(const QVector2D &v) |
| char * | toString(const QVector3D &v) |
| char * | toString(const QVector4D &v) |
| char * | toString(const std::pair<T1, T2> &pair) |
| char * | toString(const std::tuple<Types...> &tuple) |
| char * | toString(std::nullptr_t) |
| QTest::QTouchEventWidgetSequence | touchEvent(QWidget *widget, QPointingDevice *device, bool autoCommit = true) |
| QTest::QTouchEventSequence | touchEvent(QWindow *window, QPointingDevice *device, bool autoCommit = true) |
(since 6.8) void | wheelEvent(QWindow *window, QPointF pos, QPoint angleDelta, QPoint pixelDelta = QPoint(0, 0), Qt::KeyboardModifiers stateKey = Qt::NoModifier, Qt::ScrollPhase phase = Qt::NoScrollPhase) |
Macros
| QBENCHMARK | |
| QBENCHMARK_ONCE | |
| QCOMPARE(real, esperado) | |
(since 6.9) | QCOMPARE_3WAY(izquierda, derecha, orden) |
(since 6.4) | QCOMPARE_EQ(calculado, línea de base) |
(since 6.4) | QCOMPARE_GE(calculado, de referencia) |
(since 6.4) | QCOMPARE_GT(calculado, valor de referencia) |
(since 6.4) | QCOMPARE_LE(calculado, referencia) |
(since 6.4) | QCOMPARE_LT(calculado, valor de referencia) |
(since 6.4) | QCOMPARE_NE(calculado, referencia) |
| QEXPECT_FAIL(índice de datos, comentario, modo) | |
| QFAIL(mensaje) | |
| QFETCH(tipo, nombre) | |
| QFETCH_GLOBAL(tipo, nombre) | |
| QFINDTESTDATA(nombre de archivo) | |
| QSKIP(descripción) | |
| QTEST(real, elemento de prueba) | |
| QTEST_APPLESS_MAIN(ClaseDePrueba) | |
| QTEST_GUILESS_MAIN(ClaseDePrueba) | |
| QTEST_MAIN(claseDePrueba) | |
(since 6.8) | QTEST_THROW_ON_FAIL |
(since 6.8) | QTEST_THROW_ON_SKIP |
| QTRY_COMPARE(real, esperado) | |
(since 6.4) | QTRY_COMPARE_EQ(calculado, valor de referencia) |
(since 6.4) | QTRY_COMPARE_EQ_WITH_TIMEOUT(calculado, valor de referencia, tiempo de espera) |
(since 6.4) | QTRY_COMPARE_GE(calculado, valor de referencia) |
(since 6.4) | QTRY_COMPARE_GE_WITH_TIMEOUT(calculado, valor de referencia, tiempo de espera) |
(since 6.4) | QTRY_COMPARE_GT(calculado, de referencia) |
(since 6.4) | QTRY_COMPARE_GT_WITH_TIMEOUT(calculado, valor de referencia, tiempo de espera) |
(since 6.4) | QTRY_COMPARE_LE(calculado, valor de referencia) |
(since 6.4) | QTRY_COMPARE_LE_WITH_TIMEOUT(calculado, valor de referencia, tiempo de espera) |
(since 6.4) | QTRY_COMPARE_LT(calculado, valor de referencia) |
(since 6.4) | QTRY_COMPARE_LT_WITH_TIMEOUT(calculado, valor de referencia, tiempo de espera) |
(since 6.4) | QTRY_COMPARE_NE(calculado, de referencia) |
(since 6.4) | QTRY_COMPARE_NE_WITH_TIMEOUT(calculado, valor de referencia, tiempo de espera) |
| QTRY_COMPARE_WITH_TIMEOUT(real, esperado, tiempo de espera) | |
| QTRY_VERIFY2(condición, mensaje) | |
| QTRY_VERIFY(condición) | |
| QTRY_VERIFY2_WITH_TIMEOUT(condición, mensaje, tiempo de espera) | |
| QTRY_VERIFY_WITH_TIMEOUT(condición, tiempo de espera) | |
| QVERIFY2(condición, mensaje) | |
| QVERIFY(condición) | |
(since 6.3) | QVERIFY_THROWS_EXCEPTION(tipo de excepción, ...) |
(since 6.3) | QVERIFY_THROWS_NO_EXCEPTION(...) |
Descripción detallada
Consulta la descripción general de «Qt Test » para obtener información sobre cómo escribir pruebas unitarias.
Clases
clase QTouchEventSequence
La clase QTouchEventSequence se utiliza para simular una secuencia de eventos táctiles. Más...
clase QTouchEventWidgetSequence
La clase QTouchEventWidgetSequence se utiliza para simular una secuencia de eventos táctiles para un widget. Más...
clase ThrowOnFailDisabler
clase ThrowOnFailEnabler
clase ThrowOnSkipDisabler
clase ThrowOnSkipEnabler
Documentación de tipos
enum QTest::KeyAction
Esta enumeración describe las posibles acciones para la gestión de claves.
| Constante | Valor | Descripción |
|---|---|---|
QTest::Press | 0 | Se pulsa la tecla. |
QTest::Release | 1 | Se suelta la tecla. |
QTest::Click | 2 | Se pulsa la tecla (se pulsa y se suelta). |
QTest::Shortcut | 3 | Se activa un atajo de teclado. Este valor se ha añadido en Qt 5.6. |
enum QTest::MouseAction
Esta enumeración describe las posibles acciones relacionadas con el manejo del ratón.
| Constante | Valor | Descripción |
|---|---|---|
QTest::MousePress | 0 | Se pulsa un botón del ratón. |
QTest::MouseRelease | 1 | Se suelta un botón del ratón. |
QTest::MouseClick | 2 | Se hace clic con el ratón (se pulsa y se suelta). |
QTest::MouseDClick | 3 | Se hace doble clic con el ratón (se pulsa y se suelta dos veces). |
QTest::MouseMove | 4 | El puntero del ratón se ha movido. |
enum QTest::QBenchmarkMetric
Esta enumeración recoge todos los elementos que se pueden someter a pruebas de rendimiento.
| Constante | Valor | Descripción |
|---|---|---|
QTest::FramesPerSecond | 0 | Fotogramas por segundo |
QTest::BitsPerSecond | 1 | Bits por segundo |
QTest::BytesPerSecond | 2 | Bytes por segundo |
QTest::WalltimeMilliseconds | 3 | Tiempo de reloj en milisegundos |
QTest::WalltimeNanoseconds | 7 | Tiempo de reloj en nanosegundos |
QTest::BytesAllocated | 8 | Uso de memoria en bytes |
QTest::Events | 6 | Recuento de eventos |
QTest::CPUTicks | 4 | Tiempo de CPU |
QTest::CPUMigrations | 9 | Migraciones de procesos entre CPU |
QTest::CPUCycles | 10 | Ciclos de CPU |
QTest::RefCPUCycles | 30 | Ciclos de CPU de referencia |
QTest::BusCycles | 11 | Ciclos de bus |
QTest::StalledCycles | 12 | Ciclos en espera |
QTest::InstructionReads | 5 | Lecturas de instrucciones |
QTest::Instructions | 13 | Instrucciones ejecutadas |
QTest::BranchInstructions | 14 | Instrucciones de tipo de ramificación |
QTest::BranchMisses | 15 | Instrucciones de salto mal predichas |
QTest::CacheReferences | 16 | Accesos a la caché de cualquier tipo |
QTest::CacheMisses | 20 | Errores de caché de cualquier tipo |
QTest::CacheReads | 17 | Lecturas/cargas de caché |
QTest::CacheReadMisses | 21 | Fallos de lectura/carga en caché |
QTest::CacheWrites | 18 | Escrituras o almacenamientos en caché |
QTest::CacheWriteMisses | 22 | Fallos de escritura o almacenamiento en caché |
QTest::CachePrefetches | 19 | Prelecturas de caché |
QTest::CachePrefetchMisses | 23 | Fallos en la precarga de caché |
QTest::ContextSwitches | 24 | Cambios de contexto |
QTest::PageFaults | 25 | Fallos de página de cualquier tipo |
QTest::MinorPageFaults | 26 | Fallos de página menores |
QTest::MajorPageFaults | 27 | Fallos de página graves |
QTest::AlignmentFaults | 28 | Fallos causados por desalineación |
QTest::EmulationFaults | 29 | Fallos que requirieron emulación por software |
Ten en cuenta que WalltimeNanoseconds y BytesAllocated solo están disponibles para su uso a través de setBenchmarkResult(), y que los resultados de esas métricas no pueden ser proporcionados automáticamente por el marco QTest.
Véase también QTest::benchmarkMetricName() y QTest::benchmarkMetricUnit().
enum QTest::TestFailMode
Esta enumeración describe los modos para gestionar una comprobación —por ejemplo, mediante las macros QVERIFY() o QCOMPARE()— que se sabe que va a fallar. El modo se aplica independientemente de si la comprobación falla o se supera.
| Constante | Valor | Descripción |
|---|---|---|
QTest::Abort | 1 | Interrumpe la ejecución de la prueba. Utiliza este modo cuando no tenga sentido continuar ejecutando la prueba tras la comprobación problemática. |
QTest::Continue | 2 | Continúa la ejecución de la prueba tras la comprobación problemática. |
Véase también QEXPECT_FAIL().
Documentación de variables
[since 6.11] std::atomic<std::chrono::milliseconds> QTest::defaultTryTimeout
Esta variable global almacena el tiempo de espera predeterminado que utilizan las funciones QTRY_* y qWait.
El caso de uso más habitual de esta variable es modificar el tiempo de espera de toda una prueba:
using namespace std::chrono_literals;
// Since the atomic itself (defaultTryTimeout) is the only data,
// all reads and stores can be relaxed.
QTest::defaultTryTimeout.store(1s, std::memory_order_relaxed);Sin embargo, también se puede establecer para un ámbito específico, utilizando QAtomicScopedValueRollback:
const auto timeoutRollback = QAtomicScopedValueRollback(
QTest::defaultTryTimeout, 1s, std::memory_order_relaxed);Para acceder al valor, llama a load():
// Since the atomic itself is all the data, all reads and stores can be relaxed.
QCOMPARE(QTest::defaultTryTimeout.load(std::memory_order_relaxed), 1s);Esta variable se introdujo en Qt 6.11.
Documentación de la función
template <typename T> void QTest::addColumn(const char *name, T *dummy = 0)
Añade una columna de tipo « T » a los datos de prueba actuales. « name » es el nombre de la columna. « dummy » es una solución alternativa para compiladores defectuosos y puede ignorarse.
Para rellenar la columna con valores, se puede utilizar newRow(). Utiliza QFETCH() para recuperar los datos en la prueba propiamente dicha.
Ejemplo:
QTest::addColumn<int>("intval");
QTest::addColumn<QString>("str");
QTest::addColumn<double>("dbl");
QTest::newRow("row1") << 1 << "hello" << 1.5;Nota: Esta función solo se puede invocar como parte de la función de datos de una prueba que sea llamada por el marco de pruebas.
Consulta «Pruebas basadas en datos » para ver un ejemplo más detallado.
Véase también QTest::newRow(), QFETCH() y QMetaType.
QTestData &QTest::addRow(const char *format, ...)
Añade una nueva fila a los datos de prueba actuales.
Los argumentos de la función se pasan a std::snprintf() para su formateo según format. Consulte la documentación de std::snprintf() para conocer las advertencias y limitaciones.
La salida de la prueba identificará la ejecución de la prueba con estos datos de prueba utilizando el nombre resultante de este formato.
Devuelve una referencia a QTestData que se puede utilizar para introducir datos, un valor por cada columna de la tabla.
Ejemplo:
QTest::addColumn<int>("input");
QTest::addColumn<QString>("output");
QTest::addRow("%d", 0) << 0 << QString("0");
QTest::addRow("%d", 1) << 1 << QString("1");Nota: Esta función solo puede invocarse como parte de la función de datos de una prueba que sea llamada por el marco de pruebas.
Consulte «Pruebas basadas en datos » para ver un ejemplo más detallado.
Véanse también newRow(), addColumn() y QFETCH().
const char *QTest::benchmarkMetricName(QTest::QBenchmarkMetric metric)
Devuelve el valor de la enumeración « metric » como cadena de caracteres.
const char *QTest::benchmarkMetricUnit(QTest::QBenchmarkMetric metric)
Devuelve las unidades de medida del ` metric` especificado.
QPointingDevice *QTest::createTouchDevice(QInputDevice::DeviceType devType = QInputDevice::DeviceType::TouchScreen, QInputDevice::Capabilities caps = QInputDevice::Capability::Position)
Crea un dispositivo táctil ficticio de tipo ` devType ` con las capacidades ` caps ` para la simulación de eventos táctiles.
El dispositivo táctil se registrará en la interfaz del sistema de ventanas de Qt. Por lo general, se recomienda utilizar createTouchDevice() para inicializar una variable miembro de tipo QPointingDevice en la clase de tu caso de prueba, utilizar la misma instancia para todas las pruebas y eliminarla cuando ya no sea necesaria.
Véanse también QTest::QTouchEventSequence y touchEvent().
const char *QTest::currentAppName()
Devuelve el nombre del archivo binario que se está ejecutando en ese momento.
const char *QTest::currentDataTag()
Devuelve el nombre de los datos de prueba actuales. Si a la prueba no se le han asignado datos de prueba, la función devuelve « nullptr ».
[since 6.11] const char *QTest::currentGlobalDataTag()
Devuelve el nombre de los datos de prueba globales actuales. Si la prueba no tiene asignados datos de prueba globales, la función devuelve « nullptr ».
Esta función se introdujo en Qt 6.11.
bool QTest::currentTestFailed()
Devuelve « true » si la función de prueba actual ha fallado; en caso contrario, devuelve «false».
Véase también QTest::currentTestResolved().
const char *QTest::currentTestFunction()
Devuelve el nombre de la función de prueba que se está ejecutando en ese momento.
Ejemplo:
void MyTestClass::cleanup()
{
if (qstrcmp(QTest::currentTestFunction(), "myDatabaseTest") == 0) {
// clean up all database connections
closeAllDatabases();
}
}[since 6.5] bool QTest::currentTestResolved()
Devuelve ` true ` si la función de prueba actual ha fallado o se ha omitido.
Esto se aplica si la prueba ha fallado o se ha saltado. Cuando el valor es verdadero, la función de prueba debe salir anticipadamente. En concreto, las macros QTRY_* y el bucle de eventos de prueba terminan sus bucles antes de tiempo si se ejecutan durante la función de prueba (pero no durante su cleanup()). Después de que una prueba haya llamado a una función auxiliar que utilice las macros de este módulo, puede utilizar esta función para comprobar si debe salir antes de tiempo.
Esta función se introdujo en Qt 6.5.
Véase también QTest::currentTestFailed().
[since 6.3] void QTest::failOnWarning(const QRegularExpression &messagePattern)
Añade un fallo de prueba al registro de pruebas por cada advertencia que coincida con messagePattern.
La función de prueba continuará ejecutándose cuando se añada un fallo. Para abortar la prueba, puedes comprobar currentTestFailed() y salir anticipadamente si el resultado es true.
Por cada advertencia, el primer patrón que coincida provocará un fallo, y los patrones restantes se ignorarán.
Todos los patrones se borran al final de cada función de prueba.
void FileTest::loadFiles()
{
QTest::failOnWarning(QRegularExpression("^Error al cargar"));
// Cada uno de estos provocará un fallo en la prueba:
qWarning() << "Failed to load image";
qWarning() << "Failed to load video";
}Para que fallen todas las pruebas que activen una advertencia determinada, pasa una expresión regular adecuada a esta función en init():
void FileTest::init()
{
QTest::failOnWarning(
QRegularExpression("QFile::.*: File(.*) already open"));
}En el caso habitual de que falle ante cualquier advertencia, no se debe pasar ningún parámetro:
void FileTest::init()
{
QTest::failOnWarning();
}Nota: ` ignoreMessage()` tiene prioridad sobre esta función, por lo que se ignorarán todas las advertencias que coincidan con un patrón especificado tanto en ` ignoreMessage() ` como en ` failOnWarning() `.
Esta función se introdujo en Qt 6.3.
Véase también QTEST_FATAL_FAIL.
[since 6.8] void QTest::failOnWarning()
Añade un fallo de prueba al registro de pruebas si se muestra alguna advertencia.
Esta función sobrecarga ` QTest::failOnWarning()`.
Esta función se introdujo en Qt 6.8.
Véase también ` failOnWarning(const char *)`.
[since 6.3] void QTest::failOnWarning(const char *message)
Añade un fallo de prueba al registro de pruebas si se genera el error « message ».
Esta función sobrecarga QTest::failOnWarning().
Esta función se introdujo en Qt 6.3.
Véase también failOnWarning().
void QTest::ignoreMessage(QtMsgType type, const char *message)
Ignora los mensajes generados por qDebug(), qInfo() o qWarning(). Si se muestra el message con el type correspondiente, se eliminará del registro de pruebas. Si la prueba ha finalizado y no se ha mostrado el message, se añadirá un fallo de prueba al registro de pruebas.
Nota: Al invocar esta función solo se ignorará un mensaje. Si el mensaje que deseas ignorar se muestra dos veces, también tendrás que llamar a ignoreMessage() dos veces.
Ejemplo:
QDir dir;
QTest::ignoreMessage(QtWarningMsg, "QDir::mkdir: Empty or null file name(s)");
dir.mkdir("");El ejemplo anterior comprueba que QDir::mkdir() genere la advertencia correcta cuando se invoca con un nombre de archivo no válido.
Nota: message se interpretará como UTF-8.
void QTest::ignoreMessage(QtMsgType type, const QRegularExpression &messagePattern)
Ignora los mensajes generados por qDebug(), qInfo() o qWarning(). Si se muestra el mensaje que coincide con messagePattern y con el type correspondiente, se eliminará del registro de pruebas. Si la prueba ha finalizado y el mensaje no se ha mostrado, se añadirá un fallo de prueba al registro de pruebas.
Nota: Al invocar esta función solo se ignorará un mensaje. Si el mensaje que deseas ignorar se muestra dos veces, también tendrás que llamar a `ignoreMessage()` dos veces.
Esta es una función sobrecargada.
void QTest::keyClick(QWidget *widget, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)
Simula hacer clic en key con un modifier opcional en widget. Si delay es mayor que 0, la prueba esperará delay milisegundos antes de pulsar la tecla.
Ejemplos:
QTest::keyClick(myWidget, Qt::Key_Escape);
QTest::keyClick(myWidget, Qt::Key_Escape, Qt::ShiftModifier, 200);El primer ejemplo anterior simula pulsar la tecla escape en myWidget sin ningún modificador de teclado y sin retardo. El segundo ejemplo simula pulsar shift-escape en myWidget tras un retardo de 200 ms en la prueba.
Véase también QTest::keyClicks().
void QTest::keyClick(QWidget *widget, char key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)
Simula hacer clic en key con un modifier opcional en widget. Si delay es mayor que 0, la prueba esperará delay milisegundos antes de pulsar la tecla.
Ejemplo:
QTest::keyClick(myWidget, 'a');El ejemplo anterior simula hacer clic en a en myWidget sin ningún modificador de teclado y sin retraso en la prueba.
Esta es una función sobrecargada.
Véase también QTest::keyClicks().
void QTest::keyClick(QWindow *window, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)
Simula hacer clic en key con un modifier opcional en window. Si delay es mayor que 0, la prueba esperará delay milisegundos antes de pulsar la tecla.
Ejemplos:
QTest::keyClick(&myWindow, Qt::Key_Escape);
QTest::keyClick(&myWindow, Qt::Key_Escape, Qt::ShiftModifier, 200);El primer ejemplo anterior simula pulsar la tecla escape en myWindow sin ningún modificador de teclado y sin retraso. El segundo ejemplo simula pulsar shift-escape en myWindow tras un retraso de 200 ms en la prueba.
Se trata de una función sobrecargada.
Véase también QTest::keyClicks().
void QTest::keyClick(QWindow *window, char key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)
Simula hacer clic en key con un modifier opcional en window. Si delay es mayor que 0, la prueba esperará delay milisegundos antes de pulsar la tecla.
Ejemplo:
QWidget myWindow;
QTest::keyClick(&myWindow, Qt::Key_Tab);El ejemplo anterior simula hacer clic en a en myWindow sin ningún modificador de teclado y sin retraso en la prueba.
Esta es una función sobrecargada.
Véase también QTest::keyClicks().
void QTest::keyClicks(QWidget *widget, const QString &sequence, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)
Simula pulsar una « sequence » de teclas en un « widget ». Opcionalmente, se puede especificar un « modifier » del teclado, así como un « delay » (en milisegundos) de la prueba antes de cada pulsación de tecla.
Ejemplo:
QTest::keyClicks(myWidget, "hello world");El ejemplo anterior simula pulsar la secuencia de teclas que representa «hello world» en myWidget sin ningún modificador de teclado y sin retardo de la prueba.
Véase también QTest::keyClick().
void QTest::keyEvent(QTest::KeyAction action, QWidget *widget, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)
Envía un evento de tecla de Qt a widget con el key indicado y un action asociado. Opcionalmente, se puede especificar un modifier de teclado, así como un delay (en milisegundos) de la prueba antes de enviar el evento.
void QTest::keyEvent(QTest::KeyAction action, QWidget *widget, char ascii, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)
Envía un evento de tecla de Qt a widget con la tecla indicada ascii y un action asociado. De forma opcional, se puede especificar un modifier del teclado, así como un delay (en milisegundos) de la prueba antes de enviar el evento.
Se trata de una función sobrecargada.
void QTest::keyEvent(QTest::KeyAction action, QWindow *window, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)
Envía un evento de tecla de Qt a window con el key indicado y un action asociado. De forma opcional, se puede especificar un modifier de teclado, así como un delay (en milisegundos) de la prueba antes de enviar el evento.
Se trata de una función sobrecargada.
void QTest::keyEvent(QTest::KeyAction action, QWindow *window, char ascii, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)
Envía un evento de tecla de Qt a window con la tecla indicada ascii y el action asociado. Opcionalmente, se puede especificar un modifier de teclado, así como un delay (en milisegundos) de la prueba antes de enviar el evento.
Se trata de una función sobrecargada.
void QTest::keyPress(QWidget *widget, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)
Simula pulsar una tecla key con un modifier opcional en un widget. Si delay es mayor que 0, la prueba esperará delay milisegundos antes de pulsar la tecla.
Nota: En algún momento deberás soltar la tecla utilizando keyRelease().
Véase también QTest::keyRelease() y QTest::keyClick().
void QTest::keyPress(QWidget *widget, char key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)
Simula pulsar una tecla key con un modifier opcional en un widget. Si delay es mayor que 0, la prueba esperará delay milisegundos antes de pulsar la tecla.
Nota: En algún momento deberás soltar la tecla utilizando ` keyRelease()`.
Esta es una función sobrecargada.
Véase también QTest::keyRelease() y QTest::keyClick().
void QTest::keyPress(QWindow *window, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)
Simula pulsar una tecla key con un valor opcional de modifier en un window. Si delay es mayor que 0, la prueba esperará delay milisegundos antes de pulsar la tecla.
Nota: En algún momento deberás soltar la tecla utilizando keyRelease().
Esta es una función sobrecargada.
Véase también QTest::keyRelease() y QTest::keyClick().
void QTest::keyPress(QWindow *window, char key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)
Simula pulsar una tecla key con un modifier opcional en un window. Si delay es mayor que 0, la prueba esperará delay milisegundos antes de pulsar la tecla.
Nota: En algún momento deberás soltar la tecla utilizando keyRelease().
Esta es una función sobrecargada.
Véase también QTest::keyRelease() y QTest::keyClick().
void QTest::keyRelease(QWidget *widget, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)
Simula la liberación de un ` key ` con un ` modifier ` opcional en un ` widget`. Si ` delay ` es mayor que 0, la prueba esperará ` delay ` milisegundos antes de liberar la clave.
Véase también QTest::keyPress() y QTest::keyClick().
void QTest::keyRelease(QWidget *widget, char key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)
Simula liberar un ` key ` con un ` modifier ` opcional en un ` widget`. Si ` delay ` es mayor que 0, la prueba esperará ` delay ` milisegundos antes de liberar la clave.
Esta es una función sobrecargada.
Véase también QTest::keyClick().
void QTest::keyRelease(QWindow *window, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)
Simula liberar un ` key ` con un ` modifier ` opcional en un ` window`. Si ` delay ` es mayor que 0, la prueba esperará ` delay ` milisegundos antes de liberar la clave.
Esta es una función sobrecargada.
Véase también QTest::keyPress() y QTest::keyClick().
void QTest::keyRelease(QWindow *window, char key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)
Simula la liberación de un ` key ` con un ` modifier ` opcional en un ` window`. Si ` delay ` es mayor que 0, la prueba esperará ` delay ` milisegundos antes de liberar la clave.
Esta es una función sobrecargada.
Véase también QTest::keyClick().
void QTest::keySequence(QWidget *widget, const QKeySequence &keySequence)
Simula la introducción de « keySequence » en « widget ».
Esta es una función sobrecargada.
Véanse también QTest::keyClick() y QTest::keyClicks().
void QTest::keySequence(QWindow *window, const QKeySequence &keySequence)
Simula la introducción de « keySequence » en « window ».
Esta es una función sobrecargada.
Véanse también QTest::keyClick() y QTest::keyClicks().
void QTest::mouseClick(QWidget *widget, Qt::MouseButton button, Qt::KeyboardModifiers modifier = Qt::KeyboardModifiers(), QPoint pos = QPoint(), int delay = -1)
Simula un clic del ratón button con un modifier opcional en un widget. La posición del clic viene definida por pos; la posición por defecto es el centro del widget. Si se especifica delay, la prueba esperará el número de milisegundos indicado antes de pulsar y antes de soltar el botón.
Véase también QTest::mousePress() y QTest::mouseRelease().
void QTest::mouseClick(QWindow *window, Qt::MouseButton button, Qt::KeyboardModifiers stateKey = Qt::KeyboardModifiers(), QPoint pos = QPoint(), int delay = -1)
Simula un clic del ratón button con un modificador opcional stateKey en una ventana window. La posición del clic viene definida por pos; la posición por defecto es el centro de la ventana. Si se especifica delay, la prueba esperará el número de milisegundos indicado antes de pulsar y antes de soltar el botón.
Esta es una función sobrecargada.
Véase también QTest::mousePress() y QTest::mouseRelease().
void QTest::mouseDClick(QWidget *widget, Qt::MouseButton button, Qt::KeyboardModifiers modifier = Qt::KeyboardModifiers(), QPoint pos = QPoint(), int delay = -1)
Simula un doble clic del ratón button con un modifier opcional en un widget. La posición del clic viene definida por pos; la posición por defecto es el centro del widget. Si se especifica delay, la prueba esperará el número de milisegundos indicado antes de cada pulsación y soltar.
Véase también QTest::mouseClick().
void QTest::mouseDClick(QWindow *window, Qt::MouseButton button, Qt::KeyboardModifiers stateKey = Qt::KeyboardModifiers(), QPoint pos = QPoint(), int delay = -1)
Simula un doble clic con el ratón button con un modificador opcional stateKey en un window. La posición del clic viene definida por pos; la posición por defecto es el centro de la ventana. Si se especifica delay, la prueba esperará el número de milisegundos indicado antes de cada pulsación y soltar.
Esta es una función sobrecargada.
Véase también ` QTest::mouseClick()`.
void QTest::mouseMove(QWidget *widget, QPoint pos = QPoint(), int delay = -1)
Mueve el puntero del ratón a una posición widget. Si no se especifica pos, el puntero del ratón se desplaza al centro del widget. Si se indica un tiempo de espera delay (en milisegundos), la prueba esperará ese tiempo antes de mover el puntero del ratón.
void QTest::mouseMove(QWindow *window, QPoint pos = QPoint(), int delay = -1)
Mueve el puntero del ratón a una posición window. Si no se especifica pos, el puntero del ratón se desplaza al centro de la ventana. Si se indica un delay (en milisegundos), la prueba esperará antes de mover el puntero del ratón.
Esta es una función sobrecargada.
void QTest::mousePress(QWidget *widget, Qt::MouseButton button, Qt::KeyboardModifiers modifier = Qt::KeyboardModifiers(), QPoint pos = QPoint(), int delay = -1)
Simula pulsar un botón del ratón button con un modifier opcional en un widget. La posición se define mediante pos; la posición por defecto es el centro del widget. Si se especifica delay, la prueba esperará el número de milisegundos indicado antes de realizar la pulsación.
Véase también QTest::mouseRelease() y QTest::mouseClick().
void QTest::mousePress(QWindow *window, Qt::MouseButton button, Qt::KeyboardModifiers stateKey = Qt::KeyboardModifiers(), QPoint pos = QPoint(), int delay = -1)
Simula pulsar un botón del ratón button con un modificador opcional stateKey en una ventana window. La posición viene definida por pos; la posición por defecto es el centro de la ventana. Si se especifica delay, la prueba esperará el número de milisegundos indicado antes de realizar la pulsación.
Esta es una función sobrecargada.
Véase también QTest::mouseRelease() y QTest::mouseClick().
void QTest::mouseRelease(QWidget *widget, Qt::MouseButton button, Qt::KeyboardModifiers modifier = Qt::KeyboardModifiers(), QPoint pos = QPoint(), int delay = -1)
Simula soltar el botón del ratón button con un tiempo de espera opcional modifier en un widget. La posición en la que se suelta el botón viene definida por pos; la posición por defecto es el centro del widget. Si se especifica delay, la prueba esperará el número de milisegundos indicado antes de soltar el botón; de lo contrario, esperará un tiempo predeterminado (1 ms), que puede anularse mediante argumentos de línea de comandos.
Nota: Si deseas probar un doble clic enviando eventos individualmente, especifica un breve retraso, superior al predeterminado, en ambos eventos de suelta del ratón. La suma de los retrasos para pulsar, soltar, pulsar y soltar debe ser inferior a QStyleHints::mouseDoubleClickInterval(). Pero si no necesitas comprobar el estado entre eventos, es mejor utilizar QTest::mouseDClick().
QSignalSpy doubleClickSpy(target, &TargetClass::doubleClicked);
const QPoint p(1, 2);
QTest::mousePress(&myWindow, Qt::LeftButton, Qt::NoModifier, p);
QVERIFY(target.isPressed());
QTest::mouseRelease(&myWindow, Qt::LeftButton, Qt::NoModifier, p, 10);
QCOMPARE(target.isPressed(), false);
QTest::mousePress(&myWindow, Qt::LeftButton, Qt::NoModifier, p, 10);
QCOMPARE(target.pressCount(), 2);
QTest::mouseRelease(&myWindow, Qt::LeftButton, Qt::NoModifier, p, 10);
QCOMPARE(doubleClickSpy.count(), 1);Véase también QTest::mousePress() y QTest::mouseClick().
void QTest::mouseRelease(QWindow *window, Qt::MouseButton button, Qt::KeyboardModifiers stateKey = Qt::KeyboardModifiers(), QPoint pos = QPoint(), int delay = -1)
Simula soltar el botón del ratón button con un modificador opcional stateKey en un window. La posición en la que se suelta el botón viene definida por pos; la posición por defecto es el centro de la ventana. Si se especifica delay, la prueba esperará el número de milisegundos indicado antes de soltar el botón; de lo contrario, esperará un tiempo predeterminado (1 ms), que puede modificarse mediante argumentos de línea de comandos.
Nota: Si deseas simular un doble clic enviando los eventos de forma individual, especifica un breve retraso, superior al predeterminado, en ambos eventos de suelta del ratón. La suma de los retrasos para pulsar, soltar, pulsar y soltar debe ser inferior a QStyleHints::mouseDoubleClickInterval(). Pero si no necesitas comprobar el estado entre eventos, es mejor utilizar QTest::mouseDClick().
QSignalSpy doubleClickSpy(target, &TargetClass::doubleClicked);
const QPoint p(1, 2);
QTest::mousePress(&myWindow, Qt::LeftButton, Qt::NoModifier, p);
QVERIFY(target.isPressed());
QTest::mouseRelease(&myWindow, Qt::LeftButton, Qt::NoModifier, p, 10);
QCOMPARE(target.isPressed(), false);
QTest::mousePress(&myWindow, Qt::LeftButton, Qt::NoModifier, p, 10);
QCOMPARE(target.pressCount(), 2);
QTest::mouseRelease(&myWindow, Qt::LeftButton, Qt::NoModifier, p, 10);
QCOMPARE(doubleClickSpy.count(), 1);Se trata de una función sobrecargada.
Véase también QTest::mousePress() y QTest::mouseClick().
QTestData &QTest::newRow(const char *dataTag)
Añade una nueva fila a los datos de prueba actuales.
El resultado de la prueba identificará la ejecución de la prueba con estos datos de prueba utilizando el nombre « dataTag ».
Devuelve una referencia a QTestData que se puede utilizar para introducir datos de forma continua, un valor por cada columna de la tabla.
Ejemplo:
void MyTestClass::addSingleStringRows()
{
QTest::addColumn<QString>("aString");
QTest::newRow("just.hello") << QString("hello");
QTest::newRow("a.null.string") << QString();
}Nota: Esta función solo se puede invocar como parte de la función de datos de una prueba que sea llamada por el marco de pruebas.
Consulta «Pruebas basadas en datos » para ver un ejemplo más detallado.
Véanse también addRow(), addColumn() y QFETCH().
int QTest::qExec(QObject *testObject, int argc = 0, char **argv = nullptr)
Ejecuta las pruebas declaradas en testObject. Además, se ejecutan las ranuras privadas initTestCase(), cleanupTestCase(), init() y cleanup(), si existen. Consulta «Creación de una prueba» para obtener más detalles.
Opcionalmente, se pueden proporcionar los argumentos de línea de comandos argc y argv. Para obtener una lista de los argumentos reconocidos, consulta «Argumentos de línea de comandos deQt Test ».
El siguiente ejemplo ejecutará todas las pruebas de MyTestObject:
MyTestObject test1;
QTest::qExec(&test1);Esta función devuelve 0 si ninguna prueba ha fallado, o un valor distinto de 0 si una o más pruebas han fallado o en caso de excepciones no gestionadas. (Las pruebas omitidas no influyen en el valor devuelto.)
Para aplicaciones de prueba independientes, se puede utilizar la macro de conveniencia QTEST_MAIN() para declarar una función main() que analice los argumentos de la línea de comandos y ejecute las pruebas, evitando así la necesidad de llamar a esta función de forma explícita.
El valor de retorno de esta función es también el código de salida de la aplicación de pruebas cuando se utiliza la macro QTEST_MAIN().
En el caso de aplicaciones de prueba independientes, esta función no debe llamarse más de una vez, ya que las opciones de la línea de comandos para registrar la salida de las pruebas en archivos y ejecutar funciones de prueba individuales no funcionarán correctamente.
Nota: Esta función no es reentrante; solo puede ejecutarse una prueba a la vez. Una prueba que se haya ejecutado con `qExec()` no puede ejecutar otra prueba mediante `qExec()`, y no se permite que los hilos llamen a `qExec()` simultáneamente.
Si ha creado los argumentos mediante programación, en lugar de obtenerlos de los argumentos de ` main()`, es probable que le interese utilizar `QTest::qExec(QObject *, const QStringList &)`, ya que es compatible con Unicode.
Véanse también QTEST_MAIN(), QTEST_GUILESS_MAIN() y QTEST_APPLESS_MAIN().
int QTest::qExec(QObject *testObject, const QStringList &arguments)
Se comporta exactamente igual que qExec(QObject *, int, char**), pero toma un QStringList e de arguments en lugar de una lista de char**.
Se trata de una función sobrecargada.
QSharedPointer<QTemporaryDir> QTest::qExtractTestData(const QString &dirName)
Extrae un directorio de los recursos al disco. El contenido se extrae de forma recursiva a una carpeta temporal. El contenido extraído se elimina automáticamente una vez que la última referencia al valor de retorno queda fuera de ámbito.
dirName es el nombre del directorio que se va a extraer de los recursos.
Devuelve el directorio temporal donde se han extraído los datos o `null` en caso de error.
[since 6.5] void QTest::qRegisterTestCase(const QString &name, QTest::TestEntryFunction entryFunction)
Registra la prueba « name », con la función de entrada « entryFunction », en un registro central de casos de prueba para el binario actual.
El name aparecerá en la lista al ejecutar el binario de prueba por lotes sin parámetros. Al ejecutar el binario de prueba con el argumento argv[1] de name, se llamará a entryFunction.
Esta función se introdujo en Qt 6.5.
[since 6.7] void QTest::qSleep(std::chrono::milliseconds msecs)
Entra en estado de espera durante msecs, lo que bloquea la ejecución de la prueba.
Este método no procesará ningún evento y hará que la prueba no responda. La comunicación de red podría agotar el tiempo de espera mientras se está en modo de espera. Utiliza QTest::qWait() para realizar una espera no bloqueante.
msecs Debe ser mayor que 0 ms.
Nota: A partir de Qt 6.7, esta función se implementa utilizando ` std::this_thread::sleep_for`, por lo que la precisión del tiempo transcurrido depende de la implementación de la biblioteca estándar. Antes de Qt 6.7, esta función llamaba a ` nanosleep() ` en Unix o a ` Sleep() ` en Windows, por lo que la precisión del tiempo transcurrido en esta función dependía del sistema operativo.
Ejemplo:
using namespace std::chrono_literals;
QTest::qSleep(250ms);Esta función se introdujo en Qt 6.7.
Véase también QTest::qWait().
void QTest::qSleep(int ms)
Permanece inactivo durante ms milisegundos, bloqueando la ejecución de la prueba.
Equivalente a llamar a:
QTest::qSleep(std::chrono::milliseconds{ms});Esta es una función sobrecargada.
[since 6.7] void QTest::qWait(std::chrono::milliseconds msecs)
Espera a que se complete la operación « msecs ». Mientras se espera, se procesarán los eventos y tu prueba seguirá respondiendo a los eventos de la interfaz de usuario o a la comunicación de red.
Ejemplo:
using namespace std::chrono_literals;
int i = 0;
while (myNetworkServerNotResponding() && i++ < 50)
QTest::qWait(250ms);El código anterior esperará hasta que el servidor de red responda durante un máximo de unos 12,5 segundos.
Las macros QTRY_* suelen ser una mejor opción que qWait(). qWait() siempre se detiene durante todo el tiempo de espera, lo que puede dejar la prueba inactiva y ralentizar la ejecución.
Las macros « QTRY_* » comprueban la condición hasta que se cumple o se agota el tiempo de espera. De este modo, tu prueba continúa lo antes posible y resulta más fiable. Si la condición sigue fallando, las macros duplican el tiempo de espera una vez e informan del nuevo valor para que puedas ajustarlo.
Por ejemplo, reescribe el código anterior de la siguiente manera:
QTRY_VERIFY_WITH_TIMEOUT(!myNetworkServerNotResponding(), 12.5s);Esta función se introdujo en Qt 6.7.
Véase también QTest::qSleep(), QSignalSpy::wait() y QTRY_VERIFY_WITH_TIMEOUT().
void QTest::qWait(int msecs)
Espera a que se ejecute ` msecs`. Equivale a llamar a:
QTest::qWait(std::chrono::milliseconds{msecs});Esta es una función sobrecargada.
[since 6.7] template <typename Functor> bool QTest::qWaitFor(Functor predicate, QDeadlineTimer deadline = QDeadlineTimer(
defaultTryTimeout.load(std::memory_order_relaxed)))
Espera hasta que haya caducado deadline o hasta que predicate devuelva «true», lo que ocurra primero.
Devuelve true si predicate ha devuelto «true» en algún momento; en caso contrario, devuelve false.
Ejemplo:
MyObject obj;
obj.startup();
using namespace std::chrono_literals;
const bool result = QTest::qWaitFor([&obj]() { return obj.isReady(); },
QDeadlineTimer(3s));El código anterior esperará a que el objeto esté listo, durante un máximo de tres segundos.
Esta función se introdujo en Qt 6.7.
template <typename Functor> bool QTest::qWaitFor(Functor predicate, int timeout)
Espera un timeout milisegundos o hasta que la función « predicate » devuelva «true».
Esto equivale a llamar a:
qWaitFor(predicate, QDeadlineTimer(timeout));Esta es una función sobrecargada.
[since 6.10] bool QTest::qWaitForWindowActive(QWidget *widget, QDeadlineTimer timeout)
Devuelve ` true ` si ` widget ` está activo en un plazo de ` timeout ` milisegundos. En caso contrario, devuelve ` false`.
Este método resulta útil en pruebas que llaman a ` QWidget::show()` y dependen de que el widget esté realmente activo (es decir, que sea visible y tenga el foco) antes de continuar.
Nota: El método agotará el tiempo de espera y devolverá false si otra ventana impide que widget se active.
Nota: Dado que el foco es una propiedad exclusiva, « widget » puede perderlo en favor de otra ventana en cualquier momento, incluso después de que el método haya devuelto « true ».
Esta función se introdujo en Qt 6.10.
Véase también qWaitForWindowExposed() y QWidget::isActiveWindow().
[since 6.10] bool QTest::qWaitForWindowActive(QWindow *window, QDeadlineTimer timeout)
Devuelve ` true` si ` window ` está activa dentro de ` timeout`. En caso contrario, devuelve ` false`.
Este método resulta útil en pruebas que llaman a ` QWindow::show()` y dependen de que la ventana esté realmente activa (es decir, que sea visible y tenga el foco) antes de continuar.
Nota: El método agotará el tiempo de espera y devolverá false si otra ventana impide que window se active.
Nota: Dado que el foco es una propiedad exclusiva, ` window ` puede perder su foco en favor de otra ventana en cualquier momento, incluso después de que el método haya devuelto ` true`.
Esta función se introdujo en Qt 6.10.
Véase también qWaitForWindowExposed(), qWaitForWindowFocused() y QWindow::isActive().
[since 6.10] bool QTest::qWaitForWindowActive(QWidget *widget)
Esta función utiliza el tiempo de espera predeterminado de 5 segundos.
Se trata de una función sobrecargada.
Esta función se introdujo en Qt 6.10.
[since 6.10] bool QTest::qWaitForWindowActive(QWindow *window)
Esta función utiliza el tiempo de espera predeterminado de 5 segundos.
Se trata de una función sobrecargada.
Esta función se introdujo en Qt 6.10.
bool QTest::qWaitForWindowActive(QWidget *widget, int timeout)
La función « timeout » se expresa en milisegundos.
Se trata de una función sobrecargada.
bool QTest::qWaitForWindowActive(QWindow *window, int timeout)
La función « timeout » se expresa en milisegundos.
Se trata de una función sobrecargada.
[since 6.10] bool QTest::qWaitForWindowExposed(QWidget *widget, QDeadlineTimer timeout)
Devuelve ` true ` si ` widget ` queda visible en un plazo de ` timeout ` milisegundos. En caso contrario, devuelve ` false`.
Este método resulta útil en pruebas que llaman a QWidget::show() y dependen de que el widget esté realmente visible antes de continuar.
Nota: Es posible queuna ventana asignada a la pantalla no se considere expuesta si el área de cliente de la ventana no es visible, por ejemplo, porque está completamente cubierta por otras ventanas. En tales casos, el método agotará el tiempo de espera y devolverá ` false`.
Esta función se introdujo en Qt 6.10.
Véase también qWaitForWindowActive(), QWidget::isVisible() y QWindow::isExposed().
[since 6.10] bool QTest::qWaitForWindowExposed(QWindow *window, QDeadlineTimer timeout)
Devuelve ` true` si ` window ` está visible en ` timeout`. En caso contrario, devuelve ` false`.
Este método resulta útil en pruebas que llaman a ` QWindow::show()` y dependen de que la ventana esté realmente visible antes de continuar.
Nota: Es posible queuna ventana asignada a la pantalla no se considere expuesta si el área de cliente de la ventana no es visible, por ejemplo, porque está completamente cubierta por otras ventanas. En tales casos, el método agotará el tiempo de espera y devolverá false.
Esta función se introdujo en Qt 6.10.
Véase también qWaitForWindowActive() y QWindow::isExposed().
[since 6.10] bool QTest::qWaitForWindowExposed(QWidget *widget)
Esta función utiliza el tiempo de espera predeterminado de 5 segundos.
Se trata de una función sobrecargada.
Esta función se introdujo en Qt 6.10.
[since 6.10] bool QTest::qWaitForWindowExposed(QWindow *window)
Esta función utiliza el tiempo de espera predeterminado de 5 segundos.
Se trata de una función sobrecargada.
Esta función se introdujo en Qt 6.10.
bool QTest::qWaitForWindowExposed(QWidget *widget, int timeout)
La función « timeout » se expresa en milisegundos.
Se trata de una función sobrecargada.
bool QTest::qWaitForWindowExposed(QWindow *window, int timeout)
La función « timeout » se expresa en milisegundos.
Se trata de una función sobrecargada.
[since 6.7] bool QTest::qWaitForWindowFocused(QWidget *widget, QDeadlineTimer timeout)
Devuelve ` true` si ` widget ` es la ventana con el foco dentro de ` timeout`. En caso contrario, devuelve ` false`.
Este método resulta útil en pruebas que invocan a ` QWidget::show()` y dependen de que el widget tenga el foco (por ejemplo, para recibir eventos del teclado) antes de continuar.
Nota: El método agotará el tiempo de espera y devolverá ` false ` si otra ventana impide que ` widget ` obtenga el foco.
Nota: Dado que el foco es una propiedad exclusiva, widget puede perder el foco en favor de otra ventana en cualquier momento, incluso después de que el método haya devuelto true.
Esta función se introdujo en Qt 6.7.
Véase también qWaitForWindowExposed(), qWaitForWindowActive() y QGuiApplication::focusWindow().
[since 6.7] bool QTest::qWaitForWindowFocused(QWindow *window, QDeadlineTimer timeout)
Devuelve ` true` si ` window ` es la ventana con el foco dentro de ` timeout`. En caso contrario, devuelve ` false`.
Este método resulta útil en pruebas que llaman a ` QWindow::show()` y dependen de que la ventana tenga el foco (por ejemplo, para recibir eventos del teclado) antes de continuar.
Nota: El método agotará el tiempo de espera y devolverá false si otra ventana impide que window obtenga el foco.
Nota: Dado que el foco es una propiedad exclusiva, ` window ` puede perderlo en favor de otra ventana en cualquier momento, incluso después de que el método haya devuelto ` true`.
Esta función se introdujo en Qt 6.7.
Véase también qWaitForWindowExposed(), qWaitForWindowActive() y QGuiApplication::focusWindow().
[since 6.10] bool QTest::qWaitForWindowFocused(QWidget *widget)
Esta función utiliza el tiempo de espera predeterminado de 5 segundos.
Se trata de una función sobrecargada.
Esta función se introdujo en Qt 6.10.
[since 6.10] bool QTest::qWaitForWindowFocused(QWindow *window)
Esta función utiliza el tiempo de espera predeterminado de 5 segundos.
Se trata de una función sobrecargada.
Esta función se introdujo en Qt 6.10.
void QTest::setBenchmarkResult(qreal result, QTest::QBenchmarkMetric metric)
Establece el resultado de referencia de esta función de prueba en result.
Utiliza esta función si deseas informar de los resultados de las pruebas de rendimiento sin utilizar la macro QBENCHMARK. Utiliza metric para especificar cómo debe interpretar los resultados Qt Test.
El contexto del resultado será el nombre de la función de prueba y cualquier etiqueta de datos de la función _data. Esta función solo se puede llamar una vez en cada función de prueba; las llamadas posteriores sustituirán los resultados comunicados anteriormente.
Ten en cuenta que el argumento de línea de comandos -iterations no tiene ningún efecto en las funciones de prueba que no incluyan la macro QBENCHMARK.
[noexcept, since 6.8] void QTest::setThrowOnFail(bool enable)
Activa (enable = true) o desactiva (enable = false) el lanzamiento de excepciones en caso de fallo de QCOMPARE()/QVERIFY() (en lugar de limitarse a salir del contexto de la función inmediatamente circundante).
La función utiliza recuento de referencias: si llamas a esta función N veces con true, tendrás que llamarla N veces con false para volver al punto de partida.
Esta llamada no tiene ningún efecto cuando está definida la macro de C++ ` QTEST_THROW_ON_FAIL `.
Nota: Para utilizar esta característica,debes compilar tus pruebas con las excepciones habilitadas.
Esta función se introdujo en Qt 6.8.
Véase también setThrowOnSkip(), ThrowOnFailEnabler, ThrowOnFailDisabler y QTEST_THROW_ON_FAIL.
[noexcept, since 6.8] void QTest::setThrowOnSkip(bool enable)
Activa (enable = true) o desactiva (enable = false) el lanzamiento de excepciones en QSKIP() (en lugar de limitarse a salir del contexto de la función inmediatamente circundante).
Esta característica cuenta con un contador de referencias: si llamas a esta función N veces con ` true`, tendrás que llamarla N veces con ` false ` para volver al punto de partida.
Esta llamada no tiene ningún efecto cuando está definida la macro de C++ ` QTEST_THROW_ON_SKIP `.
Nota: Debes compilar tus pruebas con las excepciones habilitadas para utilizar esta función.
Esta función se introdujo en Qt 6.8.
Véase también setThrowOnFail(), ThrowOnSkipEnabler, ThrowOnSkipDisabler y QTEST_THROW_ON_SKIP.
char *QTest::toHexRepresentation(const char *ba, qsizetype length)
Devuelve un puntero a una cadena que contiene la cadena ba representada como una secuencia de caracteres hexadecimales separados por espacios. Si la entrada se considera demasiado larga, se trunca. El truncamiento se indica en la cadena devuelta mediante tres puntos suspensivos al final. El autor de la llamada es el propietario del puntero devuelto y debe asegurarse de que posteriormente se pase al operador delete[].
length es la longitud de la cadena ba.
template <typename T> char *QTest::toString(const T &value)
Devuelve una representación textual de value. Esta función la utiliza QCOMPARE() para mostrar información detallada en caso de que falle una prueba.
Puedes añadir especializaciones o sobrecargas de esta función a tu prueba para habilitar la salida detallada.
Nota: A partir de Qt 5.5, es recomendable proporcionar una función toString() en el espacio de nombres del tipo en lugar de especializar esta plantilla. Si tu código necesita seguir funcionando con la biblioteca QTestLib de Qt 5.4 o versiones anteriores, deberás seguir utilizando la especialización.
Nota: Quien llame a toString() debe eliminar los datos devueltos utilizando delete[]. Tu implementación debe devolver una cadena creada con new[] o qstrdup(). La forma más sencilla de hacerlo es crear un QByteArray o un QString y llamar a QTest::toString() sobre él (véase el segundo ejemplo a continuación).
Ejemplo de especialización (Qt ≤ 5.4):
namespace QTest {
template<>
char *toString(const MyPoint &point)
{
const QByteArray ba("MyPoint("
+ QByteArray::number(point.x()) + ", "
+ QByteArray::number(point.y()) + ')');
return qstrdup(ba.data());
}
}El ejemplo anterior define una especialización de toString() para una clase llamada MyPoint. Siempre que falle una comparación entre dos instancias de MyPoint, QCOMPARE() llamará a esta función para mostrar el contenido de MyPoint en el registro de pruebas.
El mismo ejemplo, pero con sobrecarga (Qt ≥ 5.5):
char *toString(const MyPoint &point) // should be inside the same namespace as MyPoint
{
return QTest::toString("MyPoint(" +
QByteArray::number(point.x()) + ", " +
QByteArray::number(point.y()) + ')');
}Véase también QCOMPARE().
char *toString(QSizePolicy sp)
Devuelve una representación textual de la política de tamaño sp.
Esta es una función sobrecargada.
char *toString(QSizePolicy::ControlType ct)
Devuelve una representación textual del tipo de control « ct ».
Esta es una función sobrecargada.
char *toString(QSizePolicy::ControlTypes cts)
Devuelve una representación textual de los tipos de control cts.
Esta es una función sobrecargada.
char *toString(QSizePolicy::Policy p)
Devuelve una representación textual de la política p.
Esta es una función sobrecargada.
char *QTest::toString(const QByteArray &ba)
Devuelve una representación textual de la matriz de bytes ba.
Esta es una función sobrecargada.
Véase también QTest::toHexRepresentation().
char *QTest::toString(const QCborError &c)
Devuelve una representación textual del error CBOR indicado c.
Esta es una función sobrecargada.
char *QTest::toString(const QChar &character)
Devuelve una representación textual del objeto ` character` proporcionado.
Esta es una función sobrecargada.
char *QTest::toString(const QDate &date)
Devuelve una representación textual del objeto ` date` proporcionado.
Esta es una función sobrecargada.
char *QTest::toString(const QDateTime &dateTime)
Devuelve una representación textual de la fecha y la hora especificadas por ` dateTime`.
Esta es una función sobrecargada.
[since 6.5] char *QTest::toString(const QKeySequence &ks)
Devuelve una representación textual de la secuencia de claves « ks ».
Esta es una función sobrecargada.
Esta función se introdujo en Qt 6.5.
char *QTest::toString(const QLatin1StringView &string)
Devuelve una representación textual del ` string` indicado.
Esta es una función sobrecargada.
char *QTest::toString(const QPoint &point)
Devuelve una representación textual de la expresión dada ` point`.
Esta es una función sobrecargada.
char *QTest::toString(const QPointF &point)
Devuelve una representación textual del objeto ` point` dado.
Esta es una función sobrecargada.
char *QTest::toString(const QRect &rectangle)
Devuelve una representación textual del objeto ` rectangle` proporcionado.
Esta es una función sobrecargada.
char *QTest::toString(const QRectF &rectangle)
Devuelve una representación textual del objeto ` rectangle` proporcionado.
Esta es una función sobrecargada.
char *QTest::toString(const QSize &size)
Devuelve una representación textual del ` size` indicado.
Esta es una función sobrecargada.
char *QTest::toString(const QSizeF &size)
Devuelve una representación textual del objeto ` size` proporcionado.
Esta es una función sobrecargada.
char *QTest::toString(const QString &string)
Devuelve una representación textual del objeto ` string` proporcionado.
Esta es una función sobrecargada.
char *QTest::toString(const QStringView &string)
Devuelve una representación textual del objeto ` string` proporcionado.
Esta es una función sobrecargada.
char *QTest::toString(const QTime &time)
Devuelve una representación textual del objeto ` time` proporcionado.
Esta es una función sobrecargada.
char *QTest::toString(const QUrl &url)
Devuelve una representación textual del objeto ` url` dado.
Esta es una función sobrecargada.
char *QTest::toString(const QUuid &uuid)
Devuelve una representación textual del objeto ` uuid` proporcionado.
Esta es una función sobrecargada.
char *QTest::toString(const QVariant &variant)
Devuelve una representación textual del ` variant` indicado.
Esta es una función sobrecargada.
char *QTest::toString(const QVector2D &v)
Devuelve una representación textual del vector bidimensional ` v`.
Esta es una función sobrecargada.
char *QTest::toString(const QVector3D &v)
Devuelve una representación textual del vector 3D ` v`.
Esta es una función sobrecargada.
char *QTest::toString(const QVector4D &v)
Devuelve una representación textual del vector 4D ` v`.
Esta es una función sobrecargada.
template <typename T1, typename T2> char *QTest::toString(const std::pair<T1, T2> &pair)
Devuelve una representación textual de ` pair`.
Esta es una función sobrecargada.
template <typename... Types> char *QTest::toString(const std::tuple<Types...> &tuple)
Devuelve una representación textual del objeto ` tuple` dado.
Esta es una función sobrecargada.
char *QTest::toString(std::nullptr_t)
Devuelve una cadena que contiene « nullptr ».
Esta es una función sobrecargada.
QTest::QTouchEventWidgetSequence QTest::touchEvent(QWidget *widget, QPointingDevice *device, bool autoCommit = true)
Crea y devuelve un ` QTouchEventSequence ` para el ` device ` con el fin de simular eventos para ` widget`.
Al añadir eventos táctiles a la secuencia, también se utilizará ` widget ` para convertir la posición proporcionada en coordenadas de pantalla, a menos que se especifique otro widget en las respectivas llamadas a `press()`, `move()`, etc.
Los eventos táctiles se envían al sistema de eventos cuando se llama al destructor de QTouchEventSequence (es decir, cuando el objeto devuelto sale del ámbito), a menos que autoCommit esté establecido en false. Cuando autoCommit es false, hay que llamar a commit() manualmente.
createTouchDeviceSe puede llamar a () para crear un dispositivo táctil de prueba que se utilice con esta función.
QTest::QTouchEventSequence QTest::touchEvent(QWindow *window, QPointingDevice *device, bool autoCommit = true)
Crea y devuelve un ` QTouchEventSequence ` para el ` device ` con el fin de simular eventos para ` window`.
Al añadir eventos táctiles a la secuencia, también se utilizará ` window ` para convertir la posición proporcionada en coordenadas de pantalla, a menos que se especifique otra ventana en las respectivas llamadas a `press()`, `move()`, etc.
Los eventos táctiles se envían al sistema de eventos cuando se llama al destructor de QTouchEventSequence (es decir, cuando el objeto devuelto sale del ámbito), a menos que autoCommit esté establecido en false. Cuando autoCommit es false, se debe llamar a commit() manualmente.
createTouchDeviceSe puede llamar a () para crear un dispositivo táctil de prueba que se utilice con esta función.
[since 6.8] void QTest::wheelEvent(QWindow *window, QPointF pos, QPoint angleDelta, QPoint pixelDelta = QPoint(0, 0), Qt::KeyboardModifiers stateKey = Qt::NoModifier, Qt::ScrollPhase phase = Qt::NoScrollPhase)
Simula un evento de rueda en « window » en la posición « pos » en coordenadas locales de la ventana. « angleDelta » contiene el ángulo de rotación de la rueda. Un valor positivo indica rotación hacia delante, y uno negativo, hacia atrás. « pixelDelta » contiene la distancia de desplazamiento en píxeles en pantalla. Este valor puede ser nulo. Los estados del teclado en el momento del evento se especifican mediante « stateKey ». La fase de desplazamiento del evento se especifica mediante « phase ».
Esta función se introdujo en Qt 6.8.
Documentación de macros
QBENCHMARK
Esta macro se utiliza para medir el rendimiento del código dentro de una prueba. El código que se va a someter a la prueba de rendimiento se incluye en un bloque de código que sigue a esta macro.
Por ejemplo:
void TestBenchmark::simple()
{
QString str1 = u"This is a test string"_s;
QString str2 = u"This is a test string"_s;
QCOMPARE(str1.localeAwareCompare(str2), 0);
QBENCHMARK {
str1.localeAwareCompare(str2);
}
}Véase también «Creación de una prueba de rendimiento » y «Redacción de una prueba de rendimiento».
QBENCHMARK_ONCE
La macro QBENCHMARK_ONCE sirve para medir el rendimiento de un bloque de código ejecutándolo una sola vez.
Esta macro se utiliza para medir el rendimiento del código dentro de una prueba. El código que se va a someter a la prueba de rendimiento se encuentra dentro de un bloque de código que sigue a esta macro.
A diferencia de QBENCHMARK, el contenido del bloque de código solo se ejecuta una vez. El tiempo transcurrido se indicará como «0» si es demasiado breve para que el backend seleccionado pueda medirlo.
Véase también Creación de una prueba de rendimiento y Escritura de una prueba de rendimiento.
QCOMPARE(actual, expected)
La macro QCOMPARE() compara un valor actual con un valor expected utilizando el operador de igualdad. Si actual y expected coinciden, la ejecución continúa. En caso contrario, se registra un error en el registro de pruebas y la función de prueba retorna sin intentar ninguna comprobación posterior.
Respeta siempre la semántica de los parámetros de QCOMPARE(). El primer parámetro que se le pase debe ser siempre el valor real generado por el código sometido a prueba, mientras que el segundo parámetro debe ser siempre el valor esperado. Cuando los valores no coinciden, QCOMPARE() los muestra con las etiquetas «Actual » y «Esperado». Si se invierte el orden de los parámetros, la depuración de una prueba fallida puede resultar confusa y las pruebas que esperan un valor cero pueden fallar debido a errores de redondeo.
QCOMPARE() intenta mostrar el contenido de los valores si la comparación falla, de modo que en el registro de pruebas se pueda ver por qué ha fallado la comparación.
Ejemplo:
Al comparar tipos de punto flotante (float, double y qfloat16), se utiliza qFuzzyCompare() para valores finitos. Si qFuzzyIsNull() es verdadero para ambos valores, también se consideran iguales. Los valores infinitos coinciden si tienen el mismo signo, y cualquier NaN como valor real coincide con cualquier NaN como valor esperado (aunque NaN ≠ NaN, incluso cuando sean idénticos).
Al comparar QList, se pueden pasar como valor esperado matrices y listas de inicialización del tipo de valor:
const int expected[] = {8, 10, 12, 16, 20, 24};
QCOMPARE(QFontDatabase::standardSizes(), expected);Ten en cuenta que el uso de listas de inicialización requiere definir una macro auxiliar para evitar que el preprocesador interprete las comas como delimitadores de argumentos de macro:
#define ARG(...) __VA_ARGS__
QCOMPARE(QFontDatabase::standardSizes(), ARG({8, 10, 12, 16, 20, 24}));
#undef ARGNota: Esta macro solo se puede utilizar en una función de prueba invocada por el marco de pruebas.
Para tus propias clases, puedes sobrecargar QTest::toString() para dar formato a los valores que se van a mostrar en el registro de pruebas.
Ejemplo:
char *toString(const MyType &t)
{
char *repr = new char[t.reprSize()];
t.writeRepr(repr);
return repr;
}El valor devuelto por ` toString() ` debe ser un ` new char []`. Es decir, deberá liberarse mediante ` delete[] ` (en lugar de ` free() ` o simplemente ` delete`) una vez que el código que lo invoca haya terminado de utilizarlo.
Véanse también QVERIFY(), QTRY_COMPARE(), QTest::toString(), QEXPECT_FAIL(), QCOMPARE_EQ(), QCOMPARE_NE(), QCOMPARE_LT(), QCOMPARE_LE(), QCOMPARE_GT() y QCOMPARE_GE().
[since 6.9] QCOMPARE_3WAY(lhs, rhs, order)
La macro QCOMPARE_3WAY() aplica el operador de comparación de tres vías <=> a las expresiones de entrada lhs y rhs, y comprueba si el resultado es order. Si es cierto, la ejecución continúa. De lo contrario, se registra un error en el registro de pruebas y la función de prueba devuelve un valor sin intentar ninguna comprobación posterior. La macro solo acepta tipos de ordenación Qt:: y std:: como argumento de « order »; de lo contrario, genera una afirmación.
Nota: order puede ser un tipo de ordenación Qt:: incluso si decltype(lhs <=> rhs) es de tipo std. El resultado de la operación decltype(lhs <=> rhs) debe tener la misma fuerza que order. De lo contrario, la aplicación de la macro dará lugar a un error de compilación. Por ejemplo, si el resultado de decltype(lhs <=> rhs) tiene un tipo de ordenación débil, el argumento order no puede tener tipos de ordenación parcial o fuerte.
Nota: La macro solo funciona si el compilador admite el operador <=>; de lo contrario, asertará estáticamente que la característica previa no está disponible. Antes de utilizar la macro, comprueba siempre si está definida __cpp_lib_three_way_comparison y, si no lo está, utiliza QSKIP.
Nota: Esta macro solo se puede utilizar en una función de prueba invocada por el marco de pruebas.
Para tus propias clases, puedes sobrecargar QTest::toString() para dar formato a los valores que se van a mostrar en el registro de pruebas.
Esta macro se introdujo en Qt 6.9.
[since 6.4] QCOMPARE_EQ(computed, baseline)
La macro QCOMPARE_EQ() comprueba que computed sea igual a baseline utilizando el operador de igualdad. Si es cierto, la ejecución continúa. De lo contrario, se registra un error en el registro de pruebas y la función de prueba retorna sin intentar ninguna comprobación posterior.
En general, es similar a llamar a QVERIFY(computed == baseline);, pero, en caso de fallo, muestra un mensaje de error formateado en el que se indican las expresiones y los valores de los argumentos computed y baseline.
Nota: Esta macro solo se puede utilizar en una función de prueba invocada por el marco de pruebas.
Para tus propias clases, puedes sobrecargar ` QTest::toString()` para dar formato a los valores que se enviarán al registro de pruebas.
Nota: A diferencia de QCOMPARE(), esta macro no ofrece sobrecargas para tipos personalizados ni punteros. Por lo tanto, si se pasan, por ejemplo, dos valores de const char * como parámetros, se compararán los punteros, mientras que QCOMPARE() realiza una comparación de cadenas de estilo C.
Esta macro se introdujo en Qt 6.4.
Véase también QCOMPARE(), QCOMPARE_NE(), QCOMPARE_LT(), QCOMPARE_LE(), QCOMPARE_GT() y QCOMPARE_GE().
[since 6.4] QCOMPARE_GE(computed, baseline)
La macro QCOMPARE_GE() comprueba que computed sea al menos igual a baseline utilizando el operador «mayor o igual que». Si la condición es verdadera, la ejecución continúa. De lo contrario, se registra un error en el registro de pruebas y la función de prueba finaliza sin realizar ninguna comprobación posterior.
En general, es similar a llamar a QVERIFY(computed >= baseline);, pero, en caso de fallo, muestra un mensaje de error formateado en el que se indican las expresiones y los valores de los argumentos computed y baseline.
Nota: Esta macro solo se puede utilizar en una función de prueba invocada por el marco de pruebas.
Para tus propias clases, puedes sobrecargar ` QTest::toString()` para dar formato a los valores que se van a mostrar en el registro de pruebas.
Esta macro se introdujo en Qt 6.4.
Véase también QCOMPARE_EQ(), QCOMPARE_NE(), QCOMPARE_LT(), QCOMPARE_LE() y QCOMPARE_GT().
[since 6.4] QCOMPARE_GT(computed, baseline)
La macro QCOMPARE_GT() comprueba que computed sea mayor que baseline utilizando el operador «mayor que». Si la condición se cumple, la ejecución continúa. De lo contrario, se registra un error en el registro de pruebas y la función de prueba retorna sin intentar ninguna comprobación posterior.
En general, es similar a llamar a QVERIFY(computed > baseline);, pero muestra un mensaje de error formateado en el que se indican las expresiones y los valores de los argumentos computed y baseline en caso de fallo.
Nota: Esta macro solo se puede utilizar en una función de prueba invocada por el marco de pruebas.
Para tus propias clases, puedes sobrecargar ` QTest::toString()` para dar formato a los valores que se van a mostrar en el registro de pruebas.
Esta macro se introdujo en Qt 6.4.
Véase también QCOMPARE_EQ(), QCOMPARE_NE(), QCOMPARE_LT(), QCOMPARE_LE() y QCOMPARE_GE().
[since 6.4] QCOMPARE_LE(computed, baseline)
La macro QCOMPARE_LE() comprueba que computed sea como máximo baseline utilizando el operador «menor o igual que». Si se cumple esta condición, la ejecución continúa. De lo contrario, se registra un error en el registro de pruebas y la función de prueba finaliza sin realizar ninguna comprobación posterior.
En general, es similar a llamar a ` QVERIFY(computed <= baseline); `, pero muestra un mensaje de error formateado que indica las expresiones y los valores de los argumentos ` computed ` y ` baseline ` en caso de fallo.
Nota: Esta macro solo se puede utilizar en una función de prueba invocada por el marco de pruebas.
Para tus propias clases, puedes sobrecargar ` QTest::toString()` para dar formato a los valores que se van a mostrar en el registro de pruebas.
Esta macro se introdujo en Qt 6.4.
Véase también QCOMPARE_EQ(), QCOMPARE_NE(), QCOMPARE_LT(), QCOMPARE_GT() y QCOMPARE_GE().
[since 6.4] QCOMPARE_LT(computed, baseline)
La macro QCOMPARE_LT() comprueba que computed sea menor que baseline utilizando el operador «menor que». Si la condición es verdadera, la ejecución continúa. De lo contrario, se registra un error en el registro de pruebas y la función de prueba retorna sin intentar ninguna comprobación posterior.
En general, es similar a llamar a QVERIFY(computed < baseline);, pero muestra un mensaje de error formateado en el que se indican las expresiones y los valores de los argumentos computed y baseline en caso de fallo.
Nota: Esta macro solo puede utilizarse en una función de prueba invocada por el marco de pruebas.
Para tus propias clases, puedes sobrecargar ` QTest::toString()` para dar formato a los valores que se mostrarán en el registro de pruebas.
Esta macro se introdujo en Qt 6.4.
Véase también QCOMPARE_EQ(), QCOMPARE_NE(), QCOMPARE_LE(), QCOMPARE_GT() y QCOMPARE_GE().
[since 6.4] QCOMPARE_NE(computed, baseline)
La macro QCOMPARE_NE() comprueba que computed no sea igual a baseline utilizando el operador de desigualdad. Si la condición se cumple, la ejecución continúa. De lo contrario, se registra un error en el registro de pruebas y la función de prueba finaliza sin intentar ninguna comprobación posterior.
En general, es similar a llamar a ` QVERIFY(computed != baseline); `, pero muestra un mensaje de error formateado en el que se indican las expresiones y los valores de los argumentos ` computed ` y ` baseline ` en caso de fallo.
Nota: Esta macro solo se puede utilizar en una función de prueba invocada por el marco de pruebas.
Para tus propias clases, puedes sobrecargar ` QTest::toString()` para dar formato a los valores que se van a mostrar en el registro de pruebas.
Esta macro se introdujo en Qt 6.4.
Véase también QCOMPARE_EQ(), QCOMPARE_LT(), QCOMPARE_LE(), QCOMPARE_GT() y QCOMPARE_GE().
QEXPECT_FAIL(dataIndex, comment, mode)
La macro QEXPECT_FAIL() marca la siguiente llamada a QCOMPARE() o QVERIFY() como un fallo esperado. En lugar de añadir un fallo al registro de pruebas, se notificará un fallo esperado.
Si una llamada a QVERIFY() o QCOMPARE() está marcada como un fallo esperado, pero en realidad se supera la prueba, se registra un «superado inesperado» (XPASS) en el registro de pruebas y se contabilizará como un fallo de la prueba.
El parámetro dataIndex describe para qué entrada de los datos de prueba se espera el fallo. Pasa una cadena vacía ("") si se espera el fallo para todas las entradas o si no existen datos de prueba.
comment Se añadirá al registro de pruebas para el fallo esperado.
mode es un QTest::TestFailMode y establece si la prueba debe continuar ejecutándose o no. El mode se aplica independientemente de si se produce o no el fallo esperado en la prueba.
Nota: Esta macro solo se puede utilizar en una función de prueba invocada por el marco de pruebas.
Ejemplo 1:
QEXPECT_FAIL("", "Will fix in the next release", Continue);
QCOMPARE(i, 42);
QCOMPARE(j, 43);En el ejemplo anterior, se registrará un fallo esperado en la salida de la prueba si la variable i no es 42. Si la variable i es 42, se registrará en su lugar un éxito inesperado. La función QEXPECT_FAIL() no influye en la segunda instrucción QCOMPARE() del ejemplo.
Ejemplo 2:
QEXPECT_FAIL("data27", "Oh my, this is soooo broken", Abort);
QCOMPARE(i, 42);La función de prueba anterior no continuará ejecutándose para la entrada de datos de prueba data27 (independientemente del valor de i).
Véase también QTest::TestFailMode, QVERIFY() y QCOMPARE().
QFAIL(message)
Esta macro se puede utilizar para forzar un fallo en la prueba. La prueba deja de ejecutarse y se añade el mensaje de error « message » al registro de la prueba.
Nota: Esta macro solo se puede utilizar en una función de prueba invocada por el marco de pruebas.
Ejemplo:
if (sizeof(int) != 4)
QFAIL("This test has not been ported to this platform yet.");QFETCH(type, name)
La macro «fetch» crea en la pila una variable local denominada « name » con el tipo « type ». Los valores « name » y « type » deben coincidir con una columna de la tabla de datos de la prueba. Se comprueba que esto sea así y la prueba se interrumpirá si la comprobación falla.
Supongamos que una prueba tiene los siguientes datos:
void TestQString::toInt_data()
{
QTest::addColumn<QString>("aString");
QTest::addColumn<int>("expected");
QTest::newRow("positive+value") << "42" << 42;
QTest::newRow("negative-value") << "-42" << -42;
QTest::newRow("zero") << "0" << 0;
}Los datos de la prueba tienen dos elementos: un QString denominado aString y un entero denominado expected. Para obtener estos valores en la prueba real:
void TestQString::toInt()
{
QFETCH(QString, aString);
QFETCH(int, expected);
QCOMPARE(aString.toInt(), expected);
}aString y expected son variables en la pila que se inicializan con los datos de prueba actuales.
Nota: Esta macro solo se puede utilizar en una función de prueba invocada por el marco de pruebas. La función de prueba debe tener una función _data.
QFETCH_GLOBAL(type, name)
Esta macro recupera una variable denominada « name » de tipo « type » de una fila de la tabla de datos global. Los campos « name » y « type » deben coincidir con una columna de la tabla de datos global. Se comprueba esta condición y la prueba se interrumpirá si la comprobación falla.
Supongamos que una prueba tiene los siguientes datos:
void TestQLocale::initTestCase_data()
{
QTest::addColumn<QLocale>("locale");
QTest::newRow("C") << QLocale::c();
QTest::newRow("UKish") << QLocale("en_GB");
QTest::newRow("USAish") << QLocale(QLocale::English, QLocale::UnitedStates);
}
void TestQLocale::roundTripInt_data()
{
QTest::addColumn<int>("number");
QTest::newRow("zero") << 0;
QTest::newRow("one") << 1;
QTest::newRow("two") << 2;
QTest::newRow("ten") << 10;
}Los datos propios de la prueba consisten en un único número por fila. En este caso, initTestCase_data() también proporciona una configuración regional por fila. Por lo tanto, esta prueba se ejecutará con todas las combinaciones posibles de configuración regional de la tabla local y número de la tabla global. Así, con cuatro filas en la tabla global y tres en la tabla local, la función de prueba se ejecuta para 12 casos de prueba distintos (4 * 3 = 12).
void TestQLocale::roundTripInt()
{
QFETCH_GLOBAL(QLocale, locale);
QFETCH(int, number);
bool ok;
QCOMPARE(locale.toInt(locale.toString(number), &ok), number);
QVERIFY(ok);
}La configuración regional se lee de la tabla de datos global mediante QFETCH_GLOBAL(), y el número se lee de la tabla de datos local mediante QFETCH().
Nota: Esta macro solo se puede utilizar en métodos de prueba de una clase que cuente con un método ` initTestCase_data() `.
QFINDTESTDATA(filename)
Devuelve un objeto ` QString ` correspondiente al archivo de datos de prueba al que hace referencia ` filename`, o un objeto ` QString ` vacío si no se ha podido encontrar el archivo de datos de prueba.
Esta macro permite que la prueba cargue datos desde un archivo externo sin tener que codificar de forma fija un nombre de archivo absoluto en la prueba, ni utilizar rutas relativas que pueden dar lugar a errores.
La ruta devuelta será la primera de la siguiente lista que apunte a un archivo o directorio existente:
- filename relativa a QCoreApplication::applicationDirPath() (solo si se ha creado un objeto QCoreApplication o QApplication ).
- filename relativo al directorio de instalación estándar de la prueba (QLibraryInfo::TestsPath con el nombre del caso de prueba en minúsculas añadido al final).
- filename en relación con el directorio que contiene el archivo fuente desde el que se invoca QFINDTESTDATA.
Si el archivo o directorio indicado no existe en ninguna de estas ubicaciones, se muestra una advertencia en el registro de pruebas.
Por ejemplo, en este código:
bool tst_MyXmlParser::parse()
{
MyXmlParser parser;
QString input = QFINDTESTDATA("testxml/simple1.xml");
QVERIFY(parser.parse(input));
}El archivo de datos de prueba se resolverá como el primer archivo existente de:
/home/user/build/myxmlparser/tests/tst_myxmlparser/testxml/simple1.xml/usr/local/Qt-5.0.0/tests/tst_myxmlparser/testxml/simple1.xml/home/user/sources/myxmlparser/tests/tst_myxmlparser/testxml/simple1.xml
Esto permite que la prueba encuentre sus datos de prueba independientemente de si la prueba se ha instalado o no, y de si el árbol de compilación de la prueba coincide con el árbol de fuentes de la misma.
Nota: Para una detecciónfiable de los datos de prueba a partir del directorio de código fuente, es necesario utilizar qmake, definir la macro ` QT_TESTCASE_BUILDDIR ` para que apunte al directorio de trabajo desde el que se invoca el compilador, o bien pasar al compilador únicamente rutas absolutas a los archivos fuente. De lo contrario, no se puede determinar la ruta absoluta del directorio de código fuente.
Nota: La macro ` QT_TESTCASE_BUILDDIR ` también se define implícitamente si se utiliza CMake y el módulo ` QtTest ` está vinculado al objetivo. Se puede cambiar el valor predeterminado de ` QT_TESTCASE_BUILDDIR ` configurando la propiedad `QT_TESTCASE_BUILDDIR` en el objetivo.
Nota: En el caso de las pruebas que utilizan la macro ` QTEST_APPLESS_MAIN()` para generar una función ` main() `, ` QFINDTESTDATA ` no intentará buscar los datos de prueba relativos a ` QCoreApplication::applicationDirPath()`. En la práctica, esto significa que las pruebas que utilicen ` QTEST_APPLESS_MAIN() ` no encontrarán sus datos de prueba si se ejecutan desde un árbol de compilación «sombra».
QSKIP(description)
Si se invoca desde una función de prueba, la macro QSKIP() detiene la ejecución de la prueba sin añadir un fallo al registro de pruebas. Se puede utilizar para omitir pruebas que no tendrían sentido en la configuración actual. Por ejemplo, una prueba de representación de fuentes puede llamar a QSKIP() si las fuentes necesarias no están instaladas en el sistema de pruebas.
El texto « description » se añade al registro de pruebas y debe contener una explicación de por qué no se ha podido ejecutar la prueba.
Si la prueba se basa en datos, cada llamada a QSKIP() en la función de prueba omitirá únicamente la fila actual de datos de prueba, por lo que una llamada incondicional a QSKIP() generará un mensaje de omisión en el registro de pruebas por cada fila de datos de prueba.
Si se invoca desde una función ` _data `, la macro `QSKIP()` detendrá la ejecución de la función ` _data ` e impedirá la ejecución de la función de prueba asociada. Esto omite por completo una prueba basada en datos. Para omitir filas individuales, haz que sean condicionales utilizando un simple ` if (condition) newRow(...) << ... ` en la función ` _data `, en lugar de utilizar `QSKIP()` en la función de prueba.
Si se invoca desde initTestCase_data(), la macro QSKIP() omitirá todas las funciones de prueba y _data. Si se invoca desde initTestCase() cuando no existe initTestCase_data(), o cuando esta solo configura una fila, QSKIP() omitirá igualmente toda la prueba. Sin embargo, si initTestCase_data() contiene más de una fila, entonces se llama a initTestCase() (seguida de cada prueba y, finalmente, de la función de cierre) una vez por cada fila de la misma. Por lo tanto, una llamada a QSKIP() en initTestCase() simplemente omitirá todas las funciones de prueba correspondientes a la fila actual de datos globales, configurada por initTestCase_data().
Nota: Esta macro solo se puede utilizar en una función de prueba o en una función « _data » invocada por el marco de pruebas.
Ejemplo:
if (!QSqlDatabase::drivers().contains("SQLITE"))
QSKIP("This test requires the SQLITE database driver");Omitir errores conocidos
Si una prueba detecta un error conocido que no se va a corregir de inmediato, utiliza la macro QEXPECT_FAIL() para documentar el fallo y hacer referencia al identificador de seguimiento del error correspondiente al problema conocido. Cuando se ejecute la prueba, los fallos esperados se marcarán como XFAIL en la salida de la prueba y no se contabilizarán como fallos a la hora de establecer el código de retorno del programa de pruebas. Si no se produce un fallo esperado, se informará de un XPASS (aprobado inesperado) en la salida de la prueba y se contabilizará como un fallo de la prueba.
En el caso de los errores conocidos, es preferible utilizar ` QEXPECT_FAIL()` en lugar de `QSKIP()`, ya que un desarrollador no puede corregir el error sin que un resultado `XPASS` le recuerde que la prueba también debe actualizarse. Si se utiliza `QSKIP()`, no hay ningún recordatorio para revisar o volver a habilitar la prueba, sin lo cual no se notificarán las regresiones posteriores.
Véase también QEXPECT_FAIL() y «Seleccionar los mecanismos adecuados para excluir pruebas».
QTEST(actual, testElement)
QTEST() es una macro de conveniencia para QCOMPARE() que compara el valor actual con el elemento testElement de los datos de la prueba. Si no existe dicho elemento, la prueba genera una excepción.
Aparte de eso, QTEST() se comporta exactamente igual que QCOMPARE().
En lugar de escribir:
puedes escribir:
QTEST(QString("hello").toUpper(), "myString");Véase también QCOMPARE().
QTEST_APPLESS_MAIN(TestClass)
Implementa una función main() que ejecuta todas las pruebas de TestClass.
Se comporta igual que QTEST_MAIN(), pero no crea una instancia del objeto QApplication. Utiliza esta macro para pruebas independientes muy sencillas que no utilicen interfaz gráfica de usuario.
Véase también QTEST_MAIN().
QTEST_GUILESS_MAIN(TestClass)
Implementa una función main() que crea una instancia del objeto QCoreApplication y de TestClass, y ejecuta todas las pruebas en el orden en que se definieron. Utiliza esta macro para compilar ejecutables independientes.
Se comporta como QTEST_MAIN(), pero crea una instancia de QCoreApplication en lugar del objeto QApplication. Utiliza esta macro si tu caso de prueba no necesita la funcionalidad que ofrece QApplication, pero sigues necesitando el bucle de eventos.
Véase también QTEST_MAIN().
QTEST_MAIN(TestClass)
Implementa una función main() que crea una instancia del objeto de aplicación y de TestClass, y ejecuta todas las pruebas en el orden en que se definieron. Utiliza esta macro para compilar ejecutables independientes.
Si se define ` QT_WIDGETS_LIB `, el objeto de aplicación será un ` QApplication`; si se define ` QT_GUI_LIB `, el objeto de aplicación será un ` QGuiApplication`; en caso contrario, será un ` QCoreApplication`. Si se utiliza qmake y la configuración incluye ` QT += widgets`, entonces se definirá automáticamente ` QT_WIDGETS_LIB `. Del mismo modo, si se utiliza qmake y la configuración incluye ` QT += gui`, entonces se definirá automáticamente ` QT_GUI_LIB `.
Ejemplo:
QTEST_MAIN(TestQString)Véase también QTEST_APPLESS_MAIN(), QTEST_GUILESS_MAIN() y QTest::qExec().
[since 6.8] QTEST_THROW_ON_FAIL
Una vez definidas, las funciones ` QCOMPARE()` y `QVERIFY()`, entre otras, siempre lanzan una excepción en caso de fallo. La función ` QTest::setThrowOnFail()` ya no tiene ningún efecto.
Definir esta macro resulta útil si se desea utilizar QCOMPARE() o QVERIFY() en funciones cuyo tipo de retorno no seavoid. Sin esta macro definida, QCOMPARE(), por ejemplo, se expande a una instrucción que incluye return;, por lo que no se puede utilizar en funciones (o lambdas) que devuelvan algo distinto de void, p. ej., QString. Esto incluye el caso en el que el lanzamiento de excepciones solo está habilitado en tiempo de ejecución (utilizando QTest::setThrowOnFail(true)). Con esta macro definida, QCOMPARE() se expande en su lugar a una instrucción sin un return;, que se puede utilizar desde cualquier función.
Esta macro se introdujo en Qt 6.8.
[since 6.8] QTEST_THROW_ON_SKIP
Cuando se define, ` QSKIP()` siempre lanza un error. En ese caso, ` QTest::setThrowOnSkip()` ya no tiene ningún efecto.
Definir esta macro resulta útil si se desea utilizar QSKIP() en funciones cuyo tipo de retorno no seavoid. Sin esta macro definida, ` QSKIP()` (por ejemplo) se expande a una instrucción que incluye ` return;`, por lo que no se puede utilizar en funciones (o lambdas) que devuelvan algo distinto de ` void`, p. ej., ` QString`. Esto incluye el caso en el que el lanzamiento de excepciones solo está habilitado en tiempo de ejecución (mediante ` QTest::setThrowOnSkip(true)`). Con esta macro definida, ` QSKIP()` se expande en su lugar a una instrucción sin ` return;`, que se puede utilizar desde cualquier función.
Esta macro se introdujo en Qt 6.8.
QTRY_COMPARE(actual, expected)
Realiza una comparación entre los valores de actual y expected llamando a QTRY_COMPARE_WITH_TIMEOUT() con un tiempo de espera de cinco segundos.
Nota: Esta macro solo se puede utilizar en una función de prueba invocada por el marco de pruebas.
Véase también QTRY_COMPARE_WITH_TIMEOUT(), QCOMPARE(), QVERIFY(), QTRY_VERIFY() y QEXPECT_FAIL().
[since 6.4] QTRY_COMPARE_EQ(computed, baseline)
Realiza una comparación de los valores de computed y baseline llamando a QTRY_COMPARE_EQ_WITH_TIMEOUT con un tiempo de espera de cinco segundos.
Nota: Esta macro solo se puede utilizar en una función de prueba invocada por el marco de pruebas.
Esta macro se introdujo en Qt 6.4.
Véase también QCOMPARE_EQ() y QTRY_COMPARE_EQ_WITH_TIMEOUT().
[since 6.4] QTRY_COMPARE_EQ_WITH_TIMEOUT(computed, baseline, timeout)
Esta macro es similar a ` QCOMPARE_EQ()`, pero realiza la comparación de los valores de ` computed ` y ` baseline ` de forma repetida, hasta que la comparación devuelva ` true ` o se alcance el ` timeout ` (en milisegundos). Entre cada comparación, se procesarán los eventos. Si se alcanza el tiempo de espera, se registra un error en el registro de pruebas y la prueba no se seguirá ejecutando.
Desde Qt 6.8, el valor de ` timeout ` también puede ser un literal de `std::chrono `, como ` 2s`.
Nota: Esta macro solo se puede utilizar en una función de prueba invocada por el marco de pruebas.
Esta macro se introdujo en Qt 6.4.
Véase también QCOMPARE_EQ() y QTRY_COMPARE_EQ().
[since 6.4] QTRY_COMPARE_GE(computed, baseline)
Realiza una comparación de los valores de computed y baseline llamando a QTRY_COMPARE_GE_WITH_TIMEOUT con un tiempo de espera de cinco segundos.
Nota: Esta macro solo se puede utilizar en una función de prueba invocada por el marco de pruebas.
Esta macro se introdujo en Qt 6.4.
Véase también QCOMPARE_GE() y QTRY_COMPARE_GE_WITH_TIMEOUT().
[since 6.4] QTRY_COMPARE_GE_WITH_TIMEOUT(computed, baseline, timeout)
Esta macro es similar a ` QCOMPARE_GE()`, pero realiza la comparación de los valores de ` computed ` y ` baseline ` repetidamente, hasta que la comparación devuelva ` true ` o se alcance el ` timeout ` (en milisegundos). Entre cada comparación, se procesarán los eventos. Si se alcanza el tiempo de espera, se registra un error en el registro de pruebas y la prueba no se seguirá ejecutando.
Desde Qt 6.8, el valor de ` timeout ` también puede ser un literal de `std::chrono `, como ` 2s`.
Nota: Esta macro solo se puede utilizar en una función de prueba invocada por el marco de pruebas.
Esta macro se introdujo en Qt 6.4.
Véase también QCOMPARE_GE() y QTRY_COMPARE_GE().
[since 6.4] QTRY_COMPARE_GT(computed, baseline)
Realiza una comparación de los valores de computed y baseline llamando a QTRY_COMPARE_GT_WITH_TIMEOUT con un tiempo de espera de cinco segundos.
Nota: Esta macro solo se puede utilizar en una función de prueba invocada por el marco de pruebas.
Esta macro se introdujo en Qt 6.4.
Véanse también QCOMPARE_GT() y QTRY_COMPARE_GT_WITH_TIMEOUT().
[since 6.4] QTRY_COMPARE_GT_WITH_TIMEOUT(computed, baseline, timeout)
Esta macro es similar a ` QCOMPARE_GT()`, pero realiza la comparación de los valores de ` computed ` y ` baseline ` de forma repetida, hasta que la comparación devuelva ` true ` o se alcance el ` timeout ` (en milisegundos). Entre cada comparación, se procesarán los eventos. Si se alcanza el tiempo de espera, se registra un error en el registro de pruebas y la prueba no se seguirá ejecutando.
Desde Qt 6.8, la timeout también puede ser un literal destd::chrono , como 2s.
Nota: Esta macro solo se puede utilizar en una función de prueba invocada por el marco de pruebas.
Esta macro se introdujo en Qt 6.4.
Véase también ` QCOMPARE_GT()` y ` QTRY_COMPARE_GT()`.
[since 6.4] QTRY_COMPARE_LE(computed, baseline)
Realiza una comparación entre los valores de computed y baseline llamando a QTRY_COMPARE_LE_WITH_TIMEOUT con un tiempo de espera de cinco segundos.
Nota: Esta macro solo se puede utilizar en una función de prueba invocada por el marco de pruebas.
Esta macro se introdujo en Qt 6.4.
Véase también QCOMPARE_LE() y QTRY_COMPARE_LE_WITH_TIMEOUT().
[since 6.4] QTRY_COMPARE_LE_WITH_TIMEOUT(computed, baseline, timeout)
Esta macro es similar a ` QCOMPARE_LE()`, pero realiza la comparación de los valores de ` computed ` y ` baseline ` de forma repetida, hasta que la comparación devuelva ` true ` o se alcance el ` timeout ` (en milisegundos). Entre cada comparación, se procesarán los eventos. Si se alcanza el tiempo de espera, se registra un error en el registro de pruebas y la prueba no se seguirá ejecutando.
Desde Qt 6.8, el valor de ` timeout ` también puede ser un literal de `std::chrono `, como ` 2s`.
Nota: Esta macro solo se puede utilizar en una función de prueba invocada por el marco de pruebas.
Esta macro se introdujo en Qt 6.4.
Véase también QCOMPARE_LE() y QTRY_COMPARE_LE().
[since 6.4] QTRY_COMPARE_LT(computed, baseline)
Realiza una comparación entre los valores de computed y baseline llamando a QTRY_COMPARE_LT_WITH_TIMEOUT con un tiempo de espera de cinco segundos.
Nota: Esta macro solo se puede utilizar en una función de prueba invocada por el marco de pruebas.
Esta macro se introdujo en Qt 6.4.
Véanse también QCOMPARE_LT() y QTRY_COMPARE_LT_WITH_TIMEOUT().
[since 6.4] QTRY_COMPARE_LT_WITH_TIMEOUT(computed, baseline, timeout)
Esta macro es similar a ` QCOMPARE_LT()`, pero realiza la comparación de los valores de ` computed ` y ` baseline ` de forma repetida, hasta que la comparación devuelva ` true ` o se alcance el ` timeout ` (en milisegundos). Entre cada comparación, se procesarán los eventos. Si se alcanza el tiempo de espera, se registra un error en el registro de pruebas y la prueba no se seguirá ejecutando.
Desde Qt 6.8, el valor de ` timeout ` también puede ser un literal de `std::chrono `, como ` 2s`.
Nota: Esta macro solo se puede utilizar en una función de prueba invocada por el marco de pruebas.
Esta macro se introdujo en Qt 6.4.
Véase también QCOMPARE_LT() y QTRY_COMPARE_LT().
[since 6.4] QTRY_COMPARE_NE(computed, baseline)
Realiza una comparación entre los valores de computed y baseline llamando a QTRY_COMPARE_NE_WITH_TIMEOUT con un tiempo de espera de cinco segundos.
Nota: Esta macro solo se puede utilizar en una función de prueba invocada por el marco de pruebas.
Esta macro se introdujo en Qt 6.4.
Véase también QCOMPARE_NE() y QTRY_COMPARE_NE_WITH_TIMEOUT().
[since 6.4] QTRY_COMPARE_NE_WITH_TIMEOUT(computed, baseline, timeout)
Esta macro es similar a ` QCOMPARE_NE()`, pero realiza la comparación de los valores de ` computed ` y ` baseline ` de forma repetida, hasta que la comparación devuelva ` true ` o se alcance el ` timeout ` (en milisegundos). Entre cada comparación, se procesarán los eventos. Si se alcanza el tiempo de espera, se registra un error en el registro de pruebas y la prueba no se seguirá ejecutando.
Desde Qt 6.8, el valor de ` timeout ` también puede ser un literal de `std::chrono `, como ` 2s`.
Nota: Esta macro solo se puede utilizar en una función de prueba invocada por el marco de pruebas.
Esta macro se introdujo en Qt 6.4.
Véase también QCOMPARE_NE() y QTRY_COMPARE_NE().
QTRY_COMPARE_WITH_TIMEOUT(actual, expected, timeout)
La macro `QTRY_COMPARE_WITH_TIMEOUT()` es similar a ` QCOMPARE()`, pero realiza la comparación de los valores ` actual ` y ` expected ` de forma repetida, hasta que ambos valores sean iguales o se alcance el ` timeout ` (en milisegundos). Entre cada comparación, se procesarán los eventos. Si se alcanza el tiempo de espera, se registra un error en el registro de pruebas y la prueba no se ejecutará más allá de ese punto.
Desde Qt 6.8, la variable « timeout » también puede ser un literal de «std::chrono », como por ejemplo « 2s ».
Nota: Esta macro solo se puede utilizar en una función de prueba invocada por el marco de pruebas.
Véase también QTRY_COMPARE(), QCOMPARE(), QVERIFY(), QTRY_VERIFY() y QEXPECT_FAIL().
QTRY_VERIFY2(condition, message)
Comprueba si « condition » es «true» llamando a « QTRY_VERIFY2_WITH_TIMEOUT()» con un tiempo de espera de cinco segundos. Si, tras ello, « condition » sigue siendo «false», se muestra « message ». « message » es una cadena de caracteres de C sin formato.
Ejemplo:
QTRY_VERIFY2(list.size() > 2, QByteArray::number(list.size()).constData());Nota: Esta macro solo se puede utilizar en una función de prueba invocada por el marco de pruebas.
Véase también QTRY_VERIFY2_WITH_TIMEOUT(), QTRY_VERIFY(), QVERIFY(), QCOMPARE(), QTRY_COMPARE() y QEXPECT_FAIL().
QTRY_VERIFY(condition)
Comprueba la dirección condition llamando a QTRY_VERIFY_WITH_TIMEOUT() con un tiempo de espera de cinco segundos.
Nota: Esta macro solo se puede utilizar en una función de prueba invocada por el marco de pruebas.
Véase también QTRY_VERIFY_WITH_TIMEOUT(), QTRY_VERIFY2(), QVERIFY(), QCOMPARE(), QTRY_COMPARE() y QEXPECT_FAIL().
QTRY_VERIFY2_WITH_TIMEOUT(condition, message, timeout)
La macro QTRY_VERIFY2_WITH_TIMEOUT es similar a ` QTRY_VERIFY_WITH_TIMEOUT()` salvo que genera un mensaje detallado ` message ` cuando ` condition ` sigue siendo falso tras el ` timeout ` especificado (en milisegundos). La ` message ` es una cadena de caracteres de C sin formato.
Desde Qt 6.8, el timeout también puede ser un literal destd::chrono , como 2s.
Ejemplo:
QTRY_VERIFY2_WITH_TIMEOUT(list.size() > 2, QByteArray::number(list.size()).constData(), 10s);Nota: Esta macro solo se puede utilizar en una función de prueba invocada por el marco de pruebas.
Véase también ` QTRY_VERIFY()`, ` QTRY_VERIFY_WITH_TIMEOUT()`, ` QVERIFY()`, ` QCOMPARE()`, ` QTRY_COMPARE()` y ` QEXPECT_FAIL()`.
QTRY_VERIFY_WITH_TIMEOUT(condition, timeout)
La macro `QTRY_VERIFY_WITH_TIMEOUT()` es similar a ` QVERIFY()`, pero comprueba la condición ` condition ` repetidamente, hasta que la condición se cumpla o se alcance el tiempo de espera ` timeout ` (en milisegundos). Entre cada evaluación, se procesarán los eventos. Si se alcanza el tiempo de espera, se registra un error en el registro de pruebas y la prueba no se ejecutará más.
Desde Qt 6.8, el ` timeout ` también puede ser un literal de `std::chrono `, como ` 2s`.
Nota: Esta macro solo se puede utilizar en una función de prueba invocada por el marco de pruebas.
Véase también QTRY_VERIFY(), QTRY_VERIFY2_WITH_TIMEOUT(), QVERIFY(), QCOMPARE(), QTRY_COMPARE() y QEXPECT_FAIL().
QVERIFY2(condition, message)
La macro QVERIFY2() se comporta exactamente igual que QVERIFY(), salvo que devuelve un message cuando condition es falso. La message es una cadena de caracteres de C sin formato.
El mensaje también se puede obtener mediante una llamada a una función que genere una cadena de C sin formato, como qPrintable(), aplicada a un QString, que puede construirse de cualquiera de sus formas habituales, incluida la aplicación de .args() para dar formato a algunos datos.
Ejemplo:
QVERIFY2(QFileInfo("file.txt").exists(), "file.txt does not exist.");Por ejemplo, si tienes un objeto de archivo y estás probando su función ` open() `, podrías escribir una prueba con una instrucción como:
bool opened = file.open(QIODevice::WriteOnly);
QVERIFY(opened);Si esta prueba falla, no dará ninguna pista sobre por qué no se ha podido abrir el archivo:
FAIL! : tst_QFile::open_write() 'opened' returned FALSE. ()
Si puedes generar un mensaje de error más detallado a partir de los valores que se están probando, puedes utilizar ` QVERIFY2() ` para pasar ese mensaje junto con tu condición de prueba, con el fin de proporcionar un mensaje más detallado en caso de fallo:
QVERIFY2(file.open(QIODevice::WriteOnly),
qPrintable(QString("open %1: %2")
.arg(file.fileName()).arg(file.errorString())));Si esta rama se está sometiendo a pruebas en el sistema de CI de Qt, el mensaje de error detallado anterior se incluirá en el resumen publicado en el sistema de revisión de código:
FAIL! : tst_QFile::open_write() 'opened' returned FALSE. (open /tmp/qt.a3B42Cd: No space left on device)
Véase también QVERIFY(), QCOMPARE(), QEXPECT_FAIL(), QCOMPARE_EQ(), QCOMPARE_NE(), QCOMPARE_LT(), QCOMPARE_LE(), QCOMPARE_GT() y QCOMPARE_GE().
QVERIFY(condition)
La macro QVERIFY() comprueba si la expresión « condition » es verdadera o no. Si es verdadera, la ejecución continúa. En caso contrario, se registra un error en el registro de pruebas y la prueba no se ejecutará más allá de ese punto.
Puedes utilizar QVERIFY2() cuando resulte práctico y útil incluir información adicional en el informe de fallos de la prueba.
Nota: Esta macro solo se puede utilizar en una función de prueba invocada por el marco de pruebas.
Por ejemplo, el siguiente código muestra cómo se utiliza esta macro para verificar que un objeto ` QSignalSpy ` es válido:
QVERIFY(spy.isValid());Para obtener más información sobre el fallo, utilice ` QCOMPARE(x, y) ` en lugar de ` QVERIFY(x == y)`, ya que este informa tanto del valor esperado como del valor real cuando la comparación falla.
Véase también ` QCOMPARE()`, ` QTRY_VERIFY()`, ` QSignalSpy`, ` QEXPECT_FAIL()`, ` QCOMPARE_EQ()`, ` QCOMPARE_NE()`, ` QCOMPARE_LT()`, ` QCOMPARE_LE()`, ` QCOMPARE_GT()` y ` QCOMPARE_GE()`.
[since 6.3] QVERIFY_THROWS_EXCEPTION(exceptiontype, ...)
La macro QVERIFY_THROWS_EXCEPTION ejecuta la expresión indicada en el argumento variádico y espera capturar una excepción lanzada por dicha expresión.
Hay varios resultados posibles:
- Si la expresión lanza una excepción que sea la misma que exceptiontype o derivada de exceptiontype, la ejecución continuará.
- De lo contrario, si la expresión no lanza ninguna excepción, o si la excepción lanzada deriva de
std::exception, se registrará un fallo en el registro de pruebas y la macro retornará prematuramente (desde la función que la engloba). - Si la excepción lanzada no deriva ni de
std::exceptionni de exceptiontype, se registrará un fallo en el registro de pruebas y se volverá a lanzar la excepción. Esto evita problemas con, por ejemplo, las excepciones de cancelación de pthread.
La macro utiliza argumentos variádicos, por lo que la expresión puede contener comas que el preprocesador considera separadores de argumentos, por ejemplo, como en
QVERIFY_THROWS_EXCEPTION(std::bad_alloc,
// macro arguments: ^ exceptiontype
std::vector<std::pair<int, long>>{42'000'000'000, {42, 42L}});
// macro arguments: \---------- 1 ----------/ \-------- 2 --------/ \3/ \ 4 /
// \----------------------- expression -----------------------/Nota: Esta macro solo se puede utilizar en una función de prueba invocada por el marco de pruebas.
Esta macro se introdujo en Qt 6.3.
[since 6.3] QVERIFY_THROWS_NO_EXCEPTION(...)
La macro QVERIFY_THROWS_NO_EXCEPTION ejecuta la expresión indicada en su argumento variádico e intenta capturar cualquier excepción lanzada por dicha expresión.
Hay varios resultados posibles:
- Si la expresión no lanza ninguna excepción, la ejecución continuará.
- Por el contrario, si se captura una excepción derivada de
std::exception, se registrará un fallo en el registro de pruebas y la macro retornará anticipadamente (retorno implícito desde la función contenedora). - Si se captura una excepción que no derive de `
std::exception`, se registrará un fallo en el registro de pruebas y la excepción se volverá a lanzar. Esto evita problemas con, por ejemplo, las excepciones de cancelación de pthread.
La macro utiliza argumentos variádicos, por lo que la expresión puede contener comas que el preprocesador considera separadores de argumentos, por ejemplo, como en
QVERIFY_THROWS_NO_EXCEPTION(std::pair<int, long>{42, 42L});
// macro arguments: \---- 1 ----/ \-- 2 -/ \3 /Nota: Esta macro solo se puede utilizar en una función de prueba invocada por el marco de pruebas.
Esta macro se introdujo en Qt 6.3.
© 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.