QTest Namespace

Function Documentation

template <typename T> void QTest::addColumn(const char *name, T *dummy = 0)

Adds a column with type T to the current test data. name is the name of the column. dummy is a workaround for buggy compilers and can be ignored.

To populate the column with values, newRow() can be used. Use QFETCH() to fetch the data in the actual test.

Example:

     QTest::addColumn<int>("intval");
     QTest::addColumn<QString>("str");
     QTest::addColumn<double>("dbl");
     QTest::newRow("row1") << 1 << "hello" << 1.5;

To add custom types to the testdata, the type must be registered with QMetaType via Q_DECLARE_METATYPE().

See Data Driven Testing for a more extensive example.

See also QTest::newRow(), QFETCH(), and QMetaType.

QTestData &QTest::addRow(const char *format, ...)

Appends a new row to the current test data.

The function's arguments are passed to qsnprintf() for formatting according to format. See the qvsnprintf() documentation for caveats and limitations.

The test output will identify the test run with this test data using the name that results from this formatting.

Returns a QTestData reference that can be used to stream in data, one value for each column in the table.

Example:

     QTest::addColumn<int>("input");
     QTest::addColumn<QString>("output");
     QTest::addRow("%d", 0) << 0 << QString("0");
     QTest::addRow("%d", 1) << 1 << QString("1");

See Data Driven Testing for a more extensive example.

See also newRow(), addColumn(), and QFETCH().

const char *QTest::benchmarkMetricName(QTest::QBenchmarkMetric metric)

Returns the enum value metric as a character string.

const char *QTest::benchmarkMetricUnit(QTest::QBenchmarkMetric metric)

Returns the units of measure for the specified metric.

QPointingDevice *QTest::createTouchDevice(QInputDevice::DeviceType devType = QInputDevice::DeviceType::TouchScreen, QInputDevice::Capabilities caps = QInputDevice::Capability::Position)

Creates a dummy touch device of type devType with capabilities caps for simulation of touch events.

The touch device will be registered with the Qt window system interface. You should typically use createTouchDevice() to initialize a QPointingDevice member variable in your test case class, use the same instance for all tests and delete it when no longer needed.

See also QTest::QTouchEventSequence and touchEvent().

const char *QTest::currentAppName()

Returns the name of the binary that is currently executed.

const char *QTest::currentDataTag()

Returns the name of the current test data. If the test doesn't have any assigned testdata, the function returns nullptr.

bool QTest::currentTestFailed()

Returns true if the current test function has failed, otherwise false.

See also QTest::currentTestResolved().

const char *QTest::currentTestFunction()

Returns the name of the test function that is currently executed.

Example:

 void MyTestClass::cleanup()
 {
     if (qstrcmp(QTest::currentTestFunction(), "myDatabaseTest") == 0) {
         // clean up all database connections
         closeAllDatabases();
     }
 }

[since 6.5] bool QTest::currentTestResolved()

Returns true if the current test function has failed or skipped.

This applies if the test has failed or exercised a skip. When it is true, the test function should return early. In particular, the QTRY_* macros and the test event loop terminate their loops early if executed during the test function (but not its cleanup()). After a test has called a helper function that uses this module's macros, it can use this function to test whether to return early.

This function was introduced in Qt 6.5.

See also QTest::currentTestFailed().

[since 6.3] void QTest::failOnWarning(const QRegularExpression &messagePattern)

Appends a test failure to the test log for each warning that matches messagePattern.

The test function will continue execution when a failure is added. To abort the test instead, you can check currentTestFailed() and return early if it's true.

For each warning, the first pattern that matches will cause a failure, and the remaining patterns will be ignored.

All patterns are cleared at the end of each test function.

 void FileTest::loadFiles()
 {
     QTest::failOnWarning(QRegularExpression("^Failed to load"));

     // Each of these will cause a test failure:
     qWarning() << "Failed to load image";
     qWarning() << "Failed to load video";
 }

To fail every test that triggers a given warning, pass a suitable regular expression to this function in init():

 void FileTest::init()
 {
     QTest::failOnWarning(QRegularExpression(".?"));
 }

