TestCase QML Type

Representa un caso de prueba unitaria. Más...

• Lista de todos los miembros, incluidos los heredados
• Miembros obsoletos

Propiedades

• completed : bool
• name : string
• optional : bool
• running : bool
• when : bool
• windowShown : bool

Métodos

• cleanup()
• cleanupTestCase()
• compare(actual, expected, message)
• object createTemporaryObject(Component component, object parent, object properties)
• object createTemporaryQmlObject(string qml, object 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)
• object grabImage(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 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 empiezan por "test_" se tratan como casos de prueba a ejecutar. 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 a la forma en que funcionan las propiedades de JavaScript, el orden en que se encuentran las funciones de prueba es impredecible. Para ayudar a la previsibilidad, el marco de pruebas ordenará las funciones en orden ascendente de nombre. Esto puede ayudar cuando hay dos pruebas que deben ejecutarse en orden.

Se pueden suministrar varios tipos de TestCase. El programa de prueba saldrá una vez que se hayan completado todos. Si un caso de prueba no necesita ejecutarse (porque una precondición ha fallado), entonces optional puede establecerse en true.

Pruebas basadas en datos

Los datos de una tabla pueden introducirse en una prueba utilizando un nombre de función que termine en "_data". También se puede utilizar la función init_data() para proporcionar datos de prueba predeterminados para todas las funciones de prueba que no tengan una función "_data" coincidente 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 iterará sobre todas las filas de la tabla y pasará cada fila a la función de prueba. Como se muestra, se pueden extraer las columnas para utilizarlas en la prueba. La columna tag es especial: el marco de pruebas la imprime cuando falla una fila, para ayudar al lector a identificar qué caso ha fallado entre un conjunto de pruebas que, por lo demás, han pasado.

Puntos de referencia

Las funciones cuyos nombres empiecen por "benchmark_" se ejecutarán varias veces con el marco de pruebas Qt, y se informará de un valor de tiempo medio de las ejecuciones. Esto equivale a utilizar la macro QBENCHMARK en la versión 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 al nombre de la función de prueba "benchmark_once_".

Simulación de eventos de teclado y ratón

Los métodos keyPress(), keyRelease() y keyClick() pueden utilizarse para simular eventos de teclado dentro de las pruebas unitarias. Los eventos se envían al elemento QML actualmente enfocado. Se puede pasar un valor enum Qt.Key o un carácter latino1 (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 su prueba crea otras ventanas, es posible que esas ventanas se activen, robando el foco de la ventana del TestCase. Para asegurarse de que la ventana del TestCase está activa, utilice el siguiente código:

testCase.Window.window.requestActivate()
tryCompare(testCase.Window.window, "active", true)

Nota: los eventos de teclado y ratón sólo pueden ser entregados una vez que la ventana principal ha sido mostrada. Los intentos de enviar eventos antes de ese momento fallarán. Use las propiedades when y windowShown para rastrear cuando la ventana principal ha sido mostrada.

Gestión de objetos de prueba creados dinámicamente

Un patrón típico con las pruebas QML es crear dinámicamente un objeto y luego 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 con este patrón es que cualquier fallo en la función de prueba hará que se salte la llamada a item.destroy(), dejando el elemento en la escena hasta que el caso de prueba haya terminado. Esto puede provocar interferencias con futuras pruebas; por ejemplo, bloqueando eventos de entrada o produciendo una salida de depuración no relacionada que dificulte el seguimiento de la ejecución del código.

En cambio, si se llama a createTemporaryQmlObject(), se garantiza la destrucción del objeto 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, puede utilizarse la función createTemporaryObject().

Separar las pruebas de la lógica de la aplicación

En la mayoría de los casos, querrá separar sus pruebas de la lógica de la aplicación dividiéndolas en diferentes proyectos y enlazándolas.

Por ejemplo, podría tener la siguiente estructura de proyecto:

.
| — CMakeLists.txt
| — main.cpp
| - main.qml
| — MyModule
    | — MyButton.qml
    | — CMakeLists.txt
| — tests
    | — tst_testqml.qml
    | — main.cpp
    | — setup.cpp
    | — setup.h

Ahora, para probar MyModule/MyButton.qml, cree una biblioteca para MyModule en MyModule/CMakeLists.txt y vincúlela a su proyecto de prueba, 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, puede 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);
        }
    }
}

