← C++

C++ · 23 / 24

Qt-Oberflächen mit Aktionen und Signalen testen

Du prüfst das Zusammenspiel von Eingaben, Tabelle und Anwendungsdienst mit reproduzierbaren Widgettests.

  • Groß
  • Anspruchsvoll
  • 90 min

Voraussetzungen: Qt Model/View mit Sortierung, Filtern und Bearbeitung, Asynchrone HTTP-Anfragen mit Abbruch und Zeitlimit, Aufträge mit SQLite und Transaktionen speichern

In diesem Tutorial
  1. Eine testbare Oberfläche aufbauen
  2. Die Demo selbst bedienen
  3. Benutzeraktionen durchspielen
  4. Signale und fachliche Ergebnisse verbinden
  5. Tastaturbedienung prüfen
  6. Die Grenzen automatischer UI-Prüfung kennen
  7. Übung und Lösung
  8. Projektbezug und Quellen

Lernpaket herunterladen

Einrichtung und Prüfstand

GCC mit C++20, CMake ab 3.25, CTest und Python 3. Qt 6.8 mit Core, Widgets und Test. Setze CMAKE_PREFIX_PATH auf deinen Qt-Installationsordner, falls Qt nicht automatisch gefunden wird. Lokal geprüft mit Qt 6.8.3. Entpacke das ZIP in einen neuen Ordner. python3 run_checks.py prüft Beispiel und Lösung in einer temporären Kopie und erhält deine Dateien. Für einen eigenen Build führe python3 verify.py aus. Danach liegt das Demo unter build/order_lab. Die Qt-Demos verwenden englische Beschriftungen. Automatische Widgettests nutzen standardmäßig offscreen. Starte die sichtbare Demo in einer Desktop-Sitzung ohne QT_QPA_PLATFORM=offscreen. Native Windows-Ausführung ist nicht verifiziert.

Geprüft am 21.10.2026 unter Linux x86_64. Echte Qt-Widgets, ungültige Eingabe, Tastatureingabe, Speichern, sortierte Auswahl, Löschen, Filter und Fokus-Tastenkombination. Linux offscreen, keine native Windows- oder Screenreader-Abnahme.

Ein bestandener Kerntest beweist noch nicht, dass ein Button den richtigen Auftrag löscht oder ein Eingabefehler in der Oberfläche sichtbar wird. Dieses Tutorial bedient echte Qt-Widgets mit QTest. Die Tests prüfen sowohl sichtbare Ergebnisse als auch den gespeicherten Zustand. Eine Tastaturübung ergänzt den Ablauf um einen überprüfbaren Fokuswechsel.

Paketinhalt und einzelne Dateien

01Eine testbare Oberfläche aufbauen

Die Widgets erhalten feste objectName-Werte wie title, save und orders. Tests können sie damit auffinden, ohne von einer Bildschirmkoordinate oder übersetzten Beschriftung abzuhängen. Das Formular speichert über OrderService. Bei ungültiger Eingabe erscheint eine Meldung und der Tabellenbestand bleibt erhalten.

order_editor.hpp · cppDatei öffnen
#pragma once
#include "order_model.hpp"
#include <QCheckBox>
#include <QFormLayout>
#include <QHeaderView>
#include <QLabel>
#include <QLineEdit>
#include <QPushButton>
#include <QSpinBox>
#include <QTableView>
#include <QVBoxLayout>