This function was introduced in Qt 6.3.

See also QTEST_FATAL_FAIL.

[since 6.3] void QTest::failOnWarning(const char *message)

This function overloads failOnWarning().

Appends a test failure to the test log if the message is output.

This function was introduced in Qt 6.3.

See also failOnWarning().

void QTest::ignoreMessage(QtMsgType type, const char *message)

Ignores messages created by qDebug(), qInfo() or qWarning(). If the message with the corresponding type is outputted, it will be removed from the test log. If the test finished and the message was not outputted, a test failure is appended to the test log.

Example:

 QDir dir;
 QTest::ignoreMessage(QtWarningMsg, "QDir::mkdir: Empty or null file name(s)");
 dir.mkdir("");

The example above tests that QDir::mkdir() outputs the right warning when invoked with an invalid file name.

void QTest::ignoreMessage(QtMsgType type, const QRegularExpression &messagePattern)

This is an overloaded function.

Ignores messages created by qDebug(), qInfo() or qWarning(). If the message matching messagePattern with the corresponding type is outputted, it will be removed from the test log. If the test finished and the message was not outputted, a test failure is appended to the test log.

void QTest::keyClick(QWidget *widget, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)

Simulates clicking of key with an optional modifier on a widget. If delay is larger than 0, the test will wait for delay milliseconds before clicking the key.

Examples:

 QTest::keyClick(myWidget, Qt::Key_Escape);

 QTest::keyClick(myWidget, Qt::Key_Escape, Qt::ShiftModifier, 200);

The first example above simulates clicking the escape key on myWidget without any keyboard modifiers and without delay. The second example simulates clicking shift-escape on myWidget following a 200 ms delay of the test.

See also QTest::keyClicks().

void QTest::keyClick(QWindow *window, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)

This is an overloaded function.

Simulates clicking of key with an optional modifier on a window. If delay is larger than 0, the test will wait for delay milliseconds before clicking the key.

Examples:

 QTest::keyClick(&myWindow, Qt::Key_Escape);
 QTest::keyClick(&myWindow, Qt::Key_Escape, Qt::ShiftModifier, 200);

The first example above simulates clicking the escape key on myWindow without any keyboard modifiers and without delay. The second example simulates clicking shift-escape on myWindow following a 200 ms delay of the test.

See also QTest::keyClicks().

void QTest::keyClick(QWindow *window, char key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)

This is an overloaded function.

Simulates clicking of key with an optional modifier on a window. If delay is larger than 0, the test will wait for delay milliseconds before clicking the key.

Example:

 QWidget myWindow;
 QTest::keyClick(&myWindow, Qt::Key_Tab);

The example above simulates clicking a on myWindow without any keyboard modifiers and without delay of the test.

See also QTest::keyClicks().

void QTest::keyClick(QWidget *widget, char key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)

This is an overloaded function.

Simulates clicking of key with an optional modifier on a widget. If delay is larger than 0, the test will wait for delay milliseconds before clicking the key.

Example:

 QTest::keyClick(myWidget, 'a');

The example above simulates clicking a on myWidget without any keyboard modifiers and without delay of the test.

See also QTest::keyClicks().

void QTest::keyClicks(QWidget *widget, const QString &sequence, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)

Simulates clicking a sequence of keys on a widget. Optionally, a keyboard modifier can be specified as well as a delay (in milliseconds) of the test before each key click.

Example:

 QTest::keyClicks(myWidget, "hello world");

The example above simulates clicking the sequence of keys representing "hello world" on myWidget without any keyboard modifiers and without delay of the test.

See also QTest::keyClick().

void QTest::keyEvent(QTest::KeyAction action, QWidget *widget, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)

Sends a Qt key event to widget with the given key and an associated action. Optionally, a keyboard modifier can be specified, as well as a delay (in milliseconds) of the test before sending the event.

void QTest::keyEvent(QTest::KeyAction action, QWindow *window, char ascii, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)

This is an overloaded function.

