From a9987b1bc7f789f3063c06ed23e1f51024341463 Mon Sep 17 00:00:00 2001
From: Carl Schwan <carl@carlschwan.eu>
Date: Thu, 21 Jan 2021 19:16:31 +0100
Subject: Move tests

---
 quotest/.valgrind.supp |  68 ++++
 quotest/CMakeLists.txt |   9 +
 quotest/quotest.cpp    | 864 +++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 941 insertions(+)
 create mode 100644 quotest/.valgrind.supp
 create mode 100644 quotest/CMakeLists.txt
 create mode 100644 quotest/quotest.cpp

(limited to 'quotest')

diff --git a/quotest/.valgrind.supp b/quotest/.valgrind.supp
new file mode 100644
index 00000000..d65fb52e
--- /dev/null
+++ b/quotest/.valgrind.supp
@@ -0,0 +1,68 @@
+{
+   libc_dirty_free_on_exit
+   Memcheck:Free
+   fun:free
+   fun:__libc_freeres
+   fun:_vgnU_freeres
+   fun:__run_exit_handlers
+   fun:exit
+}
+
+{
+   QAuthenticator
+   Memcheck:Leak
+   match-leak-kinds: possible
+   ...
+   fun:_ZN14QAuthenticator6detachEv
+}
+
+{
+   QTimer
+   Memcheck:Leak
+   match-leak-kinds: possible
+   fun:_Znwm
+   fun:_ZN7QObjectC1EPS_
+   fun:_ZN6QTimerC1EP7QObject
+}
+
+{
+   QSslConfiguration
+   Memcheck:Leak
+   match-leak-kinds: possible
+   fun:_Znwm
+   ...
+   fun:_ZN17QSslConfigurationC1Ev
+}
+
+{
+   libcrypto_ASN1
+   Memcheck:Leak
+   match-leak-kinds: definite
+   fun:malloc
+   ...
+   fun:ASN1_item_ex_d2i
+}
+
+{
+   malloc_from_libcrypto
+   Memcheck:Leak
+   match-leak-kinds: possible
+   fun:malloc
+   fun:CRYPTO_malloc
+   ...
+   obj:/lib/x86_64-linux-gnu/libcrypto.so.*
+}
+
+{
+   Slot_activation_from_QtNetwork
+   Memcheck:Leak
+   match-leak-kinds: definite
+   fun:malloc
+   fun:inflateInit2_
+   obj:/*/*/*/libQt5Network.so.*
+   ...
+   fun:_ZN11QMetaObject8activateEP7QObjectiiPPv
+   ...
+   fun:_ZN11QMetaObject8activateEP7QObjectiiPPv
+   obj:/*/*/*/libQt5Network.so.*
+}
\ No newline at end of file
diff --git a/quotest/CMakeLists.txt b/quotest/CMakeLists.txt
new file mode 100644
index 00000000..4553abb6
--- /dev/null
+++ b/quotest/CMakeLists.txt
@@ -0,0 +1,9 @@
+# SPDX-FileCopyrightText: 2021 Carl Schwan <carlschwan@kde.org>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+set(quotest_SRCS quotest.cpp)
+
+add_executable(quotest ${quotest_SRCS})
+add_test(NAME quotest COMMAND quotest)
+target_link_libraries(quotest PRIVATE Qt5::Core Qt5::Test ${PROJECT_NAME})
diff --git a/quotest/quotest.cpp b/quotest/quotest.cpp
new file mode 100644
index 00000000..5098bc02
--- /dev/null
+++ b/quotest/quotest.cpp
@@ -0,0 +1,864 @@
+// SPDX-FileCopyrightText: 2016 Kitsune Ral <Kitsune-Ral@users.sf.net>
+// SPDX-License-Identifier: LGPL-2.1-or-later
+
+#include "connection.h"
+#include "room.h"
+#include "user.h"
+#include "uriresolver.h"
+
+#include "csapi/joining.h"
+#include "csapi/leaving.h"
+#include "csapi/room_send.h"
+
+#include "events/reactionevent.h"
+#include "events/redactionevent.h"
+#include "events/simplestateevents.h"
+
+#include <QtTest/QSignalSpy>
+#include <QtCore/QCoreApplication>
+#include <QtCore/QFileInfo>
+#include <QtCore/QStringBuilder>
+#include <QtCore/QTemporaryFile>
+#include <QtCore/QTimer>
+
+#include <functional>
+#include <iostream>
+
+using namespace Quotient;
+using std::clog, std::endl;
+
+class TestSuite;
+
+class TestManager : public QCoreApplication {
+public:
+    TestManager(int& argc, char** argv);
+
+private:
+    void setupAndRun();
+    void onNewRoom(Room* r);
+    void doTests();
+    void conclude();
+    void finalize();
+
+private:
+    Connection* c = nullptr;
+    QString origin;
+    QString targetRoomName;
+    TestSuite* testSuite = nullptr;
+    QByteArrayList running {}, succeeded {}, failed {};
+};
+
+using TestToken = QByteArray; // return value of QMetaMethod::name
+Q_DECLARE_METATYPE(TestToken)
+
+// For now, the token itself is the test name but that may change.
+const char* testName(const TestToken& token) { return token.constData(); }
+
+/// Test function declaration
+/*!
+ * \return true, if the test finished (successfully or unsuccessfully);
+ *         false, if the test went async and will complete later
+ */
+#define TEST_DECL(Name) bool Name(const TestToken& thisTest);
+
+/// The holder for the actual tests
+/*!
+ * This class takes inspiration from Qt Test in terms of tests invocation;
+ * TestManager instantiates it and runs all public slots (cf. private slots in
+ * Qt Test) one after another. An important diversion from Qt Test is that
+ * the tests are assumed to by asynchronous rather than synchronous; so it's
+ * perfectly normal to have a few tests running at the same time. To avoid
+ * context clashes a special parameter with the name thisTest is passed to
+ * each test. Each test must conclude (synchronously or asynchronously) with
+ * an invocation of FINISH_TEST() macro (or FAIL_TEST() macro that expands to
+ * FINISH_TEST) that expects thisTest variable to be reachable. If FINISH_TEST()
+ * is invoked twice with the same thisTest, the second call will cause assertion
+ * failure; if FINISH_TEST() is not invoked at all, the test will be killed
+ * by a watchdog after a timeout and marked in the final report as not finished.
+ */
+class TestSuite : public QObject {
+    Q_OBJECT
+public:
+    TestSuite(Room* testRoom, QString source, TestManager* parent)
+        : QObject(parent), targetRoom(testRoom), origin(std::move(source))
+    {
+        qRegisterMetaType<TestToken>();
+        Q_ASSERT(testRoom && parent);
+    }
+
+signals:
+    void finishedItem(QByteArray /*name*/, bool /*condition*/);
+
+public slots:
+    void doTest(const QByteArray& testName);
+
+private slots:
+    TEST_DECL(findRoomByAlias)
+    TEST_DECL(loadMembers)
+    TEST_DECL(sendMessage)
+    TEST_DECL(sendReaction)
+    TEST_DECL(sendFile)
+    TEST_DECL(setTopic)
+    TEST_DECL(changeName)
+    TEST_DECL(sendAndRedact)
+    TEST_DECL(addAndRemoveTag)
+    TEST_DECL(markDirectChat)
+    TEST_DECL(visitResources)
+    // Add more tests above here
+
+public:
+    [[nodiscard]] Room* room() const { return targetRoom; }
+    [[nodiscard]] Connection* connection() const
+    {
+        return targetRoom->connection();
+    }
+
+private:
+    [[nodiscard]] bool checkFileSendingOutcome(const TestToken& thisTest,
+                                               const QString& txnId,
+                                               const QString& fileName);
+    [[nodiscard]] bool checkRedactionOutcome(const QByteArray& thisTest,
+                                             const QString& evtIdToRedact);
+
+    [[nodiscard]] bool validatePendingEvent(const QString& txnId);
+    [[nodiscard]] bool checkDirectChat() const;
+    void finishTest(const TestToken& token, bool condition, const char* file,
+                    int line);
+
+private:
+    Room* targetRoom;
+    QString origin;
+};
+
+#define TEST_IMPL(Name) bool TestSuite::Name(const TestToken& thisTest)
+
+// Returning true (rather than a void) allows to reuse the convention with
+// connectUntil() to break the QMetaObject::Connection upon finishing the test
+// item.
+#define FINISH_TEST(Condition) \
+    return (finishTest(thisTest, Condition, __FILE__, __LINE__), true)
+
+#define FAIL_TEST() FINISH_TEST(false)
+
+void TestSuite::doTest(const QByteArray& testName)
+{
+    clog << "Starting: " << testName.constData() << endl;
+    QMetaObject::invokeMethod(this, testName, Qt::DirectConnection,
+                              Q_ARG(TestToken, testName));
+}
+
+bool TestSuite::validatePendingEvent(const QString& txnId)
+{
+    auto it = targetRoom->findPendingEvent(txnId);
+    return it != targetRoom->pendingEvents().end()
+           && it->deliveryStatus() == EventStatus::Submitted
+           && (*it)->transactionId() == txnId;
+}
+
+void TestSuite::finishTest(const TestToken& token, bool condition,
+                           const char* file, int line)
+{
+    const auto& item = testName(token);
+    if (condition) {
+        clog << item << " successful" << endl;
+        if (targetRoom)
+            targetRoom->postMessage(origin % ": " % item % " successful",
+                                    MessageEventType::Notice);
+    } else {
+        clog << item << " FAILED at " << file << ":" << line << endl;
+        if (targetRoom)
+            targetRoom->postPlainText(origin % ": " % item % " FAILED at "
+                                      % file % ", line " % QString::number(line));
+    }
+
+    emit finishedItem(item, condition);
+}
+
+TestManager::TestManager(int& argc, char** argv)
+    : QCoreApplication(argc, argv), c(new Connection(this))
+{
+    Q_ASSERT(argc >= 5);
+    clog << "Connecting to Matrix as " << argv[1] << endl;
+    c->loginWithPassword(argv[1], argv[2], argv[3]);
+    targetRoomName = argv[4];
+    clog << "Test room name: " << argv[4] << endl;
+    if (argc > 5) {
+        origin = argv[5];
+        clog << "Origin for the test message: " << origin.toStdString() << endl;
+    }
+
+    connect(c, &Connection::connected, this, &TestManager::setupAndRun);
+    connect(c, &Connection::resolveError, this,
+        [](const QString& error) {
+            clog << "Failed to resolve the server: " << error.toStdString()
+                 << endl;
+            QCoreApplication::exit(-2);
+        },
+        Qt::QueuedConnection);
+    connect(c, &Connection::loginError, this,
+        [this](const QString& message, const QString& details) {
+            clog << "Failed to login to "
+                 << c->homeserver().toDisplayString().toStdString() << ": "
+                 << message.toStdString() << endl
+                 << "Details:" << endl
+                 << details.toStdString() << endl;
+            QCoreApplication::exit(-2);
+        },
+        Qt::QueuedConnection);
+    connect(c, &Connection::loadedRoomState, this, &TestManager::onNewRoom);
+
+    // Big countdown watchdog
+    QTimer::singleShot(180000, this, [this] {
+        if (testSuite)
+            conclude();
+        else
+            finalize();
+    });
+}
+
+void TestManager::setupAndRun()
+{
+    Q_ASSERT(!c->homeserver().isEmpty() && c->homeserver().isValid());
+    Q_ASSERT(c->domain() == c->userId().section(':', 1));
+    clog << "Connected, server: "
+         << c->homeserver().toDisplayString().toStdString() << endl;
+    clog << "Access token: " << c->accessToken().toStdString() << endl;
+
+    c->setLazyLoading(true);
+
+    clog << "Joining " << targetRoomName.toStdString() << endl;
+    auto joinJob = c->joinRoom(targetRoomName);
+    // Ensure that the room has been joined and filled with some events
+    // so that other tests could use that
+    connect(joinJob, &BaseJob::success, this, [this, joinJob] {
+        testSuite = new TestSuite(c->room(joinJob->roomId()), origin, this);
+        // Only start the sync after joining, to make sure the room just
+        // joined is in it
+        c->syncLoop();
+        connect(c, &Connection::syncDone, this, [this] {
+            static int i = 0;
+            clog << "Sync " << ++i << " complete" << endl;
+            if (auto* r = testSuite->room()) {
+                clog << "Test room timeline size = " << r->timelineSize();
+                if (r->pendingEvents().empty())
+                    clog << ", pending size = " << r->pendingEvents().size();
+                clog << endl;
+            }
+            if (!running.empty()) {
+                clog << running.size() << " test(s) in the air:";
+                for (const auto& test: qAsConst(running))
+                    clog << " " << testName(test);
+                clog << endl;
+            }
+            if (i == 1) {
+                testSuite->room()->getPreviousContent();
+                connectSingleShot(testSuite->room(), &Room::addedMessages, this,
+                                  &TestManager::doTests);
+            }
+        });
+    });
+    connect(joinJob, &BaseJob::failure, this, [this] {
+        clog << "Failed to join the test room" << endl;
+        finalize();
+    });
+}
+
+void TestManager::onNewRoom(Room* r)
+{
+    clog << "New room: " << r->id().toStdString() << endl
+         << "  Name: " << r->name().toStdString() << endl
+         << "  Canonical alias: " << r->canonicalAlias().toStdString() << endl
+         << endl;
+    connect(r, &Room::aboutToAddNewMessages, r, [r](RoomEventsRange timeline) {
+        clog << timeline.size() << " new event(s) in room "
+             << r->objectName().toStdString() << endl;
+    });
+}
+
+void TestManager::doTests()
+{
+    const auto* metaObj = testSuite->metaObject();
+    for (auto i = metaObj->methodOffset(); i < metaObj->methodCount(); ++i) {
+        const auto metaMethod = metaObj->method(i);
+        if (metaMethod.access() != QMetaMethod::Private
+            || metaMethod.methodType() != QMetaMethod::Slot)
+            continue;
+
+        const auto testName = metaMethod.name();
+        running.push_back(testName);
+        // Some tests return the result immediately but we queue everything
+        // and process all tests asynchronously.
+        QMetaObject::invokeMethod(testSuite, "doTest", Qt::QueuedConnection,
+                                  Q_ARG(QByteArray, testName));
+    }
+    clog << "Tests to do:";
+    for (const auto& test: qAsConst(running))
+        clog << " " << testName(test);
+    clog << endl;
+    connect(testSuite, &TestSuite::finishedItem, this,
+            [this](const QByteArray& itemName, bool condition) {
+                if (auto i = running.indexOf(itemName); i != -1)
+                    (condition ? succeeded : failed).push_back(running.takeAt(i));
+                else
+                    Q_ASSERT_X(false, itemName,
+                               "Test item is not in running state");
+                if (running.empty()) {
+                    clog << "All tests finished" << endl;
+                    conclude();
+                }
+            });
+}
+
+TEST_IMPL(findRoomByAlias)
+{
+    auto* roomByAlias = connection()->roomByAlias(targetRoom->canonicalAlias(),
+                                        JoinState::Join);
+    FINISH_TEST(roomByAlias == targetRoom);
+}
+
+TEST_IMPL(loadMembers)
+{
+    // It's not exactly correct because an arbitrary server might not support
+    // lazy loading; but in the absence of capabilities framework we assume
+    // it does.
+    if (targetRoom->users().size() >= targetRoom->joinedCount()) {
+        clog << "Lazy loading doesn't seem to be enabled" << endl;
+        FAIL_TEST();
+    }
+    targetRoom->setDisplayed();
+    connect(targetRoom, &Room::allMembersLoaded, this, [this, thisTest] {
+        FINISH_TEST(targetRoom->users().size() >= targetRoom->joinedCount());
+    });
+    return false;
+}
+
+TEST_IMPL(sendMessage)
+{
+    auto txnId = targetRoom->postPlainText("Hello, " % origin % " is here");
+    if (!validatePendingEvent(txnId)) {
+        clog << "Invalid pending event right after submitting" << endl;
+        FAIL_TEST();
+    }
+    connectUntil(targetRoom, &Room::pendingEventAboutToMerge, this,
+        [this, thisTest, txnId](const RoomEvent* evt, int pendingIdx) {
+            const auto& pendingEvents = targetRoom->pendingEvents();
+            Q_ASSERT(pendingIdx >= 0 && pendingIdx < int(pendingEvents.size()));
+
+            if (evt->transactionId() != txnId)
+                return false;
+
+            FINISH_TEST(is<RoomMessageEvent>(*evt) && !evt->id().isEmpty()
+                        && pendingEvents[size_t(pendingIdx)]->transactionId()
+                               == evt->transactionId());
+        });
+    return false;
+}
+
+TEST_IMPL(sendReaction)
+{
+    clog << "Reacting to the newest message in the room" << endl;
+    Q_ASSERT(targetRoom->timelineSize() > 0);
+    const auto targetEvtId = targetRoom->messageEvents().back()->id();
+    const auto key = QStringLiteral("+1");
+    const auto txnId = targetRoom->postReaction(targetEvtId, key);
+    if (!validatePendingEvent(txnId)) {
+        clog << "Invalid pending event right after submitting" << endl;
+        FAIL_TEST();
+    }
+
+    connectUntil(targetRoom, &Room::updatedEvent, this,
+        [this, thisTest, txnId, key, targetEvtId](const QString& actualTargetEvtId) {
+            if (actualTargetEvtId != targetEvtId)
+                return false;
+            const auto reactions = targetRoom->relatedEvents(
+                targetEvtId, EventRelation::Annotation());
+            // It's a test room, assuming no interference there should
+            // be exactly one reaction
+            if (reactions.size() != 1)
+                FAIL_TEST();
+
+            const auto* evt =
+                eventCast<const ReactionEvent>(reactions.back());
+            FINISH_TEST(is<ReactionEvent>(*evt) && !evt->id().isEmpty()
+                        && evt->relation().key == key
+                        && evt->transactionId() == txnId);
+            // TODO: Test removing the reaction
+        });
+    return false;
+}
+
+TEST_IMPL(sendFile)
+{
+    auto* tf = new QTemporaryFile;
+    if (!tf->open()) {
+        clog << "Failed to create a temporary file" << endl;
+        FAIL_TEST();
+    }
+    tf->write("Test");
+    tf->close();
+    // QFileInfo::fileName brings only the file name; QFile::fileName brings
+    // the full path
+    const auto tfName = QFileInfo(*tf).fileName();
+    clog << "Sending file " << tfName.toStdString() << endl;
+    const auto txnId =
+        targetRoom->postFile("Test file", QUrl::fromLocalFile(tf->fileName()));
+    if (!validatePendingEvent(txnId)) {
+        clog << "Invalid pending event right after submitting" << endl;
+        delete tf;
+        FAIL_TEST();
+    }
+
+    // Using tf as a context object to clean away both connections
+    // once either of them triggers.
+    connectUntil(targetRoom, &Room::fileTransferCompleted, tf,
+        [this, thisTest, txnId, tf, tfName](const QString& id) {
+            auto fti = targetRoom->fileTransferInfo(id);
+            Q_ASSERT(fti.status == FileTransferInfo::Completed);
+
+            if (id != txnId)
+                return false;
+
+            tf->deleteLater();
+            return checkFileSendingOutcome(thisTest, txnId, tfName);
+        });
+    connectUntil(targetRoom, &Room::fileTransferFailed, tf,
+        [this, thisTest, txnId, tf](const QString& id, const QString& error) {
+            if (id != txnId)
+                return false;
+
+            targetRoom->postPlainText(origin % ": File upload failed: " % error);
+            tf->deleteLater();
+            FAIL_TEST();
+        });
+    return false;
+}
+
+bool TestSuite::checkFileSendingOutcome(const TestToken& thisTest,
+                                        const QString& txnId,
+                                        const QString& fileName)
+{
+    auto it = targetRoom->findPendingEvent(txnId);
+    if (it == targetRoom->pendingEvents().end()) {
+        clog << "Pending file event dropped before upload completion" << endl;
+        FAIL_TEST();
+    }
+    if (it->deliveryStatus() != EventStatus::FileUploaded) {
+        clog << "Pending file event status upon upload completion is "
+             << it->deliveryStatus() << " != FileUploaded("
+             << EventStatus::FileUploaded << ')' << endl;
+        FAIL_TEST();
+    }
+
+    connectUntil(targetRoom, &Room::pendingEventAboutToMerge, this,
+        [this, thisTest, txnId, fileName](const RoomEvent* evt, int pendingIdx) {
+            const auto& pendingEvents = targetRoom->pendingEvents();
+            Q_ASSERT(pendingIdx >= 0 && pendingIdx < int(pendingEvents.size()));
+
+            if (evt->transactionId() != txnId)
+                return false;
+
+            clog << "File event " << txnId.toStdString()
+                 << " arrived in the timeline" << endl;
+            // This part tests visit()
+            return visit(
+                *evt,
+                [&](const RoomMessageEvent& e) {
+                    // TODO: actually try to download it to check, e.g., #366
+                    // (and #368 would help to test against bad file names).
+                    FINISH_TEST(
+                        !e.id().isEmpty()
+                            && pendingEvents[size_t(pendingIdx)]->transactionId()
+                                   == txnId
+                            && e.hasFileContent()
+                            && e.content()->fileInfo()->originalName == fileName);
+                },
+                [this, thisTest](const RoomEvent&) { FAIL_TEST(); });
+        });
+    return true;
+}
+
+TEST_IMPL(setTopic)
+{
+    const auto newTopic = connection()->generateTxnId(); // Just a way to make
+                                                         // a unique id
+    targetRoom->setTopic(newTopic);
+    connectUntil(targetRoom, &Room::topicChanged, this,
+        [this, thisTest, newTopic] {
+            if (targetRoom->topic() == newTopic)
+                FINISH_TEST(true);
+
+            clog << "Requested topic was " << newTopic.toStdString() << ", "
+                 << targetRoom->topic().toStdString() << " arrived instead"
+                 << endl;
+            return false;
+        });
+    return false;
+}
+
+TEST_IMPL(changeName)
+{
+    auto* const localUser = connection()->user();
+    const auto& newName = connection()->generateTxnId(); // See setTopic()
+    clog << "Renaming the user to " << newName.toStdString() << endl;
+    localUser->rename(newName);
+    connectUntil(localUser, &User::defaultNameChanged, this,
+                 [this, thisTest, localUser, newName] {
+                     FINISH_TEST(localUser->name() == newName);
+                 });
+    return false;
+}
+
+TEST_IMPL(sendAndRedact)
+{
+    clog << "Sending a message to redact" << endl;
+    auto txnId = targetRoom->postPlainText(origin % ": message to redact");
+    if (txnId.isEmpty())
+        FAIL_TEST();
+
+    connectUntil(targetRoom, &Room::messageSent, this,
+            [this, thisTest, txnId](const QString& tId, const QString& evtId) {
+                if (tId != txnId)
+                    return false;
+
+                // The event may end up having been merged, and that's ok;
+                // but if it's not, it has to be in the ReachedServer state.
+                if (auto it = room()->findPendingEvent(tId);
+                    it != room()->pendingEvents().cend()
+                    && it->deliveryStatus() != EventStatus::ReachedServer) {
+                    clog << "Incorrect sent event status ("
+                         << it->deliveryStatus() << ')' << endl;
+                    FAIL_TEST();
+                }
+
+                clog << "Redacting the message" << endl;
+                targetRoom->redactEvent(evtId, origin);
+                connectUntil(targetRoom, &Room::addedMessages, this,
+                             [this, thisTest, evtId] {
+                                 return checkRedactionOutcome(thisTest, evtId);
+                             });
+                return false;
+            });
+    return false;
+}
+
+bool TestSuite::checkRedactionOutcome(const QByteArray& thisTest,
+                                      const QString& evtIdToRedact)
+{
+    // There are two possible (correct) outcomes: either the event comes already
+    // redacted at the next sync, or the nearest sync completes with
+    // the unredacted event but the next one brings redaction.
+    auto it = targetRoom->findInTimeline(evtIdToRedact);
+    if (it == targetRoom->timelineEdge())
+        return false; // Waiting for the next sync
+
+    if ((*it)->isRedacted()) {
+        clog << "The sync brought already redacted message" << endl;
+        FINISH_TEST(true);
+    }
+
+    clog << "Message came non-redacted with the sync, waiting for redaction"
+         << endl;
+    connectUntil(targetRoom, &Room::replacedEvent, this,
+                 [this, thisTest, evtIdToRedact](const RoomEvent* newEvent,
+                                                 const RoomEvent* oldEvent) {
+                     if (oldEvent->id() != evtIdToRedact)
+                         return false;
+
+                     FINISH_TEST(newEvent->isRedacted()
+                                 && newEvent->redactionReason() == origin);
+                 });
+    return true;
+}
+
+TEST_IMPL(addAndRemoveTag)
+{
+    static const auto TestTag = QStringLiteral("im.quotient.test");
+    // Pre-requisite
+    if (targetRoom->tags().contains(TestTag))
+        targetRoom->removeTag(TestTag);
+
+    // Unlike for most of Quotient, tags are applied and tagsChanged is emitted
+    // synchronously, with the server being notified async. The test checks
+    // that the signal is emitted, not only that tags have changed; but there's
+    // (currently) no way to check that the server has been correctly notified
+    // of the tag change.
+    QSignalSpy spy(targetRoom, &Room::tagsChanged);
+    targetRoom->addTag(TestTag);
+    if (spy.count() != 1 || !targetRoom->tags().contains(TestTag)) {
+        clog << "Tag adding failed" << endl;
+        FAIL_TEST();
+    }
+    clog << "Test tag set, removing it now" << endl;
+    targetRoom->removeTag(TestTag);
+    FINISH_TEST(spy.count() == 2 && !targetRoom->tags().contains(TestTag));
+}
+
+bool TestSuite::checkDirectChat() const
+{
+    return targetRoom->directChatUsers().contains(connection()->user());
+}
+
+TEST_IMPL(markDirectChat)
+{
+    if (checkDirectChat())
+        connection()->removeFromDirectChats(targetRoom->id(),
+                                            connection()->user());
+
+    int id = qRegisterMetaType<DirectChatsMap>(); // For QSignalSpy
+    Q_ASSERT(id != -1);
+
+    // Same as with tags (and unusual for the rest of Quotient), direct chat
+    // operations are synchronous.
+    QSignalSpy spy(connection(), &Connection::directChatsListChanged);
+    clog << "Marking the room as a direct chat" << endl;
+    connection()->addToDirectChats(targetRoom, connection()->user());
+    if (spy.count() != 1 || !checkDirectChat())
+        FAIL_TEST();
+
+    // Check that the first argument (added DCs) actually contains the room
+    const auto& addedDCs = spy.back().front().value<DirectChatsMap>();
+    if (addedDCs.size() != 1
+        || !addedDCs.contains(connection()->user(), targetRoom->id())) {
+        clog << "The room is not in added direct chats" << endl;
+        FAIL_TEST();
+    }
+
+    clog << "Unmarking the direct chat" << endl;
+    connection()->removeFromDirectChats(targetRoom->id(), connection()->user());
+    if (spy.count() != 2 && checkDirectChat())
+        FAIL_TEST();
+
+    // Check that the second argument (removed DCs) actually contains the room
+    const auto& removedDCs = spy.back().back().value<DirectChatsMap>();
+    FINISH_TEST(removedDCs.size() == 1
+                && removedDCs.contains(connection()->user(), targetRoom->id()));
+}
+
+TEST_IMPL(visitResources)
+{
+    // Same as the two tests above, ResourceResolver emits signals
+    // synchronously so we use signal spies to intercept them instead of
+    // connecting lambdas before calling openResource(). NB: this test
+    // assumes that ResourceResolver::openResource is implemented in terms
+    // of ResourceResolver::visitResource, so the latter doesn't need a
+    // separate test.
+    static UriDispatcher ud;
+
+    // This lambda returns true in case of error, false if it's fine so far
+    auto testResourceResolver = [this, thisTest](const QStringList& uris,
+                                                 auto signal, auto* target,
+                                                 QVariantList otherArgs = {}) {
+        int r = qRegisterMetaType<decltype(target)>();
+        Q_ASSERT(r != 0);
+        QSignalSpy spy(&ud, signal);
+        for (const auto& uriString: uris) {
+            Uri uri { uriString };
+            clog << "Checking " << uriString.toStdString()
+                 << " -> " << uri.toDisplayString().toStdString() << endl;
+            if (auto matrixToUrl = uri.toUrl(Uri::MatrixToUri).toDisplayString();
+                !matrixToUrl.startsWith("https://matrix.to/#/")) {
+                clog << "Incorrect matrix.to representation:"
+                     << matrixToUrl.toStdString() << endl;
+            }
+            ud.visitResource(connection(), uriString);
+            if (spy.count() != 1) {
+                clog << "Wrong number of signal emissions (" << spy.count()
+                     << ')' << endl;
+                FAIL_TEST();
+            }
+            const auto& emission = spy.front();
+            Q_ASSERT(emission.count() >= 2);
+            if (emission.front().value<decltype(target)>() != target) {
+                clog << "Signal emitted with an incorrect target" << endl;
+                FAIL_TEST();
+            }
+            if (!otherArgs.empty()) {
+                if (emission.size() < otherArgs.size() + 1) {
+                    clog << "Emission doesn't include all arguments" << endl;
+                    FAIL_TEST();
+                }
+                for (auto i = 0; i < otherArgs.size(); ++i)
+                    if (otherArgs[i] != emission[i + 1]) {
+                        clog << "Mismatch in argument #" << i + 1 << endl;
+                        FAIL_TEST();
+                    }
+            }
+            spy.clear();
+        }
+        return false;
+    };
+
+    // Basic tests
+    for (const auto& u: { Uri {}, Uri { QUrl {} } })
+        if (u.isValid() || !u.isEmpty()) {
+            clog << "Empty Matrix URI test failed" << endl;
+            FAIL_TEST();
+        }
+    if (Uri { QStringLiteral("#") }.isValid()) {
+        clog << "Bare sigil URI test failed" << endl;
+        FAIL_TEST();
+    }
+    QUrl invalidUrl { "https://" };
+    invalidUrl.setAuthority("---:@@@");
+    const Uri matrixUriFromInvalidUrl { invalidUrl },
+        invalidMatrixUri { QStringLiteral("matrix:&invalid@") };
+    if (matrixUriFromInvalidUrl.isEmpty() || matrixUriFromInvalidUrl.isValid()) {
+        clog << "Invalid Matrix URI test failed" << endl;
+        FAIL_TEST();
+    }
+    if (invalidMatrixUri.isEmpty() || invalidMatrixUri.isValid()) {
+        clog << "Invalid sigil in a Matrix URI - test failed" << endl;
+        FAIL_TEST();
+    }
+
+    // Matrix identifiers used throughout all URI tests
+    const auto& roomId = room()->id();
+    const auto& roomAlias = room()->canonicalAlias();
+    const auto& userId = connection()->userId();
+    const auto& eventId = room()->messageEvents().back()->id();
+    Q_ASSERT(!roomId.isEmpty());
+    Q_ASSERT(!roomAlias.isEmpty());
+    Q_ASSERT(!userId.isEmpty());
+    Q_ASSERT(!eventId.isEmpty());
+
+    const QStringList roomUris {
+        roomId, "matrix:roomid/" + roomId.mid(1),
+        "https://matrix.to/#/%21"/*`!`*/ + roomId.mid(1),
+        roomAlias, "matrix:room/" + roomAlias.mid(1),
+        "https://matrix.to/#/" + roomAlias,
+    };
+    const QStringList userUris { userId, "matrix:user/" + userId.mid(1),
+                                 "https://matrix.to/#/" + userId };
+    const QStringList eventUris {
+        "matrix:room/" + roomAlias.mid(1) + "/event/" + eventId.mid(1),
+        "https://matrix.to/#/" + roomId + '/' + eventId
+    };
+    // Check that reserved characters are correctly processed.
+    static const auto& joinRoomAlias =
+        QStringLiteral("##/?.@\"unjoined:example.org");
+    static const auto& encodedRoomAliasNoSigil =
+        QUrl::toPercentEncoding(joinRoomAlias.mid(1), ":");
+    static const QString joinQuery { "?action=join" };
+    // These URIs are not supposed to be actually joined (and even exist,
+    // as yet) - only to be syntactically correct
+    static const QStringList joinByAliasUris {
+        Uri(joinRoomAlias.toUtf8(), {}, joinQuery.mid(1)).toDisplayString(),
+        "matrix:room/" + encodedRoomAliasNoSigil + joinQuery,
+        "https://matrix.to/#/%23"/*`#`*/ + encodedRoomAliasNoSigil + joinQuery,
+        "https://matrix.to/#/%23" + joinRoomAlias.mid(1) /* unencoded */ + joinQuery
+    };
+    static const auto& joinRoomId = QStringLiteral("!anyid:example.org");
+    static const QStringList viaServers { "matrix.org", "example.org" };
+    static const auto viaQuery =
+        std::accumulate(viaServers.cbegin(), viaServers.cend(), joinQuery,
+                        [](const QString& q, const QString& s) {
+                            return q + "&via=" + s;
+                        });
+    static const QStringList joinByIdUris {
+        "matrix:roomid/" + joinRoomId.mid(1) + viaQuery,
+        "https://matrix.to/#/" + joinRoomId + viaQuery
+    };
+    // If any test breaks, the breaking call will return true, and further
+    // execution will be cut by ||'s short-circuiting
+    if (testResourceResolver(roomUris, &UriDispatcher::roomAction, room())
+        || testResourceResolver(userUris, &UriDispatcher::userAction,
+                                connection()->user())
+        || testResourceResolver(eventUris, &UriDispatcher::roomAction,
+                                room(), { eventId })
+        || testResourceResolver(joinByAliasUris, &UriDispatcher::joinAction,
+                                connection(), { joinRoomAlias })
+        || testResourceResolver(joinByIdUris, &UriDispatcher::joinAction,
+                                connection(), { joinRoomId, viaServers }))
+        return true;
+    // TODO: negative cases
+    FINISH_TEST(true);
+}
+
+void TestManager::conclude()
+{
+    // Clean up the room (best effort)
+    auto* room = testSuite->room();
+    room->setTopic({});
+    room->localUser()->rename({});
+
+    QString succeededRec { QString::number(succeeded.size()) % " of "
+                           % QString::number(succeeded.size() + failed.size()
+                                             + running.size())
+                           % " tests succeeded" };
+    QString plainReport = origin % ": Testing complete, " % succeededRec;
+    QString color = failed.empty() && running.empty() ? "00AA00" : "AA0000";
+    QString htmlReport = origin % ": <strong><font data-mx-color='#" % color
+                         % "' color='#" % color
+                         % "'>Testing complete</font></strong>, " % succeededRec;
+    if (!failed.empty()) {
+        QByteArray failedList;
+        for (const auto& f : qAsConst(failed))
+            failedList += ' ' + f;
+        plainReport += "\nFAILED:" + failedList;
+        htmlReport += "<br><strong>Failed:</strong>" + failedList;
+    }
+    if (!running.empty()) {
+        QByteArray dnfList;
+        for (const auto& r : qAsConst(running))
+            dnfList += ' ' + r;
+        plainReport += "\nDID NOT FINISH:" + dnfList;
+        htmlReport += "<br><strong>Did not finish:</strong>" + dnfList;
+    }
+
+    auto txnId = room->postHtmlText(plainReport, htmlReport);
+    // Now just wait until all the pending events reach the server
+    connectUntil(room, &Room::messageSent, this,
+        [this, txnId, room, plainReport] (const QString& sentTxnId) {
+            if (sentTxnId != txnId)
+                return false;
+            const auto& pendingEvents = room->pendingEvents();
+            if (auto c = std::count_if(pendingEvents.cbegin(),
+                                       pendingEvents.cend(),
+                                       [](const PendingEventItem& pe) {
+                                           return pe.deliveryStatus()
+                                                  < EventStatus::ReachedServer;
+                                       });
+                c > 0) {
+                clog << "Events to reach the server: " << c
+                     << ", not leaving yet" << endl;
+                return false;
+            }
+
+            clog << "Leaving the room" << endl;
+            // TODO: Waiting for proper futures to come so that it could be:
+//           room->leaveRoom()
+//           .then(this, &TestManager::finalize); // Qt-style or
+//           .then([this] { finalize(); }); // STL-style
+            auto* job = room->leaveRoom();
+            connect(job, &BaseJob::result, this, [this, job,plainReport] {
+                Q_ASSERT(job->status().good());
+                finalize();
+                // Still flying, as the exit() connection in finalize() is queued
+                clog << plainReport.toStdString() << endl;
+            });
+            return true;
+        });
+}
+
+void TestManager::finalize()
+{
+    clog << "Logging out" << endl;
+    c->logout();
+    connect(c, &Connection::loggedOut, this,
+            [this] { QCoreApplication::exit(failed.size() + running.size()); },
+        Qt::QueuedConnection);
+}
+
+int main(int argc, char* argv[])
+{
+    // TODO: use QCommandLineParser
+    if (argc < 5) {
+        clog << "Usage: quotest <user> <passwd> <device_name> <room_alias> [origin]"
+             << endl;
+        return -1;
+    }
+    // NOLINTNEXTLINE(readability-static-accessed-through-instance)
+    return TestManager(argc, argv).exec();
+}
+
+#include "quotest.moc"
-- 
cgit v1.2.3