namespace orders {
class OrderEditor : public QWidget {
  OrderService &service_;
  OrderModel model_;
  OpenFilter proxy_;
  QSpinBox *id_;
  QLineEdit *title_;
  QSpinBox *priority_;
  QCheckBox *done_;
  QTableView *table_;
  QLabel *message_;

public:
  explicit OrderEditor(OrderService &service, QWidget *parent = nullptr)
      : QWidget(parent), service_(service), model_(service, this),
        proxy_(this) {
    auto *layout = new QVBoxLayout(this);
    auto *search = new QLineEdit(this);
    search->setObjectName("search");
    search->setPlaceholderText("Filter titles");
    search->setAccessibleName("Filter titles");
    auto *onlyOpen = new QCheckBox("Open orders only", this);
    onlyOpen->setObjectName("onlyOpen");
    layout->addWidget(search);
    layout->addWidget(onlyOpen);
    proxy_.setSourceModel(&model_);
    table_ = new QTableView(this);
    table_->setObjectName("orders");
    table_->setModel(&proxy_);
    table_->setSortingEnabled(true);
    table_->sortByColumn(0, Qt::AscendingOrder);
    table_->setSelectionBehavior(QAbstractItemView::SelectRows);
    table_->setSelectionMode(QAbstractItemView::SingleSelection);
    table_->setEditTriggers(QAbstractItemView::NoEditTriggers);
    table_->horizontalHeader()->setSectionResizeMode(1, QHeaderView::Stretch);
    layout->addWidget(table_);
    auto *form = new QFormLayout;
    id_ = new QSpinBox(this);
    id_->setObjectName("id");
    id_->setRange(1, 1000000);
    title_ = new QLineEdit(this);
    title_->setObjectName("title");
    priority_ = new QSpinBox(this);
    priority_->setObjectName("priority");
    priority_->setRange(0, 2);
    done_ = new QCheckBox("Done", this);
    done_->setObjectName("done");
    form->addRow("ID", id_);
    form->addRow("Title", title_);
    form->addRow("Priority", priority_);
    form->addRow("Status", done_);
    layout->addLayout(form);
    auto *buttons = new QHBoxLayout;
    auto *save = new QPushButton("Save order", this);
    save->setObjectName("save");
    auto *remove = new QPushButton("Delete selected", this);
    remove->setObjectName("remove");
    buttons->addWidget(save);
    buttons->addWidget(remove);
    layout->addLayout(buttons);
    message_ = new QLabel(this);
    message_->setObjectName("message");
    message_->setWordWrap(true);
    layout->addWidget(message_);
    connect(search, &QLineEdit::textChanged, &proxy_,
            &QSortFilterProxyModel::setFilterFixedString);
    connect(onlyOpen, &QCheckBox::toggled, this,
            [this](bool value) { proxy_.setOnlyOpen(value); });
    connect(table_->selectionModel(), &QItemSelectionModel::currentRowChanged,
            this, [this](const QModelIndex &current) {
              if (!current.isValid())
                return;
              auto source = proxy_.mapToSource(current);
              id_->setValue(source.data(OrderModel::Id).toInt());
              title_->setText(model_.index(source.row(), 1).data().toString());
              priority_->setValue(source.data(OrderModel::Priority).toInt());
              done_->setChecked(!source.data(OrderModel::Open).toBool());
            });
    connect(save, &QPushButton::clicked, this, [this] {
      auto result = service_.save(
          {id_->value(), title_->text().toStdString(), priority_->value(),
           done_->isChecked() ? Status::done : Status::open});
      if (report(result, "Saved"))
        refresh();
    });
    connect(remove, &QPushButton::clicked, this, [this] {
      const auto current = table_->currentIndex();
      if (!current.isValid()) {
        message_->setText("Select an order first");
        return;
      }
      const auto source = proxy_.mapToSource(current);
      auto result = service_.remove(source.data(OrderModel::Id).toInt());
      if (report(result, "Deleted"))
        refresh();
    });
    refresh();
  }
  bool report(const Result<Done> &result, const QString &success) {
    if (!succeeded(result)) {
      message_->setText(
          QString::fromStdString(std::get<Error>(result).message));
      return false;
    }
    message_->setText(success);
    return true;
  }
  void refresh() {
    auto loaded = model_.refresh();
    if (!succeeded(loaded))
      report(loaded, {});
  }
};
} // namespace orders
Erwartetes Ergebnis

Ein leerer Titel erzeugt eine sichtbare Fehlermeldung.

02Die Demo selbst bedienen

Starte ./build/order_lab in einer Desktop-Sitzung. Gib für einen neuen Auftrag eine freie ID ein, ergänze den Titel und klicke Save order. Wähle eine Zeile, um ihre Werte zu bearbeiten. Gleiche IDs aktualisieren bewusst den vorhandenen Auftrag. Die Beispieloberfläche ist englisch beschriftet und speichert hier noch im Arbeitsspeicher.

main.cpp · cppDatei öffnen
#include "order_editor.hpp"
#include "test_support.hpp"
#include <QApplication>
int main(int argc, char **argv) {
  QApplication app(argc, argv);
  orders::MemoryRepository repository;
  orders::OrderService service(repository);
  service.replace(samples());
  orders::OrderEditor editor(service);
  editor.setWindowTitle("Order model · memory example");
  editor.resize(720, 520);
  editor.show();
  return app.exec();
}
Erwartetes Ergebnis