Sends a Qt key event to window with the given key ascii and an associated action. Optionally, a keyboard modifier can be specified, as well as a delay (in milliseconds) of the test before sending the event.

void QTest::keyEvent(QTest::KeyAction action, QWindow *window, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)

This is an overloaded function.

Sends a Qt key event to window with the given key and an associated action. Optionally, a keyboard modifier can be specified, as well as a delay (in milliseconds) of the test before sending the event.

void QTest::keyEvent(QTest::KeyAction action, QWidget *widget, char ascii, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)

This is an overloaded function.

Sends a Qt key event to widget with the given key ascii and an associated action. Optionally, a keyboard modifier can be specified, as well as a delay (in milliseconds) of the test before sending the event.

void QTest::keyPress(QWidget *widget, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)

Simulates pressing a key with an optional modifier on a widget. If delay is larger than 0, the test will wait for delay milliseconds before pressing the key.

See also QTest::keyRelease() and QTest::keyClick().

void QTest::keyPress(QWindow *window, char key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)

This is an overloaded function.

Simulates pressing a key with an optional modifier on a window. If delay is larger than 0, the test will wait for delay milliseconds before pressing the key.

See also QTest::keyRelease() and QTest::keyClick().

void QTest::keyPress(QWindow *window, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)

This is an overloaded function.

Simulates pressing a key with an optional modifier on a window. If delay is larger than 0, the test will wait for delay milliseconds before pressing the key.

See also QTest::keyRelease() and QTest::keyClick().

void QTest::keyPress(QWidget *widget, char key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)

This is an overloaded function.

Simulates pressing a key with an optional modifier on a widget. If delay is larger than 0, the test will wait for delay milliseconds before pressing the key.

See also QTest::keyRelease() and QTest::keyClick().

void QTest::keyRelease(QWidget *widget, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)

Simulates releasing a key with an optional modifier on a widget. If delay is larger than 0, the test will wait for delay milliseconds before releasing the key.

See also QTest::keyPress() and QTest::keyClick().

void QTest::keyRelease(QWindow *window, char key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)

This is an overloaded function.

Simulates releasing a key with an optional modifier on a window. If delay is larger than 0, the test will wait for delay milliseconds before releasing the key.

See also QTest::keyClick().

void QTest::keyRelease(QWindow *window, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)

This is an overloaded function.

Simulates releasing a key with an optional modifier on a window. If delay is larger than 0, the test will wait for delay milliseconds before releasing the key.

See also QTest::keyPress() and QTest::keyClick().

void QTest::keyRelease(QWidget *widget, char key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1)

This is an overloaded function.

Simulates releasing a key with an optional modifier on a widget. If delay is larger than 0, the test will wait for delay milliseconds before releasing the key.

See also QTest::keyClick().

void QTest::keySequence(QWindow *window, const QKeySequence &keySequence)

This is an overloaded function.

Simulates typing of keySequence into a window.

See also QTest::keyClick() and QTest::keyClicks().

void QTest::keySequence(QWidget *widget, const QKeySequence &keySequence)

This is an overloaded function.

Simulates typing of keySequence into a widget.

See also QTest::keyClick() and QTest::keyClicks().

void QTest::mouseClick(QWidget *widget, Qt::MouseButton button, Qt::KeyboardModifiers modifier = Qt::KeyboardModifiers(), QPoint pos = QPoint(), int delay = -1)

Simulates clicking a mouse button with an optional modifier on a widget. The position of the click is defined by pos; the default position is the center of the widget. If delay is specified, the test will wait for the specified amount of milliseconds before pressing and before releasing the button.

See also QTest::mousePress() and QTest::mouseRelease().

void QTest::mouseClick(QWindow *window, Qt::MouseButton button, Qt::KeyboardModifiers stateKey = Qt::KeyboardModifiers(), QPoint pos = QPoint(), int delay = -1)

This is an overloaded function.

Simulates clicking a mouse button with an optional stateKey modifier on a window. The position of the click is defined by pos; the default position is the center of the window. If delay is specified, the test will wait for the specified amount of milliseconds before pressing and before releasing the button.

