tst_qcoapinternalrequest.cpp

++ // Copyright (C) 2018 Witekio.

++ // Copyright (C) 2018 The Qt Company Ltd.

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

++

++ #include <QtTest>

++ #include <QCoreApplication>

++

++ #include <QtCoap/qcoaprequest.h>

++ #include <private/qcoapinternalrequest_p.h>

++ #include <private/qcoaprequest_p.h>

++

++ class tst_QCoapInternalRequest : public QObject

++ {

++     Q_OBJECT

++

++ private Q_SLOTS:

++     void requestToFrame_data();

++     void requestToFrame();

++     void parseUri_data();

++     void parseUri();

++     void urlOptions_data();

++     void urlOptions();

++     void invalidUrls_data();

++     void invalidUrls();

++     void isMulticast_data();

++     void isMulticast();

++     void parseBlockOption_data();

++     void parseBlockOption();

++     void createBlockOption_data();

++     void createBlockOption();

++     void initEmptyMessage_data();

++     void initEmptyMessage();

++ };

++

++ void tst_QCoapInternalRequest::requestToFrame_data()

++ {

++     QTest::addColumn<QUrl>("url");

++     QTest::addColumn<QtCoap::Method>("method");

++     QTest::addColumn<QCoapMessage::Type>("type");

++     QTest::addColumn<quint16>("messageId");

++     QTest::addColumn<QByteArray>("token");

++     QTest::addColumn<QString>("pduHeader");

++     QTest::addColumn<QString>("pduPayload");

++

++     QTest::newRow("request_with_option_and_payload")

++         << QUrl("coap://10.20.30.40:5683/test")

++         << QtCoap::Method::Get

++         << QCoapRequest::Type::NonConfirmable

++         << quint16(56400)

++         << QByteArray::fromHex("4647f09b")

++         << "5401dc504647f09bb474657374ff"

++         << "Some payload";

++

++     QTest::newRow("request_domain")

++         << QUrl("coap://domain.com:5683/test")

++         << QtCoap::Method::Get

++         << QCoapRequest::Type::NonConfirmable

++         << quint16(56400)

++         << QByteArray::fromHex("4647f09b")

++         << "5401dc504647f09b3a646f6d61696e2e636f6d8474657374ff"

++         << "Some payload";

++

++     QTest::newRow("request_ipv6")

++         << QUrl("coap://[::ffff:ac11:3]:5683/test")

++         << QtCoap::Method::Get

++         << QCoapRequest::Type::NonConfirmable

++         << quint16(56400)

++         << QByteArray::fromHex("4647f09b")

++         << "5401dc504647f09bb474657374ff"

++         << "Some payload";

++

++     QTest::newRow("request_without_payload")

++         << QUrl("coap://10.20.30.40:5683/test")

++         << QtCoap::Method::Get

++         << QCoapRequest::Type::NonConfirmable

++         << quint16(56400)

++         << QByteArray::fromHex("4647f09b")

++         << "5401dc504647f09bb474657374"

++         << "";

++

++     QTest::newRow("request_without_option")

++         << QUrl("coap://10.20.30.40:5683/")

++         << QtCoap::Method::Put

++         << QCoapRequest::Type::Confirmable

++         << quint16(56400)

++         << QByteArray::fromHex("4647f09b")

++         << "4403dc504647f09bff"

++         << "Some payload";

++

++     QTest::newRow("request_only")

++         << QUrl("coap://10.20.30.40:5683/")

++         << QtCoap::Method::Get

++         << QCoapRequest::Type::NonConfirmable

++         << quint16(56400)

++         << QByteArray::fromHex("4647f09b")

++         << "5401dc504647f09b"

++         << "";

++

++     QTest::newRow("request_with_multiple_options")

++         << QUrl("coap://10.20.30.40:5683/test/oui")

++         << QtCoap::Method::Get

++         << QCoapRequest::Type::NonConfirmable

++         << quint16(56400)

++         << QByteArray::fromHex("4647f09b")

++         << "5401dc504647f09bb474657374036f7569"

++         << "";

++

++     QTest::newRow("request_with_big_option_number")

++         << QUrl("coap://10.20.30.40:5683/test")

++         << QtCoap::Method::Get

++         << QCoapRequest::Type::NonConfirmable

++         << quint16(56400)

++         << QByteArray::fromHex("4647f09b")

++         << "5401dc504647f09bb474657374dd240d6162636465666768696a6b6c6d6e6f70"

++            "7172737475767778797aff"

++         << "Some payload";

++ }

++

++ void tst_QCoapInternalRequest::requestToFrame()