Ein neuer Auftrag erscheint sofort in der Tabelle.

03Benutzeraktionen durchspielen

Der Test klickt zuerst mit leerem Titel auf Save order. Danach tippt er den Titel mit QTest::keyClicks und speichert erneut. Er sortiert absteigend, wählt den neu angelegten Datensatz in der sichtbaren Tabelle und löscht ihn über den echten Button. Anschließend müssen wieder exakt die ursprünglichen Aufträge gespeichert sein.

tests.cpp · cppDatei öffnen
#include "order_editor.hpp"
#include "test_support.hpp"
#include <QtTest>
using namespace orders;
class UiTests : public QObject {
  Q_OBJECT
private slots:
  void saveValidateFilterAndDelete() {
    MemoryRepository repository;
    OrderService service(repository);
    QVERIFY(succeeded(service.replace(samples())));
    OrderEditor editor(service);
    editor.resize(700, 480);
    editor.show();
    auto *title = editor.findChild<QLineEdit *>("title");
    auto *id = editor.findChild<QSpinBox *>("id");
    auto *table = editor.findChild<QTableView *>("orders");
    auto *save = editor.findChild<QPushButton *>("save");
    id->setValue(4);
    QTest::mouseClick(save, Qt::LeftButton);
    QCOMPARE(table->model()->rowCount(), 3);
    QVERIFY(editor.findChild<QLabel *>("message")->text().contains("title"));
    title->setFocus();
    QTest::keyClicks(title, "Added by keyboard");
    QTest::mouseClick(save, Qt::LeftButton);
    QCOMPARE(table->model()->rowCount(), 4);
    QVERIFY(std::get<std::vector<Order>>(service.list()).back().title ==
            "Added by keyboard");
    table->sortByColumn(0, Qt::DescendingOrder);
    auto index = table->model()->index(0, 0);
    QCOMPARE(index.data(OrderModel::Id).toInt(), 4);
    QTest::mouseClick(table->viewport(), Qt::LeftButton, {},
                      table->visualRect(index).center());
    QTest::mouseClick(editor.findChild<QPushButton *>("remove"),
                      Qt::LeftButton);
    QVERIFY(std::get<std::vector<Order>>(service.list()) == samples());
    auto *checkbox = editor.findChild<QCheckBox *>("onlyOpen");
    QTest::mouseClick(checkbox, Qt::LeftButton, {},
                      QPoint(8, checkbox->height() / 2));
    QCOMPARE(table->model()->rowCount(), 2);
    editor.findChild<QLineEdit *>("search")->setText("motors");
    QCOMPARE(table->model()->rowCount(), 1);
  }
};
QTEST_MAIN(UiTests)
#include "tests.moc"
Erwartetes Ergebnis

Die ungültige Eingabe verändert nichts. Anlegen und Löschen stellen den Ausgangsbestand wieder her.

04Signale und fachliche Ergebnisse verbinden

Das Modell sendet dataChanged erst nach erfolgreicher Speicherung. Tutorial 19 prüft dieses Signal mit QSignalSpy. Hier wird die darüberliegende Widget-Verbindung geprüft. Die Anzahl sichtbarer Zeilen allein wäre zu schwach. Deshalb vergleicht der Test beim Löschen auch die konkreten gespeicherten Aufträge.

order_model.hpp · cppDatei öffnen
#pragma once
#include "repository.hpp"
#include <QAbstractTableModel>
#include <QSortFilterProxyModel>

