tst_qlanguageserver.cpp

qt/qtlanguageserver/tests/auto/qlanguageserver/tst_qlanguageserver.cpp (file symbol)

Enable keyboard shortcuts

Revision control

Copy as Markdown

// Copyright (C) 2021 The Qt Company Ltd.

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

#include "qiopipe.h"

#include <QtJsonRpc/private/qjsonrpcprotocol_p.h>

#include <QtLanguageServer/private/qlanguageserverjsonrpctransport_p.h>

#include <QtLanguageServer/private/qlanguageserverprotocol_p.h>

#include <QtCore/qjsonarray.h>

#include <QtCore/qjsonobject.h>

#include <QtCore/qjsondocument.h>

#include <QtCore/qstring.h>

#include <QtTest/qsignalspy.h>

#include <QtTest/qtest.h>

using namespace Qt::StringLiterals;

using namespace QLspSpecification;

class TestRigEventHandler

public:

    TestRigEventHandler(QLanguageServerProtocol *protocol, QIODevice *device) : m_device(device)

        protocol->registerInitializeRequestHandler(

                    [this](const QByteArray &, const InitializeParams &clientCapabilities,

                           auto &&response) {

            Q_UNUSED(clientCapabilities);

            m_isInitialized = true;

            InitializeResult result;

            result.capabilities = m_serverCapabilities;

            response.sendResponse(result);

});

        protocol->registerInitializedNotificationHandler(

                [](const QByteArray &, const InitializedParams &) {});

        protocol->registerShutdownRequestHandler(

                [](const QByteArray &, const auto &, auto &&response) { response.sendResponse(); });

        protocol->registerExitNotificationHandler(

                [this](const QByteArray &, const auto &) { m_hasExited = true; });

        // TODO: There should be a way to do this without using the typed RPC layer.

        protocol->typedRpc()->installMessagePreprocessor(

                    [this](const QJsonDocument &doc, const QJsonParseError &,

                           const QJsonRpcProtocol::Handler<QJsonRpcProtocol::Response> &responder) {

            if (m_isInitialized)

                return QJsonRpcProtocol::Processing::Continue;

            if (doc.object()[u"method"].toString()

                    == QString::fromUtf8(QLspSpecification::Requests::InitializeMethod)) {

                return QJsonRpcProtocol::Processing::Continue;

            responder(QJsonRpcProtocol::MessageHandler::error(

                          int(QLspSpecification::ErrorCodes::ServerNotInitialized),

                          u"Method called on non initialized Language Server"_s));

            return QJsonRpcProtocol::Processing::Stop;

});

        QObject::connect(device, &QIODevice::readyRead, m_device,

                         [this, protocol]() { protocol->receiveData(m_device->readAll()); });

    bool isInitialized() const { return m_isInitialized; }

    bool hasExited() const { return m_hasExited; }

    void setServerCapabilities(QLspSpecification::ServerCapabilities capabilities)

        m_serverCapabilities = std::move(capabilities);

    QLspSpecification::ServerCapabilities serverCapabilities() const

        return m_serverCapabilities;

private:

    QLspSpecification::ServerCapabilities m_serverCapabilities;

    QIODevice *m_device = nullptr;

    bool m_isInitialized = false;

    bool m_hasExited = false;

};

static void setTransportDevice(QLanguageServerJsonRpcTransport *transport, QIODevice *device)

    transport->setDataHandler([device](const QByteArray &data) {

        device->write(data);

});

    QObject::connect(device, &QIODevice::readyRead, device, [device, transport]() {

        transport->receiveData(device->readAll());

});

static void sendAndWaitJsonRpc(QJsonRpcProtocol *protocol,

                               const QJsonRpcProtocol::Request &request,

                               const QJsonRpcProtocol::Handler<QJsonRpcProtocol::Response> &handler)

    bool handled = false;

    protocol->sendRequest(request, [&](const QJsonRpcProtocol::Response &response) {

        handled = true;

        handler(response);

});

    QTRY_VERIFY(handled);