++ {

++     QFETCH(QUrl, url);

++     QFETCH(QtCoap::Method, method);

++     QFETCH(QCoapMessage::Type, type);

++     QFETCH(quint16, messageId);

++     QFETCH(QByteArray, token);

++     QFETCH(QString, pduHeader);

++     QFETCH(QString, pduPayload);

++

++     QCoapRequest request = QCoapRequestPrivate::createRequest(QCoapRequest(url), method);

++     request.setType(type);

++     request.setPayload(pduPayload.toUtf8());

++     request.setMessageId(messageId);

++     request.setToken(token);

++     if (qstrcmp(QTest::currentDataTag(), "request_with_big_option_number") == 0)

++         request.addOption(QCoapOption::Size1, QByteArray("abcdefghijklmnopqrstuvwxyz"));

++

++     QByteArray pdu;

++     pdu.append(pduHeader.toUtf8());

++     if (!pduPayload.isEmpty())

++         pdu.append(pduPayload.toUtf8().toHex());

++

++     QCoapInternalRequest internalRequest(request);

++     QCOMPARE(internalRequest.toQByteArray().toHex(), pdu);

++ }

++

++ void tst_QCoapInternalRequest::parseUri_data()

++ {

++     qRegisterMetaType<QList<QCoapOption>>();

++     QTest::addColumn<QUrl>("uri");

++     QTest::addColumn<QUrl>("proxyUri");

++     QTest::addColumn<QList<QCoapOption>>("options");

++

++     QTest::newRow("port_path")

++                         << QUrl("coap://10.20.30.40:1234/test/path1")

++                         << QUrl()

++                         << QList<QCoapOption>({

++                             QCoapOption(QCoapOption::UriPort, 1234),

++                             QCoapOption(QCoapOption::UriPath, QByteArray("test")),

++                             QCoapOption(QCoapOption::UriPath, QByteArray("path1")) });

++

++     QTest::newRow("path_query")

++                         << QUrl("coap://10.20.30.40/test/path1/?rd=25&nd=4")

++                         << QUrl()

++                         << QList<QCoapOption>({

++                             QCoapOption(QCoapOption::UriPath, QByteArray("test")),

++                             QCoapOption(QCoapOption::UriPath, QByteArray("path1")),

++                             QCoapOption(QCoapOption::UriQuery, QByteArray("rd=25")),

++                             QCoapOption(QCoapOption::UriQuery, QByteArray("nd=4")) });

++

++     QTest::newRow("host_path_query")

++                         << QUrl("coap://aa.bb.cc.com:5683/test/path1/?rd=25&nd=4")

++                         << QUrl()

++                         << QList<QCoapOption>({

++                             QCoapOption(QCoapOption::UriHost, QByteArray("aa.bb.cc.com")),

++                             QCoapOption(QCoapOption::UriPath, QByteArray("test")),

++                             QCoapOption(QCoapOption::UriPath, QByteArray("path1")),

++                             QCoapOption(QCoapOption::UriQuery, QByteArray("rd=25")),

++                             QCoapOption(QCoapOption::UriQuery, QByteArray("nd=4")) });

++

++     QTest::newRow("proxy_url")

++                         << QUrl("coap://aa.bb.cc.com:5683/test/path1/?rd=25&nd=4")

++                         << QUrl("coap://10.20.30.40/test:5684/othertest/path")

++                         << QList<QCoapOption>({

++                             QCoapOption(QCoapOption::ProxyUri,

++                             QByteArray("coap://10.20.30.40/test:5684/othertest/path")) });

++ }

++

++ void tst_QCoapInternalRequest::parseUri()

++ {

++     QFETCH(QUrl, uri);

++     QFETCH(QUrl, proxyUri);

++     QFETCH(QList<QCoapOption>, options);

++

++     QCoapRequest request(uri, QCoapMessage::Type::NonConfirmable, proxyUri);

++     QCoapInternalRequest internalRequest(request);

++

++     for (QCoapOption opt : options)

++         QVERIFY2(internalRequest.message()->options().contains(opt), "Missing option");

++

++     QCOMPARE(options.size(), internalRequest.message()->optionCount());

++ }

++

++ void tst_QCoapInternalRequest::urlOptions_data()

++ {

++     QTest::addColumn<QString>("url");

++     QTest::addColumn<QList<QCoapOption>>("options");

++

++     QList<QCoapOption> options = {

++         { QCoapOption::UriHost, QByteArray("example.com") },

++         { QCoapOption::UriPath, QByteArray("~sensors") },

++         { QCoapOption::UriPath, QByteArray("temp.xml") }

++     };

++

++     QTest::newRow("url_with_default_port")

++             << "coap://example.com:5683/~sensors/temp.xml"

++             << options;

++

++     QTest::newRow("url_percent_encoding_uppercase")

++             << "coap://EXAMPLE.com/%7Esensors/temp.xml"

++             << options;

++

++     QTest::newRow("url_with_no_port_uppercase")

++             << "coap://EXAMPLE.com:/%7esensors/temp.xml"

++             << options;

++

++     QTest::newRow("url_with_dot_segments")

++             << "coap://exaMPLE.com/%7esensors/../%7esensors//./temp.xml"

++             << options;

++

++     //! TODO Add more test URLs

++ }