See also QTest::mousePress() and QTest::mouseRelease().

void QTest::mouseDClick(QWidget *widget, Qt::MouseButton button, Qt::KeyboardModifiers modifier = Qt::KeyboardModifiers(), QPoint pos = QPoint(), int delay = -1)

Simulates double clicking a mouse button with an optional modifier on a widget. The position of the click is defined by pos; the default position is the center of the widget. If delay is specified, the test will wait for the specified amount of milliseconds before each press and release.

See also QTest::mouseClick().

void QTest::mouseDClick(QWindow *window, Qt::MouseButton button, Qt::KeyboardModifiers stateKey = Qt::KeyboardModifiers(), QPoint pos = QPoint(), int delay = -1)

This is an overloaded function.

Simulates double clicking a mouse button with an optional stateKey modifier on a window. The position of the click is defined by pos; the default position is the center of the window. If delay is specified, the test will wait for the specified amount of milliseconds before each press and release.

See also QTest::mouseClick().

void QTest::mouseMove(QWidget *widget, QPoint pos = QPoint(), int delay = -1)

Moves the mouse pointer to a widget. If pos is not specified, the mouse pointer moves to the center of the widget. If a delay (in milliseconds) is given, the test will wait before moving the mouse pointer.

void QTest::mouseMove(QWindow *window, QPoint pos = QPoint(), int delay = -1)

This is an overloaded function.

Moves the mouse pointer to a window. If pos is not specified, the mouse pointer moves to the center of the window. If a delay (in milliseconds) is given, the test will wait before moving the mouse pointer.

void QTest::mousePress(QWidget *widget, Qt::MouseButton button, Qt::KeyboardModifiers modifier = Qt::KeyboardModifiers(), QPoint pos = QPoint(), int delay = -1)

Simulates pressing a mouse button with an optional modifier on a widget. The position is defined by pos; the default position is the center of the widget. If delay is specified, the test will wait for the specified amount of milliseconds before the press.

See also QTest::mouseRelease() and QTest::mouseClick().

void QTest::mousePress(QWindow *window, Qt::MouseButton button, Qt::KeyboardModifiers stateKey = Qt::KeyboardModifiers(), QPoint pos = QPoint(), int delay = -1)

This is an overloaded function.

Simulates pressing a mouse button with an optional stateKey modifier on a window. The position is defined by pos; the default position is the center of the window. If delay is specified, the test will wait for the specified amount of milliseconds before the press.

See also QTest::mouseRelease() and QTest::mouseClick().

void QTest::mouseRelease(QWidget *widget, Qt::MouseButton button, Qt::KeyboardModifiers modifier = Qt::KeyboardModifiers(), QPoint pos = QPoint(), int delay = -1)

Simulates releasing a mouse button with an optional modifier on a widget. The position of the release is defined by pos; the default position is the center of the widget. If delay is specified, the test will wait for the specified amount of milliseconds before releasing the button; otherwise, it will wait for a default amount of time (1 ms), which can be overridden via command-line arguments.

 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);

See also QTest::mousePress() and QTest::mouseClick().

void QTest::mouseRelease(QWindow *window, Qt::MouseButton button, Qt::KeyboardModifiers stateKey = Qt::KeyboardModifiers(), QPoint pos = QPoint(), int delay = -1)

This is an overloaded function.

Simulates releasing a mouse button with an optional stateKey modifier on a window. The position of the release is defined by pos; the default position is the center of the window. If delay is specified, the test will wait for the specified amount of milliseconds before releasing the button; otherwise, it will wait for a default amount of time (1 ms), which can be overridden via command-line arguments.

 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);

See also QTest::mousePress() and QTest::mouseClick().

QTestData &QTest::newRow(const char *dataTag)

Appends a new row to the current test data.

The test output will identify the test run with this test data using the name dataTag.

Returns a QTestData reference that can be used to stream in data, one value for each column in the table.

