diff --git a/tests/units/widgets/editorviewtest.cpp b/tests/units/widgets/editorviewtest.cpp
index 600adf5d..38e8f85d 100644
--- a/tests/units/widgets/editorviewtest.cpp
+++ b/tests/units/widgets/editorviewtest.cpp
@@ -1,870 +1,870 @@
 /* This file is part of Zanshin
 
    Copyright 2014 Kevin Ottens <ervin@kde.org>
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License as
    published by the Free Software Foundation; either version 2 of
    the License or (at your option) version 3 or any later version
    accepted by the membership of KDE e.V. (or its successor approved
    by the membership of KDE e.V.), which shall act as a proxy
    defined in Section 14 of version 3 of the license.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
    USA.
 */
 
 #include <testlib/qtest_gui_zanshin.h>
 
 #include <QAbstractButton>
 #include <QLabel>
 #include <QListView>
 #include <QPlainTextEdit>
 #include <QStandardItemModel>
 #include <QToolButton>
 
 #include <KLocalizedString>
 
 #include "domain/note.h"
 #include "domain/task.h"
 
 #include "widgets/editorview.h"
 
 #include "addressline/addresseelineedit.h"
 #include "kdateedit.h"
 
 class EditorModelStub : public QObject
 {
     Q_OBJECT
 public:
     EditorModelStub()
     {
         setProperty("editingInProgress", false);
         setProperty("attachmentModel", QVariant::fromValue(&attachmentModel));
     }
 
     void setPropertyAndSignal(const QByteArray &name, const QVariant &value)
     {
         if (property(name) == value)
             return;
         if (property("editingInProgress").toBool())
             return;
 
         setProperty(name, value);
         if (name == "artifact")
             emit artifactChanged(value.value<Domain::Artifact::Ptr>());
         else if (name == "text")
             emit textChanged(value.toString());
         else if (name == "title")
             emit titleChanged(value.toString());
         else if (name == "done")
             emit doneChanged(value.toBool());
         else if (name == "startDate")
             emit startDateChanged(value.toDateTime());
         else if (name == "dueDate")
             emit dueDateChanged(value.toDateTime());
         else if (name == "recurrence")
             emit recurrenceChanged(value.value<Domain::Task::Recurrence>());
         else if (name == "delegateText")
             emit delegateTextChanged(value.toString());
         else if (name == "hasTaskProperties")
             emit hasTaskPropertiesChanged(value.toBool());
         else
             qFatal("Unsupported property %s", name.constData());
     }
 
 public slots:
     void setArtifact(const Domain::Artifact::Ptr &artifact) { setPropertyAndSignal("artifact", QVariant::fromValue(artifact)); }
     void setTitle(const QString &title) { setPropertyAndSignal("title", title); }
     void setText(const QString &text) { setPropertyAndSignal("text", text); }
     void setDone(bool done) { setPropertyAndSignal("done", done); }
     void setStartDate(const QDateTime &start) { setPropertyAndSignal("startDate", start); }
     void setDueDate(const QDateTime &due) { setPropertyAndSignal("dueDate", due); }
     void setRecurrence(Domain::Task::Recurrence recurrence) { setPropertyAndSignal("recurrence", QVariant::fromValue(recurrence)); }
     void setDelegateText(const QString &text) { setPropertyAndSignal("delegateText", text); }
     void makeTaskAvailable() { setArtifact(Domain::Artifact::Ptr(new Domain::Task)); }
 
     void delegate(const QString &name, const QString &email)
     {
         delegateNames << name;
         delegateEmails << email;
     }
 
     void addAttachment(const QString &fileName)
     {
         auto item = new QStandardItem(fileName);
         attachmentModel.appendRow(QList<QStandardItem*>() << item);
     }
 
     void removeAttachment(const QModelIndex &index)
     {
         if (index.isValid())
             attachmentModel.removeRows(index.row(), 1, QModelIndex());
     }
 
 signals:
     void artifactChanged(const Domain::Artifact::Ptr &artifact);
     void hasTaskPropertiesChanged(bool hasTaskProperties);
     void textChanged(const QString &text);
     void titleChanged(const QString &title);
     void doneChanged(bool done);
     void startDateChanged(const QDateTime &date);
     void dueDateChanged(const QDateTime &due);
     void recurrenceChanged(Domain::Task::Recurrence recurrence);
     void delegateTextChanged(const QString &delegateText);
 
 public:
     QStringList delegateNames;
     QStringList delegateEmails;
     QStandardItemModel attachmentModel;
 };
 
 class EditorViewTest : public QObject
 {
     Q_OBJECT
 public:
     explicit EditorViewTest(QObject *parent = Q_NULLPTR)
         : QObject(parent)
     {
         qputenv("ZANSHIN_UNIT_TEST_RUN", "1");
     }
 
 private slots:
     void shouldHaveDefaultState()
     {
         Widgets::EditorView editor;
 
         QVERIFY(!editor.isEnabled());
 
         auto textEdit = editor.findChild<QPlainTextEdit*>(QStringLiteral("textEdit"));
         QVERIFY(textEdit);
         QVERIFY(textEdit->isVisibleTo(&editor));
 
         auto startDateEdit = editor.findChild<KPIM::KDateEdit*>(QStringLiteral("startDateEdit"));
         QVERIFY(startDateEdit);
         QVERIFY(!startDateEdit->isVisibleTo(&editor));
 
         auto dueDateEdit = editor.findChild<KPIM::KDateEdit*>(QStringLiteral("dueDateEdit"));
         QVERIFY(dueDateEdit);
         QVERIFY(!dueDateEdit->isVisibleTo(&editor));
 
         auto recurrenceCombo = editor.findChild<QComboBox*>(QStringLiteral("recurrenceCombo"));
         QVERIFY(recurrenceCombo);
         QVERIFY(!recurrenceCombo->isVisibleTo(&editor));
 
         auto doneButton = editor.findChild<QAbstractButton*>(QStringLiteral("doneButton"));
         QVERIFY(doneButton);
         QVERIFY(!doneButton->isVisibleTo(&editor));
 
         auto attachmentList = editor.findChild<QListView*>(QStringLiteral("attachmentList"));
         QVERIFY(attachmentList);
         QVERIFY(!attachmentList->isVisibleTo(&editor));
 
         auto addAttachmentButton = editor.findChild<QToolButton*>(QStringLiteral("addAttachmentButton"));
         QVERIFY(addAttachmentButton);
         QVERIFY(!addAttachmentButton->isVisibleTo(&editor));
 
         auto removeAttachmentButton = editor.findChild<QToolButton*>(QStringLiteral("removeAttachmentButton"));
         QVERIFY(removeAttachmentButton);
         QVERIFY(!removeAttachmentButton->isVisibleTo(&editor));
 
         auto delegateLabel = editor.findChild<QLabel*>(QStringLiteral("delegateLabel"));
         QVERIFY(delegateLabel);
         QVERIFY(!delegateLabel->isVisibleTo(&editor));
 
         auto delegateEdit = editor.findChild<KLineEdit*>(QStringLiteral("delegateEdit"));
         QVERIFY(delegateEdit);
         QVERIFY(!delegateEdit->isVisibleTo(&editor));
     }
 
     void shouldNotCrashForNullModel()
     {
         // GIVEN
         Widgets::EditorView editor;
         EditorModelStub model;
         model.setTitle(QStringLiteral("Foo"));
         model.setText(QStringLiteral("Bar"));
         model.setPropertyAndSignal("hasTaskProperties", true);
         editor.setModel(&model);
 
         auto textEdit = editor.findChild<QPlainTextEdit*>(QStringLiteral("textEdit"));
         QVERIFY(textEdit);
 
         auto startDateEdit = editor.findChild<KPIM::KDateEdit*>(QStringLiteral("startDateEdit"));
         QVERIFY(startDateEdit);
 
         auto dueDateEdit = editor.findChild<KPIM::KDateEdit*>(QStringLiteral("dueDateEdit"));
         QVERIFY(dueDateEdit);
 
         auto recurrenceCombo = editor.findChild<QComboBox*>(QStringLiteral("recurrenceCombo"));
         QVERIFY(recurrenceCombo);
 
         auto doneButton = editor.findChild<QAbstractButton*>(QStringLiteral("doneButton"));
         QVERIFY(doneButton);
 
         auto attachmentList = editor.findChild<QListView*>(QStringLiteral("attachmentList"));
         QVERIFY(attachmentList);
         QCOMPARE(attachmentList->model(), &model.attachmentModel);
 
         auto addAttachmentButton = editor.findChild<QToolButton*>(QStringLiteral("addAttachmentButton"));
         QVERIFY(addAttachmentButton);
 
         auto removeAttachmentButton = editor.findChild<QToolButton*>(QStringLiteral("removeAttachmentButton"));
         QVERIFY(removeAttachmentButton);
 
         auto delegateLabel = editor.findChild<QLabel*>(QStringLiteral("delegateLabel"));
         QVERIFY(delegateLabel);
 
         auto delegateEdit = editor.findChild<KLineEdit*>(QStringLiteral("delegateEdit"));
         QVERIFY(delegateEdit);
 
         // WHEN
         editor.setModel(Q_NULLPTR);
 
         // THEN
         QVERIFY(!editor.isEnabled());
         QVERIFY(textEdit->toPlainText().isEmpty());
         QVERIFY(!startDateEdit->isVisibleTo(&editor));
         QVERIFY(!dueDateEdit->isVisibleTo(&editor));
         QVERIFY(!recurrenceCombo->isVisibleTo(&editor));
         QVERIFY(!doneButton->isVisibleTo(&editor));
         QVERIFY(!attachmentList->isVisibleTo(&editor));
         QVERIFY(attachmentList->model() == nullptr);
         QVERIFY(!addAttachmentButton->isVisibleTo(&editor));
         QVERIFY(!removeAttachmentButton->isVisibleTo(&editor));
         QVERIFY(!delegateLabel->isVisibleTo(&editor));
         QVERIFY(!delegateEdit->isVisibleTo(&editor));
     }
 
     void shouldShowTaskPropertiesEditorsOnlyForTasks()
     {
         // GIVEN
         Widgets::EditorView editor;
         EditorModelStub model;
         model.setPropertyAndSignal("hasTaskProperties", true);
 
         auto startDateEdit = editor.findChild<KPIM::KDateEdit*>(QStringLiteral("startDateEdit"));
         QVERIFY(!startDateEdit->isVisibleTo(&editor));
 
         auto dueDateEdit = editor.findChild<KPIM::KDateEdit*>(QStringLiteral("dueDateEdit"));
         QVERIFY(!dueDateEdit->isVisibleTo(&editor));
 
         auto recurrenceCombo = editor.findChild<QComboBox*>(QStringLiteral("recurrenceCombo"));
         QVERIFY(recurrenceCombo);
 
         auto doneButton = editor.findChild<QAbstractButton*>(QStringLiteral("doneButton"));
         QVERIFY(!doneButton->isVisibleTo(&editor));
 
         auto attachmentList = editor.findChild<QListView*>(QStringLiteral("attachmentList"));
         QVERIFY(attachmentList);
 
         auto addAttachmentButton = editor.findChild<QToolButton*>(QStringLiteral("addAttachmentButton"));
         QVERIFY(addAttachmentButton);
 
         auto removeAttachmentButton = editor.findChild<QToolButton*>(QStringLiteral("removeAttachmentButton"));
         QVERIFY(removeAttachmentButton);
 
         auto delegateLabel = editor.findChild<QLabel*>(QStringLiteral("delegateLabel"));
         QVERIFY(!delegateLabel->isVisibleTo(&editor));
 
         auto delegateEdit = editor.findChild<KLineEdit*>(QStringLiteral("delegateEdit"));
         QVERIFY(!delegateEdit->isVisibleTo(&editor));
 
         // WHEN
         editor.setModel(&model);
 
         // THEN
         QVERIFY(startDateEdit->isVisibleTo(&editor));
         QVERIFY(dueDateEdit->isVisibleTo(&editor));
         QVERIFY(recurrenceCombo->isVisibleTo(&editor));
         QVERIFY(doneButton->isVisibleTo(&editor));
         QVERIFY(attachmentList->isVisibleTo(&editor));
         QVERIFY(addAttachmentButton->isVisibleTo(&editor));
         QVERIFY(removeAttachmentButton->isVisibleTo(&editor));
         QVERIFY(!delegateLabel->isVisibleTo(&editor));
         QVERIFY(delegateEdit->isVisibleTo(&editor));
     }
 
     void shouldDisplayDelegateLabelOnlyWhenNeeded()
     {
         // GIVEN
         Widgets::EditorView editor;
         EditorModelStub model;
         model.makeTaskAvailable();
         model.setDelegateText(QStringLiteral("John Doe"));
 
         auto delegateLabel = editor.findChild<QLabel*>(QStringLiteral("delegateLabel"));
         QVERIFY(!delegateLabel->isVisibleTo(&editor));
 
         // WHEN
         editor.setModel(&model);
 
         // THEN
         auto expectedText = i18n("Delegated to: <b>%1</b>", model.property("delegateText").toString());
         QVERIFY(delegateLabel->isVisibleTo(&editor));
         QCOMPARE(delegateLabel->text(), expectedText);
     }
 
     void shouldBeEnabledOnlyWhenAnArtifactIsAvailable()
     {
         // GIVEN
         Widgets::EditorView editor;
         EditorModelStub model;
 
         // WHEN
         editor.setModel(&model);
 
         // THEN
         QVERIFY(!editor.isEnabled());
 
         // WHEN
         // like model.makeTaskAvailable() does:
         Domain::Artifact::Ptr artifact(new Domain::Task);
         model.setPropertyAndSignal("artifact", QVariant::fromValue(artifact));
 
         // THEN
         QVERIFY(editor.isEnabled());
 
         // WHEN
         model.setPropertyAndSignal("artifact", QVariant::fromValue(Domain::Artifact::Ptr()));
 
         // THEN
         QVERIFY(!editor.isEnabled());
 
 
 
         // GIVEN
         EditorModelStub model2;
         model2.setPropertyAndSignal("artifact", QVariant::fromValue(artifact));
 
         // WHEN
         editor.setModel(&model2);
 
         // THEN
         QVERIFY(editor.isEnabled());
     }
 
     void shouldReactToHasTaskPropertiesChanged()
     {
         // GIVEN
         Widgets::EditorView editor;
         EditorModelStub model;
         model.makeTaskAvailable();
         editor.setModel(&model);
 
         auto startDateEdit = editor.findChild<KPIM::KDateEdit*>(QStringLiteral("startDateEdit"));
         QVERIFY(!startDateEdit->isVisibleTo(&editor));
 
         auto dueDateEdit = editor.findChild<KPIM::KDateEdit*>(QStringLiteral("dueDateEdit"));
         QVERIFY(!dueDateEdit->isVisibleTo(&editor));
 
         auto doneButton = editor.findChild<QAbstractButton*>(QStringLiteral("doneButton"));
         QVERIFY(!doneButton->isVisibleTo(&editor));
 
         // WHEN
         model.setPropertyAndSignal("hasTaskProperties", true);
 
         // THEN
         QVERIFY(startDateEdit->isVisibleTo(&editor));
         QVERIFY(dueDateEdit->isVisibleTo(&editor));
         QVERIFY(doneButton->isVisibleTo(&editor));
     }
 
     void shouldDisplayModelProperties()
     {
         // GIVEN
         Widgets::EditorView editor;
         EditorModelStub model;
         model.makeTaskAvailable();
         model.setProperty("hasTaskProperties", true);
         model.setProperty("title", "My title");
         model.setProperty("text", "\nMy text");
         model.setProperty("startDate", QDateTime::currentDateTime());
         model.setProperty("dueDate", QDateTime::currentDateTime().addDays(2));
         model.setProperty("recurrence", QVariant::fromValue(Domain::Task::RecursWeekly));
         model.setProperty("done", true);
 
         auto textEdit = editor.findChild<QPlainTextEdit*>(QStringLiteral("textEdit"));
         auto startDateEdit = editor.findChild<KPIM::KDateEdit*>(QStringLiteral("startDateEdit"));
         auto dueDateEdit = editor.findChild<KPIM::KDateEdit*>(QStringLiteral("dueDateEdit"));
         auto recurrenceCombo = editor.findChild<QComboBox*>(QStringLiteral("recurrenceCombo"));
         auto doneButton = editor.findChild<QAbstractButton*>(QStringLiteral("doneButton"));
 
         // WHEN
         editor.setModel(&model);
 
         // THEN
         QCOMPARE(textEdit->toPlainText(), QString(model.property("title").toString()
                                                 + '\n'
                                                 + model.property("text").toString()));
         QCOMPARE(startDateEdit->date(), model.property("startDate").toDateTime().date());
         QCOMPARE(dueDateEdit->date(), model.property("dueDate").toDateTime().date());
         QCOMPARE(recurrenceCombo->currentData().value<Domain::Task::Recurrence>(), model.property("recurrence").value<Domain::Task::Recurrence>());
         QCOMPARE(doneButton->isChecked(), model.property("done").toBool());
     }
 
     void shouldNotReactToChangesWhileEditing()
     {
         // GIVEN
         Widgets::EditorView editor;
         EditorModelStub model;
         model.makeTaskAvailable();
         model.setProperty("title", "My title");
         model.setProperty("text", "\nMy text");
         model.setProperty("startDate", QDateTime::currentDateTime());
         model.setProperty("dueDate", QDateTime::currentDateTime().addDays(2));
         model.setProperty("recurrence", QVariant::fromValue(Domain::Task::RecursWeekly));
         model.setProperty("done", true);
         editor.setModel(&model);
 
         auto textEdit = editor.findChild<QPlainTextEdit*>(QStringLiteral("textEdit"));
         auto startDateEdit = editor.findChild<KPIM::KDateEdit*>(QStringLiteral("startDateEdit"));
         auto dueDateEdit = editor.findChild<KPIM::KDateEdit*>(QStringLiteral("dueDateEdit"));
         auto recurrenceCombo = editor.findChild<QComboBox*>(QStringLiteral("recurrenceCombo"));
         auto doneButton = editor.findChild<QAbstractButton*>(QStringLiteral("doneButton"));
         auto delegateLabel = editor.findChild<QLabel*>(QStringLiteral("delegateLabel"));
         auto delegateEdit = editor.findChild<QWidget*>(QStringLiteral("delegateEdit"));
         model.setDelegateText(QStringLiteral("John Doe"));
         editor.setModel(&model);
 
         // WHEN
         editor.show();
-        QTest::qWaitForWindowShown(&editor);
+        QVERIFY(QTest::qWaitForWindowShown(&editor));
         editor.activateWindow();
         textEdit->setFocus();
         model.setTitle("New title");
         model.setText("New text");
         startDateEdit->setFocus();
         model.setStartDate(QDateTime::currentDateTime().addDays(1));
         dueDateEdit->setFocus();
         model.setDueDate(QDateTime::currentDateTime().addDays(3));
         recurrenceCombo->setFocus();
         model.setRecurrence(Domain::Task::RecursDaily);
         doneButton->setFocus();
         model.setDone(false);
         delegateEdit->setFocus();
         model.setDelegateText(QStringLiteral("John Smith"));
 
         // THEN (nothing changed)
         QCOMPARE(textEdit->toPlainText(), QStringLiteral("My title\n\nMy text"));
         QCOMPARE(startDateEdit->date(), QDate::currentDate());
         QCOMPARE(dueDateEdit->date(), QDate::currentDate().addDays(2));
         QCOMPARE(recurrenceCombo->currentData().value<Domain::Task::Recurrence>(), Domain::Task::RecursWeekly);
         QVERIFY(doneButton->isChecked());
         auto expectedText = i18n("Delegated to: <b>%1</b>", QStringLiteral("John Doe"));
         QCOMPARE(delegateLabel->text(), expectedText);
 
     }
 
     void shouldReactToTitleChanges()
     {
         // GIVEN
         Widgets::EditorView editor;
         EditorModelStub model;
         model.makeTaskAvailable();
         model.setProperty("title", "My title");
         model.setProperty("text", "\nMy text");
         model.setProperty("startDate", QDateTime::currentDateTime());
         model.setProperty("dueDate", QDateTime::currentDateTime().addDays(2));
         model.setProperty("done", true);
         editor.setModel(&model);
 
         auto textEdit = editor.findChild<QPlainTextEdit*>(QStringLiteral("textEdit"));
 
         // WHEN
         model.setPropertyAndSignal("title", "New title");
 
         // THEN
         QCOMPARE(textEdit->toPlainText(), QString(model.property("title").toString()
                                                 + '\n'
                                                 + model.property("text").toString()));
     }
 
     void shouldReactToTextChanges()
     {
         // GIVEN
         Widgets::EditorView editor;
         EditorModelStub model;
         model.makeTaskAvailable();
         model.setProperty("title", "My title");
         model.setProperty("text", "\nMy text");
         model.setProperty("startDate", QDateTime::currentDateTime());
         model.setProperty("dueDate", QDateTime::currentDateTime().addDays(2));
         model.setProperty("done", true);
         editor.setModel(&model);
 
         auto textEdit = editor.findChild<QPlainTextEdit*>(QStringLiteral("textEdit"));
 
         // WHEN
         model.setPropertyAndSignal("text", "\nNew text");
 
         // THEN
         QCOMPARE(textEdit->toPlainText(), QString(model.property("title").toString()
                                                 + '\n'
                                                 + model.property("text").toString()));
     }
 
     void shouldApplyTextEditChanges_data()
     {
         QTest::addColumn<QString>("plainText");
         QTest::addColumn<QString>("expectedTitle");
         QTest::addColumn<QString>("expectedText");
 
         QTest::newRow("nominal case") << "Title\n\nText" << "Title" << "\nText";
         QTest::newRow("single line") << "Title" << "Title" << "";
     }
 
     void shouldApplyTextEditChanges()
     {
         // GIVEN
         Widgets::EditorView editor;
         EditorModelStub model;
         model.makeTaskAvailable();
         editor.setModel(&model);
 
         auto textEdit = editor.findChild<QPlainTextEdit*>(QStringLiteral("textEdit"));
 
         // WHEN
         QFETCH(QString, plainText);
         textEdit->setPlainText(plainText);
 
         // THEN
         QFETCH(QString, expectedTitle);
         QCOMPARE(model.property("title").toString(), expectedTitle);
         QFETCH(QString, expectedText);
         QCOMPARE(model.property("text").toString(), expectedText);
     }
 
     void shouldReactToDoneChanges()
     {
         // GIVEN
         Widgets::EditorView editor;
         EditorModelStub model;
         model.makeTaskAvailable();
         model.setProperty("title", "My title");
         model.setProperty("text", "\nMy text");
         model.setProperty("startDate", QDateTime::currentDateTime());
         model.setProperty("dueDate", QDateTime::currentDateTime().addDays(2));
         model.setProperty("done", false);
         editor.setModel(&model);
 
         auto doneButton = editor.findChild<QAbstractButton*>(QStringLiteral("doneButton"));
         QVERIFY(!doneButton->isChecked());
 
         // WHEN
         model.setPropertyAndSignal("done", true);
 
         // THEN
         QVERIFY(doneButton->isChecked());
     }
 
     void shouldApplyDoneButtonChanges()
     {
         // GIVEN
         Widgets::EditorView editor;
         EditorModelStub model;
         model.makeTaskAvailable();
         editor.setModel(&model);
 
         auto doneButton = editor.findChild<QAbstractButton*>(QStringLiteral("doneButton"));
 
         // WHEN
         doneButton->setChecked(true);
 
         // THEN
         QCOMPARE(model.property("done").toBool(), true);
     }
 
     void shouldReactToStartDateChanges()
     {
         // GIVEN
         Widgets::EditorView editor;
         EditorModelStub model;
         model.makeTaskAvailable();
         model.setProperty("title", "My title");
         model.setProperty("text", "\nMy text");
         model.setProperty("startDate", QDateTime::currentDateTime());
         model.setProperty("dueDate", QDateTime::currentDateTime().addDays(2));
         model.setProperty("done", false);
         editor.setModel(&model);
 
         auto startDateEdit = editor.findChild<KPIM::KDateEdit*>(QStringLiteral("startDateEdit"));
 
         // WHEN
         model.setPropertyAndSignal("startDate", QDateTime::currentDateTime().addDays(-2));
 
         // THEN
         QCOMPARE(startDateEdit->date(), model.property("startDate").toDateTime().date());
     }
 
     void shouldApplyStartDateEditChanges()
     {
         // GIVEN
         Widgets::EditorView editor;
         EditorModelStub model;
         model.makeTaskAvailable();
         editor.setModel(&model);
 
         auto startDateEdit = editor.findChild<KPIM::KDateEdit*>(QStringLiteral("startDateEdit"));
         auto today = QDate::currentDate();
 
         // WHEN
         startDateEdit->setEditText(today.toString(QStringLiteral("dd/MM/yyyy")));
         QTest::keyClick(startDateEdit, Qt::Key_Enter);
 
         // THEN
         const QDateTime newStartDateTime = model.property("startDate").toDateTime();
         QCOMPARE(newStartDateTime.date(), today);
         QCOMPARE(newStartDateTime.timeSpec(), Qt::UTC);
     }
 
     void shouldReactToDueDateChanges()
     {
         // GIVEN
         Widgets::EditorView editor;
         EditorModelStub model;
         model.setProperty("title", "My title");
         model.setProperty("text", "\nMy text");
         model.setProperty("startDate", QDateTime::currentDateTime());
         model.setProperty("dueDate", QDateTime::currentDateTime().addDays(2));
         model.setProperty("done", false);
         editor.setModel(&model);
 
         auto dueDateEdit = editor.findChild<KPIM::KDateEdit*>(QStringLiteral("dueDateEdit"));
 
         // WHEN
         model.setPropertyAndSignal("dueDate", QDateTime::currentDateTime().addDays(-2));
 
         // THEN
         QCOMPARE(dueDateEdit->date(), model.property("dueDate").toDateTime().date());
     }
 
     void shouldApplyDueDateEditChanges()
     {
         // GIVEN
         Widgets::EditorView editor;
         EditorModelStub model;
         model.makeTaskAvailable();
         editor.setModel(&model);
 
         auto dueDateEdit = editor.findChild<KPIM::KDateEdit*>(QStringLiteral("dueDateEdit"));
         auto today = QDate::currentDate();
 
         // WHEN
         QVERIFY(dueDateEdit->isEnabled());
         dueDateEdit->setEditText(today.toString(QStringLiteral("dd/MM/yyyy")));
         QTest::keyClick(dueDateEdit, Qt::Key_Enter);
 
         // THEN
         QCOMPARE(model.property("dueDate").toDateTime().date(), today);
     }
 
     void shouldApplyStartTodayChanges()
     {
         // GIVEN
         Widgets::EditorView editor;
         EditorModelStub model;
         model.makeTaskAvailable();
         editor.setModel(&model);
 
         QAbstractButton *startTodayButton = editor.findChild<QAbstractButton *>(QStringLiteral("startTodayButton"));
         QVERIFY(startTodayButton);
         auto startDateEdit = editor.findChild<KPIM::KDateEdit*>(QStringLiteral("startDateEdit"));
         auto today = QDate::currentDate();
 
         // WHEN
         QVERIFY(startTodayButton->isEnabled());
         startTodayButton->click();
 
         // THEN
         QCOMPARE(startDateEdit->currentText(), today.toString(QStringLiteral("dd/MM/yyyy")));
         QCOMPARE(model.property("startDate").toDateTime().date(), today);
     }
 
     void shouldReactToRecurrenceChanges()
     {
         // GIVEN
         Widgets::EditorView editor;
         EditorModelStub model;
         model.makeTaskAvailable();
         model.setProperty("title", "My title");
         model.setProperty("text", "\nMy text");
         model.setProperty("startDate", QDateTime::currentDateTime());
         model.setProperty("dueDate", QDateTime::currentDateTime().addDays(2));
         model.setProperty("recurrence", QVariant::fromValue(Domain::Task::RecursWeekly));
         model.setProperty("done", false);
         editor.setModel(&model);
 
         auto recurrenceCombo = editor.findChild<QComboBox*>(QStringLiteral("recurrenceCombo"));
 
         // WHEN
         model.setPropertyAndSignal("recurrence", Domain::Task::RecursMonthly);
 
         // THEN
         QCOMPARE(recurrenceCombo->currentData().value<Domain::Task::Recurrence>(), model.property("recurrence").value<Domain::Task::Recurrence>());
     }
 
     void shouldApplyRecurrenceComboChanges()
     {
         // GIVEN
         Widgets::EditorView editor;
         EditorModelStub model;
         model.makeTaskAvailable();
         editor.setModel(&model);
 
         auto recurrenceCombo = editor.findChild<QComboBox*>(QStringLiteral("recurrenceCombo"));
 
         // WHEN
         recurrenceCombo->setCurrentIndex(2); // Weekly
 
         // THEN
         QCOMPARE(model.property("recurrence").value<Domain::Task::Recurrence>(), Domain::Task::RecursWeekly);
     }
 
     void shouldAddAttachments()
     {
         // GIVEN
         Widgets::EditorView editor;
         editor.setRequestFileNameFunction([](QWidget*) { return "/tmp/foobar"; });
         EditorModelStub model;
         model.makeTaskAvailable();
         editor.setModel(&model);
 
         auto addAttachmentButton = editor.findChild<QToolButton*>(QStringLiteral("addAttachmentButton"));
 
         // WHEN
         addAttachmentButton->click();
 
         // THEN
         QCOMPARE(model.attachmentModel.rowCount(), 1);
         QCOMPARE(model.attachmentModel.data(model.attachmentModel.index(0, 0)).toString(),
                  QStringLiteral("/tmp/foobar"));
     }
 
     void shouldRemoveAttachments()
     {
         // GIVEN
         Widgets::EditorView editor;
         EditorModelStub model;
         model.makeTaskAvailable();
         model.addAttachment("/tmp/foo");
         model.addAttachment("/tmp/bar");
         editor.setModel(&model);
 
         auto attachmentList = editor.findChild<QListView*>(QStringLiteral("attachmentList"));
         auto removeAttachmentButton = editor.findChild<QToolButton*>(QStringLiteral("removeAttachmentButton"));
 
         // THEN
         QVERIFY(!removeAttachmentButton->isEnabled());
 
         // WHEN
         attachmentList->selectionModel()->select(model.attachmentModel.index(0, 0), QItemSelectionModel::ClearAndSelect);
 
         // THEN
         QVERIFY(removeAttachmentButton->isEnabled());
 
         // WHEN
         removeAttachmentButton->click();
 
         // THEN
         QCOMPARE(model.attachmentModel.rowCount(), 1);
         QCOMPARE(model.attachmentModel.data(model.attachmentModel.index(0, 0)).toString(),
                  QStringLiteral("/tmp/bar"));
     }
 
     void shouldReactToDelegateTextChanges()
     {
         // GIVEN
         Widgets::EditorView editor;
         EditorModelStub model;
         model.makeTaskAvailable();
         model.setDelegateText(QStringLiteral("John Doe"));
         editor.setModel(&model);
 
         auto delegateLabel = editor.findChild<QLabel*>(QStringLiteral("delegateLabel"));
 
         // WHEN
         model.setDelegateText(QStringLiteral("John Smith"));
 
         // THEN
         auto expectedText = i18n("Delegated to: <b>%1</b>", model.property("delegateText").toString());
         QCOMPARE(delegateLabel->text(), expectedText);
     }
 
     void shouldClearDelegateEditOnArtifactChanges()
     {
         // GIVEN
         Widgets::EditorView editor;
         EditorModelStub model;
         model.makeTaskAvailable();
         editor.setModel(&model);
 
         auto delegateEdit = editor.findChild<KLineEdit*>(QStringLiteral("delegateEdit"));
         delegateEdit->setText(QStringLiteral("Foo"));
 
         // WHEN
         model.makeTaskAvailable(); // simulates an artifact change
 
         // THEN
         QVERIFY(delegateEdit->text().isEmpty());
     }
 
     void shouldRequestDelegationOnInput_data()
     {
         QTest::addColumn<QString>("userInput");
         QTest::addColumn<QString>("expectedName");
         QTest::addColumn<QString>("expectedEmail");
         QTest::addColumn<bool>("expectedCall");
 
         QTest::newRow("nominal case") << "John Doe <john@doe.com>" << "John Doe" << "john@doe.com" << true;
         QTest::newRow("nominal case") << "John Doe <j.doe@some.server.com>" << "John Doe" << "j.doe@some.server.com" << true;
         QTest::newRow("only name") << "John Doe" << QString() << QString() << false;
         QTest::newRow("only email") << "john@doe.com" << QString() << "john@doe.com" << true;
         QTest::newRow("only email again") << "<john@doe.com>" << QString() << "john@doe.com" << true;
         QTest::newRow("nonsense case") << "bleh" << QString() << QString() << false;
     }
 
     void shouldRequestDelegationOnInput()
     {
         // GIVEN
         QFETCH(QString, userInput);
         QFETCH(QString, expectedName);
         QFETCH(QString, expectedEmail);
         QFETCH(bool, expectedCall);
 
         Widgets::EditorView editor;
         EditorModelStub model;
         model.makeTaskAvailable();
         editor.setModel(&model);
 
         auto delegateEdit = editor.findChild<KLineEdit*>(QStringLiteral("delegateEdit"));
 
         // WHEN
         QVERIFY(delegateEdit->isEnabled());
         delegateEdit->setText(userInput);
         QTest::keyClick(delegateEdit, Qt::Key_Enter);
 
         // THEN
         if (expectedCall) {
             QCOMPARE(model.delegateNames.size(), 1);
             QCOMPARE(model.delegateNames.first(), expectedName);
             QCOMPARE(model.delegateEmails.size(), 1);
             QCOMPARE(model.delegateEmails.first(), expectedEmail);
             QVERIFY(delegateEdit->text().isEmpty());
         } else {
             QCOMPARE(model.delegateNames.size(), 0);
             QCOMPARE(model.delegateEmails.size(), 0);
         }
     }
 };
 
 ZANSHIN_TEST_MAIN(EditorViewTest)
 
 #include "editorviewtest.moc"