class TestRig

public:

    QLanguageServerProtocol protocol;

    QJsonRpcProtocol client;

    std::unique_ptr<TestRigEventHandler> handler;

    TestRig() : protocol([this](const QByteArray &data) { pipe.end1()->write(data); })

        handler = std::make_unique<TestRigEventHandler>(&protocol, pipe.end1());

        setTransportDevice(&clientTransport, pipe.end2());

        client.setTransport(&clientTransport);

    void open(const QLspSpecification::ServerCapabilities &capabilities

              = QLspSpecification::ServerCapabilities())

        handler->setServerCapabilities(capabilities);

        QVERIFY(pipe.open(QIODevice::ReadWrite));

    void initialize(const QLspSpecification::ClientCapabilities &clientCapabilities

                    = QLspSpecification::ClientCapabilities())

        QLspSpecification::InitializeParams params;

        params.capabilities = clientCapabilities;

        sendAndWaitJsonRpc(&client, QJsonRpcProtocol::Request {

0,

            "initialize",

            QTypedJson::toJsonValue(params)

        }, [&](const QJsonRpcProtocol::Response &response) {

            QCOMPARE(response.data["capabilities"],

                    QTypedJson::toJsonValue(handler->serverCapabilities()));

});

private:

    QLanguageServerJsonRpcTransport clientTransport;

    QIOPipe pipe;

};

class tst_QLanguageServer : public QObject

    Q_OBJECT

private slots:

    void jsonRpcTransport();

    void jsonRpcTransportHeaderCase();

    void invalidHeaderField();

    void protocolHandlesTransportErrors();

    void invalidJson();

    void protocolError();

    void lifecycle();

    void windowShowMessage();

    void windowShowMessageRequest();

    void windowLogMessage();

    void telemetryEvent();

    void clientRegisterCapability();

    void setRequestHandler();

    void rejectOutOfBoundMessages_data();

    void rejectOutOfBoundMessages();

private:

    void logOrShowMessage(const QString &method);

};

class NotificationHandler : public QJsonRpcProtocol::MessageHandler

public:

    using Handler = std::function<void(QJsonRpcProtocol::Notification)>;

    NotificationHandler(const Handler &handler) : m_notificationHandler(handler) {}

    void handleRequest(const QJsonRpcProtocol::Request &request, const ResponseHandler &handler) final;

    void handleNotification(const QJsonRpcProtocol::Notification &notification) final;

private:

    Handler m_notificationHandler;

};

class RequestHandler : public QJsonRpcProtocol::MessageHandler

public:

    using Handler = std::function<QJsonRpcProtocol::Response(QJsonRpcProtocol::Request)>;

    RequestHandler(const Handler &handler) : m_requestHandler(handler) {}

    void handleRequest(const QJsonRpcProtocol::Request &request,

                       const ResponseHandler &handler) final;

    void handleNotification(const QJsonRpcProtocol::Notification &notification) final;

private:

    Handler m_requestHandler;

};

void NotificationHandler::handleRequest(const QJsonRpcProtocol::Request &request,

                                        const ResponseHandler &responseHandler)

    Q_UNUSED(request);

    Q_UNUSED(responseHandler);

    QFAIL("request received when notification was expected");

void NotificationHandler::handleNotification(const QJsonRpcProtocol::Notification &notification)

    m_notificationHandler(notification);

void RequestHandler::handleRequest(const QJsonRpcProtocol::Request &request,

                                   const ResponseHandler &responseHandler)

    responseHandler(m_requestHandler(request));

void RequestHandler::handleNotification(const QJsonRpcProtocol::Notification &notification)

    Q_UNUSED(notification);

    QFAIL("notification received when request was expected");