Example:

 void MyTestClass::addSingleStringRows()
 {
     QTest::addColumn<QString>("aString");
     QTest::newRow("just.hello") << QString("hello");
     QTest::newRow("a.null.string") << QString();
 }

See Data Driven Testing for a more extensive example.

See also addRow(), addColumn(), and QFETCH().

int QTest::qExec(QObject *testObject, int argc = 0, char **argv = nullptr)

Executes tests declared in testObject. In addition, the private slots initTestCase(), cleanupTestCase(), init() and cleanup() are executed if they exist. See Creating a Test for more details.

Optionally, the command line arguments argc and argv can be provided. For a list of recognized arguments, read Qt Test Command Line Arguments.

The following example will run all tests in MyTestObject:

 MyTestObject test1;
 QTest::qExec(&test1);

This function returns 0 if no tests failed, or a value other than 0 if one or more tests failed or in case of unhandled exceptions. (Skipped tests do not influence the return value.)

For stand-alone test applications, the convenience macro QTEST_MAIN() can be used to declare a main() function that parses the command line arguments and executes the tests, avoiding the need to call this function explicitly.

The return value from this function is also the exit code of the test application when the QTEST_MAIN() macro is used.

For stand-alone test applications, this function should not be called more than once, as command-line options for logging test output to files and executing individual test functions will not behave correctly.

If you have programmatically created the arguments, as opposed to getting them from the arguments in main(), it is likely of interest to use QTest::qExec(QObject *, const QStringList &) since it is Unicode safe.

See also QTEST_MAIN(), QTEST_GUILESS_MAIN(), and QTEST_APPLESS_MAIN().

int QTest::qExec(QObject *testObject, const QStringList &arguments)

This is an overloaded function.

Behaves identically to qExec(QObject *, int, char**) but takes a QStringList of arguments instead of a char** list.

QSharedPointer<QTemporaryDir> QTest::qExtractTestData(const QString &dirName)

Extracts a directory from resources to disk. The content is extracted recursively to a temporary folder. The extracted content is removed automatically once the last reference to the return value goes out of scope.

dirName is the name of the directory to extract from resources.

Returns the temporary directory where the data was extracted or null in case of errors.

[since 6.5] void QTest::qRegisterTestCase(const QString &name, QTest::TestEntryFunction entryFunction)

Registers the test name, with entry function entryFunction, in a central test case registry for the current binary.

The name will be listed when running the batch test binary with no parameters. Running the test binary with the argv[1] of name will result in entryFunction being called.

This function was introduced in Qt 6.5.

[since 6.7] void QTest::qSleep(std::chrono::milliseconds msecs)

Sleeps for msecs, blocking execution of the test.

This method will not do any event processing and will leave your test unresponsive. Network communication might time out while sleeping. Use QTest::qWait() to do non-blocking sleeping.

msecs must be greater than 0ms.

Example:

 using namespace std::chrono_literals;
 QTest::qSleep(250ms);

This function was introduced in Qt 6.7.

See also QTest::qWait().

void QTest::qSleep(int ms)

This is an overloaded function.

Sleeps for ms milliseconds, blocking execution of the test.

Equivalent to calling:

 QTest::qSleep(std::chrono::milliseconds{ms});

[since 6.7] void QTest::qWait(std::chrono::milliseconds msecs)

Waits for msecs. While waiting, events will be processed and your test will stay responsive to user interface events or network communication.

Example:

     using namespace std::chrono_literals;
     int i = 0;
     while (myNetworkServerNotResponding() && i++ < 50)
         QTest::qWait(250ms);

The code above will wait until the network server is responding for a maximum of about 12.5 seconds.

This function was introduced in Qt 6.7.

See also QTest::qSleep() and QSignalSpy::wait().

void QTest::qWait(int msecs)

This is an overloaded function.

Waits for msecs. Equivalent to calling:

 QTest::qWait(std::chrono::milliseconds{msecs});

[since 6.7] template <typename Functor> bool QTest::qWaitFor(Functor predicate, QDeadlineTimer deadline = QDeadlineTimer(std::chrono::seconds{5}))

Waits until deadline has expired, or until predicate returns true, whichever happens first.