diff --git a/tests/units/widgets/pageviewerrorhandlertest.cpp b/tests/units/widgets/pageviewerrorhandlertest.cpp
index 1356ac08..6111d73e 100644
--- a/tests/units/widgets/pageviewerrorhandlertest.cpp
+++ b/tests/units/widgets/pageviewerrorhandlertest.cpp
@@ -1,103 +1,103 @@
 /* This file is part of Zanshin
 
    Copyright 2016 Kevin Ottens <ervin@kde.org>
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License as
    published by the Free Software Foundation; either version 2 of
    the License or (at your option) version 3 or any later version
    accepted by the membership of KDE e.V. (or its successor approved
    by the membership of KDE e.V.), which shall act as a proxy
    defined in Section 14 of version 3 of the license.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
    USA.
 */
 
 #include <testlib/qtest_gui_zanshin.h>
 
 #include <KMessageWidget>
 
 #include "widgets/pageviewerrorhandler.h"
 #include "widgets/pageview.h"
 
 #include "testlib/fakejob.h"
 
 class PageViewErrorHandlerTest : public QObject
 {
     Q_OBJECT
 private slots:
     void shouldHaveDefaultState()
     {
         Widgets::PageViewErrorHandler errorHandler;
         QVERIFY(!errorHandler.pageView());
     }
 
     void shouldHaveAPageView()
     {
         // GIVEN
         Widgets::PageViewErrorHandler errorHandler;
         Widgets::PageView page;
 
         // WHEN
         errorHandler.setPageView(&page);
 
         // THEN
         QCOMPARE(errorHandler.pageView(), &page);
     }
 
     void shouldDisplayMessageOnJobError()
     {
         // GIVEN
         Widgets::PageViewErrorHandler errorHandler;
         Widgets::PageView page;
         page.show();
-        QTest::qWaitForWindowShown(&page);
+        QVERIFY(QTest::qWaitForWindowShown(&page));
         QTest::qWait(100);
 
         errorHandler.setPageView(&page);
 
         auto messageWidget = page.findChild<KMessageWidget*>(QStringLiteral("messageWidget"));
         QVERIFY(messageWidget);
         QVERIFY(!messageWidget->isVisibleTo(&page));
 
         // WHEN
         auto job = new FakeJob(this);
         job->setExpectedError(1, "Bar's fault");
         errorHandler.installHandler(job, "Foo Failed");
         QSignalSpy spy(job, &KJob::result);
         QVERIFY(spy.wait(FakeJob::DURATION * 2));
 
         // THEN
         QVERIFY(messageWidget->isVisibleTo(&page));
         QVERIFY(messageWidget->isShowAnimationRunning());
         QCOMPARE(messageWidget->text(), QStringLiteral("Foo Failed: Bar's fault"));
     }
 
     void shouldNotCrashWhenNoViewIsAvailable()
     {
         // GIVEN
         Widgets::PageViewErrorHandler errorHandler;
 
         // WHEN
         auto job = new FakeJob(this);
         job->setExpectedError(1, "Bar's fault");
         errorHandler.installHandler(job, "Foo Failed");
         QSignalSpy spy(job, &KJob::result);
         QVERIFY(spy.wait(FakeJob::DURATION * 2));
 
         // THEN
         // We survive this test
     }
 };
 
 ZANSHIN_TEST_MAIN(PageViewErrorHandlerTest)
 
 #include "pageviewerrorhandlertest.moc"
