1 files changed, 496 insertions, 0 deletions
diff --git a/src/3rdparty/tinycbor/tests/encoder/tst_encoder.cpp b/src/3rdparty/tinycbor/tests/encoder/tst_encoder.cpp
new file mode 100644
index 0000000000..f30c522601
--- /dev/null
+++ b/src/3rdparty/tinycbor/tests/encoder/tst_encoder.cpp
@@ -0,0 +1,496 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 Intel Corporation
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and associated documentation files (the "Software"), to deal
+** in the Software without restriction, including without limitation the rights
+** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+** copies of the Software, and to permit persons to whom the Software is
+** furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Software.
+**
+** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+** THE SOFTWARE.
+**
+****************************************************************************/
+
+#include <QtTest>
+#include "cbor.h"
+
+#if QT_VERSION >= QT_VERSION_CHECK(5, 9, 0)
+#include <qfloat16.h>
+#endif
+
+Q_DECLARE_METATYPE(CborError)
+namespace QTest {
+template<> char *toString<CborError>(const CborError &err)
+{
+    return qstrdup(cbor_error_string(err));
+}
+}
+
+class tst_Encoder : public QObject
+{
+    Q_OBJECT
+private slots:
+    void fixed_data();
+    void fixed();
+    void strings_data();
+    void strings() { fixed(); }
+    void arraysAndMaps_data();
+    void arraysAndMaps() { fixed(); }
+    void tags_data();
+    void tags();
+    void arrays_data() { tags_data(); }
+    void arrays();
+    void maps_data() { tags_data(); }
+    void maps();
+
+    void writerApi_data() { tags_data(); }
+    void writerApi();
+    void writerApiFail_data() { tags_data(); }
+    void writerApiFail();
+    void shortBuffer_data() { tags_data(); }
+    void shortBuffer();
+    void tooShortArrays_data() { tags_data(); }
+    void tooShortArrays();
+    void tooShortMaps_data() { tags_data(); }
+    void tooShortMaps();
+    void tooBigArrays_data() { tags_data(); }
+    void tooBigArrays();
+    void tooBigMaps_data() { tags_data(); }
+    void tooBigMaps();
+    void illegalSimpleType_data();
+    void illegalSimpleType();
+};
+
+#include "tst_encoder.moc"
+#include "data.cpp"
+
+static inline bool isOomError(CborError err)
+{
+    return err == CborErrorOutOfMemory;
+}
+
+CborError encodeVariant(CborEncoder *encoder, const QVariant &v)
+{
+    int type = v.userType();
+    switch (type) {
+    case QVariant::Int:
+    case QVariant::LongLong:
+        return cbor_encode_int(encoder, v.toLongLong());
+
+    case QVariant::UInt:
+    case QVariant::ULongLong:
+        return cbor_encode_uint(encoder, v.toULongLong());
+
+    case QVariant::Bool:
+        return cbor_encode_boolean(encoder, v.toBool());
+
+    case QVariant::Invalid:
+        return cbor_encode_undefined(encoder);
+
+    case QMetaType::VoidStar:
+        return cbor_encode_null(encoder);
+
+    case QVariant::Double:
+        return cbor_encode_double(encoder, v.toDouble());
+
+    case QMetaType::Float:
+        return cbor_encode_float(encoder, v.toFloat());
+
+    case QVariant::String: {
+        QByteArray string = v.toString().toUtf8();
+        return cbor_encode_text_string(encoder, string.constData(), string.length());
+    }
+
+    case QVariant::ByteArray: {
+        QByteArray string = v.toByteArray();
+        return cbor_encode_byte_string(encoder, reinterpret_cast<const quint8 *>(string.constData()), string.length());
+    }
+
+    default:
+        if (type == qMetaTypeId<NegativeInteger>())
+            return cbor_encode_negative_int(encoder, v.value<NegativeInteger>().abs);
+        if (type == qMetaTypeId<SimpleType>())
+            return cbor_encode_simple_value(encoder, v.value<SimpleType>().type);
+#if QT_VERSION < QT_VERSION_CHECK(5, 9, 0)
+        if (type == qMetaTypeId<Float16Standin>())
+            return cbor_encode_half_float(encoder, v.constData());
+#else
+        if (type == qMetaTypeId<qfloat16>())
+            return cbor_encode_half_float(encoder, v.constData());
+#endif
+        if (type == qMetaTypeId<Tag>()) {
+            CborError err = cbor_encode_tag(encoder, v.value<Tag>().tag);
+            if (err && !isOomError(err))
+                return err;
+            return static_cast<CborError>(err | encodeVariant(encoder, v.value<Tag>().tagged));
+        }
+        if (type == QVariant::List || type == qMetaTypeId<IndeterminateLengthArray>()) {
+            CborEncoder sub;
+            QVariantList list = v.toList();
+            size_t len = list.length();
+            if (type == qMetaTypeId<IndeterminateLengthArray>()) {
+                len = CborIndefiniteLength;
+                list = v.value<IndeterminateLengthArray>();
+            }
+            CborError err = cbor_encoder_create_array(encoder, &sub, len);
+            if (err && !isOomError(err))
+                return err;
+            foreach (const QVariant &v2, list) {
+                err = static_cast<CborError>(err | encodeVariant(&sub, v2));
+                if (err && !isOomError(err))
+                    return err;
+            }
+            return cbor_encoder_close_container_checked(encoder, &sub);
+        }
+        if (type == qMetaTypeId<Map>() || type == qMetaTypeId<IndeterminateLengthMap>()) {
+            CborEncoder sub;
+            Map map = v.value<Map>();
+            size_t len = map.length();
+            if (type == qMetaTypeId<IndeterminateLengthMap>()) {
+                len = CborIndefiniteLength;
+                map = v.value<IndeterminateLengthMap>();
+            }
+            CborError err = cbor_encoder_create_map(encoder, &sub, len);
+            if (err && !isOomError(err))
+                return err;
+            for (auto pair : map) {
+                err = static_cast<CborError>(err | encodeVariant(&sub, pair.first));
+                if (err && !isOomError(err))
+                    return err;
+                err = static_cast<CborError>(err | encodeVariant(&sub, pair.second));
+                if (err && !isOomError(err))
+                    return err;
+            }
+            return cbor_encoder_close_container_checked(encoder, &sub);
+        }
+    }
+    return CborErrorUnknownType;
+}
+
+void compare(const QVariant &input, const QByteArray &output)
+{
+    QByteArray buffer(output.length(), Qt::Uninitialized);
+    uint8_t *bufptr = reinterpret_cast<quint8 *>(buffer.data());
+    CborEncoder encoder;
+    cbor_encoder_init(&encoder, bufptr, buffer.length(), 0);
+
+    QCOMPARE(encodeVariant(&encoder, input), CborNoError);
+    QCOMPARE(encoder.remaining, size_t(1));
+    QCOMPARE(cbor_encoder_get_extra_bytes_needed(&encoder), size_t(0));
+
+    buffer.resize(int(cbor_encoder_get_buffer_size(&encoder, bufptr)));
+    QCOMPARE(buffer, output);
+}
+
+void tst_Encoder::fixed_data()
+{
+    addColumns();
+    addFixedData();
+}
+
+void tst_Encoder::fixed()
+{
+    QFETCH(QVariant, input);
+    QFETCH(QByteArray, output);
+    compare(input, output);
+}
+
+void tst_Encoder::strings_data()
+{
+    addColumns();
+    addStringsData();
+}
+
+void tst_Encoder::arraysAndMaps_data()
+{
+    addColumns();
+    addArraysAndMaps();
+}
+
+void tst_Encoder::tags_data()
+{
+    addColumns();
+    addFixedData();
+    addStringsData();
+    addArraysAndMaps();
+}
+
+void tst_Encoder::tags()
+{
+    QFETCH(QVariant, input);
+    QFETCH(QByteArray, output);
+
+    compare(QVariant::fromValue(Tag{1, input}), "\xc1" + output);
+    if (QTest::currentTestFailed()) return;
+
+    compare(QVariant::fromValue(Tag{24, input}), "\xd8\x18" + output);
+    if (QTest::currentTestFailed()) return;
+
+    compare(QVariant::fromValue(Tag{255, input}), "\xd8\xff" + output);
+    if (QTest::currentTestFailed()) return;
+
+    compare(QVariant::fromValue(Tag{256, input}), raw("\xd9\1\0") + output);
+    if (QTest::currentTestFailed()) return;
+
+    compare(QVariant::fromValue(Tag{CborSignatureTag, input}), raw("\xd9\xd9\xf7") + output);
+    if (QTest::currentTestFailed()) return;
+
+    compare(QVariant::fromValue(Tag{65535, input}), raw("\xd9\xff\xff") + output);
+    if (QTest::currentTestFailed()) return;
+
+    compare(QVariant::fromValue(Tag{65536, input}), raw("\xda\0\1\0\0") + output);
+    if (QTest::currentTestFailed()) return;
+
+    compare(QVariant::fromValue(Tag{UINT32_MAX, input}), raw("\xda\xff\xff\xff\xff") + output);
+    if (QTest::currentTestFailed()) return;
+
+    compare(QVariant::fromValue(Tag{UINT32_MAX + Q_UINT64_C(1), input}), raw("\xdb\0\0\0\1\0\0\0\0") + output);
+    if (QTest::currentTestFailed()) return;
+
+    compare(QVariant::fromValue(Tag{UINT64_MAX, input}), raw("\xdb\xff\xff\xff\xff\xff\xff\xff\xff") + output);
+    if (QTest::currentTestFailed()) return;
+
+    // nested tags
+    compare(QVariant::fromValue(Tag{1, QVariant::fromValue(Tag{1, input})}), "\xc1\xc1" + output);
+}
+
+void tst_Encoder::arrays()
+{
+    QFETCH(QVariant, input);
+    QFETCH(QByteArray, output);
+
+    compare(make_list(input), "\x81" + output);
+    if (QTest::currentTestFailed()) return;
+
+    compare(make_list(input, input), "\x82" + output + output);
+    if (QTest::currentTestFailed()) return;
+
+    {
+        QVariantList list{input};
+        QByteArray longoutput = output;
+
+        // make a list with 32 elements (1 << 5)
+        for (int i = 0; i < 5; ++i) {
+            list += list;
+            longoutput += longoutput;
+        }
+        compare(list, "\x98\x20" + longoutput);
+        if (QTest::currentTestFailed()) return;
+
+        // now 256 elements (32 << 3)
+        for (int i = 0; i < 3; ++i) {
+            list += list;
+            longoutput += longoutput;
+        }
+        compare(list, raw("\x99\1\0") + longoutput);
+        if (QTest::currentTestFailed()) return;
+    }
+
+    // nested lists
+    compare(make_list(make_list(input)), "\x81\x81" + output);
+    if (QTest::currentTestFailed()) return;
+
+    compare(make_list(make_list(input, input)), "\x81\x82" + output + output);
+    if (QTest::currentTestFailed()) return;
+
+    compare(make_list(make_list(input), input), "\x82\x81" + output + output);
+    if (QTest::currentTestFailed()) return;
+
+    compare(make_list(make_list(input), make_list(input)), "\x82\x81" + output + "\x81" + output);
+}
+
+void tst_Encoder::maps()
+{
+    QFETCH(QVariant, input);
+    QFETCH(QByteArray, output);
+
+    compare(make_map({{1, input}}), "\xa1\1" + output);
+    if (QTest::currentTestFailed()) return;
+
+    compare(make_map({{1, input}, {input, 24}}), "\xa2\1" + output + output + "\x18\x18");
+    if (QTest::currentTestFailed()) return;
+
+    compare(make_map({{input, input}}), "\xa1" + output + output);
+    if (QTest::currentTestFailed()) return;
+
+    {
+        Map map{{1, input}};
+        QByteArray longoutput = "\1" + output;
+
+        // make a map with 32 elements (1 << 5)
+        for (int i = 0; i < 5; ++i) {
+            map += map;
+            longoutput += longoutput;
+        }
+        compare(QVariant::fromValue(map), "\xb8\x20" + longoutput);
+        if (QTest::currentTestFailed()) return;
+
+        // now 256 elements (32 << 3)
+        for (int i = 0; i < 3; ++i) {
+            map += map;
+            longoutput += longoutput;
+        }
+        compare(QVariant::fromValue(map), raw("\xb9\1\0") + longoutput);
+        if (QTest::currentTestFailed()) return;
+    }
+
+    // nested maps
+    compare(make_map({{1, make_map({{2, input}})}}), "\xa1\1\xa1\2" + output);
+    if (QTest::currentTestFailed()) return;
+
+    compare(make_map({{1, make_map({{2, input}, {input, false}})}}), "\xa1\1\xa2\2" + output + output + "\xf4");
+    if (QTest::currentTestFailed()) return;
+
+    compare(make_map({{1, make_map({{2, input}})}, {input, false}}), "\xa2\1\xa1\2" + output + output + "\xf4");
+    if (QTest::currentTestFailed()) return;
+}
+
+void tst_Encoder::writerApi()
+{
+    QFETCH(QVariant, input);
+    QFETCH(QByteArray, output);
+
+    // instead of writing to a QByteArray like all other tests, write to a QBuffer
+    QBuffer buffer;
+    buffer.open(QIODevice::ReadWrite);
+    auto callback = [](void *token, const void *data, size_t len, CborEncoderAppendType) {
+        auto buffer = static_cast<QBuffer *>(token);
+        buffer->write(static_cast<const char *>(data), len);
+        return CborNoError;
+    };
+
+    CborEncoder encoder;
+    cbor_encoder_init_writer(&encoder, callback, &buffer);
+    QCOMPARE(encodeVariant(&encoder, input), CborNoError);
+
+    buffer.reset();
+    QCOMPARE(buffer.readAll(), output);
+}
+
+void tst_Encoder::writerApiFail()
+{
+    QFETCH(QVariant, input);
+    QFETCH(QByteArray, output);
+
+    // same as above, but we'll produce an error during writing and we expect
+    // it to be returned
+    int callCount = 0;
+    auto callback = [](void *token, const void *, size_t, CborEncoderAppendType) {
+        ++*static_cast<int *>(token);
+        return CborErrorIO;
+    };
+
+    CborEncoder encoder;
+    cbor_encoder_init_writer(&encoder, callback, &callCount);
+    QCOMPARE(encodeVariant(&encoder, input), CborErrorIO);
+    QCOMPARE(callCount, 1);
+}
+
+void tst_Encoder::shortBuffer()
+{
+    QFETCH(QVariant, input);
+    QFETCH(QByteArray, output);
+    QByteArray buffer(output.length(), Qt::Uninitialized);
+
+    for (int len = 0; len < output.length(); ++len) {
+        CborEncoder encoder;
+        cbor_encoder_init(&encoder, reinterpret_cast<quint8 *>(buffer.data()), len, 0);
+        QCOMPARE(encodeVariant(&encoder, input), CborErrorOutOfMemory);
+        QVERIFY(cbor_encoder_get_extra_bytes_needed(&encoder) != 0);
+        QCOMPARE(len + cbor_encoder_get_extra_bytes_needed(&encoder), size_t(output.length()));
+    }
+}
+
+void tst_Encoder::tooShortArrays()
+{
+    QFETCH(QVariant, input);
+    QFETCH(QByteArray, output);
+    QByteArray buffer(output.length() + 1, Qt::Uninitialized);
+
+    CborEncoder encoder, container;
+    cbor_encoder_init(&encoder, reinterpret_cast<quint8 *>(buffer.data()), buffer.length(), 0);
+    QCOMPARE(cbor_encoder_create_array(&encoder, &container, 2), CborNoError);
+    QCOMPARE(encodeVariant(&container, input), CborNoError);
+    QCOMPARE(container.remaining, size_t(2));
+    QCOMPARE(cbor_encoder_close_container_checked(&encoder, &container), CborErrorTooFewItems);
+}
+
+void tst_Encoder::tooShortMaps()
+{
+    QFETCH(QVariant, input);
+    QFETCH(QByteArray, output);
+    QByteArray buffer(output.length() + 1, Qt::Uninitialized);
+
+    CborEncoder encoder, container;
+    cbor_encoder_init(&encoder, reinterpret_cast<quint8 *>(buffer.data()), buffer.length(), 0);
+    QCOMPARE(cbor_encoder_create_map(&encoder, &container, 2), CborNoError);
+    QCOMPARE(encodeVariant(&container, input), CborNoError);
+    QCOMPARE(container.remaining, size_t(4));
+    QCOMPARE(cbor_encoder_close_container_checked(&encoder, &container), CborErrorTooFewItems);
+}
+
+void tst_Encoder::tooBigArrays()
+{
+    QFETCH(QVariant, input);
+    QFETCH(QByteArray, output);
+    QByteArray buffer(output.length() * 2 + 1, Qt::Uninitialized);
+
+    CborEncoder encoder, container;
+    cbor_encoder_init(&encoder, reinterpret_cast<quint8 *>(buffer.data()), buffer.length(), 0);
+    QCOMPARE(cbor_encoder_create_array(&encoder, &container, 1), CborNoError);
+    QCOMPARE(encodeVariant(&container, input), CborNoError);
+    QCOMPARE(encodeVariant(&container, input), CborNoError);
+    QCOMPARE(container.remaining, size_t(0));
+    QCOMPARE(cbor_encoder_close_container_checked(&encoder, &container), CborErrorTooManyItems);
+}
+
+void tst_Encoder::tooBigMaps()
+{
+    QFETCH(QVariant, input);
+    QFETCH(QByteArray, output);
+    QByteArray buffer(output.length() * 3 + 1, Qt::Uninitialized);
+
+    CborEncoder encoder, container;
+    cbor_encoder_init(&encoder, reinterpret_cast<quint8 *>(buffer.data()), buffer.length(), 0);
+    QCOMPARE(cbor_encoder_create_map(&encoder, &container, 1), CborNoError);
+    QCOMPARE(encodeVariant(&container, input), CborNoError);
+    QCOMPARE(encodeVariant(&container, input), CborNoError);
+    QCOMPARE(encodeVariant(&container, input), CborNoError);
+    QCOMPARE(container.remaining, size_t(0));
+    QCOMPARE(cbor_encoder_close_container_checked(&encoder, &container), CborErrorTooManyItems);
+}
+
+void tst_Encoder::illegalSimpleType_data()
+{
+    QTest::addColumn<int>("type");
+    QTest::newRow("half-float") << 25;
+    QTest::newRow("float") << 26;
+    QTest::newRow("double") << 27;
+    QTest::newRow("28") << 28;
+    QTest::newRow("29") << 29;
+    QTest::newRow("30") << 30;
+    QTest::newRow("31") << 31;
+}
+
+void tst_Encoder::illegalSimpleType()
+{
+    QFETCH(int, type);
+
+    quint8 buf[2];
+    CborEncoder encoder;
+    cbor_encoder_init(&encoder, buf, sizeof(buf), 0);
+    QCOMPARE(cbor_encode_simple_value(&encoder, type), CborErrorIllegalSimpleType);
+}
+
+QTEST_MAIN(tst_Encoder)