Returns true if predicate returned true at any point, otherwise returns false.

Example:

     MyObject obj;
     obj.startup();
     using namespace std::chrono_literals;
     const bool result = QTest::qWaitFor([&obj]() { return obj.isReady(); },
                                         QDeadlineTimer(3s));

The code above will wait for the object to become ready, for a maximum of three seconds.

This function was introduced in Qt 6.7.

template <typename Functor> bool QTest::qWaitFor(Functor predicate, int timeout)

This is an overloaded function.

Waits for timeout milliseconds or until the predicate returns true.

This is equivalent to calling:

 qWaitFor(predicate, QDeadlineTimer(timeout));

bool QTest::qWaitForWindowActive(QWindow *window, int timeout = 5000)

Returns true, if window is active within timeout milliseconds. Otherwise returns false.

The method is useful in tests that call QWindow::show() and rely on the window actually being active (i.e. being visible and having focus) before proceeding.

See also qWaitForWindowExposed(), qWaitForWindowFocused(), and QWindow::isActive().

bool QTest::qWaitForWindowActive(QWidget *widget, int timeout = 5000)

Returns true if widget is active within timeout milliseconds. Otherwise returns false.

The method is useful in tests that call QWidget::show() and rely on the widget actually being active (i.e. being visible and having focus) before proceeding.

See also qWaitForWindowExposed() and QWidget::isActiveWindow().

bool QTest::qWaitForWindowExposed(QWindow *window, int timeout = 5000)

Returns true, if window is exposed within timeout milliseconds. Otherwise returns false.

The method is useful in tests that call QWindow::show() and rely on the window actually being being visible before proceeding.

See also qWaitForWindowActive() and QWindow::isExposed().

bool QTest::qWaitForWindowExposed(QWidget *widget, int timeout = 5000)

Returns true if widget is exposed within timeout milliseconds. Otherwise returns false.

The method is useful in tests that call QWidget::show() and rely on the widget actually being being visible before proceeding.

See also qWaitForWindowActive(), QWidget::isVisible(), and QWindow::isExposed().

[since 6.7] bool QTest::qWaitForWindowFocused(QWindow *window, QDeadlineTimer timeout = std::chrono::seconds{5})

Returns true, if window is the focus window within timeout. Otherwise returns false.

The method is useful in tests that call QWindow::show() and rely on the window having focus (for receiving keyboard events e.g.) before proceeding.

This function was introduced in Qt 6.7.

See also qWaitForWindowExposed(), qWaitForWindowActive(), and QGuiApplication::focusWindow().

[since 6.7] bool QTest::qWaitForWindowFocused(QWidget *widget, QDeadlineTimer timeout = std::chrono::seconds{5})

Returns true, if widget is the focus window within timeout. Otherwise returns false.

The method is useful in tests that call QWidget::show() and rely on the widget having focus (for receiving keyboard events e.g.) before proceeding.

This function was introduced in Qt 6.7.

See also qWaitForWindowExposed(), qWaitForWindowActive(), and QGuiApplication::focusWindow().

void QTest::setBenchmarkResult(qreal result, QTest::QBenchmarkMetric metric)

Sets the benchmark result for this test function to result.

Use this function if you want to report benchmark results without using the QBENCHMARK macro. Use metric to specify how Qt Test should interpret the results.

The context for the result will be the test function name and any data tag from the _data function. This function can only be called once in each test function, subsequent calls will replace the earlier reported results.

Note that the -iterations command line argument has no effect on test functions without the QBENCHMARK macro.

char *QTest::toHexRepresentation(const char *ba, qsizetype length)

Returns a pointer to a string that is the string ba represented as a space-separated sequence of hex characters. If the input is considered too long, it is truncated. A trucation is indicated in the returned string as an ellipsis at the end. The caller has ownership of the returned pointer and must ensure it is later passed to operator delete[].

length is the length of the string ba.

template <typename T> char *QTest::toString(const T &value)

Returns a textual representation of value. This function is used by QCOMPARE() to output verbose information in case of a test failure.

