Revision control
++ // Copyright (C) 2017 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/qcoapmessage.h>
++
++ class tst_QCoapMessage : public QObject
++ {
++ Q_OBJECT
++
++ private Q_SLOTS:
++ void copyAndDetach();
++ void setType_data();
++ void setType();
++ void addOption();
++ void addOption_string_data();
++ void addOption_string();
++ void addOption_uint_data();
++ void addOption_uint();
++ void removeOption_data();
++ void removeOption();
++ void removeOptionByName_data();
++ void removeOptionByName();
++ void removeAll();
++ };
++
++ void tst_QCoapMessage::copyAndDetach()
++ {
++ QCoapMessage a;
++ a.setMessageId(3);
++ a.setPayload("payload");
++ a.setToken("token");
++ a.setType(QCoapMessage::Type::Acknowledgment);
++ a.setVersion(5);
++
++ // Test the copy
++ QCoapMessage b(a);
++ QVERIFY2(b.messageId() == 3, "Message not copied correctly");
++ QVERIFY2(b.payload() == "payload", "Message not copied correctly");
++ QVERIFY2(b.token() == "token", "Message not copied correctly");
++ QVERIFY2(b.type() == QCoapMessage::Type::Acknowledgment, "Message not copied correctly");
++ QVERIFY2(b.version() == 5, "Message not copied correctly");
++
++ // Detach
++ b.setMessageId(9);
++ QCOMPARE(b.messageId(), 9);
++ QCOMPARE(a.messageId(), 3);
++ }
++
++ void tst_QCoapMessage::setType_data()
++ {
++ QTest::addColumn<QCoapMessage::Type>("type");
++
++ QTest::newRow("acknowledgment") << QCoapMessage::Type::Acknowledgment;
++ QTest::newRow("confirmable") << QCoapMessage::Type::Confirmable;
++ QTest::newRow("non-confirmable") << QCoapMessage::Type::NonConfirmable;
++ QTest::newRow("reset") << QCoapMessage::Type::Reset;
++ }
++
++ void tst_QCoapMessage::setType()
++ {
++ QFETCH(QCoapMessage::Type, type);
++ QCoapMessage message;
++ message.setType(type);
++ QCOMPARE(message.type(), type);
++ }
++
++ void tst_QCoapMessage::addOption()
++ {
++ QCoapMessage message;
++
++ QList<QCoapOption::OptionName> optionNames = {
++ QCoapOption::ProxyUri,
++ QCoapOption::UriHost,
++ QCoapOption::LocationQuery,
++ QCoapOption::ProxyUri,
++ QCoapOption::UriHost,
++ QCoapOption::UriQuery
++ };
++ QVERIFY(!std::is_sorted(optionNames.cbegin(), optionNames.cend()));
++
++ const QByteArray value("\xAF\x01\xC2");
++ for (const auto& name : optionNames)
++ message.addOption(name, value);
++
++ QCOMPARE(message.optionCount(), optionNames.size());
++ QVERIFY(std::is_sorted(message.options().cbegin(), message.options().cend(),
++ [](const QCoapOption &a, const QCoapOption &b) -> bool {
++ return a.name() < b.name();
++ }));
++
++ for (const auto& name : optionNames)
++ QVERIFY2(message.hasOption(name), qPrintable(QString("Missing option %1").arg(name)));
++
++ QVERIFY(std::all_of(message.options().cbegin(), message.options().cend(),
++ [value](const QCoapOption opt) -> bool {
++ return opt.opaqueValue() == value;
++ }));
++ }
++
++ void tst_QCoapMessage::addOption_string_data()
++ {
++ QTest::addColumn<QList<QCoapOption>>("options");
++
++ QList<QCoapOption> single_string_option = { { QCoapOption::LocationPath, QString("path1") } };
++ QList<QCoapOption> single_ba_option = {
++ { QCoapOption::LocationPath, QByteArray("\xAF\x01\xC2") }
++ };
++ QList<QCoapOption> multiple_string_options = {
++ { QCoapOption::LocationPath, QString("str_path2") },
++ { QCoapOption::LocationPath, QString("str_path3") }
++ };
++
++ QTest::newRow("single_char_option") << single_string_option;
++ QTest::newRow("single_ba_option") << single_ba_option;
++ QTest::newRow("multiple_string_options") << multiple_string_options;
++ }
++
++ void tst_QCoapMessage::addOption_string()
++ {
++ QFETCH(QList<QCoapOption>, options);
++
++ QCoapMessage message;
++ for (const auto& option : options)
++ message.addOption(option);
++
++ QCOMPARE(message.optionCount(), options.size());
++ for (const auto& option : options)
++ {
++ const auto it = std::find(message.options().cbegin(), message.options().cend(), option);
++ QVERIFY(it != message.options().cend());
++ }
++ }
++
++ void tst_QCoapMessage::addOption_uint_data()
++ {
++ QTest::addColumn<quint32>("value");
++ QTest::addColumn<int>("size");
++
++ QTest::newRow("4 bytes") << static_cast<quint32>(0xF0aF0010) << 4;
++ QTest::newRow("3 bytes") << static_cast<quint32>(0x300010) << 3;
++ QTest::newRow("2 bytes") << static_cast<quint32>(0x5010) << 2;
++ QTest::newRow("1 byte") << static_cast<quint32>(0x80) << 1;
++ }
++
++ void tst_QCoapMessage::addOption_uint()
++ {
++ QFETCH(quint32, value);
++ QFETCH(int, size);
++
++ const auto name = QCoapOption::Block1;
++ const QCoapOption option(name, value);
++
++ QCoapMessage message;
++ message.addOption(option);
++
++ QCOMPARE(message.options(name).size(), 1);
++ QCOMPARE(message.option(name).uintValue(), value);
++ QCOMPARE(option.opaqueValue().size(), size);
++ }
++
++ void tst_QCoapMessage::removeOption_data()
++ {
++ QTest::addColumn<QList<QCoapOption>>("options");
++
++ QList<QCoapOption> single_option = { { QCoapOption::LocationPath, QByteArray("path1") } };
++ QList<QCoapOption> multiple_options = {
++ { QCoapOption::LocationPath, QByteArray("path2") },
++ { QCoapOption::LocationPath, QByteArray("path3") }
++ };
++
++ QTest::newRow("single_option") << single_option;
++ QTest::newRow("multiple_options") << multiple_options;
++ }
++
++ void tst_QCoapMessage::removeOption()
++ {
++ QFETCH(QList<QCoapOption>, options);
++
++ QCoapMessage message;
++ for (const auto& option : options)
++ message.addOption(option);
++
++ for (const auto& option : options)
++ {
++ // Make sure option is present before removal
++ auto it = std::find(message.options().cbegin(), message.options().cend(), option);
++ QVERIFY(it != message.options().end());
++
++ message.removeOption(option);
++ it = std::find(message.options().cbegin(), message.options().cend(), option);
++ QVERIFY(it == message.options().end());
++ }
++ }
++
++ void tst_QCoapMessage::removeOptionByName_data()
++ {
++ QTest::addColumn<QList<QCoapOption>>("options");
++ QTest::addColumn<QCoapOption::OptionName>("name");
++
++ QList<QCoapOption> single_option = { { QCoapOption::LocationPath, QByteArray("path1") } };
++ QList<QCoapOption> multiple_options = {
++ { QCoapOption::LocationPath, QByteArray("path2") },
++ { QCoapOption::LocationPath, QByteArray("path3") }
++ };
++
++ QTest::newRow("remove_single_option") << single_option << single_option.back().name();
++ QTest::newRow("remove_multiple_options") << multiple_options << multiple_options.back().name();
++ }
++
++ void tst_QCoapMessage::removeOptionByName()
++ {
++ QFETCH(QList<QCoapOption>, options);
++ QFETCH(QCoapOption::OptionName, name);
++
++ QCoapMessage message;
++ for (const auto& option : options)
++ message.addOption(option);
++
++ message.removeOption(name);
++ QVERIFY(!message.hasOption(name));
++ }
++
++ void tst_QCoapMessage::removeAll()
++ {
++ QCoapMessage message;
++ message.addOption(QCoapOption::LocationPath, "path");
++ message.addOption(QCoapOption::ProxyUri, "proxy1");
++ message.addOption(QCoapOption::ProxyUri, "proxy2");
++ message.clearOptions();
++
++ QVERIFY(message.options().isEmpty());
++ }
++
++ QTEST_APPLESS_MAIN(tst_QCoapMessage)
++
++ #include "tst_qcoapmessage.moc"