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.
#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 ¤t) {
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
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.
#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();
}
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.
#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"
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.
#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
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.
#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"
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.
"""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)
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.
#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.