From 390162a0c707c51590acb27df81e98a85d3b6cf7 Mon Sep 17 00:00:00 2001
From: Carl Schwan <carl@carlschwan.eu>
Date: Fri, 22 Jan 2021 15:40:52 +0100
Subject: Remove quotest from ctest

---
 quotest/CMakeLists.txt | 1 -
 1 file changed, 1 deletion(-)

(limited to 'quotest')

diff --git a/quotest/CMakeLists.txt b/quotest/CMakeLists.txt
index 4553abb6..d17e8620 100644
--- a/quotest/CMakeLists.txt
+++ b/quotest/CMakeLists.txt
@@ -5,5 +5,4 @@
 set(quotest_SRCS quotest.cpp)
 
 add_executable(quotest ${quotest_SRCS})
-add_test(NAME quotest COMMAND quotest)
 target_link_libraries(quotest PRIVATE Qt5::Core Qt5::Test ${PROJECT_NAME})
-- 
cgit v1.2.3


From 680e0f9deb3042db5cda43b81dbc7b1c153b8744 Mon Sep 17 00:00:00 2001
From: Carl Schwan <carl@carlschwan.eu>
Date: Sat, 23 Jan 2021 16:33:43 +0100
Subject: Add test

---
 quotest/quotest.cpp | 12 ++++++++++++
 1 file changed, 12 insertions(+)

(limited to 'quotest')

diff --git a/quotest/quotest.cpp b/quotest/quotest.cpp
index 5098bc02..f693319f 100644
--- a/quotest/quotest.cpp
+++ b/quotest/quotest.cpp
@@ -101,6 +101,7 @@ private slots:
     TEST_DECL(setTopic)
     TEST_DECL(changeName)
     TEST_DECL(sendAndRedact)
+    TEST_DECL(showLocalUsername)
     TEST_DECL(addAndRemoveTag)
     TEST_DECL(markDirectChat)
     TEST_DECL(visitResources)
@@ -508,6 +509,17 @@ TEST_IMPL(changeName)
     return false;
 }
 
+
+TEST_IMPL(showLocalUsername)
+{
+    auto* const localUser = connection()->user();
+    if (localUser->name().contains("@")) {
+        // it is using the id fallback :(
+        FAIL_TEST();
+    }
+    return false;
+}
+
 TEST_IMPL(sendAndRedact)
 {
     clog << "Sending a message to redact" << endl;
-- 
cgit v1.2.3


From bfaf9330c4214636478df977ab7f6b5d1d843104 Mon Sep 17 00:00:00 2001
From: Carl Schwan <carl@carlschwan.eu>
Date: Sat, 23 Jan 2021 18:14:46 +0100
Subject: Update test

---
 quotest/quotest.cpp | 1 +
 1 file changed, 1 insertion(+)

(limited to 'quotest')

diff --git a/quotest/quotest.cpp b/quotest/quotest.cpp
index f693319f..ed1c1d13 100644
--- a/quotest/quotest.cpp
+++ b/quotest/quotest.cpp
@@ -517,6 +517,7 @@ TEST_IMPL(showLocalUsername)
         // it is using the id fallback :(
         FAIL_TEST();
     }
+    FINISH_TEST(true);
     return false;
 }
 
-- 
cgit v1.2.3


From a1b1b96bcd78c6efb0ad3c1ba9c93284497d74a6 Mon Sep 17 00:00:00 2001
From: Alexey Rusakov <Kitsune-Ral@users.sf.net>
Date: Mon, 25 Jan 2021 10:38:02 +0100
Subject: CMakeLists.txt: refactor configuration of features

- The feature summary is only generated at the end of the configuration.
- InstallQuotest feature is defined in quotest/CMakeLists.txt now,
  and therefore is only available if quotest is getting built
  (i.e., if BUILD_TESTING is on).
- API generation configuration code merged from two places into one.
---
 CMakeLists.txt         | 78 +++++++++++++++++++++++---------------------------
 quotest/CMakeLists.txt |  8 ++++++
 2 files changed, 44 insertions(+), 42 deletions(-)

(limited to 'quotest')

diff --git a/CMakeLists.txt b/CMakeLists.txt
index a458c9ff..39b1b03a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -12,10 +12,6 @@ message(STATUS "Configuring ${PROJECT_NAME} ${PROJECT_VERSION} ==>")
 include(FeatureSummary)
 include(CTest)
 
