QTest Namespace

Function Documentation

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:

 void myTestFunction_data() {
     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().

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

See Data Driven Testing for a more extensive example.

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

const char * QTest::benchmarkMetricName(QBenchmarkMetric metric)

Returns the enum value metric as a character string.

This function was introduced in Qt 4.7.

const char * QTest::benchmarkMetricUnit(QBenchmarkMetric metric)

Retuns the units of measure for the specified metric.

This function was introduced in Qt 4.7.

const char * QTest::currentDataTag()

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

bool QTest::currentTestFailed()

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

const char * QTest::currentTestFunction()

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

Example:

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

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

Ignores messages created by qDebug() 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.

Note: Invoking this function will only ignore one message. If the message you want to ignore is outputted twice, you have to call ignoreMessage() twice, too.

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::keyClick(QWindow * window, Qt::Key key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1) [static]

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

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

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(QWidget * widget, char key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1) [static]

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) [static]

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(KeyAction action, QWindow * window, char ascii, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1) [static]

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

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

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(KeyAction action, QWidget * widget, char ascii, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1) [static]

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(QWindow * window, char key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1) [static]

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

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

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.

Note: At some point you should release the key using keyRelease().

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

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

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.

Note: At some point you should release the key using keyRelease().

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

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

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

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

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(QWidget * widget, char key, Qt::KeyboardModifiers modifier = Qt::NoModifier, int delay = -1) [static]

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::mouseClick(QWindow * window, Qt::MouseButton button, Qt::KeyboardModifiers stateKey = 0, QPoint pos = QPoint(), int delay = -1)