namespace orders {
class OrderModel final : public QAbstractTableModel {
  OrderService &service_;
  std::vector<Order> values_;
  QString lastError_;

public:
  enum Role { Id = Qt::UserRole + 1, Priority, Open };
  explicit OrderModel(OrderService &service, QObject *parent = nullptr)
      : QAbstractTableModel(parent), service_(service) {}
  int rowCount(const QModelIndex &parent = {}) const override {
    return parent.isValid() ? 0 : int(values_.size());
  }
  int columnCount(const QModelIndex &parent = {}) const override {
    return parent.isValid() ? 0 : 4;
  }
  QVariant data(const QModelIndex &index,
                int role = Qt::DisplayRole) const override {
    if (!index.isValid() || index.row() < 0 || index.row() >= rowCount() ||
        index.column() < 0 || index.column() >= 4)
      return {};
    const auto &order = values_[std::size_t(index.row())];
    if (role == Id)
      return order.id;
    if (role == Priority)
      return order.priority;
    if (role == Open)
      return order.status == Status::open;
    if (role != Qt::DisplayRole && role != Qt::EditRole)
      return {};
    switch (index.column()) {
    case 0:
      return order.id;
    case 1:
      return QString::fromStdString(order.title);
    case 2:
      return order.priority;
    case 3:
      return order.status == Status::open ? "open" : "done";
    }
    return {};
  }
  QVariant headerData(int section, Qt::Orientation orientation,
                      int role) const override {
    if (orientation == Qt::Horizontal && role == Qt::DisplayRole &&
        section >= 0 && section < 4)
      return QStringList{"ID", "Title", "Priority", "Status"}.at(section);
    return QAbstractTableModel::headerData(section, orientation, role);
  }
  Qt::ItemFlags flags(const QModelIndex &index) const override {
    if (!index.isValid())
      return Qt::NoItemFlags;
    auto result = QAbstractTableModel::flags(index);
    if (index.column() == 1)
      result |= Qt::ItemIsEditable;
    return result;
  }
  bool setData(const QModelIndex &index, const QVariant &value,
               int role) override {
    if (role != Qt::EditRole || !index.isValid() || index.column() != 1 ||
        index.row() < 0 || index.row() >= rowCount())
      return false;
    auto candidate = values_[std::size_t(index.row())];
    candidate.title = value.toString().toStdString();
    auto saved = service_.save(candidate);
    if (!succeeded(saved)) {
      lastError_ = QString::fromStdString(std::get<Error>(saved).message);
      return false;
    }
    values_[std::size_t(index.row())] = std::move(candidate);
    lastError_.clear();
    emit dataChanged(index, index, {Qt::DisplayRole, Qt::EditRole});
    return true;
  }
  Result<Done> refresh() {
    auto loaded = service_.list();
    if (!succeeded(loaded))
      return std::get<Error>(loaded);
    auto batch = std::get<std::vector<Order>>(std::move(loaded));
    beginResetModel();
    values_.swap(batch);
    endResetModel();
    return Done{};
  }
  QString lastError() const { return lastError_; }
};
class OpenFilter : public QSortFilterProxyModel {
  bool onlyOpen_{false};

protected:
  bool filterAcceptsRow(int row, const QModelIndex &parent) const override {
    return QSortFilterProxyModel::filterAcceptsRow(row, parent) &&
           (!onlyOpen_ || sourceModel()
                              ->index(row, 0, parent)
                              .data(OrderModel::Open)
                              .toBool());
  }

public:
  explicit OpenFilter(QObject *parent = nullptr)
      : QSortFilterProxyModel(parent) {
    setFilterKeyColumn(1);
    setFilterCaseSensitivity(Qt::CaseInsensitive);
  }
  void setOnlyOpen(bool value) {
    onlyOpen_ = value;
    invalidateFilter();
  }
};
} // namespace orders
Erwartetes Ergebnis

Ein falsch zugeordneter Proxy-Index würde am Datenvergleich auffallen.

05Tastaturbedienung prüfen

Ergänze Ctrl+L als Fokuswechsel zum Titelfeld. Die Lösung verwendet einen QShortcut mit dem Editor als Besitzer. Der Test startet mit Fokus im Suchfeld, sendet die Tastenkombination und erwartet Fokus und markierten Text im Titelfeld. Er prüft außerdem, dass der Fokuswechsel noch keine Daten speichert.

solution.cpp · cppDatei öffnen
#include "order_editor.hpp"
#include <QShortcut>
#include <QtTest>
void addTitleShortcut(orders::OrderEditor &editor) {
  auto *shortcut = new QShortcut(QKeySequence("Ctrl+L"), &editor);
  QObject::connect(shortcut, &QShortcut::activated, &editor, [&editor] {
    auto *title = editor.findChild<QLineEdit *>("title");
    title->setFocus();
    title->selectAll();
  });
}
class ShortcutTest : public QObject {
  Q_OBJECT
private slots:
  void focusAndSelection() {
    orders::MemoryRepository repository;
    orders::OrderService service(repository);
    orders::OrderEditor editor(service);
    addTitleShortcut(editor);
    editor.show();
    editor.activateWindow();
    QTRY_VERIFY_WITH_TIMEOUT(editor.isActiveWindow(), 2000);
    auto *title = editor.findChild<QLineEdit *>("title");
    title->setText("Existing draft");
    auto *search = editor.findChild<QLineEdit *>("search");
    search->setFocus();
    QTest::keyClick(search, Qt::Key_L, Qt::ControlModifier);
    QTRY_VERIFY_WITH_TIMEOUT(title->hasFocus(), 2000);
    QCOMPARE(title->selectedText(), QString("Existing draft"));
    QVERIFY(std::get<std::vector<orders::Order>>(service.list()).empty());
  }
};
QTEST_MAIN(ShortcutTest)
#include "solution.moc"
Erwartetes Ergebnis