diff --git a/tests/units/widgets/pageviewtest.cpp b/tests/units/widgets/pageviewtest.cpp
index 3808016f..857fb094 100644
--- a/tests/units/widgets/pageviewtest.cpp
+++ b/tests/units/widgets/pageviewtest.cpp
@@ -1,748 +1,748 @@
 /* This file is part of Zanshin
 
    Copyright 2014 Kevin Ottens <ervin@kde.org>
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License as
    published by the Free Software Foundation; either version 2 of
    the License or (at your option) version 3 or any later version
    accepted by the membership of KDE e.V. (or its successor approved
    by the membership of KDE e.V.), which shall act as a proxy
    defined in Section 14 of version 3 of the license.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
    USA.
 */
 
 #include <testlib/qtest_gui_zanshin.h>
 
 #include <QAbstractItemModel>
 #include <QAction>
 #include <QHeaderView>
 #include <QLayout>
 #include <QLineEdit>
 #include <QMessageBox>
 #include <QStandardItemModel>
 #include <QToolButton>
 #include <QTreeView>
 #include <runningtaskmodelinterface.h>
 
 #include <KLocalizedString>
 #include <KMessageWidget>
 
 #include "domain/task.h"
 
 #include "presentation/artifactfilterproxymodel.h"
 #include "presentation/metatypes.h"
 #include "presentation/querytreemodelbase.h"
 
 #include "widgets/filterwidget.h"
 #include "widgets/itemdelegate.h"
 #include "widgets/pageview.h"
 
 #include "messageboxstub.h"
 
 class PageModelStub : public QObject
 {
     Q_OBJECT
     Q_PROPERTY(QAbstractItemModel* centralListModel READ centralListModel)
 public:
     QAbstractItemModel *centralListModel()
     {
         return &itemModel;
     }
 
     QStandardItem *addStubItem(const QString &title, QStandardItem *parentItem = Q_NULLPTR)
     {
         QStandardItem *item = new QStandardItem;
         item->setData(title, Qt::DisplayRole);
         if (!parentItem)
             itemModel.appendRow(item);
         else
             parentItem->appendRow(item);
 
         taskNames << title;
         return item;
     }
 
     Domain::Task::Ptr addTaskItem(const QString &title, QStandardItem *parentItem = Q_NULLPTR)
     {
         auto item = addStubItem(title, parentItem);
         auto task = Domain::Task::Ptr::create();
         task->setTitle(title);
         item->setData(QVariant::fromValue<Domain::Artifact::Ptr>(task), Presentation::QueryTreeModelBase::ObjectRole);
         return task;
     }
 
     void addStubItems(const QStringList &list)
     {
         foreach (const QString &title, list) {
             addStubItem(title);
         }
     }
 
 public slots:
     void addItem(const QString &name, const QModelIndex &parentIndex)
     {
         taskNames << name;
         parentIndices << parentIndex;
     }
 
     void removeItem(const QModelIndex &index)
     {
         removedIndices << index;
     }
 
     void promoteItem(const QModelIndex &index)
     {
         promotedIndices << index;
     }
 
 public:
     QStringList taskNames;
     QList<QPersistentModelIndex> parentIndices;
     QList<QPersistentModelIndex> removedIndices;
     QList<QPersistentModelIndex> promotedIndices;
     QStandardItemModel itemModel;
 };
 
 class RunningTaskModelStub : public Presentation::RunningTaskModelInterface
 {
     Q_OBJECT
 public:
     Domain::Task::Ptr runningTask() const Q_DECL_OVERRIDE { return m_runningTask; }
     void setRunningTask(const Domain::Task::Ptr &task) Q_DECL_OVERRIDE { m_runningTask = task; }
     void taskDeleted(const Domain::Task::Ptr &task) Q_DECL_OVERRIDE { m_deletedTask = task; }
     void stopTask() Q_DECL_OVERRIDE {}
     void doneTask() Q_DECL_OVERRIDE {}
 private:
     Domain::Task::Ptr m_runningTask;
     Domain::Task::Ptr m_deletedTask;
 };
 
 class PageViewTest : public QObject
 {
     Q_OBJECT
 private slots:
     void shouldHaveDefaultState()
     {
         Widgets::PageView page;
         QCOMPARE(page.contentsMargins(), QMargins(0, 0, 0, 0));
         QCOMPARE(page.layout()->contentsMargins(), QMargins(0, 0, 0, 3));
 
         auto messageWidget = page.findChild<KMessageWidget*>(QStringLiteral("messageWidget"));
         QVERIFY(messageWidget);
         QVERIFY(!messageWidget->isVisibleTo(&page));
         QVERIFY(!messageWidget->isCloseButtonVisible());
         QVERIFY(messageWidget->wordWrap());
         QVERIFY(messageWidget->text().isEmpty());
         QVERIFY(messageWidget->icon().isNull());
         QCOMPARE(messageWidget->messageType(), KMessageWidget::Error);
         QVERIFY(!messageWidget->isShowAnimationRunning());
         QVERIFY(!messageWidget->isHideAnimationRunning());
 
         auto centralView = page.findChild<QTreeView*>(QStringLiteral("centralView"));
         QVERIFY(centralView);
         QVERIFY(centralView->isVisibleTo(&page));
         QVERIFY(!centralView->header()->isVisibleTo(&page));
         QVERIFY(qobject_cast<Widgets::ItemDelegate*>(centralView->itemDelegate()));
         QVERIFY(centralView->alternatingRowColors());
         QCOMPARE(centralView->dragDropMode(), QTreeView::DragDrop);
 
         auto filter = page.findChild<Widgets::FilterWidget*>(QStringLiteral("filterWidget"));
         QVERIFY(filter);
         QVERIFY(!filter->isVisibleTo(&page));
         QVERIFY(filter->proxyModel());
         QCOMPARE(filter->proxyModel(), centralView->model());
 
         QLineEdit *quickAddEdit = page.findChild<QLineEdit*>(QStringLiteral("quickAddEdit"));
         QVERIFY(quickAddEdit);
         QVERIFY(quickAddEdit->isVisibleTo(&page));
         QVERIFY(quickAddEdit->text().isEmpty());
         QCOMPARE(quickAddEdit->placeholderText(), i18n("Type and press enter to add an item"));
 
         auto addAction = page.findChild<QAction*>(QStringLiteral("addItemAction"));
         QVERIFY(addAction);
         auto cancelAddAction = page.findChild<QAction*>(QStringLiteral("cancelAddItemAction"));
         QVERIFY(cancelAddAction);
         auto removeAction = page.findChild<QAction*>(QStringLiteral("removeItemAction"));
         QVERIFY(removeAction);
         auto promoteAction = page.findChild<QAction*>(QStringLiteral("promoteItemAction"));
         QVERIFY(promoteAction);
         auto filterAction = page.findChild<QAction*>(QStringLiteral("filterViewAction"));
         QVERIFY(filterAction);
         QVERIFY(filterAction->isCheckable());
         QVERIFY(!filterAction->isChecked());
         auto runTaskAction = page.findChild<QAction*>(QStringLiteral("runTaskAction"));
         QVERIFY(runTaskAction);
         QVERIFY(!runTaskAction->isEnabled());
 
         auto actions = page.globalActions();
         QCOMPARE(actions.value(QStringLiteral("page_view_add")), addAction);
         QCOMPARE(actions.value(QStringLiteral("page_view_remove")), removeAction);
         QCOMPARE(actions.value(QStringLiteral("page_view_promote")), promoteAction);
         QCOMPARE(actions.value(QStringLiteral("page_view_filter")), filterAction);
         QCOMPARE(actions.value(QStringLiteral("page_run_task")), runTaskAction);
     }
 
     void shouldDisplayListFromPageModel()
     {
         // GIVEN
         QStandardItemModel model;
 
         QObject stubPageModel;
         stubPageModel.setProperty("centralListModel", QVariant::fromValue(static_cast<QAbstractItemModel*>(&model)));
 
         Widgets::PageView page;
         auto centralView = page.findChild<QTreeView*>(QStringLiteral("centralView"));
         QVERIFY(centralView);
         auto proxyModel = qobject_cast<Presentation::ArtifactFilterProxyModel*>(centralView->model());
         QVERIFY(proxyModel);
         QVERIFY(!proxyModel->sourceModel());
 
         // WHEN
         page.setModel(&stubPageModel);
 
         // THEN
         QCOMPARE(page.model(), &stubPageModel);
         QVERIFY(page.isEnabled());
         QCOMPARE(proxyModel->sourceModel(), &model);
     }
 
     void shouldNotCrashWithNullModel()
     {
         // GIVEN
         QStandardItemModel model;
         QObject stubPageModel;
         stubPageModel.setProperty("centralListModel", QVariant::fromValue(static_cast<QAbstractItemModel*>(&model)));
 
         Widgets::PageView page;
         page.setModel(&stubPageModel);
 
         auto centralView = page.findChild<QTreeView*>(QStringLiteral("centralView"));
         QVERIFY(centralView);
         auto proxyModel = qobject_cast<Presentation::ArtifactFilterProxyModel*>(centralView->model());
         QVERIFY(proxyModel);
         QCOMPARE(proxyModel->sourceModel(), &model);
 
         // WHEN
         page.setModel(Q_NULLPTR);
 
         // THEN
         QVERIFY(!page.model());
         QVERIFY(!page.isEnabled());
         QVERIFY(!proxyModel->sourceModel());
     }
 
     void shouldManageFocusThroughActions()
     {
         // GIVEN
         Widgets::PageView page;
         auto centralView = page.findChild<QTreeView*>(QStringLiteral("centralView"));
         auto quickAddEdit = page.findChild<QLineEdit*>(QStringLiteral("quickAddEdit"));
         auto filter = page.findChild<Widgets::FilterWidget*>(QStringLiteral("filterWidget"));
         auto filterEdit = filter->findChild<QLineEdit*>();
         QVERIFY(filterEdit);
         page.show();
-        QTest::qWaitForWindowShown(&page);
+        QVERIFY(QTest::qWaitForWindowShown(&page));
 
         centralView->setFocus();
         QVERIFY(centralView->hasFocus());
         QVERIFY(!quickAddEdit->hasFocus());
         QVERIFY(!filter->isVisibleTo(&page));
         QVERIFY(!filterEdit->hasFocus());
 
         auto addAction = page.findChild<QAction*>(QStringLiteral("addItemAction"));
         auto cancelAddAction = page.findChild<QAction*>(QStringLiteral("cancelAddItemAction"));
         auto filterAction = page.findChild<QAction*>(QStringLiteral("filterViewAction"));
 
         // WHEN
         addAction->trigger();
 
         // THEN
         QVERIFY(!centralView->hasFocus());
         QVERIFY(quickAddEdit->hasFocus());
         QVERIFY(!filter->isVisibleTo(&page));
         QVERIFY(!filterEdit->hasFocus());
 
         // WHEN
         cancelAddAction->trigger();
 
         // THEN
         QVERIFY(centralView->hasFocus());
         QVERIFY(!quickAddEdit->hasFocus());
         QVERIFY(!filter->isVisibleTo(&page));
         QVERIFY(!filterEdit->hasFocus());
 
         // WHEN
         filterAction->trigger();
 
         // THEN
         QVERIFY(!centralView->hasFocus());
         QVERIFY(!quickAddEdit->hasFocus());
         QVERIFY(filter->isVisibleTo(&page));
         QVERIFY(filterEdit->hasFocus());
 
         // WHEN
         cancelAddAction->trigger();
 
         // THEN
         QVERIFY(centralView->hasFocus());
         QVERIFY(!quickAddEdit->hasFocus());
         QVERIFY(filter->isVisibleTo(&page));
         QVERIFY(!filterEdit->hasFocus());
     }
 
     void shouldManageFilterVisibilityThroughAction()
     {
         // GIVEN
         Widgets::PageView page;
         auto centralView = page.findChild<QTreeView*>(QStringLiteral("centralView"));
         auto filter = page.findChild<Widgets::FilterWidget*>(QStringLiteral("filterWidget"));
         auto filterEdit = filter->findChild<QLineEdit*>();
         QVERIFY(filterEdit);
         page.show();
-        QTest::qWaitForWindowShown(&page);
+        QVERIFY(QTest::qWaitForWindowShown(&page));
 
         centralView->setFocus();
         QVERIFY(centralView->hasFocus());
         QVERIFY(!filter->isVisibleTo(&page));
         QVERIFY(!filterEdit->hasFocus());
 
         auto filterAction = page.findChild<QAction*>(QStringLiteral("filterViewAction"));
 
         // WHEN
         filterAction->trigger();
 
         // THEN
         QVERIFY(!centralView->hasFocus());
         QVERIFY(filter->isVisibleTo(&page));
         QVERIFY(filterEdit->hasFocus());
 
         // WHEN
         filterEdit->setText("Foo");
 
         // THEN
         QCOMPARE(filterEdit->text(), QString("Foo"));
 
         // WHEN
         filterAction->trigger();
 
         // THEN
         QVERIFY(centralView->hasFocus());
         QVERIFY(!filter->isVisibleTo(&page));
         QVERIFY(!filterEdit->hasFocus());
         QVERIFY(filterEdit->text().isEmpty());
     }
 
     void shouldCreateTasksWithNoParentWhenHittingReturnWithoutSelectedIndex()
     {
         // GIVEN
         PageModelStub stubPageModel;
         Widgets::PageView page;
         page.setModel(&stubPageModel);
         auto quickAddEdit = page.findChild<QLineEdit*>(QStringLiteral("quickAddEdit"));
 
         // WHEN
         QTest::keyClick(quickAddEdit, Qt::Key_Return); // Does nothing (edit empty)
         QTest::keyClicks(quickAddEdit, QStringLiteral("Foo"));
         QTest::keyClick(quickAddEdit, Qt::Key_Return);
         QTest::keyClick(quickAddEdit, Qt::Key_Return); // Does nothing (edit empty)
         QTest::keyClicks(quickAddEdit, QStringLiteral("Bar"));
         QTest::keyClick(quickAddEdit, Qt::Key_Return);
         QTest::keyClick(quickAddEdit, Qt::Key_Return); // Does nothing (edit empty)
 
         // THEN
         QCOMPARE(stubPageModel.taskNames, QStringList() << QStringLiteral("Foo") << QStringLiteral("Bar"));
         QCOMPARE(stubPageModel.parentIndices.size(), 2);
         QCOMPARE(stubPageModel.parentIndices.first(), QPersistentModelIndex());
         QCOMPARE(stubPageModel.parentIndices.last(), QPersistentModelIndex());
     }
 
     void shouldCreateTasksWithNoParentWhenHittingReturnWithSeveralSelectedIndices()
     {
         // GIVEN
         PageModelStub stubPageModel;
         Q_ASSERT(stubPageModel.property("centralListModel").canConvert<QAbstractItemModel*>());
         stubPageModel.addStubItems(QStringList() << QStringLiteral("A") << QStringLiteral("B") << QStringLiteral("C"));
         QPersistentModelIndex index0 = stubPageModel.itemModel.index(0, 0);
         QPersistentModelIndex index1 = stubPageModel.itemModel.index(1, 0);
 
         Widgets::PageView page;
         page.setModel(&stubPageModel);
 
         auto centralView = page.findChild<QTreeView*>(QStringLiteral("centralView"));
         centralView->selectionModel()->select(index0, QItemSelectionModel::ClearAndSelect);
         centralView->selectionModel()->select(index1, QItemSelectionModel::Select);
 
         auto quickAddEdit = page.findChild<QLineEdit*>(QStringLiteral("quickAddEdit"));
 
         // WHEN
         QTest::keyClicks(quickAddEdit, QStringLiteral("Foo"));
         QTest::keyClick(quickAddEdit, Qt::Key_Return);
 
         // THEN
         QCOMPARE(stubPageModel.taskNames, QStringList() << QStringLiteral("A")
                                                         << QStringLiteral("B")
                                                         << QStringLiteral("C")
                                                         << QStringLiteral("Foo"));
         QCOMPARE(stubPageModel.parentIndices.size(), 1);
         QCOMPARE(stubPageModel.parentIndices.first(), QPersistentModelIndex());
     }
 
     void shouldCreateTasksWithParentWhenHittingReturnWithOneSelectedIndex()
     {
         // GIVEN
         PageModelStub stubPageModel;
         Q_ASSERT(stubPageModel.property("centralListModel").canConvert<QAbstractItemModel*>());
         stubPageModel.addStubItems(QStringList() << QStringLiteral("A") << QStringLiteral("B") << QStringLiteral("C"));
         QPersistentModelIndex index = stubPageModel.itemModel.index(1, 0);
 
         Widgets::PageView page;
         page.setModel(&stubPageModel);
 
         auto centralView = page.findChild<QTreeView*>(QStringLiteral("centralView"));
         centralView->selectionModel()->select(index, QItemSelectionModel::ClearAndSelect);
 
         auto quickAddEdit = page.findChild<QLineEdit*>(QStringLiteral("quickAddEdit"));
 
         // WHEN
         QTest::keyClicks(quickAddEdit, QStringLiteral("Foo"));
         QTest::keyClick(quickAddEdit, Qt::Key_Return);
 
         // THEN
         QCOMPARE(stubPageModel.taskNames, QStringList() << QStringLiteral("A")
                                                         << QStringLiteral("B")
                                                         << QStringLiteral("C")
                                                         << QStringLiteral("Foo"));
         QCOMPARE(stubPageModel.parentIndices.size(), 1);
         QCOMPARE(stubPageModel.parentIndices.first(), index);
     }
 
     void shouldDeleteItemWhenHittingTheDeleteKey()
     {
         // GIVEN
         PageModelStub stubPageModel;
         Q_ASSERT(stubPageModel.property("centralListModel").canConvert<QAbstractItemModel*>());
         stubPageModel.addStubItems(QStringList() << QStringLiteral("A") << QStringLiteral("B") << QStringLiteral("C"));
         QPersistentModelIndex index = stubPageModel.itemModel.index(1, 0);
 
         Widgets::PageView page;
         page.setModel(&stubPageModel);
 
         QTreeView *centralView = page.findChild<QTreeView*>(QStringLiteral("centralView"));
         centralView->selectionModel()->setCurrentIndex(index, QItemSelectionModel::ClearAndSelect);
         centralView->setFocus();
 
         // Needed for shortcuts to work
         page.show();
-        QTest::qWaitForWindowShown(&page);
+        QVERIFY(QTest::qWaitForWindowShown(&page));
         QTest::qWait(100);
 
         // WHEN
         QTest::keyPress(centralView, Qt::Key_Delete);
 
         // THEN
         QCOMPARE(stubPageModel.removedIndices.size(), 1);
         QCOMPARE(stubPageModel.removedIndices.first(), index);
     }
 
     void shouldNoteTryToDeleteIfThereIsNoSelection()
     {
         // GIVEN
         PageModelStub stubPageModel;
         Q_ASSERT(stubPageModel.property("centralListModel").canConvert<QAbstractItemModel*>());
         stubPageModel.addStubItems(QStringList() << QStringLiteral("A") << QStringLiteral("B") << QStringLiteral("C"));
 
         Widgets::PageView page;
         page.setModel(&stubPageModel);
 
         QTreeView *centralView = page.findChild<QTreeView*>(QStringLiteral("centralView"));
         centralView->clearSelection();
         page.findChild<QLineEdit*>(QStringLiteral("quickAddEdit"))->setFocus();
 
         // Needed for shortcuts to work
         page.show();
-        QTest::qWaitForWindowShown(&page);
+        QVERIFY(QTest::qWaitForWindowShown(&page));
         QTest::qWait(100);
 
         // WHEN
         QTest::keyPress(centralView, Qt::Key_Delete);
 
         // THEN
         QVERIFY(stubPageModel.removedIndices.isEmpty());
     }
 
     void shouldDisplayNotificationWhenHittingTheDeleteKeyOnAnItemWithChildren()
     {
         // GIVEN
         PageModelStub stubPageModel;
         Q_ASSERT(stubPageModel.property("centralListModel").canConvert<QAbstractItemModel*>());
         stubPageModel.addStubItems(QStringList() << QStringLiteral("A") << QStringLiteral("B"));
         QStandardItem *parentIndex = stubPageModel.itemModel.item(1, 0);
         stubPageModel.addStubItem(QStringLiteral("C"), parentIndex);
         QPersistentModelIndex index = stubPageModel.itemModel.index(1, 0);
 
         Widgets::PageView page;
         page.setModel(&stubPageModel);
         auto msgbox = MessageBoxStub::Ptr::create();
         page.setMessageBoxInterface(msgbox);
 
         QTreeView *centralView = page.findChild<QTreeView*>(QStringLiteral("centralView"));
         centralView->selectionModel()->setCurrentIndex(index, QItemSelectionModel::ClearAndSelect);
         QVERIFY(centralView->selectionModel()->currentIndex().isValid());
         centralView->setFocus();
 
         // Needed for shortcuts to work
         page.show();
-        QTest::qWaitForWindowShown(&page);
+        QVERIFY(QTest::qWaitForWindowShown(&page));
         QTest::qWait(100);
 
         // WHEN
         QTest::keyPress(centralView, Qt::Key_Delete);
 
         // THEN
         QVERIFY(msgbox->called());
         QCOMPARE(stubPageModel.removedIndices.size(), 1);
         QCOMPARE(stubPageModel.removedIndices.first(), index);
     }
 
     void shouldDeleteItemsWhenHittingTheDeleteKey()
     {
         // GIVEN
         PageModelStub stubPageModel;
         Q_ASSERT(stubPageModel.property("centralListModel").canConvert<QAbstractItemModel*>());
         stubPageModel.addStubItems(QStringList() << QStringLiteral("A") << QStringLiteral("B") << QStringLiteral("C"));
         QPersistentModelIndex index = stubPageModel.itemModel.index(1, 0);
         QPersistentModelIndex index2 = stubPageModel.itemModel.index(2, 0);
 
         Widgets::PageView page;
         page.setModel(&stubPageModel);
         auto msgbox = MessageBoxStub::Ptr::create();
         page.setMessageBoxInterface(msgbox);
 
         QTreeView *centralView = page.findChild<QTreeView*>(QStringLiteral("centralView"));
         centralView->selectionModel()->setCurrentIndex(index, QItemSelectionModel::ClearAndSelect);
         centralView->selectionModel()->setCurrentIndex(index2, QItemSelectionModel::Select);
         centralView->setFocus();
 
         // Needed for shortcuts to work
         page.show();
-        QTest::qWaitForWindowShown(&page);
+        QVERIFY(QTest::qWaitForWindowShown(&page));
         QTest::qWait(100);
 
         // WHEN
         QTest::keyPress(centralView, Qt::Key_Delete);
 
         // THEN
         QVERIFY(msgbox->called());
         QCOMPARE(stubPageModel.removedIndices.size(), 2);
         QCOMPARE(stubPageModel.removedIndices.first(), index);
         QCOMPARE(stubPageModel.removedIndices.at(1), index2);
     }
 
     void shouldPromoteItem()
     {
         // GIVEN
         PageModelStub stubPageModel;
         Q_ASSERT(stubPageModel.property("centralListModel").canConvert<QAbstractItemModel*>());
         stubPageModel.addStubItems(QStringList() << QStringLiteral("A") << QStringLiteral("B") << QStringLiteral("C"));
         QPersistentModelIndex index = stubPageModel.itemModel.index(1, 0);
 
         Widgets::PageView page;
         page.setModel(&stubPageModel);
 
         auto promoteAction = page.findChild<QAction*>(QStringLiteral("promoteItemAction"));
         QVERIFY(promoteAction);
 
         QTreeView *centralView = page.findChild<QTreeView*>(QStringLiteral("centralView"));
         centralView->selectionModel()->setCurrentIndex(index, QItemSelectionModel::ClearAndSelect);
         centralView->setFocus();
 
         // WHEN
         promoteAction->trigger();
 
         // THEN
         QCOMPARE(stubPageModel.promotedIndices.size(), 1);
         QCOMPARE(stubPageModel.promotedIndices.first(), index);
     }
 
     void shouldNotTryToPromoteItemIfThereIsNoSelection()
     {
         // GIVEN
         PageModelStub stubPageModel;
         Q_ASSERT(stubPageModel.property("centralListModel").canConvert<QAbstractItemModel*>());
         stubPageModel.addStubItems(QStringList() << QStringLiteral("A") << QStringLiteral("B") << QStringLiteral("C"));
 
         Widgets::PageView page;
         page.setModel(&stubPageModel);
 
         auto promoteAction = page.findChild<QAction*>(QStringLiteral("promoteItemAction"));
         QVERIFY(promoteAction);
 
         QTreeView *centralView = page.findChild<QTreeView*>(QStringLiteral("centralView"));
         centralView->selectionModel()->clear();
         centralView->setFocus();
 
         // WHEN
         promoteAction->trigger();
 
         // THEN
         QVERIFY(stubPageModel.promotedIndices.isEmpty());
     }
 
     void shouldClearCentralViewSelectionOnEscape()
     {
         // GIVEN
         PageModelStub stubPageModel;
         Q_ASSERT(stubPageModel.property("centralListModel").canConvert<QAbstractItemModel*>());
         stubPageModel.addStubItems(QStringList() << QStringLiteral("A") << QStringLiteral("B") << QStringLiteral("C"));
         QPersistentModelIndex index = stubPageModel.itemModel.index(1, 0);
 
         Widgets::PageView page;
         page.setModel(&stubPageModel);
 
         auto centralView = page.findChild<QTreeView*>(QStringLiteral("centralView"));
         centralView->selectionModel()->select(index, QItemSelectionModel::ClearAndSelect);
         QVERIFY(!centralView->selectionModel()->selectedIndexes().isEmpty());
 
         // WHEN
         QTest::keyClick(centralView, Qt::Key_Escape);
 
         // THEN
         QVERIFY(centralView->selectionModel()->selectedIndexes().isEmpty());
     }
 
     void shouldReturnSelectedIndexes()
     {
         // GIVEN
         PageModelStub stubPageModel;
         Q_ASSERT(stubPageModel.property("centralListModel").canConvert<QAbstractItemModel*>());
         stubPageModel.addStubItems(QStringList() << QStringLiteral("A") << QStringLiteral("B") << QStringLiteral("C"));
         auto index = stubPageModel.itemModel.index(1, 0);
         auto index2 = stubPageModel.itemModel.index(2, 0);
 
         Widgets::PageView page;
         page.setModel(&stubPageModel);
 
         auto centralView = page.findChild<QTreeView*>(QStringLiteral("centralView"));
         auto filterWidget = page.findChild<Widgets::FilterWidget*>(QStringLiteral("filterWidget"));
 
         auto displayedModel = filterWidget->proxyModel();
         auto displayedIndex = displayedModel->index(1, 0);
         auto displayedIndex2 = displayedModel->index(2, 0);
 
         // WHEN
         centralView->selectionModel()->setCurrentIndex(displayedIndex, QItemSelectionModel::ClearAndSelect);
         centralView->selectionModel()->setCurrentIndex(displayedIndex2, QItemSelectionModel::Select);
 
         // THEN
         auto selectedIndexes = page.selectedIndexes();
         QCOMPARE(selectedIndexes.size(), 2);
 
         QCOMPARE(selectedIndexes.at(0), index);
         QCOMPARE(selectedIndexes.at(1), index2);
 
         QCOMPARE(selectedIndexes.at(0).model(), index.model());
         QCOMPARE(selectedIndexes.at(1).model(), index2.model());
     }
 
     void shouldDisplayMessageOnError()
     {
         // GIVEN
         Widgets::PageView page;
         page.show();
-        QTest::qWaitForWindowShown(&page);
+        QVERIFY(QTest::qWaitForWindowShown(&page));
         QTest::qWait(100);
 
         auto messageWidget = page.findChild<KMessageWidget*>(QStringLiteral("messageWidget"));
         QVERIFY(messageWidget);
         QVERIFY(!messageWidget->isVisibleTo(&page));
 
         QCOMPARE(messageWidget->findChildren<QToolButton*>().size(), 1);
         auto closeButton = messageWidget->findChildren<QToolButton*>().first();
         QVERIFY(closeButton);
 
         // WHEN
         page.displayErrorMessage(QStringLiteral("Foo Error"));
 
         // THEN
         QVERIFY(messageWidget->isVisibleTo(&page));
         QVERIFY(messageWidget->isCloseButtonVisible());
         QCOMPARE(messageWidget->text(), QStringLiteral("Foo Error"));
         QVERIFY(messageWidget->icon().isNull());
         QCOMPARE(messageWidget->messageType(), KMessageWidget::Error);
         QVERIFY(messageWidget->isShowAnimationRunning());
         QVERIFY(!messageWidget->isHideAnimationRunning());
 
         // WHEN
         QTest::qWait(800);
 
         // THEN
         QVERIFY(!messageWidget->isShowAnimationRunning());
         QVERIFY(!messageWidget->isHideAnimationRunning());
 
         // WHEN
         closeButton->click();
 
         // THEN
         QVERIFY(!messageWidget->isShowAnimationRunning());
         QVERIFY(messageWidget->isHideAnimationRunning());
 
         // WHEN
         QTest::qWait(800);
 
         // THEN
         QVERIFY(!messageWidget->isShowAnimationRunning());
         QVERIFY(!messageWidget->isHideAnimationRunning());
     }
 
     void shouldRunTask()
     {
         // GIVEN
         PageModelStub stubPageModel;
         Q_ASSERT(stubPageModel.property("centralListModel").canConvert<QAbstractItemModel*>());
         auto task1 = stubPageModel.addTaskItem(QStringLiteral("Task1"));
         auto task2 = stubPageModel.addTaskItem(QStringLiteral("Task2"));
         Widgets::PageView page;
         page.setModel(&stubPageModel);
         RunningTaskModelStub stubRunningTaskModel;
         page.setRunningTaskModel(&stubRunningTaskModel);
         auto centralView = page.findChild<QTreeView*>(QStringLiteral("centralView"));
 
         QModelIndex index = stubPageModel.itemModel.index(0, 0);
         centralView->selectionModel()->setCurrentIndex(index, QItemSelectionModel::ClearAndSelect);
         QVERIFY(centralView->selectionModel()->currentIndex().isValid());
 
         auto runTaskAction = page.findChild<QAction*>(QStringLiteral("runTaskAction"));
         QVERIFY(runTaskAction);
         QVERIFY(runTaskAction->isEnabled());
 
         // WHEN starting the first task
         runTaskAction->trigger();
 
         // THEN
         QCOMPARE(stubRunningTaskModel.property("runningTask").value<Domain::Task::Ptr>(), task1);
         QCOMPARE(task1->startDate().date(), QDate::currentDate());
 
         // WHEN starting the second task
         QModelIndex index2 = stubPageModel.itemModel.index(1, 0);
         centralView->selectionModel()->setCurrentIndex(index2, QItemSelectionModel::ClearAndSelect);
         runTaskAction->trigger();
 
         // THEN
         QCOMPARE(stubRunningTaskModel.property("runningTask").value<Domain::Task::Ptr>(), task2);
         QCOMPARE(task2->startDate().date(), QDate::currentDate());
     }
 };
 
 ZANSHIN_TEST_MAIN(PageViewTest)
 
 #include "pageviewtest.moc"