Kapitel 4: Wiedergeben von GUI-Ereignissen

In diesem Kapitel zeigen wir Ihnen, wie Sie ein GUI-Ereignis simulieren und wie Sie eine Reihe von GUI-Ereignissen speichern sowie auf einem Widget wiedergeben können.

Der Ansatz zum Speichern einer Reihe von Ereignissen und deren Wiedergabe ähnelt stark dem in Kapitel 2 erläuterten. Sie müssen lediglich eine Datenfunktion zu Ihrer Testklasse hinzufügen:

class TestGui: public QObject
{
    Q_OBJECT

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

Erstellen der Datenfunktion

Wie zuvor trägt die zu einer Testfunktion gehörende Datenfunktion denselben Namen, an den „ _data “ angehängt wird.

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+back-again") << list2 << "";
}

Zunächst definieren wir die Elemente der Tabelle mithilfe der Funktion ` QTest::addColumn()`: Eine Liste von GUI-Ereignissen und das erwartete Ergebnis der Anwendung dieser Ereignisliste auf ein ` QWidget`. Beachten Sie, dass der Typ des ersten Elements ` QTestEventList` ist.

Ein ` QTestEventList ` kann mit GUI-Ereignissen gefüllt werden, die als Testdaten für die spätere Verwendung gespeichert oder auf einem beliebigen ` QWidget` wiedergegeben werden können.

In unserer aktuellen Datenfunktion erstellen wir zwei „ QTestEventList “-Elemente. Die erste Liste besteht aus einem einzelnen Klick auf die Taste „a“. Wir fügen das Ereignis mithilfe der Funktion „ QTestEventList::addKeyClick()“ zur Liste hinzu. Anschließend verwenden wir die Funktion „ QTest::newRow()“, um dem Datensatz einen Namen zu geben und die Ereignisliste sowie das erwartete Ergebnis in die Tabelle zu streamen.

Die zweite Liste besteht aus zwei Tastenanschlägen: einem „a“, gefolgt von einem „Backspace“. Auch hier verwenden wir die Funktion „ QTestEventList::addKeyClick()“, um die Ereignisse zur Liste hinzuzufügen, und „ QTest::newRow()“, um die Ereignisliste und das erwartete Ergebnis unter einem entsprechenden Namen in die Tabelle einzutragen.

Umschreiben der Testfunktion

Unser Test lässt sich nun wie folgt umschreiben:

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

    QLineEdit lineEdit;

    events.simulate(&lineEdit);

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

Die Funktion `TestGui::testGui()` wird zweimal ausgeführt, einmal für jeden Eintrag in den Testdaten, die wir in der zugehörigen Funktion `TestGui::testGui_data()` erstellt haben.

Zunächst rufen wir die beiden Elemente des Datensatzes mithilfe des Makros ` QFETCH()` ab. ` QFETCH()` benötigt zwei Argumente: den Datentyp des Elements und den Elementnamen. Anschließend erstellen wir ein ` QLineEdit` und wenden die Liste der Ereignisse mithilfe der Funktion ` QTestEventList::simulate()` auf dieses Widget an.

Abschließend verwenden wir das Makro „ QCOMPARE()“, um zu überprüfen, ob der Text des Zeileneingabefelds den Erwartungen entspricht.

Vorbereitung der eigenständigen ausführbaren Datei

Wie zuvor sind die folgenden zwei Zeilen erforderlich, um unseren Testfall zu einer eigenständigen ausführbaren Datei zu machen:

QTEST_MAIN(TestGui)
#include "testgui.moc"

Das Makro „ QTEST_MAIN()“ wird zu einer einfachen `main()`-Methode erweitert, die alle Testfunktionen ausführt. Da sich sowohl die Deklaration als auch die Implementierung unserer Testklasse in einer `.cpp`-Datei befinden, müssen wir außerdem die generierte `moc`-Datei einbinden, damit die Introspektion von Qt funktioniert.

Erstellen der ausführbaren Datei

Sie können die ausführbare Testdatei mit CMake oder qmake erstellen.

Erstellen mit CMake

Konfigurieren Sie Ihre Build-Einstellungen in Ihrer `CMakeLists.txt`-Datei:

# Copyright (C) 2022 The Qt Company Ltd.
# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause

cmake_minimum_required(VERSION 3.16)
project(tutorial4 LANGUAGES CXX)

find_package(Qt6 REQUIRED COMPONENTS Core Gui Test Widgets)

qt_standard_project_setup()

qt_add_executable(tutorial4
    testgui.cpp
)

set_target_properties(tutorial4 PROPERTIES
    WIN32_EXECUTABLE TRUE
    MACOSX_BUNDLE TRUE
)

target_link_libraries(tutorial4 PRIVATE
    Qt6::Core
    Qt6::Gui
    Qt6::Test
    Qt6::Widgets
)

install(TARGETS tutorial4
    BUNDLE  DESTINATION .
    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
)

qt_generate_deploy_app_script(
    TARGET tutorial4
    OUTPUT_SCRIPT deploy_script
    NO_UNSUPPORTED_PLATFORM_ERROR
)
install(SCRIPT ${deploy_script})

Führen Sie anschließend in der Befehlszeile entweder „ cmake “ aus oder verwenden Sie das Hilfsskript „ qt-cmake “, das sich unter „ Qt-prefix/<version>/<platform>/bin/qt-cmake “ befindet:

<Qt-prefix>/<version>/<platform>/bin/qt-cmake <source-dir> <build-dir> -G Ninja

Führen Sie anschließend Ihr bevorzugtes Generierungswerkzeug aus, um die ausführbare Datei zu erstellen. Hier verwenden wir Ninja:

ninja

Erstellen mit qmake

Konfigurieren Sie Ihre Build-Einstellungen in Ihrer Datei „ .pro “:

QT += widgets testlib

SOURCES = testgui.cpp

# install
target.path = $$[QT_INSTALL_EXAMPLES]/qtestlib/tutorial4
INSTALLS += target

Führen Sie anschließend „ qmake “ aus und schließlich „ make “, um Ihre ausführbare Datei zu erstellen:

qmake
make

Ausführen der ausführbaren Datei

Wenn Sie die resultierende ausführbare Datei ausführen, sollten Sie die folgende Ausgabe erhalten:

********* Start testing of TestGui *********
Config: Using QtTest library %VERSION%, Qt %VERSION%
PASS   : TestGui::initTestCase()
PASS   : TestGui::testGui(char)
PASS   : TestGui::testGui(there+back-again)
PASS   : TestGui::cleanupTestCase()
Totals: 4 passed, 0 failed, 0 skipped, 0 blacklisted, 18ms
********* Finished testing of TestGui *********