void QTest::mouseClick(QWidget * widget, Qt::MouseButton button, Qt::KeyboardModifiers modifier = 0, 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::mouseDClick(QWindow * window, Qt::MouseButton button, Qt::KeyboardModifiers stateKey = 0, QPoint pos = QPoint(), int delay = -1)

void QTest::mouseDClick(QWidget * widget, Qt::MouseButton button, Qt::KeyboardModifiers modifier = 0, 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::mouseEvent(MouseAction action, QWindow * window, Qt::MouseButton button, Qt::KeyboardModifiers stateKey, QPoint pos, int delay = -1) [static]

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

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::mousePress(QWindow * window, Qt::MouseButton button, Qt::KeyboardModifiers stateKey = 0, QPoint pos = QPoint(), int delay = -1)

void QTest::mousePress(QWidget * widget, Qt::MouseButton button, Qt::KeyboardModifiers modifier = 0, 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::mouseRelease(QWindow * window, Qt::MouseButton button, Qt::KeyboardModifiers stateKey = 0, QPoint pos = QPoint(), int delay = -1)

void QTest::mouseRelease(QWidget * widget, Qt::MouseButton button, Qt::KeyboardModifiers modifier = 0, 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.

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

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

Appends a new row to the current test data. dataTag is the name of the testdata that will appear in the test output. Returns a QTestData reference that can be used to stream in data.

Example:

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

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

See Data Driven Testing for a more extensive example.

See also addColumn() and QFETCH().

bool QTest::qCompare(double const & t1, float const & t2, const char * actual, const char * expected, const char * file, int line)

bool QTest::qCompare(float const & t1, double const & t2, const char * actual, const char * expected, const char * file, int line)

bool QTest::qCompare(QImage const & t1, QImage const & t2, const char * actual, const char * expected, const char * file, int line)

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

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 QTestLib 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.

Note: This function is not reentrant, only one test can run at a time. A test that was executed with qExec() can't run another test via qExec() and threads are not allowed to call qExec() simultaneously.

If you have programatically 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().

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.

This function was introduced in Qt 4.4.

QString QTest::qFindTestData(const QString & basepath, const char * file = 0, int line = 0, const char * builddir = 0)

void QTest::qSleep(int ms)

Sleeps for ms milliseconds, blocking execution of the test. qSleep() will not do any event processing and leave your test unresponsive. Network communication might time out while sleeping. Use qWait() to do non-blocking sleeping.

ms must be greater than 0.

Note: The qSleep() function calls either nanosleep() on unix or Sleep() on windows, so the accuracy of time spent in qSleep() depends on the operating system.

Example:

 QTest::qSleep(250);

See also qWait().

void QTest::qWait(int ms) [static]

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

Example:

 int i = 0;
 while (myNetworkServerNotResponding() && i++ < 50)
     QTest::qWait(250);

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

See also QTest::qSleep().

bool QTest::qWaitForWindowActive(QWindow * window, int timeout = 1000) [static]

Waits for timeout milliseconds or until the window is active.

Returns true if window is active in timout milliseconds, otherwise returns false.

This function was introduced in Qt 5.0.

See also QTest::qWaitForWindowActive(), QTest::qWaitForWindowShown(), and QWindow::isActive().

bool QTest::qWaitForWindowExposed(QWindow * window, int timeout = 1000) [static]

Waits for timeout milliseconds or until the window is exposed. Returns true if window is exposed in timout milliseconds, otherwise returns false.

This function was introduced in Qt 5.0.

See also QTest::qWaitForWindowShown(), QTest::qWaitForWindowExposed(), and QWindow::isExposed().

bool QTest::qWaitForWindowShown(QWidget * window) [static]

Waits until the window is shown on the screen. This is mainly useful for asynchronous systems like X11, where a window will be mapped to screen some time after being asked to show itself on the screen. Returns true.

Example:

 QWidget widget;
 widget.show();
 QTest::qWaitForWindowShown(&widget);

This function was introduced in Qt 4.6.

bool QTest::qWaitForWindowShown(QWindow * window, int timeout = 1000) [static]

Waits for timeout milliseconds or until the window is shown on the screen. This is mainly useful for asynchronous systems like X11, where a window will be mapped to screen some time after being asked to show itself on the screen.

Returns true if window is show in timout milliseconds, otherwise returns false.

This function was introduced in Qt 5.0.

See also QTest::qWaitForWindowActive() and QTest::qWaitForWindowExposed().

void QTest::sendKeyEvent(KeyAction action, QWindow * window, Qt::Key code, QString text, Qt::KeyboardModifiers modifier, int delay = -1) [static]

void QTest::sendKeyEvent(KeyAction action, QWindow * window, Qt::Key code, char ascii, Qt::KeyboardModifiers modifier, int delay = -1) [static]

void QTest::setBenchmarkResult(qreal result, 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 QTestLib 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.

This function was introduced in Qt 4.7.

void QTest::simulateEvent(QWindow * window, bool press, int code, Qt::KeyboardModifiers modifier, QString text, bool repeat, int delay = -1) [static]

char * QTest::toHexRepresentation(const char * ba, int 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.

length is the length of the string ba.

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 of this function to your test to enable verbose output.

Note: The caller of toString() must delete the returned data using delete[]. Your implementation should return a string created with new[] or qstrdup().

Example:

 namespace QTest {
     template<>
     char *toString(const MyPoint &point)
     {
         QByteArray ba = "MyPoint(";
         ba += QByteArray::number(point.x()) + ", " + QByteArray::number(point.y());
         ba += ")";
         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.

See also QCOMPARE().

char * QTest::toString(const QLatin1String & 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 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 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 QUrl & url)

This is an overloaded function.

Returns a textual representation of the given url.

This function was introduced in Qt 4.4.

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 QVariant & variant)

This is an overloaded function.

Returns a textual representation of the given variant.

QTouchEventSequence QTest::touchEvent(QWidget * widget, QTouchDevice * device, bool autoCommit = true)

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

void QTest::waitForEvents() [static]

 void TestBenchmark::simple()
 {
     QString str1 = QLatin1String("This is a test string");
     QString str2 = QLatin1String("This is a test string");

     QCOMPARE(str1.localeAwareCompare(str2), 0);

     QBENCHMARK {
         str1.localeAwareCompare(str2);
     }
 }

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

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

 // Source: /home/user/sources/myxmlparser/tests/tst_myxmlparser/tst_myxmlparser.cpp
 // Build:  /home/user/build/myxmlparser/tests/tst_myxmlparser
 // Qt:     /usr/local/Qt-5.0.0
 void 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");

 class TestQString: public QObject { ... };
 QTEST_MAIN(TestQString)

 QVERIFY2(1 + 1 == 2, "A breach in basic arithmetic occurred.");

 QVERIFY(1 + 1 == 2);