++

++ void tst_QCoapInternalRequest::urlOptions()

++ {

++     QFETCH(QString, url);

++     QFETCH(QList<QCoapOption>, options);

++

++     const QCoapRequest request(QUrl{url});

++     const QCoapInternalRequest internalRequest(request);

++

++     auto requestOptions = internalRequest.message()->options();

++     for (const auto& option : options)

++         QVERIFY2(requestOptions.removeAll(option) > 0, "Missing option");

++

++     QVERIFY2(requestOptions.isEmpty(), "Fewer options were expected");

++ }

++

++ void tst_QCoapInternalRequest::invalidUrls_data()

++ {

++     QTest::addColumn<QString>("url");

++

++     QTest::newRow("url_with_non_ascii")

++             << QString("coap://example.com:5683/~sensors/%1temp.xml").arg(QChar(0x00A3));

++

++     QTest::newRow("url_no_scheme")

++             << "example.com:5683/~sensors/temp.xml";

++

++     QTest::newRow("url_wrong_scheme")

++             << "http://example.com:5683/~sensors/temp.xml";

++

++     //! TODO Add more test URLs

++ }

++

++ void tst_QCoapInternalRequest::invalidUrls()

++ {

++     QFETCH(QString, url);

++     const QCoapRequest request(QUrl{url});

++     const QCoapInternalRequest internalRequest(request);

++

++     QVERIFY(!internalRequest.isValid());

++     QVERIFY(internalRequest.message()->options().empty());

++ }

++

++ void tst_QCoapInternalRequest::isMulticast_data()

++ {

++     QTest::addColumn<QString>("url");

++     QTest::addColumn<bool>("result");

++

++     QTest::newRow("ipv4_multicast") << QString("coap://224.0.1.187") << true;

++     QTest::newRow("ipv4_multicast_resource") << QString("coap://224.0.1.187/path") << true;

++     QTest::newRow("ipv6_multicast_link_local") << "coap://[ff02::fd]" << true;

++     QTest::newRow("ipv6_multicast_site_local") << "coap://[ff05::fd]" << true;

++     QTest::newRow("not_multicast") << QString("coap://127.0.0.1") << false;

++ }

++

++ void tst_QCoapInternalRequest::isMulticast()

++ {

++     QFETCH(QString, url);

++     QFETCH(bool, result);

++

++     const QCoapRequest request(QUrl{url});

++     const QCoapInternalRequest internalRequest(request);

++     QCOMPARE(internalRequest.isMulticast(), result);

++ }

++

++ void tst_QCoapInternalRequest::parseBlockOption_data()

++ {

++     QTest::addColumn<QByteArray>("value");

++     QTest::addColumn<uint>("blockNumber");

++     QTest::addColumn<bool>("hasNext");

++     QTest::addColumn<uint>("blockSize");

++

++     QTest::newRow("block_option_1byte_more_blocks") << QByteArray::fromHex("3B")

++                                                     << 3u

++                                                     << true

++                                                     << 128u;

++     QTest::newRow("block_option_1byte_no_more_blocks") << QByteArray::fromHex("93")

++                                                        << 9u

++                                                        << false

++                                                        << 128u;

++     QTest::newRow("block_option_2bytes_more_blocks") << QByteArray::fromHex("12A")

++                                                      << 18u

++                                                      << true

++                                                      << 64u;

++     QTest::newRow("block_option_2bytes_no_more_blocks") << QByteArray::fromHex("132")

++                                                         << 19u

++                                                         << false

++                                                         << 64u;

++     QTest::newRow("block_option_3bytes_more_blocks") << QByteArray::fromHex("3AB2A")

++                                                      << 15026u

++                                                      << true

++                                                      << 64u;

++     QTest::newRow("block_option_3bytes_no_more_blocks") << QByteArray::fromHex("3AB22")

++                                                         << 15026u

++                                                         << false

++                                                         << 64u;

++ }

++

++ void tst_QCoapInternalRequest::parseBlockOption()

++ {

++     QFETCH(QByteArray, value);

++     QFETCH(uint, blockNumber);

++     QFETCH(bool, hasNext);

++     QFETCH(uint, blockSize);

++

++     QCoapInternalRequest request;

++     request.addOption(QCoapOption::Block1, value);

++

++     QCOMPARE(request.currentBlockNumber(), blockNumber);

++     QCOMPARE(request.hasMoreBlocksToReceive(), hasNext);

++     QCOMPARE(request.blockSize(), blockSize);

++ }

++

++ void tst_QCoapInternalRequest::createBlockOption_data()