import QtQuick
import QtQuick.Controls

Button {
    width: 50
    height: 50
    onClicked: width = 100
}

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 completado su ejecución. Los casos de prueba sólo se ejecutan una vez. El valor inicial es false.

Véase también running y when.

name : string

Esta propiedad define el nombre del caso de prueba para el informe de resultados. El valor por defecto es una cadena vacía.

TestCase {
    name: "ButtonTests"
    ...
}

optional : bool

En una aplicación de prueba pueden suministrarse varios tipos de TestCase. La aplicación se cerrará cuando se hayan completado todos. Si un caso de prueba no necesita ejecutarse (porque una precondición ha fallado), entonces esta propiedad puede establecerse a true. El valor por defecto es false.

TestCase {
    when: false
    optional: true
    function test_not_run() {
        verify(false)
    }
}

Véase también when y completed.

running : bool

Esta propiedad se establecerá en true mientras se esté ejecutando el caso de prueba. El valor inicial es false, y el valor volverá a ser false una vez finalizado el caso de prueba.

Véase también completed y when.

when : bool

Esta propiedad debe establecerse en true cuando la aplicación desea 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 prueba saldrá una vez que todos los tipos de TestCase se hayan disparado y ejecutado. La propiedad optional puede utilizarse para excluir un tipo TestCase.

Véase también optional y completed.

windowShown : bool

Esta propiedad se establecerá en true después de que se haya mostrado la ventana de visualización 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 involucra tipos visuales y comportamientos, entonces puede ser necesario retrasarlo hasta después de que se muestre 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 llama después de cada función de prueba que se ejecuta en el tipo TestCase. La implementación por defecto no hace nada. La aplicación puede proporcionar su propia implementación para realizar la limpieza después de cada función de prueba.

Véase también init() y cleanupTestCase().

cleanupTestCase()

Esta función se llama después de que todas las demás funciones de prueba del tipo TestCase hayan finalizado. La implementación por defecto no hace nada. La aplicación puede proporcionar su propia implementación para realizar la limpieza del caso de prueba.

Véase también initTestCase() y cleanup().

compare(actual, expected, message = "")

Falla el caso de prueba actual si actual no es el mismo que expected, y muestra el opcional message. Similar a QCOMPARE(actual, expected) en C++.

Véase también tryCompare() y fuzzyCompare.

object createTemporaryObject(Component component, object parent, object properties)

Esta función crea dinámicamente un objeto QML a partir del component dado con los parent y properties opcionales especificados. El objeto devuelto será destruido (si no lo estaba ya) después de que cleanup() haya terminado de ejecutarse, lo que significa que los objetos creados con esta función tienen garantizada su destrucción después de cada prueba, independientemente de si las pruebas fallan o no.

Si se ha producido 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.

object createTemporaryQmlObject(string qml, object parent, string filePath)

Esta función crea dinámicamente un objeto QML a partir de la cadena qml dada con el parent especificado. El objeto devuelto será destruido (si no lo estaba ya) después de que cleanup() haya terminado de ejecutarse, lo que significa que los objetos creados con esta función tienen garantizada su destrucción después de cada prueba, independientemente de si las pruebas fallan o no.

Si se ha producido un error al crear el objeto, se devolverá null.

Si se especifica filePath, se utilizará para informar de errores en el 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 que se espera que falle. Cuando se produce el fallo, muestra message, aborta 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, 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 que se espera que falle. Cuando se produce el fallo, muestra message y, a continuación, continúa la prueba. Similar a QEXPECT_FAIL(tag, message, Continue) en C++.

Si la prueba no está basada en datos, tag debe establecerse como una cadena vacía.

Véase también expectFail().

fail(message = "")

Falla el caso de prueba actual, con la opción message. 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á la ejecución cuando se añada un fallo.

message puede ser una cadena o una expresión regular que proporcione un patrón de mensajes. En este último caso, por cada advertencia encontrada, 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 fallará una prueba si se produce una advertencia con el texto "Ha ocurrido algo malo":

failOnWarning("Something bad happened")