void tst_QLanguageServer::jsonRpcTransport()

    static const QByteArray header = "Content-Length: 15\r\n\r\n";

    static const QByteArray content = "{\"some\":\"json\"}";

        QIOPipe pipe;

        QVERIFY(pipe.open(QIODevice::WriteOnly));

        QLanguageServerJsonRpcTransport transport;

        setTransportDevice(&transport, pipe.end2());

        int messages = 0;

        transport.setMessageHandler([&](const QJsonDocument &message,

                                        const QJsonParseError &error) {

            QCOMPARE(error.error, QJsonParseError::NoError);

            QCOMPARE(message.toJson(QJsonDocument::Compact), content);

            ++messages;

});

        for (int i = 0; i < 5; ++i) {

            QCOMPARE(pipe.end1()->write(header), header.size());

            QCOMPARE(pipe.end1()->write(content), content.size());

            QTRY_COMPARE(messages, i + 1);

        QIOPipe pipe;

        QVERIFY(pipe.open(QIODevice::ReadOnly));

        QByteArray received;

        QIODevice *end1 = pipe.end1();

        connect(end1, &QIODevice::readyRead, end1, [&]() {

            received.append(end1->read(end1->bytesAvailable()));

});

        QLanguageServerJsonRpcTransport protocol;

        setTransportDevice(&protocol, pipe.end2());

        for (int i = 0; i < 5; ++i) {

            protocol.sendMessage(QJsonDocument::fromJson(content));

            QTRY_COMPARE(received, header + content);

            received.clear();

void tst_QLanguageServer::jsonRpcTransportHeaderCase()

    static const QList<QByteArray> headers = { { "Content-Length: 15\r\n\r\n" },

                                               { "content-length: 15\r\n\r\n" },

                                               { "ConTEnt-lEngTh:  15 \r\n\r\n" },

                                               { "CONTENT-LENGTH:  15\r\n\r\n" },

                                               { "cONtENt-LENgTh: 15  \r\n\r\n" } };

    static const QByteArray content = "{\"some\":\"json\"}";

        QIOPipe pipe;

        QVERIFY(pipe.open(QIODevice::WriteOnly));

        QLanguageServerJsonRpcTransport transport;

        setTransportDevice(&transport, pipe.end2());

        int messages = 0;

        transport.setMessageHandler(

                [&](const QJsonDocument &message, const QJsonParseError &error) {

                    QCOMPARE(error.error, QJsonParseError::NoError);

                    QCOMPARE(message.toJson(QJsonDocument::Compact), content);

                    ++messages;

});

        for (int i = 0; i < 5; ++i) {

            QCOMPARE(pipe.end1()->write(headers.at(i)), headers.at(i).size());

            QCOMPARE(pipe.end1()->write(content), content.size());

            QTRY_COMPARE(messages, i + 1);

        QIOPipe pipe;

        QVERIFY(pipe.open(QIODevice::ReadOnly));

        QByteArray received;

        QIODevice *end1 = pipe.end1();

        connect(end1, &QIODevice::readyRead, end1,

                [&]() { received.append(end1->read(end1->bytesAvailable())); });

        QLanguageServerJsonRpcTransport protocol;

        setTransportDevice(&protocol, pipe.end2());

        for (int i = 0; i < 5; ++i) {

            protocol.sendMessage(QJsonDocument::fromJson(content));

            QTRY_COMPARE(received, headers.at(0) + content);

            received.clear();

void tst_QLanguageServer::invalidHeaderField()

    static const QByteArray header = "Broken-Mess\r\n"

                                     "Content-Length: 15\r\n\r\n";

    static const QByteArray content = "{\"some\":\"json\"}";

    QIOPipe pipe;

    QVERIFY(pipe.open(QIODevice::ReadWrite));

    QLanguageServerJsonRpcTransport transport;

    setTransportDevice(&transport, pipe.end1());

    int messages = 0;

    transport.setMessageHandler([&](const QJsonDocument &message,

                                    const QJsonParseError &error) {

        QCOMPARE(error.error, QJsonParseError::NoError);

        QCOMPARE(message.toJson(QJsonDocument::Compact), content);

        ++messages;

});

    int warnings = 0;

    transport.setDiagnosticHandler([&](QJsonRpcTransport::DiagnosticLevel level,

                                   const QString &message) {

        QVERIFY2(level == QJsonRpcTransport::Warning, qPrintable(message));

        ++warnings;

});

    QIODevice *end2 = pipe.end2();

    for (int i = 0; i < 5; ++i) {

        QCOMPARE(end2->write(header), header.size());

        QCOMPARE(end2->write(content), content.size());

        QTRY_COMPARE(messages, i + 1);

        QCOMPARE(warnings, 2 * (i + 1));

void tst_QLanguageServer::protocolHandlesTransportErrors()

    static const QByteArray header = "Broken-Mess\r\n"

                                     "Content-Length: 15\r\n\r\n";

    static const QByteArray content = "{\"some\":\"json\"}";

    QIOPipe pipe;

    QVERIFY(pipe.open(QIODevice::ReadWrite));

    auto device = pipe.end1();

    QLanguageServerProtocol protocol([device](const QByteArray &data) { device->write(data); });

    QObject::connect(device, &QIODevice::readyRead, device,

                     [device, &protocol]() { protocol.receiveData(device->readAll()); });

    int warnings = 0;

    protocol.registerResponseErrorHandler(

            [&](const QLspSpecification::ResponseError &) { ++warnings; });

    QIODevice *end2 = pipe.end2();

    for (int i = 0; i < 5; ++i) {

        QCOMPARE(end2->write(header), header.size());

        QCOMPARE(end2->write(content), content.size());

        QTRY_COMPARE(warnings, 2 * (i + 1));

void tst_QLanguageServer::invalidJson()

    static const QByteArray header = "Content-Length: 15\r\n\r\n";

    static const QByteArray content = "{\"someZ:\"json\"}";

    QIOPipe pipe;

    QVERIFY(pipe.open(QIODevice::ReadWrite));

    QLanguageServerJsonRpcTransport transport;

    setTransportDevice(&transport, pipe.end2());

    int messages = 0;

    transport.setMessageHandler([&](const QJsonDocument &doc, const QJsonParseError &error) {

        QVERIFY(error.error != QJsonParseError::NoError);

        QVERIFY(doc.isNull());

        ++messages;

});

    QIODevice *end1 = pipe.end1();

    for (int i = 0; i < 5; ++i) {

        QCOMPARE(end1->write(header), header.size());

        QCOMPARE(end1->write(content), content.size());

        QTRY_COMPARE(messages, i + 1);

void tst_QLanguageServer::protocolError()

    static const QByteArray header = "Total-Mess: schalala\r\n\r\n";

    QIOPipe pipe;

    QVERIFY(pipe.open(QIODevice::WriteOnly));

    QLanguageServerJsonRpcTransport transport;

    setTransportDevice(&transport, pipe.end2());

    int errors = 0;

    transport.setDiagnosticHandler([&](QJsonRpcTransport::DiagnosticLevel level, const QString &) {

        if (level == QJsonRpcTransport::Error)

            ++errors;

});

    int messages = 0;

    transport.setMessageHandler([&](const QJsonDocument &doc, const QJsonParseError &error) {

        Q_UNUSED(doc);

        QVERIFY(error.error != QJsonParseError::NoError);

        ++messages;

});

    QCOMPARE(pipe.end1()->write(header), header.size());

    QTRY_COMPARE(errors, 1);

    QTRY_COMPARE(messages, 1);

void tst_QLanguageServer::lifecycle()

    QIOPipe pipe;

    pipe.open(QIODevice::ReadWrite);

    QLanguageServerProtocol server([&pipe](const QByteArray &data) {

        QMetaObject::invokeMethod(pipe.end1(), [&pipe, data]() { pipe.end1()->write(data); });

});

    TestRigEventHandler handler(&server, pipe.end1());

    QLanguageServerJsonRpcTransport transport;

    setTransportDevice(&transport, pipe.end2());

    QJsonRpcProtocol protocol;

    protocol.setTransport(&transport);

    int id = 0;

    sendAndWaitJsonRpc(&protocol, {

        ++id,

        "initialize",

        QJsonObject({

            { "processId", QJsonValue::Null },

            { "rootUri", QJsonValue::Null },

            { "capabilities", QJsonObject() }

})

    }, [&](const QJsonRpcProtocol::Response &response) {

        QCOMPARE(response.id, QJsonValue(id));

        QVERIFY2(response.errorMessage.isEmpty(), qPrintable(response.errorMessage));

        QVERIFY(!response.errorCode.isDouble());

        QCOMPARE(QJsonDocument(response.data.toObject()).toJson(QJsonDocument::Compact),

                 "{\"capabilities\":{}}");

});

    protocol.sendNotification({

        "initialized",

        QJsonObject()

});

    sendAndWaitJsonRpc(&protocol, {

        ++id,

        "shutdown",

        QJsonValue::Undefined

    }, [&](const QJsonRpcProtocol::Response &response) {

        QCOMPARE(response.id, QJsonValue(id));

        QVERIFY2(response.errorMessage.isEmpty(), qPrintable(response.errorMessage));

        QVERIFY(!response.errorCode.isDouble());

        QVERIFY(response.data.isNull());

});

    QVERIFY(!handler.hasExited());

    protocol.sendNotification({

        "exit",

        QJsonValue::Undefined

});

    QTRY_VERIFY(handler.hasExited());

void tst_QLanguageServer::logOrShowMessage(const QString &method)

    TestRig test;

    test.open();

    const QString message = QStringLiteral("msmsmsmsmsg");

    bool messageReceived = false;

    test.client.setMessageHandler(

                method,

                new NotificationHandler([&](const QJsonRpcProtocol::Notification &notification) {

        const QJsonObject params = notification.params.toObject();

        QCOMPARE(params["type"].toInt(), 4); // MessageType::Log

        QCOMPARE(params["message"].toString(), message);

        messageReceived = true;

    }));

    if (method == "window/showMessage") {

        QLspSpecification::ShowMessageParams params;

        params.type = QLspSpecification::MessageType::Log;

        params.message = message.toUtf8();

        test.protocol.notifyShowMessage(params);

    } else if (method == "window/logMessage") {

        QLspSpecification::LogMessageParams params;

        params.type = QLspSpecification::MessageType::Log;

        params.message = message.toUtf8();

        test.protocol.notifyLogMessage(params);

    } else {

        QFAIL("wrong method");

    QTRY_VERIFY(messageReceived);

void tst_QLanguageServer::windowShowMessage()

    logOrShowMessage("window/showMessage");

void tst_QLanguageServer::windowShowMessageRequest()

    TestRig test;

    test.open();

    const QString message = QStringLiteral("msmsmsmsmsg");

    auto item = [](const char *title) {

        QLspSpecification::MessageActionItem item;

        item.title = title;

        return item;

};

    const QList<QLspSpecification::MessageActionItem> actions({

        item("aaa"), item("bbb"), item("ccc")

});

    bool messageReceived = false;

    test.client.setMessageHandler(

                "window/showMessageRequest",

                new RequestHandler([&](const QJsonRpcProtocol::Request &request) {

        const QJsonObject params = request.params.toObject();

        [&]() {

            QCOMPARE(params["type"].toInt(), 4); // MessageType::Log

            QCOMPARE(params["message"].toString(), message);

            QCOMPARE(params["actions"].toArray(), QJsonArray({

                QJsonObject{{"title", "aaa"}},

                QJsonObject{{"title", "bbb"}},

                QJsonObject{{"title", "ccc"}},

            }));

        }();

        messageReceived = true;

        const QJsonRpcProtocol::Response response = {

            request.id,

            QJsonObject{{"title", "aaa"}},

            QJsonValue::Undefined,

            QString()

};

        return response;

    }));

    QLspSpecification::ShowMessageRequestParams params;

    params.type = QLspSpecification::MessageType::Log;

    params.message = message.toUtf8();

    params.actions = actions;

    test.protocol.requestShowMessageRequest(

            params,

            [&](const std::variant<std::nullptr_t, QLspSpecification::MessageActionItem> &_r) {

                auto r = std::get_if<QLspSpecification::MessageActionItem>(&_r);

                QVERIFY(r);

                QCOMPARE(r->title, "aaa");

});

    QTRY_VERIFY(messageReceived);

void tst_QLanguageServer::windowLogMessage()

    logOrShowMessage("window/logMessage");

void tst_QLanguageServer::telemetryEvent()

    TestRig test;

    test.open();

    const QJsonObject message { { QStringLiteral("a"), 42 } };

    bool messageReceived = false;

    test.client.setMessageHandler(

                "telemetry/event",

                new NotificationHandler([&](const QJsonRpcProtocol::Notification &notification) {

        QCOMPARE(notification.params, message);

        messageReceived = true;

    }));

    test.protocol.notifyTelemetryEvent(message);

    QTRY_VERIFY(messageReceived);

static void checkRequestInvalid(TestRig *test, const QLspSpecification::RegistrationParams &params)

    test->protocol.requestRegistration(params, []() {

        QFAIL("server responded to invalid request");

});

static void checkRequestValid(TestRig *test, const QLspSpecification::RegistrationParams &params)

    test->protocol.requestRegistration(

                params, [](){}, [](const QLspSpecification::ResponseError &) {

        QFAIL("server failed on valid request");

});

static void checkRequestInvalid(

        TestRig *test, const QLspSpecification::UnregistrationParams &params)

    test->protocol.requestUnregistration(params, []() {

        QFAIL("server responded to invalid request");

});

static void checkRequestValid(TestRig *test, const QLspSpecification::UnregistrationParams &params)

    test->protocol.requestUnregistration(

                params, [](){}, [](const QLspSpecification::ResponseError &) {

        QFAIL("server failed on valid request");

});

void tst_QLanguageServer::clientRegisterCapability()

    TestRig test;

    QLspSpecification::ServerCapabilities serverCapabilities;

    serverCapabilities.referencesProvider = true;

    test.open(serverCapabilities);

    QLspSpecification::RegistrationParams params;

    QLspSpecification::Registration referencesRegistration;

    referencesRegistration.method = "textDocument/references";

    params.registrations = { referencesRegistration };

    QTest::ignoreMessage(QtWarningMsg, QRegularExpression(u"ERROR -32601"_s));

    checkRequestInvalid(&test, params);

    QLspSpecification::ReferenceClientCapabilities references;

    references.dynamicRegistration = true;

    QLspSpecification::TextDocumentClientCapabilities textDocumentCapabilities;

    textDocumentCapabilities.references = references;

    QLspSpecification::ClientCapabilities clientCapabilities;

    clientCapabilities.textDocument = textDocumentCapabilities;

    test.initialize(clientCapabilities);

    QTest::ignoreMessage(QtWarningMsg, QRegularExpression(u"ERROR -32601"_s));

    checkRequestInvalid(&test, params);

    auto handler = [&](const QJsonRpcProtocol::Request &request) {

        [&]() {

            const QJsonObject params = request.params.toObject();

            QCOMPARE(params.length(), 1);

            const QJsonArray registrations = params.begin().value().toArray();

            QCOMPARE(registrations.count(), 1);

            const QJsonObject registration = registrations[0].toObject();

            QCOMPARE(registration["method"].toString(), QStringLiteral("textDocument/references"));

        }();

        const QJsonRpcProtocol::Response response = {

            request.id,

            QJsonValue::Null,

            QJsonValue::Undefined,

            QString()

};

        return response;

};

    test.client.setMessageHandler("client/registerCapability", new RequestHandler(handler));

    checkRequestValid(&test, params);

    const QLspSpecification::Registration registration = params.registrations.first();

    QLspSpecification::UnregistrationParams unregisterParams;

    unregisterParams.unregisterations = {

        QLspSpecification::Unregistration { registration.id, registration.method }

};

    checkRequestInvalid(&test, unregisterParams);

    test.client.setMessageHandler("client/unregisterCapability", new RequestHandler(handler));

    checkRequestValid(&test, unregisterParams);

void tst_QLanguageServer::setRequestHandler()

    TestRig test;

    const QList<QLspSpecification::Location> locations = {

        QLspSpecification::Location { "a.b.x", QLspSpecification::Range() }

};

    test.protocol.registerReferenceRequestHandler(

                [locations](const QByteArray &, const QLspSpecification::ReferenceParams &,

                   QLspSpecification::LSPPartialResponse<std::variant<

                        QList<QLspSpecification::Location>, std::nullptr_t>,

                   QList<QLspSpecification::Location>> &&result) {

        result.sendResponse(locations);

});

    test.open();

    QJsonRpcProtocol::Response response;

    auto requestReferences = [&]() {

        sendAndWaitJsonRpc(&test.client, {

4,

            "textDocument/references",

            QJsonValue()

        }, [&](const QJsonRpcProtocol::Response &received) {

            response = received;

});

};

    requestReferences();

    QCOMPARE(response.errorCode.toInt(), -32002);

    test.initialize();

    QVERIFY(test.handler->isInitialized());

    requestReferences();

    QVERIFY(response.errorCode.isUndefined());

    QCOMPARE(response.data, QTypedJson::toJsonValue(locations));

void tst_QLanguageServer::rejectOutOfBoundMessages_data()

    QTest::addColumn<QByteArray>("content");

    QTest::addColumn<std::optional<int>>("maxContentLength");

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

    const auto quint64_max = std::numeric_limits<quint64>::max();

    QTest::newRow("Exceeding INT_MAX Limit")

            << QString("Content-Length: %1\r\n\r\n{...}").arg(quint64_max).toUtf8()

            << std::optional<int>()

            << u"Invalid Content-Length: %1"_s.arg(quint64_max);

    QTest::newRow("Valid message within limit")

            << QByteArray("Content-Length: 500\r\n\r\n{...}")

            << std::optional<int>(1000) << QString();

    QTest::newRow("Invalid Message Exceeding Configured Limit")

            << QByteArray("Content-Length: 200\r\n\r\n")

            << std::optional<int>(100)

            << u"Content-Length 200 exceeds maximum allowed size 100"_s;

    QTest::newRow("Configuring Negative Limit Clamped to Zero")

            << QByteArray("Content-Length: 10\r\n\r\n") << std::optional<int>(-100)

            << u"Content-Length 10 exceeds maximum allowed size 0"_s;;

    QTest::newRow("Negative Content-Length")

            << QByteArray("Content-Length: -100\r\n\r\n")

            << std::optional<int>()

            << u"Negative Content-Length: -100"_s;

    QTest::newRow("Zero Content-Length")

            << QByteArray("Content-Length: 0\r\n\r\n")

            << std::optional<int>() << QString();

void tst_QLanguageServer::rejectOutOfBoundMessages()

    QFETCH(QByteArray, content);

    QFETCH(std::optional<int>, maxContentLength);

    QFETCH(QString, expectedWarningMessage);

    Q_UNUSED(maxContentLength);

    QLanguageServerJsonRpcTransport transport;

    if (maxContentLength.has_value())

        transport.setMaxContentLength(*maxContentLength);

    int warnings = 0;

    QSet<QString> warningMessages;

    transport.setDiagnosticHandler(

            [&](QJsonRpcTransport::DiagnosticLevel level, const QString &msg) {

                if (level == QJsonRpcTransport::Warning)

                    ++warnings;

                warningMessages.insert(msg);

});

    transport.receiveData(content);

    if (expectedWarningMessage.isEmpty()) {

        QCOMPARE(warnings, 0);

        return;

    QVERIFY(warningMessages.contains(expectedWarningMessage));

QTEST_MAIN(tst_QLanguageServer)

#include <tst_qlanguageserver.moc>