tst_webchannel.cpp

qt/qtwebchannel/tests/auto/webchannel/tst_webchannel.cpp (file symbol)

Enable keyboard shortcuts

Source code

Go to header file

Revision control

Copy as Markdown

// Copyright (C) 2016 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com, author Milian Wolff <milian.wolff@kdab.com>

// Copyright (C) 2019 Menlo Systems GmbH, author Arno Rehn <a.rehn@menlosystems.com>

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only

#include "tst_webchannel.h"

#include <QtWebChannel/qwebchannel.h>

#include <QtWebChannel/private/qwebchannel_p.h>

#include <QtWebChannel/private/qmetaobjectpublisher_p.h>

#include <QtTest>

#include <QtTest/private/qpropertytesthelper_p.h>

#ifdef WEBCHANNEL_TESTS_CAN_USE_JS_ENGINE

#include <QJSEngine>

#endif

#include <QPromise>

#include <QTimer>

#ifdef WEBCHANNEL_TESTS_CAN_USE_CONCURRENT

#include <QtConcurrent>

#endif

#include <cstddef>

#include <memory>

#include <new>

#include <optional>

#include <vector>

using namespace Qt::StringLiterals;

QT_USE_NAMESPACE

#ifdef WEBCHANNEL_TESTS_CAN_USE_JS_ENGINE

class TestJSEngine;

class TestEngineTransport : public QWebChannelAbstractTransport

    Q_OBJECT

public:

    TestEngineTransport(TestJSEngine *);

    void sendMessage(const QJsonObject &message) override;

    Q_INVOKABLE void channelSetupReady();

    Q_INVOKABLE void send(const QByteArray &message);

private:

    TestJSEngine *m_testEngine;

};

class ConsoleLogger : public QObject

    Q_OBJECT

public:

    ConsoleLogger(QObject *parent = 0);

    Q_INVOKABLE void log(const QString &text);

    Q_INVOKABLE void error(const QString &text);

    int errorCount() const { return m_errCount; }

    int logCount() const { return m_logCount; }

    QString lastError() const { return m_lastError; }

private:

    int m_errCount;

    int m_logCount;

    QString m_lastError;

};

ConsoleLogger::ConsoleLogger(QObject *parent)

    : QObject(parent)

    , m_errCount(0)

    , m_logCount(0)

void ConsoleLogger::log(const QString &text)

    m_logCount++;

    qDebug("LOG: %s", qPrintable(text));

void ConsoleLogger::error(const QString &text)

    m_errCount++;

    m_lastError = text;

    qWarning("ERROR: %s", qPrintable(text));

// A test JS engine with convenience integration with WebChannel.

class TestJSEngine : public QJSEngine

    Q_OBJECT

public:

    TestJSEngine();

    TestEngineTransport *transport() const;

    ConsoleLogger *logger() const;

    void initWebChannelJS();

signals:

    void channelSetupReady(TestEngineTransport *transport);

private:

    TestEngineTransport *m_transport;

    ConsoleLogger *m_logger;

};

TestEngineTransport::TestEngineTransport(TestJSEngine *engine)

    : QWebChannelAbstractTransport(engine)

    , m_testEngine(engine)

void TestEngineTransport::sendMessage(const QJsonObject &message)

    QByteArray json = QJsonDocument(message).toJson(QJsonDocument::Compact);

    QJSValue callback = m_testEngine->evaluate(QStringLiteral("transport.onmessage"));

    Q_ASSERT(callback.isCallable());

    QJSValue arg = m_testEngine->newObject();

    QJSValue data = m_testEngine->evaluate(QString::fromLatin1("JSON.parse('%1');").arg(QString::fromUtf8(json)));

    Q_ASSERT(!data.isError());

    arg.setProperty(QStringLiteral("data"), data);

    QJSValue val = callback.call((QJSValueList() << arg));

    Q_ASSERT(!val.isError());

void TestEngineTransport::channelSetupReady()

    emit m_testEngine->channelSetupReady(m_testEngine->transport());

void TestEngineTransport::send(const QByteArray &message)

    QJsonDocument doc(QJsonDocument::fromJson(message));

    emit messageReceived(doc.object(), this);

TestJSEngine::TestJSEngine()

    : m_transport(new TestEngineTransport(this))

    , m_logger(new ConsoleLogger(this))

    globalObject().setProperty("transport", newQObject(m_transport));

    globalObject().setProperty("console", newQObject(m_logger));

    QString webChannelJSPath(QStringLiteral(":/qtwebchannel/qwebchannel.js"));

    QFile webChannelJS(webChannelJSPath);

    if (!webChannelJS.open(QFile::ReadOnly))

        qFatal("Error opening qwebchannel.js");

    QString source(QString::fromUtf8(webChannelJS.readAll()));

    evaluate(source, webChannelJSPath);

TestEngineTransport *TestJSEngine::transport() const

    return m_transport;

ConsoleLogger *TestJSEngine::logger() const

    return m_logger;

void TestJSEngine::initWebChannelJS()

    globalObject().setProperty(QStringLiteral("channel"), newObject());

    QJSValue channel = evaluate(QStringLiteral("channel = new QWebChannel(transport, function(channel) { transport.channelSetupReady();});"));

    Q_ASSERT(!channel.isError());

#endif // WEBCHANNEL_TESTS_CAN_USE_JS_ENGINE

namespace {

QVariantList convert_to_js(const TestStructVector &list)

    QVariantList ret;

    ret.reserve(list.size());

    std::transform(list.begin(), list.end(), std::back_inserter(ret), [](const TestStruct &value) -> QVariant {

        QVariantMap map;

        map["foo"] = value.foo;

        map["bar"] = value.bar;

        return map;

});

    return ret;

#if QT_CONFIG(future)

QFuture<int> TestObject::futureIntResult() const

    return QtFuture::makeReadyValueFuture(42);

QFuture<int> TestObject::futureDelayedIntResult() const

    QPromise<int> p;

    const auto f = p.future();

    p.start();

    QTimer::singleShot(10, this, [p=std::move(p)]() mutable {

        p.addResult(7);

        p.finish();

});

    return f;

#ifdef WEBCHANNEL_TESTS_CAN_USE_CONCURRENT

QFuture<int> TestObject::futureIntResultFromThread() const

    return QtConcurrent::run([] {

        return 1337;

});

#endif

QFuture<void> TestObject::futureVoidResult() const

    return QtFuture::makeReadyVoidFuture();

QFuture<QString> TestObject::futureStringResult() const

    return QtFuture::makeReadyValueFuture<QString>("foo");

QFuture<int> TestObject::cancelledFuture() const

    QPromise<int> p;

    auto f = p.future();

    p.start();

    f.cancel();

    Q_ASSERT(f.isCanceled());

    return f;

QFuture<int> TestObject::failedFuture() const

    return QtFuture::makeExceptionalFuture<int>(QException{});

#endif

TestWebChannel::TestWebChannel(QObject *parent)

    : QObject(parent)

    , m_dummyTransport(new DummyTransport(this))

    , m_lastInt(0)

    , m_lastBool(false)

    , m_lastDouble(0)

    qRegisterMetaType<TestStruct>();

    Q_ASSERT(QMetaType::fromType<TestStruct>().isEqualityComparable());

    Q_ASSERT(QMetaType::fromType<TestStruct>().hasRegisteredDebugStreamOperator());

    qRegisterMetaType<TestStructVector>();

    QMetaType::registerConverter<TestStructVector, QVariantList>(convert_to_js);

    QMetaType::registerConverter<TestStruct, QString>();

    QMetaType::registerConverter<TestStruct, QJsonValue>(

        [](const TestStruct &s) {

            return QJsonObject {

                { "__type__", "TestStruct" },

                { "foo", s.foo },

                { "bar", s.bar },

};

});

    QMetaType::registerConverter<QJsonValue, TestStruct>(

        [](const QJsonValue &value) -> std::optional<TestStruct> {

            const auto object = value.toObject();

            if (object.value("__type__").toString() != QStringLiteral("TestStruct"))

                return std::nullopt;

            return TestStruct {

                object.value("foo").toInt(),

                object.value("bar").toInt(),

};

});

TestWebChannel::~TestWebChannel()

int TestWebChannel::readInt() const

    return m_lastInt;

void TestWebChannel::setInt(int i)

    m_lastInt = i;

    emit lastIntChanged();

bool TestWebChannel::readBool() const

    return m_lastBool;

void TestWebChannel::setBool(bool b)

    m_lastBool = b;

    emit lastBoolChanged();

double TestWebChannel::readDouble() const

    return m_lastDouble;

void TestWebChannel::setDouble(double d)

    m_lastDouble = d;

    emit lastDoubleChanged();

void TestWebChannel::setIntDouble(int i, double d)

    m_lastInt = i;