El siguiente fragmento fallará una prueba si se encuentra cualquier advertencia que coincida con el patrón dado:

failOnWarning(/[0-9]+ bad things happened/)

Para fallar cada prueba que desencadene una advertencia dada, pase una expresión regular adecuada a esta función en init():

function init() {
    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 hijo de parent con objectName, o null si no existe tal elemento. Tanto los hijos visuales como los no visuales se buscan recursivamente, siendo los visuales los primeros en buscarse.

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 valor opcional message. Similar a qFuzzyCompare(actual, expected) en C++ pero con un valor delta requerido.

Esta función también puede utilizarse para comparaciones de color si los valores actual y expected pueden convertirse en valores de color. Si alguna de las diferencias para los valores del canal RGBA es mayor que delta, la prueba falla.

Véase también tryCompare() y compare().

object grabImage(item)

Devuelve un objeto imagen instantánea de la dirección item.

El objeto imagen devuelto tiene las siguientes propiedades:

• width Devuelve la anchura de la imagen subyacente (desde 5.10)
• height Devuelve la altura de la imagen subyacente (desde 5.10)
• size Devuelve el tamaño de la imagen subyacente (desde 5.10)

Además, el objeto imagen devuelto tiene los siguientes métodos:

• red(x, y) Devuelve el valor del canal rojo del píxel en la posición x, y
• green(x, y) Devuelve el valor del canal verde del píxel en la posición x, y
• blue(x, y) Devuelve el valor del canal azul del píxel en la posición x, y
• alpha(x, y) Devuelve el valor del canal alfa del píxel en la posición x, y
• pixel(x, y) Devuelve el valor del color del píxel en la posición x, y
• equals(image) Devuelve true si esta imagen es idéntica a la imagen - véase QImage::operator== (desde 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 la imagen no se puede guardar, se lanzará una excepción. (desde 5.10)

  Esto puede ser útil para realizar análisis postmortem en 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 mensaje de advertencia ignorado. Cuando se produzca, no se imprimirá la advertencia y la prueba pasará. Si el mensaje no se produce, la prueba fallará. Similar a QTest::ignoreMessage(QtWarningMsg, message) en C++.

Desde Qt 5.12, message puede ser una cadena o una expresión regular que proporcione un patrón de mensajes a ignorar.

Por ejemplo, el siguiente fragmento ignorará un mensaje de advertencia de cadena:

ignoreWarning("Something sort of bad happened")

Y el siguiente fragmento ignorará una expresión regular que coincida con una serie de posibles mensajes de advertencia:

ignoreWarning(new RegExp("[0-9]+ bad things happened"))

Véase también warn().

init()

Esta función se llama antes de cada función de prueba que se ejecuta en el tipo TestCase. La implementación por defecto no hace nada. La aplicación puede proporcionar su propia implementación para realizar la inicialización antes de cada función de prueba.

Véase también cleanup() y initTestCase().

initTestCase()

Esta función se llama antes que cualquier otra función de prueba en el tipo TestCase. La implementación por defecto no hace nada. La aplicación puede proporcionar su propia implementación para realizar la inicialización del caso de prueba.

Véase también cleanupTestCase() y init().

bool isPolishScheduled(object itemOrWindow)

Si itemOrWindow es un Item, esta función devuelve true si updatePolish() no ha sido llamada sobre él desde la última llamada a polish(), 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 ninguno de los elementos que gestiona desde la última llamada a polish() en esos elementos, en caso contrario devuelve false.

Cuando se asignan valores a propiedades en QML, cualquier diseño que el elemento deba hacer como resultado de la asignación puede no tener efecto inmediatamente, sino que puede ser pospuesto hasta que el elemento sea pulido. En estos casos, puede utilizar esta función para asegurarse de que los elementos se han 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 ver que no había ningún pulido programado y, por tanto, pasar al instante, suponiendo que el elemento ya había sido pulido. Esta función hace que sea obvio por qué no se ha pulido un elemento y permite que las pruebas fallen antes en tales circunstancias.

Véase también waitForPolish(), QQuickItem::polish(), y QQuickItem::updatePolish().

keyClick(key, modifiers = Qt.NoModifier, delay = -1)

Simula el clic de key con modifiers opcional en el elemento actualmente enfocado. Si delay es mayor que 0, la prueba esperará delay milisegundos.

El evento se enviará a la ventana TestCase o, en caso de múltiples ventanas, a la ventana activa en ese momento. Véase QGuiApplication::focusWindow() para más detalles.

Véase también keyPress() y keyRelease().

keyPress(key, modifiers = Qt.NoModifier, delay = -1)

Simula la pulsación de un key con modifiers opcional en el elemento actualmente enfocado. Si delay es mayor que 0, la prueba esperará delay milisegundos.

El evento se enviará a la ventana TestCase o, en caso de múltiples ventanas, a la ventana activa en ese momento. Véase QGuiApplication::focusWindow() para más detalles.

Nota: En algún momento deberás soltar la tecla utilizando keyRelease().

Véase también keyRelease() y keyClick().

keyRelease(key, modifiers = Qt.NoModifier, delay = -1)

Simula la liberación de un key con modifiers opcional en el elemento actualmente enfocado. Si delay es mayor que 0, la prueba esperará delay milisegundos.

El evento se enviará a la ventana TestCase o, en caso de múltiples ventanas, a la ventana activa en ese momento. Véase QGuiApplication::focusWindow() para más detalles.

Véase también keyPress() y keyClick().

keySequence(keySequence)

Simula la escritura de keySequence. La secuencia de teclas puede ajustarse a una de las standard keyboard shortcuts, o puede describirse con una cadena que contenga una secuencia de hasta cuatro pulsaciones de teclas.

Cada evento se enviará a la ventana TestCase o, en caso de múltiples ventanas, a la ventana activa en ese momento. Véase QGuiApplication::focusWindow() para 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 el clic de un ratón button con modifiers opcional en un item. La posición del clic se define mediante x y y. Si x y y no se definen, la posición será el centro de item. Si se especifica delay, la prueba esperará la cantidad especificada de milisegundos antes de pulsar y antes de soltar el botón.

La posición dada por x y y se transforma del sistema de coordenadas de item a coordenadas de ventana y luego se entrega. Si item está oculto por otro elemento, o un hijo de item ocupa esa posición, el evento se enviará al otro elemento.

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 modifiers opcional en un item.

Este método reproduce la secuencia de eventos del ratón generados cuando un usuario hace doble clic: Pulsar-Liberar-Pulsar-DobleClic-Liberar.

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á la cantidad de milisegundos especificada antes de pulsar y antes de soltar el botón.

La posición dada por x y y se transforma del sistema de coordenadas de item a coordenadas de ventana y luego se entrega. Si item está oculto por otro elemento, o un hijo de item ocupa esa posición, el evento se enviará al otro elemento.

Este método QML se introdujo en Qt 5.5.

Ver también mousePress(), mouseRelease(), mouseClick(), mouseMove(), mouseDrag(), y mouseWheel().

mouseDrag(item, x, y, dx, dy, button = Qt.LeftButton, modifiers = Qt.NoModifier, delay = -1)

Simula el arrastre del ratón sobre un item con button pulsado y modifiers opcional. La posición inicial de arrastre se define mediante x y y, y la distancia de arrastre se define mediante dx y dy. Si se especifica delay, la prueba esperará la cantidad especificada de milisegundos antes de soltar el botón.

La posición dada por x y y se transforma del sistema de coordenadas de item a coordenadas de ventana y luego se entrega. Si item está oculto por otro elemento, o un hijo de item ocupa esa posición, el evento se enviará al otro elemento.

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 dada por x y y dentro de item, mientras mantiene buttons si se da. Desde Qt 6.0, si x y y no están definidos, la posición será el centro de item.

Si se da un delay (en milisegundos), la prueba esperará antes de mover el puntero del ratón.

La posición dada por x y y se transforma del sistema de coordenadas de item a coordenadas de ventana y luego se entrega. Si item está oculto por otro elemento, o un elemento secundario de item ocupa esa posición, el evento se enviará al otro elemento.

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 la pulsación de un ratón button con modifiers opcional 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á la cantidad de milisegundos especificada antes de la pulsación.

La posición dada por x y y se transforma del sistema de coordenadas de item a coordenadas de ventana y luego se entrega. Si item está oculto por otro elemento, o un elemento secundario de item ocupa esa posición, el evento se enviará al otro elemento.

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 la liberación de un ratón button con modifiers opcional en un item. La posición de la liberación está definida por x y y. Si x o y no están definidos, la posición será el centro de item. Si se especifica delay, la prueba esperará la cantidad especificada de milisegundos antes de liberar el botón.

La posición dada por x y y se transforma del sistema de coordenadas de item a coordenadas de ventana y luego se entrega. Si item está oculto por otro elemento, o un hijo de item ocupa esa posición, el evento se enviará al otro elemento.

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 la rotación de la rueda del ratón en un item con button pulsado y modifiers opcional. La posición del evento de la rueda está definida por x y y. Si se especifica delay, la prueba esperará la cantidad especificada de milisegundos antes de soltar el botón.

La posición dada por x y y se transforma del sistema de coordenadas de item a coordenadas de ventana y luego se entrega. Si item está oculto por otro elemento, o un elemento secundario de item ocupa esa posición, el evento se enviará al otro elemento.

xDelta y yDelta contienen la distancia de rotación de la rueda en octavos de grado. véase QWheelEvent::angleDelta() para más detalles.

Véase también mousePress(), mouseClick(), mouseDoubleClickSequence(), mouseMove(), mouseRelease(), mouseDrag(), y QWheelEvent::angleDelta().

skip(message = "")

Salta el caso de prueba actual e imprime la dirección opcional message. Si se trata de una prueba basada en datos, sólo se omitirá la fila actual. Similar a QSKIP(message) en C++.

sleep(ms)

Permanece inactivo durante ms milisegundos sin procesar eventos 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 entregarán a través de un único QTouchEvent. Los toques se envían a la ventana que contiene TestCase a menos 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 = "")

Falla el caso de prueba actual si el property especificado en obj no es el mismo que expected, y muestra el message opcional. La prueba se reintentará varias veces hasta que se alcance el timeout (en milisegundos).

Esta función está pensada para probar aplicaciones en las que una propiedad cambia de valor en función de eventos asíncronos. Utilice compare() para probar cambios de propiedades sincrónicas.

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() proporciona un método alternativo para esperar a que se emita una señal.

Véase también compare() y SignalSpy::wait().

tryVerify(function, timeout = 5000, message = "")

Falla el caso de prueba actual si function no se evalúa en true antes de que transcurra el tiempo especificado en timeout (en milisegundos). La función se evalúa varias veces hasta que se alcanza el tiempo de espera. En caso de error, 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. Utilice 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(), porque la propiedad currentItem podría ser null durante un corto período de tiempo:

tryCompare(listView.currentItem, "text", "Hello");

En su lugar, podemos utilizar tryVerify() para comprobar primero que currentItem no es null, y después utilizar una comparación regular:

tryVerify(function(){ return listView.currentItem })
compare(listView.currentItem.text, "Hello")

Véase también verify(), compare(), tryCompare(), y SignalSpy::wait().

verify(condition, message = "")

Falla el caso de prueba actual si condition es falso, y muestra el message opcional. Similar a QVERIFY(condition) o QVERIFY2(condition, message) en C++.

wait(ms)

Espera durante ms milisegundos mientras procesa eventos Qt.

Ver también sleep(), waitForRendering(), y Qt::TimerType.

[since 6.5] bool waitForPolish(object windowOrItem, int timeout = 5000)

Si windowOrItem es un elemento, esta función espera durante timeout milisegundos o hasta que isPolishScheduled(windowOrItem) devuelva false. Devuelve true si isPolishScheduled(windowOrItem) devuelve false en timeout milisegundos, en caso contrario devuelve false.

Si windowOrItem es una ventana, esta función espera durante 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 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 durante timeout milisegundos o hasta que item es renderizado por el renderizador. Devuelve true si item se renderiza en timeout milisegundos, en caso contrario devuelve false. El valor por defecto de timeout es 5000.

Véase también sleep() y wait().

warn(message)

Imprime message como mensaje de advertencia. Similar a qWarning(message) en C++.

Véase también ignoreWarning().