You can add specializations or overloads of this function to your test to enable verbose output.

Example for specializing (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());
     }
 }

The example above defines a toString() specialization for a class called MyPoint. Whenever a comparison of two instances of MyPoint fails, QCOMPARE() will call this function to output the contents of MyPoint to the test log.

Same example, but with overloading (Qt ≥ 5.5):

 namespace {
     char *toString(const MyPoint &point)
     {
         return QTest::toString("MyPoint(" +
                                QByteArray::number(point.x()) + ", " +
                                QByteArray::number(point.y()) + ')');
     }
 }

See also QCOMPARE().

template <typename T1, typename T2> char *QTest::toString(const std::pair<T1, T2> &pair)

This is an overloaded function.

Returns a textual representation of the pair.

[since 6.5] char *QTest::toString(const QKeySequence &ks)

This is an overloaded function.

Returns a textual representation of the key sequence ks.

This function was introduced in Qt 6.5.

char *QTest::toString(QSizePolicy::Policy p)

This is an overloaded function.

Returns a textual representation of policy p.

char *QTest::toString(QSizePolicy::ControlTypes cts)

This is an overloaded function.

Returns a textual representation of control types cts.

char *QTest::toString(QSizePolicy::ControlType ct)

This is an overloaded function.

Returns a textual representation of control type ct.

char *QTest::toString(QSizePolicy sp)

This is an overloaded function.

Returns a textual representation of size policy sp.

template <typename... Types> char *QTest::toString(const std::tuple<Types...> &tuple)

This is an overloaded function.

Returns a textual representation of the given tuple.

char *QTest::toString(const QStringView &string)

This is an overloaded function.

Returns a textual representation of the given string.

char *QTest::toString(const QString &string)

This is an overloaded function.

Returns a textual representation of the given string.

char *QTest::toString(const QLatin1StringView &string)

This is an overloaded function.

Returns a textual representation of the given string.

char *QTest::toString(const QByteArray &ba)

This is an overloaded function.

Returns a textual representation of the byte array ba.

See also QTest::toHexRepresentation().

char *QTest::toString(const QTime &time)

This is an overloaded function.

Returns a textual representation of the given time.

char *QTest::toString(const QDate &date)

This is an overloaded function.

Returns a textual representation of the given date.

char *QTest::toString(const QDateTime &dateTime)

This is an overloaded function.

Returns a textual representation of the date and time specified by dateTime.

char *QTest::toString(const QCborError &c)

This is an overloaded function.

Returns a textual representation of the given CBOR error c.

char *QTest::toString(const QChar &character)

This is an overloaded function.

Returns a textual representation of the given character.

char *QTest::toString(const QPoint &point)

This is an overloaded function.

Returns a textual representation of the given point.

char *QTest::toString(const QSize &size)

This is an overloaded function.

Returns a textual representation of the given size.

char *QTest::toString(const QRect &rectangle)

This is an overloaded function.

Returns a textual representation of the given rectangle.

char *QTest::toString(const QPointF &point)

This is an overloaded function.

Returns a textual representation of the given point.

char *QTest::toString(const QSizeF &size)

This is an overloaded function.

Returns a textual representation of the given size.

char *QTest::toString(const QRectF &rectangle)

This is an overloaded function.

Returns a textual representation of the given rectangle.

char *QTest::toString(const QUrl &url)

This is an overloaded function.

Returns a textual representation of the given url.

char *QTest::toString(const QUuid &uuid)

This is an overloaded function.

Returns a textual representation of the given uuid.

char *QTest::toString(const QVariant &variant)

This is an overloaded function.

Returns a textual representation of the given variant.

char *QTest::toString(std::nullptr_t)

This is an overloaded function.

Returns a string containing nullptr.

char *QTest::toString(const QVector2D &v)

This is an overloaded function.

Returns a textual representation of the 2D vector v.

char *QTest::toString(const QVector3D &v)

This is an overloaded function.

Returns a textual representation of the 3D vector v.

char *QTest::toString(const QVector4D &v)

This is an overloaded function.