Ctrl+L markiert Existing draft im Titelfeld.

06Die Grenzen automatischer UI-Prüfung kennen

python3 verify.py verwendet für automatisierte Läufe standardmäßig Qt offscreen. Dadurch kann die Ereignisschleife ohne sichtbaren Desktop arbeiten. Für asynchrone Bedingungen verwendet die Tastaturprüfung begrenzte QTRY-Wartezeiten. Eine native Windows-Sitzung, Screenreader-Bedienung oder subjektive visuelle Qualität ist damit noch nicht geprüft.

verify.py · pythonDatei öffnen
"""Build all targets and run the example and solution tests."""

import os
import subprocess
from pathlib import Path

root = Path(__file__).resolve().parent
environment = dict(os.environ)
environment.setdefault("QT_QPA_PLATFORM", "offscreen")
for command in [
    ["cmake", "-S", ".", "-B", "build", "-DCMAKE_BUILD_TYPE=Debug"],
    ["cmake", "--build", "build", "--parallel", "2"],
    ["ctest", "--test-dir", "build", "--output-on-failure"],
]:
    subprocess.run(command, cwd=root, env=environment, check=True, timeout=600)
Erwartetes Ergebnis

Widgetablauf und Tastaturübung bestehen in der dokumentierten Linux-Umgebung.

Deine Übung

Ergänze Ctrl+L zum Fokussieren und vollständigen Markieren des Titelfeldes. Prüfe den Wechsel aus dem Suchfeld und stelle sicher, dass dadurch keine Speicherung erfolgt.

Lösung mit Erklärung anzeigen

Ein vom Editor besessener QShortcut verbindet activated mit setFocus und selectAll. Der Test verarbeitet Qt-Ereignisse mit einer begrenzten Wartezeit und prüft anschließend den weiterhin leeren Repository-Bestand.

solution.cpp · cppDatei öffnen
#include "order_editor.hpp"
#include <QShortcut>
#include <QtTest>
void addTitleShortcut(orders::OrderEditor &editor) {
  auto *shortcut = new QShortcut(QKeySequence("Ctrl+L"), &editor);
  QObject::connect(shortcut, &QShortcut::activated, &editor, [&editor] {
    auto *title = editor.findChild<QLineEdit *>("title");
    title->setFocus();
    title->selectAll();
  });
}
class ShortcutTest : public QObject {
  Q_OBJECT
private slots:
  void focusAndSelection() {
    orders::MemoryRepository repository;
    orders::OrderService service(repository);
    orders::OrderEditor editor(service);
    addTitleShortcut(editor);
    editor.show();
    editor.activateWindow();
    QTRY_VERIFY_WITH_TIMEOUT(editor.isActiveWindow(), 2000);
    auto *title = editor.findChild<QLineEdit *>("title");
    title->setText("Existing draft");
    auto *search = editor.findChild<QLineEdit *>("search");
    search->setFocus();
    QTest::keyClick(search, Qt::Key_L, Qt::ControlModifier);
    QTRY_VERIFY_WITH_TIMEOUT(title->hasFocus(), 2000);
    QCOMPARE(title->selectedText(), QString("Existing draft"));
    QVERIFY(std::get<std::vector<orders::Order>>(service.list()).empty());
  }
};
QTEST_MAIN(ShortcutTest)
#include "solution.moc"

Projektbezug und Quellen

Eigenständiges Lernprojekt im Logistikthema von FactoryForge. Der bestehende FactoryForge-Quellstand dient als Architekturkontext. Die hier eingeführten SQLite-, Netzwerk- und Importfunktionen sind Funktionen des Lernprojekts. Das Order-Lab-JSON ist ein eigenes Format.