QQuickTest Namespace | Qt Quick Test | Qt 6.10.3
Description: The QQuickTest namespace contains all the functions and macros related to Qt Quick Test.

- Qt 6.10
- Qt Quick Test
- QQuickTest Namespace
- Qt 6.10.3 Reference Documentation

# QQuickTest Namespace

The QQuickTest namespace contains all the functions and macros related to Qt Quick Test. More...

Header: | `#include <QtQuickTest>`

- Deprecated members

## Functions

bool | qIsPolishScheduled(const QQuickItem *item)
`(since 6.4)` bool | qIsPolishScheduled(const QQuickWindow *window)
`(since 6.4)` bool | qWaitForPolish(const QQuickItem *item, int timeout = defaultTimeout)
`(since 6.4)` bool | qWaitForPolish(const QQuickWindow *window, int timeout = defaultTimeout)

## Macros

`(since 6.10)` | QTRY_VERIFY_ACTIVE_FOCUS(item)
| QUICK_TEST_MAIN(name)
| QUICK_TEST_MAIN_WITH_SETUP(name, QuickTestSetupClass)
`(since 6.10)` | QVERIFY_ACTIVE_FOCUS(item)

## Detailed Description

See the Introduction to Qt Quick Test for information about how to write Qt Quick unit tests.

To link to the Qt Quick Test C++ library, see Qt Quick Test C++ API.

See also Executing C++ Before QML Tests.

## Function Documentation

### bool QQuickTest::qIsPolishScheduled(const QQuickItem *item)

Returns `true` if updatePolish() has not been called on item since the last call to polish(), otherwise returns `false`.

When assigning values to properties in QML, any layouting the item must do as a result of the assignment might not take effect immediately, but can instead be postponed until the item is polished. For these cases, you can use this function to ensure that the item has been polished before the execution of the test continues. For example:

     QVERIFY(QQuickTest::qIsPolishScheduled(item));
     QVERIFY(QQuickTest::qWaitForItemPolished(item));

Without the call to `qIsPolishScheduled()` above, the call to `qWaitForItemPolished()` might see that no polish was scheduled and therefore pass instantly, assuming that the item had already been polished. This function makes it obvious why an item wasn't polished and allows tests to fail early under such circumstances.

The QML equivalent of this function is isPolishScheduled().

See also QQuickItem::polish() and QQuickItem::updatePolish().

### `[since 6.4]` bool QQuickTest::qIsPolishScheduled(const QQuickWindow *window)

Returns `true` if there are any items managed by this window for which `qIsPolishScheduled(item)` returns `true`, otherwise returns `false`.

For example, if an item somewhere within the scene may or may not be polished, but you need to wait for it if it is, you can use the following code:

     if (QQuickTest::qIsPolishScheduled(window))
         QVERIFY(QQuickTest::qWaitForPolish(window));

The QML equivalent of this function is isPolishScheduled().

This function overloads QQuickTest::qIsPolishScheduled().

This function was introduced in Qt 6.4.

See also QQuickItem::polish(), QQuickItem::updatePolish(), and QQuickTest::qWaitForPolish().

### `[since 6.4]` bool QQuickTest::qWaitForPolish(const QQuickItem *item, int timeout = defaultTimeout)

Waits for timeout milliseconds or until updatePolish() has been called on item.

Returns `true` if `updatePolish()` was called on item within timeout milliseconds, otherwise returns `false`.

This function was introduced in Qt 6.4.

See also QQuickItem::polish(), QQuickItem::updatePolish(), and QQuickTest::qIsPolishScheduled().

### `[since 6.4]` bool QQuickTest::qWaitForPolish(const QQuickWindow *window, int timeout = defaultTimeout)

Waits for timeout milliseconds or until `qIsPolishScheduled(item)` returns `false` for all items managed by window.

Returns `true` if `qIsPolishScheduled(item)` returns false for all items within timeout milliseconds, otherwise returns `false`.

The QML equivalent of this function is waitForPolish().

This function was introduced in Qt 6.4.

See also QQuickItem::polish(), QQuickItem::updatePolish(), and QQuickTest::qIsPolishScheduled().

## Macro Documentation

### `[since 6.10]` QTRY_VERIFY_ACTIVE_FOCUS(item)

This macro does the same check as QVERIFY_ACTIVE_FOCUS with item, but repeatedly, until either the condition becomes true or the timeout (in milliseconds) is reached. Between each evaluation, events will be processed. If the timeout is reached, a failure is recorded in the test log and the test won't be executed further.

Note: This macro can only be used in a test function that is invoked by the test framework.

This macro was introduced in Qt 6.10.

### QUICK_TEST_MAIN(name)

Sets up the entry point for a Qt Quick Test application. The name argument uniquely identifies this set of tests.

     #include <QtQuickTest>
     QUICK_TEST_MAIN(example)

Note: The macro assumes that your test sources are in the current directory, unless the `QUICK_TEST_SOURCE_DIR` environment variable is set.

See also QUICK_TEST_MAIN_WITH_SETUP() and Running Qt Quick Tests.

### QUICK_TEST_MAIN_WITH_SETUP(name, QuickTestSetupClass)

Sets up the entry point for a Qt Quick Test application. The name argument uniquely identifies this set of tests.

This macro is identical to QUICK_TEST_MAIN(), except that it takes an additional argument QuickTestSetupClass, the type of a QObject-derived class which will be instantiated. With this class it is possible to define additional setup code to execute before running the QML test.

Note: The macro assumes that your test sources are in the current directory, unless the `QUICK_TEST_SOURCE_DIR` environment variable is set.

The following snippet demonstrates the use of this macro:

     // src_qmltest_qquicktest.cpp
     #include <QtQuickTest>
     #include <QQmlEngine>
     #include <QQmlContext>
     #include <QGuiApplication>

     class Setup : public QObject
     {
         Q_OBJECT

     public:
         Setup() {}

     public slots:
         void applicationAvailable()
         {
             // Initialization that only requires the QGuiApplication object to be available
         }

         void qmlEngineAvailable(QQmlEngine *engine)
         {
             // Initialization requiring the QQmlEngine to be constructed
             engine->rootContext()->setContextProperty("myContextProperty", QVariant(true));
         }

         void cleanupTestCase()
         {
             // Implement custom resource cleanup
         }
     };

     QUICK_TEST_MAIN_WITH_SETUP(mytest, Setup)

     #include "src_qmltest_qquicktest.moc"

See also QUICK_TEST_MAIN() and Running Qt Quick Tests.

### `[since 6.10]` QVERIFY_ACTIVE_FOCUS(item)

Checks whether the item (which must be derived from QQuickItem) has active focus. If it does, execution continues. If not, a failure is recorded in the test log and the test won't be executed further. The failure message contains focus-specific information that is relevant for diagnosing the cause of the failure.

Note: This macro can only be used in a test function that is invoked by the test framework.

This macro was introduced in Qt 6.10.