-option(${PROJECT_NAME}_INSTALL_TESTS "install quotest (former qmc-example) application" ON)
-add_feature_info(InstallQuotest ${PROJECT_NAME}_INSTALL_TESTS
-                 "the library functional test suite")
-
 # https://github.com/quotient-im/libQuotient/issues/369
 option(${PROJECT_NAME}_ENABLE_E2EE "end-to-end encryption (E2EE) support" OFF)
 add_feature_info(EnableE2EE ${PROJECT_NAME}_ENABLE_E2EE
@@ -115,36 +111,6 @@ if (${PROJECT_NAME}_ENABLE_E2EE)
     endif ()
 endif ()
 
-if (GTAD_PATH)
-    get_filename_component(ABS_GTAD_PATH "${GTAD_PATH}" REALPATH)
-endif ()
-if (MATRIX_DOC_PATH)
-    get_filename_component(ABS_API_DEF_PATH "${MATRIX_DOC_PATH}/api" REALPATH)
-endif ()
-if (ABS_GTAD_PATH AND ABS_API_DEF_PATH)
-    message( STATUS "Using GTAD at ${ABS_GTAD_PATH}" )
-    message( STATUS "Using API files at ${ABS_API_DEF_PATH}" )
-    set(API_GENERATION_ENABLED 1)
-    if (NOT CLANG_FORMAT)
-        set(CLANG_FORMAT clang-format)
-    endif()
-    get_filename_component(ABS_CLANG_FORMAT "${CLANG_FORMAT}" PROGRAM)
-    if (ABS_CLANG_FORMAT)
-        set(API_FORMATTING_ENABLED 1)
-        message( STATUS "clang-format is at ${ABS_CLANG_FORMAT}")
-    else ()
-        message( STATUS "${CLANG_FORMAT} is NOT FOUND; API files won't be reformatted")
-    endif ()
-endif()
-add_feature_info(EnableApiCodeGeneration "${API_GENERATION_ENABLED}"
-                 "build target update-api")
-add_feature_info(EnableApiFormatting "${API_FORMATTING_ENABLED}"
-                 "formatting of generated API files with clang-format")
-
-message(STATUS)
-feature_summary(WHAT ENABLED_FEATURES DISABLED_FEATURES
-                FATAL_ON_MISSING_REQUIRED_PACKAGES)
-
 # Set up source files
 set(lib_SRCS
     lib/networkaccessmanager.cpp
@@ -192,12 +158,34 @@ set(lib_SRCS
     lib/jobs/downloadfilejob.cpp
 )
 
+# Configure API files generation
+
 set(CSAPI_DIR csapi)
 set(FULL_CSAPI_DIR lib/${CSAPI_DIR})
 set(ASAPI_DEF_DIR application-service/definitions)
 set(ISAPI_DEF_DIR identity/definitions)
 
-if (MATRIX_DOC_PATH AND GTAD_PATH)
+if (GTAD_PATH)
+    get_filename_component(ABS_GTAD_PATH "${GTAD_PATH}" REALPATH)
+endif ()
+if (MATRIX_DOC_PATH)
+    get_filename_component(ABS_API_DEF_PATH "${MATRIX_DOC_PATH}/api" REALPATH)
+endif ()
+if (ABS_GTAD_PATH AND ABS_API_DEF_PATH)
+    message( STATUS "Using GTAD at ${ABS_GTAD_PATH}" )
+    message( STATUS "Using API files at ${ABS_API_DEF_PATH}" )
+    set(API_GENERATION_ENABLED 1)
+    if (NOT CLANG_FORMAT)
+        set(CLANG_FORMAT clang-format)
+    endif()
+    get_filename_component(ABS_CLANG_FORMAT "${CLANG_FORMAT}" PROGRAM)
+    if (ABS_CLANG_FORMAT)
+        set(API_FORMATTING_ENABLED 1)
+        message( STATUS "clang-format is at ${ABS_CLANG_FORMAT}")
+    else ()
+        message( STATUS "${CLANG_FORMAT} is NOT FOUND; API files won't be reformatted")
+    endif ()
+
     if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.12.0")
         # We use globbing with CONFIGURE_DEPENDS to produce two file lists:
         # one of all API files for clang-format and another of just .cpp
@@ -250,6 +238,10 @@ if (MATRIX_DOC_PATH AND GTAD_PATH)
         endif()
     endif()
 endif()
+add_feature_info(EnableApiCodeGeneration "${API_GENERATION_ENABLED}"
+                 "build target update-api")
+add_feature_info(EnableApiFormatting "${API_FORMATTING_ENABLED}"
+                 "formatting of generated API files with clang-format")
 
 # Make no mistake: CMake cannot run gtad first and then populate the list of
 # resulting api_SRCS files. In other words, placing the below statement after
@@ -289,15 +281,17 @@ if (${PROJECT_NAME}_ENABLE_E2EE)
 endif()
 target_link_libraries(${PROJECT_NAME} Qt5::Core Qt5::Network Qt5::Gui Qt5::Multimedia)
 
+configure_file(${PROJECT_NAME}.pc.in ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc @ONLY NEWLINE_STYLE UNIX)
+
+# Configure testing
+
 if (BUILD_TESTING)
     enable_testing()
     add_subdirectory(quotest)
     add_subdirectory(autotests)
 endif()
 
-configure_file(${PROJECT_NAME}.pc.in ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc @ONLY NEWLINE_STYLE UNIX)
-
-# Installation
+# Configure installation
 
 install(TARGETS ${PROJECT_NAME} EXPORT ${PROJECT_NAME}Targets
         ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
@@ -338,13 +332,13 @@ if (WIN32)
     install(FILES mime/packages/freedesktop.org.xml DESTINATION mime/packages)
 endif (WIN32)
 
-if (${PROJECT_NAME}_INSTALL_TESTS)
-    install(TARGETS ${TEST_BINARY} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
-endif ()
-
 if (UNIX AND NOT APPLE)
     install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc
             DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
 endif()
 
+message(STATUS)
+feature_summary(WHAT ENABLED_FEATURES DISABLED_FEATURES
+                FATAL_ON_MISSING_REQUIRED_PACKAGES)
+
 message(STATUS "<== End of libQuotient configuration")
diff --git a/quotest/CMakeLists.txt b/quotest/CMakeLists.txt
index d17e8620..29c53fae 100644
--- a/quotest/CMakeLists.txt
+++ b/quotest/CMakeLists.txt
@@ -6,3 +6,11 @@ set(quotest_SRCS quotest.cpp)
 
 add_executable(quotest ${quotest_SRCS})
 target_link_libraries(quotest PRIVATE Qt5::Core Qt5::Test ${PROJECT_NAME})
+
+option(${PROJECT_NAME}_INSTALL_TESTS "install quotest (former qmc-example) application" ON)
+add_feature_info(InstallQuotest ${PROJECT_NAME}_INSTALL_TESTS
+                 "the library functional test suite")
+
+if (${PROJECT_NAME}_INSTALL_TESTS)
+    install(TARGETS quotest RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+endif ()
-- 
cgit v1.2.3


From 9760bc4c22b2abf9732732df22cadb7f7db0641c Mon Sep 17 00:00:00 2001
From: Carl Schwan <carl@carlschwan.eu>
Date: Tue, 9 Feb 2021 21:11:14 +0100
Subject: Update

---
 quotest/quotest.cpp | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

(limited to 'quotest')

diff --git a/quotest/quotest.cpp b/quotest/quotest.cpp
index ed1c1d13..2512df0d 100644
--- a/quotest/quotest.cpp
+++ b/quotest/quotest.cpp
@@ -513,12 +513,7 @@ TEST_IMPL(changeName)
 TEST_IMPL(showLocalUsername)
 {
     auto* const localUser = connection()->user();
-    if (localUser->name().contains("@")) {
-        // it is using the id fallback :(
-        FAIL_TEST();
-    }
-    FINISH_TEST(true);
-    return false;
+    FINISH_TEST(localUser->name().contains("@"));
 }
 
 TEST_IMPL(sendAndRedact)
-- 
cgit v1.2.3


From fb6e3f215774d48f7e0c6000cc7a9ebbc66ceb64 Mon Sep 17 00:00:00 2001
From: Carl Schwan <carl@carlschwan.eu>
Date: Mon, 15 Feb 2021 21:03:49 +0100
Subject: Update quotest/quotest.cpp

Co-authored-by: Alexey Rusakov <Kitsune-Ral@users.sf.net>
---
 quotest/quotest.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'quotest')

diff --git a/quotest/quotest.cpp b/quotest/quotest.cpp
index 2512df0d..bf29c434 100644
--- a/quotest/quotest.cpp
+++ b/quotest/quotest.cpp
@@ -513,7 +513,7 @@ TEST_IMPL(changeName)
 TEST_IMPL(showLocalUsername)
 {
     auto* const localUser = connection()->user();
-    FINISH_TEST(localUser->name().contains("@"));
+    FINISH_TEST(!localUser->name().contains("@"));
 }
 
 TEST_IMPL(sendAndRedact)
-- 
cgit v1.2.3


From 81664eaf5a983dbd326e4d24d21c2108ea4d6353 Mon Sep 17 00:00:00 2001
From: Alexey Rusakov <Kitsune-Ral@users.sf.net>
Date: Sun, 21 Feb 2021 20:20:38 +0100
Subject: Uri: support abbreviated types in Matrix URIs

As per the latest iteration of MSC2312, room/, user/ and event/ are
only supported for parsing and replication but not for emitting from
Matrix identifiers.

(cherry picked from commit 86f24d1ecf300b82b3a7253b81a2c392669d2c2b)
---
 lib/uri.cpp         | 15 +++++++++++----
 quotest/quotest.cpp |  4 ++++
 2 files changed, 15 insertions(+), 4 deletions(-)

(limited to 'quotest')

diff --git a/lib/uri.cpp b/lib/uri.cpp
index 4b171e79..291bfcae 100644
--- a/lib/uri.cpp
+++ b/lib/uri.cpp
@@ -10,13 +10,19 @@
 using namespace Quotient;
 
 struct ReplacePair { QByteArray uriString; char sigil; };
-/// Defines bi-directional mapping of path prefixes and sigils
+/// \brief Defines bi-directional mapping of path prefixes and sigils
+///
+/// When there are two prefixes for the same sigil, the first matching
+/// entry for a given sigil is used.
 static const auto replacePairs = {
-    ReplacePair { "user/", '@' },
+    ReplacePair { "u/", '@' },
+    { "user/", '@' },
     { "roomid/", '!' },
+    { "r/", '#' },
     { "room/", '#' },
     // The notation for bare event ids is not proposed in MSC2312 but there's
     // https://github.com/matrix-org/matrix-doc/pull/2644
+    { "e/", '$' },
     { "event/", '$' }
 };
 
@@ -97,7 +103,7 @@ Uri::Uri(QUrl url) : QUrl(std::move(url))
         case 2:
             break;
         case 4:
-            if (splitPath[2] == "event")
+            if (splitPath[2] == "event" || splitPath[2] == "e")
                 break;
             [[fallthrough]];
         default:
@@ -150,7 +156,8 @@ Uri::Type Uri::type() const { return primaryType_; }
 
 Uri::SecondaryType Uri::secondaryType() const
 {
-    return pathSegment(*this, 2) == "event" ? EventId : NoSecondaryId;
+    const auto& type2 = pathSegment(*this, 2);
+    return type2 == "event" || type2 == "e" ? EventId : NoSecondaryId;
 }
 
 QUrl Uri::toUrl(UriForm form) const
diff --git a/quotest/quotest.cpp b/quotest/quotest.cpp
index bf29c434..a0914c72 100644
--- a/quotest/quotest.cpp
+++ b/quotest/quotest.cpp
@@ -733,12 +733,15 @@ TEST_IMPL(visitResources)
         roomId, "matrix:roomid/" + roomId.mid(1),
         "https://matrix.to/#/%21"/*`!`*/ + roomId.mid(1),
         roomAlias, "matrix:room/" + roomAlias.mid(1),
+        "matrix:r/" + roomAlias.mid(1),
         "https://matrix.to/#/" + roomAlias,
     };
     const QStringList userUris { userId, "matrix:user/" + userId.mid(1),
+                                 "matrix:u/" + userId.mid(1),
                                  "https://matrix.to/#/" + userId };
     const QStringList eventUris {
         "matrix:room/" + roomAlias.mid(1) + "/event/" + eventId.mid(1),
+        "matrix:r/" + roomAlias.mid(1) + "/e/" + eventId.mid(1),
         "https://matrix.to/#/" + roomId + '/' + eventId
     };
     // Check that reserved characters are correctly processed.
@@ -752,6 +755,7 @@ TEST_IMPL(visitResources)
     static const QStringList joinByAliasUris {
         Uri(joinRoomAlias.toUtf8(), {}, joinQuery.mid(1)).toDisplayString(),
         "matrix:room/" + encodedRoomAliasNoSigil + joinQuery,
+        "matrix:r/" + encodedRoomAliasNoSigil + joinQuery,
         "https://matrix.to/#/%23"/*`#`*/ + encodedRoomAliasNoSigil + joinQuery,
         "https://matrix.to/#/%23" + joinRoomAlias.mid(1) /* unencoded */ + joinQuery
     };
-- 
cgit v1.2.3


From dcbb2cfd0e238f788105d7d249f8aac6ad0823e4 Mon Sep 17 00:00:00 2001
From: Alexey Rusakov <Kitsune-Ral@users.sf.net>
Date: Fri, 11 Jun 2021 17:46:58 +0200
Subject: CMakeLists: require at least Qt 5.12; add Qt 6 support

---
 CMakeLists.txt           | 23 +++++++++++++++++++----
 autotests/CMakeLists.txt |  2 +-
 quotest/CMakeLists.txt   |  2 +-
 3 files changed, 21 insertions(+), 6 deletions(-)

(limited to 'quotest')

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 39b1b03a..9b53a53a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -72,9 +72,21 @@ message(STATUS "  Header files will be installed to ${CMAKE_INSTALL_PREFIX}/${${
 # Instruct CMake to run moc automatically when needed.
 set(CMAKE_AUTOMOC ON)
 
-find_package(Qt5 5.9 REQUIRED Core Network Gui Multimedia Test)
-get_filename_component(Qt5_Prefix "${Qt5_DIR}/../../../.." ABSOLUTE)
-message(STATUS "Using Qt ${Qt5_VERSION} at ${Qt5_Prefix}")
+option(BUILD_WITH_QT6 "Build Quotient with Qt 6" OFF)
+
+if (NOT BUILD_WITH_QT6)
+    # Use Qt5 by default
+    find_package(Qt5 5.12 QUIET COMPONENTS Core)
+endif()
+if (NOT Qt5Core_FOUND OR BUILD_WITH_Qt6)
+    find_package(Qt6 6.2 REQUIRED Core Network Gui Test) # TODO: Multimedia
+    set(Qt Qt6)
+else()
+    find_package(Qt5 5.12 REQUIRED Core Network Gui Multimedia Test)
+    set(Qt Qt5)
+endif()
+get_filename_component($Qt_Prefix "${${Qt}_DIR}/../../../.." ABSOLUTE)
+message(STATUS "Using Qt ${${Qt}_VERSION} at ${Qt_Prefix}")
 
 if (${PROJECT_NAME}_ENABLE_E2EE)
     if ((NOT DEFINED USE_INTREE_LIBQOLM OR USE_INTREE_LIBQOLM)
@@ -279,7 +291,10 @@ if (${PROJECT_NAME}_ENABLE_E2EE)
     target_link_libraries(${PROJECT_NAME} QtOlm)
     set(FIND_DEPS "find_dependency(QtOlm)") # For QuotientConfig.cmake.in
 endif()
-target_link_libraries(${PROJECT_NAME} Qt5::Core Qt5::Network Qt5::Gui Qt5::Multimedia)
+target_link_libraries(${PROJECT_NAME} ${Qt}::Core ${Qt}::Network ${Qt}::Gui)
+if (Qt STREQUAL Qt5) # Qt 6 hasn't got Multimedia component as yet
+    target_link_libraries(${PROJECT_NAME} ${Qt}::Multimedia)
+endif()
 
 configure_file(${PROJECT_NAME}.pc.in ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc @ONLY NEWLINE_STYLE UNIX)
 
diff --git a/autotests/CMakeLists.txt b/autotests/CMakeLists.txt
index 07f1f046..282ab036 100644
--- a/autotests/CMakeLists.txt
+++ b/autotests/CMakeLists.txt
@@ -7,7 +7,7 @@ include(CMakeParseArguments)
 function(QUOTIENT_ADD_TEST)
     cmake_parse_arguments(ARG "" "NAME" "" ${ARGN})
     add_executable(${ARG_NAME} ${ARG_NAME}.cpp)
-    target_link_libraries(${ARG_NAME} Qt5::Core Qt5::Test Quotient)
+    target_link_libraries(${ARG_NAME} ${Qt}::Core ${Qt}::Test Quotient)
     add_test(NAME ${ARG_NAME} COMMAND ${ARG_NAME})
 endfunction()
 
diff --git a/quotest/CMakeLists.txt b/quotest/CMakeLists.txt
index 29c53fae..bf9af796 100644
--- a/quotest/CMakeLists.txt
+++ b/quotest/CMakeLists.txt
@@ -5,7 +5,7 @@
 set(quotest_SRCS quotest.cpp)
 
 add_executable(quotest ${quotest_SRCS})
-target_link_libraries(quotest PRIVATE Qt5::Core Qt5::Test ${PROJECT_NAME})
+target_link_libraries(quotest PRIVATE ${Qt}::Core ${Qt}::Test ${PROJECT_NAME})
 
 option(${PROJECT_NAME}_INSTALL_TESTS "install quotest (former qmc-example) application" ON)
 add_feature_info(InstallQuotest ${PROJECT_NAME}_INSTALL_TESTS
-- 
cgit v1.2.3


From 004ebf8d5ba095ca1b11e30d86cedc2ff8c0cfe7 Mon Sep 17 00:00:00 2001
From: Alexey Rusakov <Kitsune-Ral@users.sf.net>
Date: Sun, 18 Jul 2021 18:22:28 +0200
Subject: Room::postFile(): adjust to the changed RoomMessageEvent API

9a5fa623 dropped one of RoomMessageEvent constructors for Qt 6 in order
to address #483 - breaking the build with Qt 6 along the way, as
Room::postFile() relied on that constructor. This commit changes
Room::postFile() in turn, deprecating the current signature and adding
a new one that accepts an EventContent object rather than a path to
a file. In order to achieve that, FileInfo and ImageInfo classes have
gained new constructors that accept QFileInfo instead of the legacy
series of parameters, streamlining usage of EventContent structures.
---
 lib/events/eventcontent.cpp  |  51 +++++++++++++++------
 lib/events/eventcontent.h    |  23 ++++++----
 lib/events/roomavatarevent.h |   4 +-
 lib/room.cpp                 | 105 ++++++++++++++++++++++++++-----------------
 lib/room.h                   |   5 +++
 quotest/quotest.cpp          |   9 ++--
 6 files changed, 128 insertions(+), 69 deletions(-)

(limited to 'quotest')

diff --git a/lib/events/eventcontent.cpp b/lib/events/eventcontent.cpp
index b249b160..1f28f195 100644
--- a/lib/events/eventcontent.cpp
+++ b/lib/events/eventcontent.cpp
@@ -5,10 +5,13 @@
 
 #include "converters.h"
 #include "util.h"
+#include "logging.h"
 
 #include <QtCore/QMimeDatabase>
+#include <QtCore/QFileInfo>
 
 using namespace Quotient::EventContent;
+using std::move;
 
 QJsonObject Base::toJson() const
 {
@@ -17,22 +20,37 @@ QJsonObject Base::toJson() const
     return o;
 }
 
-FileInfo::FileInfo(const QUrl& u, qint64 payloadSize, const QMimeType& mimeType,
-                   const QString& originalFilename)
+FileInfo::FileInfo(const QFileInfo &fi)
+    : mimeType(QMimeDatabase().mimeTypeForFile(fi))
+    , url(QUrl::fromLocalFile(fi.filePath()))
+    , payloadSize(fi.size())
+    , originalName(fi.fileName())
+{
+    Q_ASSERT(fi.isFile());
+}
+
+FileInfo::FileInfo(QUrl u, qint64 payloadSize, const QMimeType& mimeType,
+                   QString originalFilename)
     : mimeType(mimeType)
-    , url(u)
+    , url(move(u))
     , payloadSize(payloadSize)
-    , originalName(originalFilename)
-{}
+    , originalName(move(originalFilename))
+{
+    if (!isValid())
+        qCWarning(MESSAGES)
+            << "To client developers: using FileInfo(QUrl, qint64, ...) "
+               "constructor for non-mxc resources is deprecated since Quotient "
+               "0.7; for local resources, use FileInfo(QFileInfo) instead";
+}
 
-FileInfo::FileInfo(const QUrl& u, const QJsonObject& infoJson,
-                   const QString& originalFilename)
+FileInfo::FileInfo(QUrl mxcUrl, const QJsonObject& infoJson,
+                   QString originalFilename)
     : originalInfoJson(infoJson)
     , mimeType(
           QMimeDatabase().mimeTypeForName(infoJson["mimetype"_ls].toString()))
-    , url(u)
+    , url(move(mxcUrl))
     , payloadSize(fromJson<qint64>(infoJson["size"_ls]))
-    , originalName(originalFilename)
+    , originalName(move(originalFilename))
 {
     if (!mimeType.isValid())
         mimeType = QMimeDatabase().mimeTypeForData(QByteArray());
@@ -53,14 +71,19 @@ void FileInfo::fillInfoJson(QJsonObject* infoJson) const
         infoJson->insert(QStringLiteral("mimetype"), mimeType.name());
 }
 
-ImageInfo::ImageInfo(const QUrl& u, qint64 fileSize, QMimeType mimeType,
-                     const QSize& imageSize, const QString& originalFilename)
-    : FileInfo(u, fileSize, mimeType, originalFilename), imageSize(imageSize)
+ImageInfo::ImageInfo(const QFileInfo& fi, QSize imageSize)
+    : FileInfo(fi), imageSize(imageSize)
+{}
+
+ImageInfo::ImageInfo(const QUrl& mxcUrl, qint64 fileSize, const QMimeType& type,
+                     QSize imageSize, const QString& originalFilename)
+    : FileInfo(mxcUrl, fileSize, type, originalFilename)
+    , imageSize(imageSize)
 {}
 
-ImageInfo::ImageInfo(const QUrl& u, const QJsonObject& infoJson,
+ImageInfo::ImageInfo(const QUrl& mxcUrl, const QJsonObject& infoJson,
                      const QString& originalFilename)
-    : FileInfo(u, infoJson, originalFilename)
+    : FileInfo(mxcUrl, infoJson, originalFilename)
     , imageSize(infoJson["w"_ls].toInt(), infoJson["h"_ls].toInt())
 {}
 
diff --git a/lib/events/eventcontent.h b/lib/events/eventcontent.h
index 60d1f7b7..78c5b287 100644
--- a/lib/events/eventcontent.h
+++ b/lib/events/eventcontent.h
@@ -10,7 +10,8 @@
 #include <QtCore/QMimeType>
 #include <QtCore/QSize>
 #include <QtCore/QUrl>
-#include <QtCore/QMetaType>
+
+class QFileInfo;
 
 namespace Quotient {
 namespace EventContent {
@@ -73,11 +74,13 @@ namespace EventContent {
      */
     class FileInfo {
     public:
-        explicit FileInfo(const QUrl& u, qint64 payloadSize = -1,
+        FileInfo() = default;
+        explicit FileInfo(const QFileInfo& fi);
+        explicit FileInfo(QUrl mxcUrl, qint64 payloadSize = -1,
                           const QMimeType& mimeType = {},
-                          const QString& originalFilename = {});
-        FileInfo(const QUrl& u, const QJsonObject& infoJson,
-                 const QString& originalFilename = {});
+                          QString originalFilename = {});
+        FileInfo(QUrl mxcUrl, const QJsonObject& infoJson,
+                 QString originalFilename = {});
 
         bool isValid() const;
 
@@ -113,10 +116,12 @@ namespace EventContent {
      */
     class ImageInfo : public FileInfo {
     public:
-        explicit ImageInfo(const QUrl& u, qint64 fileSize = -1,
-                           QMimeType mimeType = {}, const QSize& imageSize = {},
+        ImageInfo() = default;
+        explicit ImageInfo(const QFileInfo& fi, QSize imageSize = {});
+        explicit ImageInfo(const QUrl& mxcUrl, qint64 fileSize = -1,
+                           const QMimeType& type = {}, QSize imageSize = {},
                            const QString& originalFilename = {});
-        ImageInfo(const QUrl& u, const QJsonObject& infoJson,
+        ImageInfo(const QUrl& mxcUrl, const QJsonObject& infoJson,
                   const QString& originalFilename = {});
 
         void fillInfoJson(QJsonObject* infoJson) const;
@@ -134,7 +139,7 @@ namespace EventContent {
      */
     class Thumbnail : public ImageInfo {
     public:
-        Thumbnail() : ImageInfo(QUrl()) {} // To allow empty thumbnails
+        Thumbnail() = default; // Allow empty thumbnails
         Thumbnail(const QJsonObject& infoJson);
         Thumbnail(const ImageInfo& info) : ImageInfo(info) {}
         using ImageInfo::ImageInfo;
diff --git a/lib/events/roomavatarevent.h b/lib/events/roomavatarevent.h
index a4257895..3fa11a0f 100644
--- a/lib/events/roomavatarevent.h
+++ b/lib/events/roomavatarevent.h
@@ -20,12 +20,12 @@ public:
         : StateEvent(typeId(), matrixTypeId(), QString(), avatar)
     {}
     // A replica of EventContent::ImageInfo constructor
-    explicit RoomAvatarEvent(const QUrl& u, qint64 fileSize = -1,
+    explicit RoomAvatarEvent(const QUrl& mxcUrl, qint64 fileSize = -1,
                              QMimeType mimeType = {},
                              const QSize& imageSize = {},
                              const QString& originalFilename = {})
         : RoomAvatarEvent(EventContent::ImageContent {
-            u, fileSize, mimeType, imageSize, originalFilename })
+            mxcUrl, fileSize, mimeType, imageSize, originalFilename })
     {}
 
     QUrl url() const { return content().url; }
diff --git a/lib/room.cpp b/lib/room.cpp
index 0984bd96..6b729b8f 100644
--- a/lib/room.cpp
+++ b/lib/room.cpp
@@ -306,6 +306,8 @@ public:
         return sendEvent(makeEvent<EventT>(std::forward<ArgTs>(eventArgs)...));
     }
 
+    QString doPostFile(RoomEventPtr &&msgEvent, const QUrl &localUrl);
+
     RoomEvent* addAsPending(RoomEventPtr&& event);
 
     QString doSendEvent(const RoomEvent* pEvent);
@@ -1756,57 +1758,80 @@ QString Room::postReaction(const QString& eventId, const QString& key)
     return d->sendEvent<ReactionEvent>(EventRelation::annotate(eventId, key));
 }
 
-QString Room::postFile(const QString& plainText, const QUrl& localPath,
-                       bool asGenericFile)
+QString Room::Private::doPostFile(RoomEventPtr&& msgEvent, const QUrl& localUrl)
 {
-    QFileInfo localFile { localPath.toLocalFile() };
-    Q_ASSERT(localFile.isFile());
-
-    const auto txnId =
-        d->addAsPending(
-             makeEvent<RoomMessageEvent>(plainText, localFile, asGenericFile))
-            ->transactionId();
+    const auto txnId = addAsPending(move(msgEvent))->transactionId();
     // Remote URL will only be known after upload; fill in the local path
     // to enable the preview while the event is pending.
-    uploadFile(txnId, localPath);
+    q->uploadFile(txnId, localUrl);
     // Below, the upload job is used as a context object to clean up connections
-    const auto& transferJob = d->fileTransfers.value(txnId).job;
-    connect(this, &Room::fileTransferCompleted, transferJob,
-            [this, txnId](const QString& id, const QUrl&, const QUrl& mxcUri) {
-                if (id == txnId) {
-                    auto it = findPendingEvent(txnId);
-                    if (it != d->unsyncedEvents.end()) {
-                        it->setFileUploaded(mxcUri);
-                        emit pendingEventChanged(
-                            int(it - d->unsyncedEvents.begin()));
-                        d->doSendEvent(it->get());
-                    } else {
-                        // Normally in this situation we should instruct
-                        // the media server to delete the file; alas, there's no
-                        // API specced for that.
-                        qCWarning(MAIN) << "File uploaded to" << mxcUri
-                                        << "but the event referring to it was "
-                                           "cancelled";
-                    }
+    const auto& transferJob = fileTransfers.value(txnId).job;
+    connect(q, &Room::fileTransferCompleted, transferJob,
+            [this, txnId](const QString& tId, const QUrl&, const QUrl& mxcUri) {
+                if (tId != txnId)
+                    return;
+
+                const auto it = q->findPendingEvent(txnId);
+                if (it != unsyncedEvents.end()) {
+                    it->setFileUploaded(mxcUri);
+                    emit q->pendingEventChanged(
+                        int(it - unsyncedEvents.begin()));
+                    doSendEvent(it->get());
+                } else {
+                    // Normally in this situation we should instruct
+                    // the media server to delete the file; alas, there's no
+                    // API specced for that.
+                    qCWarning(MAIN) << "File uploaded to" << mxcUri
+                                    << "but the event referring to it was "
+                                       "cancelled";
                 }
             });
-    connect(this, &Room::fileTransferCancelled, transferJob,
-            [this, txnId](const QString& id) {
-                if (id == txnId) {
-                    auto it = findPendingEvent(txnId);
-                    if (it != d->unsyncedEvents.end()) {
-                        const auto idx = int(it - d->unsyncedEvents.begin());
-                        emit pendingEventAboutToDiscard(idx);
-                        // See #286 on why iterator may not be valid here.
-                        d->unsyncedEvents.erase(d->unsyncedEvents.begin() + idx);
-                        emit pendingEventDiscarded();
-                    }
-                }
+    connect(q, &Room::fileTransferCancelled, transferJob,
+            [this, txnId](const QString& tId) {
+                if (tId != txnId)
+                    return;
+
+                const auto it = q->findPendingEvent(txnId);
+                if (it == unsyncedEvents.end())
+                    return;
+
+                const auto idx = int(it - unsyncedEvents.begin());
+                emit q->pendingEventAboutToDiscard(idx);
+                // See #286 on why `it` may not be valid here.
+                unsyncedEvents.erase(unsyncedEvents.begin() + idx);
+                emit q->pendingEventDiscarded();
             });
 
     return txnId;
 }
 
+QString Room::postFile(const QString& plainText,
+                       EventContent::TypedBase* content)
+{
+    Q_ASSERT(content != nullptr && content->fileInfo() != nullptr);
+    const auto* const fileInfo = content->fileInfo();
+    Q_ASSERT(fileInfo != nullptr);
+    QFileInfo localFile { fileInfo->url.toLocalFile() };
+    Q_ASSERT(localFile.isFile());
+
+    return d->doPostFile(
+        makeEvent<RoomMessageEvent>(
+            plainText, RoomMessageEvent::rawMsgTypeForFile(localFile), content),
+        fileInfo->url);
+}
+
+#if QT_VERSION_MAJOR < 6
+QString Room::postFile(const QString& plainText, const QUrl& localPath,
+                       bool asGenericFile)
+{
+    QFileInfo localFile { localPath.toLocalFile() };
+    Q_ASSERT(localFile.isFile());
+    return d->doPostFile(makeEvent<RoomMessageEvent>(plainText, localFile,
+                                                     asGenericFile),
+                         localPath);
+}
+#endif
+
 QString Room::postEvent(RoomEvent* event)
 {
     return d->sendEvent(RoomEventPtr(event));
diff --git a/lib/room.h b/lib/room.h
index 26d0121e..d71bff9c 100644
--- a/lib/room.h
+++ b/lib/room.h
@@ -549,8 +549,13 @@ public Q_SLOTS:
     QString postHtmlText(const QString& plainText, const QString& html);
     /// Send a reaction on a given event with a given key
     QString postReaction(const QString& eventId, const QString& key);
+
+    QString postFile(const QString& plainText, EventContent::TypedBase* content);
+#if QT_VERSION_MAJOR < 6
+    /// \deprecated Use postFile(QString, MessageEventType, EventContent) instead
     QString postFile(const QString& plainText, const QUrl& localPath,
                      bool asGenericFile = false);
+#endif
     /** Post a pre-created room message event
      *
      * Takes ownership of the event, deleting it once the matching one
diff --git a/quotest/quotest.cpp b/quotest/quotest.cpp
index a0914c72..5646d54d 100644
--- a/quotest/quotest.cpp
+++ b/quotest/quotest.cpp
@@ -397,15 +397,16 @@ TEST_IMPL(sendFile)
     }
     tf->write("Test");
     tf->close();
+    QFileInfo tfi { *tf };
     // QFileInfo::fileName brings only the file name; QFile::fileName brings
     // the full path
-    const auto tfName = QFileInfo(*tf).fileName();
+    const auto tfName = tfi.fileName();
     clog << "Sending file " << tfName.toStdString() << endl;
-    const auto txnId =
-        targetRoom->postFile("Test file", QUrl::fromLocalFile(tf->fileName()));
+    const auto txnId = targetRoom->postFile(
+        "Test file", new EventContent::FileContent(tfi));
     if (!validatePendingEvent(txnId)) {
         clog << "Invalid pending event right after submitting" << endl;
-        delete tf;
+        tf->deleteLater();
         FAIL_TEST();
     }
 
-- 
cgit v1.2.3


From 7ee1681d7640b7e7683f7bb40bf768704a48832c Mon Sep 17 00:00:00 2001
From: Alexey Rusakov <Kitsune-Ral@users.sf.net>
Date: Fri, 30 Jul 2021 08:22:13 +0200
Subject: Clean up after the previous commit

RoomAliasesEvent is no more even registered (meaning that the library
will load m.room.aliases as unknown state events); quotest code updated
to use historyEdge() instead of timelineEdge().
---
 lib/events/simplestateevents.h | 1 -
 quotest/quotest.cpp            | 2 +-
 2 files changed, 1 insertion(+), 2 deletions(-)

(limited to 'quotest')

diff --git a/lib/events/simplestateevents.h b/lib/events/simplestateevents.h
index 3bac54e6..cf1bfbba 100644
--- a/lib/events/simplestateevents.h
+++ b/lib/events/simplestateevents.h
@@ -72,5 +72,4 @@ public:
     QString server() const { return stateKey(); }
     QStringList aliases() const { return content().value; }
 };
-REGISTER_EVENT_TYPE(RoomAliasesEvent)
 } // namespace Quotient
diff --git a/quotest/quotest.cpp b/quotest/quotest.cpp
index 5646d54d..ec7d4dcb 100644
--- a/quotest/quotest.cpp
+++ b/quotest/quotest.cpp
@@ -557,7 +557,7 @@ bool TestSuite::checkRedactionOutcome(const QByteArray& thisTest,
     // redacted at the next sync, or the nearest sync completes with
     // the unredacted event but the next one brings redaction.
     auto it = targetRoom->findInTimeline(evtIdToRedact);
-    if (it == targetRoom->timelineEdge())
+    if (it == targetRoom->historyEdge())
         return false; // Waiting for the next sync
 
     if ((*it)->isRedacted()) {
-- 
cgit v1.2.3


From 693b5da2920f173a9e3f723b845d35a7b4aa9823 Mon Sep 17 00:00:00 2001
From: Alexey Rusakov <Kitsune-Ral@users.sf.net>
Date: Sun, 12 Sep 2021 04:35:43 +0200
Subject: Add a download test to quotest

---
 quotest/CMakeLists.txt |  3 ++-
 quotest/quotest.cpp    | 37 +++++++++++++++++++++++++++++++------
 2 files changed, 33 insertions(+), 7 deletions(-)

(limited to 'quotest')

diff --git a/quotest/CMakeLists.txt b/quotest/CMakeLists.txt
index bf9af796..59334e30 100644
--- a/quotest/CMakeLists.txt
+++ b/quotest/CMakeLists.txt
@@ -4,8 +4,9 @@
 
 set(quotest_SRCS quotest.cpp)
 
+find_package(${Qt} COMPONENTS Concurrent)
 add_executable(quotest ${quotest_SRCS})
-target_link_libraries(quotest PRIVATE ${Qt}::Core ${Qt}::Test ${PROJECT_NAME})
+target_link_libraries(quotest PRIVATE ${Qt}::Core ${Qt}::Test ${Qt}::Concurrent ${PROJECT_NAME})
 
 option(${PROJECT_NAME}_INSTALL_TESTS "install quotest (former qmc-example) application" ON)
 add_feature_info(InstallQuotest ${PROJECT_NAME}_INSTALL_TESTS
diff --git a/quotest/quotest.cpp b/quotest/quotest.cpp
index ec7d4dcb..3f886676 100644
--- a/quotest/quotest.cpp
+++ b/quotest/quotest.cpp
@@ -5,6 +5,7 @@
 #include "room.h"
 #include "user.h"
 #include "uriresolver.h"
+#include "networkaccessmanager.h"
 
 #include "csapi/joining.h"
 #include "csapi/leaving.h"
@@ -20,6 +21,8 @@
 #include <QtCore/QStringBuilder>
 #include <QtCore/QTemporaryFile>
 #include <QtCore/QTimer>
+#include <QtConcurrent/QtConcurrent>
+#include <QtNetwork/QNetworkReply>
 
 #include <functional>
 #include <iostream>
@@ -435,6 +438,27 @@ TEST_IMPL(sendFile)
     return false;
 }
 
+bool testDownload(const QUrl& url)
+{
+    // Move out actual test from the multithreaded code
+    // to help debugging
+    auto results =
+        QtConcurrent::blockingMapped(QVector<int> { 1, 2, 3 }, [url](int) {
+            QEventLoop el;
+            auto reply =
+                NetworkAccessManager::instance()->get(QNetworkRequest(url));
+            QObject::connect(
+                reply, &QNetworkReply::finished, &el, [&el] { el.exit(); },
+                Qt::QueuedConnection);
+            el.exec();
+            return reply->error();
+        });
+    return std::all_of(results.cbegin(), results.cend(),
+                        [](QNetworkReply::NetworkError ne) {
+                            return ne == QNetworkReply::NoError;
+                        });
+}
+
 bool TestSuite::checkFileSendingOutcome(const TestToken& thisTest,
                                         const QString& txnId,
                                         const QString& fileName)
@@ -465,14 +489,15 @@ bool TestSuite::checkFileSendingOutcome(const TestToken& thisTest,
             return visit(
                 *evt,
                 [&](const RoomMessageEvent& e) {
-                    // TODO: actually try to download it to check, e.g., #366
-                    // (and #368 would help to test against bad file names).
+                    // TODO: check #366 once #368 is implemented
                     FINISH_TEST(
                         !e.id().isEmpty()
-                            && pendingEvents[size_t(pendingIdx)]->transactionId()
-                                   == txnId
-                            && e.hasFileContent()
-                            && e.content()->fileInfo()->originalName == fileName);
+                        && pendingEvents[size_t(pendingIdx)]->transactionId()
+                               == txnId
+                        && e.hasFileContent()
+                        && e.content()->fileInfo()->originalName == fileName
+                        && testDownload(targetRoom->connection()->makeMediaUrl(
+                            e.content()->fileInfo()->url)));
                 },
                 [this, thisTest](const RoomEvent&) { FAIL_TEST(); });
         });
-- 
cgit v1.2.3


From 167509514587aa22d837b42a8d30d7c1128e0a45 Mon Sep 17 00:00:00 2001
From: Alexey Rusakov <Kitsune-Ral@users.sf.net>
Date: Sun, 12 Sep 2021 04:52:41 +0200
Subject: Fix building with older Qt

---
 quotest/quotest.cpp | 31 ++++++++++++++++++++-----------
 1 file changed, 20 insertions(+), 11 deletions(-)

(limited to 'quotest')

diff --git a/quotest/quotest.cpp b/quotest/quotest.cpp
index 3f886676..31a0b6d6 100644
--- a/quotest/quotest.cpp
+++ b/quotest/quotest.cpp
@@ -438,21 +438,30 @@ TEST_IMPL(sendFile)
     return false;
 }
 
+// Can be replaced with a lambda once QtConcurrent is able to resolve return
+// types from lambda invocations (Qt 6 can, not sure about earlier)
+struct DownloadRunner {
+    QUrl url;
+
+    using result_type = QNetworkReply::NetworkError;
+
+    QNetworkReply::NetworkError operator()(int) const {
+        QEventLoop el;
+        auto reply = NetworkAccessManager::instance()->get(QNetworkRequest(url));
+        QObject::connect(
+            reply, &QNetworkReply::finished, &el, [&el] { el.exit(); },
+            Qt::QueuedConnection);
+        el.exec();
+        return reply->error();
+    }
+};
+
 bool testDownload(const QUrl& url)
 {
     // Move out actual test from the multithreaded code
     // to help debugging
-    auto results =
-        QtConcurrent::blockingMapped(QVector<int> { 1, 2, 3 }, [url](int) {
-            QEventLoop el;
-            auto reply =
-                NetworkAccessManager::instance()->get(QNetworkRequest(url));
-            QObject::connect(
-                reply, &QNetworkReply::finished, &el, [&el] { el.exit(); },
-                Qt::QueuedConnection);
-            el.exec();
-            return reply->error();
-        });
+    auto results = QtConcurrent::blockingMapped(QVector<int> { 1, 2, 3 },
+                                                DownloadRunner { url });
     return std::all_of(results.cbegin(), results.cend(),
                         [](QNetworkReply::NetworkError ne) {
                             return ne == QNetworkReply::NoError;
-- 
cgit v1.2.3


From bcaab611840a0a2ad284e6f1e7c2f0b4de10222d Mon Sep 17 00:00:00 2001
From: Alexey Rusakov <Kitsune-Ral@users.sf.net>
Date: Sun, 12 Sep 2021 05:22:53 +0200
Subject: Fix a memory leak in DownloadRunner

---
 quotest/quotest.cpp | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

(limited to 'quotest')

diff --git a/quotest/quotest.cpp b/quotest/quotest.cpp
index 31a0b6d6..4142c718 100644
--- a/quotest/quotest.cpp
+++ b/quotest/quotest.cpp
@@ -445,11 +445,14 @@ struct DownloadRunner {
 
     using result_type = QNetworkReply::NetworkError;
 
-    QNetworkReply::NetworkError operator()(int) const {
+    QNetworkReply::NetworkError operator()(int) const
+    {
         QEventLoop el;
-        auto reply = NetworkAccessManager::instance()->get(QNetworkRequest(url));
+        QScopedPointer<QNetworkReply, QScopedPointerDeleteLater> reply {
+            NetworkAccessManager::instance()->get(QNetworkRequest(url))
+        };
         QObject::connect(
-            reply, &QNetworkReply::finished, &el, [&el] { el.exit(); },
+            reply.data(), &QNetworkReply::finished, &el, [&el] { el.exit(); },
             Qt::QueuedConnection);
         el.exec();
         return reply->error();
-- 
cgit v1.2.3


From 9f43d34c590a825504b72be7f6b238d0ff2c915a Mon Sep 17 00:00:00 2001
From: Alexey Rusakov <Kitsune-Ral@users.sf.net>
Date: Sun, 12 Sep 2021 04:39:44 +0200
Subject: Use C++ instead of commenting

---
 quotest/quotest.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'quotest')

diff --git a/quotest/quotest.cpp b/quotest/quotest.cpp
index 4142c718..3a77eb01 100644
--- a/quotest/quotest.cpp
+++ b/quotest/quotest.cpp
@@ -51,7 +51,7 @@ private:
     QByteArrayList running {}, succeeded {}, failed {};
 };
 
-using TestToken = QByteArray; // return value of QMetaMethod::name
+using TestToken = decltype(std::declval<QMetaMethod>().name());
 Q_DECLARE_METATYPE(TestToken)
 
 // For now, the token itself is the test name but that may change.
-- 
cgit v1.2.3


From 062d534a0024959117e310f8c2a964434acb9fa0 Mon Sep 17 00:00:00 2001
From: Alexey Rusakov <Kitsune-Ral@users.sf.net>
Date: Mon, 4 Oct 2021 09:53:33 +0200
Subject: Add tests for prettyPrint()

---
 quotest/quotest.cpp | 49 ++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 48 insertions(+), 1 deletion(-)

(limited to 'quotest')

diff --git a/quotest/quotest.cpp b/quotest/quotest.cpp
index 3a77eb01..44d82adf 100644
--- a/quotest/quotest.cpp
+++ b/quotest/quotest.cpp
@@ -108,6 +108,7 @@ private slots:
     TEST_DECL(addAndRemoveTag)
     TEST_DECL(markDirectChat)
     TEST_DECL(visitResources)
+    TEST_DECL(prettyPrintTests)
     // Add more tests above here
 
 public:
@@ -140,7 +141,7 @@ private:
 // connectUntil() to break the QMetaObject::Connection upon finishing the test
 // item.
 #define FINISH_TEST(Condition) \
-    return (finishTest(thisTest, Condition, __FILE__, __LINE__), true)
+    return (finishTest(thisTest, (Condition), __FILE__, __LINE__), true)
 
 #define FAIL_TEST() FINISH_TEST(false)
 
@@ -824,6 +825,52 @@ TEST_IMPL(visitResources)
     FINISH_TEST(true);
 }
 
+bool checkPrettyPrint(
+    std::initializer_list<std::pair<const char*, const char*>> tests)
+{
+    bool result = true;
+    for (const auto& [test, etalon] : tests) {
+        const auto is = prettyPrint(test).toStdString();
+        const auto shouldBe = std::string("<span style='white-space:pre-wrap'>")
+                              + etalon + "</span>";
+        if (is == shouldBe)
+            continue;
+        clog << is << " != " << shouldBe << endl;
+        result = false;
+    }
+    return result;
+}
+
+TEST_IMPL(prettyPrintTests)
+{
+    const bool prettyPrintTestResult = checkPrettyPrint(
+        { { "https://www.matrix.org",
+            R"(<a href="https://www.matrix.org">https://www.matrix.org</a>)" },
+//          { "www.matrix.org", // Doesn't work yet
+//             R"(<a href="https://www.matrix.org">www.matrix.org</a>)" },
+          { "smb://somewhere/file", "smb://somewhere/file" }, // Disallowed scheme
+          { "https:/something", "https:/something" }, // Malformed URL
+          { "https://matrix.to/#/!roomid:example.org",
+            R"(<a href="https://matrix.to/#/!roomid:example.org">https://matrix.to/#/!roomid:example.org</a>)" },
+          { "https://matrix.to/#/@user_id:example.org",
+            R"(<a href="https://matrix.to/#/@user_id:example.org">https://matrix.to/#/@user_id:example.org</a>)" },
+          { "https://matrix.to/#/#roomalias:example.org",
+            R"(<a href="https://matrix.to/#/#roomalias:example.org">https://matrix.to/#/#roomalias:example.org</a>)" },
+          { "https://matrix.to/#/##ircroomalias:example.org",
+            R"(<a href="https://matrix.to/#/##ircroomalias:example.org">https://matrix.to/#/##ircroomalias:example.org</a>)" },
+          { "me@example.org",
+            R"(<a href="mailto:me@example.org">me@example.org</a>)" },
+          { "mailto:me@example.org",
+            R"(<a href="mailto:me@example.org">mailto:me@example.org</a>)" },
+          { "!room_id:example.org",
+            R"(<a href="https://matrix.to/#/!room_id:example.org">!room_id:example.org</a>)" },
+          { "@user_id:example.org",
+            R"(<a href="https://matrix.to/#/@user_id:example.org">@user_id:example.org</a>)" },
+          { "#room_alias:example.org",
+            R"(<a href="https://matrix.to/#/#room_alias:example.org">#room_alias:example.org</a>)" } });
+    FINISH_TEST(prettyPrintTestResult);
+}
+
 void TestManager::conclude()
 {
     // Clean up the room (best effort)
-- 
cgit v1.2.3


From 7b516cdf0b987e542b1e4cd4556ecb2bfbde3ff9 Mon Sep 17 00:00:00 2001
From: Alexey Rusakov <Kitsune-Ral@users.sf.net>
Date: Tue, 5 Oct 2021 03:52:19 +0200
Subject: Quotest: return non-zero when things go really wrong

...such as stuck login or failure to join the room. Closes #496.
---
 quotest/quotest.cpp | 18 +++++++++++++++---
 1 file changed, 15 insertions(+), 3 deletions(-)

(limited to 'quotest')

diff --git a/quotest/quotest.cpp b/quotest/quotest.cpp
index 44d82adf..d006c7fb 100644
--- a/quotest/quotest.cpp
+++ b/quotest/quotest.cpp
@@ -245,7 +245,7 @@ void TestManager::setupAndRun()
             clog << "Sync " << ++i << " complete" << endl;
             if (auto* r = testSuite->room()) {
                 clog << "Test room timeline size = " << r->timelineSize();
-                if (r->pendingEvents().empty())
+                if (!r->pendingEvents().empty())
                     clog << ", pending size = " << r->pendingEvents().size();
                 clog << endl;
             }
@@ -939,10 +939,22 @@ void TestManager::conclude()
 
 void TestManager::finalize()
 {
+    if (!c->isUsable() || !c->isLoggedIn()) {
+        clog << "No usable connection reached" << endl;
+        QCoreApplication::exit(-2);
+        return; // NB: QCoreApplication::exit() does return to the caller
+    }
     clog << "Logging out" << endl;
     c->logout();
-    connect(c, &Connection::loggedOut, this,
-            [this] { QCoreApplication::exit(failed.size() + running.size()); },
+    connect(
+        c, &Connection::loggedOut, this,
+        [this] {
+            QCoreApplication::exit(!testSuite ? -3
+                                   : succeeded.empty() && failed.empty()
+                                           && running.empty()
+                                       ? -4
+                                       : failed.size() + running.size());
+        },
         Qt::QueuedConnection);
 }
 
-- 
cgit v1.2.3


From ae0ad49f36e8ba5983839581302ed16ddbd75d5f Mon Sep 17 00:00:00 2001
From: Alexey Rusakov <Kitsune-Ral@users.sf.net>
Date: Thu, 2 Dec 2021 14:04:49 +0100
Subject: visit(Event, ...) -> switchOnType()

It has not much to do with the Visitor design pattern; also,
std::visit() has different conventions on the order of parameters.
---
 lib/connection.cpp  |  4 ++--
 lib/events/event.h  | 58 ++++++++++++++++++++++++++++++-----------------------
 lib/room.cpp        |  9 +++++----
 quotest/quotest.cpp |  4 ++--
 4 files changed, 42 insertions(+), 33 deletions(-)

(limited to 'quotest')

diff --git a/lib/connection.cpp b/lib/connection.cpp
index e65fdac4..25219def 100644
--- a/lib/connection.cpp
+++ b/lib/connection.cpp
@@ -659,7 +659,7 @@ void Connection::Private::consumeAccountData(Events&& accountDataEvents)
     // After running this loop, the account data events not saved in
     // accountData (see the end of the loop body) are auto-cleaned away
     for (auto&& eventPtr: accountDataEvents) {
-        visit(*eventPtr,
+        switchOnType(*eventPtr,
             [this](const DirectChatEvent& dce) {
                 // https://github.com/quotient-im/libQuotient/wiki/Handling-direct-chat-events
                 const auto& usersToDCs = dce.usersToDirectChats();
@@ -760,7 +760,7 @@ void Connection::Private::consumeToDeviceEvents(Events&& toDeviceEvents)
                       << ee.senderId();
         // encryptionManager->updateDeviceKeys();
 
-        visit(*sessionDecryptMessage(ee),
+        switchOnType(*sessionDecryptMessage(ee),
             [this, senderKey = ee.senderKey()](const RoomKeyEvent& roomKeyEvent) {
                 if (auto* detectedRoom = q->room(roomKeyEvent.roomId()))
                     detectedRoom->handleRoomKeyEvent(roomKeyEvent, senderKey);
diff --git a/lib/events/event.h b/lib/events/event.h
index 998a386c..ce737280 100644
--- a/lib/events/event.h
+++ b/lib/events/event.h
@@ -290,7 +290,7 @@ using Events = EventsArray<Event>;
     }                                                             \
     // End of macro
 
-// === is<>(), eventCast<>() and visit<>() ===
+// === is<>(), eventCast<>() and switchOnType<>() ===
 
 template <class EventT>
 inline bool is(const Event& e)
@@ -312,12 +312,12 @@ inline auto eventCast(const BasePtrT& eptr)
                                            : nullptr;
 }
 
-// A single generic catch-all visitor
+// A trivial generic catch-all "switch"
 template <class BaseEventT, typename FnT>
-inline auto visit(const BaseEventT& event, FnT&& visitor)
-    -> decltype(visitor(event))
+inline auto switchOnType(const BaseEventT& event, FnT&& fn)
+    -> decltype(fn(event))
 {
-    return visitor(event);
+    return fn(event);
 }
 
 namespace _impl {
@@ -328,52 +328,60 @@ namespace _impl {
         && !std::is_same_v<BaseT, std::decay_t<fn_arg_t<FnT>>>;
 }
 
-// A single type-specific void visitor
+// A trivial type-specific "switch" for a void function
 template <class BaseT, typename FnT>
-inline auto visit(const BaseT& event, FnT&& visitor)
+inline auto switchOnType(const BaseT& event, FnT&& fn)
     -> std::enable_if_t<_impl::needs_downcast<BaseT, FnT>
                         && std::is_void_v<fn_return_t<FnT>>>
 {
     using event_type = fn_arg_t<FnT>;
     if (is<std::decay_t<event_type>>(event))
-        visitor(static_cast<event_type>(event));
+        fn(static_cast<event_type>(event));
 }
 
-// A single type-specific non-void visitor with an optional default value
-// non-voidness is guarded by defaultValue type
+// A trivial type-specific "switch" for non-void functions with an optional
+// default value; non-voidness is guarded by defaultValue type
 template <class BaseT, typename FnT>
-inline auto visit(const BaseT& event, FnT&& visitor,
-                  fn_return_t<FnT>&& defaultValue = {})
+inline auto switchOnType(const BaseT& event, FnT&& fn,
+                         fn_return_t<FnT>&& defaultValue = {})
     -> std::enable_if_t<_impl::needs_downcast<BaseT, FnT>, fn_return_t<FnT>>
 {
     using event_type = fn_arg_t<FnT>;
     if (is<std::decay_t<event_type>>(event))
-        return visitor(static_cast<event_type>(event));
-    return std::forward<fn_return_t<FnT>>(defaultValue);
+        return fn(static_cast<event_type>(event));
+    return std::move(defaultValue);
 }
 
-// A chain of 2 or more visitors
+// A switch for a chain of 2 or more functions
 template <class BaseT, typename FnT1, typename FnT2, typename... FnTs>
-inline std::common_type_t<fn_return_t<FnT1>, fn_return_t<FnT2>> visit(
-        const BaseT& event, FnT1&& visitor1, FnT2&& visitor2,
-        FnTs&&... visitors)
+inline std::common_type_t<fn_return_t<FnT1>, fn_return_t<FnT2>>
+switchOnType(const BaseT& event, FnT1&& fn1, FnT2&& fn2, FnTs&&... fns)
 {
     using event_type1 = fn_arg_t<FnT1>;
     if (is<std::decay_t<event_type1>>(event))
-        return visitor1(static_cast<event_type1&>(event));
-    return visit(event, std::forward<FnT2>(visitor2),
-                 std::forward<FnTs>(visitors)...);
+        return fn1(static_cast<event_type1&>(event));
+    return switchOnType(event, std::forward<FnT2>(fn2),
+                        std::forward<FnTs>(fns)...);
 }
 
-// A facility overload that calls void-returning visit() on each event
+template <class BaseT, typename... FnTs>
+[[deprecated("The new name for visit() is switchOnType()")]] //
+inline std::common_type_t<fn_return_t<FnTs>...>
+visit(const BaseT& event, FnTs&&... fns)
+{
+    return switchOnType(event, std::forward<FnTs>(fns)...);
+}
+
+    // A facility overload that calls void-returning switchOnType() on each event
 // over a range of event pointers
+// TODO: replace with ranges::for_each once all standard libraries have it
 template <typename RangeT, typename... FnTs>
-inline auto visitEach(RangeT&& events, FnTs&&... visitors)
+inline auto visitEach(RangeT&& events, FnTs&&... fns)
     -> std::enable_if_t<std::is_void_v<
-            decltype(visit(**begin(events), std::forward<FnTs>(visitors)...))>>
+        decltype(switchOnType(**begin(events), std::forward<FnTs>(fns)...))>>
 {
     for (auto&& evtPtr: events)
-        visit(*evtPtr, std::forward<FnTs>(visitors)...);
+        switchOnType(*evtPtr, std::forward<FnTs>(fns)...);
 }
 } // namespace Quotient
 Q_DECLARE_METATYPE(Quotient::Event*)
diff --git a/lib/room.cpp b/lib/room.cpp
index 4d60570d..b3438e08 100644
--- a/lib/room.cpp
+++ b/lib/room.cpp
@@ -2779,7 +2779,7 @@ Room::Changes Room::processStateEvent(const RoomEvent& e)
     auto& curStateEvent = d->currentState[{ e.matrixType(), e.stateKey() }];
     // Prepare for the state change
     // clang-format off
-    const bool proceed = visit(e
+    const bool proceed = switchOnType(e
         , [this, curStateEvent](const RoomMemberEvent& rme) {
             // clang-format on
             auto* oldRme = static_cast<const RoomMemberEvent*>(curStateEvent);
@@ -2877,7 +2877,7 @@ Room::Changes Room::processStateEvent(const RoomEvent& e)
     // Update internal structures as per the change and work out the return value
 
     // clang-format off
-    const auto result = visit(e
+    const auto result = switchOnType(e
         , [] (const RoomNameEvent&) {
             return Change::Name;
         }
@@ -2885,7 +2885,7 @@ Room::Changes Room::processStateEvent(const RoomEvent& e)
             // clang-format on
             setObjectName(cae.alias().isEmpty() ? d->id : cae.alias());
             const auto* oldCae =
-                    static_cast<const RoomCanonicalAliasEvent*>(oldStateEvent);
+                static_cast<const RoomCanonicalAliasEvent*>(oldStateEvent);
             QStringList previousAltAliases {};
             if (oldCae) {
                 previousAltAliases = oldCae->altAliases();
@@ -2897,7 +2897,8 @@ Room::Changes Room::processStateEvent(const RoomEvent& e)
             if (!cae.alias().isEmpty())
                 newAliases.push_front(cae.alias());
 
-            connection()->updateRoomAliases(id(), previousAltAliases, newAliases);
+            connection()->updateRoomAliases(id(), previousAltAliases,
+                                            newAliases);
             return Change::Aliases;
             // clang-format off
         }
diff --git a/quotest/quotest.cpp b/quotest/quotest.cpp
index d006c7fb..764d5dfd 100644
--- a/quotest/quotest.cpp
+++ b/quotest/quotest.cpp
@@ -498,8 +498,8 @@ bool TestSuite::checkFileSendingOutcome(const TestToken& thisTest,
 
             clog << "File event " << txnId.toStdString()
                  << " arrived in the timeline" << endl;
-            // This part tests visit()
-            return visit(
+            // This part tests switchOnType()
+            return switchOnType(
                 *evt,
                 [&](const RoomMessageEvent& e) {
                     // TODO: check #366 once #368 is implemented
-- 
cgit v1.2.3


From 7981c654c0cd53f6e100ecae25882246a9de5d6e Mon Sep 17 00:00:00 2001
From: Alexey Rusakov <Kitsune-Ral@users.sf.net>
Date: Sun, 5 Dec 2021 21:47:25 +0100
Subject: Drop 'qmc-example' from one last(?) place

---
 quotest/CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'quotest')

diff --git a/quotest/CMakeLists.txt b/quotest/CMakeLists.txt
index 59334e30..8d67b6f1 100644
--- a/quotest/CMakeLists.txt
+++ b/quotest/CMakeLists.txt
@@ -8,7 +8,7 @@ find_package(${Qt} COMPONENTS Concurrent)
 add_executable(quotest ${quotest_SRCS})
 target_link_libraries(quotest PRIVATE ${Qt}::Core ${Qt}::Test ${Qt}::Concurrent ${PROJECT_NAME})
 
-option(${PROJECT_NAME}_INSTALL_TESTS "install quotest (former qmc-example) application" ON)
+option(${PROJECT_NAME}_INSTALL_TESTS "install quotest application" ON)
 add_feature_info(InstallQuotest ${PROJECT_NAME}_INSTALL_TESTS
                  "the library functional test suite")
 
-- 
cgit v1.2.3


From e5256e0b1e4c43ce96d99d1b82ca5d98a1baded6 Mon Sep 17 00:00:00 2001
From: Alexey Rusakov <Kitsune-Ral@users.sf.net>
Date: Fri, 17 Dec 2021 08:07:07 +0100
Subject: RoomMemberEvent: fix an off-by-one error

Also: extended quotest to cover member renames, not just user profile renames.
---
 lib/events/roommemberevent.cpp |  8 +++-----
 quotest/quotest.cpp            | 35 +++++++++++++++++++++++++++--------
 2 files changed, 30 insertions(+), 13 deletions(-)

(limited to 'quotest')

diff --git a/lib/events/roommemberevent.cpp b/lib/events/roommemberevent.cpp
index b0bc7bcb..3141f6b5 100644
--- a/lib/events/roommemberevent.cpp
+++ b/lib/events/roommemberevent.cpp
@@ -48,11 +48,9 @@ void MemberEventContent::fillJson(QJsonObject* o) const
 {
     Q_ASSERT(o);
     if (membership != Membership::Invalid)
-        o->insert(
-            QStringLiteral("membership"),
-            MembershipStrings[qCountTrailingZeroBits(
-                                  std::underlying_type_t<Membership>(membership))
-                              + 1]);
+        o->insert(QStringLiteral("membership"),
+                  MembershipStrings[qCountTrailingZeroBits(
+                      std::underlying_type_t<Membership>(membership))]);
     if (displayName)
         o->insert(QStringLiteral("displayname"), *displayName);
     if (avatarUrl && avatarUrl->isValid())
diff --git a/quotest/quotest.cpp b/quotest/quotest.cpp
index 764d5dfd..8703efb2 100644
--- a/quotest/quotest.cpp
+++ b/quotest/quotest.cpp
@@ -214,6 +214,7 @@ TestManager::TestManager(int& argc, char** argv)
 
     // Big countdown watchdog
     QTimer::singleShot(180000, this, [this] {
+        clog << "Time is up, stopping the session";
         if (testSuite)
             conclude();
         else
@@ -537,14 +538,32 @@ TEST_IMPL(setTopic)
 
 TEST_IMPL(changeName)
 {
-    auto* const localUser = connection()->user();
-    const auto& newName = connection()->generateTxnId(); // See setTopic()
-    clog << "Renaming the user to " << newName.toStdString() << endl;
-    localUser->rename(newName);
-    connectUntil(localUser, &User::defaultNameChanged, this,
-                 [this, thisTest, localUser, newName] {
-                     FINISH_TEST(localUser->name() == newName);
-                 });
+    connectSingleShot(targetRoom, &Room::allMembersLoaded, this, [this, thisTest] {
+        auto* const localUser = connection()->user();
+        const auto& newName = connection()->generateTxnId(); // See setTopic()
+        clog << "Renaming the user to " << newName.toStdString()
+             << " in the target room" << endl;
+        localUser->rename(newName, targetRoom);
+        connectUntil(targetRoom, &Room::memberRenamed, this,
+                     [this, thisTest, localUser, newName](const User* u) {
+                         if (localUser != u)
+                             return false;
+                         if (localUser->name(targetRoom) != newName)
+                             FAIL_TEST();
+
+                         clog
+                             << "Member rename successful, renaming the account"
+                             << endl;
+                         const auto newN = newName.mid(0, 5);
+                         localUser->rename(newN);
+                         connectUntil(localUser, &User::defaultNameChanged,
+                                      this, [this, thisTest, localUser, newN] {
+                                          targetRoom->localUser()->rename({});
+                                          FINISH_TEST(localUser->name() == newN);
+                                      });
+                         return true;
+                     });
+    });
     return false;
 }
 
-- 
cgit v1.2.3


From 24a562cc64e8fac6c55108ae2b7b6997ecdd2010 Mon Sep 17 00:00:00 2001
From: Alexey Rusakov <Kitsune-Ral@users.sf.net>
Date: Sun, 19 Dec 2021 10:43:33 +0100
Subject: Quotest: add a missing \n in the output

---
 quotest/quotest.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'quotest')

diff --git a/quotest/quotest.cpp b/quotest/quotest.cpp
index 8703efb2..7bd9c5c3 100644
--- a/quotest/quotest.cpp
+++ b/quotest/quotest.cpp
@@ -214,7 +214,7 @@ TestManager::TestManager(int& argc, char** argv)
 
     // Big countdown watchdog
     QTimer::singleShot(180000, this, [this] {
-        clog << "Time is up, stopping the session";
+        clog << "Time is up, stopping the session\n";
         if (testSuite)
             conclude();
         else
-- 
cgit v1.2.3


From 53c494f1b9f273395caade35c93e3fb520d083ec Mon Sep 17 00:00:00 2001
From: Alexey Rusakov <Kitsune-Ral@users.sf.net>
Date: Mon, 27 Dec 2021 20:15:47 +0100
Subject: Quotest: add compile warnings from libQuotient

---
 quotest/CMakeLists.txt | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

(limited to 'quotest')

diff --git a/quotest/CMakeLists.txt b/quotest/CMakeLists.txt
index 8d67b6f1..cb41141d 100644
--- a/quotest/CMakeLists.txt
+++ b/quotest/CMakeLists.txt
@@ -8,6 +8,21 @@ find_package(${Qt} COMPONENTS Concurrent)
 add_executable(quotest ${quotest_SRCS})
 target_link_libraries(quotest PRIVATE ${Qt}::Core ${Qt}::Test ${Qt}::Concurrent ${PROJECT_NAME})
 
+if (MSVC)
+    target_compile_options(quotest PUBLIC /EHsc /W4
+        /wd4100 /wd4127 /wd4242 /wd4244 /wd4245 /wd4267 /wd4365 /wd4456 /wd4459
+        /wd4464 /wd4505 /wd4514 /wd4571 /wd4619 /wd4623 /wd4625 /wd4626 /wd4706
+        /wd4710 /wd4774 /wd4820 /wd4946 /wd5026 /wd5027)
+else()
+    foreach (FLAG W Wall Wpedantic Wextra Wno-unused-parameter Werror=return-type)
+        CHECK_CXX_COMPILER_FLAG("-${FLAG}" COMPILER_${FLAG}_SUPPORTED)
+        if (COMPILER_${FLAG}_SUPPORTED AND
+                NOT CMAKE_CXX_FLAGS MATCHES "(^| )-?${FLAG}($| )")
+            target_compile_options(quotest PUBLIC -${FLAG})
+        endif ()
+    endforeach ()
+endif()
+
 option(${PROJECT_NAME}_INSTALL_TESTS "install quotest application" ON)
 add_feature_info(InstallQuotest ${PROJECT_NAME}_INSTALL_TESTS
                  "the library functional test suite")
-- 
cgit v1.2.3


From 02fdd08b98d878168eb81376a44586176dfd9576 Mon Sep 17 00:00:00 2001
From: Alexey Rusakov <Kitsune-Ral@users.sf.net>
Date: Sun, 26 Dec 2021 10:40:56 +0100
Subject: Quotest: test sending and receiving custom events

This seems to be the crux of #413.
---
 quotest/quotest.cpp | 57 ++++++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 52 insertions(+), 5 deletions(-)

(limited to 'quotest')

diff --git a/quotest/quotest.cpp b/quotest/quotest.cpp
index 7bd9c5c3..5a5642fe 100644
--- a/quotest/quotest.cpp
+++ b/quotest/quotest.cpp
@@ -101,6 +101,7 @@ private slots:
     TEST_DECL(sendMessage)
     TEST_DECL(sendReaction)
     TEST_DECL(sendFile)
+    TEST_DECL(sendCustomEvent)
     TEST_DECL(setTopic)
     TEST_DECL(changeName)
     TEST_DECL(sendAndRedact)
@@ -125,6 +126,7 @@ private:
     [[nodiscard]] bool checkRedactionOutcome(const QByteArray& thisTest,
                                              const QString& evtIdToRedact);
 
+    template <class EventT>
     [[nodiscard]] bool validatePendingEvent(const QString& txnId);
     [[nodiscard]] bool checkDirectChat() const;
     void finishTest(const TestToken& token, bool condition, const char* file,
@@ -152,12 +154,14 @@ void TestSuite::doTest(const QByteArray& testName)
                               Q_ARG(TestToken, testName));
 }
 
+template <class EventT>
 bool TestSuite::validatePendingEvent(const QString& txnId)
 {
     auto it = targetRoom->findPendingEvent(txnId);
     return it != targetRoom->pendingEvents().end()
            && it->deliveryStatus() == EventStatus::Submitted
-           && (*it)->transactionId() == txnId;
+           && (*it)->transactionId() == txnId && is<EventT>(**it)
+           && (*it)->matrixType() == EventT::matrixTypeId();
 }
 
 void TestSuite::finishTest(const TestToken& token, bool condition,
@@ -341,7 +345,7 @@ TEST_IMPL(loadMembers)
 TEST_IMPL(sendMessage)
 {
     auto txnId = targetRoom->postPlainText("Hello, " % origin % " is here");
-    if (!validatePendingEvent(txnId)) {
+    if (!validatePendingEvent<RoomMessageEvent>(txnId)) {
         clog << "Invalid pending event right after submitting" << endl;
         FAIL_TEST();
     }
@@ -367,7 +371,7 @@ TEST_IMPL(sendReaction)
     const auto targetEvtId = targetRoom->messageEvents().back()->id();
     const auto key = QStringLiteral("+1");
     const auto txnId = targetRoom->postReaction(targetEvtId, key);
-    if (!validatePendingEvent(txnId)) {
+    if (!validatePendingEvent<ReactionEvent>(txnId)) {
         clog << "Invalid pending event right after submitting" << endl;
         FAIL_TEST();
     }
@@ -409,7 +413,7 @@ TEST_IMPL(sendFile)
     clog << "Sending file " << tfName.toStdString() << endl;
     const auto txnId = targetRoom->postFile(
         "Test file", new EventContent::FileContent(tfi));
-    if (!validatePendingEvent(txnId)) {
+    if (!validatePendingEvent<RoomMessageEvent>(txnId)) {
         clog << "Invalid pending event right after submitting" << endl;
         tf->deleteLater();
         FAIL_TEST();
@@ -518,6 +522,50 @@ bool TestSuite::checkFileSendingOutcome(const TestToken& thisTest,
     return true;
 }
 
+class CustomEvent : public RoomEvent {
+public:
+    DEFINE_EVENT_TYPEID("quotest.custom", CustomEvent)
+
+    CustomEvent(const QJsonObject& jo)
+        : RoomEvent(typeId(), jo)
+    {}
+    CustomEvent(int testValue)
+        : RoomEvent(typeId(),
+                    basicEventJson(matrixTypeId(),
+                                   QJsonObject { { "testValue"_ls,
+                                                   toJson(testValue) } }))
+    {}
+
+    auto testValue() const { return contentPart<int>("testValue"_ls); }
+};
+REGISTER_EVENT_TYPE(CustomEvent)
+
+TEST_IMPL(sendCustomEvent)
+{
+    auto txnId = targetRoom->postEvent(new CustomEvent(42));
+    if (!validatePendingEvent<CustomEvent>(txnId)) {
+        clog << "Invalid pending event right after submitting" << endl;
+        FAIL_TEST();
+    }
+    connectUntil(
+        targetRoom, &Room::pendingEventAboutToMerge, this,
+        [this, thisTest, txnId](const RoomEvent* evt, int pendingIdx) {
+            const auto& pendingEvents = targetRoom->pendingEvents();
+            Q_ASSERT(pendingIdx >= 0 && pendingIdx < int(pendingEvents.size()));
+
+            if (evt->transactionId() != txnId)
+                return false;
+
+            return switchOnType(*evt,
+                [this, thisTest, &evt](const CustomEvent& e) {
+                    FINISH_TEST(!evt->id().isEmpty() && e.testValue() == 42);
+                },
+                [this, thisTest] (const RoomEvent&) { FAIL_TEST(); });
+        });
+    return false;
+
+}
+
 TEST_IMPL(setTopic)
 {
     const auto newTopic = connection()->generateTxnId(); // Just a way to make
@@ -567,7 +615,6 @@ TEST_IMPL(changeName)
     return false;
 }
 
-
 TEST_IMPL(showLocalUsername)
 {
     auto* const localUser = connection()->user();
-- 
cgit v1.2.3


From 39b50a13a0379ea32be114c85f3c697d75d4e03b Mon Sep 17 00:00:00 2001
From: Alexey Rusakov <Kitsune-Ral@users.sf.net>
Date: Wed, 29 Dec 2021 21:22:26 +0100
Subject: Quotest: build with hidden visibility too

---
 quotest/CMakeLists.txt | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'quotest')

diff --git a/quotest/CMakeLists.txt b/quotest/CMakeLists.txt
index cb41141d..ec305620 100644
--- a/quotest/CMakeLists.txt
+++ b/quotest/CMakeLists.txt
@@ -8,6 +8,11 @@ find_package(${Qt} COMPONENTS Concurrent)
 add_executable(quotest ${quotest_SRCS})
 target_link_libraries(quotest PRIVATE ${Qt}::Core ${Qt}::Test ${Qt}::Concurrent ${PROJECT_NAME})
 
+set_target_properties(quotest PROPERTIES
+    VISIBILITY_INLINES_HIDDEN ON
+    CXX_VISIBILITY_PRESET hidden
+)
+
 if (MSVC)
     target_compile_options(quotest PUBLIC /EHsc /W4
         /wd4100 /wd4127 /wd4242 /wd4244 /wd4245 /wd4267 /wd4365 /wd4456 /wd4459
-- 
cgit v1.2.3


From fdff209744ac4c422f63fe2549aa0132df7e6292 Mon Sep 17 00:00:00 2001
From: Alexey Rusakov <Kitsune-Ral@users.sf.net>
Date: Fri, 21 Jan 2022 02:04:10 +0100
Subject: Redo EventRelation; deprecate RelatesTo

RelatesTo and EventRelation have been two means to the same end in two
different contexts. (Modernised) EventRelation is the one used now both
for ReactionEvent and EventContent::TextContent. The modernisation
mostly boils down to using inline variables instead of functions to
return relation types and switching to QLatin1String from const char*
(because we know exactly that those constants are Latin-1 and
QLatin1String is more efficient than const char* to compare/convert to
QString).
---
 CMakeLists.txt                  |  3 ++-
 lib/events/eventrelation.cpp    | 38 ++++++++++++++++++++++++++++++
 lib/events/eventrelation.h      | 52 +++++++++++++++++++++++++++++++++++++++++
 lib/events/reactionevent.cpp    | 29 -----------------------
 lib/events/reactionevent.h      | 32 ++-----------------------
 lib/events/roommessageevent.cpp | 38 ++++++++----------------------
 lib/events/roommessageevent.h   | 27 +++++++++++----------
 lib/room.cpp                    | 11 ++++-----
 lib/room.h                      |  5 ++--
 quotest/quotest.cpp             |  2 +-
 10 files changed, 128 insertions(+), 109 deletions(-)
 create mode 100644 lib/events/eventrelation.cpp
 create mode 100644 lib/events/eventrelation.h
 delete mode 100644 lib/events/reactionevent.cpp

(limited to 'quotest')

diff --git a/CMakeLists.txt b/CMakeLists.txt
index fd5f1dca..df193b94 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -153,6 +153,7 @@ list(APPEND lib_SRCS
     lib/events/stateevent.h lib/events/stateevent.cpp
     lib/events/simplestateevents.h
     lib/events/eventcontent.h lib/events/eventcontent.cpp
+    lib/events/eventrelation.h lib/events/eventrelation.cpp
     lib/events/roomcreateevent.h lib/events/roomcreateevent.cpp
     lib/events/roomtombstoneevent.h lib/events/roomtombstoneevent.cpp
     lib/events/roommessageevent.h lib/events/roommessageevent.cpp
@@ -162,7 +163,7 @@ list(APPEND lib_SRCS
     lib/events/typingevent.h lib/events/typingevent.cpp
     lib/events/accountdataevents.h
     lib/events/receiptevent.h lib/events/receiptevent.cpp
-    lib/events/reactionevent.h lib/events/reactionevent.cpp
+    lib/events/reactionevent.h
     lib/events/callinviteevent.h lib/events/callinviteevent.cpp
     lib/events/callcandidatesevent.h
     lib/events/callanswerevent.h lib/events/callanswerevent.cpp
diff --git a/lib/events/eventrelation.cpp b/lib/events/eventrelation.cpp
new file mode 100644
index 00000000..04972f45
--- /dev/null
+++ b/lib/events/eventrelation.cpp
@@ -0,0 +1,38 @@
+// SPDX-FileCopyrightText: 2022 Kitsune Ral <kitsune-ral@users.sf.net>
+// SPDX-License-Identifier: LGPL-2.1-or-later
+
+#include "eventrelation.h"
+
+#include "../logging.h"
+#include "event.h"
+
+using namespace Quotient;
+
+void JsonObjectConverter<EventRelation>::dumpTo(QJsonObject& jo,
+                                                const EventRelation& pod)
+{
+    if (pod.type.isEmpty()) {
+        qCWarning(MAIN) << "Empty relation type; won't dump to JSON";
+        return;
+    }
+    jo.insert(RelTypeKey, pod.type);
+    jo.insert(EventIdKey, pod.eventId);
+    if (pod.type == EventRelation::AnnotationType)
+        jo.insert(QStringLiteral("key"), pod.key);
+}
+
+void JsonObjectConverter<EventRelation>::fillFrom(const QJsonObject& jo,
+                                                  EventRelation& pod)
+{
+    if (const auto replyJson = jo.value(EventRelation::ReplyType).toObject();
+        !replyJson.isEmpty()) {
+        pod.type = EventRelation::ReplyType;
+        fromJson(replyJson[EventIdKeyL], pod.eventId);
+    } else {
+        // The experimental logic for generic relationships (MSC1849)
+        fromJson(jo[RelTypeKey], pod.type);
+        fromJson(jo[EventIdKeyL], pod.eventId);
+        if (pod.type == EventRelation::AnnotationType)
+            fromJson(jo["key"_ls], pod.key);
+    }
+}
diff --git a/lib/events/eventrelation.h b/lib/events/eventrelation.h
new file mode 100644
index 00000000..e445ee42
--- /dev/null
+++ b/lib/events/eventrelation.h
@@ -0,0 +1,52 @@
+// SPDX-FileCopyrightText: 2022 Kitsune Ral <kitsune-ral@users.sf.net>
+// SPDX-License-Identifier: LGPL-2.1-or-later
+
+#pragma once
+
+#include "converters.h"
+
+namespace Quotient {
+
+[[maybe_unused]] constexpr auto RelatesToKey = "m.relates_to"_ls;
+constexpr auto RelTypeKey = "rel_type"_ls;
+
+struct QUOTIENT_API EventRelation {
+    using reltypeid_t = QLatin1String;
+
+    QString type;
+    QString eventId;
+    QString key = {}; // Only used for m.annotation for now
+
+    static constexpr auto ReplyType = "m.in_reply_to"_ls;
+    static constexpr auto AnnotationType = "m.annotation"_ls;
+    static constexpr auto ReplacementType = "m.replace"_ls;
+
+    static EventRelation replyTo(QString eventId)
+    {
+        return { ReplyType, std::move(eventId) };
+    }
+    static EventRelation annotate(QString eventId, QString key)
+    {
+        return { AnnotationType, std::move(eventId), std::move(key) };
+    }
+    static EventRelation replace(QString eventId)
+    {
+        return { ReplacementType, std::move(eventId) };
+    }
+
+    [[deprecated("Use ReplyRelation variable instead")]]
+    static constexpr auto Reply() { return ReplyType; }
+    [[deprecated("Use AnnotationRelation variable instead")]] //
+    static constexpr auto Annotation() { return AnnotationType; }
+    [[deprecated("Use ReplacementRelation variable instead")]] //
+    static constexpr auto Replacement() { return ReplacementType; }
+};
+
+template <>
+struct QUOTIENT_API JsonObjectConverter<EventRelation> {
+    static void dumpTo(QJsonObject& jo, const EventRelation& pod);
+    static void fillFrom(const QJsonObject& jo, EventRelation& pod);
+};
+
+}
+
diff --git a/lib/events/reactionevent.cpp b/lib/events/reactionevent.cpp
deleted file mode 100644
index b53fffd6..00000000
--- a/lib/events/reactionevent.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-// SPDX-FileCopyrightText: 2019 Kitsune Ral <kitsune-ral@users.sf.net>
-// SPDX-License-Identifier: LGPL-2.1-or-later
-
-#include "reactionevent.h"
-
-using namespace Quotient;
-
-void JsonObjectConverter<EventRelation>::dumpTo(
-    QJsonObject& jo, const EventRelation& pod)
-{
-    if (pod.type.isEmpty()) {
-        qCWarning(MAIN) << "Empty relation type; won't dump to JSON";
-        return;
-    }
-    jo.insert(QStringLiteral("rel_type"), pod.type);
-    jo.insert(EventIdKey, pod.eventId);
-    if (pod.type == EventRelation::Annotation())
-        jo.insert(QStringLiteral("key"), pod.key);
-}
-
-void JsonObjectConverter<EventRelation>::fillFrom(
-    const QJsonObject& jo, EventRelation& pod)
-{
-    // The experimental logic for generic relationships (MSC1849)
-    fromJson(jo["rel_type"_ls], pod.type);
-    fromJson(jo[EventIdKeyL], pod.eventId);
-    if (pod.type == EventRelation::Annotation())
-        fromJson(jo["key"_ls], pod.key);
-}
diff --git a/lib/events/reactionevent.h b/lib/events/reactionevent.h
index ce11eaed..b3cb3ca7 100644
--- a/lib/events/reactionevent.h
+++ b/lib/events/reactionevent.h
@@ -4,38 +4,10 @@
 #pragma once
 
 #include "roomevent.h"
+#include "eventrelation.h"
 
 namespace Quotient {
 
-struct QUOTIENT_API EventRelation {
-    using reltypeid_t = const char*;
-    static constexpr reltypeid_t Reply() { return "m.in_reply_to"; }
-    static constexpr reltypeid_t Annotation() { return "m.annotation"; }
-    static constexpr reltypeid_t Replacement() { return "m.replace"; }
-
-    QString type;
-    QString eventId;
-    QString key = {}; // Only used for m.annotation for now
-
-    static EventRelation replyTo(QString eventId)
-    {
-        return { Reply(), std::move(eventId) };
-    }
-    static EventRelation annotate(QString eventId, QString key)
-    {
-        return { Annotation(), std::move(eventId), std::move(key) };
-    }
-    static EventRelation replace(QString eventId)
-    {
-        return { Replacement(), std::move(eventId) };
-    }
-};
-template <>
-struct QUOTIENT_API JsonObjectConverter<EventRelation> {
-    static void dumpTo(QJsonObject& jo, const EventRelation& pod);
-    static void fillFrom(const QJsonObject& jo, EventRelation& pod);
-};
-
 class QUOTIENT_API ReactionEvent : public RoomEvent {
 public:
     DEFINE_EVENT_TYPEID("m.reaction", ReactionEvent)
@@ -47,7 +19,7 @@ public:
     explicit ReactionEvent(const QJsonObject& obj) : RoomEvent(typeId(), obj) {}
     EventRelation relation() const
     {
-        return contentPart<EventRelation>("m.relates_to"_ls);
+        return contentPart<EventRelation>(RelatesToKey);
     }
 };
 REGISTER_EVENT_TYPE(ReactionEvent)
diff --git a/lib/events/roommessageevent.cpp b/lib/events/roommessageevent.cpp
index 5ab0f845..c07a4f3c 100644
--- a/lib/events/roommessageevent.cpp
+++ b/lib/events/roommessageevent.cpp
@@ -6,6 +6,7 @@
 #include "roommessageevent.h"
 
 #include "logging.h"
+#include "events/eventrelation.h"
 
 #include <QtCore/QFileInfo>
 #include <QtCore/QMimeDatabase>
@@ -20,7 +21,6 @@ using namespace EventContent;
 using MsgType = RoomMessageEvent::MsgType;
 
 namespace { // Supporting internal definitions
-
 constexpr auto RelatesToKey = "m.relates_to"_ls;
 constexpr auto MsgTypeKey = "msgtype"_ls;
 constexpr auto FormattedBodyKey = "formatted_body"_ls;
@@ -84,9 +84,9 @@ MsgType jsonToMsgType(const QString& matrixType)
     return MsgType::Unknown;
 }
 
-inline bool isReplacement(const Omittable<RelatesTo>& rel)
+inline bool isReplacement(const Omittable<EventRelation>& rel)
 {
-    return rel && rel->type == RelatesTo::ReplacementTypeId();
+    return rel && rel->type == EventRelation::ReplacementType;
 }
 
 } // anonymous namespace
@@ -105,10 +105,10 @@ QJsonObject RoomMessageEvent::assembleContentJson(const QString& plainBody,
                 << "messages; the relation has been stripped off";
         } else {
             // After the above, we know for sure that the content is TextContent
-            // and that its RelatesTo structure is not omitted
+            // and that its EventRelation structure is not omitted
             auto* textContent = static_cast<const TextContent*>(content);
             Q_ASSERT(textContent && textContent->relatesTo.has_value());
-            if (textContent->relatesTo->type == RelatesTo::ReplacementTypeId()) {
+            if (textContent->relatesTo->type == EventRelation::ReplacementType) {
                 auto newContentJson = json.take("m.new_content"_ls).toObject();
                 newContentJson.insert(BodyKey, plainBody);
                 newContentJson.insert(MsgTypeKey, jsonMsgType);
@@ -269,7 +269,7 @@ QString RoomMessageEvent::rawMsgTypeForFile(const QFileInfo& fi)
 }
 
 TextContent::TextContent(QString text, const QString& contentType,
-                         Omittable<RelatesTo> relatesTo)
+                         Omittable<EventRelation> relatesTo)
     : mimeType(QMimeDatabase().mimeTypeForName(contentType))
     , body(std::move(text))
     , relatesTo(std::move(relatesTo))
@@ -278,26 +278,8 @@ TextContent::TextContent(QString text, const QString& contentType,
         mimeType = QMimeDatabase().mimeTypeForName("text/html");
 }
 
-namespace Quotient {
-// Overload the default fromJson<> logic that defined in converters.h
-// as we want
-template <>
-Omittable<RelatesTo> fromJson(const QJsonValue& jv)
-{
-    const auto jo = jv.toObject();
-    if (jo.isEmpty())
-        return none;
-    const auto replyJson = jo.value(RelatesTo::ReplyTypeId()).toObject();
-    if (!replyJson.isEmpty())
-        return replyTo(fromJson<QString>(replyJson[EventIdKeyL]));
-
-    return RelatesTo { jo.value("rel_type"_ls).toString(),
-                       jo.value(EventIdKeyL).toString() };
-}
-} // namespace Quotient
-
 TextContent::TextContent(const QJsonObject& json)
-    : relatesTo(fromJson<Omittable<RelatesTo>>(json[RelatesToKey]))
+    : relatesTo(fromJson<Omittable<EventRelation>>(json[RelatesToKey]))
 {
     QMimeDatabase db;
     static const auto PlainTextMimeType = db.mimeTypeForName("text/plain");
@@ -331,13 +313,13 @@ void TextContent::fillJson(QJsonObject* json) const
     if (relatesTo) {
         json->insert(
             QStringLiteral("m.relates_to"),
-            relatesTo->type == RelatesTo::ReplyTypeId()
+            relatesTo->type == EventRelation::ReplyType
                 ? QJsonObject { { relatesTo->type,
                                   QJsonObject {
                                       { EventIdKey, relatesTo->eventId } } } }
-                : QJsonObject { { "rel_type", relatesTo->type },
+                : QJsonObject { { RelTypeKey, relatesTo->type },
                                 { EventIdKey, relatesTo->eventId } });
-        if (relatesTo->type == RelatesTo::ReplacementTypeId()) {
+        if (relatesTo->type == EventRelation::ReplacementType) {
             QJsonObject newContentJson;
             if (mimeType.inherits("text/html")) {
                 newContentJson.insert(FormatKey, HtmlContentTypeId);
diff --git a/lib/events/roommessageevent.h b/lib/events/roommessageevent.h
index 0c901b7a..44ef05fb 100644
--- a/lib/events/roommessageevent.h
+++ b/lib/events/roommessageevent.h
@@ -6,6 +6,7 @@
 #pragma once
 
 #include "eventcontent.h"
+#include "eventrelation.h"
 #include "roomevent.h"
 
 class QFileInfo;
@@ -97,23 +98,25 @@ REGISTER_EVENT_TYPE(RoomMessageEvent)
 using MessageEventType = RoomMessageEvent::MsgType;
 
 namespace EventContent {
-    // Additional event content types
 
-    struct RelatesTo {
-        static constexpr const char* ReplyTypeId() { return "m.in_reply_to"; }
-        static constexpr const char* ReplacementTypeId() { return "m.replace"; }
-        QString type; // The only supported relation so far
-        QString eventId;
+    struct [[deprecated("Use Quotient::EventRelation instead")]] RelatesTo
+        : EventRelation {
+        static constexpr auto ReplyTypeId() { return Reply(); }
+        static constexpr auto ReplacementTypeId() { return Replacement(); }
     };
-    inline RelatesTo replyTo(QString eventId)
+    [[deprecated("Use EventRelation::replyTo() instead")]]
+    inline auto replyTo(QString eventId)
     {
-        return { RelatesTo::ReplyTypeId(), std::move(eventId) };
+        return EventRelation::replyTo(std::move(eventId));
     }
-    inline RelatesTo replacementOf(QString eventId)
+    [[deprecated("Use EventRelation::replace() instead")]]
+    inline auto replacementOf(QString eventId)
     {
-        return { RelatesTo::ReplacementTypeId(), std::move(eventId) };
+        return EventRelation::replace(std::move(eventId));
     }
 
+    // Additional event content types
+
     /**
      * Rich text content for m.text, m.emote, m.notice
      *
@@ -123,14 +126,14 @@ namespace EventContent {
     class QUOTIENT_API TextContent : public TypedBase {
     public:
         TextContent(QString text, const QString& contentType,
-                    Omittable<RelatesTo> relatesTo = none);
+                    Omittable<EventRelation> relatesTo = none);
         explicit TextContent(const QJsonObject& json);
 
         QMimeType type() const override { return mimeType; }
 
         QMimeType mimeType;
         QString body;
-        Omittable<RelatesTo> relatesTo;
+        Omittable<EventRelation> relatesTo;
 
     protected:
         void fillJson(QJsonObject* json) const override;
diff --git a/lib/room.cpp b/lib/room.cpp
index 55efb5b9..ba63f50d 100644
--- a/lib/room.cpp
+++ b/lib/room.cpp
@@ -996,14 +996,14 @@ Room::findPendingEvent(const QString& txnId) const
                         });
 }
 
-const Room::RelatedEvents Room::relatedEvents(const QString& evtId,
-                                              const char* relType) const
+const Room::RelatedEvents Room::relatedEvents(
+    const QString& evtId, EventRelation::reltypeid_t relType) const
 {
     return d->relations.value({ evtId, relType });
 }
 
-const Room::RelatedEvents Room::relatedEvents(const RoomEvent& evt,
-                                              const char* relType) const
+const Room::RelatedEvents Room::relatedEvents(
+    const RoomEvent& evt, EventRelation::reltypeid_t relType) const
 {
     return relatedEvents(evt.id(), relType);
 }
@@ -2506,8 +2506,7 @@ bool Room::Private::processRedaction(const RedactionEvent& redaction)
     }
     if (const auto* reaction = eventCast<ReactionEvent>(oldEvent)) {
         const auto& targetEvtId = reaction->relation().eventId;
-        const auto lookupKey =
-            qMakePair(targetEvtId, EventRelation::Annotation());
+        const QPair lookupKey { targetEvtId, EventRelation::AnnotationType };
         if (relations.contains(lookupKey)) {
             relations[lookupKey].removeOne(reaction);
             emit q->updatedEvent(targetEvtId);
diff --git a/lib/room.h b/lib/room.h
index 61f475e8..15bc7648 100644
--- a/lib/room.h
+++ b/lib/room.h
@@ -21,6 +21,7 @@
 #include "events/roommessageevent.h"
 #include "events/roomcreateevent.h"
 #include "events/roomtombstoneevent.h"
+#include "events/eventrelation.h"
 
 #include <QtCore/QJsonObject>
 #include <QtGui/QImage>
@@ -394,9 +395,9 @@ public:
     PendingEvents::const_iterator findPendingEvent(const QString& txnId) const;
 
     const RelatedEvents relatedEvents(const QString& evtId,
-                                      const char* relType) const;
+                                      EventRelation::reltypeid_t relType) const;
     const RelatedEvents relatedEvents(const RoomEvent& evt,
-                                      const char* relType) const;
+                                      EventRelation::reltypeid_t relType) const;
 
     const RoomCreateEvent* creation() const
     {
diff --git a/quotest/quotest.cpp b/quotest/quotest.cpp
index 5a5642fe..40bc456b 100644
--- a/quotest/quotest.cpp
+++ b/quotest/quotest.cpp
@@ -381,7 +381,7 @@ TEST_IMPL(sendReaction)
             if (actualTargetEvtId != targetEvtId)
                 return false;
             const auto reactions = targetRoom->relatedEvents(
-                targetEvtId, EventRelation::Annotation());
+                targetEvtId, EventRelation::AnnotationType);
             // It's a test room, assuming no interference there should
             // be exactly one reaction
             if (reactions.size() != 1)
-- 
cgit v1.2.3


From 63c953800330017ebb2afbabf41e5c4932c4d640 Mon Sep 17 00:00:00 2001
From: Alexey Rusakov <Kitsune-Ral@users.sf.net>
Date: Sat, 22 Jan 2022 13:43:15 +0100
Subject: Quotest: fix changeName test

This test was very unreliable because memberRenamed() signal was emitted
upon lazy-loading of past member renames. The new code connects to
aboutToAddNewMessages() instead, which should only contain the latest
renaming event (past events are delivered in the 'state' object).
---
 quotest/quotest.cpp | 43 +++++++++++++++++++++++++------------------
 1 file changed, 25 insertions(+), 18 deletions(-)

(limited to 'quotest')

diff --git a/quotest/quotest.cpp b/quotest/quotest.cpp
index 40bc456b..792faabd 100644
--- a/quotest/quotest.cpp
+++ b/quotest/quotest.cpp
@@ -14,6 +14,7 @@
 #include "events/reactionevent.h"
 #include "events/redactionevent.h"
 #include "events/simplestateevents.h"
+#include "events/roommemberevent.h"
 
 #include <QtTest/QSignalSpy>
 #include <QtCore/QCoreApplication>
@@ -592,25 +593,31 @@ TEST_IMPL(changeName)
         clog << "Renaming the user to " << newName.toStdString()
              << " in the target room" << endl;
         localUser->rename(newName, targetRoom);
-        connectUntil(targetRoom, &Room::memberRenamed, this,
-                     [this, thisTest, localUser, newName](const User* u) {
-                         if (localUser != u)
-                             return false;
-                         if (localUser->name(targetRoom) != newName)
-                             FAIL_TEST();
-
-                         clog
-                             << "Member rename successful, renaming the account"
+        connectUntil(
+            targetRoom, &Room::aboutToAddNewMessages, this,
+            [this, thisTest, localUser, newName](const RoomEventsRange& evts) {
+                for (const auto& e : evts) {
+                    if (const auto* rme = eventCast<const RoomMemberEvent>(e)) {
+                        if (rme->stateKey() != localUser->id()
+                            || !rme->isRename())
+                            continue;
+                        if (!rme->newDisplayName()
+                            || *rme->newDisplayName() != newName)
+                            FAIL_TEST();
+                        clog << "Member rename successful, renaming the account"
                              << endl;
-                         const auto newN = newName.mid(0, 5);
-                         localUser->rename(newN);
-                         connectUntil(localUser, &User::defaultNameChanged,
-                                      this, [this, thisTest, localUser, newN] {
-                                          targetRoom->localUser()->rename({});
-                                          FINISH_TEST(localUser->name() == newN);
-                                      });
-                         return true;
-                     });
+                        const auto newN = newName.mid(0, 5);
+                        localUser->rename(newN);
+                        connectUntil(localUser, &User::defaultNameChanged, this,
+                                     [this, thisTest, localUser, newN] {
+                                         targetRoom->localUser()->rename({});
+                                         FINISH_TEST(localUser->name() == newN);
+                                     });
+                        return true;
+                    }
+                }
+                return false;
+            });
     });
     return false;
 }
-- 
cgit v1.2.3


From 843f7a0ac2619a2f2863d457cdeaa03707255793 Mon Sep 17 00:00:00 2001
From: Alexey Rusakov <Kitsune-Ral@users.sf.net>
Date: Wed, 4 May 2022 21:12:29 +0200
Subject: basic*EventJson() -> *Event::basicJson()

This makes it easier and more intuitive to build a minimal JSON payload
for a given event type. A common basicJson() call point is also
convenient in template contexts (see next commits).
---
 lib/connection.cpp        |  4 ++--
 lib/events/event.cpp      |  2 +-
 lib/events/event.h        | 14 +++++++-------
 lib/events/eventloader.h  |  4 ++--
 lib/events/roomevent.cpp  | 10 +++++-----
 lib/events/roomevent.h    |  5 +++++
 lib/events/stateevent.cpp |  2 +-
 lib/events/stateevent.h   | 28 ++++++++++++++++++----------
 quotest/quotest.cpp       |  8 ++++----
 9 files changed, 45 insertions(+), 32 deletions(-)

(limited to 'quotest')

diff --git a/lib/connection.cpp b/lib/connection.cpp
index a969b3b9..1ea394a1 100644
--- a/lib/connection.cpp
+++ b/lib/connection.cpp
@@ -1858,11 +1858,11 @@ void Connection::saveState() const
     }
     {
         QJsonArray accountDataEvents {
-            basicEventJson(QStringLiteral("m.direct"), toJson(d->directChats))
+            Event::basicJson(QStringLiteral("m.direct"), toJson(d->directChats))
         };
         for (const auto& e : d->accountData)
             accountDataEvents.append(
-                basicEventJson(e.first, e.second->contentJson()));
+                Event::basicJson(e.first, e.second->contentJson()));
 
         rootObj.insert(QStringLiteral("account_data"),
                        QJsonObject {
diff --git a/lib/events/event.cpp b/lib/events/event.cpp
index 4c304a3c..1f1eebaa 100644
--- a/lib/events/event.cpp
+++ b/lib/events/event.cpp
@@ -29,7 +29,7 @@ Event::Event(Type type, const QJsonObject& json) : _type(type), _json(json)
 }
 
 Event::Event(Type type, event_mtype_t matrixType, const QJsonObject& contentJson)
-    : Event(type, basicEventJson(matrixType, contentJson))
+    : Event(type, basicJson(matrixType, contentJson))
 {}
 
 Event::~Event() = default;
diff --git a/lib/events/event.h b/lib/events/event.h
index 113fa3fa..5be2b41b 100644
--- a/lib/events/event.h
+++ b/lib/events/event.h
@@ -48,13 +48,6 @@ const QString RoomIdKey { RoomIdKeyL };
 const QString UnsignedKey { UnsignedKeyL };
 const QString StateKeyKey { StateKeyKeyL };
 
-/// Make a minimal correct Matrix event JSON
-inline QJsonObject basicEventJson(const QString& matrixType,
-                                  const QJsonObject& content)
-{
-    return { { TypeKey, matrixType }, { ContentKey, content } };
-}
-
 // === Event types ===
 
 using event_type_t = QLatin1String;
@@ -193,6 +186,13 @@ public:
     Event& operator=(Event&&) = delete;
     virtual ~Event();
 
+    /// Make a minimal correct Matrix event JSON
+    static QJsonObject basicJson(const QString& matrixType,
+                                 const QJsonObject& content)
+    {
+        return { { TypeKey, matrixType }, { ContentKey, content } };
+    }
+
     Type type() const { return _type; }
     QString matrixType() const;
     [[deprecated("Use fullJson() and stringify it with QJsonDocument::toJson() "
diff --git a/lib/events/eventloader.h b/lib/events/eventloader.h
index fe624d70..c7b82e8e 100644
--- a/lib/events/eventloader.h
+++ b/lib/events/eventloader.h
@@ -29,7 +29,7 @@ template <typename BaseEventT>
 inline event_ptr_tt<BaseEventT> loadEvent(const QString& matrixType,
                                           const QJsonObject& content)
 {
-    return doLoadEvent<BaseEventT>(basicEventJson(matrixType, content),
+    return doLoadEvent<BaseEventT>(Event::basicJson(matrixType, content),
                                    matrixType);
 }
 
@@ -44,7 +44,7 @@ inline StateEventPtr loadStateEvent(const QString& matrixType,
                                     const QString& stateKey = {})
 {
     return doLoadEvent<StateEventBase>(
-        basicStateEventJson(matrixType, content, stateKey), matrixType);
+        StateEventBase::basicJson(matrixType, content, stateKey), matrixType);
 }
 
 template <typename EventT>
diff --git a/lib/events/roomevent.cpp b/lib/events/roomevent.cpp
index 2f482871..ebe72149 100644
--- a/lib/events/roomevent.cpp
+++ b/lib/events/roomevent.cpp
@@ -101,19 +101,19 @@ void RoomEvent::dumpTo(QDebug dbg) const
     dbg << " (made at " << originTimestamp().toString(Qt::ISODate) << ')';
 }
 
-QJsonObject makeCallContentJson(const QString& callId, int version,
-                                QJsonObject content)
+QJsonObject CallEventBase::basicJson(const QString& matrixType,
+                                     const QString& callId, int version,
+                                     QJsonObject content)
 {
     content.insert(QStringLiteral("call_id"), callId);
     content.insert(QStringLiteral("version"), version);
-    return content;
+    return RoomEvent::basicJson(matrixType, content);
 }
 
 CallEventBase::CallEventBase(Type type, event_mtype_t matrixType,
                              const QString& callId, int version,
                              const QJsonObject& contentJson)
-    : RoomEvent(type, matrixType,
-                makeCallContentJson(callId, version, contentJson))
+    : RoomEvent(type, basicJson(type, callId, version, contentJson))
 {}
 
 CallEventBase::CallEventBase(Event::Type type, const QJsonObject& json)
diff --git a/lib/events/roomevent.h b/lib/events/roomevent.h
index a7d6c428..0692ad8a 100644
--- a/lib/events/roomevent.h
+++ b/lib/events/roomevent.h
@@ -98,6 +98,11 @@ public:
 
     QString callId() const { return contentPart<QString>("call_id"_ls); }
     int version() const { return contentPart<int>("version"_ls); }
+
+protected:
+    static QJsonObject basicJson(const QString& matrixType,
+                                 const QString& callId, int version,
+                                 QJsonObject contentJson = {});
 };
 } // namespace Quotient
 Q_DECLARE_METATYPE(Quotient::RoomEvent*)
diff --git a/lib/events/stateevent.cpp b/lib/events/stateevent.cpp
index e53d47d4..cdf3c449 100644
--- a/lib/events/stateevent.cpp
+++ b/lib/events/stateevent.cpp
@@ -16,7 +16,7 @@ StateEventBase::StateEventBase(Type type, const QJsonObject& json)
 StateEventBase::StateEventBase(Event::Type type, event_mtype_t matrixType,
                                const QString& stateKey,
                                const QJsonObject& contentJson)
-    : RoomEvent(type, basicStateEventJson(matrixType, contentJson, stateKey))
+    : RoomEvent(type, basicJson(type, contentJson, stateKey))
 {}
 
 bool StateEventBase::repeatsState() const
diff --git a/lib/events/stateevent.h b/lib/events/stateevent.h
index 19905431..47bf6e59 100644
--- a/lib/events/stateevent.h
+++ b/lib/events/stateevent.h
@@ -7,16 +7,6 @@
 
 namespace Quotient {
 
-/// Make a minimal correct Matrix state event JSON
-inline QJsonObject basicStateEventJson(const QString& matrixTypeId,
-                                       const QJsonObject& content,
-                                       const QString& stateKey = {})
-{
-    return { { TypeKey, matrixTypeId },
-             { StateKeyKey, stateKey },
-             { ContentKey, content } };
-}
-
 class QUOTIENT_API StateEventBase : public RoomEvent {
 public:
     static inline EventFactory<StateEventBase> factory { "StateEvent" };
@@ -27,6 +17,16 @@ public:
                    const QJsonObject& contentJson = {});
     ~StateEventBase() override = default;
 
+    //! Make a minimal correct Matrix state event JSON
+    static QJsonObject basicJson(const QString& matrixTypeId,
+                                 const QJsonObject& content,
+                                 const QString& stateKey = {})
+    {
+        return { { TypeKey, matrixTypeId },
+                 { StateKeyKey, stateKey },
+                 { ContentKey, content } };
+    }
+
     bool isStateEvent() const override { return true; }
     QString replacedState() const;
     void dumpTo(QDebug dbg) const override;
@@ -36,6 +36,14 @@ public:
 using StateEventPtr = event_ptr_tt<StateEventBase>;
 using StateEvents = EventsArray<StateEventBase>;
 
+[[deprecated("Use StateEventBase::basicJson() instead")]]
+inline QJsonObject basicStateEventJson(const QString& matrixTypeId,
+                                       const QJsonObject& content,
+                                       const QString& stateKey = {})
+{
+    return StateEventBase::basicJson(matrixTypeId, content, stateKey);
+}
+
 //! \brief Override RoomEvent factory with that from StateEventBase if JSON has
 //! stateKey
 //!
diff --git a/quotest/quotest.cpp b/quotest/quotest.cpp
index 792faabd..861cfba0 100644
--- a/quotest/quotest.cpp
+++ b/quotest/quotest.cpp
@@ -531,10 +531,10 @@ public:
         : RoomEvent(typeId(), jo)
     {}
     CustomEvent(int testValue)
-        : RoomEvent(typeId(),
-                    basicEventJson(matrixTypeId(),
-                                   QJsonObject { { "testValue"_ls,
-                                                   toJson(testValue) } }))
+        : RoomEvent(TypeId,
+                    Event::basicJson(TypeId,
+                                     QJsonObject { { "testValue"_ls,
+                                                     toJson(testValue) } }))
     {}
 
     auto testValue() const { return contentPart<int>("testValue"_ls); }
-- 
cgit v1.2.3


From e7a4b5a545b0f59b95ca8097009dbf6eea534db1 Mon Sep 17 00:00:00 2001
From: Alexey Rusakov <Kitsune-Ral@users.sf.net>
Date: Fri, 6 May 2022 22:17:55 +0200
Subject: Generalise DEFINE_SIMPLE_EVENT

This macro was defined in accountdataevents.h but adding one more
parameter (base class) makes it applicable to pretty much any event
with the content that has one key-value pair (though state events
already have a non-macro solution in the form of
`StateEvent<EventContent::SingleKeyValue>`). Now CustomEvent definition
in quotest.cpp can be replaced with a single line.
---
 lib/events/accountdataevents.h | 31 +++++++++----------------------
 lib/events/event.h             | 26 ++++++++++++++++++++++++++
 quotest/quotest.cpp            | 18 +-----------------
 3 files changed, 36 insertions(+), 39 deletions(-)

(limited to 'quotest')

diff --git a/lib/events/accountdataevents.h b/lib/events/accountdataevents.h
index 12f1f00b..ec2f64e3 100644
--- a/lib/events/accountdataevents.h
+++ b/lib/events/accountdataevents.h
@@ -46,27 +46,14 @@ struct JsonObjectConverter<TagRecord> {
 
 using TagsMap = QHash<QString, TagRecord>;
 
-#define DEFINE_SIMPLE_EVENT(_Name, _TypeId, _ContentType, _ContentKey)       \
-    class QUOTIENT_API _Name : public Event {                             \
-    public:                                                                  \
-        using content_type = _ContentType;                                   \
-        DEFINE_EVENT_TYPEID(_TypeId, _Name)                                  \
-        explicit _Name(const QJsonObject& obj) : Event(typeId(), obj) {}     \
-        explicit _Name(const content_type& content)                          \
-            : Event(typeId(), matrixTypeId(),                                \
-                    QJsonObject {                                            \
-                        { QStringLiteral(#_ContentKey), toJson(content) } }) \
-        {}                                                                   \
-        auto _ContentKey() const                                             \
-        {                                                                    \
-            return contentPart<content_type>(#_ContentKey##_ls);             \
-        }                                                                    \
-    };                                                                       \
-    REGISTER_EVENT_TYPE(_Name)                                               \
-    // End of macro
-
-DEFINE_SIMPLE_EVENT(TagEvent, "m.tag", TagsMap, tags)
-DEFINE_SIMPLE_EVENT(ReadMarkerEvent, "m.fully_read", QString, event_id)
-DEFINE_SIMPLE_EVENT(IgnoredUsersEvent, "m.ignored_user_list", QSet<QString>,
+DEFINE_SIMPLE_EVENT(TagEvent, Event, "m.tag", TagsMap, tags)
+DEFINE_SIMPLE_EVENT(ReadMarkerEventImpl, Event, "m.fully_read", QString, eventId)
+class ReadMarkerEvent : public ReadMarkerEventImpl {
+public:
+    using ReadMarkerEventImpl::ReadMarkerEventImpl;
+    [[deprecated("Use ReadMarkerEvent::eventId() instead")]]
+    QString event_id() const { return eventId(); }
+};
+DEFINE_SIMPLE_EVENT(IgnoredUsersEvent, Event, "m.ignored_user_list", QSet<QString>,
                     ignored_users)
 } // namespace Quotient
diff --git a/lib/events/event.h b/lib/events/event.h
index 5be2b41b..a27c0b96 100644
--- a/lib/events/event.h
+++ b/lib/events/event.h
@@ -278,6 +278,32 @@ using Events = EventsArray<Event>;
         Type_::factory.addMethod<Type_>();                        \
     // End of macro
 
+/// \brief Define a new event class with a single key-value pair in the content
+///
+/// This macro defines a new event class \p Name_ derived from \p Base_,
+/// with Matrix event type \p TypeId_, providing a getter named \p GetterName_
+/// for a single value of type \p ValueType_ inside the event content.
+/// To retrieve the value the getter uses a JSON key name that corresponds to
+/// its own (getter's) name but written in snake_case. \p GetterName_ must be
+/// in camelCase, no quotes (an identifier, not a literal).
+#define DEFINE_SIMPLE_EVENT(Name_, Base_, TypeId_, ValueType_, GetterName_)     \
+    class QUOTIENT_API Name_ : public Base_ {                                   \
+    public:                                                                     \
+        using content_type = ValueType_;                                        \
+        DEFINE_EVENT_TYPEID(TypeId_, Name_)                                     \
+        explicit Name_(const QJsonObject& obj) : Base_(TypeId, obj) {}          \
+        explicit Name_(const content_type& content)                             \
+            : Name_(Base_::basicJson(TypeId, { { JsonKey, toJson(content) } })) \
+        {}                                                                      \
+        auto GetterName_() const                                                \
+        {                                                                       \
+            return contentPart<content_type>(JsonKey);                          \
+        }                                                                       \
+        static inline const auto JsonKey = toSnakeCase(#GetterName_##_ls);      \
+    };                                                                          \
+    REGISTER_EVENT_TYPE(Name_)                                                  \
+    // End of macro
+
 // === is<>(), eventCast<>() and switchOnType<>() ===
 
 template <class EventT>
diff --git a/quotest/quotest.cpp b/quotest/quotest.cpp
index 861cfba0..b14442b9 100644
--- a/quotest/quotest.cpp
+++ b/quotest/quotest.cpp
@@ -523,23 +523,7 @@ bool TestSuite::checkFileSendingOutcome(const TestToken& thisTest,
     return true;
 }
 
-class CustomEvent : public RoomEvent {
-public:
-    DEFINE_EVENT_TYPEID("quotest.custom", CustomEvent)
-
-    CustomEvent(const QJsonObject& jo)
-        : RoomEvent(typeId(), jo)
-    {}
-    CustomEvent(int testValue)
-        : RoomEvent(TypeId,
-                    Event::basicJson(TypeId,
-                                     QJsonObject { { "testValue"_ls,
-                                                     toJson(testValue) } }))
-    {}
-
-    auto testValue() const { return contentPart<int>("testValue"_ls); }
-};
-REGISTER_EVENT_TYPE(CustomEvent)
+DEFINE_SIMPLE_EVENT(CustomEvent, RoomEvent, "quotest.custom", int, testValue)
 
 TEST_IMPL(sendCustomEvent)
 {
-- 
cgit v1.2.3


From f1ed7eec77f843de689c3f3540db73bb235b2164 Mon Sep 17 00:00:00 2001
From: Alexey Rusakov <Kitsune-Ral@users.sf.net>
Date: Sat, 14 May 2022 20:09:39 +0200
Subject: Quotest: test checkResource()

---
 quotest/quotest.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

(limited to 'quotest')

diff --git a/quotest/quotest.cpp b/quotest/quotest.cpp
index b14442b9..1eed865f 100644
--- a/quotest/quotest.cpp
+++ b/quotest/quotest.cpp
@@ -764,6 +764,14 @@ TEST_IMPL(visitResources)
                 clog << "Incorrect matrix.to representation:"
                      << matrixToUrl.toStdString() << endl;
             }
+            const auto checkResult = checkResource(connection(), uriString);
+            if ((checkResult != UriResolved && uri.type() != Uri::NonMatrix)
+                || (uri.type() == Uri::NonMatrix
+                    && checkResult != CouldNotResolve)) {
+                clog << "checkResource() returned incorrect result:"
+                     << checkResult;
+                FAIL_TEST();
+            }
             ud.visitResource(connection(), uriString);
             if (spy.count() != 1) {
                 clog << "Wrong number of signal emissions (" << spy.count()
-- 
cgit v1.2.3


From 0b5e72a2c6502f22a752b72b4df5fa25746fdd25 Mon Sep 17 00:00:00 2001
From: Alexey Rusakov <Kitsune-Ral@users.sf.net>
Date: Thu, 26 May 2022 08:51:22 +0200
Subject: Refactor EncryptedFile and EC::FileInfo::file

Besides having a misleading name (and it goes back to the spec),
EncryptedFile under `file` key preempts the `url` (or `thumbnail_url`)
string value so only one of the two should exist. This is a case for
using std::variant<> - despite its clumsy syntax, it can actually
simplify and streamline code when all the necessary bits are in place
(such as conversion to JSON and getting the common piece - the URL -
out of it). This commit replaces `FileInfo::url` and `FileInfo::file`
with a common field `source` of type `FileSourceInfo` that is an alias
for a variant type covering both underlying types; and `url()` is
reintroduced as a function instead, to allow simplified access
to whichever URL is available inside the variant.

Oh, and EncryptedFile is EncryptedFileMetadata now, to clarify that it
does not represent the file payload itself but rather the data necessary
to obtain that payload.
---
 CMakeLists.txt                  |   2 +-
 autotests/testfilecrypto.cpp    |   6 +-
 autotests/testolmaccount.cpp    |   5 +-
 lib/connection.cpp              |  11 ++-
 lib/connection.h                |   5 +-
 lib/converters.h                |   8 ++
 lib/eventitem.cpp               |  21 ++---
 lib/eventitem.h                 |   9 +-
 lib/events/encryptedfile.cpp    | 119 --------------------------
 lib/events/encryptedfile.h      |  63 --------------
 lib/events/eventcontent.cpp     |  68 +++++++--------
 lib/events/eventcontent.h       |  53 ++++++------
 lib/events/filesourceinfo.cpp   | 181 ++++++++++++++++++++++++++++++++++++++++
 lib/events/filesourceinfo.h     |  89 ++++++++++++++++++++
 lib/events/roomavatarevent.h    |   4 +-
 lib/events/roommessageevent.cpp |   8 +-
 lib/events/stickerevent.cpp     |   2 +-
 lib/jobs/downloadfilejob.cpp    |  13 +--
 lib/jobs/downloadfilejob.h      |   5 +-
 lib/mxcreply.cpp                |  10 ++-
 lib/room.cpp                    |  85 +++++++++----------
 lib/room.h                      |   3 +-
 quotest/quotest.cpp             |   2 +-
 23 files changed, 427 insertions(+), 345 deletions(-)
 delete mode 100644 lib/events/encryptedfile.cpp
 delete mode 100644 lib/events/encryptedfile.h
 create mode 100644 lib/events/filesourceinfo.cpp
 create mode 100644 lib/events/filesourceinfo.h

(limited to 'quotest')

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 404ba87c..635efd90 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -168,7 +168,7 @@ list(APPEND lib_SRCS
     lib/events/roomkeyevent.h lib/events/roomkeyevent.cpp
     lib/events/stickerevent.h lib/events/stickerevent.cpp
     lib/events/keyverificationevent.h lib/events/keyverificationevent.cpp
-    lib/events/encryptedfile.h lib/events/encryptedfile.cpp
+    lib/events/filesourceinfo.h lib/events/filesourceinfo.cpp
     lib/jobs/requestdata.h lib/jobs/requestdata.cpp
     lib/jobs/basejob.h lib/jobs/basejob.cpp
     lib/jobs/syncjob.h lib/jobs/syncjob.cpp
diff --git a/autotests/testfilecrypto.cpp b/autotests/testfilecrypto.cpp
index f9212376..b86114a4 100644
--- a/autotests/testfilecrypto.cpp
+++ b/autotests/testfilecrypto.cpp
@@ -3,14 +3,16 @@
 // SPDX-License-Identifier: LGPL-2.1-or-later
 
 #include "testfilecrypto.h"
-#include "events/encryptedfile.h"
+
+#include "events/filesourceinfo.h"
+
 #include <qtest.h>
 
 using namespace Quotient;
 void TestFileCrypto::encryptDecryptData()
 {
     QByteArray data = "ABCDEF";
-    auto [file, cipherText] = EncryptedFile::encryptFile(data);
+    auto [file, cipherText] = EncryptedFileMetadata::encryptFile(data);
     auto decrypted = file.decryptFile(cipherText);
     // AES CTR produces ciphertext of the same size as the original
     QCOMPARE(cipherText.size(), data.size());
diff --git a/autotests/testolmaccount.cpp b/autotests/testolmaccount.cpp
index e31ff6d3..b509d12f 100644
--- a/autotests/testolmaccount.cpp
+++ b/autotests/testolmaccount.cpp
@@ -10,7 +10,7 @@
 #include <e2ee/qolmaccount.h>
 #include <e2ee/qolmutility.h>
 #include <events/encryptionevent.h>
-#include <events/encryptedfile.h>
+#include <events/filesourceinfo.h>
 #include <networkaccessmanager.h>
 #include <room.h>
 
@@ -156,8 +156,7 @@ void TestOlmAccount::encryptedFile()
         "sha256": "fdSLu/YkRx3Wyh3KQabP3rd6+SFiKg5lsJZQHtkSAYA"
       }})");
 
-    EncryptedFile file;
-    JsonObjectConverter<EncryptedFile>::fillFrom(doc.object(), file);
+    const auto file = fromJson<EncryptedFileMetadata>(doc);
 
     QCOMPARE(file.v, "v2");
     QCOMPARE(file.iv, "w+sE15fzSc0AAAAAAAAAAA");
diff --git a/lib/connection.cpp b/lib/connection.cpp
index dba18cb1..0994d85a 100644
--- a/lib/connection.cpp
+++ b/lib/connection.cpp
@@ -1137,15 +1137,14 @@ DownloadFileJob* Connection::downloadFile(const QUrl& url,
 }
 
 #ifdef Quotient_E2EE_ENABLED
-DownloadFileJob* Connection::downloadFile(const QUrl& url,
-                                          const EncryptedFile& file,
-                                          const QString& localFilename)
+DownloadFileJob* Connection::downloadFile(
+    const QUrl& url, const EncryptedFileMetadata& fileMetadata,
+    const QString& localFilename)
 {
     auto mediaId = url.authority() + url.path();
     auto idParts = splitMediaId(mediaId);
-    auto* job =
-        callApi<DownloadFileJob>(idParts.front(), idParts.back(), file, localFilename);
-    return job;
+    return callApi<DownloadFileJob>(idParts.front(), idParts.back(),
+                                    fileMetadata, localFilename);
 }
 #endif
 
diff --git a/lib/connection.h b/lib/connection.h
index f8744752..656e597c 100644
--- a/lib/connection.h
+++ b/lib/connection.h
@@ -51,7 +51,7 @@ class SendToDeviceJob;
 class SendMessageJob;
 class LeaveRoomJob;
 class Database;
-struct EncryptedFile;
+struct EncryptedFileMetadata;
 
 class QOlmAccount;
 class QOlmInboundGroupSession;
@@ -601,7 +601,8 @@ public Q_SLOTS:
                                   const QString& localFilename = {});
 
 #ifdef Quotient_E2EE_ENABLED
-    DownloadFileJob* downloadFile(const QUrl& url, const EncryptedFile& file,
+    DownloadFileJob* downloadFile(const QUrl& url,
+                                  const EncryptedFileMetadata& file,
                                   const QString& localFilename = {});
 #endif
     /**
diff --git a/lib/converters.h b/lib/converters.h
index 5e3becb8..49cb1ed9 100644
--- a/lib/converters.h
+++ b/lib/converters.h
@@ -16,6 +16,7 @@
 
 #include <type_traits>
 #include <vector>
+#include <variant>
 
 class QVariant;
 
@@ -224,6 +225,13 @@ struct QUOTIENT_API JsonConverter<QVariant> {
     static QVariant load(const QJsonValue& jv);
 };
 
+template <typename... Ts>
+inline QJsonValue toJson(const std::variant<Ts...>& v)
+{
+    return std::visit(
+        [](const auto& value) { return QJsonValue { toJson(value) }; }, v);
+}
+
 template <typename T>
 struct JsonConverter<Omittable<T>> {
     static QJsonValue dump(const Omittable<T>& from)
diff --git a/lib/eventitem.cpp b/lib/eventitem.cpp
index 302ae053..a2e2a156 100644
--- a/lib/eventitem.cpp
+++ b/lib/eventitem.cpp
@@ -8,32 +8,23 @@
 
 using namespace Quotient;
 
-void PendingEventItem::setFileUploaded(const QUrl& remoteUrl)
+void PendingEventItem::setFileUploaded(const FileSourceInfo& uploadedFileData)
 {
     // TODO: eventually we might introduce hasFileContent to RoomEvent,
     // and unify the code below.
     if (auto* rme = getAs<RoomMessageEvent>()) {
         Q_ASSERT(rme->hasFileContent());
-        rme->editContent([remoteUrl](EventContent::TypedBase& ec) {
-            ec.fileInfo()->url = remoteUrl;
+        rme->editContent([&uploadedFileData](EventContent::TypedBase& ec) {
+            ec.fileInfo()->source = uploadedFileData;
         });
     }
     if (auto* rae = getAs<RoomAvatarEvent>()) {
         Q_ASSERT(rae->content().fileInfo());
-        rae->editContent(
-            [remoteUrl](EventContent::FileInfo& fi) { fi.url = remoteUrl; });
-    }
-    setStatus(EventStatus::FileUploaded);
-}
-
-void PendingEventItem::setEncryptedFile(const EncryptedFile& encryptedFile)
-{
-    if (auto* rme = getAs<RoomMessageEvent>()) {
-        Q_ASSERT(rme->hasFileContent());
-        rme->editContent([encryptedFile](EventContent::TypedBase& ec) {
-            ec.fileInfo()->file = encryptedFile;
+        rae->editContent([&uploadedFileData](EventContent::FileInfo& fi) {
+            fi.source = uploadedFileData;
         });
     }
+    setStatus(EventStatus::FileUploaded);
 }
 
 // Not exactly sure why but this helps with the linker not finding
diff --git a/lib/eventitem.h b/lib/eventitem.h
index d8313736..5e001d88 100644
--- a/lib/eventitem.h
+++ b/lib/eventitem.h
@@ -3,14 +3,14 @@
 
 #pragma once
 
-#include "events/stateevent.h"
 #include "quotient_common.h"
 
+#include "events/filesourceinfo.h"
+#include "events/stateevent.h"
+
 #include <any>
 #include <utility>
 
-#include "events/encryptedfile.h"
-
 namespace Quotient {
 
 namespace EventStatus {
@@ -115,8 +115,7 @@ public:
     QString annotation() const { return _annotation; }
 
     void setDeparted() { setStatus(EventStatus::Departed); }
-    void setFileUploaded(const QUrl& remoteUrl);
-    void setEncryptedFile(const EncryptedFile& encryptedFile);
+    void setFileUploaded(const FileSourceInfo &uploadedFileData);
     void setReachedServer(const QString& eventId)
     {
         setStatus(EventStatus::ReachedServer);
diff --git a/lib/events/encryptedfile.cpp b/lib/events/encryptedfile.cpp
deleted file mode 100644
index 33ebb514..00000000
--- a/lib/events/encryptedfile.cpp
+++ /dev/null
@@ -1,119 +0,0 @@
-// SPDX-FileCopyrightText: 2021 Carl Schwan <carlschwan@kde.org>
-//
-// SPDX-License-Identifier: LGPL-2.1-or-later
-
-#include "encryptedfile.h"
-#include "logging.h"
-
-#ifdef Quotient_E2EE_ENABLED
-#include <openssl/evp.h>
-#include <QtCore/QCryptographicHash>
-#include "e2ee/qolmutils.h"
-#endif
-
-using namespace Quotient;
-
-QByteArray EncryptedFile::decryptFile(const QByteArray& ciphertext) const
-{
-#ifdef Quotient_E2EE_ENABLED
-    auto _key = key.k;
-    const auto keyBytes = QByteArray::fromBase64(
-        _key.replace(u'_', u'/').replace(u'-', u'+').toLatin1());
-    const auto sha256 = QByteArray::fromBase64(hashes["sha256"].toLatin1());
-    if (sha256
-        != QCryptographicHash::hash(ciphertext, QCryptographicHash::Sha256)) {
-        qCWarning(E2EE) << "Hash verification failed for file";
-        return {};
-    }
-    {
-        int length;
-        auto* ctx = EVP_CIPHER_CTX_new();
-        QByteArray plaintext(ciphertext.size() + EVP_MAX_BLOCK_LENGTH
-                                 - 1,
-                             '\0');
-        EVP_DecryptInit_ex(ctx, EVP_aes_256_ctr(), nullptr,
-                           reinterpret_cast<const unsigned char*>(
-                               keyBytes.data()),
-                           reinterpret_cast<const unsigned char*>(
-                               QByteArray::fromBase64(iv.toLatin1()).data()));
-        EVP_DecryptUpdate(
-            ctx, reinterpret_cast<unsigned char*>(plaintext.data()), &length,
-            reinterpret_cast<const unsigned char*>(ciphertext.data()),
-            ciphertext.size());
-        EVP_DecryptFinal_ex(ctx,
-                            reinterpret_cast<unsigned char*>(plaintext.data())
-                                + length,
-                            &length);
-        EVP_CIPHER_CTX_free(ctx);
-        return plaintext.left(ciphertext.size());
-    }
-#else
-    qWarning(MAIN) << "This build of libQuotient doesn't support E2EE, "
-                      "cannot decrypt the file";
-    return ciphertext;
-#endif
-}
-
-std::pair<EncryptedFile, QByteArray> EncryptedFile::encryptFile(const QByteArray &plainText)
-{
-#ifdef Quotient_E2EE_ENABLED
-    QByteArray k = getRandom(32);
-    auto kBase64 = k.toBase64();
-    QByteArray iv = getRandom(16);
-    JWK key = {"oct"_ls, {"encrypt"_ls, "decrypt"_ls}, "A256CTR"_ls, QString(k.toBase64()).replace(u'/', u'_').replace(u'+', u'-').left(kBase64.indexOf('=')), true};
-
-    int length;
-    auto* ctx = EVP_CIPHER_CTX_new();
-    EVP_EncryptInit_ex(ctx, EVP_aes_256_ctr(), nullptr, reinterpret_cast<const unsigned char*>(k.data()),reinterpret_cast<const unsigned char*>(iv.data()));
-    const auto blockSize = EVP_CIPHER_CTX_block_size(ctx);
-    QByteArray cipherText(plainText.size() + blockSize - 1, '\0');
-    EVP_EncryptUpdate(ctx, reinterpret_cast<unsigned char*>(cipherText.data()), &length, reinterpret_cast<const unsigned char*>(plainText.data()), plainText.size());
-    EVP_EncryptFinal_ex(ctx, reinterpret_cast<unsigned char*>(cipherText.data()) + length, &length);
-    EVP_CIPHER_CTX_free(ctx);
-
-    auto hash = QCryptographicHash::hash(cipherText, QCryptographicHash::Sha256).toBase64();
-    auto ivBase64 = iv.toBase64();
-    EncryptedFile file = {{}, key, ivBase64.left(ivBase64.indexOf('=')), {{QStringLiteral("sha256"), hash.left(hash.indexOf('='))}}, "v2"_ls};
-    return {file, cipherText};
-#else
-    return {};
-#endif
-}
-
-void JsonObjectConverter<EncryptedFile>::dumpTo(QJsonObject& jo,
-                                                const EncryptedFile& pod)
-{
-    addParam<>(jo, QStringLiteral("url"), pod.url);
-    addParam<>(jo, QStringLiteral("key"), pod.key);
-    addParam<>(jo, QStringLiteral("iv"), pod.iv);
-    addParam<>(jo, QStringLiteral("hashes"), pod.hashes);
-    addParam<>(jo, QStringLiteral("v"), pod.v);
-}
-
-void JsonObjectConverter<EncryptedFile>::fillFrom(const QJsonObject& jo,
-                                                  EncryptedFile& pod)
-{
-    fromJson(jo.value("url"_ls), pod.url);
-    fromJson(jo.value("key"_ls), pod.key);
-    fromJson(jo.value("iv"_ls), pod.iv);
-    fromJson(jo.value("hashes"_ls), pod.hashes);
-    fromJson(jo.value("v"_ls), pod.v);
-}
-
-void JsonObjectConverter<JWK>::dumpTo(QJsonObject &jo, const JWK &pod)
-{
-    addParam<>(jo, QStringLiteral("kty"), pod.kty);
-    addParam<>(jo, QStringLiteral("key_ops"), pod.keyOps);
-    addParam<>(jo, QStringLiteral("alg"), pod.alg);
-    addParam<>(jo, QStringLiteral("k"), pod.k);
-    addParam<>(jo, QStringLiteral("ext"), pod.ext);
-}
-
-void JsonObjectConverter<JWK>::fillFrom(const QJsonObject &jo, JWK &pod)
-{
-    fromJson(jo.value("kty"_ls), pod.kty);
-    fromJson(jo.value("key_ops"_ls), pod.keyOps);
-    fromJson(jo.value("alg"_ls), pod.alg);
-    fromJson(jo.value("k"_ls), pod.k);
-    fromJson(jo.value("ext"_ls), pod.ext);
-}
diff --git a/lib/events/encryptedfile.h b/lib/events/encryptedfile.h
deleted file mode 100644
index 022ac91e..00000000
--- a/lib/events/encryptedfile.h
+++ /dev/null
@@ -1,63 +0,0 @@
-// SPDX-FileCopyrightText: 2021 Carl Schwan <carlschwan@kde.org>
-//
-// SPDX-License-Identifier: LGPL-2.1-or-later
-
-#pragma once
-
-#include "converters.h"
-
-namespace Quotient {
-/**
- * JSON Web Key object as specified in
- * https://spec.matrix.org/unstable/client-server-api/#extensions-to-mroommessage-msgtypes
- * The only currently relevant member is `k`, the rest needs to be set to the defaults specified in the spec.
- */
-struct JWK
-{
-    Q_GADGET
-    Q_PROPERTY(QString kty MEMBER kty CONSTANT)
-    Q_PROPERTY(QStringList keyOps MEMBER keyOps CONSTANT)
-    Q_PROPERTY(QString alg MEMBER alg CONSTANT)
-    Q_PROPERTY(QString k MEMBER k CONSTANT)
-    Q_PROPERTY(bool ext MEMBER ext CONSTANT)
-
-public:
-    QString kty;
-    QStringList keyOps;
-    QString alg;
-    QString k;
-    bool ext;
-};
-
-struct QUOTIENT_API EncryptedFile
-{
-    Q_GADGET
-    Q_PROPERTY(QUrl url MEMBER url CONSTANT)
-    Q_PROPERTY(JWK key MEMBER key CONSTANT)
-    Q_PROPERTY(QString iv MEMBER iv CONSTANT)
-    Q_PROPERTY(QHash<QString, QString> hashes MEMBER hashes CONSTANT)
-    Q_PROPERTY(QString v MEMBER v CONSTANT)
-
-public:
-    QUrl url;
-    JWK key;
-    QString iv;
-    QHash<QString, QString> hashes;
-    QString v;
-
-    QByteArray decryptFile(const QByteArray &ciphertext) const;
-    static std::pair<EncryptedFile, QByteArray> encryptFile(const QByteArray& plainText);
-};
-
-template <>
-struct QUOTIENT_API JsonObjectConverter<EncryptedFile> {
-    static void dumpTo(QJsonObject& jo, const EncryptedFile& pod);
-    static void fillFrom(const QJsonObject& jo, EncryptedFile& pod);
-};
-
-template <>
-struct QUOTIENT_API JsonObjectConverter<JWK> {
-    static void dumpTo(QJsonObject& jo, const JWK& pod);
-    static void fillFrom(const QJsonObject& jo, JWK& pod);
-};
-} // namespace Quotient
diff --git a/lib/events/eventcontent.cpp b/lib/events/eventcontent.cpp
index 6218e3b8..36b647cb 100644
--- a/lib/events/eventcontent.cpp
+++ b/lib/events/eventcontent.cpp
@@ -19,23 +19,21 @@ QJsonObject Base::toJson() const
     return o;
 }
 
-FileInfo::FileInfo(const QFileInfo &fi)
-    : mimeType(QMimeDatabase().mimeTypeForFile(fi))
-    , url(QUrl::fromLocalFile(fi.filePath()))
-    , payloadSize(fi.size())
-    , originalName(fi.fileName())
+FileInfo::FileInfo(const QFileInfo& fi)
+    : source(QUrl::fromLocalFile(fi.filePath())),
+      mimeType(QMimeDatabase().mimeTypeForFile(fi)),
+      payloadSize(fi.size()),
+      originalName(fi.fileName())
 {
     Q_ASSERT(fi.isFile());
 }
 
-FileInfo::FileInfo(QUrl u, qint64 payloadSize, const QMimeType& mimeType,
-                   Omittable<EncryptedFile> encryptedFile,
-                   QString originalFilename)
-    : mimeType(mimeType)
-    , url(move(u))
+FileInfo::FileInfo(FileSourceInfo sourceInfo, qint64 payloadSize,
+                   const QMimeType& mimeType, QString originalFilename)
+    : source(move(sourceInfo))
+    , mimeType(mimeType)
     , payloadSize(payloadSize)
     , originalName(move(originalFilename))
-    , file(move(encryptedFile))
 {
     if (!isValid())
         qCWarning(MESSAGES)
@@ -44,28 +42,28 @@ FileInfo::FileInfo(QUrl u, qint64 payloadSize, const QMimeType& mimeType,
                "0.7; for local resources, use FileInfo(QFileInfo) instead";
 }
 
-FileInfo::FileInfo(QUrl mxcUrl, const QJsonObject& infoJson,
-                   Omittable<EncryptedFile> encryptedFile,
+FileInfo::FileInfo(FileSourceInfo sourceInfo, const QJsonObject& infoJson,
                    QString originalFilename)
-    : originalInfoJson(infoJson)
+    : source(move(sourceInfo))
+    , originalInfoJson(infoJson)
     , mimeType(
           QMimeDatabase().mimeTypeForName(infoJson["mimetype"_ls].toString()))
-    , url(move(mxcUrl))
     , payloadSize(fromJson<qint64>(infoJson["size"_ls]))
     , originalName(move(originalFilename))
-    , file(move(encryptedFile))
 {
-    if(url.isEmpty() && file.has_value()) {
-        url = file->url;
-    }
     if (!mimeType.isValid())
         mimeType = QMimeDatabase().mimeTypeForData(QByteArray());
 }
 
 bool FileInfo::isValid() const
 {
-    return url.scheme() == "mxc"
-           && (url.authority() + url.path()).count('/') == 1;
+    const auto& u = url();
+    return u.scheme() == "mxc" && (u.authority() + u.path()).count('/') == 1;
+}
+
+QUrl FileInfo::url() const
+{
+    return getUrlFromSourceInfo(source);
 }
 
 QJsonObject Quotient::EventContent::toInfoJson(const FileInfo& info)
@@ -75,7 +73,6 @@ QJsonObject Quotient::EventContent::toInfoJson(const FileInfo& info)
         infoJson.insert(QStringLiteral("size"), info.payloadSize);
     if (info.mimeType.isValid())
         infoJson.insert(QStringLiteral("mimetype"), info.mimeType.name());
-    //TODO add encryptedfile
     return infoJson;
 }
 
@@ -83,17 +80,16 @@ ImageInfo::ImageInfo(const QFileInfo& fi, QSize imageSize)
     : FileInfo(fi), imageSize(imageSize)
 {}
 
-ImageInfo::ImageInfo(const QUrl& mxcUrl, qint64 fileSize, const QMimeType& type,
-                     QSize imageSize, Omittable<EncryptedFile> encryptedFile,
+ImageInfo::ImageInfo(FileSourceInfo sourceInfo, qint64 fileSize,
+                     const QMimeType& type, QSize imageSize,
                      const QString& originalFilename)
-    : FileInfo(mxcUrl, fileSize, type, move(encryptedFile), originalFilename)
+    : FileInfo(move(sourceInfo), fileSize, type, originalFilename)
     , imageSize(imageSize)
 {}
 
-ImageInfo::ImageInfo(const QUrl& mxcUrl, const QJsonObject& infoJson,
-                     Omittable<EncryptedFile> encryptedFile,
+ImageInfo::ImageInfo(FileSourceInfo sourceInfo, const QJsonObject& infoJson,
                      const QString& originalFilename)
-    : FileInfo(mxcUrl, infoJson, move(encryptedFile), originalFilename)
+    : FileInfo(move(sourceInfo), infoJson, originalFilename)
     , imageSize(infoJson["w"_ls].toInt(), infoJson["h"_ls].toInt())
 {}
 
@@ -107,16 +103,20 @@ QJsonObject Quotient::EventContent::toInfoJson(const ImageInfo& info)
     return infoJson;
 }
 
-Thumbnail::Thumbnail(const QJsonObject& infoJson,
-                     Omittable<EncryptedFile> encryptedFile)
+Thumbnail::Thumbnail(
+    const QJsonObject& infoJson,
+    const Omittable<EncryptedFileMetadata>& encryptedFileMetadata)
     : ImageInfo(QUrl(infoJson["thumbnail_url"_ls].toString()),
-                infoJson["thumbnail_info"_ls].toObject(), move(encryptedFile))
-{}
+                infoJson["thumbnail_info"_ls].toObject())
+{
+    if (encryptedFileMetadata)
+        source = *encryptedFileMetadata;
+}
 
 void Thumbnail::dumpTo(QJsonObject& infoJson) const
 {
-    if (url.isValid())
-        infoJson.insert(QStringLiteral("thumbnail_url"), url.toString());
+    if (url().isValid())
+        fillJson(infoJson, { "thumbnail_url"_ls, "thumbnail_file"_ls }, source);
     if (!imageSize.isEmpty())
         infoJson.insert(QStringLiteral("thumbnail_info"),
                          toInfoJson(*this));
diff --git a/lib/events/eventcontent.h b/lib/events/eventcontent.h
index bbd35618..23281876 100644
--- a/lib/events/eventcontent.h
+++ b/lib/events/eventcontent.h
@@ -6,14 +6,14 @@
 // This file contains generic event content definitions, applicable to room
 // message events as well as other events (e.g., avatars).
 
-#include "encryptedfile.h"
+#include "filesourceinfo.h"
 #include "quotient_export.h"
 
 #include <QtCore/QJsonObject>
+#include <QtCore/QMetaType>
 #include <QtCore/QMimeType>
 #include <QtCore/QSize>
 #include <QtCore/QUrl>
-#include <QtCore/QMetaType>
 
 class QFileInfo;
 
@@ -50,7 +50,7 @@ namespace EventContent {
 
     // A quick classes inheritance structure follows (the definitions are
     // spread across eventcontent.h and roommessageevent.h):
-    // UrlBasedContent<InfoT> : InfoT + url and thumbnail data
+    // UrlBasedContent<InfoT> : InfoT + thumbnail data
     //   PlayableContent<InfoT> : + duration attribute
     // FileInfo
     //   FileContent = UrlBasedContent<FileInfo>
@@ -89,34 +89,32 @@ namespace EventContent {
         //!
         //! \param fi a QFileInfo object referring to an existing file
         explicit FileInfo(const QFileInfo& fi);
-        explicit FileInfo(QUrl mxcUrl, qint64 payloadSize = -1,
+        explicit FileInfo(FileSourceInfo sourceInfo, qint64 payloadSize = -1,
                           const QMimeType& mimeType = {},
-                          Omittable<EncryptedFile> encryptedFile = none,
                           QString originalFilename = {});
         //! \brief Construct from a JSON `info` payload
         //!
         //! Make sure to pass the `info` subobject of content JSON, not the
         //! whole JSON content.
-        FileInfo(QUrl mxcUrl, const QJsonObject& infoJson,
-                 Omittable<EncryptedFile> encryptedFile,
+        FileInfo(FileSourceInfo sourceInfo, const QJsonObject& infoJson,
                  QString originalFilename = {});
 
         bool isValid() const;
+        QUrl url() const;
 
         //! \brief Extract media id from the URL
         //!
         //! This can be used, e.g., to construct a QML-facing image://
         //! URI as follows:
         //! \code "image://provider/" + info.mediaId() \endcode
-        QString mediaId() const { return url.authority() + url.path(); }
+        QString mediaId() const { return url().authority() + url().path(); }
 
     public:
+        FileSourceInfo source;
         QJsonObject originalInfoJson;
         QMimeType mimeType;
-        QUrl url;
         qint64 payloadSize = 0;
         QString originalName;
-        Omittable<EncryptedFile> file = none;
     };
 
     QUOTIENT_API QJsonObject toInfoJson(const FileInfo& info);
@@ -126,12 +124,10 @@ namespace EventContent {
     public:
         ImageInfo() = default;
         explicit ImageInfo(const QFileInfo& fi, QSize imageSize = {});
-        explicit ImageInfo(const QUrl& mxcUrl, qint64 fileSize = -1,
+        explicit ImageInfo(FileSourceInfo sourceInfo, qint64 fileSize = -1,
                            const QMimeType& type = {}, QSize imageSize = {},
-                           Omittable<EncryptedFile> encryptedFile = none,
                            const QString& originalFilename = {});
-        ImageInfo(const QUrl& mxcUrl, const QJsonObject& infoJson,
-                  Omittable<EncryptedFile> encryptedFile,
+        ImageInfo(FileSourceInfo sourceInfo, const QJsonObject& infoJson,
                   const QString& originalFilename = {});
 
     public:
@@ -144,12 +140,13 @@ namespace EventContent {
     //!
     //! This class saves/loads a thumbnail to/from `info` subobject of
     //! the JSON representation of event content; namely, `info/thumbnail_url`
-    //! and `info/thumbnail_info` fields are used.
+    //! (or, in case of an encrypted thumbnail, `info/thumbnail_file`) and
+    //! `info/thumbnail_info` fields are used.
     class QUOTIENT_API Thumbnail : public ImageInfo {
     public:
         using ImageInfo::ImageInfo;
         Thumbnail(const QJsonObject& infoJson,
-                  Omittable<EncryptedFile> encryptedFile = none);
+                  const Omittable<EncryptedFileMetadata>& encryptedFile = none);
 
         //! \brief Add thumbnail information to the passed `info` JSON object
         void dumpTo(QJsonObject& infoJson) const;
@@ -169,10 +166,10 @@ namespace EventContent {
 
     //! \brief A template class for content types with a URL and additional info
     //!
-    //! Types that derive from this class template take `url` and,
-    //! optionally, `filename` values from the top-level JSON object and
-    //! the rest of information from the `info` subobject, as defined by
-    //! the parameter type.
+    //! Types that derive from this class template take `url` (or, if the file
+    //! is encrypted, `file`) and, optionally, `filename` values from
+    //! the top-level JSON object and the rest of information from the `info`
+    //! subobject, as defined by the parameter type.
     //! \tparam InfoT base info class - FileInfo or ImageInfo
     template <class InfoT>
     class UrlBasedContent : public TypedBase, public InfoT {
@@ -181,10 +178,12 @@ namespace EventContent {
         explicit UrlBasedContent(const QJsonObject& json)
             : TypedBase(json)
             , InfoT(QUrl(json["url"].toString()), json["info"].toObject(),
-                    fromJson<Omittable<EncryptedFile>>(json["file"]),
                     json["filename"].toString())
             , thumbnail(FileInfo::originalInfoJson)
         {
+            const auto efmJson = json.value("file"_ls).toObject();
+            if (!efmJson.isEmpty())
+                InfoT::source = fromJson<EncryptedFileMetadata>(efmJson);
             // Two small hacks on originalJson to expose mediaIds to QML
             originalJson.insert("mediaId", InfoT::mediaId());
             originalJson.insert("thumbnailMediaId", thumbnail.mediaId());
@@ -204,11 +203,7 @@ namespace EventContent {
 
         void fillJson(QJsonObject& json) const override
         {
-            if (!InfoT::file.has_value()) {
-                json.insert("url", InfoT::url.toString());
-            } else {
-                json.insert("file", Quotient::toJson(*InfoT::file));
-            }
+            Quotient::fillJson(json, { "url"_ls, "file"_ls }, InfoT::source);
             if (!InfoT::originalName.isEmpty())
                 json.insert("filename", InfoT::originalName);
             auto infoJson = toInfoJson(*this);
@@ -223,7 +218,7 @@ namespace EventContent {
     //!
     //! Available fields:
     //! - corresponding to the top-level JSON:
-    //!   - url
+    //!   - source (corresponding to `url` or `file` in JSON)
     //!   - filename (extension to the spec)
     //! - corresponding to the `info` subobject:
     //!   - payloadSize (`size` in JSON)
@@ -241,12 +236,12 @@ namespace EventContent {
     //!
     //! Available fields:
     //! - corresponding to the top-level JSON:
-    //!   - url
+    //!   - source (corresponding to `url` or `file` in JSON)
     //!   - filename
     //! - corresponding to the `info` subobject:
     //!   - payloadSize (`size` in JSON)
     //!   - mimeType (`mimetype` in JSON)
-    //!   - thumbnail.url (`thumbnail_url` in JSON)
+    //!   - thumbnail.source (`thumbnail_url` or `thumbnail_file` in JSON)
     //! - corresponding to the `info/thumbnail_info` subobject:
     //!   - thumbnail.payloadSize
     //!   - thumbnail.mimeType
diff --git a/lib/events/filesourceinfo.cpp b/lib/events/filesourceinfo.cpp
new file mode 100644
index 00000000..a64c7da8
--- /dev/null
+++ b/lib/events/filesourceinfo.cpp
@@ -0,0 +1,181 @@
+// SPDX-FileCopyrightText: 2021 Carl Schwan <carlschwan@kde.org>
+//
+// SPDX-License-Identifier: LGPL-2.1-or-later
+
+#include "filesourceinfo.h"
+
+#include "logging.h"
+
+#ifdef Quotient_E2EE_ENABLED
+#    include "e2ee/qolmutils.h"
+
+#    include <QtCore/QCryptographicHash>
+
+#    include <openssl/evp.h>
+#endif
+
+using namespace Quotient;
+
+QByteArray EncryptedFileMetadata::decryptFile(const QByteArray& ciphertext) const
+{
+#ifdef Quotient_E2EE_ENABLED
+    auto _key = key.k;
+    const auto keyBytes = QByteArray::fromBase64(
+        _key.replace(u'_', u'/').replace(u'-', u'+').toLatin1());
+    const auto sha256 =
+        QByteArray::fromBase64(hashes["sha256"_ls].toLatin1());
+    if (sha256
+        != QCryptographicHash::hash(ciphertext, QCryptographicHash::Sha256)) {
+        qCWarning(E2EE) << "Hash verification failed for file";
+        return {};
+    }
+    {
+        int length;
+        auto* ctx = EVP_CIPHER_CTX_new();
+        QByteArray plaintext(ciphertext.size() + EVP_MAX_BLOCK_LENGTH - 1, '\0');
+        EVP_DecryptInit_ex(
+            ctx, EVP_aes_256_ctr(), nullptr,
+            reinterpret_cast<const unsigned char*>(keyBytes.data()),
+            reinterpret_cast<const unsigned char*>(
+                QByteArray::fromBase64(iv.toLatin1()).data()));
+        EVP_DecryptUpdate(
+            ctx, reinterpret_cast<unsigned char*>(plaintext.data()), &length,
+            reinterpret_cast<const unsigned char*>(ciphertext.data()),
+            ciphertext.size());
+        EVP_DecryptFinal_ex(ctx,
+                            reinterpret_cast<unsigned char*>(plaintext.data())
+                                + length,
+                            &length);
+        EVP_CIPHER_CTX_free(ctx);
+        return plaintext.left(ciphertext.size());
+    }
+#else
+    qWarning(MAIN) << "This build of libQuotient doesn't support E2EE, "
+                      "cannot decrypt the file";
+    return ciphertext;
+#endif
+}
+
+std::pair<EncryptedFileMetadata, QByteArray> EncryptedFileMetadata::encryptFile(
+    const QByteArray& plainText)
+{
+#ifdef Quotient_E2EE_ENABLED
+    QByteArray k = getRandom(32);
+    auto kBase64 = k.toBase64();
+    QByteArray iv = getRandom(16);
+    JWK key = { "oct"_ls,
+                { "encrypt"_ls, "decrypt"_ls },
+                "A256CTR"_ls,
+                QString(k.toBase64())
+                    .replace(u'/', u'_')
+                    .replace(u'+', u'-')
+                    .left(kBase64.indexOf('=')),
+                true };
+
+    int length;
+    auto* ctx = EVP_CIPHER_CTX_new();
+    EVP_EncryptInit_ex(ctx, EVP_aes_256_ctr(), nullptr,
+                       reinterpret_cast<const unsigned char*>(k.data()),
+                       reinterpret_cast<const unsigned char*>(iv.data()));
+    const auto blockSize = EVP_CIPHER_CTX_block_size(ctx);
+    QByteArray cipherText(plainText.size() + blockSize - 1, '\0');
+    EVP_EncryptUpdate(ctx, reinterpret_cast<unsigned char*>(cipherText.data()),
+                      &length,
+                      reinterpret_cast<const unsigned char*>(plainText.data()),
+                      plainText.size());
+    EVP_EncryptFinal_ex(ctx,
+                        reinterpret_cast<unsigned char*>(cipherText.data())
+                            + length,
+                        &length);
+    EVP_CIPHER_CTX_free(ctx);
+
+    auto hash = QCryptographicHash::hash(cipherText, QCryptographicHash::Sha256)
+                    .toBase64();
+    auto ivBase64 = iv.toBase64();
+    EncryptedFileMetadata efm = { {},
+                           key,
+                           ivBase64.left(ivBase64.indexOf('=')),
+                           { { QStringLiteral("sha256"),
+                               hash.left(hash.indexOf('=')) } },
+                           "v2"_ls };
+    return { efm, cipherText };
+#else
+    return {};
+#endif
+}
+
+void JsonObjectConverter<EncryptedFileMetadata>::dumpTo(QJsonObject& jo,
+                                                const EncryptedFileMetadata& pod)
+{
+    addParam<>(jo, QStringLiteral("url"), pod.url);
+    addParam<>(jo, QStringLiteral("key"), pod.key);
+    addParam<>(jo, QStringLiteral("iv"), pod.iv);
+    addParam<>(jo, QStringLiteral("hashes"), pod.hashes);
+    addParam<>(jo, QStringLiteral("v"), pod.v);
+}
+
+void JsonObjectConverter<EncryptedFileMetadata>::fillFrom(const QJsonObject& jo,
+                                                  EncryptedFileMetadata& pod)
+{
+    fromJson(jo.value("url"_ls), pod.url);
+    fromJson(jo.value("key"_ls), pod.key);
+    fromJson(jo.value("iv"_ls), pod.iv);
+    fromJson(jo.value("hashes"_ls), pod.hashes);
+    fromJson(jo.value("v"_ls), pod.v);
+}
+
+void JsonObjectConverter<JWK>::dumpTo(QJsonObject& jo, const JWK& pod)
+{
+    addParam<>(jo, QStringLiteral("kty"), pod.kty);
+    addParam<>(jo, QStringLiteral("key_ops"), pod.keyOps);
+    addParam<>(jo, QStringLiteral("alg"), pod.alg);
+    addParam<>(jo, QStringLiteral("k"), pod.k);
+    addParam<>(jo, QStringLiteral("ext"), pod.ext);
+}
+
+void JsonObjectConverter<JWK>::fillFrom(const QJsonObject& jo, JWK& pod)
+{
+    fromJson(jo.value("kty"_ls), pod.kty);
+    fromJson(jo.value("key_ops"_ls), pod.keyOps);
+    fromJson(jo.value("alg"_ls), pod.alg);
+    fromJson(jo.value("k"_ls), pod.k);
+    fromJson(jo.value("ext"_ls), pod.ext);
+}
+
+template <typename... FunctorTs>
+struct Overloads : FunctorTs... {
+    using FunctorTs::operator()...;
+};
+
+template <typename... FunctorTs>
+Overloads(FunctorTs&&...) -> Overloads<FunctorTs...>;
+
+QUrl Quotient::getUrlFromSourceInfo(const FileSourceInfo& fsi)
+{
+    return std::visit(Overloads { [](const QUrl& url) { return url; },
+                                  [](const EncryptedFileMetadata& efm) {
+                                      return efm.url;
+                                  } },
+                      fsi);
+}
+
+void Quotient::setUrlInSourceInfo(FileSourceInfo& fsi, const QUrl& newUrl)
+{
+    std::visit(Overloads { [&newUrl](QUrl& url) { url = newUrl; },
+                           [&newUrl](EncryptedFileMetadata& efm) {
+                               efm.url = newUrl;
+                           } },
+               fsi);
+}
+
+void Quotient::fillJson(QJsonObject& jo,
+                        const std::array<QLatin1String, 2>& jsonKeys,
+                        const FileSourceInfo& fsi)
+{
+    // NB: Keeping variant_size_v out of the function signature for readability.
+    // NB2: Can't use jsonKeys directly inside static_assert as its value is
+    // unknown so the compiler cannot ensure size() is constexpr (go figure...)
+    static_assert(
+        std::variant_size_v<FileSourceInfo> == decltype(jsonKeys) {}.size());
+    jo.insert(jsonKeys[fsi.index()], toJson(fsi));
+}
diff --git a/lib/events/filesourceinfo.h b/lib/events/filesourceinfo.h
new file mode 100644
index 00000000..885601be
--- /dev/null
+++ b/lib/events/filesourceinfo.h
@@ -0,0 +1,89 @@
+// SPDX-FileCopyrightText: 2021 Carl Schwan <carlschwan@kde.org>
+//
+// SPDX-License-Identifier: LGPL-2.1-or-later
+
+#pragma once
+
+#include "converters.h"
+
+#include <array>
+
+namespace Quotient {
+/**
+ * JSON Web Key object as specified in
+ * https://spec.matrix.org/unstable/client-server-api/#extensions-to-mroommessage-msgtypes
+ * The only currently relevant member is `k`, the rest needs to be set to the defaults specified in the spec.
+ */
+struct JWK
+{
+    Q_GADGET
+    Q_PROPERTY(QString kty MEMBER kty CONSTANT)
+    Q_PROPERTY(QStringList keyOps MEMBER keyOps CONSTANT)
+    Q_PROPERTY(QString alg MEMBER alg CONSTANT)
+    Q_PROPERTY(QString k MEMBER k CONSTANT)
+    Q_PROPERTY(bool ext MEMBER ext CONSTANT)
+
+public:
+    QString kty;
+    QStringList keyOps;
+    QString alg;
+    QString k;
+    bool ext;
+};
+
+struct QUOTIENT_API EncryptedFileMetadata {
+    Q_GADGET
+    Q_PROPERTY(QUrl url MEMBER url CONSTANT)
+    Q_PROPERTY(JWK key MEMBER key CONSTANT)
+    Q_PROPERTY(QString iv MEMBER iv CONSTANT)
+    Q_PROPERTY(QHash<QString, QString> hashes MEMBER hashes CONSTANT)
+    Q_PROPERTY(QString v MEMBER v CONSTANT)
+
+public:
+    QUrl url;
+    JWK key;
+    QString iv;
+    QHash<QString, QString> hashes;
+    QString v;
+
+    static std::pair<EncryptedFileMetadata, QByteArray> encryptFile(
+        const QByteArray& plainText);
+    QByteArray decryptFile(const QByteArray& ciphertext) const;
+};
+
+template <>
+struct QUOTIENT_API JsonObjectConverter<EncryptedFileMetadata> {
+    static void dumpTo(QJsonObject& jo, const EncryptedFileMetadata& pod);
+    static void fillFrom(const QJsonObject& jo, EncryptedFileMetadata& pod);
+};
+
+template <>
+struct QUOTIENT_API JsonObjectConverter<JWK> {
+    static void dumpTo(QJsonObject& jo, const JWK& pod);
+    static void fillFrom(const QJsonObject& jo, JWK& pod);
+};
+
+using FileSourceInfo = std::variant<QUrl, EncryptedFileMetadata>;
+
+QUOTIENT_API QUrl getUrlFromSourceInfo(const FileSourceInfo& fsi);
+
+QUOTIENT_API void setUrlInSourceInfo(FileSourceInfo& fsi, const QUrl& newUrl);
+
+// The way FileSourceInfo is stored in JSON requires an extra parameter so
+// the original template is not applicable
+template <>
+void fillJson(QJsonObject&, const FileSourceInfo&) = delete;
+
+//! \brief Export FileSourceInfo to a JSON object
+//!
+//! Depending on what is stored inside FileSourceInfo, this function will insert
+//! - a key-to-string pair where key is taken from jsonKeys[0] and the string
+//!   is the URL, if FileSourceInfo stores a QUrl;
+//! - a key-to-object mapping where key is taken from jsonKeys[1] and the object
+//!   is the result of converting EncryptedFileMetadata to JSON,
+//!   if FileSourceInfo stores EncryptedFileMetadata
+QUOTIENT_API void fillJson(QJsonObject& jo,
+                           const std::array<QLatin1String, 2>& jsonKeys,
+                           const FileSourceInfo& fsi);
+
+} // namespace Quotient
diff --git a/lib/events/roomavatarevent.h b/lib/events/roomavatarevent.h
index c54b5801..af291696 100644
--- a/lib/events/roomavatarevent.h
+++ b/lib/events/roomavatarevent.h
@@ -26,10 +26,10 @@ public:
                              const QSize& imageSize = {},
                              const QString& originalFilename = {})
         : RoomAvatarEvent(EventContent::ImageContent {
-            mxcUrl, fileSize, mimeType, imageSize, none, originalFilename })
+            mxcUrl, fileSize, mimeType, imageSize, originalFilename })
     {}
 
-    QUrl url() const { return content().url; }
+    QUrl url() const { return content().url(); }
 };
 REGISTER_EVENT_TYPE(RoomAvatarEvent)
 } // namespace Quotient
diff --git a/lib/events/roommessageevent.cpp b/lib/events/roommessageevent.cpp
index d9d3fbe0..2a6ae93c 100644
--- a/lib/events/roommessageevent.cpp
+++ b/lib/events/roommessageevent.cpp
@@ -148,21 +148,21 @@ TypedBase* contentFromFile(const QFileInfo& file, bool asGenericFile)
         auto mimeTypeName = mimeType.name();
         if (mimeTypeName.startsWith("image/"))
             return new ImageContent(localUrl, file.size(), mimeType,
-                                    QImageReader(filePath).size(), none,
+                                    QImageReader(filePath).size(),
                                     file.fileName());
 
         // duration can only be obtained asynchronously and can only be reliably
         // done by starting to play the file. Left for a future implementation.
         if (mimeTypeName.startsWith("video/"))
             return new VideoContent(localUrl, file.size(), mimeType,
-                                    QMediaResource(localUrl).resolution(), none,
+                                    QMediaResource(localUrl).resolution(),
                                     file.fileName());
 
         if (mimeTypeName.startsWith("audio/"))
-            return new AudioContent(localUrl, file.size(), mimeType, none,
+            return new AudioContent(localUrl, file.size(), mimeType,
                                     file.fileName());
     }
-    return new FileContent(localUrl, file.size(), mimeType, none, file.fileName());
+    return new FileContent(localUrl, file.size(), mimeType, file.fileName());
 }
 
 RoomMessageEvent::RoomMessageEvent(const QString& plainBody,
diff --git a/lib/events/stickerevent.cpp b/lib/events/stickerevent.cpp
index 628fd154..6d318f0e 100644
--- a/lib/events/stickerevent.cpp
+++ b/lib/events/stickerevent.cpp
@@ -22,5 +22,5 @@ const EventContent::ImageContent &StickerEvent::image() const
 
 QUrl StickerEvent::url() const
 {
-    return m_imageContent.url;
+    return m_imageContent.url();
 }
diff --git a/lib/jobs/downloadfilejob.cpp b/lib/jobs/downloadfilejob.cpp
index d00fc5f4..85c235c7 100644
--- a/lib/jobs/downloadfilejob.cpp
+++ b/lib/jobs/downloadfilejob.cpp
@@ -8,8 +8,9 @@
 #include <QtNetwork/QNetworkReply>
 
 #ifdef Quotient_E2EE_ENABLED
-#   include <QtCore/QCryptographicHash>
-#   include "events/encryptedfile.h"
+#    include "events/filesourceinfo.h"
+
+#    include <QtCore/QCryptographicHash>
 #endif
 
 using namespace Quotient;
@@ -26,7 +27,7 @@ public:
     QScopedPointer<QFile> tempFile;
 
 #ifdef Quotient_E2EE_ENABLED
-    Omittable<EncryptedFile> encryptedFile;
+    Omittable<EncryptedFileMetadata> encryptedFile;
 #endif
 };
 
@@ -49,7 +50,7 @@ DownloadFileJob::DownloadFileJob(const QString& serverName,
 #ifdef Quotient_E2EE_ENABLED
 DownloadFileJob::DownloadFileJob(const QString& serverName,
                                  const QString& mediaId,
-                                 const EncryptedFile& file,
+                                 const EncryptedFileMetadata& file,
                                  const QString& localFilename)
     : GetContentJob(serverName, mediaId)
     , d(localFilename.isEmpty() ? makeImpl<Private>()
@@ -126,7 +127,7 @@ BaseJob::Status DownloadFileJob::prepareResult()
             d->tempFile->seek(0);
             QByteArray encrypted = d->tempFile->readAll();
 
-            EncryptedFile file = *d->encryptedFile;
+            EncryptedFileMetadata file = *d->encryptedFile;
             const auto decrypted = file.decryptFile(encrypted);
             d->targetFile->write(decrypted);
             d->tempFile->remove();
@@ -151,7 +152,7 @@ BaseJob::Status DownloadFileJob::prepareResult()
             d->tempFile->seek(0);
             const auto encrypted = d->tempFile->readAll();
 
-            EncryptedFile file = *d->encryptedFile;
+            EncryptedFileMetadata file = *d->encryptedFile;
             const auto decrypted = file.decryptFile(encrypted);
             d->tempFile->write(decrypted);
         } else {
diff --git a/lib/jobs/downloadfilejob.h b/lib/jobs/downloadfilejob.h
index ffa3d055..cbbfd244 100644
--- a/lib/jobs/downloadfilejob.h
+++ b/lib/jobs/downloadfilejob.h
@@ -4,7 +4,8 @@
 #pragma once
 
 #include "csapi/content-repo.h"
-#include "events/encryptedfile.h"
+
+#include "events/filesourceinfo.h"
 
 namespace Quotient {
 class QUOTIENT_API DownloadFileJob : public GetContentJob {
@@ -16,7 +17,7 @@ public:
                     const QString& localFilename = {});
 
 #ifdef Quotient_E2EE_ENABLED
-    DownloadFileJob(const QString& serverName, const QString& mediaId, const EncryptedFile& file, const QString& localFilename = {});
+    DownloadFileJob(const QString& serverName, const QString& mediaId, const EncryptedFileMetadata& file, const QString& localFilename = {});
 #endif
     QString targetFileName() const;
 
diff --git a/lib/mxcreply.cpp b/lib/mxcreply.cpp
index 319d514a..b7993ad5 100644
--- a/lib/mxcreply.cpp
+++ b/lib/mxcreply.cpp
@@ -8,7 +8,7 @@
 #include "room.h"
 
 #ifdef Quotient_E2EE_ENABLED
-#include "events/encryptedfile.h"
+#include "events/filesourceinfo.h"
 #endif
 
 using namespace Quotient;
@@ -20,7 +20,7 @@ public:
         : m_reply(r)
     {}
     QNetworkReply* m_reply;
-    Omittable<EncryptedFile> m_encryptedFile;
+    Omittable<EncryptedFileMetadata> m_encryptedFile;
     QIODevice* m_device = nullptr;
 };
 
@@ -47,7 +47,7 @@ MxcReply::MxcReply(QNetworkReply* reply, Room* room, const QString &eventId)
         if(!d->m_encryptedFile.has_value()) {
             d->m_device = d->m_reply;
         } else {
-            EncryptedFile file = *d->m_encryptedFile;
+            EncryptedFileMetadata file = *d->m_encryptedFile;
             auto buffer = new QBuffer(this);
             buffer->setData(file.decryptFile(d->m_reply->readAll()));
             buffer->open(ReadOnly);
@@ -64,7 +64,9 @@ MxcReply::MxcReply(QNetworkReply* reply, Room* room, const QString &eventId)
     auto eventIt = room->findInTimeline(eventId);
     if(eventIt != room->historyEdge()) {
         auto event = eventIt->viewAs<RoomMessageEvent>();
-        d->m_encryptedFile = event->content()->fileInfo()->file;
+        if (auto* efm = std::get_if<EncryptedFileMetadata>(
+                &event->content()->fileInfo()->source))
+            d->m_encryptedFile = *efm;
     }
 #endif
 }
diff --git a/lib/room.cpp b/lib/room.cpp
index 7022a49d..20ea1159 100644
--- a/lib/room.cpp
+++ b/lib/room.cpp
@@ -1525,7 +1525,7 @@ QUrl Room::urlToThumbnail(const QString& eventId) const
             auto* thumbnail = event->content()->thumbnailInfo();
             Q_ASSERT(thumbnail != nullptr);
             return connection()->getUrlForApi<MediaThumbnailJob>(
-                thumbnail->url, thumbnail->imageSize);
+                thumbnail->url(), thumbnail->imageSize);
         }
     qCDebug(MAIN) << "Event" << eventId << "has no thumbnail";
     return {};
@@ -1536,7 +1536,7 @@ QUrl Room::urlToDownload(const QString& eventId) const
     if (auto* event = d->getEventWithFile(eventId)) {
         auto* fileInfo = event->content()->fileInfo();
         Q_ASSERT(fileInfo != nullptr);
-        return connection()->getUrlForApi<DownloadFileJob>(fileInfo->url);
+        return connection()->getUrlForApi<DownloadFileJob>(fileInfo->url());
     }
     return {};
 }
@@ -2275,28 +2275,26 @@ QString Room::Private::doPostFile(RoomEventPtr&& msgEvent, const QUrl& localUrl)
     // Below, the upload job is used as a context object to clean up connections
     const auto& transferJob = fileTransfers.value(txnId).job;
     connect(q, &Room::fileTransferCompleted, transferJob,
-            [this, txnId](const QString& tId, const QUrl&, const QUrl& mxcUri, Omittable<EncryptedFile> encryptedFile) {
-                if (tId != txnId)
-                    return;
+        [this, txnId](const QString& tId, const QUrl&,
+                      const FileSourceInfo fileMetadata) {
+            if (tId != txnId)
+                return;
 
-                const auto it = q->findPendingEvent(txnId);
-                if (it != unsyncedEvents.end()) {
-                    it->setFileUploaded(mxcUri);
-                    if (encryptedFile) {
-                        it->setEncryptedFile(*encryptedFile);
-                    }
-                    emit q->pendingEventChanged(
-                        int(it - unsyncedEvents.begin()));
-                    doSendEvent(it->get());
-                } else {
-                    // Normally in this situation we should instruct
-                    // the media server to delete the file; alas, there's no
-                    // API specced for that.
-                    qCWarning(MAIN) << "File uploaded to" << mxcUri
-                                    << "but the event referring to it was "
-                                       "cancelled";
-                }
-            });
+            const auto it = q->findPendingEvent(txnId);
+            if (it != unsyncedEvents.end()) {
+                it->setFileUploaded(fileMetadata);
+                emit q->pendingEventChanged(int(it - unsyncedEvents.begin()));
+                doSendEvent(it->get());
+            } else {
+                // Normally in this situation we should instruct
+                // the media server to delete the file; alas, there's no
+                // API specced for that.
+                qCWarning(MAIN)
+                    << "File uploaded to" << getUrlFromSourceInfo(fileMetadata)
+                    << "but the event referring to it was "
+                       "cancelled";
+            }
+        });
     connect(q, &Room::fileTransferFailed, transferJob,
             [this, txnId](const QString& tId) {
                 if (tId != txnId)
@@ -2322,13 +2320,13 @@ QString Room::postFile(const QString& plainText,
     Q_ASSERT(content != nullptr && content->fileInfo() != nullptr);
     const auto* const fileInfo = content->fileInfo();
     Q_ASSERT(fileInfo != nullptr);
-    QFileInfo localFile { fileInfo->url.toLocalFile() };
+    QFileInfo localFile { fileInfo->url().toLocalFile() };
     Q_ASSERT(localFile.isFile());
 
     return d->doPostFile(
         makeEvent<RoomMessageEvent>(
             plainText, RoomMessageEvent::rawMsgTypeForFile(localFile), content),
-        fileInfo->url);
+        fileInfo->url());
 }
 
 #if QT_VERSION_MAJOR < 6
@@ -2520,18 +2518,19 @@ void Room::uploadFile(const QString& id, const QUrl& localFilename,
     Q_ASSERT_X(localFilename.isLocalFile(), __FUNCTION__,
                "localFilename should point at a local file");
     auto fileName = localFilename.toLocalFile();
-    Omittable<EncryptedFile> encryptedFile { none };
+    FileSourceInfo fileMetadata;
 #ifdef Quotient_E2EE_ENABLED
     QTemporaryFile tempFile;
     if (usesEncryption()) {
         tempFile.open();
         QFile file(localFilename.toLocalFile());
         file.open(QFile::ReadOnly);
-        auto [e, data] = EncryptedFile::encryptFile(file.readAll());
+        QByteArray data;
+        std::tie(fileMetadata, data) =
+            EncryptedFileMetadata::encryptFile(file.readAll());
         tempFile.write(data);
         tempFile.close();
         fileName = QFileInfo(tempFile).absoluteFilePath();
-        encryptedFile = e;
     }
 #endif
     auto job = connection()->uploadFile(fileName, overrideContentType);
@@ -2542,17 +2541,13 @@ void Room::uploadFile(const QString& id, const QUrl& localFilename,
                     d->fileTransfers[id].update(sent, total);
                     emit fileTransferProgress(id, sent, total);
                 });
-        connect(job, &BaseJob::success, this, [this, id, localFilename, job, encryptedFile] {
-            d->fileTransfers[id].status = FileTransferInfo::Completed;
-            if (encryptedFile) {
-                auto file = *encryptedFile;
-                file.url = QUrl(job->contentUri());
-                emit fileTransferCompleted(id, localFilename, QUrl(job->contentUri()), file);
-            } else {
-                emit fileTransferCompleted(id, localFilename, QUrl(job->contentUri()), none);
-            }
-
-        });
+        connect(job, &BaseJob::success, this,
+                [this, id, localFilename, job, fileMetadata]() mutable {
+                    // The lambda is mutable to change encryptedFileMetadata
+                    d->fileTransfers[id].status = FileTransferInfo::Completed;
+                    setUrlInSourceInfo(fileMetadata, QUrl(job->contentUri()));
+                    emit fileTransferCompleted(id, localFilename, fileMetadata);
+                });
         connect(job, &BaseJob::failure, this,
                 std::bind(&Private::failedTransfer, d, id, job->errorString()));
         emit newFileTransfer(id, localFilename);
@@ -2585,11 +2580,11 @@ void Room::downloadFile(const QString& eventId, const QUrl& localFilename)
                         << "has an empty or malformed mxc URL; won't download";
         return;
     }
-    const auto fileUrl = fileInfo->url;
+    const auto fileUrl = fileInfo->url();
     auto filePath = localFilename.toLocalFile();
     if (filePath.isEmpty()) { // Setup default file path
         filePath =
-            fileInfo->url.path().mid(1) % '_' % d->fileNameToDownload(event);
+            fileInfo->url().path().mid(1) % '_' % d->fileNameToDownload(event);
 
         if (filePath.size() > 200) // If too long, elide in the middle
             filePath.replace(128, filePath.size() - 192, "---");
@@ -2599,9 +2594,9 @@ void Room::downloadFile(const QString& eventId, const QUrl& localFilename)
     }
     DownloadFileJob *job = nullptr;
 #ifdef Quotient_E2EE_ENABLED
-    if(fileInfo->file.has_value()) {
-        auto file = *fileInfo->file;
-        job = connection()->downloadFile(fileUrl, file, filePath);
+    if (auto* fileMetadata =
+            std::get_if<EncryptedFileMetadata>(&fileInfo->source)) {
+        job = connection()->downloadFile(fileUrl, *fileMetadata, filePath);
     } else {
 #endif
     job = connection()->downloadFile(fileUrl, filePath);
@@ -2619,7 +2614,7 @@ void Room::downloadFile(const QString& eventId, const QUrl& localFilename)
         connect(job, &BaseJob::success, this, [this, eventId, fileUrl, job] {
             d->fileTransfers[eventId].status = FileTransferInfo::Completed;
             emit fileTransferCompleted(
-                eventId, fileUrl, QUrl::fromLocalFile(job->targetFileName()), none);
+                eventId, fileUrl, QUrl::fromLocalFile(job->targetFileName()));
         });
         connect(job, &BaseJob::failure, this,
                 std::bind(&Private::failedTransfer, d, eventId,
diff --git a/lib/room.h b/lib/room.h
index c3bdc4a0..0636c4bb 100644
--- a/lib/room.h
+++ b/lib/room.h
@@ -999,7 +999,8 @@ Q_SIGNALS:
 
     void newFileTransfer(QString id, QUrl localFile);
     void fileTransferProgress(QString id, qint64 progress, qint64 total);
-    void fileTransferCompleted(QString id, QUrl localFile, QUrl mxcUrl, Omittable<EncryptedFile> encryptedFile);
+    void fileTransferCompleted(QString id, QUrl localFile,
+                               FileSourceInfo fileMetadata);
     void fileTransferFailed(QString id, QString errorMessage = {});
     // fileTransferCancelled() is no more here; use fileTransferFailed() and
     // check the transfer status instead
diff --git a/quotest/quotest.cpp b/quotest/quotest.cpp
index 1eed865f..6bcd71cd 100644
--- a/quotest/quotest.cpp
+++ b/quotest/quotest.cpp
@@ -516,7 +516,7 @@ bool TestSuite::checkFileSendingOutcome(const TestToken& thisTest,
                         && e.hasFileContent()
                         && e.content()->fileInfo()->originalName == fileName
                         && testDownload(targetRoom->connection()->makeMediaUrl(
-                            e.content()->fileInfo()->url)));
+                            e.content()->fileInfo()->url())));
                 },
                 [this, thisTest](const RoomEvent&) { FAIL_TEST(); });
         });
-- 
cgit v1.2.3


From e2ea64c603b1e4b2184e363ee0d0a13fa0e286a0 Mon Sep 17 00:00:00 2001
From: Alexey Rusakov <Kitsune-Ral@users.sf.net>
Date: Mon, 11 Jul 2022 10:15:09 +0200
Subject: Add QUOTIENT_API to RoomStateView

Fixing link errors at non-template RoomStateView::get() when building
with libQuotient as a shared object. There's also a test in quotest.cpp
now to cover that case.
---
 lib/roomstateview.h | 3 ++-
 quotest/quotest.cpp | 8 ++++++++
 2 files changed, 10 insertions(+), 1 deletion(-)

(limited to 'quotest')

diff --git a/lib/roomstateview.h b/lib/roomstateview.h
index cab69ae3..29cce00e 100644
--- a/lib/roomstateview.h
+++ b/lib/roomstateview.h
@@ -11,7 +11,8 @@ namespace Quotient {
 
 class Room;
 
-class RoomStateView : private QHash<StateEventKey, const StateEventBase*> {
+class QUOTIENT_API RoomStateView
+    : private QHash<StateEventKey, const StateEventBase*> {
     Q_GADGET
 public:
     const QHash<StateEventKey, const StateEventBase*>& events() const
diff --git a/quotest/quotest.cpp b/quotest/quotest.cpp
index 6bcd71cd..90a5a69b 100644
--- a/quotest/quotest.cpp
+++ b/quotest/quotest.cpp
@@ -588,6 +588,14 @@ TEST_IMPL(changeName)
                         if (!rme->newDisplayName()
                             || *rme->newDisplayName() != newName)
                             FAIL_TEST();
+                        // State events coming in the timeline are first
+                        // processed to change the room state and then as
+                        // timeline messages; aboutToAddNewMessages is triggered
+                        // when the state is already updated, so check that
+                        if (targetRoom->currentState().get<RoomMemberEvent>(
+                                localUser->id())
+                            != rme)
+                            FAIL_TEST();
                         clog << "Member rename successful, renaming the account"
                              << endl;
                         const auto newN = newName.mid(0, 5);
-- 
cgit v1.2.3


From 4ad2f6e165a4eb486155eae652e187dc4d6b7d99 Mon Sep 17 00:00:00 2001
From: Alexey Rusakov <Kitsune-Ral@users.sf.net>
Date: Thu, 25 Aug 2022 20:02:35 +0200
Subject: Cleanup

---
 lib/connection.cpp  |  7 +++----
 lib/connection.h    | 13 ++-----------
 lib/room.cpp        |  1 +
 quotest/quotest.cpp |  1 +
 4 files changed, 7 insertions(+), 15 deletions(-)

(limited to 'quotest')

diff --git a/lib/connection.cpp b/lib/connection.cpp
index 9e4444df..98720f3b 100644
--- a/lib/connection.cpp
+++ b/lib/connection.cpp
@@ -6,11 +6,12 @@
 
 #include "connection.h"
 
+#include "accountregistry.h"
 #include "connectiondata.h"
+#include "qt_connection_util.h"
 #include "room.h"
 #include "settings.h"
 #include "user.h"
-#include "accountregistry.h"
 
 // NB: since Qt 6, moc_connection.cpp needs Room and User fully defined
 #include "moc_connection.cpp"
@@ -20,10 +21,8 @@
 #include "csapi/joining.h"
 #include "csapi/leaving.h"
 #include "csapi/logout.h"
-#include "csapi/receipts.h"
 #include "csapi/room_send.h"
 #include "csapi/to_device.h"
-#include "csapi/versions.h"
 #include "csapi/voip.h"
 #include "csapi/wellknown.h"
 #include "csapi/whoami.h"
@@ -2184,8 +2183,8 @@ PicklingMode Connection::picklingMode() const
 
 void Connection::saveOlmAccount()
 {
-    qCDebug(E2EE) << "Saving olm account";
 #ifdef Quotient_E2EE_ENABLED
+    qCDebug(E2EE) << "Saving olm account";
     if (const auto expectedPickle = d->olmAccount->pickle(d->picklingMode))
         d->database->setAccountPickle(*expectedPickle);
     else
diff --git a/lib/connection.h b/lib/connection.h
index 0d0c85b6..0e0abc39 100644
--- a/lib/connection.h
+++ b/lib/connection.h
@@ -5,13 +5,12 @@
 
 #pragma once
 
-#include "ssosession.h"
-#include "qt_connection_util.h"
 #include "quotient_common.h"
+#include "ssosession.h"
 #include "util.h"
 
-#include "csapi/login.h"
 #include "csapi/create_room.h"
+#include "csapi/login.h"
 
 #include "events/accountdataevents.h"
 
@@ -379,20 +378,12 @@ public:
 
     /**
      * Call this before first sync to load from previously saved file.
-     *
-     * \param fromFile A local path to read the state from. Uses QUrl
-     * to be QML-friendly. Empty parameter means saving to the directory
-     * defined by stateCachePath() / stateCacheDir().
      */
     Q_INVOKABLE void loadState();
     /**
      * This method saves the current state of rooms (but not messages
      * in them) to a local cache file, so that it could be loaded by
      * loadState() on a next run of the client.
-     *
-     * \param toFile A local path to save the state to. Uses QUrl to be
-     * QML-friendly. Empty parameter means saving to the directory
-     * defined by stateCachePath() / stateCacheDir().
      */
     Q_INVOKABLE void saveState() const;
 
diff --git a/lib/room.cpp b/lib/room.cpp
index c6fbb353..007446dc 100644
--- a/lib/room.cpp
+++ b/lib/room.cpp
@@ -16,6 +16,7 @@
 #include "user.h"
 #include "eventstats.h"
 #include "roomstateview.h"
+#include "qt_connection_util.h"
 
 // NB: since Qt 6, moc_room.cpp needs User fully defined
 #include "moc_room.cpp"
diff --git a/quotest/quotest.cpp b/quotest/quotest.cpp
index 90a5a69b..b6c855bb 100644
--- a/quotest/quotest.cpp
+++ b/quotest/quotest.cpp
@@ -6,6 +6,7 @@
 #include "user.h"
 #include "uriresolver.h"
 #include "networkaccessmanager.h"
+#include "qt_connection_util.h"
 
 #include "csapi/joining.h"
 #include "csapi/leaving.h"
-- 
cgit v1.2.3


From a26147582ce8cbd6a5206aee4b59de98c9dfe9b6 Mon Sep 17 00:00:00 2001
From: Alexey Rusakov <Kitsune-Ral@users.sf.net>
Date: Wed, 27 Jul 2022 20:19:44 +0200
Subject: DEFINE_SIMPLE_EVENT: support custom JSON keys

---
 CMakeLists.txt                 |  2 +-
 lib/connection.cpp             |  2 +-
 lib/connection.h               |  2 +-
 lib/events/accountdataevents.h | 18 +++++++++++------
 lib/events/event.h             | 46 ++++++++++++++++++++++--------------------
 lib/events/reactionevent.h     | 17 ++--------------
 lib/events/typingevent.cpp     | 11 ----------
 lib/events/typingevent.h       | 10 +--------
 lib/room.cpp                   |  2 +-
 quotest/quotest.cpp            |  3 ++-
 10 files changed, 45 insertions(+), 68 deletions(-)
 delete mode 100644 lib/events/typingevent.cpp

(limited to 'quotest')

diff --git a/CMakeLists.txt b/CMakeLists.txt
index f8667645..06e754aa 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -154,7 +154,7 @@ list(APPEND lib_SRCS
     lib/events/roomcanonicalaliasevent.h
     lib/events/roomavatarevent.h
     lib/events/roompowerlevelsevent.h lib/events/roompowerlevelsevent.cpp
-    lib/events/typingevent.h lib/events/typingevent.cpp
+    lib/events/typingevent.h
     lib/events/accountdataevents.h
     lib/events/receiptevent.h lib/events/receiptevent.cpp
     lib/events/reactionevent.h
diff --git a/lib/connection.cpp b/lib/connection.cpp
index 79d7ae55..722829e8 100644
--- a/lib/connection.cpp
+++ b/lib/connection.cpp
@@ -1701,7 +1701,7 @@ bool Connection::isIgnored(const User* user) const
 IgnoredUsersList Connection::ignoredUsers() const
 {
     const auto* event = accountData<IgnoredUsersEvent>();
-    return event ? event->ignored_users() : IgnoredUsersList();
+    return event ? event->ignoredUsers() : IgnoredUsersList();
 }
 
 void Connection::addToIgnoredUsers(const User* user)
diff --git a/lib/connection.h b/lib/connection.h
index 39921938..66ed8b68 100644
--- a/lib/connection.h
+++ b/lib/connection.h
@@ -111,7 +111,7 @@ auto defaultUserFactory(Connection* c, const QString& id)
 // are stored with no regard to their state.
 using DirectChatsMap = QMultiHash<const User*, QString>;
 using DirectChatUsersMap = QMultiHash<QString, User*>;
-using IgnoredUsersList = IgnoredUsersEvent::content_type;
+using IgnoredUsersList = IgnoredUsersEvent::value_type;
 
 class QUOTIENT_API Connection : public QObject {
     Q_OBJECT
diff --git a/lib/events/accountdataevents.h b/lib/events/accountdataevents.h
index 24c3353c..324ce449 100644
--- a/lib/events/accountdataevents.h
+++ b/lib/events/accountdataevents.h
@@ -4,7 +4,6 @@
 #pragma once
 
 #include "event.h"
-#include "util.h"
 
 namespace Quotient {
 constexpr auto FavouriteTag [[maybe_unused]] = "m.favourite"_ls;
@@ -46,14 +45,21 @@ struct JsonObjectConverter<TagRecord> {
 
 using TagsMap = QHash<QString, TagRecord>;
 
-DEFINE_SIMPLE_EVENT(TagEvent, Event, "m.tag", TagsMap, tags)
-DEFINE_SIMPLE_EVENT(ReadMarkerEventImpl, Event, "m.fully_read", QString, eventId)
+DEFINE_SIMPLE_EVENT(TagEvent, Event, "m.tag", TagsMap, tags, "tags")
+DEFINE_SIMPLE_EVENT(ReadMarkerEventImpl, Event, "m.fully_read", QString,
+                    eventId, "event_id")
 class ReadMarkerEvent : public ReadMarkerEventImpl {
 public:
     using ReadMarkerEventImpl::ReadMarkerEventImpl;
     [[deprecated("Use ReadMarkerEvent::eventId() instead")]]
-    QString event_id() const { return eventId(); }
+    auto event_id() const { return eventId(); }
+};
+DEFINE_SIMPLE_EVENT(IgnoredUsersEventImpl, Event, "m.ignored_user_list",
+                    QSet<QString>, ignoredUsers, "ignored_users")
+class IgnoredUsersEvent : public IgnoredUsersEventImpl {
+public:
+    using IgnoredUsersEventImpl::IgnoredUsersEventImpl;
+    [[deprecated("Use IgnoredUsersEvent::ignoredUsers() instead")]]
+    auto ignored_users() const { return ignoredUsers(); }
 };
-DEFINE_SIMPLE_EVENT(IgnoredUsersEvent, Event, "m.ignored_user_list", QSet<QString>,
-                    ignored_users)
 } // namespace Quotient
diff --git a/lib/events/event.h b/lib/events/event.h
index b7454337..711f8fd4 100644
--- a/lib/events/event.h
+++ b/lib/events/event.h
@@ -6,6 +6,7 @@
 #include "converters.h"
 #include "logging.h"
 #include "function_traits.h"
+#include "single_key_value.h"
 
 namespace Quotient {
 // === event_ptr_tt<> and type casting facilities ===
@@ -258,6 +259,13 @@ template <typename EventT>
 using EventsArray = std::vector<event_ptr_tt<EventT>>;
 using Events = EventsArray<Event>;
 
+#define QUO_CONTENT_GETTER_X(PartType_, PartName_, JsonKey_) \
+    PartType_ PartName_() const                                 \
+    {                                                           \
+        static const auto PartName_##JsonKey = JsonKey_;        \
+        return contentPart<PartType_>(PartName_##JsonKey);      \
+    }
+
 //! \brief Define an inline method obtaining a content part
 //!
 //! This macro adds a const method that extracts a JSON value at the key
@@ -266,12 +274,8 @@ using Events = EventsArray<Event>;
 //! \code
 //! contentPart<PartType_>(Quotient::toSnakeCase(#PartName_##_ls));
 //! \endcode
-#define QUO_CONTENT_GETTER(PartType_, PartName_)                  \
-    PartType_ PartName_() const                                   \
-    {                                                             \
-        static const auto JsonKey = toSnakeCase(#PartName_##_ls); \
-        return contentPart<PartType_>(JsonKey);                   \
-    }
+#define QUO_CONTENT_GETTER(PartType_, PartName_) \
+    QUO_CONTENT_GETTER_X(PartType_, PartName_, toSnakeCase(#PartName_##_ls))
 
 // === Facilities for event class definitions ===
 
@@ -301,22 +305,20 @@ using Events = EventsArray<Event>;
 /// To retrieve the value the getter uses a JSON key name that corresponds to
 /// its own (getter's) name but written in snake_case. \p GetterName_ must be
 /// in camelCase, no quotes (an identifier, not a literal).
-#define DEFINE_SIMPLE_EVENT(Name_, Base_, TypeId_, ValueType_, GetterName_)     \
-    class QUOTIENT_API Name_ : public Base_ {                                   \
-    public:                                                                     \
-        using content_type = ValueType_;                                        \
-        DEFINE_EVENT_TYPEID(TypeId_, Name_)                                     \
-        explicit Name_(const QJsonObject& obj) : Base_(TypeId, obj) {}          \
-        explicit Name_(const content_type& content)                             \
-            : Name_(Base_::basicJson(TypeId, { { JsonKey, toJson(content) } })) \
-        {}                                                                      \
-        auto GetterName_() const                                                \
-        {                                                                       \
-            return contentPart<content_type>(JsonKey);                          \
-        }                                                                       \
-        static inline const auto JsonKey = toSnakeCase(#GetterName_##_ls);      \
-    };                                                                          \
-    REGISTER_EVENT_TYPE(Name_)                                                  \
+#define DEFINE_SIMPLE_EVENT(Name_, Base_, TypeId_, ValueType_, GetterName_, \
+                            JsonKey_)                                       \
+    class QUOTIENT_API Name_ : public Base_ {                               \
+    public:                                                                 \
+        DEFINE_EVENT_TYPEID(TypeId_, Name_)                                 \
+        using value_type = ValueType_;                                      \
+        explicit Name_(const QJsonObject& obj) : Base_(TypeId, obj) {}      \
+        explicit Name_(const value_type& v)                                 \
+            : Name_(Base_::basicJson(TypeId, { { JsonKey, toJson(v) } }))   \
+        {}                                                                  \
+        QUO_CONTENT_GETTER_X(ValueType_, GetterName_, JsonKey)              \
+        static inline const auto JsonKey = toSnakeCase(#GetterName_##_ls);  \
+    };                                                                      \
+    REGISTER_EVENT_TYPE(Name_)                                              \
     // End of macro
 
 // === is<>(), eventCast<>() and switchOnType<>() ===
diff --git a/lib/events/reactionevent.h b/lib/events/reactionevent.h
index b3cb3ca7..8d873441 100644
--- a/lib/events/reactionevent.h
+++ b/lib/events/reactionevent.h
@@ -8,20 +8,7 @@
 
 namespace Quotient {
 
-class QUOTIENT_API ReactionEvent : public RoomEvent {
-public:
-    DEFINE_EVENT_TYPEID("m.reaction", ReactionEvent)
-
-    explicit ReactionEvent(const EventRelation& value)
-        : RoomEvent(typeId(), matrixTypeId(),
-                    { { QStringLiteral("m.relates_to"), toJson(value) } })
-    {}
-    explicit ReactionEvent(const QJsonObject& obj) : RoomEvent(typeId(), obj) {}
-    EventRelation relation() const
-    {
-        return contentPart<EventRelation>(RelatesToKey);
-    }
-};
-REGISTER_EVENT_TYPE(ReactionEvent)
+DEFINE_SIMPLE_EVENT(ReactionEvent, RoomEvent, "m.reaction", EventRelation,
+                    relation, "m.relates_to")
 
 } // namespace Quotient
diff --git a/lib/events/typingevent.cpp b/lib/events/typingevent.cpp
deleted file mode 100644
index 7e5d7ee6..00000000
--- a/lib/events/typingevent.cpp
+++ /dev/null
@@ -1,11 +0,0 @@
-// SPDX-FileCopyrightText: 2017 Kitsune Ral <Kitsune-Ral@users.sf.net>
-// SPDX-License-Identifier: LGPL-2.1-or-later
-
-#include "typingevent.h"
-
-using namespace Quotient;
-
-QStringList TypingEvent::users() const
-{
-    return contentPart<QStringList>("user_ids"_ls);
-}
diff --git a/lib/events/typingevent.h b/lib/events/typingevent.h
index 522f7e42..b56475af 100644
--- a/lib/events/typingevent.h
+++ b/lib/events/typingevent.h
@@ -6,13 +6,5 @@
 #include "event.h"
 
 namespace Quotient {
-class QUOTIENT_API TypingEvent : public Event {
-public:
-    DEFINE_EVENT_TYPEID("m.typing", TypingEvent)
-
-    explicit TypingEvent(const QJsonObject& obj) : Event(typeId(), obj) {}
-
-    QStringList users() const;
-};
-REGISTER_EVENT_TYPE(TypingEvent)
+DEFINE_SIMPLE_EVENT(TypingEvent, Event, "m.typing", QStringList, users, "user_ids")
 } // namespace Quotient
diff --git a/lib/room.cpp b/lib/room.cpp
index ebc6e6af..4cae2333 100644
--- a/lib/room.cpp
+++ b/lib/room.cpp
@@ -3294,7 +3294,7 @@ Room::Changes Room::processAccountDataEvent(EventPtr&& event)
     }
 
     if (auto* evt = eventCast<const ReadMarkerEvent>(event))
-        changes |= d->setFullyReadMarker(evt->event_id());
+        changes |= d->setFullyReadMarker(evt->eventId());
 
     // For all account data events
     auto& currentData = d->accountData[event->matrixType()];
diff --git a/quotest/quotest.cpp b/quotest/quotest.cpp
index b6c855bb..3860ae1e 100644
--- a/quotest/quotest.cpp
+++ b/quotest/quotest.cpp
@@ -524,7 +524,8 @@ bool TestSuite::checkFileSendingOutcome(const TestToken& thisTest,
     return true;
 }
 
-DEFINE_SIMPLE_EVENT(CustomEvent, RoomEvent, "quotest.custom", int, testValue)
+DEFINE_SIMPLE_EVENT(CustomEvent, RoomEvent, "quotest.custom", int, testValue,
+                    "test_value")
 
 TEST_IMPL(sendCustomEvent)
 {
-- 
cgit v1.2.3


From 80499cc7619bb857c284e6e89db728ccee9c61f6 Mon Sep 17 00:00:00 2001
From: Alexey Rusakov <Kitsune-Ral@users.sf.net>
Date: Sat, 3 Sep 2022 19:12:42 +0200
Subject: More cleanup

---
 lib/events/encryptedevent.cpp   |  7 ++++---
 lib/events/encryptedevent.h     |  7 ++++---
 lib/events/event.h              |  2 +-
 lib/events/roommessageevent.cpp |  5 ++---
 lib/expected.h                  |  7 ++++---
 lib/room.cpp                    | 16 ++++++++--------
 lib/room.h                      |  7 +++----
 quotest/quotest.cpp             |  2 +-
 8 files changed, 27 insertions(+), 26 deletions(-)

(limited to 'quotest')

diff --git a/lib/events/encryptedevent.cpp b/lib/events/encryptedevent.cpp
index e9b4a585..94b44901 100644
--- a/lib/events/encryptedevent.cpp
+++ b/lib/events/encryptedevent.cpp
@@ -6,14 +6,15 @@
 
 using namespace Quotient;
 
-EncryptedEvent::EncryptedEvent(const QJsonObject& ciphertext,
+EncryptedEvent::EncryptedEvent(const QJsonObject& ciphertexts,
                                const QString& senderKey)
     : RoomEvent({ { AlgorithmKeyL, OlmV1Curve25519AesSha2AlgoKey },
-                  { CiphertextKeyL, ciphertext },
+                  { CiphertextKeyL, ciphertexts },
                   { SenderKeyKeyL, senderKey } })
 {}
 
-EncryptedEvent::EncryptedEvent(QByteArray ciphertext, const QString& senderKey,
+EncryptedEvent::EncryptedEvent(const QByteArray& ciphertext,
+                               const QString& senderKey,
                                const QString& deviceId, const QString& sessionId)
     : RoomEvent({
         { AlgorithmKeyL, MegolmV1AesSha2AlgoKey },
diff --git a/lib/events/encryptedevent.h b/lib/events/encryptedevent.h
index 22e51cb8..02d4c7aa 100644
--- a/lib/events/encryptedevent.h
+++ b/lib/events/encryptedevent.h
@@ -32,11 +32,12 @@ public:
     /* In case with Olm, the encrypted content of the event is
      * a map from the recipient Curve25519 identity key to ciphertext
      * information */
-    explicit EncryptedEvent(const QJsonObject& ciphertext,
+    explicit EncryptedEvent(const QJsonObject& ciphertexts,
                             const QString& senderKey);
     /* In case with Megolm, device_id and session_id are required */
-    explicit EncryptedEvent(QByteArray ciphertext, const QString& senderKey,
-                            const QString& deviceId, const QString& sessionId);
+    explicit EncryptedEvent(const QByteArray& ciphertext,
+                            const QString& senderKey, const QString& deviceId,
+                            const QString& sessionId);
     explicit EncryptedEvent(const QJsonObject& obj);
 
     QString algorithm() const;
diff --git a/lib/events/event.h b/lib/events/event.h
index 4b715813..ea5a2554 100644
--- a/lib/events/event.h
+++ b/lib/events/event.h
@@ -269,7 +269,7 @@ public:
     explicit Event(const QJsonObject& json);
 
     Q_DISABLE_COPY(Event)
-    Event(Event&&) = default;
+    Event(Event&&) noexcept = default;
     Event& operator=(Event&&) = delete;
     virtual ~Event();
 
diff --git a/lib/events/roommessageevent.cpp b/lib/events/roommessageevent.cpp
index db5afaf1..df4840b3 100644
--- a/lib/events/roommessageevent.cpp
+++ b/lib/events/roommessageevent.cpp
@@ -128,9 +128,8 @@ QJsonObject RoomMessageEvent::assembleContentJson(const QString& plainBody,
 RoomMessageEvent::RoomMessageEvent(const QString& plainBody,
                                    const QString& jsonMsgType,
                                    TypedBase* content)
-    : RoomEvent(RoomEvent::basicJson(TypeId,
-                                     assembleContentJson(plainBody, jsonMsgType,
-                                                         content)))
+    : RoomEvent(
+        basicJson(TypeId, assembleContentJson(plainBody, jsonMsgType, content)))
     , _content(content)
 {}
 
diff --git a/lib/expected.h b/lib/expected.h
index 7b9e7f1d..81e186ea 100644
--- a/lib/expected.h
+++ b/lib/expected.h
@@ -21,11 +21,12 @@ public:
     using error_type = E;
 
     Expected() = default;
-    explicit Expected(const Expected&) = default;
-    explicit Expected(Expected&&) noexcept = default;
+    Expected(const Expected&) = default;
+    Expected(Expected&&) noexcept = default;
+    ~Expected() = default;
 
     template <typename X, typename = enable_if_constructible_t<X>>
-    Expected(X&& x)
+    QUO_IMPLICIT Expected(X&& x) // NOLINT(google-explicit-constructor)
         : data(std::forward<X>(x))
     {}
 
diff --git a/lib/room.cpp b/lib/room.cpp
index f11b03e1..042d38ac 100644
--- a/lib/room.cpp
+++ b/lib/room.cpp
@@ -26,13 +26,13 @@
 #include "csapi/inviting.h"
 #include "csapi/kicking.h"
 #include "csapi/leaving.h"
+#include "csapi/read_markers.h"
 #include "csapi/receipts.h"
 #include "csapi/redaction.h"
 #include "csapi/room_send.h"
 #include "csapi/room_state.h"
 #include "csapi/room_upgrades.h"
 #include "csapi/rooms.h"
-#include "csapi/read_markers.h"
 #include "csapi/tags.h"
 
 #include "events/callanswerevent.h"
@@ -44,15 +44,15 @@
 #include "events/receiptevent.h"
 #include "events/redactionevent.h"
 #include "events/roomavatarevent.h"
+#include "events/roomcanonicalaliasevent.h"
 #include "events/roomcreateevent.h"
 #include "events/roommemberevent.h"
+#include "events/roompowerlevelsevent.h"
 #include "events/roomtombstoneevent.h"
 #include "events/simplestateevents.h"
 #include "events/typingevent.h"
-#include "events/roompowerlevelsevent.h"
 #include "jobs/downloadfilejob.h"
 #include "jobs/mediathumbnailjob.h"
-#include "events/roomcanonicalaliasevent.h"
 
 #include <QtCore/QDir>
 #include <QtCore/QHash>
@@ -1353,7 +1353,7 @@ void Room::setTags(TagsMap newTags, ActionScope applyOn)
 
     d->setTags(move(newTags));
     connection()->callApi<SetAccountDataPerRoomJob>(
-        localUser()->id(), id(), TagEvent::matrixTypeId(),
+        localUser()->id(), id(), TagEvent::TypeId,
         TagEvent(d->tags).contentJson());
 
     if (propagate) {
@@ -2635,10 +2635,10 @@ RoomEventPtr makeRedacted(const RoomEvent& target,
         QStringLiteral("membership") };
     // clang-format on
 
-    static const std::pair<event_type_t, QStringList> keepContentKeysMap[] {
-        { RoomMemberEvent::typeId(), { QStringLiteral("membership") } },
-        { RoomCreateEvent::typeId(), { QStringLiteral("creator") } },
-        { RoomPowerLevelsEvent::typeId(),
+    static const std::pair<event_type_t, QStringList> keepContentKeysMap[]{
+        { RoomMemberEvent::TypeId, { QStringLiteral("membership") } },
+        { RoomCreateEvent::TypeId, { QStringLiteral("creator") } },
+        { RoomPowerLevelsEvent::TypeId,
           { QStringLiteral("ban"), QStringLiteral("events"),
             QStringLiteral("events_default"), QStringLiteral("kick"),
             QStringLiteral("redact"), QStringLiteral("state_default"),
diff --git a/lib/room.h b/lib/room.h
index 44504691..b454bfbc 100644
--- a/lib/room.h
+++ b/lib/room.h
@@ -770,11 +770,10 @@ public:
                  "make sure to check its result for nullptrs")]] //
     const EvT* getCurrentState(const QString& stateKey = {}) const
     {
-        QT_IGNORE_DEPRECATIONS(
-            const auto* evt = eventCast<const EvT>(
-                getCurrentState(EvT::matrixTypeId(), stateKey));)
+        QT_IGNORE_DEPRECATIONS(const auto* evt = eventCast<const EvT>(
+                                   getCurrentState(EvT::TypeId, stateKey));)
         Q_ASSERT(evt);
-        Q_ASSERT(evt->matrixTypeId() == EvT::matrixTypeId()
+        Q_ASSERT(evt->matrixType() == EvT::TypeId
                  && evt->stateKey() == stateKey);
         return evt;
     }
diff --git a/quotest/quotest.cpp b/quotest/quotest.cpp
index 3860ae1e..3ac6404a 100644
--- a/quotest/quotest.cpp
+++ b/quotest/quotest.cpp
@@ -163,7 +163,7 @@ bool TestSuite::validatePendingEvent(const QString& txnId)
     return it != targetRoom->pendingEvents().end()
            && it->deliveryStatus() == EventStatus::Submitted
            && (*it)->transactionId() == txnId && is<EventT>(**it)
-           && (*it)->matrixType() == EventT::matrixTypeId();
+           && (*it)->matrixType() == EventT::TypeId;
 }
 
 void TestSuite::finishTest(const TestToken& token, bool condition,
-- 
cgit v1.2.3


From bde38f86337d6f49b34b38016ab088d2f48ec371 Mon Sep 17 00:00:00 2001
From: Alexey Rusakov <Kitsune-Ral@users.sf.net>
Date: Mon, 1 Aug 2022 18:09:47 +0200
Subject: concept EventClass

Constrain types to derive from Event (or the chosen class), where
applicable.
---
 lib/connection.cpp  |  2 +-
 lib/connection.h    |  2 +-
 lib/eventitem.h     |  4 ++--
 lib/events/event.h  | 43 ++++++++++++++++++++++++++-----------------
 quotest/quotest.cpp |  4 ++--
 5 files changed, 32 insertions(+), 23 deletions(-)

(limited to 'quotest')

diff --git a/lib/connection.cpp b/lib/connection.cpp
index a33ace51..d9268028 100644
--- a/lib/connection.cpp
+++ b/lib/connection.cpp
@@ -188,7 +188,7 @@ public:
         emit q->accountDataChanged(eventType);
     }
 
-    template <typename EventT, typename ContentT>
+    template <EventClass EventT, typename ContentT>
     void packAndSendAccountData(ContentT&& content)
     {
         packAndSendAccountData(
diff --git a/lib/connection.h b/lib/connection.h
index 66ed8b68..5afcfc2f 100644
--- a/lib/connection.h
+++ b/lib/connection.h
@@ -189,7 +189,7 @@ public:
     //!         of that type.
     //! \note Direct chats map cannot be retrieved using this method _yet_;
     //!       use directChats() instead.
-    template <typename EventT>
+    template <EventClass EventT>
     const EventT* accountData() const
     {
         return eventCast<EventT>(accountData(EventT::TypeId));
diff --git a/lib/eventitem.h b/lib/eventitem.h
index 2e55a724..445f8265 100644
--- a/lib/eventitem.h
+++ b/lib/eventitem.h
@@ -46,7 +46,7 @@ public:
 
     const RoomEvent* event() const { return rawPtr(evt); }
     const RoomEvent* get() const { return event(); }
-    template <typename EventT>
+    template <EventClass<RoomEvent> EventT>
     const EventT* viewAs() const
     {
         return eventCast<const EventT>(evt);
@@ -67,7 +67,7 @@ public:
     std::any& userData() { return data; }
 
 protected:
-    template <typename EventT>
+    template <EventClass<RoomEvent> EventT>
     EventT* getAs()
     {
         return eventCast<EventT>(evt);
diff --git a/lib/events/event.h b/lib/events/event.h
index 9d7c61a9..d0b63085 100644
--- a/lib/events/event.h
+++ b/lib/events/event.h
@@ -64,7 +64,11 @@ struct QUOTIENT_API EventTypeRegistry {
 
 class Event;
 
-template <class EventT>
+// TODO: move over to std::derived_from<Event> once it's available everywhere
+template <typename EventT, typename BaseEventT = Event>
+concept EventClass = std::is_base_of_v<BaseEventT, EventT>;
+
+template <EventClass EventT>
 bool is(const Event& e);
 
 //! \brief The base class for event metatypes
@@ -206,13 +210,13 @@ private:
 //!
 //! This should not be used to load events from JSON - use loadEvent() for that.
 //! \sa loadEvent
-template <typename EventT, typename... ArgTs>
+template <EventClass EventT, typename... ArgTs>
 inline event_ptr_tt<EventT> makeEvent(ArgTs&&... args)
 {
     return std::make_unique<EventT>(std::forward<ArgTs>(args)...);
 }
 
-template <class EventT>
+template <EventClass EventT>
 constexpr const auto& mostSpecificMetaType()
 {
     if constexpr (requires { EventT::MetaType; })
@@ -226,7 +230,7 @@ constexpr const auto& mostSpecificMetaType()
 //! Use this factory template to detect the type from the JSON object
 //! contents (the detected event type should derive from the template
 //! parameter type) and create an event object of that type.
-template <typename EventT>
+template <EventClass EventT>
 inline event_ptr_tt<EventT> loadEvent(const QJsonObject& fullJson)
 {
     return mostSpecificMetaType<EventT>().loadFrom(
@@ -238,7 +242,7 @@ inline event_ptr_tt<EventT> loadEvent(const QJsonObject& fullJson)
 //! Use this template to resolve the C++ type from the Matrix type string in
 //! \p matrixType and create an event of that type by passing all parameters
 //! to BaseEventT::basicJson().
-template <typename EventT>
+template <EventClass EventT>
 inline event_ptr_tt<EventT> loadEvent(const QString& matrixType,
                                       const auto&... otherBasicJsonParams)
 {
@@ -246,7 +250,7 @@ inline event_ptr_tt<EventT> loadEvent(const QString& matrixType,
         EventT::basicJson(matrixType, otherBasicJsonParams...), matrixType);
 }
 
-template <typename EventT>
+template <EventClass EventT>
 struct JsonConverter<event_ptr_tt<EventT>>
     : JsonObjectUnpacker<event_ptr_tt<EventT>> {
     // No dump() to avoid any ambiguity on whether a given export to JSON uses
@@ -295,7 +299,7 @@ public:
     //! the returned value will be different.
     QString matrixType() const;
 
-    template <class EventT>
+    template <EventClass EventT>
     bool is() const
     {
         return Quotient::is<EventT>(*this);
@@ -377,7 +381,7 @@ private:
 };
 using EventPtr = event_ptr_tt<Event>;
 
-template <typename EventT>
+template <EventClass EventT>
 using EventsArray = std::vector<event_ptr_tt<EventT>>;
 using Events = EventsArray<Event>;
 
@@ -400,8 +404,10 @@ using Events = EventsArray<Event>;
 //! your class will likely be clearer and more concise.
 //! \sa https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern
 //! \sa DEFINE_SIMPLE_EVENT
-template <class EventT, class BaseEventT, typename ContentT = void>
+template <typename EventT, EventClass BaseEventT, typename ContentT = void>
 class EventTemplate : public BaseEventT {
+    // Above: can't constrain EventT to be EventClass because it's incomplete
+    // by CRTP definition.
 public:
     static_assert(
         !std::is_same_v<ContentT, void>,
@@ -522,7 +528,7 @@ public:
 
 // === is<>(), eventCast<>() and switchOnType<>() ===
 
-template <class EventT>
+template <EventClass EventT>
 inline bool is(const Event& e)
 {
     if constexpr (requires { EventT::MetaType; }) {
@@ -544,7 +550,7 @@ inline bool is(const Event& e)
 //! can be either "dumb" (BaseEventT*) or "smart" (`event_ptr_tt<>`). This
 //! overload doesn't affect the event ownership - if the original pointer owns
 //! the event it must outlive the downcast pointer to keep it from dangling.
-template <class EventT, typename BasePtrT>
+template <EventClass EventT, typename BasePtrT>
 inline auto eventCast(const BasePtrT& eptr)
     -> decltype(static_cast<EventT*>(&*eptr))
 {
@@ -567,7 +573,7 @@ inline auto eventCast(const BasePtrT& eptr)
 //!       after calling this overload; if it is a temporary, this normally
 //!       leads to the event getting deleted along with the end of
 //!       the temporary's lifetime.
-template <class EventT, typename BaseEventT>
+template <EventClass EventT, typename BaseEventT>
 inline auto eventCast(event_ptr_tt<BaseEventT>&& eptr)
 {
     return eptr && is<std::decay_t<EventT>>(*eptr)
@@ -576,12 +582,15 @@ inline auto eventCast(event_ptr_tt<BaseEventT>&& eptr)
 }
 
 namespace _impl {
-    template <typename FnT, class BaseT>
-    concept Invocable_With_Downcast =
+    template <typename FnT, typename BaseT>
+    concept Invocable_With_Downcast = requires
+    {
+        requires EventClass<BaseT>;
         std::is_base_of_v<BaseT, std::remove_cvref_t<fn_arg_t<FnT>>>;
+    };
 }
 
-template <class BaseT, typename TailT>
+template <EventClass BaseT, typename TailT>
 inline auto switchOnType(const BaseT& event, TailT&& tail)
 {
     if constexpr (std::is_invocable_v<TailT, BaseT>) {
@@ -596,7 +605,7 @@ inline auto switchOnType(const BaseT& event, TailT&& tail)
     }
 }
 
-template <class BaseT, typename FnT1, typename... FnTs>
+template <EventClass BaseT, typename FnT1, typename... FnTs>
 inline auto switchOnType(const BaseT& event, FnT1&& fn1, FnTs&&... fns)
 {
     using event_type1 = fn_arg_t<FnT1>;
@@ -605,7 +614,7 @@ inline auto switchOnType(const BaseT& event, FnT1&& fn1, FnTs&&... fns)
     return switchOnType(event, std::forward<FnTs>(fns)...);
 }
 
-template <class BaseT, typename... FnTs>
+template <EventClass BaseT, typename... FnTs>
 [[deprecated("The new name for visit() is switchOnType()")]] //
 inline auto visit(const BaseT& event, FnTs&&... fns)
 {
diff --git a/quotest/quotest.cpp b/quotest/quotest.cpp
index 3ac6404a..624888be 100644
--- a/quotest/quotest.cpp
+++ b/quotest/quotest.cpp
@@ -128,7 +128,7 @@ private:
     [[nodiscard]] bool checkRedactionOutcome(const QByteArray& thisTest,
                                              const QString& evtIdToRedact);
 
-    template <class EventT>
+    template <EventClass<RoomEvent> EventT>
     [[nodiscard]] bool validatePendingEvent(const QString& txnId);
     [[nodiscard]] bool checkDirectChat() const;
     void finishTest(const TestToken& token, bool condition, const char* file,
@@ -156,7 +156,7 @@ void TestSuite::doTest(const QByteArray& testName)
                               Q_ARG(TestToken, testName));
 }
 
-template <class EventT>
+template <EventClass<RoomEvent> EventT>
 bool TestSuite::validatePendingEvent(const QString& txnId)
 {
     auto it = targetRoom->findPendingEvent(txnId);
-- 
cgit v1.2.3