++ {

++     QTest::addColumn<QByteArray>("payload");

++     QTest::addColumn<uint>("blockNumber");

++     QTest::addColumn<uint>("blockSize");

++     QTest::addColumn<QCoapOption>("expectedOption");

++

++     QByteArray data;

++     for (uint i = 0; i < 1024; ++i)

++         data.append(0xF);

++

++     QByteArray largeData;

++     for (uint i = 0; i < 32; ++i)

++         largeData.append(data);

++

++     QTest::newRow("block1_option_1byte_more_blocks")

++             << data

++             << 3u

++             << 64u

++             << QCoapOption(QCoapOption::Block1, QByteArray::fromHex("3A"));

++     QTest::newRow("block1_option_1byte_no_more_blocks")

++             << data

++             << 8u

++             << 128u

++             << QCoapOption(QCoapOption::Block1, QByteArray::fromHex("83"));

++     QTest::newRow("block2_option_1byte")

++             << data

++             << 3u

++             << 64u

++             << QCoapOption(QCoapOption::Block2, QByteArray::fromHex("32"));

++     QTest::newRow("block1_option_2bytes_more_blocks")

++             << data

++             << 29u

++             << 32u

++             << QCoapOption(QCoapOption::Block1, QByteArray::fromHex("1D9"));

++     QTest::newRow("block1_option_2bytes_no_more_blocks")

++             << data

++             << 32u

++             << 32u

++             << QCoapOption(QCoapOption::Block1, QByteArray::fromHex("201"));

++     QTest::newRow("block2_option_2bytes")

++             << data

++             << 29u

++             << 32u

++             << QCoapOption(QCoapOption::Block2, QByteArray::fromHex("1D1"));

++     QTest::newRow("block1_option_3bytes_more_blocks")

++             << largeData

++             << 4096u

++             << 4u

++             << QCoapOption(QCoapOption::Block1, QByteArray::fromHex("10008"));

++     QTest::newRow("block1_option_3bytes_no_more_blocks")

++             << largeData

++             << 8192u

++             << 4u

++             << QCoapOption(QCoapOption::Block1, QByteArray::fromHex("20000"));

++     QTest::newRow("block2_option_3bytes")

++             << largeData

++             << 4096u

++             << 4u

++             << QCoapOption(QCoapOption::Block2, QByteArray::fromHex("10000"));

++ }

++

++ void tst_QCoapInternalRequest::createBlockOption()

++ {

++     QFETCH(QByteArray, payload);

++     QFETCH(uint, blockNumber);

++     QFETCH(uint, blockSize);

++     QFETCH(QCoapOption, expectedOption);

++

++     QCoapRequest request;

++     request.setPayload(payload);

++     QCoapInternalRequest internalRequest(request);

++     if (expectedOption.name() == QCoapOption::Block1)

++         internalRequest.setToSendBlock(blockNumber, blockSize);

++     else if (expectedOption.name() == QCoapOption::Block2)

++         internalRequest.setToRequestBlock(blockNumber, blockSize);

++     else

++         QFAIL("Incorrect option, the test expects Block1 or Block2 options.");

++

++     QCOMPARE(internalRequest.message()->options().size(), 1);

++

++     const auto option = internalRequest.message()->options().back();

++     QCOMPARE(option.name(), expectedOption.name());

++     QCOMPARE(option.opaqueValue(), expectedOption.opaqueValue());

++ }

++

++ void tst_QCoapInternalRequest::initEmptyMessage_data()

++ {

++     QTest::addColumn<QCoapMessage::Type>("type");

++     QTest::addColumn<QByteArray>("messageHeader");

++     QTest::newRow("acknowledge") << QCoapMessage::Type::Acknowledgment << QByteArray("6000002a");

++     QTest::newRow("reset") << QCoapMessage::Type::Reset << QByteArray("7000002a");

++

++ }

++

++ void tst_QCoapInternalRequest::initEmptyMessage()

++ {

++     QFETCH(QCoapMessage::Type, type);

++     QFETCH(QByteArray, messageHeader);

++

++     // Populate the request with random data

++     QCoapRequest request = QCoapRequestPrivate::createRequest(QCoapRequest("coap://test"),

++                                                               QtCoap::Method::Get);

++     request.setVersion(1);

++     request.setType(QCoapMessage::Type::Confirmable);

++     request.setMessageId(111);

++     request.setToken("token");

++     request.addOption(QCoapOption::ProxyUri);

++     request.setPayload("payload");

++

++     QCoapInternalRequest emptyMessageRequest(request);

++     emptyMessageRequest.initEmptyMessage(42, type);

++     QCOMPARE(emptyMessageRequest.toQByteArray().toHex(), messageHeader);

++ }

++

++ QTEST_APPLESS_MAIN(tst_QCoapInternalRequest)

++

++ #include "tst_qcoapinternalrequest.moc"

Revision control