TestCase QML Type
Representa un caso de prueba unitaria. Más...
| Import Statement: | import QtTest |
| Inherits: |
Propiedades
- completed : bool
- name : string
- running : bool
- when : bool
- windowShown : bool
Métodos
- cleanup()
- cleanupTestCase()
- compare(actual, expected, message)
- QtObject createTemporaryObject(Component component, QtObject parent, var properties)
- QtObject createTemporaryQmlObject(string qml, QtObject parent, string filePath)
- expectFail(tag, message)
- expectFailContinue(tag, message)
- fail(message)
- failOnWarning(message)
(since 6.3) - QtObject findChild(parent, objectName)
- fuzzyCompare(actual, expected, delta, message)
- QtObject grabImage(Item item)
- ignoreWarning(message)
- init()
- initTestCase()
- bool isPolishScheduled(object itemOrWindow)
- keyClick(key, modifiers, delay)
- keyPress(key, modifiers, delay)
- keyRelease(key, modifiers, delay)
- keySequence(keySequence)
- mouseClick(item, x, y, button, modifiers, delay)
- mouseDoubleClickSequence(item, x, y, button, modifiers, delay)
- mouseDrag(item, x, y, dx, dy, button, modifiers, delay)
- mouseMove(item, x, y, delay, buttons)
- mousePress(item, x, y, button, modifiers, delay)
- mouseRelease(item, x, y, button, modifiers, delay)
- mouseWheel(item, x, y, xDelta, yDelta, button, modifiers, delay)
- skip(message)
- sleep(ms)
- TouchEventSequence touchEvent(object item)
- tryCompare(obj, property, expected, timeout, message)
- tryVerify(function, timeout, message)
- verify(condition, message)
- wait(ms)
- bool waitForPolish(object windowOrItem, int timeout)
(since 6.5) - waitForRendering(item, timeout)
- warn(message)
Descripción detallada
Introducción a los casos de prueba de QML
Los casos de prueba se escriben como funciones JavaScript dentro de un tipo TestCase:
import QtQuick 2.0
import QtTest 1.2
TestCase {
name: "MathTests"
function test_math() {
compare(2 + 2, 4, "2 + 2 = 4")
}
function test_fail() {
compare(2 + 2, 5, "2 + 2 = 5")
}
}Las funciones cuyos nombres comienzan por «test_» se tratan como casos de prueba que deben ejecutarse. La propiedad name se utiliza para anteponer un prefijo a las funciones en la salida:
********* Start testing of MathTests *********
Config: Using QTest library 4.7.2, Qt 4.7.2
PASS : MathTests::initTestCase()
FAIL! : MathTests::test_fail() 2 + 2 = 5
Actual (): 4
Expected (): 5
Loc: [/home/.../tst_math.qml(12)]
PASS : MathTests::test_math()
PASS : MathTests::cleanupTestCase()
Totals: 3 passed, 1 failed, 0 skipped
********* Finished testing of MathTests *********Debido al funcionamiento de las propiedades de JavaScript, el orden en el que se encuentran las funciones de prueba es impredecible. Para facilitar la previsibilidad, el marco de pruebas ordenará las funciones en orden ascendente por nombre. Esto puede resultar útil cuando hay dos pruebas que deben ejecutarse en un orden determinado.
Se pueden proporcionar varios tipos de TestCase. El programa de pruebas finalizará una vez que todas se hayan completado.
Pruebas basadas en datos
Se pueden proporcionar datos de una tabla a una prueba utilizando un nombre de función que termine en «_data». Como alternativa, se puede utilizar la función init_data() para proporcionar datos de prueba por defecto a todas las funciones de prueba que no tengan una función «_data» correspondiente en un tipo TestCase:
import QtQuick 2.0
import QtTest 1.2
TestCase {
name: "DataTests"
function init_data() {
return [
{tag:"init_data_1", a:1, b:2, answer: 3},
{tag:"init_data_2", a:2, b:4, answer: 6}
];
}
function test_table_data() {
return [
{tag: "2 + 2 = 4", a: 2, b: 2, answer: 4 },
{tag: "2 + 6 = 8", a: 2, b: 6, answer: 8 },
]
}
function test_table(data) {
//data comes from test_table_data
compare(data.a + data.b, data.answer)
}
function test_default_table(data) {
//data comes from init_data
compare(data.a + data.b, data.answer)
}
}El marco de pruebas recorrerá todas las filas de la tabla y pasará cada una de ellas a la función de prueba. Como se muestra, las columnas se pueden extraer para su uso en la prueba. La columna « tag » es especial: el marco de pruebas la muestra cuando una fila falla, para ayudar al lector a identificar qué caso ha fallado entre un conjunto de pruebas que, por lo demás, han superado la prueba.
Pruebas de rendimiento
Las funciones cuyos nombres empiecen por «benchmark_» se ejecutarán varias veces con el marco de pruebas de rendimiento de Qt, y se informará del tiempo medio de ejecución de las repeticiones. Esto equivale a utilizar la macro QBENCHMARK en la versión en C++ de QTestLib.
TestCase {
id: top
name: "CreateBenchmark"
function benchmark_create_component() {
let component = Qt.createComponent("item.qml")
let obj = component.createObject(top)
obj.destroy()
component.destroy()
}
}
RESULT : CreateBenchmark::benchmark_create_component:
0.23 msecs per iteration (total: 60, iterations: 256)
PASS : CreateBenchmark::benchmark_create_component()Para obtener el efecto de la macro ` QBENCHMARK_ONCE `, anteponga «benchmark_once_» al nombre de la función de prueba.
Simulación de eventos de teclado y ratón
Los métodos ` keyPress()`, ` keyRelease()` y ` keyClick()` pueden utilizarse para simular eventos de teclado en las pruebas unitarias. Los eventos se envían al elemento QML que tenga el foco en ese momento. Se puede pasar un valor de la enumeración `Qt.Key` o un carácter latin1 (cadena de longitud uno).
Rectangle {
width: 50; height: 50
focus: true
TestCase {
name: "KeyClick"
when: windowShown
function test_key_click() {
keyClick(Qt.Key_Left)
keyClick("a")
...
}
}
}Los métodos mousePress(), mouseRelease(), mouseClick(), mouseDoubleClickSequence() y mouseMove() pueden utilizarse para simular eventos de ratón de forma similar.
Si tu prueba crea otras ventanas, es posible que estas se activen y le quiten el foco a la ventana del TestCase. Para asegurarte de que la ventana del TestCase esté activa, utiliza el siguiente código:
testCase.Window.window.requestActivate()
tryCompare(testCase.Window.window, "active", true)Nota: los eventos de teclado y ratón solo pueden generarse una vez que se haya mostrado la ventana principal. Los intentos de generar eventos antes de ese momento fallarán. Utiliza las propiedades when y windowShown para comprobar cuándo se ha mostrado la ventana principal.
Gestión de objetos de prueba creados dinámicamente
Un patrón típico en las pruebas QML consiste en crear dinámicamente un elemento y, a continuación, destruirlo al final de la función de prueba:
TestCase {
id: testCase
name: "MyTest"
when: windowShown
function test_click() {
let item = Qt.createQmlObject("import QtQuick 2.0; Item {}", testCase);
verify(item);
// Test item...
item.destroy();
}
}El problema de este patrón es que cualquier fallo en la función de prueba hará que se omita la llamada a ` item.destroy() `, lo que deja el elemento en la escena hasta que el caso de prueba haya finalizado. Esto puede provocar interferencias en pruebas futuras; por ejemplo, bloqueando eventos de entrada o generando salidas de depuración no relacionadas que dificulten el seguimiento de la ejecución del código.
En cambio, al llamar a ` createTemporaryQmlObject()` se garantiza que el objeto se destruya al final de la función de prueba:
TestCase {
id: testCase
name: "MyTest"
when: windowShown
function test_click() {
let item = createTemporaryQmlObject("import QtQuick 2.0; Item {}", testCase);
verify(item);
// Test item...
// Don't need to worry about destroying "item" here.
}
}Para los objetos creados mediante la función ` createObject()` de ` Component`, se puede utilizar la función ` createTemporaryObject()`.
Separación de las pruebas de la lógica de la aplicación
En la mayoría de los casos, es recomendable separar las pruebas de la lógica de la aplicación dividiéndolas en proyectos distintos y vinculándolos.
Por ejemplo, podría tener la siguiente estructura de proyectos:
.
| — CMakeLists.txt
| — main.cpp
| - main.qml
| — MyModule
| — MyButton.qml
| — CMakeLists.txt
| — tests
| — tst_testqml.qml
| — main.cpp
| — setup.cpp
| — setup.hAhora, para probar MyModule/MyButton.qml, crea una biblioteca para MyModule en MyModule/CMakeLists.txt y vincúlala a tu proyecto de pruebas, tests/UnitQMLTests/CMakeLists.txt:
...
qt_add_library(MyModule STATIC)
qt6_add_qml_module(MyModule
URI MyModule
QML_FILES MyButton.qml
)
... ...
add_executable(TestMyApplication main.cpp
setup.cpp setup.h)
add_test(NAME TestMyApplication COMMAND TestMyApplication)
target_link_libraries(TestMyApplication
PRIVATE
Qt6::QuickTest
Qt6::Qml
MyModule
MyModuleplugin
)
...#include <QtQuickTest/quicktest.h>
#include "setup.h"
QUICK_TEST_MAIN_WITH_SETUP(TestQML, Setup)#include "setup.h"
void Setup::applicationAvailable()
{
// custom code that doesn't require QQmlEngine
}
void Setup::qmlEngineAvailable(QQmlEngine *engine)
{
// add import paths
}
void Setup::cleanupTestCase()
{
// custom code to clean up before destruction starts
}#ifndef SETUP_H
#define SETUP_H
#include <QObject>
#include <QQmlEngine>
class Setup : public QObject
{
Q_OBJECT
public:
Setup() = default;
public slots:
void applicationAvailable();
void qmlEngineAvailable(QQmlEngine *engine);
void cleanupTestCase();
};
#endif // SETUP_H ...
add_subdirectory(MyModule)
add_subdirectory(tests)
qt_add_executable(MyApplication
src/main.cpp
)
qt_add_qml_module(MyApplication
URI MyApplication
QML_FILES main.qml
)
...A continuación, en tests/tst_testqml.qml, puedes importar MyModule/MyButton.qml:
import QtQuick
import QtQuick.Controls
import QtTest
import MyModule
Item {
width: 800
height: 600
MyButton {
id: myButton
anchors.centerIn: parent
}
TestCase {
name: "MyButton"
when: windowShown
function test_clickToExpand() {
const widthBeforeClick = myButton.width;
mouseClick(myButton);
const widthAfterClick = myButton.width;
verify(widthBeforeClick < widthAfterClick);
}
}
}Véase también SignalSpy y Qt Quick Test.
Documentación de propiedades
completed : bool
Esta propiedad se establecerá en «true» una vez que el caso de prueba haya finalizado su ejecución. Los casos de prueba solo se ejecutan una vez. El valor inicial es «false».
name : string
Esta propiedad define el nombre del caso de prueba para la generación de informes de resultados. El valor por defecto es una cadena vacía.
TestCase {
name: "ButtonTests"
...
}running : bool
Esta propiedad se establecerá en «true» mientras se esté ejecutando el caso de prueba. El valor inicial es «false», y volverá a ser «false» una vez que finalice el caso de prueba.
Véase también completed y when.
when : bool
Esta propiedad debe establecerse en «true» cuando la aplicación desee que se ejecuten los casos de prueba. El valor por defecto es «true». En el siguiente ejemplo, se ejecuta una prueba cuando el usuario pulsa el botón del ratón:
Rectangle {
id: foo
width: 640; height: 480
color: "cyan"
MouseArea {
id: area
anchors.fill: parent
}
property bool bar: true
TestCase {
name: "ItemTests"
when: area.pressed
id: test1
function test_bar() {
verify(bar)
}
}
}La aplicación de pruebas se cerrará una vez que se hayan activado y ejecutado todos los tipos de « TestCase ».
Véase también completed.
windowShown : bool
Esta propiedad se establecerá en «true» una vez que se haya mostrado la ventana de visualización de QML. Normalmente, los casos de prueba se ejecutan tan pronto como se carga la aplicación de prueba y antes de que se muestre una ventana. Si el caso de prueba incluye elementos visuales y comportamientos, puede que sea necesario retrasar su ejecución hasta que se haya mostrado la ventana.
Button {
id: button
onClicked: text = "Clicked"
TestCase {
name: "ClickTest"
when: windowShown
function test_click() {
button.clicked();
compare(button.text, "Clicked");
}
}
}Documentación del método
cleanup()
Esta función se invoca tras cada función de prueba que se ejecuta en el tipo TestCase. La implementación por defecto no realiza ninguna acción. La aplicación puede proporcionar su propia implementación para llevar a cabo tareas de limpieza tras cada función de prueba.
Véase también ` init()` y ` cleanupTestCase()`.
cleanupTestCase()
Esta función se invoca una vez que se han completado todas las demás funciones de prueba del tipo « TestCase ». La implementación por defecto no realiza ninguna acción. La aplicación puede proporcionar su propia implementación para llevar a cabo la limpieza de los casos de prueba.
Véase también ` initTestCase()` y ` cleanup()`.
compare(actual, expected, message = "")
Hace que falle el caso de prueba actual si actual no coincide con expected, y muestra el mensaje opcional message. Es similar a QCOMPARE(actual, expected) en C++.
Véase también tryCompare() y fuzzyCompare.
QtObject createTemporaryObject(Component component, QtObject parent, var properties)
Esta función crea dinámicamente un objeto QML a partir del ` component ` proporcionado, con los parámetros opcionales ` parent ` y ` properties` especificados. El objeto devuelto se destruirá (si aún no lo ha sido) una vez que haya finalizado la ejecución de ` cleanup()`, lo que significa que se garantiza que los objetos creados con esta función se destruyan tras cada prueba, independientemente de si las pruebas fallan o no.
Si se produjera un error al crear el objeto, se devolverá null.
Esta función llama internamente a component.createObject().
Véase también Managing Dynamically Created Test Objects.
QtObject createTemporaryQmlObject(string qml, QtObject parent, string filePath)
Esta función crea dinámicamente un objeto QML a partir de la cadena « qml » proporcionada, con el « parent » especificado. El objeto devuelto se destruirá (si aún no lo ha sido) una vez que haya finalizado la ejecución de « cleanup()», lo que significa que se garantiza que los objetos creados con esta función se destruirán tras cada prueba, independientemente de si las pruebas fallan o no.
Si se produce un error al crear el objeto, se devolverá null.
Si se especifica ` filePath `, se utilizará para informar de los errores del objeto creado.
Esta función llama internamente a ` Qt.createQmlObject()`.
Véase también Managing Dynamically Created Test Objects.
expectFail(tag, message)
En una prueba basada en datos, marca la fila asociada a tag como «esperada que falle». Cuando se produzca el fallo, muestra el message, interrumpe la prueba y marca la prueba como superada. Similar a QEXPECT_FAIL(tag, message, Abort) en C++.
Si la prueba no está basada en datos, entonces tag debe establecerse como una cadena vacía.
Véase también expectFailContinue().
expectFailContinue(tag, message)
En una prueba basada en datos, marca la fila asociada a tag como «se espera que falle». Cuando se produzca el fallo, muestra el message y, a continuación, continúa con la prueba. Es similar a QEXPECT_FAIL(tag, message, Continue) en C++.
Si la prueba no está basada en datos, entonces tag debe establecerse en una cadena vacía.
Véase también expectFail().
fail(message = "")
Hace fallar el caso de prueba actual, con el parámetro opcional ` message`. Es similar a ` QFAIL(message) ` en C++.
[since 6.3] failOnWarning(message)
Añade un fallo de prueba al registro de pruebas por cada advertencia que coincida con message. La función de prueba continuará su ejecución cuando se añada un fallo.
message Puede ser una cadena de caracteres o una expresión regular que defina un patrón de mensajes. En este último caso, por cada advertencia que se encuentre, 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.
Por ejemplo, el siguiente fragmento de código hará que falle una prueba si se produce una advertencia con el texto «Something bad happened»:
failOnWarning("Something bad happened")El siguiente fragmento de código hará que la prueba falle si se encuentra cualquier advertencia que coincida con el patrón dado:
failOnWarning(/[0-9]+ bad things happened/)Para que falle cualquier prueba que active una advertencia determinada, pasa una expresión regular adecuada a esta función en ` init()`:
function init() {
failOnWarning(/.?/)
}Nota: A pesar de ser un objeto RegExp de JavaScript, no se interpretará como tal; en su lugar, el patrón se pasará a ` QRegularExpression`.
Nota: `ignoreMessage ()` tiene prioridad sobre esta función, por lo que se ignorarán todas las advertencias que coincidan con un patrón proporcionado tanto a ` ignoreMessage() ` como a ` failOnWarning() `.
Este método se introdujo en Qt 6.3.
Véase también QTest::failOnWarning() y warn().
QtObject findChild(parent, objectName)
Devuelve el primer elemento secundario de ` parent ` con ` objectName`, o ` null ` si no existe dicho elemento. Se realizan búsquedas recursivas tanto en los elementos secundarios visuales como en los no visuales, y se buscan primero los elementos secundarios visuales.
compare(findChild(item, "childObject"), expectedChildObject);fuzzyCompare(actual, expected, delta, message = "")
Falla el caso de prueba actual si la diferencia entre actual y expected es mayor que delta, y muestra el mensaje opcional message. Es similar a qFuzzyCompare(actual, expected) en C++, pero con un valor obligatorio de delta.
Esta función también se puede utilizar para comparaciones de color si tanto el valor actual como el expected se pueden convertir en valores de color. Si alguna de las diferencias en los valores de los canales RGBA es mayor que delta, la prueba falla.
Véanse también tryCompare() y compare().
QtObject grabImage(Item item)
Devuelve un objeto de imagen instantánea del ` item` indicado.
El objeto de imagen devuelto tiene las siguientes propiedades:
- width Devuelve la anchura de la imagen subyacente (desde la versión 5.10)
- height: Devuelve la altura de la imagen subyacente (desde la versión 5.10)
- size: Devuelve el tamaño de la imagen subyacente (desde la versión 5.10)
Además, el objeto de imagen devuelto dispone de los siguientes métodos:
red(x, y)Devuelve el valor del canal rojo del píxel situado en la posición x, ygreen(x, y)Devuelve el valor del canal verde del píxel situado en la posición x, yblue(x, y)Devuelve el valor del canal azul del píxel situado en la posición x, yalpha(x, y)Devuelve el valor del canal alfa del píxel situado en la posición x, ypixel(x, y)Devuelve el valor de color del píxel situado en la posición x, yequals(image)Devuelve «true» si esta imagen es idéntica a «image»; véase QImage::operator== (desde la versión 5.6)Por ejemplo:
let image = grabImage(rect); compare(image.red(10, 10), 255); compare(image.pixel(20, 20), Qt.rgba(255, 0, 0, 255)); rect.width += 10; let newImage = grabImage(rect); verify(!newImage.equals(image));save(path)Guarda la imagen en la ruta indicada. Si no se puede guardar la imagen, se lanzará una excepción. (desde la versión 5.10)Esto puede resultar útil para realizar un análisis postmortem de las pruebas fallidas, por ejemplo:
let image = grabImage(rect); try { compare(image.width, 100); } catch (ex) { image.save("debug.png"); throw ex; }
ignoreWarning(message)
Marca ` message ` como un mensaje de advertencia que se ignora. Cuando aparece, la advertencia no se muestra y la prueba se supera. Si el mensaje no aparece, la prueba fallará. Es similar a ` QTest::ignoreMessage(QtWarningMsg, message) ` en C++.
Desde Qt 5.12, message puede ser una cadena de caracteres o una expresión regular que proporcione un patrón de mensajes que se deben ignorar.
Por ejemplo, el siguiente fragmento de código ignorará un mensaje de advertencia de tipo cadena:
ignoreWarning("Something sort of bad happened")Y el siguiente fragmento de código ignorará una expresión regular que coincida con varios posibles mensajes de advertencia:
ignoreWarning(new RegExp("[0-9]+ bad things happened"))Nota: A pesar de ser un objeto RegExp de JavaScript, no se interpretará como tal; en su lugar, el patrón se pasará a ` QRegularExpression`.
Véase también warn().
init()
Esta función se invoca antes de cada función de prueba que se ejecuta en el tipo TestCase. La implementación por defecto no realiza ninguna acción. La aplicación puede proporcionar su propia implementación para llevar a cabo la inicialización antes de cada función de prueba.
Véase también cleanup() y initTestCase().
initTestCase()
Esta función se invoca antes que cualquier otra función de prueba del tipo « TestCase ». La implementación predeterminada no realiza ninguna acción. La aplicación puede proporcionar su propia implementación para llevar a cabo la inicialización de los casos de prueba.
Véanse también « cleanupTestCase()» y « init()».
bool isPolishScheduled(object itemOrWindow)
Si ` itemOrWindow ` es un ` Item`, esta función devuelve ` true ` si no se ha llamado a ` updatePolish()` sobre él desde la última llamada a ` polish()`, y en caso contrario devuelve ` false`.
Desde Qt 6.5, si itemOrWindow es un Window, esta función devuelve true si no se ha llamado a updatePolish() en ningún elemento que gestione desde la última llamada a polish() en dichos elementos; en caso contrario, devuelve false.
Al asignar valores a propiedades en QML, es posible que cualquier ajuste de diseño que el elemento deba realizar como resultado de la asignación no surta efecto de forma inmediata, sino que se posponga hasta que el elemento se haya «pulido». En estos casos, puedes utilizar esta función para asegurarte de que los elementos se hayan «pulido» antes de que continúe la ejecución de la prueba. Por ejemplo:
verify(isPolishScheduled(item))
verify(waitForItemPolished(item))Sin la llamada a ` isPolishScheduled() ` anterior, la llamada a ` waitForItemPolished() ` podría detectar que no se ha programado ningún pulido y, por lo tanto, pasar al instante, suponiendo que el elemento ya se hubiera pulido. Esta función deja claro por qué un elemento no se ha pulido y permite que las pruebas fallen precozmente en tales circunstancias.
Véanse también waitForPolish(), QQuickItem::polish() y QQuickItem::updatePolish().
keyClick(key, modifiers = Qt.NoModifier, delay = -1)
Simula hacer clic en key con el valor opcional modifiers en el elemento que tiene el foco actualmente. Si delay es mayor que 0, la prueba esperará delay milisegundos.
Para obtener más información sobre los formatos aceptados de key, consulta Simulating Keyboard and Mouse Events.
El evento se enviará a la ventana TestCase o, en caso de que haya varias ventanas, a la ventana activa en ese momento. Consulte QGuiApplication::focusWindow() para obtener más detalles.
Véase también keyPress() y keyRelease().
keyPress(key, modifiers = Qt.NoModifier, delay = -1)
Simula pulsar un botón « key » con el valor opcional « modifiers » en el elemento que tiene el foco en ese momento. Si « delay » es mayor que 0, la prueba esperará « delay » milisegundos.
Para obtener más información sobre los formatos de key aceptados, consulta Simulating Keyboard and Mouse Events.
El evento se enviará a la ventana TestCase o, en caso de que haya varias ventanas, a la ventana activa en ese momento. Consulte QGuiApplication::focusWindow() para obtener más detalles.
Nota: En algún momento deberás soltar la tecla utilizando keyRelease().
Véanse también keyRelease() y keyClick().
keyRelease(key, modifiers = Qt.NoModifier, delay = -1)
Simula soltar un « key » con un « modifiers » opcional sobre el elemento que tiene el foco actualmente. Si « delay » es mayor que 0, la prueba esperará « delay » milisegundos.
Para obtener más información sobre los formatos de key aceptados, consulta Simulating Keyboard and Mouse Events.
El evento se enviará a la ventana TestCase o, en caso de que haya varias ventanas, a la ventana activa en ese momento. Consulte QGuiApplication::focusWindow() para obtener más detalles.
Véanse también keyPress() y keyClick().
keySequence(keySequence)
Simula la pulsación de keySequence. La secuencia de teclas puede configurarse como una de las siguientes: standard keyboard shortcuts, o bien puede describirse mediante una cadena que contenga una secuencia de hasta cuatro pulsaciones de teclas.
Cada evento se enviará a la ventana TestCase o, en caso de que haya varias ventanas, a la ventana activa en ese momento. Véase QGuiApplication::focusWindow() para obtener más detalles.
Véase también keyPress(), keyRelease(), GNU Emacs Style Key Sequences y Shortcut.sequence.
mouseClick(item, x = item.width / 2, y = item.height / 2, button = Qt.LeftButton, modifiers = Qt.NoModifier, delay = -1)
Simula hacer clic con el ratón en button con el texto opcional modifiers en item. La posición del clic viene definida por x y y. Si no se definen x y y, la posición será el centro de item. Si se especifica delay, la prueba esperará el número de milisegundos indicado antes de pulsar y antes de soltar el botón.
La posición indicada por x y y se transforma del sistema de coordenadas de item a coordenadas de ventana y, a continuación, se transmite. Si item queda oculto por otro elemento, o si un elemento secundario de item ocupa esa posición, el evento se transmitirá al otro elemento en su lugar.
Véase también mousePress(), mouseRelease(), mouseDoubleClickSequence(), mouseMove(), mouseDrag() y mouseWheel().
mouseDoubleClickSequence(item, x = item.width / 2, y = item.height / 2, button = Qt.LeftButton, modifiers = Qt.NoModifier, delay = -1)
Simula la secuencia completa de eventos generados al hacer doble clic con el ratón button, con la opción « modifiers » en item.
Este método reproduce la secuencia de eventos del ratón que se genera cuando un usuario realiza un doble clic: pulsar-soltar-pulsar-doble clic-soltar.
La posición del clic viene definida por x y y. Si x y y no están definidos, la posición será el centro de item. Si se especifica delay, la prueba esperará el número de milisegundos indicado antes de pulsar y antes de soltar el botón.
La posición indicada por x y y se transforma del sistema de coordenadas de item a coordenadas de ventana y, a continuación, se envía. Si item queda oculto por otro elemento, o si un elemento secundario de item ocupa esa posición, el evento se enviará al otro elemento en su lugar.
Este método Qml se introdujo en Qt 5.5.
Véase también mousePress(), mouseRelease(), mouseClick(), mouseMove(), mouseDrag() y mouseWheel().
mouseDrag(item, x, y, dx, dy, button = Qt.LeftButton, modifiers = Qt.NoModifier, delay = -1)
Simula arrastrar el ratón sobre un elemento ` item ` con la tecla ` button ` pulsada y, opcionalmente, la tecla ` modifiers `. La posición inicial del arrastre viene definida por ` x ` y ` y`, y la distancia de arrastre por ` dx ` y ` dy`. Si se especifica ` delay `, la prueba esperará el número de milisegundos indicado antes de soltar el botón.
La posición indicada por x y y se transforma del sistema de coordenadas de item a coordenadas de ventana y, a continuación, se transmite. Si item queda oculto por otro elemento, o si un elemento secundario de item ocupa esa posición, el evento se transmitirá al otro elemento en su lugar.
Véase también mousePress(), mouseClick(), mouseDoubleClickSequence(), mouseMove(), mouseRelease() y mouseWheel().
mouseMove(item, x = item.width / 2, y = item.height / 2, delay = -1, buttons = Qt.NoButton)
Mueve el puntero del ratón a la posición indicada por x y y dentro de item, mientras se mantiene pulsada la tecla buttons si se ha especificado. Desde Qt 6.0, si x y y no están definidos, la posición será el centro de item.
Si se especifica un delay (en milisegundos), la prueba esperará antes de mover el puntero del ratón.
La posición indicada por x y y se transforma del sistema de coordenadas de item a coordenadas de ventana y, a continuación, se envía. Si item queda oculto por otro elemento, o si un elemento secundario de item ocupa esa posición, el evento se enviará al otro elemento en su lugar.
Véase también mousePress(), mouseRelease(), mouseClick(), mouseDoubleClickSequence(), mouseDrag() y mouseWheel().
mousePress(item, x = item.width / 2, y = item.height / 2, button = Qt.LeftButton, modifiers = Qt.NoModifier, delay = -1)
Simula pulsar el botón del ratón button con el botón opcional modifiers en un item. La posición viene definida por x y y. Si no se definen x o y, la posición será el centro de item. Si se especifica delay, la prueba esperará el número de milisegundos indicado antes de realizar la pulsación.
La posición indicada por x y y se transforma del sistema de coordenadas de item a coordenadas de ventana y, a continuación, se transmite. Si item queda oculto por otro elemento, o si un elemento secundario de item ocupa esa posición, el evento se transmitirá al otro elemento en su lugar.
Véase también mouseRelease(), mouseClick(), mouseDoubleClickSequence(), mouseMove(), mouseDrag() y mouseWheel().
mouseRelease(item, x = item.width / 2, y = item.height / 2, button = Qt.LeftButton, modifiers = Qt.NoModifier, delay = -1)
Simula soltar el botón del ratón button con el evento opcional modifiers en un item. La posición en la que se suelta el botón viene definida por x y y. Si no se definen x o y, la posición será el centro de item. Si se especifica delay, la prueba esperará el número de milisegundos indicado antes de soltar el botón.
La posición indicada por x y y se transforma del sistema de coordenadas de item a coordenadas de ventana y, a continuación, se transmite. Si item queda oculto por otro elemento, o si un elemento secundario de item ocupa esa posición, el evento se transmitirá al otro elemento en su lugar.
Véase también mousePress(), mouseClick(), mouseDoubleClickSequence(), mouseMove(), mouseDrag() y mouseWheel().
mouseWheel(item, x, y, xDelta, yDelta, button = Qt.LeftButton, modifiers = Qt.NoModifier, delay = -1)
Simula el giro de la rueda del ratón en un item con button pulsado y, opcionalmente, modifiers. La posición del evento de la rueda se define mediante x y y. Si se especifica delay, la prueba esperará el número de milisegundos indicado antes de soltar el botón.
La posición indicada por x y y se transforma del sistema de coordenadas de item a coordenadas de ventana y, a continuación, se transmite. Si item queda oculto por otro elemento, o si un elemento secundario de item ocupa esa posición, el evento se transmitirá al otro elemento en su lugar.
Los parámetros « xDelta » y « yDelta » contienen la distancia de rotación de la rueda en octavos de grado. Véase QWheelEvent::angleDelta() para obtener más detalles.
Véanse también mousePress(), mouseClick(), mouseDoubleClickSequence(), mouseMove(), mouseRelease(), mouseDrag() y QWheelEvent::angleDelta().
skip(message = "")
Omite el caso de prueba actual y muestra el mensaje opcional « message ». Si se trata de una prueba basada en datos, solo se omite la fila actual. Es similar a « QSKIP(message) » en C++.
sleep(ms)
Permanece inactivo durante ms milisegundos sin procesar eventos de Qt.
Véase también wait() y waitForRendering().
TouchEventSequence touchEvent(object item)
Inicia una secuencia de eventos táctiles a través de una pantalla táctil simulada (QPointingDevice). Los eventos se envían a la ventana que contiene item.
El objeto devuelto se utiliza para enumerar los eventos que se enviarán a través de un único QTouchEvent. Los toques se envían a la ventana que contiene el TestCase, salvo que se especifique lo contrario.
Rectangle {
width: 640; height: 480
MultiPointTouchArea {
id: area
anchors.fill: parent
property bool touched: false
onPressed: touched = true
}
TestCase {
name: "ItemTests"
when: windowShown
id: test1
function test_touch() {
let touch = touchEvent(area);
touch.press(0, area, 10, 10);
touch.commit();
verify(area.touched);
}
}
}Véase también TouchEventSequence::press(), TouchEventSequence::move(), TouchEventSequence::release(), TouchEventSequence::stationary(), TouchEventSequence::commit() y QInputDevice::DeviceType.
tryCompare(obj, property, expected, timeout = 5000, message = "")
Hace que falle el caso de prueba actual si el valor especificado en « property » (en obj ) no coincide con el de « expected », y muestra el mensaje opcional « message ». La prueba se volverá a intentar varias veces hasta que se alcance el límite de « timeout » (en milisegundos).
Esta función está pensada para probar aplicaciones en las que el valor de una propiedad cambia en función de eventos asíncronos. Utiliza compare() para probar cambios sincrónicos en las propiedades.
tryCompare(img, "status", BorderImage.Ready)
compare(img.width, 120)
compare(img.height, 120)
compare(img.horizontalTileMode, BorderImage.Stretch)
compare(img.verticalTileMode, BorderImage.Stretch)SignalSpy::wait() ofrece un método alternativo para esperar a que se emita una señal.
Véanse también compare() y SignalSpy::wait().
tryVerify(function, timeout = 5000, message = "")
El caso de prueba actual falla si function no da como resultado true antes de que haya transcurrido el tiempo de espera especificado timeout (en milisegundos). La función se evalúa varias veces hasta que se alcanza el tiempo de espera. En caso de fallo, se muestra un mensaje opcional message.
Esta función está pensada para probar aplicaciones en las que una condición cambia en función de eventos asíncronos. Utiliza ` verify()` para probar cambios de condición síncronos y ` tryCompare()` para probar cambios de propiedad asíncronos.
Por ejemplo, en el código siguiente, no es posible utilizar ` tryCompare()`, ya que la propiedad ` currentItem ` podría ser ` null ` durante un breve periodo de tiempo:
tryCompare(listView.currentItem, "text", "Hello");En su lugar, podemos utilizar tryVerify() para comprobar primero que currentItem no es null y, a continuación, utilizar una comparación normal:
tryVerify(function(){ return listView.currentItem })
compare(listView.currentItem.text, "Hello")Véase también verify(), compare(), tryCompare() y SignalSpy::wait().
verify(condition, message = "")
Hace que falle el caso de prueba actual si ` condition ` es falso, y muestra el mensaje opcional ` message`. Es similar a ` QVERIFY(condition) ` o ` QVERIFY2(condition, message) ` en C++.
wait(ms)
Espera ms milisegundos mientras se procesan los eventos de Qt.
Nota: Este método utiliza un temporizador preciso para realizar la espera propiamente dicha. Es posible que el evento que se está esperando no lo haga. En concreto, cualquier animación, así como el tipo QML ` Timer `, puede utilizar temporizadores precisos o aproximados, dependiendo de diversos factores. En el caso de un temporizador aproximado, hay que tener en cuenta una desviación de alrededor del 5 % con respecto al temporizador preciso utilizado por TestCase::wait(). Sin embargo, Qt no puede ofrecer garantías absolutas sobre la desviación, ya que el sistema operativo no suele ofrecer garantías absolutas sobre los temporizadores.
Véase también sleep(), waitForRendering() y Qt::TimerType.
[since 6.5] bool waitForPolish(object windowOrItem, int timeout = 5000)
Si windowOrItem es un Item, esta función espera timeout milisegundos o hasta que isPolishScheduled(windowOrItem) devuelva false. Devuelve true si isPolishScheduled(windowOrItem) devuelve false en un plazo de timeout milisegundos; en caso contrario, devuelve false.
Si windowOrItem es una ventana, esta función espera timeout milisegundos o hasta que isPolishScheduled() devuelva false para todos los elementos gestionados por la ventana. Devuelve true si isPolishScheduled() devuelve false para todos los elementos en un plazo de timeout milisegundos; en caso contrario, devuelve false.
Este método se introdujo en Qt 6.5.
Véase también isPolishScheduled(), QQuickItem::polish() y QQuickItem::updatePolish().
waitForRendering(item, timeout = 5000)
Espera timeout milisegundos o hasta que el renderizador haya renderizado item. Devuelve «true» si item se ha renderizado en timeout milisegundos; en caso contrario, devuelve «false». El valor predeterminado de timeout es 5000.
Véase también sleep() y wait().
warn(message)
Muestra el mensaje de advertencia « message ». Es similar a « qWarning(message) » en C++.
Véase también ignoreWarning().
© 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.