Kapitel 2: Datengesteuertes Testen

In diesem Kapitel wird gezeigt, wie man einen Test mehrmals mit unterschiedlichen Testdaten ausführt.

Bisher haben wir die zu testenden Daten fest in unsere Testfunktion eingebettet. Wenn wir weitere Testdaten hinzufügen, könnte die Funktion etwa so aussehen:

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

Um zu verhindern, dass die Funktion mit sich wiederholendem Code überladen wird, unterstützt „ Qt Test “ das Hinzufügen von Testdaten zu einer Testfunktion. Dazu müssen wir lediglich einen weiteren privaten Slot zu unserer Testklasse hinzufügen:

class TestQString: public QObject
{
    Q_OBJECT

private slots:
    void toUpper_data();
    void toUpper();
};

Die Datenfunktion schreiben

Der Name der zu einer Testfunktion gehörenden Datenfunktion wird um „ _data “ ergänzt. Unsere Datenfunktion sieht wie folgt aus:

void TestQString::toUpper_data()
{
    QTest::addColumn<QString>("string");
    QTest::addColumn<QString>("result");

    QTest::newRow("all-lower") << "hello" << "HELLO";
    QTest::newRow("mixed")     << "Hello" << "HELLO";
    QTest::newRow("all-upper") << "HELLO" << "HELLO";
}

Zunächst definieren wir die beiden Elemente unserer Testtabelle mithilfe der Funktion ` QTest::addColumn()`: eine Testzeichenfolge und das erwartete Ergebnis der Anwendung der Funktion ` QString::toUpper()` auf diese Zeichenfolge.

Anschließend fügen wir der Tabelle mithilfe der Funktion ` QTest::newRow()` einige Daten hinzu. Wir können auch ` QTest::addRow()` verwenden, wenn wir bestimmte Daten im Zeilennamen formatieren müssen, beispielsweise bei der iterativen Generierung vieler Datenzeilen. Jede Datenzeile wird zu einer separaten Zeile in der Testtabelle.

QTest::newRow() nimmt ein Argument entgegen: einen Namen, der dem Datensatz zugeordnet und im Testprotokoll zur Identifizierung der Datenzeile verwendet wird. QTest::addRow() nimmt eine Formatzeichenfolge (im Stil vonprintf) entgegen, gefolgt von den Parametern, die anstelle der Formatierungs-Token in der Formatzeichenfolge dargestellt werden sollen. Anschließend streamen wir den Datensatz in die neue Tabellenzeile. Zunächst eine beliebige Zeichenfolge und anschließend das erwartete Ergebnis der Anwendung der Funktion ` QString::toUpper()` auf diese Zeichenfolge.

Man kann sich die Testdaten als zweidimensionale Tabelle vorstellen. In unserem Fall hat sie zwei Spalten namens „ string “ und „ result “ sowie drei Zeilen. Zudem sind jeder Zeile ein Name und ein Index zugeordnet:

Wenn Daten in die Zeile gestreamt werden, wird für jeden Datenwert überprüft, ob er mit dem Typ der Spalte übereinstimmt, deren Wert er liefert. Wenn eine dieser Überprüfungen fehlschlägt, wird der Test abgebrochen.

Die Namen von Zeilen und Spalten in der Datentabelle einer bestimmten Testfunktion sollten eindeutig sein: Wenn zwei Zeilen denselben Namen haben oder zwei Spalten denselben Namen haben, wird (seit Qt 6.5) eine Warnung ausgegeben. Unter „ qWarning “ () erfährst du, wie du Warnungen als Fehler behandeln lassen kannst, und unter „Test for Warnings“, wie du deine Tests von weiteren Warnungen befreien kannst.

Neuschreiben der Testfunktion

Unsere Testfunktion kann nun umgeschrieben werden:

void TestQString::toUpper()
{
    QFETCH(QString, string);
    QFETCH(QString, result);

    QCOMPARE(string.toUpper(), result);
}

Die Funktion `TestQString::toUpper()` wird dreimal ausgeführt, einmal für jeden Eintrag in der Testtabelle, die wir in der zugehörigen Funktion `TestQString::toUpper_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 führen wir den Test mithilfe des Makros „ QCOMPARE()“ durch.

Dieser Ansatz macht es sehr einfach, dem Test neue Daten hinzuzufügen, ohne den Test selbst ändern zu müssen.

Vorbereitung der eigenständigen ausführbaren Datei

Und auch hier sind wieder die folgenden zwei Zeilen erforderlich, um unseren Testfall zu einer eigenständigen ausführbaren Datei zu machen:

QTEST_MAIN(TestQString)
#include "testqstring.moc"

Wie zuvor wird das Makro „ QTEST_MAIN()“ 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(tutorial2 LANGUAGES CXX)

find_package(Qt6 REQUIRED COMPONENTS Core Gui Test Widgets)

qt_standard_project_setup()

qt_add_executable(tutorial2
    testqstring.cpp
)

set_target_properties(tutorial2 PROPERTIES
    WIN32_EXECUTABLE TRUE
    MACOSX_BUNDLE TRUE
)

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

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

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

Führen Sie anschließend über die 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 = testqstring.cpp

# install
target.path = $$[QT_INSTALL_EXAMPLES]/qtestlib/tutorial2
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 TestQString *********
Config: Using QtTest library %VERSION%, Qt %VERSION%
PASS   : TestQString::initTestCase()
PASS   : TestQString::toUpper(all-lower)
PASS   : TestQString::toUpper(mixed)
PASS   : TestQString::toUpper(all-upper)
PASS   : TestQString::cleanupTestCase()
Totals: 5 passed, 0 failed, 0 skipped, 0 blacklisted, 0ms
********* Finished testing of TestQString *********