Chapter 4: Replaying GUI Events

How to replay GUI events

testgui.cpp Example File

tutorial4.pro Example File

How to replay GUI events.

In this chapter, we will show how to simulate a GUI event, and how to store a series of GUI events as well as replay them on a widget.

The approach to storing a series of events and replaying them is quite similar to the approach explained in chapter 2 . All you need to do is to add a data function to your test class:

class TestGui: public QObject
{
    Q_OBJECT

private slots:
    void testGui_data();
    void testGui();
};

Writing the Data Function

As before, a test function’s associated data function carries the same name, appended by _data .

void TestGui::testGui_data()
{
    QTest::addColumn<QTestEventList>("events");
    QTest::addColumn<QString>("expected");

    QTestEventList list1;
    list1.addKeyClick('a');
    QTest::newRow("char") << list1 << "a";

    QTestEventList list2;
    list2.addKeyClick('a');
    list2.addKeyClick(Qt::Key_Backspace);
    QTest::newRow("there and back again") << list2 << "";
}

First, we define the elements of the table using the QTest::addColumn() function: A list of GUI events, and the expected result of applying the list of events on a QWidget . Note that the type of the first element is QTestEventList.

A QTestEventList can be populated with GUI events that can be stored as test data for later usage, or be replayed on any QWidget .

In our current data function, we create two QTestEventList elements. The first list consists of a single click to the ‘a’ key. We add the event to the list using the QTestEventList::addKeyClick() function. Then we use the QTest::newRow() function to give the data set a name, and stream the event list and the expected result into the table.

The second list consists of two key clicks: an ‘a’ with a following ‘backspace’. Again we use the QTestEventList::addKeyClick() to add the events to the list, and QTest::newRow() to put the event list and the expected result into the table with an associated name.

Rewriting the Test Function

Our test can now be rewritten:

void TestGui::testGui()
{
    QFETCH(QTestEventList, events);
    QFETCH(QString, expected);

    QLineEdit lineEdit;

    events.simulate(&lineEdit);

    QCOMPARE(lineEdit.text(), expected);
}

The TestGui::testGui() function will be executed two times, once for each entry in the test data that we created in the associated TestGui::testGui_data() function.

First, we fetch the two elements of the data set using the QFETCH() macro. QFETCH() takes two arguments: the data type of the element and the element name. Then we create a QLineEdit, and apply the list of events on that widget using the QTestEventList::simulate() function.

Finally, we use the QCOMPARE() macro to check if the line edit’s text is as expected.

As before, to make our test case a stand-alone executable, the following two lines are needed:

QTEST_MAIN(TestGui)
#include "testgui.moc"

The QTEST_MAIN() macro expands to a simple main() method that runs all the test functions, and since both the declaration and the implementation of our test class are in a .cpp file, we also need to include the generated moc file to make Qt’s introspection work.