    emit lastIntChanged();

    m_lastDouble = d;

    emit lastDoubleChanged();

QVariant TestWebChannel::readVariant() const

    return m_lastVariant;

void TestWebChannel::setVariant(const QVariant &v)

    m_lastVariant = v;

    emit lastVariantChanged();

QJsonValue TestWebChannel::readJsonValue() const

    return m_lastJsonValue;

void TestWebChannel::setJsonValue(const QJsonValue& v)

    m_lastJsonValue = v;

    emit lastJsonValueChanged();

QUrl TestWebChannel::readUrl() const

    return m_lastUrl;

void TestWebChannel::setUrl(const QUrl& u)

    m_lastUrl = u;

QJsonObject TestWebChannel::readJsonObject() const

    return m_lastJsonObject;

void TestWebChannel::setJsonObject(const QJsonObject& v)

    m_lastJsonObject = v;

    emit lastJsonObjectChanged();

QJsonArray TestWebChannel::readJsonArray() const

    return m_lastJsonArray;

void TestWebChannel::setJsonArray(const QJsonArray& v)

    m_lastJsonArray = v;

    emit lastJsonArrayChanged();

int TestWebChannel::readOverload(int i)

    return i + 1;

QString TestWebChannel::readOverload(const QString &arg)

    return arg.toUpper();

QString TestWebChannel::readOverload(const QString &arg, int i)

    return arg.toUpper() + QString::number(i + 1);

void TestWebChannel::testRegisterObjects()

    QWebChannel channel;

    QObject plain;

    QHash<QString, QObject*> objects;

    objects[QStringLiteral("plain")] = &plain;

    objects[QStringLiteral("channel")] = &channel;

    objects[QStringLiteral("publisher")] = channel.d_func()->publisher;

    objects[QStringLiteral("test")] = this;

    channel.registerObjects(objects);

void TestWebChannel::testDeregisterObjects()

    QWebChannel channel;

    TestObject testObject;

    testObject.setObjectName("myTestObject");

    channel.registerObject(testObject.objectName(), &testObject);

    channel.connectTo(m_dummyTransport);

    channel.d_func()->publisher->initializeClient(m_dummyTransport);

    QJsonObject connectMessage =

            QJsonDocument::fromJson(("{\"type\": 7,"

                                    "\"object\": \"myTestObject\","

                                    "\"signal\": " + QString::number(testObject.metaObject()->indexOfSignal("sig1()"))

                                    + "}").toLatin1()).object();

    channel.d_func()->publisher->handleMessage(connectMessage, m_dummyTransport);

    emit testObject.sig1();

    channel.deregisterObject(&testObject);

    emit testObject.sig1();

void TestWebChannel::testDeregisterObjectAtStart()

    QWebChannel channel;

    QVERIFY(channel.registeredObjects().isEmpty());

    TestObject testObject;

    testObject.setObjectName("myTestObject");

    channel.registerObject(testObject.objectName(), &testObject);

    QCOMPARE(channel.registeredObjects().size(), 1);

    channel.deregisterObject(&testObject);

    QVERIFY(channel.registeredObjects().isEmpty());

void TestWebChannel::testInfoForObject()

    TestObject obj;

    obj.setObjectName("myTestObject");

    QWebChannel channel;

    const QJsonObject info = channel.d_func()->publisher->classInfoForObject(&obj, m_dummyTransport);

    QCOMPARE(info.keys(), QStringList() << "enums" << "methods" << "properties" << "signals");