Returns a textual representation of the 4D vector v.

QTest::QTouchEventWidgetSequence QTest::touchEvent(QWidget *widget, QPointingDevice *device, bool autoCommit = true)

Creates and returns a QTouchEventSequence for the device to simulate events for widget.

When adding touch events to the sequence, widget will also be used to translate the position provided to screen coordinates, unless another widget is provided in the respective calls to press(), move() etc.

The touch events are committed to the event system when the destructor of the QTouchEventSequence is called (ie when the object returned runs out of scope), unless autoCommit is set to false. When autoCommit is false, commit() has to be called manually.

createTouchDevice() can be called to create a test touch device for use with this function.

QTest::QTouchEventSequence QTest::touchEvent(QWindow *window, QPointingDevice *device, bool autoCommit = true)

Creates and returns a QTouchEventSequence for the device to simulate events for window.

When adding touch events to the sequence, window will also be used to translate the position provided to screen coordinates, unless another window is provided in the respective calls to press(), move() etc.

The touch events are committed to the event system when the destructor of the QTouchEventSequence is called (ie when the object returned runs out of scope), unless autoCommit is set to false. When autoCommit is false, commit() has to be called manually.

createTouchDevice() can be called to create a test touch device for use with this function.

 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);
     }
 }

 QCOMPARE(QString("hello").toUpper(), QString("HELLO"));

     const int expected[] = {8, 10, 12, 16, 20, 24};
     QCOMPARE(QFontDatabase::standardSizes(), expected);

  #define ARG(...) __VA_ARGS__
      QCOMPARE(QFontDatabase::standardSizes(), ARG({8, 10, 12, 16, 20, 24}));
  #undef ARG

 char *toString(const MyType &t)
 {
     char *repr = new char[t.reprSize()];
     t.writeRepr(repr);
     return repr;
 }

 QEXPECT_FAIL("", "Will fix in the next release", Continue);
 QCOMPARE(i, 42);
 QCOMPARE(j, 43);

 QEXPECT_FAIL("data27", "Oh my, this is soooo broken", Abort);
 QCOMPARE(i, 42);

 if (sizeof(int) != 4)
     QFAIL("This test has not been ported to this platform yet.");

 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;
 }

 void TestQString::toInt()
 {
      QFETCH(QString, aString);
      QFETCH(int, expected);

      QCOMPARE(aString.toInt(), expected);
 }

 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;
 }

 void TestQLocale::roundTripInt()
 {
     QFETCH_GLOBAL(QLocale, locale);
     QFETCH(int, number);
     bool ok;
     QCOMPARE(locale.toInt(locale.toString(number), &ok), number);
     QVERIFY(ok);
 }

 bool tst_MyXmlParser::parse()
 {
     MyXmlParser parser;
     QString input = QFINDTESTDATA("testxml/simple1.xml");
     QVERIFY(parser.parse(input));
 }

 if (!QSqlDatabase::drivers().contains("SQLITE"))
     QSKIP("This test requires the SQLITE database driver");

 QFETCH(QString, myString);
 QCOMPARE(QString("hello").toUpper(), myString);

 QTEST(QString("hello").toUpper(), "myString");

 QTEST_MAIN(TestQString)

 QTRY_VERIFY2(list.size() > 2, QByteArray::number(list.size()).constData());

 QTRY_VERIFY2_WITH_TIMEOUT(list.size() > 2, QByteArray::number(list.size()).constData(), 10000);

 QVERIFY2(QFileInfo("file.txt").exists(), "file.txt does not exist.");

 bool opened = file.open(QIODevice::WriteOnly);
 QVERIFY(opened);

 QVERIFY2(file.open(QIODevice::WriteOnly),
          qPrintable(QString("open %1: %2")
                     .arg(file.fileName()).arg(file.errorString())));

 QVERIFY(spy.isValid());

 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 -----------------------/

 QVERIFY_THROWS_NO_EXCEPTION(std::pair<int, long>{42, 42L});
 // macro arguments:         \---- 1 ----/  \-- 2 -/  \3 /