    { // enums

        QJsonObject fooEnum;

        fooEnum["Asdf"] = TestObject::Asdf;

        fooEnum["Bar"] = TestObject::Bar;

        QJsonObject testFlags;

        testFlags["FirstFlag"] = static_cast<int>(TestObject::FirstFlag);

        testFlags["SecondFlag"] = static_cast<int>(TestObject::SecondFlag);

        QJsonObject expected;

        expected["Foo"] = fooEnum;

        expected["TestFlags"] = testFlags;

        QCOMPARE(info["enums"].toObject(), expected);

    QJsonArray expected;

    auto addMethod = [&expected, &obj](const QString &name, const char *signature, bool addName = true) {

        const auto index = obj.metaObject()->indexOfMethod(signature);

        QVERIFY2(index != -1, signature);

        if (addName)

            expected.append(QJsonArray{name, index});

        expected.append(QJsonArray{QString::fromUtf8(signature), index});

};

    { // methods & slots

        expected = {};

        addMethod(QStringLiteral("deleteLater"), "deleteLater()");

        addMethod(QStringLiteral("slot1"), "slot1()");

        addMethod(QStringLiteral("slot2"), "slot2(QString)");

        addMethod(QStringLiteral("setReturnedObject"), "setReturnedObject(TestObject*)");

        addMethod(QStringLiteral("setObjectProperty"), "setObjectProperty(QObject*)");

        addMethod(QStringLiteral("setProp"), "setProp(QString)");

        addMethod(QStringLiteral("fire"), "fire()");

        addMethod(QStringLiteral("overload"), "overload(double)");

        addMethod(QStringLiteral("overload"), "overload(int)", false);

        addMethod(QStringLiteral("overload"), "overload(QObject*)", false);

        addMethod(QStringLiteral("overload"), "overload(QString)", false);

        addMethod(QStringLiteral("overload"), "overload(QString,int)", false);

        addMethod(QStringLiteral("overload"), "overload(QJsonArray)", false);

        addMethod(QStringLiteral("setStringProperty"), "setStringProperty(QString)");

        addMethod(QStringLiteral("bindableStringProperty"), "bindableStringProperty()");

        addMethod(QStringLiteral("getStringProperty"), "getStringProperty()");

        addMethod(QStringLiteral("bindStringPropertyToStringProperty2"), "bindStringPropertyToStringProperty2()");

        addMethod(QStringLiteral("setStringProperty2"), "setStringProperty2(QString)");

        addMethod(QStringLiteral("method1"), "method1()");

#if QT_CONFIG(future)

        addMethod(QStringLiteral("futureIntResult"), "futureIntResult()");

        addMethod(QStringLiteral("futureDelayedIntResult"), "futureDelayedIntResult()");

#ifdef WEBCHANNEL_TESTS_CAN_USE_CONCURRENT

        addMethod(QStringLiteral("futureIntResultFromThread"), "futureIntResultFromThread()");

#endif

        addMethod(QStringLiteral("futureVoidResult"), "futureVoidResult()");

        addMethod(QStringLiteral("futureStringResult"), "futureStringResult()");

        addMethod(QStringLiteral("cancelledFuture"), "cancelledFuture()");

        addMethod(QStringLiteral("failedFuture"), "failedFuture()");

#endif

        QCOMPARE(info["methods"].toArray(), expected);

    { // signals

        expected = {};

        addMethod(QStringLiteral("destroyed"), "destroyed(QObject*)");

        addMethod(QStringLiteral("destroyed"), "destroyed()", false);

        addMethod(QStringLiteral("sig1"), "sig1()");

        addMethod(QStringLiteral("sig2"), "sig2(QString)");

        addMethod(QStringLiteral("replay"), "replay()");

        addMethod(QStringLiteral("overloadSignal"), "overloadSignal(int)");

        addMethod(QStringLiteral("overloadSignal"), "overloadSignal(float)", false);

        QCOMPARE(info["signals"].toArray(), expected);

    { // properties

        QJsonArray expected;

            QJsonArray property;

            property.append(obj.metaObject()->indexOfProperty("objectName"));

            property.append(QStringLiteral("objectName"));

                QJsonArray signal;

                signal.append(1);

                signal.append(obj.metaObject()->indexOfMethod("objectNameChanged(QString)"));

                property.append(signal);

            property.append(obj.objectName());

            expected.append(property);

            QJsonArray property;

            property.append(obj.metaObject()->indexOfProperty("foo"));

            property.append(QStringLiteral("foo"));

                QJsonArray signal;

                property.append(signal);

            property.append(obj.foo());

            expected.append(property);

            QJsonArray property;

            property.append(obj.metaObject()->indexOfProperty("asdf"));

            property.append(QStringLiteral("asdf"));

                QJsonArray signal;

                signal.append(1);

                signal.append(obj.metaObject()->indexOfMethod("asdfChanged()"));

                property.append(signal);

            property.append(obj.asdf());

            expected.append(property);

            QJsonArray property;

            property.append(obj.metaObject()->indexOfProperty("bar"));

            property.append(QStringLiteral("bar"));

                QJsonArray signal;

                signal.append(QStringLiteral("theBarHasChanged"));

                signal.append(obj.metaObject()->indexOfMethod("theBarHasChanged()"));

                property.append(signal);

            property.append(obj.bar());

            expected.append(property);

            QJsonArray property;

            property.append(obj.metaObject()->indexOfProperty("objectProperty"));

            property.append(QStringLiteral("objectProperty"));

                QJsonArray signal;

                signal.append(1);

                signal.append(obj.metaObject()->indexOfMethod("objectPropertyChanged()"));

                property.append(signal);

            property.append(QJsonValue::fromVariant(QVariant::fromValue(obj.objectProperty())));

            expected.append(property);

            QJsonArray property;

            property.append(obj.metaObject()->indexOfProperty("returnedObject"));

            property.append(QStringLiteral("returnedObject"));

                QJsonArray signal;

                signal.append(1);

                signal.append(obj.metaObject()->indexOfMethod("returnedObjectChanged()"));

                property.append(signal);

            property.append(QJsonValue::fromVariant(QVariant::fromValue(obj.returnedObject())));

            expected.append(property);

            QJsonArray property;

            property.append(obj.metaObject()->indexOfProperty("prop"));

            property.append(QStringLiteral("prop"));

                QJsonArray signal;

                signal.append(1);

                signal.append(obj.metaObject()->indexOfMethod("propChanged(QString)"));

                property.append(signal);

            property.append(QJsonValue::fromVariant(QVariant::fromValue(obj.prop())));

            expected.append(property);

            QJsonArray property;

            property.append(obj.metaObject()->indexOfProperty("stringProperty"));

            property.append(QStringLiteral("stringProperty"));

                QJsonArray signal;

                property.append(signal);

            property.append(QJsonValue::fromVariant(QVariant::fromValue(obj.readStringProperty())));

            expected.append(property);

        QCOMPARE(info["properties"].toArray(), expected);

void TestWebChannel::testInvokeMethodConversion()

    QWebChannel channel;

    channel.connectTo(m_dummyTransport);

    QJsonArray args;

    args.append(QJsonValue(1000));

        channel.d_func()->publisher->invokeMethod(this, "setInt", args);

        QCOMPARE(m_lastInt, args.at(0).toInt());

        int getterMethod = metaObject()->indexOfMethod("readInt()");

        QVERIFY(getterMethod != -1);

        auto retVal = channel.d_func()->publisher->invokeMethod(this, getterMethod, {});

        QCOMPARE(retVal, args.at(0).toVariant());

        QJsonArray args;

        args.append(QJsonValue(!m_lastBool));

        channel.d_func()->publisher->invokeMethod(this, "setBool", args);

        QCOMPARE(m_lastBool, args.at(0).toBool());

        int getterMethod = metaObject()->indexOfMethod("readBool()");

        QVERIFY(getterMethod != -1);

        auto retVal = channel.d_func()->publisher->invokeMethod(this, getterMethod, {});

        QCOMPARE(retVal, args.at(0).toVariant());

        channel.d_func()->publisher->invokeMethod(this, "setDouble", args);

        QCOMPARE(m_lastDouble, args.at(0).toDouble());

        int getterMethod = metaObject()->indexOfMethod("readDouble()");

        QVERIFY(getterMethod != -1);

        auto retVal = channel.d_func()->publisher->invokeMethod(this, getterMethod, {});

        QCOMPARE(retVal, args.at(0).toVariant());

        channel.d_func()->publisher->invokeMethod(this, "setVariant", args);

        QCOMPARE(m_lastVariant, args.at(0).toVariant());

        int getterMethod = metaObject()->indexOfMethod("readVariant()");

        QVERIFY(getterMethod != -1);

        auto retVal = channel.d_func()->publisher->invokeMethod(this, getterMethod, {});

        QCOMPARE(retVal, args.at(0).toVariant());

        channel.d_func()->publisher->invokeMethod(this, "setJsonValue", args);

        QCOMPARE(m_lastJsonValue, args.at(0));

        int getterMethod = metaObject()->indexOfMethod("readJsonValue()");

        QVERIFY(getterMethod != -1);

        auto retVal = channel.d_func()->publisher->invokeMethod(this, getterMethod, {});

        QCOMPARE(retVal, QVariant(args.at(0)));

        QJsonObject object;

        object["foo"] = QJsonValue(123);

        object["bar"] = QJsonValue(4.2);

        args[0] = object;

        channel.d_func()->publisher->invokeMethod(this, "setJsonObject", args);

        QCOMPARE(m_lastJsonObject, object);

        int getterMethod = metaObject()->indexOfMethod("readJsonObject()");

        QVERIFY(getterMethod != -1);

        auto retVal = channel.d_func()->publisher->invokeMethod(this, getterMethod, {});

        QCOMPARE(retVal, QVariant::fromValue(object));

        QJsonArray array;

        array << QJsonValue(123);

        array <<  QJsonValue(4.2);

        args[0] = array;

        channel.d_func()->publisher->invokeMethod(this, "setJsonArray", args);

        QCOMPARE(m_lastJsonArray, array);

        int getterMethod = metaObject()->indexOfMethod("readJsonArray()");

        QVERIFY(getterMethod != -1);

        auto retVal = channel.d_func()->publisher->invokeMethod(this, getterMethod, {});

        QCOMPARE(retVal, QVariant::fromValue(array));

        args[0] = QJsonValue::fromVariant(QUrl("aviancarrier:/ok"));

        channel.d_func()->publisher->invokeMethod(this, "setUrl", args);

        QVERIFY(m_lastUrl.isValid());

        int getterMethod = metaObject()->indexOfMethod("readUrl()");

        QVERIFY(getterMethod != -1);

        auto retVal = channel.d_func()->publisher->invokeMethod(this, getterMethod, {});

        QCOMPARE(retVal, args.at(0).toVariant().toUrl());

void TestWebChannel::testFunctionOverloading()

    QWebChannel channel;

    channel.connectTo(m_dummyTransport);

    // all method calls will use the first method's index

    const auto method1 = metaObject()->indexOfMethod("readOverload(int)");

    QVERIFY(method1 != -1);

    const auto method2 = metaObject()->indexOfMethod("readOverload(QString)");

    QVERIFY(method2 != -1);

    QVERIFY(method1 < method2);

    const auto method3 = metaObject()->indexOfMethod("readOverload(QString,int)");

    QVERIFY(method3 != -1);

    QVERIFY(method2 < method3);

    { // int

        const auto retVal = channel.d_func()->publisher->invokeMethod(this, method1, QJsonArray{1000});

        QCOMPARE(retVal.toInt(), 1001);

    { // QString

        const auto retVal = channel.d_func()->publisher->invokeMethod(this, method2, QJsonArray{QStringLiteral("hello world")});

        QCOMPARE(retVal.toString(), QStringLiteral("HELLO WORLD"));

    { // QString, int

        const auto retVal = channel.d_func()->publisher->invokeMethod(this, method3, QJsonArray{QStringLiteral("the answer is "), 41});

        QCOMPARE(retVal.toString(), QStringLiteral("THE ANSWER IS 42"));

void TestWebChannel::testSetPropertyConversion()

    QWebChannel channel;

    channel.connectTo(m_dummyTransport);

        int property = metaObject()->indexOfProperty("lastInt");

        QVERIFY(property != -1);

        channel.d_func()->publisher->setProperty(this, property, QJsonValue(42));

        QCOMPARE(m_lastInt, 42);

        int property = metaObject()->indexOfProperty("lastBool");

        QVERIFY(property != -1);

        bool newValue = !m_lastBool;

        channel.d_func()->publisher->setProperty(this, property, QJsonValue(newValue));

        QCOMPARE(m_lastBool, newValue);

        int property = metaObject()->indexOfProperty("lastDouble");

        QVERIFY(property != -1);

        channel.d_func()->publisher->setProperty(this, property, QJsonValue(-4.2));

        QCOMPARE(m_lastDouble, -4.2);

        int property = metaObject()->indexOfProperty("lastVariant");

        QVERIFY(property != -1);

        QVariant variant("foo bar asdf");

        channel.d_func()->publisher->setProperty(this, property, QJsonValue::fromVariant(variant));

        QCOMPARE(m_lastVariant, variant);

        int property = metaObject()->indexOfProperty("lastJsonValue");

        QVERIFY(property != -1);

        QJsonValue value("asdf asdf");

        channel.d_func()->publisher->setProperty(this, property, value);

        QCOMPARE(m_lastJsonValue, value);

        int property = metaObject()->indexOfProperty("lastJsonArray");

        QVERIFY(property != -1);

        QJsonArray array;

        array << QJsonValue(-123);

        array <<  QJsonValue(-42);

        channel.d_func()->publisher->setProperty(this, property, array);

        QCOMPARE(m_lastJsonArray, array);

        int property = metaObject()->indexOfProperty("lastJsonObject");

        QVERIFY(property != -1);

        QJsonObject object;

        object["foo"] = QJsonValue(-123);

        object["bar"] = QJsonValue(-4.2);

        channel.d_func()->publisher->setProperty(this, property, object);

        QCOMPARE(m_lastJsonObject, object);

void TestWebChannel::testInvokeMethodOverloadResolution()

    QWebChannel channel;

    TestObject testObject;

    TestObject exportedObject;

    channel.registerObject("test", &exportedObject);

    channel.connectTo(m_dummyTransport);

    QVariant result;

    QMetaObjectPublisher *publisher = channel.d_func()->publisher;

        result = publisher->invokeMethod(&testObject, "overload", { 41.0 });

        QVERIFY(result.userType() == QMetaType::Double);

        QCOMPARE(result.toDouble(), 42.0);

        // In JavaScript, there's only 'double', so this should always invoke the 'double' overload

        result = publisher->invokeMethod(&testObject, "overload", { 41 });

        QVERIFY(result.userType() == QMetaType::Double);

        QCOMPARE(result.toDouble(), 42);

        QJsonObject wrappedObject { {"id", "test"} };

        result = publisher->invokeMethod(&testObject, "overload", { wrappedObject });

        QCOMPARE(result.value<TestObject*>(), &exportedObject);

        result = publisher->invokeMethod(&testObject, "overload", { "hello world" });

        QCOMPARE(result.toString(), QStringLiteral("HELLO WORLD"));

        result = publisher->invokeMethod(&testObject, "overload", { "the answer is ", 41 });

        QCOMPARE(result.toString(), QStringLiteral("THE ANSWER IS 42"));

        QJsonArray args;

        args.append(QJsonArray { "foobar", 42 });

        result = publisher->invokeMethod(&testObject, "overload", args);

        QCOMPARE(result.toString(), QStringLiteral("42foobar"));

void TestWebChannel::testDisconnect()

    QWebChannel channel;

    channel.connectTo(m_dummyTransport);

    channel.disconnectFrom(m_dummyTransport);

    m_dummyTransport->emitMessageReceived(QJsonObject());

void TestWebChannel::testWrapRegisteredObject()

    QWebChannel channel;

    TestObject obj;

    obj.setObjectName("myTestObject");

    channel.registerObject(obj.objectName(), &obj);

    channel.connectTo(m_dummyTransport);

    channel.d_func()->publisher->initializeClient(m_dummyTransport);

    QJsonObject objectInfo = channel.d_func()->publisher->wrapResult(QVariant::fromValue(&obj), m_dummyTransport).toObject();

    QCOMPARE(2, objectInfo.length());

    QVERIFY(objectInfo.contains("id"));

    QVERIFY(objectInfo.contains("__QObject*__"));

    QVERIFY(objectInfo.value("__QObject*__").isBool() && objectInfo.value("__QObject*__").toBool());

    QString returnedId = objectInfo.value("id").toString();

    QCOMPARE(&obj, channel.d_func()->publisher->registeredObjects.value(obj.objectName()));

    QCOMPARE(obj.objectName(), channel.d_func()->publisher->registeredObjectIds.value(&obj));

    QCOMPARE(obj.objectName(), returnedId);

void TestWebChannel::testUnwrapObject()

    QWebChannel channel;

        TestObject obj;

        obj.setObjectName("testObject");

        channel.registerObject(obj.objectName(), &obj);

        QObject *unwrapped = channel.d_func()->publisher->unwrapObject(obj.objectName());

        QCOMPARE(unwrapped, &obj);

        TestObject obj;

        QJsonObject objectInfo = channel.d_func()->publisher->wrapResult(QVariant::fromValue(&obj), m_dummyTransport).toObject();

        QObject *unwrapped = channel.d_func()->publisher->unwrapObject(objectInfo["id"].toString());

        QCOMPARE(unwrapped, &obj);

void TestWebChannel::testTransportWrapObjectProperties()

    QWebChannel channel;

    TestObject obj;

    obj.setObjectName("testObject");

    channel.registerObject(obj.objectName(), &obj);

    DummyTransport *dummyTransport = new DummyTransport(this);

    channel.connectTo(dummyTransport);

    channel.d_func()->publisher->initializeClient(dummyTransport);

    channel.d_func()->publisher->setClientIsIdle(true, dummyTransport);

    QCOMPARE(channel.d_func()->publisher->transportedWrappedObjects.size(), 0);

    QObject objPropObject;

    objPropObject.setObjectName("foobar");

    obj.setObjectProperty(&objPropObject);

    channel.d_func()->publisher->sendPendingPropertyUpdates();

    QCOMPARE(channel.d_func()->publisher->wrappedObjects.size(), 1);

    const QString wrappedObjId = channel.d_func()->publisher->wrappedObjects.keys()[0];

    QCOMPARE(channel.d_func()->publisher->transportedWrappedObjects.size(), 1);

    QCOMPARE(channel.d_func()->publisher->transportedWrappedObjects.keys()[0], dummyTransport);

    QCOMPARE(channel.d_func()->publisher->transportedWrappedObjects.values()[0], wrappedObjId);

void TestWebChannel::testRemoveUnusedTransports()

    QWebChannel channel;

    DummyTransport *dummyTransport = new DummyTransport(this);

    TestObject obj;

    channel.connectTo(dummyTransport);

    channel.d_func()->publisher->initializeClient(dummyTransport);

    QMetaObjectPublisher *pub = channel.d_func()->publisher;

    pub->wrapResult(QVariant::fromValue(&obj), dummyTransport);

    QCOMPARE(pub->wrappedObjects.size(), 1);

    QCOMPARE(pub->registeredObjectIds.size(), 1);

    channel.disconnectFrom(dummyTransport);

    delete dummyTransport;

    QCOMPARE(pub->wrappedObjects.size(), 0);

    QCOMPARE(pub->registeredObjectIds.size(), 0);

void TestWebChannel::testPassWrappedObjectBack()

    QWebChannel channel;

    TestObject registeredObj;

    TestObject returnedObjMethod;

    TestObject returnedObjProperty;

    registeredObj.setObjectName("registeredObject");

    channel.registerObject(registeredObj.objectName(), &registeredObj);

    channel.connectTo(m_dummyTransport);

    channel.d_func()->publisher->initializeClient(m_dummyTransport);

    QMetaObjectPublisher *pub = channel.d_func()->publisher;

    QJsonObject returnedObjMethodInfo = pub->wrapResult(QVariant::fromValue(&returnedObjMethod), m_dummyTransport).toObject();

    QJsonObject returnedObjPropertyInfo = pub->wrapResult(QVariant::fromValue(&returnedObjProperty), m_dummyTransport).toObject();

    QJsonArray argsMethod;

    QJsonObject argMethod0;

    argMethod0["id"] = returnedObjMethodInfo["id"];

    argsMethod << argMethod0;

    QJsonObject argProperty;

    argProperty["id"] = returnedObjPropertyInfo["id"];

    pub->invokeMethod(&registeredObj, "setReturnedObject", argsMethod);

    QCOMPARE(registeredObj.mReturnedObject, &returnedObjMethod);

    pub->setProperty(&registeredObj, registeredObj.metaObject()->indexOfProperty("returnedObject"), argProperty);

    QCOMPARE(registeredObj.mReturnedObject, &returnedObjProperty);

void TestWebChannel::testWrapValues_data()

    QTest::addColumn<QVariant>("variant");

    QTest::addColumn<QJsonValue>("json");

    QTest::addRow("enum") << QVariant::fromValue(TestObject::Asdf)

                          << QJsonValue(static_cast<int>(TestObject::Asdf));

    const TestObject::TestFlags flags = TestObject::FirstFlag | TestObject::SecondFlag;

    QTest::addRow("flags") << QVariant::fromValue(flags)

                           << QJsonValue(static_cast<int>(flags));

    QTest::addRow("list") << QVariant::fromValue(QList<int>{1, 2, 3})

                          << QJsonValue(QJsonArray{1, 2, 3});

    QTest::addRow("customVector") << QVariant::fromValue(TestStructVector{{1, 2}, {3, 4}})

                                  << QJsonValue(QJsonArray({QJsonObject{{"foo", 1}, {"bar", 2}},

                                                            QJsonObject{{"foo", 3}, {"bar", 4}}}));

    QTest::addRow("nullptr") << QVariant::fromValue(nullptr)

                             << QJsonValue();

    QTest::addRow("hash") << QVariant::fromValue(QVariantHash{{"One", 1},

                                                              {"Two", 2}})

                          << QJsonValue(QJsonObject{{"One", 1},

                                                    {"Two", 2}});

    QTest::addRow("url") << QVariant::fromValue(QUrl("aviancarrier:/test"))

                         << QJsonValue(QJsonValue(QString("aviancarrier:/test")));

    QTest::addRow("map") << QVariant::fromValue(QVariantMap{{"One", 1},

                                                            {"Two", 2}})

                         << QJsonValue(QJsonObject{{"One", 1},

                                                   {"Two", 2}});

    QTest::addRow("customType") << QVariant::fromValue(TestStruct{42, 7})

                                << QJsonValue(QJsonObject{{"__type__", "TestStruct"},

                                                          {"foo", 42},

                                                          {"bar", 7}});

void TestWebChannel::testWrapValues()

    QWebChannel channel;

    channel.connectTo(m_dummyTransport);

    QFETCH(QVariant, variant);

    QFETCH(QJsonValue, json);

    QJsonValue value = channel.d_func()->publisher->wrapResult(variant, m_dummyTransport);

    QCOMPARE(value, json);

void TestWebChannel::testWrapObjectWithMultipleTransports()

    QWebChannel channel;

    QMetaObjectPublisher *pub = channel.d_func()->publisher;

    DummyTransport *dummyTransport = new DummyTransport(this);

    DummyTransport *dummyTransport2 = new DummyTransport(this);

    TestObject obj;

    pub->wrapResult(QVariant::fromValue(&obj), dummyTransport);

    pub->wrapResult(QVariant::fromValue(&obj), dummyTransport2);

    QCOMPARE(pub->transportedWrappedObjects.size(), 2);

void TestWebChannel::testJsonToVariant_data()

    QTest::addColumn<QJsonValue>("json");

    QTest::addColumn<QVariant>("targetVariant");

    QTest::addRow("enum") << QJsonValue(static_cast<int>(TestObject::Asdf))

                          << QVariant::fromValue(TestObject::Asdf);

    const TestObject::TestFlags flags =  TestObject::FirstFlag | TestObject::SecondFlag;

    QTest::addRow("flags") << QJsonValue(static_cast<int>(flags))

                           << QVariant::fromValue(flags);

    QTest::addRow("customType") << QJsonValue(QJsonObject{{"__type__", "TestStruct"},

                                                          {"foo", 42},

                                                          {"bar", 7}})

                                << QVariant::fromValue(TestStruct{42, 7});

void TestWebChannel::testJsonToVariant()

    QWebChannel channel;

    channel.connectTo(m_dummyTransport);

    QFETCH(QJsonValue, json);

    QFETCH(QVariant, targetVariant);

    const std::optional<QVariant> convertedValue =

            channel.d_func()->publisher->toVariant(json, targetVariant.userType());

    QVERIFY(convertedValue);

    QCOMPARE(*convertedValue, targetVariant);

void TestWebChannel::testInfiniteRecursion()

    QWebChannel channel;

    TestObject obj;

    obj.setObjectProperty(&obj);

    obj.setObjectName("myTestObject");

    channel.connectTo(m_dummyTransport);

    channel.d_func()->publisher->initializeClient(m_dummyTransport);

    QJsonObject objectInfo = channel.d_func()->publisher->wrapResult(QVariant::fromValue(&obj), m_dummyTransport).toObject();

    // Wrap the result twice to test for QTBUG-84007. A single result wrap will not trigger all recursion paths.

    objectInfo = channel.d_func()->publisher->wrapResult(QVariant::fromValue(&obj), m_dummyTransport).toObject();

void TestWebChannel::testAsyncObject()

    QWebChannel channel;

    channel.connectTo(m_dummyTransport);

    QThread thread;

    thread.start();

    TestObject obj;

    obj.moveToThread(&thread);

    QJsonArray args;

    args.append(QJsonValue("message"));

        int received = 0;

        connect(&obj, &TestObject::propChanged, this, [&](const QString &arg) {

            QCOMPARE(arg, args.at(0).toString());

            ++received;

});

        channel.d_func()->publisher->invokeMethod(&obj, "setProp", args);

        QTRY_COMPARE(received, 1);

        int received = 0;

        auto handler = obj.bindableStringProperty().onValueChanged([&] {

            ++received;

});

        channel.d_func()->publisher->invokeMethod(&obj, "setStringProperty", args);

        QTRY_COMPARE(received, 1);

    channel.registerObject("myObj", &obj);

    channel.d_func()->publisher->initializeClient(m_dummyTransport);

    QJsonObject connectMessage;

    connectMessage["type"] = 7;

    connectMessage["object"] = "myObj";

    connectMessage["signal"] = obj.metaObject()->indexOfSignal("replay()");

    channel.d_func()->publisher->handleMessage(connectMessage, m_dummyTransport);

        int received = 0;

        connect(&obj, &TestObject::replay, this, [&]() { ++received; });

        QMetaObject::invokeMethod(&obj, "fire");

        QTRY_COMPARE(received, 1);

        channel.deregisterObject(&obj);

        QMetaObject::invokeMethod(&obj, "fire");

        QTRY_COMPARE(received, 2);

    thread.quit();

    thread.wait();

void TestWebChannel::testQProperty()

    static const int IndexOfStringProperty =

            TestObject::staticMetaObject.indexOfProperty("stringProperty");

    DummyTransport transport;

    QWebChannel channel;

    QMetaObjectPublisher *publisher = channel.d_func()->publisher;

        TestObject testObj;

        testObj.setObjectName("testObject");

        QProperty<QString> obj1("Hello");

        testObj.bindableStringProperty().setBinding([&](){ return obj1.value(); });

        QCOMPARE(obj1.value(), testObj.readStringProperty());

        channel.registerObject(testObj.objectName(), &testObj);

        channel.connectTo(&transport);

        publisher->initializeClient(&transport);

        // One bindable property should result in one observer

        QCOMPARE(publisher->propertyObservers.count(&testObj), 1u);

        QVariant result;

        publisher->setClientIsIdle(true, &transport);

        result = publisher->invokeMethod(&testObj, "getStringProperty", {});

        QCOMPARE(result.toString(), obj1.value());

        obj1 = "world";

        result = publisher->invokeMethod(&testObj, "getStringProperty", {});

        QCOMPARE(result.toString(), obj1.value());

        publisher->sendPendingPropertyUpdates();

        QVERIFY(!transport.messagesSent().isEmpty());

        const QJsonObject updateMessage = transport.messagesSent().last()["data"][0].toObject();

        QCOMPARE(updateMessage["object"], testObj.objectName());

        QCOMPARE(updateMessage["properties"][QString::number(IndexOfStringProperty)], obj1.value());

        publisher->invokeMethod(&testObj, "setStringProperty2", {"Hey"});

        publisher->invokeMethod(&testObj, "bindStringPropertyToStringProperty2", {});

        obj1 = "This should not affect getStringProperty";

        result = publisher->invokeMethod(&testObj, "getStringProperty", {});

        QCOMPARE(result.toString(), "Hey");

        publisher->invokeMethod(&testObj, "setStringProperty2", {"again"});

        result = publisher->invokeMethod(&testObj, "getStringProperty", {});

        QCOMPARE(result.toString(), "again");

    // Ensure that the observer has been removed after the object has been

    // destroyed

    QCOMPARE(publisher->propertyObservers.size(), 0u);

void TestWebChannel::testPropertyUpdateInterval_data()

    QTest::addColumn<int>("firstUpdateInterval");

    QTest::addColumn<int>("firstUpdateWithin");

    QTest::addColumn<int>("secondUpdateInterval");

    QTest::addColumn<int>("secondUpdateWithin");

    QTest::newRow("1500ms") << 1500 << 2000 << 1500 << 2000;

    QTest::newRow("Next event") << 0 << 0 << 0 << 0;

    QTest::newRow("Immediately") << -1 << 0 << -1 << 0;

    QTest::newRow("1500ms then next event") << 1500 << 2000 << 0 << 0;

    QTest::newRow("Next event then 1500ms") << 0 << 0 << 1500 << 2000;

    QTest::newRow("Immediately the next event") << -1 << 0 << 0 << 0;

    QTest::newRow("Next event then immediately") << 0 << 0 << -1 << 0;

    QTest::newRow("Immediately then 1500ms") << -1 << 0 << 1500 << 2000;

    QTest::newRow("1500ms then immediately") << 1500 << 2000 << -1 << 0;

void TestWebChannel::testPropertyUpdateInterval()

    DummyTransport transport;

    QWebChannel channel;

    QMetaObjectPublisher *publisher = channel.d_func()->publisher;

    QFETCH(int, firstUpdateInterval);

    QFETCH(int, firstUpdateWithin);

    QProperty<int> propertyUpdateInterval(firstUpdateInterval);

    channel.bindablePropertyUpdateInterval().setBinding(

            Qt::makePropertyBinding(propertyUpdateInterval));

    QCOMPARE(channel.propertyUpdateInterval(), firstUpdateInterval);

    TestObject testObj;

    testObj.setObjectName("testObject");

    channel.registerObject(testObj.objectName(), &testObj);

    channel.connectTo(&transport);

    QProperty<QString> obj1("Hello");

    testObj.bindableStringProperty().setBinding([&]() { return obj1.value(); });

    publisher->initializeClient(&transport);

    publisher->setClientIsIdle(true, &transport);

    QVERIFY(transport.messagesSent().isEmpty());

    // First update

    obj1 = "world";

    if (firstUpdateInterval > 0) {

        QCoreApplication::processEvents();

        QVERIFY(transport.messagesSent().isEmpty());

        QTRY_COMPARE_WITH_TIMEOUT(transport.messagesSent().size(), 1u, firstUpdateWithin);

    } else if (firstUpdateInterval == 0) {

        QCOMPARE(transport.messagesSent().size(), 0u);

        QCoreApplication::processEvents();

        QCOMPARE(transport.messagesSent().size(), 1u);

    } else {

        QCOMPARE(transport.messagesSent().size(), 1u);

    QFETCH(int, secondUpdateInterval);

    QFETCH(int, secondUpdateWithin);

    propertyUpdateInterval = secondUpdateInterval;

    publisher->setClientIsIdle(true, &transport);

    obj1 = "!!!";

    if (secondUpdateInterval > 0) {

        QCoreApplication::processEvents();

        QCOMPARE(transport.messagesSent().size(), 1u);

        QCOMPARE(channel.propertyUpdateInterval(), secondUpdateInterval);

        QVERIFY(publisher->timer.isActive());

        QTRY_COMPARE_WITH_TIMEOUT(transport.messagesSent().size(), 2u, secondUpdateWithin);

    } else if (secondUpdateInterval == 0) {

        QCOMPARE(transport.messagesSent().size(), 1u);

        QCoreApplication::processEvents();

        QCOMPARE(transport.messagesSent().size(), 2u);

    } else {

        QCOMPARE(transport.messagesSent().size(), 2u);

void TestWebChannel::testQPropertyBlockUpdates()

    DummyTransport transport;

    QWebChannel channel;

    QMetaObjectPublisher *publisher = channel.d_func()->publisher;

    publisher->setPropertyUpdateInterval(0);

    QProperty<bool> blockUpdates(false);

    channel.bindableBlockUpdates().setBinding(Qt::makePropertyBinding(blockUpdates));

    QCOMPARE(channel.blockUpdates(), false);

    bool blockedSignalled(false);

    connect(&channel, &QWebChannel::blockUpdatesChanged, this,

            [&](bool block) { blockedSignalled = block; });

    TestObject testObj;

    testObj.setObjectName("testObject");

    channel.registerObject(testObj.objectName(), &testObj);

    channel.connectTo(&transport);

    QProperty<QString> obj1("Hello");

    testObj.bindableStringProperty().setBinding(Qt::makePropertyBinding(obj1));

    publisher->initializeClient(&transport);

    QVERIFY(transport.messagesSent().isEmpty());

    blockUpdates = true;

    QCOMPARE(blockedSignalled, true);

    publisher->setClientIsIdle(true, &transport);

    obj1 = "world";

    QTest::qWait(0);

    QCOMPARE(transport.messagesSent().size(), 0u);

    blockUpdates = false;

    QCOMPARE(blockedSignalled, false);

    QCOMPARE(transport.messagesSent().size(), 1u);

void TestWebChannel::testBindings()

    QWebChannel channel;

    QTestPrivate::testReadWritePropertyBasics(channel, true, false, "blockUpdates");

    if (QTest::currentTestFailed()) {

        qDebug("Failed property test for QWebChannel::blockUpdates");

        return;

    QVERIFY(!channel.blockUpdates());

    QTestPrivate::testReadWritePropertyBasics(channel, 100, 200, "propertyUpdateInterval");

    if (QTest::currentTestFailed()) {

        qDebug("Failed property test for QWebChannel::propertyUpdateInterval");

        return;

void TestWebChannel::testPropertyMultipleTransports()

    DummyTransport transport1;

    DummyTransport transport2;

    QWebChannel channel;

    QMetaObjectPublisher *publisher = channel.d_func()->publisher;

    TestObject testObj;

    testObj.setObjectName("testObject");

    channel.registerObject(testObj.objectName(), &testObj);

    channel.connectTo(&transport1);

    channel.connectTo(&transport2);

    QProperty<QString> obj1("Hello");

    testObj.bindableStringProperty().setBinding([&]() { return obj1.value(); });

    publisher->initializeClient(&transport1);

    publisher->initializeClient(&transport2);

    publisher->setClientIsIdle(true, &transport1);

    QCOMPARE(publisher->isClientIdle(&transport1), true);

    QCOMPARE(publisher->isClientIdle(&transport2), false);

    channel.setPropertyUpdateInterval(1000);

    QVERIFY(transport1.messagesSent().isEmpty());

    QVERIFY(transport2.messagesSent().isEmpty());

    obj1 = "World";

    QTRY_COMPARE_WITH_TIMEOUT(transport1.messagesSent().size(), 1u, 2000);

    QCOMPARE(transport2.messagesSent().size(), 0u);

    publisher->setClientIsIdle(true, &transport2);

    QTRY_COMPARE_WITH_TIMEOUT(transport2.messagesSent().size(), 1u, 2000);

    QCOMPARE(publisher->isClientIdle(&transport1), false);

    QCOMPARE(publisher->isClientIdle(&transport2), false);

    obj1 = "!!!";

    publisher->setClientIsIdle(true, &transport2);

    QCOMPARE(publisher->isClientIdle(&transport2), true);

    QCOMPARE(publisher->isClientIdle(&transport1), false);

    QTRY_COMPARE_WITH_TIMEOUT(transport2.messagesSent().size(), 2u, 2000);

    QCOMPARE(transport1.messagesSent().size(), 1u);

    publisher->setClientIsIdle(true, &transport1);

    QTRY_COMPARE_WITH_TIMEOUT(transport1.messagesSent().size(), 2u, 2000);

    QCOMPARE(publisher->isClientIdle(&transport1), false);

    QCOMPARE(publisher->isClientIdle(&transport2), false);

class FunctionWrapper : public QObject

    Q_OBJECT

    std::function<void()> m_fun;

public:

    FunctionWrapper(std::function<void()> fun) : m_fun(std::move(fun)) {}

public slots:

    void invoke()

        m_fun();

};

void TestWebChannel::testDeletionDuringMethodInvocation_data()

    QTest::addColumn<bool>("deleteChannel");

    QTest::addColumn<bool>("deleteTransport");

    QTest::newRow("delete neither")   << false << false;

    QTest::newRow("delete channel")   << true  << false;

    QTest::newRow("delete transport") << false << true;

    QTest::newRow("delete both")      << true  << true;

void TestWebChannel::testDeletionDuringMethodInvocation()

    QFETCH(bool, deleteChannel);

    QFETCH(bool, deleteTransport);

    QScopedPointer<QWebChannel> channel(new QWebChannel);

    QScopedPointer<DummyTransport> transport(new DummyTransport(nullptr));

    FunctionWrapper deleter([&](){

        if (deleteChannel)

            channel.reset();

        if (deleteTransport)

            transport.reset();

});

    channel->registerObject("deleter", &deleter);

    channel->connectTo(transport.data());

    transport->emitMessageReceived({

        {"type", TypeInvokeMethod},

        {"object", "deleter"},

        {"method", deleter.metaObject()->indexOfMethod("invoke()")},

        {"id", 42}

});

    QCOMPARE(deleteChannel, !channel);

    QCOMPARE(deleteTransport, !transport);

    if (!deleteTransport)

        QCOMPARE(transport->messagesSent().size(), deleteChannel ? 0 : 1);

void TestWebChannel::testRejectsMissingArguments()

    QWebChannel channel;

    channel.connectTo(m_dummyTransport);

    auto *publisher = channel.d_func()->publisher;

    const int index = metaObject()->indexOfMethod("setInt(int)");

    QVERIFY(index >= 0);

    m_lastInt = 0;

    publisher->invokeMethod(this, index, QJsonArray{42});

    QCOMPARE(m_lastInt, 42);

    QTest::ignoreMessage(QtWarningMsg,

                         QRegularExpression("0 arguments given, but method requires 1"));

    publisher->invokeMethod(this, index, QJsonArray());

    QCOMPARE(m_lastInt, 42);

    const int index2 = metaObject()->indexOfMethod("setIntDouble(int,double)");

    QVERIFY(index2 >= 0);

    m_lastInt = 7;

    m_lastDouble = 4.2;

    QTest::ignoreMessage(QtWarningMsg,

                         QRegularExpression("1 arguments given, but method requires 2"));

    publisher->invokeMethod(this, index2, QJsonArray{1});

    QCOMPARE(m_lastInt, 7);

    QCOMPARE(m_lastDouble, 4.2);

void TestWebChannel::testRejectsUnresolvableObjectId()

    QWebChannel channel;

    channel.connectTo(m_dummyTransport);

    TestObject obj;

    obj.setObjectProperty(&obj);

    channel.registerObject(u"obj"_s, &obj);

    auto *publisher = channel.d_func()->publisher;

    publisher->initializeClient(m_dummyTransport);

    const int index = obj.metaObject()->indexOfProperty("objectProperty");

    QVERIFY(index >= 0);

    QTest::ignoreMessage(QtWarningMsg,

                         QRegularExpression("No wrapped object"));

    QTest::ignoreMessage(QtWarningMsg,

                         QRegularExpression("Cannot convert argument QJsonValue"));

    QTest::ignoreMessage(QtWarningMsg,

                         QRegularExpression("Conversion failed:"));

    publisher->setProperty(&obj, index,

                           QJsonObject{{ u"id"_s, u"nope"_s }});

    // Must be left alone, not overwritten with nullptr.

    QCOMPARE(obj.objectProperty(), &obj);

void TestWebChannel::testRejectsUnresolvableObjectIdInMethodCall()

    QWebChannel channel;

    channel.connectTo(m_dummyTransport);

    TestObject obj;

    channel.registerObject(u"obj"_s, &obj);

    auto *publisher = channel.d_func()->publisher;

    publisher->initializeClient(m_dummyTransport);

    obj.setObjectProperty(&obj);

    QTest::ignoreMessage(QtWarningMsg,

                         QRegularExpression("No wrapped object"));

    QTest::ignoreMessage(QtWarningMsg,

                         QRegularExpression("No wrapped object"));

    QTest::ignoreMessage(QtWarningMsg,

                         QRegularExpression("Cannot convert argument QJsonValue"));

    QTest::ignoreMessage(QtWarningMsg,

                         QRegularExpression("Cannot invoke"));

    // Same rejection, but through invokeMethod_helper rather than setProperty.

    publisher->invokeMethod(&obj, "setObjectProperty"_ba,

                            QJsonArray{ QJsonObject{{ u"id"_s, u"nope"_s }} });

    // Must be left alone, not overwritten with nullptr.

    QCOMPARE(obj.objectProperty(), &obj);

void TestWebChannel::testAcceptsExplicitNullForObjectPointer()

    QWebChannel channel;

    channel.connectTo(m_dummyTransport);

    TestObject obj;

    obj.setObjectProperty(&obj);

    channel.registerObject(u"obj"_s, &obj);

    auto *publisher = channel.d_func()->publisher;

    publisher->initializeClient(m_dummyTransport);

    const int index = obj.metaObject()->indexOfProperty("objectProperty");

    publisher->setProperty(&obj, index, QJsonValue(QJsonValue::Null));

    // Rejecting unresolvable ids must not break the legitimate null case.

    QCOMPARE(obj.objectProperty(), nullptr);

// Mismatched classes used to be caught by QMetaProperty::write().

// toVariant() now rejects them itself, so the wrong class never

// reaches the property. The variant is typed to match the property,

// so write() no longer converts and no longer checks.

void TestWebChannel::testRejectsMismatchedObjectClass()

    QWebChannel channel;

    channel.connectTo(m_dummyTransport);

    TestObject receiver;

    QObject decoy;

    channel.registerObject(u"receiver"_s, &receiver);

    channel.registerObject(u"decoy"_s, &decoy);

    auto *publisher = channel.d_func()->publisher;

    publisher->initializeClient(m_dummyTransport);

    receiver.setReturnedObject(nullptr);

    // returnedObject is declared TestObject*, so a plain QObject must be refused.

    const int index = receiver.metaObject()->indexOfProperty("returnedObject");

    QVERIFY(index >= 0);

    QTest::ignoreMessage(QtWarningMsg,

                         QRegularExpression("Cannot convert argument QJsonValue"));

    QTest::ignoreMessage(QtWarningMsg,

                         QRegularExpression("Conversion failed:"));

    publisher->setProperty(&receiver, index,

                           QJsonObject{ { u"id"_s, u"decoy"_s } });

    QCOMPARE(receiver.returnedObject(), nullptr);

void TestWebChannel::testRejectsMismatchedObjectClassByName()

    QWebChannel channel;

    channel.connectTo(m_dummyTransport);

    TestObject receiver;

    QObject decoy;

    channel.registerObject(u"decoy"_s, &decoy);

    auto *publisher = channel.d_func()->publisher;

    publisher->initializeClient(m_dummyTransport);

    receiver.setReturnedObject(nullptr);

    QTest::ignoreMessage(QtWarningMsg,

                         QRegularExpression("Cannot convert argument QJsonValue"));

    QTest::ignoreMessage(QtWarningMsg,

                         QRegularExpression("Cannot invoke"));

    publisher->invokeMethod(&receiver, "setReturnedObject"_ba,

                            QJsonArray{ QJsonObject{ { u"id"_s, u"decoy"_s } } });

    QCOMPARE(receiver.returnedObject(), nullptr);

void TestWebChannel::testRejectsMismatchedObjectClassByIndex()

    QWebChannel channel;

    channel.connectTo(m_dummyTransport);

    TestObject receiver;

    QObject decoy;

    channel.registerObject(u"decoy"_s, &decoy);

    auto *publisher = channel.d_func()->publisher;

    publisher->initializeClient(m_dummyTransport);

    const int index =

            receiver.metaObject()->indexOfMethod("setReturnedObject(TestObject*)");

    QVERIFY(index >= 0);

    receiver.setReturnedObject(nullptr);

    QTest::ignoreMessage(QtWarningMsg,

                         QRegularExpression("Cannot convert argument QJsonValue"));

    QTest::ignoreMessage(QtWarningMsg,

                         QRegularExpression("Cannot invoke"));

    publisher->invokeMethod(&receiver, index,

                            QJsonArray{ QJsonObject{ { u"id"_s,

                                                       u"decoy"_s } } });

    QCOMPARE(receiver.returnedObject(), nullptr);

void TestWebChannel::testRejectsUnconvertibleArgument()

    QWebChannel channel;

    channel.connectTo(m_dummyTransport);

    auto *publisher = channel.d_func()->publisher;

    const QUrl before(u"http://example.com"_s);

    setUrl(before);

    QTest::ignoreMessage(QtWarningMsg,

                         QRegularExpression("Could not convert argument QJsonValue"));

    QTest::ignoreMessage(QtWarningMsg,

                         QRegularExpression("Cannot invoke"));

    // A JSON object has no conversion to QUrl by either route.

    publisher->invokeMethod(this, "setUrl"_ba,

                            QJsonArray{ QJsonObject{ { u"not"_s,

                                                       u"a url"_s } } });

    QCOMPARE(readUrl(), before);

void TestWebChannel::testRejectsNonSignalIndex()

    QWebChannel channel;

    TestObject obj;

    channel.registerObject(u"obj"_s, &obj);

    channel.connectTo(m_dummyTransport);

    auto *publisher = channel.d_func()->publisher;

    publisher->initializeClient(m_dummyTransport);

    const int slotIndex = obj.metaObject()->indexOfMethod("setObjectProperty(QObject*)");

    QVERIFY(slotIndex >= 0);

    QCOMPARE(obj.metaObject()->method(slotIndex).methodType(), QMetaMethod::Slot);

    QJsonObject connectMessage;

    connectMessage[u"type"_s] = TypeConnectToSignal;

    connectMessage[u"object"_s] = u"obj"_s;

    connectMessage[u"signal"_s] = slotIndex;

    QTest::ignoreMessage(QtWarningMsg,

                         QRegularExpression(u"Method with index %1 .* is not a signal."_s.arg(slotIndex)));

    publisher->handleMessage(connectMessage, m_dummyTransport);

    auto *handler = publisher->signalHandlerFor(&obj);

    QVERIFY(!handler->m_connectionsCounter.value(&obj).contains(slotIndex));

    QVERIFY(!handler->m_signalArgumentTypes.value(obj.metaObject()).contains(slotIndex));

    // A real signal still connects

    const int signalIndex = obj.metaObject()->indexOfSignal("replay()");

    QVERIFY(signalIndex >= 0);

    connectMessage[u"signal"_s] = signalIndex;

    publisher->handleMessage(connectMessage, m_dummyTransport);

    m_dummyTransport->clearMessages();

    obj.fire();

    QVERIFY(!m_dummyTransport->messagesSent().isEmpty());

    QVERIFY(handler->m_connectionsCounter.value(&obj).contains(signalIndex));

    QVERIFY(handler->m_signalArgumentTypes.value(obj.metaObject()).contains(signalIndex));

#if QT_CONFIG(future)

void TestWebChannel::testAsyncMethodReturningFuture_data()

    QTest::addColumn<QString>("methodName");

    QTest::addColumn<QJsonValue>("result");

    QTest::addRow("int") << "futureIntResult" << QJsonValue{42};

    QTest::addRow("int-delayed") << "futureDelayedIntResult" << QJsonValue{7};

#ifdef WEBCHANNEL_TESTS_CAN_USE_CONCURRENT

    QTest::addRow("int-thread") << "futureIntResultFromThread" << QJsonValue{1337};

#endif

    QTest::addRow("void") << "futureVoidResult" << QJsonValue{};

    QTest::addRow("QString") << "futureStringResult" << QJsonValue{"foo"};

    QTest::addRow("cancelled") << "cancelledFuture" << QJsonValue{};

    QTest::addRow("failed")    << "failedFuture"    << QJsonValue{};

void TestWebChannel::testAsyncMethodReturningFuture()

    QFETCH(QString, methodName);

    QFETCH(QJsonValue, result);

    QWebChannel channel;

    TestObject obj;

    channel.registerObject("testObject", &obj);

    DummyTransport transport;

    channel.connectTo(&transport);

    transport.emitMessageReceived({

        {"type", TypeInvokeMethod},

        {"object", "testObject"},

        {"method", methodName},

        {"id", 1}

});

    QTRY_COMPARE(transport.messagesSent().size(), 1);

    QCOMPARE(transport.messagesSent().first().value("data"), result);

#endif

#ifdef WEBCHANNEL_TESTS_CAN_USE_JS_ENGINE

class SubclassedTestObject : public TestObject

    Q_OBJECT

    Q_PROPERTY(QString bar READ bar WRITE setBar NOTIFY theBarHasChanged)

public:

    void setBar(const QString &newBar);

signals:

    void theBarHasChanged();

};

void SubclassedTestObject::setBar(const QString &newBar)

    if (!newBar.isNull())

        emit theBarHasChanged();

class TestSubclassedFunctor {

public:

    TestSubclassedFunctor(TestJSEngine *engine)

        : m_engine(engine)

    void operator()() {

        QCOMPARE(m_engine->logger()->errorCount(), 0);

private:

    TestJSEngine *m_engine;

};

#endif // WEBCHANNEL_TESTS_CAN_USE_JS_ENGINE

void TestWebChannel::qtbug46548_overriddenProperties()

#ifndef WEBCHANNEL_TESTS_CAN_USE_JS_ENGINE

    QSKIP("A JS engine is required for this test to make sense.");

#else

    SubclassedTestObject obj;

    obj.setObjectName("subclassedTestObject");

    QWebChannel webChannel;

    webChannel.registerObject(obj.objectName(), &obj);

    TestJSEngine engine;

    webChannel.connectTo(engine.transport());

    QSignalSpy spy(&engine, &TestJSEngine::channelSetupReady);

    connect(&engine, &TestJSEngine::channelSetupReady, TestSubclassedFunctor(&engine));

    engine.initWebChannelJS();

    if (!spy.size())

        spy.wait();

    QCOMPARE(spy.size(), 1);

    QJSValue subclassedTestObject = engine.evaluate("channel.objects[\"subclassedTestObject\"]");

    QVERIFY(subclassedTestObject.isObject());

#endif // WEBCHANNEL_TESTS_CAN_USE_JS_ENGINE

void TestWebChannel::qtbug62388_wrapObjectMultipleTransports()

    QWebChannel channel;

    TestObject obj;

    auto initTransport = [&channel](QWebChannelAbstractTransport *transport) {

        channel.connectTo(transport);

        channel.d_func()->publisher->initializeClient(transport);

};

    initTransport(m_dummyTransport);

    auto queryObjectInfo = [&channel](QObject *obj, QWebChannelAbstractTransport *transport) {

        return channel.d_func()->publisher->wrapResult(QVariant::fromValue(obj), transport).toObject();

};

    auto verifyObjectInfo = [&obj](const QJsonObject &objectInfo) {

        QCOMPARE(objectInfo.length(), 3);

        QVERIFY(objectInfo.contains("id"));

        QVERIFY(objectInfo.contains("__QObject*__"));

        QVERIFY(objectInfo.contains("data"));

        QVERIFY(objectInfo.value("__QObject*__").isBool() && objectInfo.value("__QObject*__").toBool());

        const auto propIndex = obj.metaObject()->indexOfProperty("prop");

        const auto prop = objectInfo["data"].toObject()["properties"].toArray()[propIndex].toArray()[3].toString();

        QCOMPARE(prop, obj.prop());

};

    const auto objectInfo = queryObjectInfo(&obj, m_dummyTransport);

    verifyObjectInfo(objectInfo);

    const auto id = objectInfo.value("id").toString();

    QCOMPARE(channel.d_func()->publisher->unwrapObject(id), &obj);

    DummyTransport transport;

    initTransport(&transport);

    QCOMPARE(queryObjectInfo(&obj, &transport), objectInfo);

    obj.setProp("asdf");

    const auto objectInfo2 = queryObjectInfo(&obj, m_dummyTransport);

    QVERIFY(objectInfo2 != objectInfo);

    verifyObjectInfo(objectInfo2);

    DummyTransport transport2;

    initTransport(&transport2);

    QCOMPARE(queryObjectInfo(&obj, &transport2), objectInfo2);

    // don't crash when the transports are destroyed

// Scenario: A transport is destroyed while it is still connected.

// Given a publisher that holds per-transport state for the transport,

// when the transport is destroyed,

// then the publisher erases the per-transport state.

void TestWebChannel::qtbug150200_transportStateRemovedOnDestroy()

    // GIVEN: A publisher that holds per-transport state

    QWebChannel channel;

    QMetaObjectPublisher *publisher = channel.d_func()->publisher;

    auto transport = std::make_unique<DummyTransport>();

    channel.connectTo(transport.get());

    publisher->initializeClient(transport.get());

    publisher->setClientIsIdle(true, transport.get());

    QCOMPARE(publisher->transportState.size(), 1);

    // WHEN: The transport is destroyed

    transport.reset();

    // THEN: The publisher erases the per-transport state

    QCOMPARE(publisher->transportState.size(), 0);

// Scenario: A transport is disconnected from the channel.

// Given a publisher that holds per-transport state for the transport,

// when the transport is disconnected,

// then the publisher erases the per-transport state.

void TestWebChannel::qtbug150200_transportStateRemovedOnDisconnect()

    // GIVEN: A publisher that holds per-transport state

    QWebChannel channel;

    QMetaObjectPublisher *publisher = channel.d_func()->publisher;

    DummyTransport transport;

    channel.connectTo(&transport);

    publisher->initializeClient(&transport);

    publisher->setClientIsIdle(true, &transport);

    QCOMPARE(publisher->transportState.size(), 1);

    // WHEN: The transport is disconnected

    channel.disconnectFrom(&transport);

    // THEN: The publisher erases the per-transport state

    QCOMPARE(publisher->transportState.size(), 0);

// Scenario: A new transport reuses the address of a destroyed transport.

// Given a destroyed transport that was idle and had a queued message,

// when a new transport is constructed at the same address,

// then the new client is not idle and gets no queued message.

void TestWebChannel::qtbug150200_newTransportDoesNotInheritState()

    // Runs the destructor of a transport that was constructed in place,

    // and leaves the storage itself alone.

    struct InPlaceDeleter

        void operator()(DummyTransport *transport) const

            transport->~DummyTransport();

};

    using InPlaceTransport = std::unique_ptr<DummyTransport, InPlaceDeleter>;

    // GIVEN: A destroyed transport that was idle and had a queued message

    QWebChannel channel;

    QMetaObjectPublisher *publisher = channel.d_func()->publisher;

    alignas(DummyTransport) std::byte storage[sizeof(DummyTransport)];

    InPlaceTransport oldTransport(new (storage) DummyTransport);

    const void *oldAddress = oldTransport.get();

    channel.connectTo(oldTransport.get());

    publisher->initializeClient(oldTransport.get());

    publisher->setClientIsIdle(true, oldTransport.get());

    publisher->enqueueMessage(QJsonObject{{"type", "stale"}},

                              oldTransport.get());

    QCOMPARE(publisher->isClientIdle(oldTransport.get()), true);

    oldTransport.reset();

    // WHEN: A new transport is constructed at the same address

    InPlaceTransport newTransport(new (storage) DummyTransport);

    QCOMPARE(static_cast<const void *>(newTransport.get()), oldAddress);

    channel.connectTo(newTransport.get());

    publisher->initializeClient(newTransport.get());

    // THEN: The new client is not idle and gets no queued message

    QCOMPARE(publisher->isClientIdle(newTransport.get()), false);

    publisher->setClientIsIdle(true, newTransport.get());

    QCOMPARE(newTransport->messagesSent().size(), 0);

QTEST_MAIN(TestWebChannel)

#include "tst_webchannel.moc"