[修改] 增加freeRTOS
1. 版本FreeRTOSv202212.01，命名为kernel；
This commit is contained in:
15
kernel/FreeRTOS-Plus/ThirdParty/tinycbor/tests/.gitignore
vendored
Normal file
15
kernel/FreeRTOS-Plus/ThirdParty/tinycbor/tests/.gitignore
vendored
Normal file
@ -0,0 +1,15 @@
|
||||
Makefile
|
||||
debug
|
||||
moc_predefs.h
|
||||
release
|
||||
target_wrapper.*
|
||||
|
||||
# The executables
|
||||
cpp/cpp
|
||||
cpp/cpp.exe
|
||||
encoder/encoder
|
||||
encoder/encoder.exe
|
||||
parser/parser
|
||||
parser/parser.exe
|
||||
tojson/tojson
|
||||
tojson/tojson.exe
|
||||
7
kernel/FreeRTOS-Plus/ThirdParty/tinycbor/tests/c90/c90.pro
vendored
Normal file
7
kernel/FreeRTOS-Plus/ThirdParty/tinycbor/tests/c90/c90.pro
vendored
Normal file
@ -0,0 +1,7 @@
|
||||
CONFIG += testcase parallel_test console
|
||||
CONFIG -= qt app_bundle
|
||||
gcc: QMAKE_CFLAGS += -std=c90 -pedantic-errors -Wall -Wextra -Werror
|
||||
darwin: QMAKE_CFLAGS += -Wno-long-long
|
||||
|
||||
SOURCES += tst_c90.c
|
||||
INCLUDEPATH += ../../src
|
||||
30
kernel/FreeRTOS-Plus/ThirdParty/tinycbor/tests/c90/tst_c90.c
vendored
Normal file
30
kernel/FreeRTOS-Plus/ThirdParty/tinycbor/tests/c90/tst_c90.c
vendored
Normal file
@ -0,0 +1,30 @@
|
||||
/****************************************************************************
|
||||
**
|
||||
** Copyright (C) 2018 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 "cbor.h"
|
||||
|
||||
int main()
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
5
kernel/FreeRTOS-Plus/ThirdParty/tinycbor/tests/cpp/cpp.pro
vendored
Normal file
5
kernel/FreeRTOS-Plus/ThirdParty/tinycbor/tests/cpp/cpp.pro
vendored
Normal file
@ -0,0 +1,5 @@
|
||||
CONFIG += testcase parallel_test c++11
|
||||
QT = core testlib
|
||||
|
||||
SOURCES = tst_cpp.cpp
|
||||
INCLUDEPATH += ../../src
|
||||
44
kernel/FreeRTOS-Plus/ThirdParty/tinycbor/tests/cpp/tst_cpp.cpp
vendored
Normal file
44
kernel/FreeRTOS-Plus/ThirdParty/tinycbor/tests/cpp/tst_cpp.cpp
vendored
Normal file
@ -0,0 +1,44 @@
|
||||
/****************************************************************************
|
||||
**
|
||||
** Copyright (C) 2017 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 "../../src/cborencoder.c"
|
||||
#include "../../src/cborencoder_float.c"
|
||||
#include "../../src/cborerrorstrings.c"
|
||||
#include "../../src/cborparser.c"
|
||||
#include "../../src/cborparser_dup_string.c"
|
||||
#include "../../src/cborparser_float.c"
|
||||
#include "../../src/cborvalidation.c"
|
||||
|
||||
#include <QtTest>
|
||||
|
||||
// This is a compilation-only test.
|
||||
// All it does is verify that the four source files above
|
||||
// compile as C++ without errors.
|
||||
class tst_Cpp : public QObject
|
||||
{
|
||||
Q_OBJECT
|
||||
};
|
||||
|
||||
QTEST_MAIN(tst_Cpp)
|
||||
#include "tst_cpp.moc"
|
||||
346
kernel/FreeRTOS-Plus/ThirdParty/tinycbor/tests/encoder/data.cpp
vendored
Normal file
346
kernel/FreeRTOS-Plus/ThirdParty/tinycbor/tests/encoder/data.cpp
vendored
Normal file
@ -0,0 +1,346 @@
|
||||
/****************************************************************************
|
||||
**
|
||||
** Copyright (C) 2021 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>
|
||||
|
||||
static float myNaNf()
|
||||
{
|
||||
uint32_t v = 0x7fc00000;
|
||||
float f;
|
||||
memcpy(&f, &v, sizeof(f));
|
||||
Q_ASSERT(qIsNaN(f));
|
||||
return f;
|
||||
}
|
||||
|
||||
static float myInff()
|
||||
{
|
||||
uint32_t v = 0x7f800000;
|
||||
float f;
|
||||
memcpy(&f, &v, sizeof(f));
|
||||
Q_ASSERT(qIsInf(f));
|
||||
return f;
|
||||
}
|
||||
|
||||
static float myNInff()
|
||||
{
|
||||
uint32_t v = 0xff800000;
|
||||
float f;
|
||||
memcpy(&f, &v, sizeof(f));
|
||||
Q_ASSERT(qIsInf(f));
|
||||
return f;
|
||||
}
|
||||
|
||||
static double myNaN()
|
||||
{
|
||||
uint64_t v = UINT64_C(0x7ff8000000000000);
|
||||
double f;
|
||||
memcpy(&f, &v, sizeof(f));
|
||||
Q_ASSERT(qIsNaN(f));
|
||||
return f;
|
||||
}
|
||||
|
||||
static double myInf()
|
||||
{
|
||||
uint64_t v = UINT64_C(0x7ff0000000000000);
|
||||
double f;
|
||||
memcpy(&f, &v, sizeof(f));
|
||||
Q_ASSERT(qIsInf(f));
|
||||
return f;
|
||||
}
|
||||
|
||||
static double myNInf()
|
||||
{
|
||||
uint64_t v = UINT64_C(0xfff0000000000000);
|
||||
double f;
|
||||
memcpy(&f, &v, sizeof(f));
|
||||
Q_ASSERT(qIsInf(f));
|
||||
return f;
|
||||
}
|
||||
|
||||
template <size_t N> QByteArray raw(const char (&data)[N])
|
||||
{
|
||||
return QByteArray::fromRawData(data, N - 1);
|
||||
}
|
||||
|
||||
struct NegativeInteger { quint64 abs; };
|
||||
Q_DECLARE_METATYPE(NegativeInteger)
|
||||
|
||||
struct SimpleType { uint8_t type; };
|
||||
Q_DECLARE_METATYPE(SimpleType)
|
||||
|
||||
struct Float16Standin { uint16_t val; };
|
||||
Q_DECLARE_METATYPE(Float16Standin)
|
||||
|
||||
struct Tag { CborTag tag; QVariant tagged; };
|
||||
Q_DECLARE_METATYPE(Tag)
|
||||
|
||||
template <typename... Args>
|
||||
QVariant make_list(const Args &... args)
|
||||
{
|
||||
return QVariantList{args...};
|
||||
}
|
||||
|
||||
typedef QVector<QPair<QVariant, QVariant>> Map;
|
||||
Q_DECLARE_METATYPE(Map)
|
||||
QVariant make_map(const std::initializer_list<QPair<QVariant, QVariant>> &list)
|
||||
{
|
||||
return QVariant::fromValue(Map(list));
|
||||
}
|
||||
|
||||
struct IndeterminateLengthArray : QVariantList { using QVariantList::QVariantList; };
|
||||
struct IndeterminateLengthMap : Map { using Map::Map; };
|
||||
Q_DECLARE_METATYPE(IndeterminateLengthArray)
|
||||
Q_DECLARE_METATYPE(IndeterminateLengthMap)
|
||||
|
||||
QVariant make_ilarray(const std::initializer_list<QVariant> &list)
|
||||
{
|
||||
return QVariant::fromValue(IndeterminateLengthArray(list));
|
||||
}
|
||||
|
||||
QVariant make_ilmap(const std::initializer_list<QPair<QVariant, QVariant>> &list)
|
||||
{
|
||||
return QVariant::fromValue(IndeterminateLengthMap(list));
|
||||
}
|
||||
|
||||
void addHalfFloat()
|
||||
{
|
||||
QTest::addColumn<QByteArray>("output");
|
||||
QTest::addColumn<unsigned>("rawInput");
|
||||
QTest::addColumn<double>("floatInput");
|
||||
|
||||
QTest::newRow("+0") << raw("\x00\x00") << 0U << 0.0;
|
||||
QTest::newRow("-0") << raw("\x80\x00") << 0x8000U << 0.0;
|
||||
|
||||
QTest::newRow("min.denorm") << raw("\x00\x01") << 1U << ldexp(1.0, -14) * ldexp(1.0, -10);
|
||||
QTest::newRow("-min.denorm") << raw("\x80\x01") << 0x8001U << ldexp(-1.0, -14) * ldexp(1.0, -10);
|
||||
|
||||
QTest::newRow("max.denorm") << raw("\x03\xff") << 0x03ffU << ldexp(1.0, -14) * (1.0 - ldexp(1.0, -10));
|
||||
QTest::newRow("-max.denorm") << raw("\x83\xff") << 0x83ffU << ldexp(-1.0, -14) * (1.0 - ldexp(1.0, -10));
|
||||
|
||||
QTest::newRow("min.norm") << raw("\x04\x00") << 0x0400U << ldexp(1.0, -14);
|
||||
QTest::newRow("-min.norm") << raw("\x84\x00") << 0x8400U << ldexp(-1.0, -14);
|
||||
|
||||
QTest::newRow("1.0") << raw("\x3c\x00") << 0x3c00U << 1.0;
|
||||
QTest::newRow("-1.0") << raw("\xbc\x00") << 0xbc00U << -1.0;
|
||||
|
||||
QTest::newRow("1.5") << raw("\x3e\x00") << 0x3e00U << 1.5;
|
||||
QTest::newRow("-1.5") << raw("\xbe\x00") << 0xbe00U << -1.5;
|
||||
|
||||
QTest::newRow("max") << raw("\x7b\xff") << 0x7bffU << ldexp(1.0, 15) * (2.0 - ldexp(1.0, -10));
|
||||
QTest::newRow("-max") << raw("\xfb\xff") << 0xfbffU << ldexp(-1.0, 15) * (2.0 - ldexp(1.0, -10));
|
||||
|
||||
QTest::newRow("inf") << raw("\x7c\x00") << 0x7c00U << myInf();
|
||||
QTest::newRow("-inf") << raw("\xfc\x00") << 0xfc00U << myNInf();
|
||||
|
||||
QTest::newRow("nan1") << raw("\x7c\x01") << 0x7c01U << myNaN();
|
||||
QTest::newRow("nan2") << raw("\xfc\x01") << 0xfc01U << myNaN();
|
||||
QTest::newRow("nan3") << raw("\x7e\x00") << 0x7e00U << myNaN();
|
||||
QTest::newRow("nan4") << raw("\xfe\x00") << 0xfe00U << myNaN();
|
||||
}
|
||||
|
||||
void addColumns()
|
||||
{
|
||||
QTest::addColumn<QByteArray>("output");
|
||||
QTest::addColumn<QVariant>("input");
|
||||
}
|
||||
|
||||
void addFixedData()
|
||||
{
|
||||
// unsigned integers
|
||||
QTest::newRow("0U") << raw("\x00") << QVariant(0U);
|
||||
QTest::newRow("1U") << raw("\x01") << QVariant(1U);
|
||||
QTest::newRow("10U") << raw("\x0a") << QVariant(10U);
|
||||
QTest::newRow("23U") << raw("\x17") << QVariant(23U);
|
||||
QTest::newRow("24U") << raw("\x18\x18") << QVariant(24U);
|
||||
QTest::newRow("255U") << raw("\x18\xff") << QVariant(255U);
|
||||
QTest::newRow("256U") << raw("\x19\x01\x00") << QVariant(256U);
|
||||
QTest::newRow("65535U") << raw("\x19\xff\xff") << QVariant(65535U);
|
||||
QTest::newRow("65536U") << raw("\x1a\0\1\x00\x00") << QVariant(65536U);
|
||||
QTest::newRow("4294967295U") << raw("\x1a\xff\xff\xff\xff") << QVariant(4294967295U);
|
||||
QTest::newRow("4294967296U") << raw("\x1b\0\0\0\1\0\0\0\0") << QVariant(Q_UINT64_C(4294967296));
|
||||
QTest::newRow("UINT64_MAX") << raw("\x1b" "\xff\xff\xff\xff" "\xff\xff\xff\xff")
|
||||
<< QVariant(std::numeric_limits<quint64>::max());
|
||||
|
||||
// signed integers containing non-negative numbers
|
||||
QTest::newRow("0") << raw("\x00") << QVariant(0);
|
||||
QTest::newRow("1") << raw("\x01") << QVariant(1);
|
||||
QTest::newRow("10") << raw("\x0a") << QVariant(10);
|
||||
QTest::newRow("23") << raw("\x17") << QVariant(23);
|
||||
QTest::newRow("24") << raw("\x18\x18") << QVariant(24);
|
||||
QTest::newRow("255") << raw("\x18\xff") << QVariant(255);
|
||||
QTest::newRow("256") << raw("\x19\x01\x00") << QVariant(256);
|
||||
QTest::newRow("65535") << raw("\x19\xff\xff") << QVariant(65535);
|
||||
QTest::newRow("65536") << raw("\x1a\0\1\x00\x00") << QVariant(65536);
|
||||
QTest::newRow("4294967295") << raw("\x1a\xff\xff\xff\xff") << QVariant(Q_INT64_C(4294967295));
|
||||
QTest::newRow("4294967296") << raw("\x1b\0\0\0\1\0\0\0\0") << QVariant(Q_INT64_C(4294967296));
|
||||
|
||||
// signed integers containing negative numbers
|
||||
QTest::newRow("-1") << raw("\x20") << QVariant(-1);
|
||||
QTest::newRow("-2") << raw("\x21") << QVariant(-2);
|
||||
QTest::newRow("-24") << raw("\x37") << QVariant(-24);
|
||||
QTest::newRow("-25") << raw("\x38\x18") << QVariant(-25);
|
||||
QTest::newRow("-UINT8_MAX") << raw("\x38\xff") << QVariant(-256);
|
||||
QTest::newRow("-UINT8_MAX-1") << raw("\x39\x01\x00") << QVariant(-257);
|
||||
QTest::newRow("-UINT16_MAX") << raw("\x39\xff\xff") << QVariant(-65536);
|
||||
QTest::newRow("-UINT16_MAX-1") << raw("\x3a\0\1\x00\x00") << QVariant(-65537);
|
||||
QTest::newRow("-UINT32_MAX") << raw("\x3a\xff\xff\xff\xff") << QVariant(Q_INT64_C(-4294967296));
|
||||
QTest::newRow("-UINT32_MAX-1") << raw("\x3b\0\0\0\1\0\0\0\0") << QVariant(Q_INT64_C(-4294967297));
|
||||
|
||||
// negative integers
|
||||
auto neg = [](quint64 v) { return QVariant::fromValue<NegativeInteger>({v}); };
|
||||
QTest::newRow("negative1") << raw("\x20") << neg(1);
|
||||
QTest::newRow("negative2") << raw("\x21") << neg(2);
|
||||
QTest::newRow("negative24") << raw("\x37") << neg(24);
|
||||
QTest::newRow("negative25") << raw("\x38\x18") << neg(25);
|
||||
QTest::newRow("negativeUINT8_MAX") << raw("\x38\xff") << neg(256);
|
||||
QTest::newRow("negativeUINT8_MAX-1") << raw("\x39\x01\x00") << neg(257);
|
||||
QTest::newRow("negativeUINT16_MAX") << raw("\x39\xff\xff") << neg(65536);
|
||||
QTest::newRow("negativeUINT16_MAX-1") << raw("\x3a\0\1\x00\x00") << neg(65537);
|
||||
QTest::newRow("negativeUINT32_MAX") << raw("\x3a\xff\xff\xff\xff") << neg(Q_UINT64_C(4294967296));
|
||||
QTest::newRow("negativeUINT32_MAX-1") << raw("\x3b\0\0\0\1\0\0\0\0") << neg(Q_UINT64_C(4294967297));
|
||||
QTest::newRow("negativeUINT64_MAX") << raw("\x3b" "\xff\xff\xff\xff" "\xff\xff\xff\xfe")
|
||||
<< neg(std::numeric_limits<quint64>::max());
|
||||
QTest::newRow("negativeUINT64_MAX+1") << raw("\x3b" "\xff\xff\xff\xff" "\xff\xff\xff\xff") << neg(0);
|
||||
|
||||
QTest::newRow("simple0") << raw("\xe0") << QVariant::fromValue(SimpleType{0});
|
||||
QTest::newRow("simple19") << raw("\xf3") << QVariant::fromValue(SimpleType{19});
|
||||
QTest::newRow("false") << raw("\xf4") << QVariant(false);
|
||||
QTest::newRow("true") << raw("\xf5") << QVariant(true);
|
||||
QTest::newRow("null") << raw("\xf6") << QVariant::fromValue<void *>(nullptr);
|
||||
QTest::newRow("undefined") << raw("\xf7") << QVariant();
|
||||
QTest::newRow("simple32") << raw("\xf8\x20") << QVariant::fromValue(SimpleType{32});
|
||||
QTest::newRow("simple255") << raw("\xf8\xff") << QVariant::fromValue(SimpleType{255});
|
||||
|
||||
// floating point
|
||||
#if QT_VERSION < QT_VERSION_CHECK(5, 9, 0)
|
||||
QTest::newRow("0.f16") << raw("\xf9\0\0") << QVariant::fromValue(Float16Standin{0x0000});
|
||||
#else
|
||||
QTest::newRow("0.f16") << raw("\xf9\0\0") << QVariant::fromValue(qfloat16(0));
|
||||
QTest::newRow("-1.f16") << raw("\xf9\xbc\0") << QVariant::fromValue(qfloat16(-1));
|
||||
QTest::newRow("1.5f16") << raw("\xf9\x3e\0") << QVariant::fromValue(qfloat16(1.5));
|
||||
QTest::newRow("nan_f16") << raw("\xf9\x7e\0") << QVariant::fromValue<qfloat16>(myNaNf());
|
||||
QTest::newRow("-inf_f16") << raw("\xf9\xfc\0") << QVariant::fromValue<qfloat16>(myNInff());
|
||||
QTest::newRow("+inf_f16") << raw("\xf9\x7c\0") << QVariant::fromValue<qfloat16>(myInff());
|
||||
#endif
|
||||
|
||||
QTest::newRow("0.f") << raw("\xfa\0\0\0\0") << QVariant::fromValue(0.f);
|
||||
QTest::newRow("0.") << raw("\xfb\0\0\0\0\0\0\0\0") << QVariant(0.);
|
||||
QTest::newRow("-1.f") << raw("\xfa\xbf\x80\0\0") << QVariant::fromValue(-1.f);
|
||||
QTest::newRow("-1.") << raw("\xfb\xbf\xf0\0\0\0\0\0\0") << QVariant(-1.);
|
||||
QTest::newRow("16777215.f") << raw("\xfa\x4b\x7f\xff\xff") << QVariant::fromValue(16777215.f);
|
||||
QTest::newRow("16777215.") << raw("\xfb\x41\x6f\xff\xff\xe0\0\0\0") << QVariant::fromValue(16777215.);
|
||||
QTest::newRow("-16777215.f") << raw("\xfa\xcb\x7f\xff\xff") << QVariant(-16777215.f);
|
||||
QTest::newRow("-16777215.") << raw("\xfb\xc1\x6f\xff\xff\xe0\0\0\0") << QVariant::fromValue(-16777215.);
|
||||
|
||||
QTest::newRow("nan_f") << raw("\xfa\x7f\xc0\0\0") << QVariant::fromValue<float>(myNaNf());
|
||||
QTest::newRow("nan") << raw("\xfb\x7f\xf8\0\0\0\0\0\0") << QVariant(myNaN());
|
||||
QTest::newRow("-inf_f") << raw("\xfa\xff\x80\0\0") << QVariant::fromValue<float>(myNInff());
|
||||
QTest::newRow("-inf") << raw("\xfb\xff\xf0\0\0\0\0\0\0") << QVariant(myNInf());
|
||||
QTest::newRow("+inf_f") << raw("\xfa\x7f\x80\0\0") << QVariant::fromValue<float>(myInff());
|
||||
QTest::newRow("+inf") << raw("\xfb\x7f\xf0\0\0\0\0\0\0") << QVariant(myInf());
|
||||
}
|
||||
|
||||
void addStringsData()
|
||||
{
|
||||
// byte strings
|
||||
QTest::newRow("emptybytestring") << raw("\x40") << QVariant(QByteArray(""));
|
||||
QTest::newRow("bytestring1") << raw("\x41 ") << QVariant(QByteArray(" "));
|
||||
QTest::newRow("bytestring1-nul") << raw("\x41\0") << QVariant(QByteArray("", 1));
|
||||
QTest::newRow("bytestring5") << raw("\x45Hello") << QVariant(QByteArray("Hello"));
|
||||
QTest::newRow("bytestring24") << raw("\x58\x18""123456789012345678901234")
|
||||
<< QVariant(QByteArray("123456789012345678901234"));
|
||||
QTest::newRow("bytestring256") << raw("\x59\1\0") + QByteArray(256, '3')
|
||||
<< QVariant(QByteArray(256, '3'));
|
||||
|
||||
// text strings
|
||||
QTest::newRow("emptytextstring") << raw("\x60") << QVariant("");
|
||||
QTest::newRow("textstring1") << raw("\x61 ") << QVariant(" ");
|
||||
QTest::newRow("textstring1-nul") << raw("\x61\0") << QVariant(QString::fromLatin1("", 1));
|
||||
QTest::newRow("textstring5") << raw("\x65Hello") << QVariant("Hello");
|
||||
QTest::newRow("textstring24") << raw("\x78\x18""123456789012345678901234")
|
||||
<< QVariant("123456789012345678901234");
|
||||
QTest::newRow("textstring256") << raw("\x79\1\0") + QByteArray(256, '3')
|
||||
<< QVariant(QString(256, '3'));
|
||||
}
|
||||
|
||||
void addArraysAndMaps()
|
||||
{
|
||||
QTest::newRow("emptyarray") << raw("\x80") << make_list();
|
||||
QTest::newRow("emptymap") << raw("\xa0") << make_map({});
|
||||
|
||||
QTest::newRow("array-0") << raw("\x81\0") << make_list(0);
|
||||
QTest::newRow("array-{0-0}") << raw("\x82\0\0") << make_list(0, 0);
|
||||
QTest::newRow("array-Hello") << raw("\x81\x65Hello") << make_list("Hello");
|
||||
QTest::newRow("array-array-0") << raw("\x81\x81\0") << make_list(make_list(0));
|
||||
QTest::newRow("array-array-{0-0}") << raw("\x81\x82\0\0") << make_list(make_list(0, 0));
|
||||
QTest::newRow("array-array-0-0") << raw("\x82\x81\0\0") << make_list(make_list(0),0);
|
||||
QTest::newRow("array-array-Hello") << raw("\x81\x81\x65Hello") << make_list(make_list("Hello"));
|
||||
|
||||
QTest::newRow("map-0:0") << raw("\xa1\0\0") << make_map({{0,0}});
|
||||
QTest::newRow("map-0:0-1:1") << raw("\xa2\0\0\1\1") << make_map({{0,0}, {1,1}});
|
||||
QTest::newRow("map-0:{map-0:0-1:1}") << raw("\xa1\0\xa2\0\0\1\1") << make_map({{0, make_map({{0,0}, {1,1}})}});
|
||||
|
||||
QTest::newRow("array-map1") << raw("\x81\xa1\0\0") << make_list(make_map({{0,0}}));
|
||||
QTest::newRow("array-map2") << raw("\x82\xa1\0\0\xa1\1\1") << make_list(make_map({{0,0}}), make_map({{1,1}}));
|
||||
|
||||
QTest::newRow("map-array1") << raw("\xa1\x62oc\x81\0") << make_map({{"oc", make_list(0)}});
|
||||
QTest::newRow("map-array2") << raw("\xa1\x62oc\x84\0\1\2\3") << make_map({{"oc", make_list(0, 1, 2, 3)}});
|
||||
QTest::newRow("map-array3") << raw("\xa2\x62oc\x82\0\1\2\3") << make_map({{"oc", make_list(0, 1)}, {2, 3}});
|
||||
|
||||
// indeterminate length
|
||||
QTest::newRow("_emptyarray") << raw("\x9f\xff") << QVariant::fromValue(IndeterminateLengthArray{});
|
||||
QTest::newRow("_emptymap") << raw("\xbf\xff") << make_ilmap({});
|
||||
|
||||
QTest::newRow("_array-0") << raw("\x9f\0\xff") << make_ilarray({0});
|
||||
QTest::newRow("_array-{0-0}") << raw("\x9f\0\0\xff") << make_ilarray({0, 0});
|
||||
QTest::newRow("_array-Hello") << raw("\x9f\x65Hello\xff") << make_ilarray({"Hello"});
|
||||
QTest::newRow("_array-array-0") << raw("\x9f\x81\0\xff") << make_ilarray({make_list(0)});
|
||||
QTest::newRow("_array-_array-0") << raw("\x9f\x9f\0\xff\xff") << make_ilarray({make_ilarray({0})});
|
||||
QTest::newRow("_array-_array-{0-0}") << raw("\x9f\x9f\0\0\xff\xff") << make_ilarray({make_ilarray({0, 0})});
|
||||
QTest::newRow("_array-_array-0-0") << raw("\x9f\x9f\0\xff\0\xff") << make_ilarray({make_ilarray({0}),0});
|
||||
QTest::newRow("_array-_array-Hello") << raw("\x9f\x9f\x65Hello\xff\xff") << make_ilarray({make_ilarray({"Hello"})});
|
||||
|
||||
QTest::newRow("_map-0:0") << raw("\xbf\0\0\xff") << make_ilmap({{0,0}});
|
||||
QTest::newRow("_map-0:0-1:1") << raw("\xbf\0\0\1\1\xff") << make_ilmap({{0,0}, {1,1}});
|
||||
QTest::newRow("_map-0:{map-0:0-1:1}") << raw("\xbf\0\xa2\0\0\1\1\xff") << make_ilmap({{0, make_map({{0,0}, {1,1}})}});
|
||||
QTest::newRow("_map-0:{_map-0:0-1:1}") << raw("\xbf\0\xbf\0\0\1\1\xff\xff") << make_ilmap({{0, make_ilmap({{0,0}, {1,1}})}});
|
||||
|
||||
QTest::newRow("_array-map1") << raw("\x9f\xa1\0\0\xff") << make_ilarray({make_map({{0,0}})});
|
||||
QTest::newRow("_array-_map1") << raw("\x9f\xbf\0\0\xff\xff") << make_ilarray({make_ilmap({{0,0}})});
|
||||
QTest::newRow("_array-map2") << raw("\x9f\xa1\0\0\xa1\1\1\xff") << make_ilarray({make_map({{0,0}}), make_map({{1,1}})});
|
||||
QTest::newRow("_array-_map2") << raw("\x9f\xbf\0\0\xff\xbf\1\1\xff\xff") << make_ilarray({make_ilmap({{0,0}}), make_ilmap({{1,1}})});
|
||||
|
||||
QTest::newRow("_map-array1") << raw("\xbf\x62oc\x81\0\xff") << make_ilmap({{"oc", make_list(0)}});
|
||||
QTest::newRow("_map-_array1") << raw("\xbf\x62oc\x9f\0\xff\xff") << make_ilmap({{"oc", make_ilarray({0})}});
|
||||
QTest::newRow("_map-array2") << raw("\xbf\x62oc\x84\0\1\2\3\xff") << make_ilmap({{"oc", make_list(0, 1, 2, 3)}});
|
||||
QTest::newRow("_map-_array2") << raw("\xbf\x62oc\x9f\0\1\2\3\xff\xff") << make_ilmap({{"oc", make_ilarray({0, 1, 2, 3})}});
|
||||
QTest::newRow("_map-array3") << raw("\xbf\x62oc\x82\0\1\2\3\xff") << make_ilmap({{"oc", make_list(0, 1)}, {2, 3}});
|
||||
QTest::newRow("_map-_array3") << raw("\xbf\x62oc\x9f\0\1\xff\2\3\xff") << make_ilmap({{"oc", make_ilarray({0, 1})}, {2, 3}});
|
||||
|
||||
// tagged
|
||||
QTest::newRow("array-1(0)") << raw("\x81\xc1\0") << make_list(QVariant::fromValue(Tag{1, 0}));
|
||||
QTest::newRow("array-1(map)") << raw("\x81\xc1\xa0") << make_list(QVariant::fromValue(Tag{1, make_map({})}));
|
||||
QTest::newRow("map-1(2):3(4)") << raw("\xa1\xc1\2\xc3\4") << make_map({{QVariant::fromValue(Tag{1, 2}), QVariant::fromValue(Tag{3, 4})}});
|
||||
}
|
||||
|
||||
9
kernel/FreeRTOS-Plus/ThirdParty/tinycbor/tests/encoder/encoder.pro
vendored
Normal file
9
kernel/FreeRTOS-Plus/ThirdParty/tinycbor/tests/encoder/encoder.pro
vendored
Normal file
@ -0,0 +1,9 @@
|
||||
SOURCES += tst_encoder.cpp
|
||||
|
||||
CONFIG += testcase parallel_test c++11
|
||||
QT = core testlib
|
||||
|
||||
INCLUDEPATH += ../../src
|
||||
msvc: POST_TARGETDEPS = ../../lib/tinycbor.lib
|
||||
else: POST_TARGETDEPS += ../../lib/libtinycbor.a
|
||||
LIBS += $$POST_TARGETDEPS
|
||||
609
kernel/FreeRTOS-Plus/ThirdParty/tinycbor/tests/encoder/tst_encoder.cpp
vendored
Normal file
609
kernel/FreeRTOS-Plus/ThirdParty/tinycbor/tests/encoder/tst_encoder.cpp
vendored
Normal file
@ -0,0 +1,609 @@
|
||||
/****************************************************************************
|
||||
**
|
||||
** Copyright (C) 2021 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 floatAsHalfFloat_data();
|
||||
void floatAsHalfFloat();
|
||||
void halfFloat_data();
|
||||
void halfFloat();
|
||||
void floatAsHalfFloatCloseToZero_data();
|
||||
void floatAsHalfFloatCloseToZero();
|
||||
void floatAsHalfFloatNaN();
|
||||
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;
|
||||
}
|
||||
|
||||
template <typename Input, typename FnUnderTest>
|
||||
void encodeOne(Input input, FnUnderTest fn_under_test, QByteArray &buffer, CborError &error)
|
||||
{
|
||||
uint8_t *bufptr = reinterpret_cast<quint8 *>(buffer.data());
|
||||
CborEncoder encoder;
|
||||
cbor_encoder_init(&encoder, bufptr, buffer.length(), 0);
|
||||
|
||||
error = fn_under_test(&encoder, input);
|
||||
|
||||
if (error == 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)));
|
||||
}
|
||||
}
|
||||
|
||||
template <typename Input, typename FnUnderTest>
|
||||
void compare(Input input, FnUnderTest fn_under_test, const QByteArray &output)
|
||||
{
|
||||
QByteArray buffer(output.length(), Qt::Uninitialized);
|
||||
CborError error;
|
||||
|
||||
encodeOne(input, fn_under_test, buffer, error);
|
||||
if (QTest::currentTestFailed())
|
||||
return;
|
||||
|
||||
QCOMPARE(error, CborNoError);
|
||||
QCOMPARE(buffer, output);
|
||||
}
|
||||
|
||||
void compare(const QVariant &input, const QByteArray &output)
|
||||
{
|
||||
compare(input, encodeVariant, output);
|
||||
}
|
||||
|
||||
void tst_Encoder::floatAsHalfFloat_data()
|
||||
{
|
||||
addHalfFloat();
|
||||
}
|
||||
|
||||
void tst_Encoder::floatAsHalfFloat()
|
||||
{
|
||||
QFETCH(unsigned, rawInput);
|
||||
QFETCH(double, floatInput);
|
||||
QFETCH(QByteArray, output);
|
||||
|
||||
if (rawInput == 0U || rawInput == 0x8000U)
|
||||
QSKIP("zero values are out of scope of this test case", QTest::SkipSingle);
|
||||
|
||||
if (qIsNaN(floatInput))
|
||||
QSKIP("NaN values are out of scope of this test case", QTest::SkipSingle);
|
||||
|
||||
output.prepend('\xf9');
|
||||
|
||||
compare((float)floatInput, cbor_encode_float_as_half_float, output);
|
||||
}
|
||||
|
||||
void tst_Encoder::halfFloat_data()
|
||||
{
|
||||
addHalfFloat();
|
||||
}
|
||||
|
||||
void tst_Encoder::halfFloat()
|
||||
{
|
||||
QFETCH(unsigned, rawInput);
|
||||
QFETCH(QByteArray, output);
|
||||
|
||||
uint16_t v = (uint16_t)rawInput;
|
||||
output.prepend('\xf9');
|
||||
|
||||
compare(&v, cbor_encode_half_float, output);
|
||||
}
|
||||
|
||||
void tst_Encoder::floatAsHalfFloatCloseToZero_data()
|
||||
{
|
||||
QTest::addColumn<double>("floatInput");
|
||||
|
||||
QTest::newRow("+0") << 0.0;
|
||||
QTest::newRow("-0") << -0.0;
|
||||
|
||||
QTest::newRow("below min.denorm") << ldexp(1.0, -14) * ldexp(1.0, -11);
|
||||
QTest::newRow("above -min.denorm") << ldexp(-1.0, -14) * ldexp(1.0, -11);
|
||||
}
|
||||
|
||||
void tst_Encoder::floatAsHalfFloatCloseToZero()
|
||||
{
|
||||
QFETCH(double, floatInput);
|
||||
|
||||
QByteArray buffer(4, Qt::Uninitialized);
|
||||
CborError error;
|
||||
|
||||
encodeOne((float)floatInput, cbor_encode_float_as_half_float, buffer, error);
|
||||
|
||||
QCOMPARE(error, CborNoError);
|
||||
|
||||
QVERIFY2(
|
||||
buffer == raw("\xf9\x00\x00") || buffer == raw("\xf9\x80\x00"),
|
||||
"Got value " + QByteArray::number(floatInput) + " encoded to: " + buffer);
|
||||
}
|
||||
|
||||
void tst_Encoder::floatAsHalfFloatNaN()
|
||||
{
|
||||
QByteArray buffer(4, Qt::Uninitialized);
|
||||
CborError error;
|
||||
|
||||
encodeOne(myNaNf(), cbor_encode_float_as_half_float, buffer, error);
|
||||
|
||||
QCOMPARE(error, CborNoError);
|
||||
QCOMPARE(buffer.size(), 3);
|
||||
|
||||
uint8_t ini_byte = (uint8_t)buffer[0],
|
||||
exp = (uint8_t)buffer[1] & 0x7cU,
|
||||
manth = (uint8_t)buffer[1] & 0x03U,
|
||||
mantl = (uint8_t)buffer[2];
|
||||
|
||||
QCOMPARE((unsigned)ini_byte, 0xf9U);
|
||||
QCOMPARE((unsigned)exp, 0x7cU);
|
||||
QVERIFY((manth | mantl) != 0);
|
||||
}
|
||||
|
||||
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)
|
||||
607
kernel/FreeRTOS-Plus/ThirdParty/tinycbor/tests/parser/data.cpp
vendored
Normal file
607
kernel/FreeRTOS-Plus/ThirdParty/tinycbor/tests/parser/data.cpp
vendored
Normal file
@ -0,0 +1,607 @@
|
||||
/****************************************************************************
|
||||
**
|
||||
** Copyright (C) 2021 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 <limits>
|
||||
#include <cbor.h>
|
||||
|
||||
Q_DECLARE_METATYPE(CborError)
|
||||
|
||||
template <size_t N> QByteArray raw(const char (&data)[N])
|
||||
{
|
||||
return QByteArray::fromRawData(data, N - 1);
|
||||
}
|
||||
|
||||
void addIntegers()
|
||||
{
|
||||
QTest::addColumn<QByteArray>("data");
|
||||
QTest::addColumn<quint64>("expectedRaw");
|
||||
QTest::addColumn<qint64>("expectedValue");
|
||||
QTest::addColumn<bool>("isNegative");
|
||||
QTest::addColumn<bool>("inInt64Range");
|
||||
|
||||
// unsigned integers
|
||||
QTest::newRow("0") << raw("\x00") << Q_UINT64_C(0) << Q_INT64_C(0) << false << true;
|
||||
QTest::newRow("1") << raw("\x01") << Q_UINT64_C(1) << Q_INT64_C(1) << false << true;
|
||||
QTest::newRow("10") << raw("\x0a") << Q_UINT64_C(10) << Q_INT64_C(10) << false << true;
|
||||
QTest::newRow("23") << raw("\x17") << Q_UINT64_C(23) << Q_INT64_C(23) << false << true;
|
||||
QTest::newRow("24") << raw("\x18\x18") << Q_UINT64_C(24) << Q_INT64_C(24) << false << true;
|
||||
QTest::newRow("UINT8_MAX") << raw("\x18\xff") << Q_UINT64_C(255) << Q_INT64_C(255) << false << true;
|
||||
QTest::newRow("UINT8_MAX+1") << raw("\x19\x01\x00") << Q_UINT64_C(256) << Q_INT64_C(256) << false << true;
|
||||
QTest::newRow("UINT16_MAX") << raw("\x19\xff\xff") << Q_UINT64_C(65535) << Q_INT64_C(65535) << false << true;
|
||||
QTest::newRow("UINT16_MAX+1") << raw("\x1a\0\1\x00\x00") << Q_UINT64_C(65536) << Q_INT64_C(65536) << false << true;
|
||||
QTest::newRow("UINT32_MAX") << raw("\x1a\xff\xff\xff\xff") << Q_UINT64_C(4294967295) << Q_INT64_C(4294967295) << false << true;
|
||||
QTest::newRow("UINT32_MAX+1") << raw("\x1b\0\0\0\1\0\0\0\0") << Q_UINT64_C(4294967296) << Q_INT64_C(4294967296) << false << true;
|
||||
QTest::newRow("INT64_MAX") << raw("\x1b" "\x7f\xff\xff\xff" "\xff\xff\xff\xff")
|
||||
<< quint64(std::numeric_limits<qint64>::max())
|
||||
<< std::numeric_limits<qint64>::max() << false << true;
|
||||
QTest::newRow("UINT64_MAX") << raw("\x1b" "\xff\xff\xff\xff" "\xff\xff\xff\xff")
|
||||
<< std::numeric_limits<quint64>::max() << qint64(-123456) << false << false;
|
||||
|
||||
// negative integers
|
||||
QTest::newRow("-1") << raw("\x20") << Q_UINT64_C(0) << Q_INT64_C(-1) << true << true;
|
||||
QTest::newRow("-2") << raw("\x21") << Q_UINT64_C(1) << Q_INT64_C(-2) << true << true;
|
||||
QTest::newRow("-24") << raw("\x37") << Q_UINT64_C(23) << Q_INT64_C(-24) << true << true;
|
||||
QTest::newRow("-25") << raw("\x38\x18") << Q_UINT64_C(24) << Q_INT64_C(-25) << true << true;
|
||||
QTest::newRow("-UINT8_MAX") << raw("\x38\xff") << Q_UINT64_C(255) << Q_INT64_C(-256) << true << true;
|
||||
QTest::newRow("-UINT8_MAX-1") << raw("\x39\x01\x00") << Q_UINT64_C(256) << Q_INT64_C(-257) << true << true;
|
||||
QTest::newRow("-UINT16_MAX") << raw("\x39\xff\xff") << Q_UINT64_C(65535) << Q_INT64_C(-65536) << true << true;
|
||||
QTest::newRow("-UINT16_MAX-1") << raw("\x3a\0\1\x00\x00") << Q_UINT64_C(65536) << Q_INT64_C(-65537) << true << true;
|
||||
QTest::newRow("-UINT32_MAX") << raw("\x3a\xff\xff\xff\xff") << Q_UINT64_C(4294967295) << Q_INT64_C(-4294967296) << true << true;
|
||||
QTest::newRow("-UINT32_MAX-1") << raw("\x3b\0\0\0\1\0\0\0\0") << Q_UINT64_C(4294967296) << Q_INT64_C(-4294967297) << true << true;
|
||||
QTest::newRow("INT64_MIN+1") << raw("\x3b\x7f\xff\xff\xff""\xff\xff\xff\xfe")
|
||||
<< quint64(std::numeric_limits<qint64>::max() - 1)
|
||||
<< (std::numeric_limits<qint64>::min() + 1)
|
||||
<< true << true;
|
||||
QTest::newRow("INT64_MIN") << raw("\x3b\x7f\xff\xff\xff""\xff\xff\xff\xff")
|
||||
<< quint64(std::numeric_limits<qint64>::max())
|
||||
<< std::numeric_limits<qint64>::min()
|
||||
<< true << true;
|
||||
QTest::newRow("INT64_MIN-1") << raw("\x3b\x80\0\0\0""\0\0\0\0") << Q_UINT64_C(9223372036854775808) << qint64(-123456) << true << false;
|
||||
QTest::newRow("-UINT64_MAX") << raw("\x3b" "\xff\xff\xff\xff" "\xff\xff\xff\xfe")
|
||||
<< (std::numeric_limits<quint64>::max() - 1) << qint64(-123456) << true << false;
|
||||
QTest::newRow("-UINT64_MAX+1") << raw("\x3b" "\xff\xff\xff\xff" "\xff\xff\xff\xff")
|
||||
<< std::numeric_limits<quint64>::max() << qint64(-123456) << true << false;
|
||||
}
|
||||
|
||||
void addColumns()
|
||||
{
|
||||
QTest::addColumn<QByteArray>("data");
|
||||
QTest::addColumn<QString>("expected");
|
||||
QTest::addColumn<int>("n"); // some aux integer, not added in all columns
|
||||
}
|
||||
|
||||
void addFixedData()
|
||||
{
|
||||
// unsigned integers
|
||||
QTest::newRow("0") << raw("\x00") << "0";
|
||||
QTest::newRow("1") << raw("\x01") << "1";
|
||||
QTest::newRow("10") << raw("\x0a") << "10";
|
||||
QTest::newRow("23") << raw("\x17") << "23";
|
||||
QTest::newRow("24") << raw("\x18\x18") << "24";
|
||||
QTest::newRow("UINT8_MAX") << raw("\x18\xff") << "255";
|
||||
QTest::newRow("UINT8_MAX+1") << raw("\x19\x01\x00") << "256";
|
||||
QTest::newRow("UINT16_MAX") << raw("\x19\xff\xff") << "65535";
|
||||
QTest::newRow("UINT16_MAX+1") << raw("\x1a\0\1\x00\x00") << "65536";
|
||||
QTest::newRow("UINT32_MAX") << raw("\x1a\xff\xff\xff\xff") << "4294967295";
|
||||
QTest::newRow("UINT32_MAX+1") << raw("\x1b\0\0\0\1\0\0\0\0") << "4294967296";
|
||||
QTest::newRow("UINT64_MAX") << raw("\x1b" "\xff\xff\xff\xff" "\xff\xff\xff\xff")
|
||||
<< QString::number(std::numeric_limits<uint64_t>::max());
|
||||
|
||||
// negative integers
|
||||
QTest::newRow("-1") << raw("\x20") << "-1";
|
||||
QTest::newRow("-2") << raw("\x21") << "-2";
|
||||
QTest::newRow("-24") << raw("\x37") << "-24";
|
||||
QTest::newRow("-25") << raw("\x38\x18") << "-25";
|
||||
QTest::newRow("-UINT8_MAX") << raw("\x38\xff") << "-256";
|
||||
QTest::newRow("-UINT8_MAX-1") << raw("\x39\x01\x00") << "-257";
|
||||
QTest::newRow("-UINT16_MAX") << raw("\x39\xff\xff") << "-65536";
|
||||
QTest::newRow("-UINT16_MAX-1") << raw("\x3a\0\1\x00\x00") << "-65537";
|
||||
QTest::newRow("-UINT32_MAX") << raw("\x3a\xff\xff\xff\xff") << "-4294967296";
|
||||
QTest::newRow("-UINT32_MAX-1") << raw("\x3b\0\0\0\1\0\0\0\0") << "-4294967297";
|
||||
QTest::newRow("INT64_MIN+1") << raw("\x3b\x7f\xff\xff\xff""\xff\xff\xff\xfe")
|
||||
<< QString::number(std::numeric_limits<int64_t>::min() + 1);
|
||||
QTest::newRow("INT64_MIN") << raw("\x3b\x7f\xff\xff\xff""\xff\xff\xff\xff")
|
||||
<< QString::number(std::numeric_limits<int64_t>::min());
|
||||
QTest::newRow("INT64_MIN-1") << raw("\x3b\x80\0\0\0""\0\0\0\0") << "-9223372036854775809";
|
||||
QTest::newRow("-UINT64_MAX") << raw("\x3b" "\xff\xff\xff\xff" "\xff\xff\xff\xfe")
|
||||
<< '-' + QString::number(std::numeric_limits<uint64_t>::max());
|
||||
QTest::newRow("-UINT64_MAX+1") << raw("\x3b" "\xff\xff\xff\xff" "\xff\xff\xff\xff")
|
||||
<< "-18446744073709551616";
|
||||
|
||||
// overlongs
|
||||
QTest::newRow("0*1") << raw("\x18\x00") << "0_0";
|
||||
QTest::newRow("0*2") << raw("\x19\x00\x00") << "0_1";
|
||||
QTest::newRow("0*4") << raw("\x1a\0\0\0\0") << "0_2";
|
||||
QTest::newRow("0*8") << raw("\x1b\0\0\0\0\0\0\0\0") << "0_3";
|
||||
QTest::newRow("-1*1") << raw("\x38\x00") << "-1_0";
|
||||
QTest::newRow("-1*2") << raw("\x39\x00\x00") << "-1_1";
|
||||
QTest::newRow("-1*4") << raw("\x3a\0\0\0\0") << "-1_2";
|
||||
QTest::newRow("-1*8") << raw("\x3b\0\0\0\0\0\0\0\0") << "-1_3";
|
||||
|
||||
QTest::newRow("simple0") << raw("\xe0") << "simple(0)";
|
||||
QTest::newRow("simple19") << raw("\xf3") << "simple(19)";
|
||||
QTest::newRow("false") << raw("\xf4") << "false";
|
||||
QTest::newRow("true") << raw("\xf5") << "true";
|
||||
QTest::newRow("null") << raw("\xf6") << "null";
|
||||
QTest::newRow("undefined") << raw("\xf7") << "undefined";
|
||||
QTest::newRow("simple32") << raw("\xf8\x20") << "simple(32)";
|
||||
QTest::newRow("simple255") << raw("\xf8\xff") << "simple(255)";
|
||||
|
||||
// floating point
|
||||
|
||||
QTest::newRow("0.f16") << raw("\xf9\0\0") << "0.f16";
|
||||
QTest::newRow("0.f") << raw("\xfa\0\0\0\0") << "0.f";
|
||||
QTest::newRow("0.") << raw("\xfb\0\0\0\0\0\0\0\0") << "0.";
|
||||
QTest::newRow("-1.f16") << raw("\xf9\xbc\x00") << "-1.f16";
|
||||
QTest::newRow("-1.f") << raw("\xfa\xbf\x80\0\0") << "-1.f";
|
||||
QTest::newRow("-1.") << raw("\xfb\xbf\xf0\0\0\0\0\0\0") << "-1.";
|
||||
QTest::newRow("65504.f16") << raw("\xf9\x7b\xff") << "65504.f16";
|
||||
QTest::newRow("16777215.f") << raw("\xfa\x4b\x7f\xff\xff") << "16777215.f";
|
||||
QTest::newRow("16777215.") << raw("\xfb\x41\x6f\xff\xff\xe0\0\0\0") << "16777215.";
|
||||
QTest::newRow("-16777215.f") << raw("\xfa\xcb\x7f\xff\xff") << "-16777215.f";
|
||||
QTest::newRow("-16777215.") << raw("\xfb\xc1\x6f\xff\xff\xe0\0\0\0") << "-16777215.";
|
||||
|
||||
QTest::newRow("0.5f16") << raw("\xf9\x38\0") << "0.5f16";
|
||||
QTest::newRow("0.5f") << raw("\xfa\x3f\0\0\0") << "0.5f";
|
||||
QTest::newRow("0.5") << raw("\xfb\x3f\xe0\0\0\0\0\0\0") << "0.5";
|
||||
QTest::newRow("2.f16^11-1") << raw("\xf9\x67\xff") << "2047.f16";
|
||||
QTest::newRow("2.f^24-1") << raw("\xfa\x4b\x7f\xff\xff") << "16777215.f";
|
||||
QTest::newRow("2.^53-1") << raw("\xfb\x43\x3f\xff\xff""\xff\xff\xff\xff") << "9007199254740991.";
|
||||
QTest::newRow("2.f^64-epsilon") << raw("\xfa\x5f\x7f\xff\xff") << "18446742974197923840.f";
|
||||
QTest::newRow("2.^64-epsilon") << raw("\xfb\x43\xef\xff\xff""\xff\xff\xff\xff") << "18446744073709549568.";
|
||||
QTest::newRow("2.f^64") << raw("\xfa\x5f\x80\0\0") << "1.8446744073709552e+19f";
|
||||
QTest::newRow("2.^64") << raw("\xfb\x43\xf0\0\0\0\0\0\0") << "1.8446744073709552e+19";
|
||||
|
||||
QTest::newRow("nan_f16") << raw("\xf9\x7e\x00") << "nan";
|
||||
QTest::newRow("nan_f") << raw("\xfa\x7f\xc0\0\0") << "nan";
|
||||
QTest::newRow("nan") << raw("\xfb\x7f\xf8\0\0\0\0\0\0") << "nan";
|
||||
QTest::newRow("-inf_f16") << raw("\xf9\xfc\x00") << "-inf";
|
||||
QTest::newRow("-inf_f") << raw("\xfa\xff\x80\0\0") << "-inf";
|
||||
QTest::newRow("-inf") << raw("\xfb\xff\xf0\0\0\0\0\0\0") << "-inf";
|
||||
QTest::newRow("+inf_f16") << raw("\xf9\x7c\x00") << "inf";
|
||||
QTest::newRow("+inf_f") << raw("\xfa\x7f\x80\0\0") << "inf";
|
||||
QTest::newRow("+inf") << raw("\xfb\x7f\xf0\0\0\0\0\0\0") << "inf";
|
||||
|
||||
}
|
||||
|
||||
void addNonChunkedStringsData()
|
||||
{
|
||||
// byte strings
|
||||
QTest::newRow("emptybytestring") << raw("\x40") << "h''";
|
||||
QTest::newRow("bytestring1") << raw("\x41 ") << "h'20'";
|
||||
QTest::newRow("bytestring1-nul") << raw("\x41\0") << "h'00'";
|
||||
QTest::newRow("bytestring5") << raw("\x45Hello") << "h'48656c6c6f'";
|
||||
QTest::newRow("bytestring24") << raw("\x58\x18""123456789012345678901234")
|
||||
<< "h'313233343536373839303132333435363738393031323334'";
|
||||
QTest::newRow("bytestring256") << raw("\x59\1\0") + QByteArray(256, '3')
|
||||
<< "h'" + QString(256 * 2, '3') + '\'';
|
||||
|
||||
// text strings
|
||||
QTest::newRow("emptytextstring") << raw("\x60") << "\"\"";
|
||||
QTest::newRow("textstring1") << raw("\x61 ") << "\" \"";
|
||||
QTest::newRow("textstring1-nul") << raw("\x61\0") << "\"\\u0000\"";
|
||||
QTest::newRow("textstring5") << raw("\x65Hello") << "\"Hello\"";
|
||||
QTest::newRow("textstring24") << raw("\x78\x18""123456789012345678901234")
|
||||
<< "\"123456789012345678901234\"";
|
||||
QTest::newRow("textstring256") << raw("\x79\1\0") + QByteArray(256, '3')
|
||||
<< '"' + QString(256, '3') + '"';
|
||||
|
||||
// some strings with UTF-8 content
|
||||
// we had a bug in the pretty dumper - see issue #54
|
||||
QTest::newRow("textstringutf8-2char") << raw("\x62\xc2\xa0") << "\"\\u00A0\"";
|
||||
QTest::newRow("textstringutf8-2char2") << raw("\x64\xc2\xa0\xc2\xa9") << "\"\\u00A0\\u00A9\"";
|
||||
QTest::newRow("textstringutf8-3char") << raw("\x63\xe2\x88\x80") << "\"\\u2200\"";
|
||||
QTest::newRow("textstringutf8-4char") << raw("\x64\xf0\x90\x88\x83") << "\"\\uD800\\uDE03\"";
|
||||
|
||||
// strings with overlong length
|
||||
QTest::newRow("emptybytestring*1") << raw("\x58\x00") << "h''_0";
|
||||
QTest::newRow("emptytextstring*1") << raw("\x78\x00") << "\"\"_0";
|
||||
QTest::newRow("emptybytestring*2") << raw("\x59\x00\x00") << "h''_1";
|
||||
QTest::newRow("emptytextstring*2") << raw("\x79\x00\x00") << "\"\"_1";
|
||||
QTest::newRow("emptybytestring*4") << raw("\x5a\0\0\0\0") << "h''_2";
|
||||
QTest::newRow("emptytextstring*4") << raw("\x7a\0\0\0\0") << "\"\"_2";
|
||||
QTest::newRow("emptybytestring*8") << raw("\x5b\0\0\0\0\0\0\0\0") << "h''_3";
|
||||
QTest::newRow("emptytextstring*8") << raw("\x7b\0\0\0\0\0\0\0\0") << "\"\"_3";
|
||||
QTest::newRow("bytestring5*1") << raw("\x58\x05Hello") << "h'48656c6c6f'_0";
|
||||
QTest::newRow("textstring5*1") << raw("\x78\x05Hello") << "\"Hello\"_0";
|
||||
QTest::newRow("bytestring5*2") << raw("\x59\0\5Hello") << "h'48656c6c6f'_1";
|
||||
QTest::newRow("textstring5*2") << raw("\x79\0\x05Hello") << "\"Hello\"_1";
|
||||
QTest::newRow("bytestring5*4") << raw("\x5a\0\0\0\5Hello") << "h'48656c6c6f'_2";
|
||||
QTest::newRow("textstring5*4") << raw("\x7a\0\0\0\x05Hello") << "\"Hello\"_2";
|
||||
QTest::newRow("bytestring5*8") << raw("\x5b\0\0\0\0\0\0\0\5Hello") << "h'48656c6c6f'_3";
|
||||
QTest::newRow("textstring5*8") << raw("\x7b\0\0\0\0\0\0\0\x05Hello") << "\"Hello\"_3";
|
||||
|
||||
}
|
||||
|
||||
void addStringsData()
|
||||
{
|
||||
addNonChunkedStringsData();
|
||||
|
||||
// strings with undefined length
|
||||
QTest::newRow("_emptybytestring") << raw("\x5f\xff") << "(_ )";
|
||||
QTest::newRow("_emptytextstring") << raw("\x7f\xff") << "(_ )";
|
||||
QTest::newRow("_emptybytestring2") << raw("\x5f\x40\xff") << "(_ h'')";
|
||||
QTest::newRow("_emptytextstring2") << raw("\x7f\x60\xff") << "(_ \"\")";
|
||||
QTest::newRow("_emptybytestring2*1") << raw("\x5f\x58\x00\xff") << "(_ h''_0)";
|
||||
QTest::newRow("_emptytextstring2*1") << raw("\x7f\x78\x00\xff") << "(_ \"\"_0)";
|
||||
QTest::newRow("_emptybytestring3") << raw("\x5f\x40\x40\xff") << "(_ h'', h'')";
|
||||
QTest::newRow("_emptytextstring3") << raw("\x7f\x60\x60\xff") << "(_ \"\", \"\")";
|
||||
QTest::newRow("_emptybytestring3*2") << raw("\x5f\x59\x00\x00\x40\xff") << "(_ h''_1, h'')";
|
||||
QTest::newRow("_emptytextstring3*2") << raw("\x7f\x79\x00\x00\x60\xff") << "(_ \"\"_1, \"\")";
|
||||
QTest::newRow("_bytestring5x2") << raw("\x5f\x43Hel\x42lo\xff") << "(_ h'48656c', h'6c6f')";
|
||||
QTest::newRow("_textstring5x2") << raw("\x7f\x63Hel\x62lo\xff") << "(_ \"Hel\", \"lo\")";
|
||||
QTest::newRow("_bytestring5x2*8*4") << raw("\x5f\x5b\0\0\0\0\0\0\0\3Hel\x5a\0\0\0\2lo\xff") << "(_ h'48656c'_3, h'6c6f'_2)";
|
||||
QTest::newRow("_textstring5x2*8*4") << raw("\x7f\x7b\0\0\0\0\0\0\0\3Hel\x7a\0\0\0\2lo\xff") << "(_ \"Hel\"_3, \"lo\"_2)";
|
||||
QTest::newRow("_bytestring5x5") << raw("\x5f\x41H\x41""e\x41l\x41l\x41o\xff") << "(_ h'48', h'65', h'6c', h'6c', h'6f')";
|
||||
QTest::newRow("_textstring5x5") << raw("\x7f\x61H\x61""e\x61l\x61l\x61o\xff") << "(_ \"H\", \"e\", \"l\", \"l\", \"o\")";
|
||||
QTest::newRow("_bytestring5x6") << raw("\x5f\x41H\x41""e\x40\x41l\x41l\x41o\xff") << "(_ h'48', h'65', h'', h'6c', h'6c', h'6f')";
|
||||
QTest::newRow("_textstring5x6") << raw("\x7f\x61H\x61""e\x61l\x60\x61l\x61o\xff") << "(_ \"H\", \"e\", \"l\", \"\", \"l\", \"o\")";
|
||||
}
|
||||
|
||||
void addTagsData()
|
||||
{
|
||||
// since parseOne() works recursively for tags, we can't test lone tags
|
||||
QTest::newRow("tag0") << raw("\xc0\x00") << "0(0)";
|
||||
QTest::newRow("tag1") << raw("\xc1\x00") << "1(0)";
|
||||
QTest::newRow("tag24") << raw("\xd8\x18\x00") << "24(0)";
|
||||
QTest::newRow("tag255") << raw("\xd8\xff\x00") << "255(0)";
|
||||
QTest::newRow("tag256") << raw("\xd9\1\0\x00") << "256(0)";
|
||||
QTest::newRow("tag65535") << raw("\xd9\xff\xff\x00") << "65535(0)";
|
||||
QTest::newRow("tag65536") << raw("\xda\0\1\0\0\x00") << "65536(0)";
|
||||
QTest::newRow("tagUINT32_MAX-1") << raw("\xda\xff\xff\xff\xff\x00") << "4294967295(0)";
|
||||
QTest::newRow("tagUINT32_MAX") << raw("\xdb\0\0\0\1\0\0\0\0\x00") << "4294967296(0)";
|
||||
QTest::newRow("tagUINT64_MAX") << raw("\xdb" "\xff\xff\xff\xff" "\xff\xff\xff\xff" "\x00")
|
||||
<< QString::number(std::numeric_limits<uint64_t>::max()) + "(0)";
|
||||
|
||||
// overlong tags
|
||||
QTest::newRow("tag0*1") << raw("\xd8\0\x00") << "0_0(0)";
|
||||
QTest::newRow("tag0*2") << raw("\xd9\0\0\x00") << "0_1(0)";
|
||||
QTest::newRow("tag0*4") << raw("\xda\0\0\0\0\x00") << "0_2(0)";
|
||||
QTest::newRow("tag0*8") << raw("\xdb\0\0\0\0\0\0\0\0\x00") << "0_3(0)";
|
||||
|
||||
// tag other things
|
||||
QTest::newRow("unixtime") << raw("\xc1\x1a\x55\x4b\xbf\xd3") << "1(1431027667)";
|
||||
QTest::newRow("rfc3339date") << raw("\xc0\x78\x19" "2015-05-07 12:41:07-07:00")
|
||||
<< "0(\"2015-05-07 12:41:07-07:00\")";
|
||||
QTest::newRow("tag6+false") << raw("\xc6\xf4") << "6(false)";
|
||||
QTest::newRow("tag25+true") << raw("\xd8\x19\xf5") << "25(true)";
|
||||
QTest::newRow("tag256+null") << raw("\xd9\1\0\xf6") << "256(null)";
|
||||
QTest::newRow("tag65536+simple32") << raw("\xda\0\1\0\0\xf8\x20") << "65536(simple(32))";
|
||||
QTest::newRow("float+unixtime") << raw("\xc1\xfa\x4e\xaa\x97\x80") << "1(1431027712.f)";
|
||||
QTest::newRow("double+unixtime") << raw("\xc1\xfb" "\x41\xd5\x52\xef" "\xf4\xc7\xce\xfe")
|
||||
<< "1(1431027667.1220088)";
|
||||
}
|
||||
|
||||
void addEmptyContainersData()
|
||||
{
|
||||
QTest::newRow("emptyarray") << raw("\x80") << "[]" << 0;
|
||||
QTest::newRow("emptymap") << raw("\xa0") << "{}" << 0;
|
||||
QTest::newRow("_emptyarray") << raw("\x9f\xff") << "[_ ]" << -1;
|
||||
QTest::newRow("_emptymap") << raw("\xbf\xff") << "{_ }" << -1;
|
||||
}
|
||||
|
||||
void addMapMixedData()
|
||||
{
|
||||
QTest::newRow("map-0-24") << raw("\xa1\0\x18\x18") << "{0: 24}" << 1;
|
||||
QTest::newRow("map-0*1-24") << raw("\xa1\x18\0\x18\x18") << "{0_0: 24}" << 1;
|
||||
QTest::newRow("map-0*1-24*2") << raw("\xa1\x18\0\x19\0\x18") << "{0_0: 24_1}" << 1;
|
||||
QTest::newRow("map-0*4-24*2") << raw("\xa1\x1a\0\0\0\0\x19\0\x18") << "{0_2: 24_1}" << 1;
|
||||
QTest::newRow("map-24-0") << raw("\xa1\x18\x18\0") << "{24: 0}" << 1;
|
||||
QTest::newRow("map-24-0*1") << raw("\xa1\x18\x18\x18\0") << "{24: 0_0}" << 1;
|
||||
QTest::newRow("map-255-65535") << raw("\xa1\x18\xff\x19\xff\xff") << "{255: 65535}" << 1;
|
||||
|
||||
QTest::newRow("_map-0-24") << raw("\xbf\0\x18\x18\xff") << "{_ 0: 24}" << 1;
|
||||
QTest::newRow("_map-0*1-24") << raw("\xbf\x18\0\x18\x18\xff") << "{_ 0_0: 24}" << 1;
|
||||
QTest::newRow("_map-0*1-24*2") << raw("\xbf\x18\0\x19\0\x18\xff") << "{_ 0_0: 24_1}" << 1;
|
||||
QTest::newRow("_map-0*4-24*2") << raw("\xbf\x1a\0\0\0\0\x19\0\x18\xff") << "{_ 0_2: 24_1}" << 1;
|
||||
QTest::newRow("_map-24-0") << raw("\xbf\x18\x18\0\xff") << "{_ 24: 0}" << 1;
|
||||
QTest::newRow("_map-24-0*1") << raw("\xbf\x18\x18\x18\0\xff") << "{_ 24: 0_0}" << 1;
|
||||
QTest::newRow("_map-255-65535") << raw("\xbf\x18\xff\x19\xff\xff\xff") << "{_ 255: 65535}" << 1;
|
||||
}
|
||||
|
||||
void addChunkedStringData()
|
||||
{
|
||||
QTest::addColumn<QByteArray>("data");
|
||||
QTest::addColumn<QString>("concatenated");
|
||||
QTest::addColumn<QStringList>("chunks");
|
||||
|
||||
// non-chunked:
|
||||
QTest::newRow("emptybytestring") << raw("\x40") << "h''" << QStringList{"h''"};
|
||||
QTest::newRow("bytestring1") << raw("\x41 ") << "h'20'" << QStringList{"h'20'"};
|
||||
QTest::newRow("emptytextstring") << raw("\x60") << "\"\"" << QStringList{"\"\""};
|
||||
QTest::newRow("textstring1") << raw("\x61 ") << "\" \"" << QStringList{"\" \""};
|
||||
|
||||
// empty chunked:
|
||||
QTest::newRow("_emptybytestring") << raw("\x5f\xff") << "h''" << QStringList{};
|
||||
QTest::newRow("_emptytextstring") << raw("\x7f\xff") << "\"\"" << QStringList{};
|
||||
QTest::newRow("_emptybytestring2") << raw("\x5f\x40\xff") << "h''" << QStringList{"h''"};
|
||||
QTest::newRow("_emptytextstring2") << raw("\x7f\x60\xff") << "\"\"" << QStringList{"\"\""};
|
||||
QTest::newRow("_emptybytestring3") << raw("\x5f\x40\x40\xff") << "h''" << QStringList{"h''", "h''"};
|
||||
QTest::newRow("_emptytextstring3") << raw("\x7f\x60\x60\xff") << "\"\"" << QStringList{"\"\"", "\"\""};
|
||||
|
||||
// regular chunks
|
||||
QTest::newRow("_bytestring1") << raw("\x5f\x41 \xff") << "h'20'" << QStringList{"h'20'"};
|
||||
QTest::newRow("_bytestring2") << raw("\x5f\x41 \x41z\xff") << "h'207a'" << QStringList{"h'20'", "h'7a'"};
|
||||
QTest::newRow("_bytestring3") << raw("\x5f\x41 \x58\x18""123456789012345678901234\x41z\xff")
|
||||
<< "h'203132333435363738393031323334353637383930313233347a'"
|
||||
<< QStringList{"h'20'", "h'313233343536373839303132333435363738393031323334'", "h'7a'"};
|
||||
|
||||
QTest::newRow("_textstring1") << raw("\x7f\x61 \xff") << "\" \"" << QStringList{"\" \""};
|
||||
QTest::newRow("_textstring2") << raw("\x7f\x61 \x61z\xff") << "\" z\"" << QStringList{"\" \"", "\"z\""};
|
||||
QTest::newRow("_textstring3") << raw("\x7f\x61 \x78\x18""123456789012345678901234\x61z\xff")
|
||||
<< "\" 123456789012345678901234z\""
|
||||
<< QStringList{"\" \"", "\"123456789012345678901234\"", "\"z\""};
|
||||
}
|
||||
|
||||
void addValidationColumns()
|
||||
{
|
||||
QTest::addColumn<QByteArray>("data");
|
||||
QTest::addColumn<int>("flags"); // future
|
||||
QTest::addColumn<CborError>("expectedError");
|
||||
}
|
||||
|
||||
void addValidationData(size_t minInvalid = ~size_t(0))
|
||||
{
|
||||
// illegal numbers are future extension points
|
||||
QTest::newRow("illegal-number-in-unsigned-1") << raw("\x81\x1c") << 0 << CborErrorIllegalNumber;
|
||||
QTest::newRow("illegal-number-in-unsigned-2") << raw("\x81\x1d") << 0 << CborErrorIllegalNumber;
|
||||
QTest::newRow("illegal-number-in-unsigned-3") << raw("\x81\x1e") << 0 << CborErrorIllegalNumber;
|
||||
QTest::newRow("illegal-number-in-unsigned-4") << raw("\x81\x1f") << 0 << CborErrorIllegalNumber;
|
||||
QTest::newRow("illegal-number-in-negative-1") << raw("\x81\x3c") << 0 << CborErrorIllegalNumber;
|
||||
QTest::newRow("illegal-number-in-negative-2") << raw("\x81\x3d") << 0 << CborErrorIllegalNumber;
|
||||
QTest::newRow("illegal-number-in-negative-3") << raw("\x81\x3e") << 0 << CborErrorIllegalNumber;
|
||||
QTest::newRow("illegal-number-in-negative-4") << raw("\x81\x3f") << 0 << CborErrorIllegalNumber;
|
||||
QTest::newRow("illegal-number-in-bytearray-length-1") << raw("\x81\x5c") << 0 << CborErrorIllegalNumber;
|
||||
QTest::newRow("illegal-number-in-bytearray-length-2") << raw("\x81\x5d") << 0 << CborErrorIllegalNumber;
|
||||
QTest::newRow("illegal-number-in-bytearray-length-3") << raw("\x81\x5e") << 0 << CborErrorIllegalNumber;
|
||||
QTest::newRow("illegal-number-in-string-length-1") << raw("\x81\x7c") << 0 << CborErrorIllegalNumber;
|
||||
QTest::newRow("illegal-number-in-string-length-2") << raw("\x81\x7d") << 0 << CborErrorIllegalNumber;
|
||||
QTest::newRow("illegal-number-in-string-length-3") << raw("\x81\x7e") << 0 << CborErrorIllegalNumber;
|
||||
QTest::newRow("illegal-number-in-array-length-1") << raw("\x81\x9c") << 0 << CborErrorIllegalNumber;
|
||||
QTest::newRow("illegal-number-in-array-length-2") << raw("\x81\x9d") << 0 << CborErrorIllegalNumber;
|
||||
QTest::newRow("illegal-number-in-array-length-3") << raw("\x81\x9e") << 0 << CborErrorIllegalNumber;
|
||||
QTest::newRow("illegal-number-in-map-length-1") << raw("\x81\xbc") << 0 << CborErrorIllegalNumber;
|
||||
QTest::newRow("illegal-number-in-map-length-2") << raw("\x81\xbd") << 0 << CborErrorIllegalNumber;
|
||||
QTest::newRow("illegal-number-in-map-length-3") << raw("\x81\xbe") << 0 << CborErrorIllegalNumber;
|
||||
QTest::newRow("illegal-number-in-tag-1") << raw("\x81\xdc") << 0 << CborErrorIllegalNumber;
|
||||
QTest::newRow("illegal-number-in-tag-2") << raw("\x81\xdd") << 0 << CborErrorIllegalNumber;
|
||||
QTest::newRow("illegal-number-in-tag-3") << raw("\x81\xde") << 0 << CborErrorIllegalNumber;
|
||||
QTest::newRow("illegal-number-in-tag-4") << raw("\x81\xdf") << 0 << CborErrorIllegalNumber;
|
||||
|
||||
QTest::newRow("unsigned-too-short-1-0") << raw("\x81\x18") << 0 << CborErrorUnexpectedEOF; // requires 1 byte, 0 given
|
||||
QTest::newRow("unsigned-too-short-2-0") << raw("\x81\x19") << 0 << CborErrorUnexpectedEOF; // requires 2 bytes, 0 given
|
||||
QTest::newRow("unsigned-too-short-2-1") << raw("\x81\x19\x01") << 0 << CborErrorUnexpectedEOF; // etc
|
||||
QTest::newRow("unsigned-too-short-4-0") << raw("\x81\x1a") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("unsigned-too-short-4-3") << raw("\x81\x1a\x01\x02\x03") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("unsigned-too-short-8-0") << raw("\x81\x1b") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("unsigned-too-short-8-7") << raw("\x81\x1b\1\2\3\4\5\6\7") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("negative-length-too-short-1-0") << raw("\x81\x38") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("negative-length-too-short-2-0") << raw("\x81\x39") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("negative-length-too-short-2-1") << raw("\x81\x39\x01") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("negative-length-too-short-4-0") << raw("\x81\x3a") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("negative-length-too-short-4-3") << raw("\x81\x3a\x01\x02\x03") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("negative-length-too-short-8-0") << raw("\x81\x3b") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("negative-length-too-short-8-7") << raw("\x81\x3b\1\2\3\4\5\6\7") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("bytearray-length-too-short-1-0") << raw("\x81\x58") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("bytearray-length-too-short-2-0") << raw("\x81\x59") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("bytearray-length-too-short-2-1") << raw("\x81\x59\x01") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("bytearray-length-too-short-4-0") << raw("\x81\x5a") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("bytearray-length-too-short-4-3") << raw("\x81\x5a\x01\x02\x03") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("bytearray-length-too-short-8-0") << raw("\x81\x5b") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("bytearray-length-too-short-8-7") << raw("\x81\x5b\1\2\3\4\5\6\7") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("string-length-too-short-1-0") << raw("\x81\x78") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("string-length-too-short-2-0") << raw("\x81\x79") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("string-length-too-short-2-1") << raw("\x81\x79\x01") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("string-length-too-short-4-0") << raw("\x81\x7a") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("string-length-too-short-4-3") << raw("\x81\x7a\x01\x02\x03") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("string-length-too-short-8-0") << raw("\x81\x7b") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("string-length-too-short-8-7") << raw("\x81\x7b\1\2\3\4\5\6\7") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("bytearray-chunked-length-too-short-1-0") << raw("\x81\x5f\x58") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("bytearray-chunked-length-too-short-2-0") << raw("\x81\x5f\x59") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("bytearray-chunked-length-too-short-2-1") << raw("\x81\x5f\x59\x01") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("bytearray-chunked-length-too-short-4-0") << raw("\x81\x5f\x5a") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("bytearray-chunked-length-too-short-4-3") << raw("\x81\x5f\x5a\x01\x02\x03") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("bytearray-chunked-length-too-short-8-0") << raw("\x81\x5f\x5b") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("bytearray-chunked-length-too-short-8-7") << raw("\x81\x5f\x5b\1\2\3\4\5\6\7") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("string-chunked-length-too-short-1-0") << raw("\x81\x7f\x78") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("string-chunked-length-too-short-2-0") << raw("\x81\x7f\x79") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("string-chunked-length-too-short-2-1") << raw("\x81\x7f\x79\x01") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("string-chunked-length-too-short-4-0") << raw("\x81\x7f\x7a") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("string-chunked-length-too-short-4-3") << raw("\x81\x7f\x7a\x01\x02\x03") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("string-chunked-length-too-short-8-0") << raw("\x81\x7f\x7b") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("string-chunked-length-too-short-8-7") << raw("\x81\x7f\x7b\1\2\3\4\5\6\7") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("bytearray-chunked-2-length-too-short-1-0") << raw("\x81\x5f\x40\x58") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("bytearray-chunked-2-length-too-short-2-0") << raw("\x81\x5f\x40\x59") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("bytearray-chunked-2-length-too-short-2-1") << raw("\x81\x5f\x40\x59\x01") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("bytearray-chunked-2-length-too-short-4-0") << raw("\x81\x5f\x40\x5a") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("bytearray-chunked-2-length-too-short-4-3") << raw("\x81\x5f\x40\x5a\x01\x02\x03") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("bytearray-chunked-2-length-too-short-8-0") << raw("\x81\x5f\x40\x5b") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("bytearray-chunked-2-length-too-short-8-7") << raw("\x81\x5f\x40\x5b\1\2\3\4\5\6\7") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("string-chunked-2-length-too-short-1-0") << raw("\x81\x7f\x60\x78") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("string-chunked-2-length-too-short-2-0") << raw("\x81\x7f\x60\x79") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("string-chunked-2-length-too-short-2-1") << raw("\x81\x7f\x60\x79\x01") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("string-chunked-2-length-too-short-4-0") << raw("\x81\x7f\x60\x7a") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("string-chunked-2-length-too-short-4-3") << raw("\x81\x7f\x60\x7a\x01\x02\x03") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("string-chunked-2-length-too-short-8-0") << raw("\x81\x7f\x60\x7b") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("string-chunked-2-length-too-short-8-7") << raw("\x81\x7f\x60\x7b\1\2\3\4\5\6\7") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("array-length-too-short-1-0") << raw("\x81\x98") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("array-length-too-short-2-0") << raw("\x81\x99") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("array-length-too-short-2-1") << raw("\x81\x99\x01") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("array-length-too-short-4-0") << raw("\x81\x9a") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("array-length-too-short-4-3") << raw("\x81\x9a\x01\x02\x03") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("array-length-too-short-8-0") << raw("\x81\x9b") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("array-length-too-short-8-7") << raw("\x81\x9b\1\2\3\4\5\6\7") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("map-length-too-short-1-0") << raw("\x81\xb8") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("map-length-too-short-2-0") << raw("\x81\xb9") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("map-length-too-short-2-1") << raw("\x81\xb9\x01") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("map-length-too-short-4-0") << raw("\x81\xba") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("map-length-too-short-4-3") << raw("\x81\xba\x01\x02\x03") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("map-length-too-short-8-0") << raw("\x81\xbb") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("map-length-too-short-8-7") << raw("\x81\xbb\1\2\3\4\5\6\7") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("tag-too-short-1-0") << raw("\x81\xd8") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("tag-too-short-2-0") << raw("\x81\xd9") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("tag-too-short-2-1") << raw("\x81\xd9\x01") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("tag-too-short-4-0") << raw("\x81\xda") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("tag-too-short-4-3") << raw("\x81\xda\x01\x02\x03") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("tag-too-short-8-0") << raw("\x81\xdb") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("tag-too-short-8-7") << raw("\x81\xdb\1\2\3\4\5\6\7") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("fp16-too-short1") << raw("\x81\xf9") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("fp16-too-short2") << raw("\x81\xf9\x00") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("float-too-short1") << raw("\x81\xfa") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("float-too-short2") << raw("\x81\xfa\0\0\0") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("double-too-short1") << raw("\x81\xfb") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("double-too-short2") << raw("\x81\xfb\0\0\0\0\0\0\0") << 0 << CborErrorUnexpectedEOF;
|
||||
|
||||
QTest::newRow("bytearray-too-short1") << raw("\x81\x42z") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("bytearray-too-short2") << raw("\x81\x58\x02z") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("bytearray-too-short3") << raw("\x81\x5a\0\0\0\2z") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("bytearray-too-short4") << raw("\x81\x5b\0\0\0\0\0\0\0\2z") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("string-too-short1") << raw("\x81\x62z") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("string-too-short2") << raw("\x81\x78\x02z") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("string-too-short3") << raw("\x81\x7a\0\0\0\2z") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("string-too-short4") << raw("\x81\x7b\0\0\0\0\0\0\0\2z") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("bytearray-chunked-too-short1") << raw("\x81\x5f\x42z") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("bytearray-chunked-too-short2") << raw("\x81\x5f\x58\x02z") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("bytearray-chunked-too-short3") << raw("\x81\x5f\x5a\0\0\0\2z") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("bytearray-chunked-too-short4") << raw("\x81\x5f\x5b\0\0\0\0\0\0\0\2z") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("string-chunked-too-short1") << raw("\x81\x7f\x62z") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("string-chunked-too-short2") << raw("\x81\x7f\x78\x02z") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("string-chunked-too-short3") << raw("\x81\x7f\x7a\0\0\0\2z") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("string-chunked-too-short4") << raw("\x81\x7f\x7b\0\0\0\0\0\0\0\2z") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("bytearray-chunked-too-short1x2") << raw("\x81\x5f\x40\x42z") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("bytearray-chunked-too-short2x2") << raw("\x81\x5f\x40\x58\x02z") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("bytearray-chunked-too-short3x2") << raw("\x81\x5f\x40\x5a\0\0\0\2z") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("bytearray-chunked-too-short4x2") << raw("\x81\x5f\x40\x5b\0\0\0\0\0\0\0\2z") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("string-chunked-too-short1x2") << raw("\x81\x7f\x60\x62z") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("string-chunked-too-short2x2") << raw("\x81\x7f\x60\x78\x02z") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("string-chunked-too-short3x2") << raw("\x81\x7f\x60\x7a\0\0\0\2z") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("string-chunked-too-short4x2") << raw("\x81\x7f\x60\x7b\0\0\0\0\0\0\0\2z") << 0 << CborErrorUnexpectedEOF;
|
||||
|
||||
QTest::newRow("bytearray-no-break1") << raw("\x81\x5f") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("bytearray-no-break2") << raw("\x81\x5f\x40") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("string-no-break1") << raw("\x81\x7f") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("string-no-break2") << raw("\x81\x7f\x60") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("array-no-break1") << raw("\x81\x9f") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("array-no-break2") << raw("\x81\x9f\0") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("map-no-break1") << raw("\x81\xbf") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("map-no-break2") << raw("\x81\xbf\0\0") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("map-break-after-key") << raw("\x81\xbf\0\xff") << 0 << CborErrorUnexpectedBreak;
|
||||
QTest::newRow("map-break-after-second-key") << raw("\x81\xbf\x64xyzw\x04\x00\xff") << 0 << CborErrorUnexpectedBreak;
|
||||
QTest::newRow("map-break-after-value-tag") << raw("\x81\xbf\0\xc0\xff") << 0 << CborErrorUnexpectedBreak;
|
||||
QTest::newRow("map-break-after-value-tag2") << raw("\x81\xbf\0\xd8\x20\xff") << 0 << CborErrorUnexpectedBreak;
|
||||
|
||||
// check for pointer additions wrapping over the limit of the address space
|
||||
auto wraparoundError = [minInvalid](uint64_t encodedSize) {
|
||||
if (encodedSize > minInvalid)
|
||||
return CborErrorDataTooLarge;
|
||||
return CborErrorUnexpectedEOF;
|
||||
};
|
||||
constexpr uint64_t FourGB = UINT32_MAX + UINT64_C(1);
|
||||
// on 32-bit systems, this is a -1
|
||||
QTest::newRow("bytearray-wraparound1") << raw("\x81\x5a\xff\xff\xff\xff") << 0 << wraparoundError(UINT32_MAX);
|
||||
QTest::newRow("string-wraparound1") << raw("\x81\x7a\xff\xff\xff\xff") << 0 << wraparoundError(UINT32_MAX);
|
||||
// on 32-bit systems, a 4GB addition could be dropped
|
||||
QTest::newRow("bytearray-wraparound2") << raw("\x81\x5b\0\0\0\1\0\0\0\0") << 0 << wraparoundError(FourGB);
|
||||
QTest::newRow("string-wraparound2") << raw("\x81\x7b\0\0\0\1\0\0\0\0") << 0 << wraparoundError(FourGB);
|
||||
// on 64-bit systems, this could be a -1
|
||||
QTest::newRow("bytearray-wraparound3") << raw("\x81\x5b\xff\xff\xff\xff\xff\xff\xff\xff") << 0
|
||||
<< wraparoundError(UINT64_MAX);
|
||||
QTest::newRow("string-wraparound3") << raw("\x81\x7b\xff\xff\xff\xff\xff\xff\xff\xff") << 0
|
||||
<< wraparoundError(UINT64_MAX);
|
||||
|
||||
// ditto on chunks
|
||||
QTest::newRow("bytearray-chunk-wraparound1") << raw("\x81\x5f\x5a\xff\xff\xff\xff") << 0 << wraparoundError(UINT32_MAX);
|
||||
QTest::newRow("string-chunk-wraparound1") << raw("\x81\x7f\x7a\xff\xff\xff\xff") << 0 << wraparoundError(UINT32_MAX);
|
||||
// on 32-bit systems, a 4GB addition could be dropped
|
||||
QTest::newRow("bytearray-chunk-wraparound2") << raw("\x81\x5f\x5b\0\0\0\1\0\0\0\0") << 0 << wraparoundError(FourGB);
|
||||
QTest::newRow("string-chunk-wraparound2") << raw("\x81\x7f\x7b\0\0\0\1\0\0\0\0") << 0 << wraparoundError(FourGB);
|
||||
// on 64-bit systems, this could be a -1
|
||||
QTest::newRow("bytearray-chunk-wraparound3") << raw("\x81\x5f\x5b\xff\xff\xff\xff\xff\xff\xff\xff") << 0
|
||||
<< wraparoundError(UINT64_MAX);
|
||||
QTest::newRow("string-chunk-wraparound3") << raw("\x81\x7f\x7b\xff\xff\xff\xff\xff\xff\xff\xff") << 0
|
||||
<< wraparoundError(UINT64_MAX);
|
||||
|
||||
QTest::newRow("eof-after-array") << raw("\x81") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("eof-after-array2") << raw("\x81\x78\x20") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("eof-after-array-element") << raw("\x81\x82\x01") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("eof-after-object") << raw("\x81\xa1") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("eof-after-object2") << raw("\x81\xb8\x20") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("eof-after-object-key") << raw("\x81\xa1\x01") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("eof-after-object-value") << raw("\x81\xa2\x01\x01") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("eof-after-tag") << raw("\x81\xc0") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("eof-after-tag2") << raw("\x81\xd8\x20") << 0 << CborErrorUnexpectedEOF;
|
||||
|
||||
// major type 7 has future types
|
||||
QTest::newRow("future-type-28") << raw("\x81\xfc") << 0 << CborErrorUnknownType;
|
||||
QTest::newRow("future-type-29") << raw("\x81\xfd") << 0 << CborErrorUnknownType;
|
||||
QTest::newRow("future-type-30") << raw("\x81\xfe") << 0 << CborErrorUnknownType;
|
||||
QTest::newRow("unexpected-break") << raw("\x81\xff") << 0 << CborErrorUnexpectedBreak;
|
||||
QTest::newRow("illegal-simple-0") << raw("\x81\xf8\0") << 0 << CborErrorIllegalSimpleType;
|
||||
QTest::newRow("illegal-simple-31") << raw("\x81\xf8\x1f") << 0 << CborErrorIllegalSimpleType;
|
||||
|
||||
// not only too big (UINT_MAX or UINT_MAX+1 in size), but also incomplete
|
||||
if (sizeof(size_t) < sizeof(uint64_t)) {
|
||||
QTest::newRow("bytearray-too-big1") << raw("\x81\x5b\0\0\0\1\0\0\0\0") << 0 << CborErrorDataTooLarge;
|
||||
QTest::newRow("string-too-big1") << raw("\x81\x7b\0\0\0\1\0\0\0\0") << 0 << CborErrorDataTooLarge;
|
||||
}
|
||||
QTest::newRow("array-too-big1") << raw("\x81\x9a\xff\xff\xff\xff\0\0\0\0") << 0 << CborErrorDataTooLarge;
|
||||
QTest::newRow("array-too-big2") << raw("\x81\x9b\0\0\0\1\0\0\0\0") << 0 << CborErrorDataTooLarge;
|
||||
QTest::newRow("object-too-big1") << raw("\x81\xba\xff\xff\xff\xff\0\0\0\0") << 0 << CborErrorDataTooLarge;
|
||||
QTest::newRow("object-too-big2") << raw("\x81\xbb\0\0\0\1\0\0\0\0") << 0 << CborErrorDataTooLarge;
|
||||
|
||||
QTest::newRow("no-break-for-array0") << raw("\x81\x9f") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("no-break-for-array1") << raw("\x81\x9f\x01") << 0 << CborErrorUnexpectedEOF;
|
||||
|
||||
QTest::newRow("no-break-string0") << raw("\x81\x7f") << 0 << CborErrorUnexpectedEOF;
|
||||
QTest::newRow("no-break-string1") << raw("\x81\x7f\x61Z") << 0 << CborErrorUnexpectedEOF;
|
||||
|
||||
QTest::newRow("nested-indefinite-length-bytearrays") << raw("\x81\x5f\x5f\xff\xff") << 0 << CborErrorIllegalNumber;
|
||||
QTest::newRow("nested-indefinite-length-strings") << raw("\x81\x7f\x7f\xff\xff") << 0 << CborErrorIllegalNumber;
|
||||
|
||||
QTest::newRow("string-chunk-unsigned") << raw("\x81\x7f\0\xff") << 0 << CborErrorIllegalType;
|
||||
QTest::newRow("string-chunk-negative") << raw("\x81\x7f\x20\xff") << 0 << CborErrorIllegalType;
|
||||
QTest::newRow("string-chunk-bytearray") << raw("\x81\x7f\x40\xff") << 0 << CborErrorIllegalType;
|
||||
QTest::newRow("string-chunk-array") << raw("\x81\x7f\x80\xff") << 0 << CborErrorIllegalType;
|
||||
QTest::newRow("string-chunk-map") << raw("\x81\x7f\xa0\xff") << 0 << CborErrorIllegalType;
|
||||
QTest::newRow("string-chunk-tag") << raw("\x81\x7f\xc0\xff") << 0 << CborErrorIllegalType;
|
||||
QTest::newRow("string-chunk-tagged-string") << raw("\x81\x7f\xc0\x60\xff") << 0 << CborErrorIllegalType;
|
||||
QTest::newRow("string-chunk-simple0") << raw("\x81\x7f\xe0\xff") << 0 << CborErrorIllegalType;
|
||||
QTest::newRow("string-chunk-false") << raw("\x81\x7f\xf4\xff") << 0 << CborErrorIllegalType;
|
||||
QTest::newRow("string-chunk-true") << raw("\x81\x7f\xf5\xff") << 0 << CborErrorIllegalType;
|
||||
QTest::newRow("string-chunk-null") << raw("\x81\x7f\xf6\xff") << 0 << CborErrorIllegalType;
|
||||
QTest::newRow("string-chunk-undefined") << raw("\x81\x7f\xf7\xff") << 0 << CborErrorIllegalType;
|
||||
|
||||
QTest::newRow("bytearray-chunk-string") << raw("\x81\x5f\x60\xff") << 0 << CborErrorIllegalType;
|
||||
QTest::newRow("bytearray-chunk-tagged-bytearray") << raw("\x81\x7f\xc0\x40\xff") << 0 << CborErrorIllegalType;
|
||||
|
||||
// RFC 7049 Section 2.2.2 "Indefinite-Length Byte Strings and Text Strings" says
|
||||
// Text strings with indefinite lengths act the same as byte strings
|
||||
// with indefinite lengths, except that all their chunks MUST be
|
||||
// definite-length text strings. Note that this implies that the bytes
|
||||
// of a single UTF-8 character cannot be spread between chunks: a new
|
||||
// chunk can only be started at a character boundary.
|
||||
// This test technically tests the dumper, not the parser.
|
||||
QTest::newRow("string-utf8-chunk-split") << raw("\x81\x7f\x61\xc2\x61\xa0\xff") << 0 << CborErrorInvalidUtf8TextString;
|
||||
}
|
||||
10
kernel/FreeRTOS-Plus/ThirdParty/tinycbor/tests/parser/parser.pro
vendored
Normal file
10
kernel/FreeRTOS-Plus/ThirdParty/tinycbor/tests/parser/parser.pro
vendored
Normal file
@ -0,0 +1,10 @@
|
||||
SOURCES += tst_parser.cpp ../../src/cborparser.c
|
||||
|
||||
CONFIG += testcase parallel_test c++11
|
||||
QT = core testlib
|
||||
DEFINES += CBOR_PARSER_MAX_RECURSIONS=16
|
||||
|
||||
INCLUDEPATH += ../../src
|
||||
msvc: POST_TARGETDEPS = ../../lib/tinycbor.lib
|
||||
else: POST_TARGETDEPS += ../../lib/libtinycbor.a
|
||||
LIBS += $$POST_TARGETDEPS
|
||||
1888
kernel/FreeRTOS-Plus/ThirdParty/tinycbor/tests/parser/tst_parser.cpp
vendored
Normal file
1888
kernel/FreeRTOS-Plus/ThirdParty/tinycbor/tests/parser/tst_parser.cpp
vendored
Normal file
File diff suppressed because it is too large
Load Diff
3
kernel/FreeRTOS-Plus/ThirdParty/tinycbor/tests/tests.pro
vendored
Normal file
3
kernel/FreeRTOS-Plus/ThirdParty/tinycbor/tests/tests.pro
vendored
Normal file
@ -0,0 +1,3 @@
|
||||
TEMPLATE = subdirs
|
||||
SUBDIRS = parser encoder c90 cpp tojson
|
||||
msvc: SUBDIRS -= tojson
|
||||
8
kernel/FreeRTOS-Plus/ThirdParty/tinycbor/tests/tojson/tojson.pro
vendored
Normal file
8
kernel/FreeRTOS-Plus/ThirdParty/tinycbor/tests/tojson/tojson.pro
vendored
Normal file
@ -0,0 +1,8 @@
|
||||
CONFIG += testcase parallel_test c++11
|
||||
QT = core testlib
|
||||
|
||||
SOURCES += tst_tojson.cpp
|
||||
INCLUDEPATH += ../../src
|
||||
msvc: POST_TARGETDEPS = ../../lib/tinycbor.lib
|
||||
else: POST_TARGETDEPS += ../../lib/libtinycbor.a
|
||||
LIBS += $$POST_TARGETDEPS
|
||||
721
kernel/FreeRTOS-Plus/ThirdParty/tinycbor/tests/tojson/tst_tojson.cpp
vendored
Normal file
721
kernel/FreeRTOS-Plus/ThirdParty/tinycbor/tests/tojson/tst_tojson.cpp
vendored
Normal file
@ -0,0 +1,721 @@
|
||||
/****************************************************************************
|
||||
**
|
||||
** Copyright (C) 2021 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"
|
||||
#include "cborjson.h"
|
||||
#include <locale.h>
|
||||
|
||||
extern "C" FILE *open_memstream(char **bufptr, size_t *sizeptr);
|
||||
|
||||
class tst_ToJson : public QObject
|
||||
{
|
||||
Q_OBJECT
|
||||
private slots:
|
||||
void initTestCase();
|
||||
|
||||
void fixed_data();
|
||||
void fixed();
|
||||
void textstrings_data();
|
||||
void textstrings() { fixed(); }
|
||||
void nonjson_data();
|
||||
void nonjson() { fixed(); }
|
||||
void bytestrings_data();
|
||||
void bytestrings() { fixed(); }
|
||||
void emptyContainers_data();
|
||||
void emptyContainers() { fixed(); }
|
||||
void arrays_data();
|
||||
void arrays();
|
||||
void nestedArrays_data() { arrays_data(); }
|
||||
void nestedArrays();
|
||||
void maps_data() { arrays_data(); }
|
||||
void maps();
|
||||
void nestedMaps_data() { maps_data(); }
|
||||
void nestedMaps();
|
||||
void nonStringKeyMaps_data();
|
||||
void nonStringKeyMaps();
|
||||
|
||||
void tagsToObjects_data();
|
||||
void tagsToObjects();
|
||||
void taggedByteStringsToBase16_data();
|
||||
void taggedByteStringsToBase16();
|
||||
void taggedByteStringsToBase64_data() { taggedByteStringsToBase16_data(); }
|
||||
void taggedByteStringsToBase64();
|
||||
void taggedByteStringsToBigNum_data() { taggedByteStringsToBase16_data(); }
|
||||
void taggedByteStringsToBigNum();
|
||||
void otherTags_data();
|
||||
void otherTags();
|
||||
|
||||
void metaData_data();
|
||||
void metaData();
|
||||
void metaDataAndTagsToObjects_data() { tagsToObjects_data(); }
|
||||
void metaDataAndTagsToObjects();
|
||||
void metaDataForKeys_data();
|
||||
void metaDataForKeys();
|
||||
};
|
||||
#include "tst_tojson.moc"
|
||||
|
||||
template <size_t N> QByteArray raw(const char (&data)[N])
|
||||
{
|
||||
return QByteArray::fromRawData(data, N - 1);
|
||||
}
|
||||
|
||||
void addColumns()
|
||||
{
|
||||
QTest::addColumn<QByteArray>("data");
|
||||
QTest::addColumn<QString>("expected");
|
||||
}
|
||||
|
||||
void addFixedData()
|
||||
{
|
||||
// unsigned integers
|
||||
QTest::newRow("0") << raw("\x00") << "0";
|
||||
QTest::newRow("1") << raw("\x01") << "1";
|
||||
QTest::newRow("2^53-1") << raw("\x1b\0\x1f\xff\xff""\xff\xff\xff\xff") << "9007199254740991";
|
||||
QTest::newRow("2^64-epsilon") << raw("\x1b\xff\xff\xff\xff""\xff\xff\xf8\x00") << "18446744073709549568";
|
||||
|
||||
// negative integers
|
||||
QTest::newRow("-1") << raw("\x20") << "-1";
|
||||
QTest::newRow("-2") << raw("\x21") << "-2";
|
||||
QTest::newRow("-2^53+1") << raw("\x3b\0\x1f\xff\xff""\xff\xff\xff\xfe") << "-9007199254740991";
|
||||
QTest::newRow("-2^64+epsilon") << raw("\x3b\xff\xff\xff\xff""\xff\xff\xf8\x00") << "-18446744073709549568";
|
||||
|
||||
QTest::newRow("false") << raw("\xf4") << "false";
|
||||
QTest::newRow("true") << raw("\xf5") << "true";
|
||||
QTest::newRow("null") << raw("\xf6") << "null";
|
||||
|
||||
QTest::newRow("0.f16") << raw("\xf9\0\0") << "0";
|
||||
QTest::newRow("0.f") << raw("\xfa\0\0\0\0") << "0";
|
||||
QTest::newRow("0.") << raw("\xfb\0\0\0\0\0\0\0\0") << "0";
|
||||
QTest::newRow("-1.f16") << raw("\xf9\xbc\x00") << "-1";
|
||||
QTest::newRow("-1.f") << raw("\xfa\xbf\x80\0\0") << "-1";
|
||||
QTest::newRow("-1.") << raw("\xfb\xbf\xf0\0\0\0\0\0\0") << "-1";
|
||||
QTest::newRow("16777215.f") << raw("\xfa\x4b\x7f\xff\xff") << "16777215";
|
||||
QTest::newRow("16777215.") << raw("\xfb\x41\x6f\xff\xff\xe0\0\0\0") << "16777215";
|
||||
QTest::newRow("-16777215.f") << raw("\xfa\xcb\x7f\xff\xff") << "-16777215";
|
||||
QTest::newRow("-16777215.") << raw("\xfb\xc1\x6f\xff\xff\xe0\0\0\0") << "-16777215";
|
||||
|
||||
QTest::newRow("0.5f16") << raw("\xf9\x38\0") << "0.5";
|
||||
QTest::newRow("0.5f") << raw("\xfa\x3f\0\0\0") << "0.5";
|
||||
QTest::newRow("0.5") << raw("\xfb\x3f\xe0\0\0\0\0\0\0") << "0.5";
|
||||
QTest::newRow("2.f^24-1") << raw("\xfa\x4b\x7f\xff\xff") << "16777215";
|
||||
QTest::newRow("2.^53-1") << raw("\xfb\x43\x3f\xff\xff""\xff\xff\xff\xff") << "9007199254740991";
|
||||
QTest::newRow("2.f^64-epsilon") << raw("\xfa\x5f\x7f\xff\xff") << "18446742974197923840";
|
||||
QTest::newRow("2.^64-epsilon") << raw("\xfb\x43\xef\xff\xff""\xff\xff\xff\xff") << "18446744073709549568";
|
||||
QTest::newRow("2.f^64") << raw("\xfa\x5f\x80\0\0") << "1.8446744073709552e+19";
|
||||
QTest::newRow("2.^64") << raw("\xfb\x43\xf0\0\0\0\0\0\0") << "1.8446744073709552e+19";
|
||||
|
||||
// infinities and NaN are not supported in JSON, they convert to null
|
||||
QTest::newRow("nan_f16") << raw("\xf9\x7e\x00") << "null";
|
||||
QTest::newRow("nan_f") << raw("\xfa\x7f\xc0\0\0") << "null";
|
||||
QTest::newRow("nan") << raw("\xfb\x7f\xf8\0\0\0\0\0\0") << "null";
|
||||
QTest::newRow("-inf_f") << raw("\xfa\xff\x80\0\0") << "null";
|
||||
QTest::newRow("-inf_f16") << raw("\xf9\xfc\x00") << "null";
|
||||
QTest::newRow("-inf") << raw("\xfb\xff\xf0\0\0\0\0\0\0") << "null";
|
||||
QTest::newRow("+inf_f") << raw("\xfa\x7f\x80\0\0") << "null";
|
||||
QTest::newRow("+inf_f16") << raw("\xf9\x7c\x00") << "null";
|
||||
QTest::newRow("+inf") << raw("\xfb\x7f\xf0\0\0\0\0\0\0") << "null";
|
||||
}
|
||||
|
||||
void addTextStringsData()
|
||||
{
|
||||
QTest::newRow("emptytextstring") << raw("\x60") << "\"\"";
|
||||
QTest::newRow("textstring1") << raw("\x61 ") << "\" \"";
|
||||
QTest::newRow("textstring5") << raw("\x65Hello") << "\"Hello\"";
|
||||
QTest::newRow("textstring24") << raw("\x78\x18""123456789012345678901234")
|
||||
<< "\"123456789012345678901234\"";
|
||||
QTest::newRow("textstring256") << raw("\x79\1\0") + QByteArray(256, '3')
|
||||
<< '"' + QString(256, '3') + '"';
|
||||
|
||||
// strings with undefined length
|
||||
QTest::newRow("_emptytextstring") << raw("\x7f\xff") << "\"\"";
|
||||
QTest::newRow("_emptytextstring2") << raw("\x7f\x60\xff") << "\"\"";
|
||||
QTest::newRow("_emptytextstring3") << raw("\x7f\x60\x60\xff") << "\"\"";
|
||||
QTest::newRow("_textstring5*2") << raw("\x7f\x63Hel\x62lo\xff") << "\"Hello\"";
|
||||
QTest::newRow("_textstring5*5") << raw("\x7f\x61H\x61""e\x61l\x61l\x61o\xff") << "\"Hello\"";
|
||||
QTest::newRow("_textstring5*6") << raw("\x7f\x61H\x61""e\x61l\x60\x61l\x61o\xff") << "\"Hello\"";
|
||||
}
|
||||
|
||||
void addNonJsonData()
|
||||
{
|
||||
QTest::newRow("undefined") << raw("\xf7") << "\"undefined\"";
|
||||
QTest::newRow("simple0") << raw("\xe0") << "\"simple(0)\"";
|
||||
QTest::newRow("simple19") << raw("\xf3") << "\"simple(19)\"";
|
||||
QTest::newRow("simple32") << raw("\xf8\x20") << "\"simple(32)\"";
|
||||
QTest::newRow("simple255") << raw("\xf8\xff") << "\"simple(255)\"";
|
||||
}
|
||||
|
||||
void addByteStringsData()
|
||||
{
|
||||
QTest::newRow("emptybytestring") << raw("\x40") << "\"\"";
|
||||
QTest::newRow("bytestring1") << raw("\x41 ") << "\"IA\"";
|
||||
QTest::newRow("bytestring1-nul") << raw("\x41\0") << "\"AA\"";
|
||||
QTest::newRow("bytestring2") << raw("\x42Hi") << "\"SGk\"";
|
||||
QTest::newRow("bytestring3") << raw("\x43Hey") << "\"SGV5\"";
|
||||
QTest::newRow("bytestring4") << raw("\x44Hola") << "\"SG9sYQ\"";
|
||||
QTest::newRow("bytestring5") << raw("\x45Hello") << "\"SGVsbG8\"";
|
||||
QTest::newRow("bytestring24") << raw("\x58\x18""123456789012345678901234")
|
||||
<< "\"MTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0\"";
|
||||
|
||||
// strings with undefined length
|
||||
QTest::newRow("_emptybytestring") << raw("\x5f\xff") << "\"\"";
|
||||
QTest::newRow("_emptybytestring2") << raw("\x5f\x40\xff") << "\"\"";
|
||||
QTest::newRow("_emptybytestring3") << raw("\x5f\x40\x40\xff") << "\"\"";
|
||||
QTest::newRow("_bytestring5*2") << raw("\x5f\x43Hel\x42lo\xff") << "\"SGVsbG8\"";
|
||||
QTest::newRow("_bytestring5*5") << raw("\x5f\x41H\x41""e\x41l\x41l\x41o\xff") << "\"SGVsbG8\"";
|
||||
QTest::newRow("_bytestring5*6") << raw("\x5f\x41H\x41""e\x40\x41l\x41l\x41o\xff") << "\"SGVsbG8\"";
|
||||
}
|
||||
|
||||
void addEmptyContainersData()
|
||||
{
|
||||
QTest::newRow("emptyarray") << raw("\x80") << "[]";
|
||||
QTest::newRow("emptymap") << raw("\xa0") << "{}";
|
||||
QTest::newRow("_emptyarray") << raw("\x9f\xff") << "[]";
|
||||
QTest::newRow("_emptymap") << raw("\xbf\xff") << "{}";
|
||||
}
|
||||
|
||||
CborError parseOne(CborValue *it, QString *parsed, int flags)
|
||||
{
|
||||
char *buffer;
|
||||
size_t size;
|
||||
|
||||
FILE *f = open_memstream(&buffer, &size);
|
||||
CborError err = cbor_value_to_json_advance(f, it, flags);
|
||||
fclose(f);
|
||||
|
||||
*parsed = QString::fromLatin1(buffer);
|
||||
free(buffer);
|
||||
return err;
|
||||
}
|
||||
|
||||
bool compareFailed = true;
|
||||
void compareOne_real(const QByteArray &data, const QString &expected, int flags, int line)
|
||||
{
|
||||
compareFailed = true;
|
||||
CborParser parser;
|
||||
CborValue first;
|
||||
CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &first);
|
||||
QVERIFY2(!err, QByteArray::number(line) + ": Got error \"" + cbor_error_string(err) + "\"");
|
||||
|
||||
QString decoded;
|
||||
err = parseOne(&first, &decoded, flags);
|
||||
QVERIFY2(!err, QByteArray::number(line) + ": Got error \"" + cbor_error_string(err) +
|
||||
"\"; decoded stream:\n" + decoded.toLatin1());
|
||||
QCOMPARE(decoded, expected);
|
||||
|
||||
// check that we consumed everything
|
||||
QCOMPARE((void*)cbor_value_get_next_byte(&first), (void*)data.constEnd());
|
||||
|
||||
compareFailed = false;
|
||||
}
|
||||
#define compareOne(data, expected, flags) \
|
||||
compareOne_real(data, expected, flags, __LINE__); \
|
||||
if (compareFailed) return
|
||||
|
||||
void tst_ToJson::initTestCase()
|
||||
{
|
||||
setlocale(LC_ALL, "C");
|
||||
}
|
||||
|
||||
void tst_ToJson::fixed_data()
|
||||
{
|
||||
addColumns();
|
||||
addFixedData();
|
||||
}
|
||||
|
||||
void tst_ToJson::fixed()
|
||||
{
|
||||
QFETCH(QByteArray, data);
|
||||
QFETCH(QString, expected);
|
||||
|
||||
compareOne(data, expected, 0);
|
||||
}
|
||||
|
||||
void tst_ToJson::textstrings_data()
|
||||
{
|
||||
addColumns();
|
||||
addTextStringsData();
|
||||
}
|
||||
|
||||
void tst_ToJson::nonjson_data()
|
||||
{
|
||||
addColumns();
|
||||
addNonJsonData();
|
||||
}
|
||||
|
||||
void tst_ToJson::bytestrings_data()
|
||||
{
|
||||
addColumns();
|
||||
addByteStringsData();
|
||||
}
|
||||
|
||||
void tst_ToJson::emptyContainers_data()
|
||||
{
|
||||
addColumns();
|
||||
addEmptyContainersData();
|
||||
}
|
||||
|
||||
void tst_ToJson::arrays_data()
|
||||
{
|
||||
addColumns();
|
||||
addFixedData();
|
||||
addTextStringsData();
|
||||
addNonJsonData();
|
||||
addByteStringsData();
|
||||
}
|
||||
|
||||
void tst_ToJson::arrays()
|
||||
{
|
||||
QFETCH(QByteArray, data);
|
||||
QFETCH(QString, expected);
|
||||
|
||||
compareOne("\x81" + data, '[' + expected + ']', 0);
|
||||
compareOne("\x82" + data + data, '[' + expected + ',' + expected + ']', 0);
|
||||
}
|
||||
|
||||
void tst_ToJson::nestedArrays()
|
||||
{
|
||||
QFETCH(QByteArray, data);
|
||||
QFETCH(QString, expected);
|
||||
|
||||
compareOne("\x81\x81" + data, "[[" + expected + "]]", 0);
|
||||
compareOne("\x81\x81\x81" + data, "[[[" + expected + "]]]", 0);
|
||||
compareOne("\x81\x82" + data + data, "[[" + expected + ',' + expected + "]]", 0);
|
||||
compareOne("\x82\x81" + data + data, "[[" + expected + "]," + expected + "]", 0);
|
||||
compareOne("\x82\x81" + data + '\x81' + data, "[[" + expected + "],[" + expected + "]]", 0);
|
||||
}
|
||||
|
||||
void tst_ToJson::maps()
|
||||
{
|
||||
QFETCH(QByteArray, data);
|
||||
QFETCH(QString, expected);
|
||||
|
||||
compareOne("\xa1\x65" "Hello" + data, "{\"Hello\":" + expected + '}', 0);
|
||||
}
|
||||
|
||||
void tst_ToJson::nestedMaps()
|
||||
{
|
||||
QFETCH(QByteArray, data);
|
||||
QFETCH(QString, expected);
|
||||
|
||||
compareOne("\xa1\x65Hello\xa1\x65World" + data, "{\"Hello\":{\"World\":" + expected + "}}", 0);
|
||||
// compareOne("\xa1\x63""foo\xa1\63""bar" + data + "\63""baz\xa1\x64quux" + data,
|
||||
// "{\"foo\":{\"bar\":" + expected + "},\"baz\":{\"quux\":" + expected + "}", 0);
|
||||
}
|
||||
|
||||
void tst_ToJson::nonStringKeyMaps_data()
|
||||
{
|
||||
addColumns();
|
||||
|
||||
QTest::newRow("0") << raw("\x00") << "0";
|
||||
QTest::newRow("1") << raw("\x01") << "1";
|
||||
QTest::newRow("UINT32_MAX") << raw("\x1a\xff\xff\xff\xff") << "4294967295";
|
||||
QTest::newRow("UINT32_MAX+1") << raw("\x1b\0\0\0\1\0\0\0\0") << "4294967296";
|
||||
QTest::newRow("UINT64_MAX") << raw("\x1b" "\xff\xff\xff\xff" "\xff\xff\xff\xff")
|
||||
<< QString::number(std::numeric_limits<uint64_t>::max());
|
||||
|
||||
QTest::newRow("-1") << raw("\x20") << "-1";
|
||||
QTest::newRow("-UINT32_MAX") << raw("\x3a\xff\xff\xff\xff") << "-4294967296";
|
||||
QTest::newRow("-UINT32_MAX-1") << raw("\x3b\0\0\0\1\0\0\0\0") << "-4294967297";
|
||||
QTest::newRow("-UINT64_MAX") << raw("\x3b" "\xff\xff\xff\xff" "\xff\xff\xff\xfe")
|
||||
<< '-' + QString::number(std::numeric_limits<uint64_t>::max());
|
||||
QTest::newRow("-UINT64_MAX-1") << raw("\x3b" "\xff\xff\xff\xff" "\xff\xff\xff\xff")
|
||||
<< "-18446744073709551616";
|
||||
|
||||
QTest::newRow("simple0") << raw("\xe0") << "simple(0)";
|
||||
QTest::newRow("simple19") << raw("\xf3") << "simple(19)";
|
||||
QTest::newRow("false") << raw("\xf4") << "false";
|
||||
QTest::newRow("true") << raw("\xf5") << "true";
|
||||
QTest::newRow("null") << raw("\xf6") << "null";
|
||||
QTest::newRow("undefined") << raw("\xf7") << "undefined";
|
||||
QTest::newRow("simple32") << raw("\xf8\x20") << "simple(32)";
|
||||
QTest::newRow("simple255") << raw("\xf8\xff") << "simple(255)";
|
||||
|
||||
QTest::newRow("0.f16") << raw("\xf9\0\0") << "0.f16";
|
||||
QTest::newRow("0.f") << raw("\xfa\0\0\0\0") << "0.f";
|
||||
QTest::newRow("0.") << raw("\xfb\0\0\0\0\0\0\0\0") << "0.";
|
||||
QTest::newRow("-1.f16") << raw("\xf9\xbc\x00") << "-1.f16";
|
||||
QTest::newRow("-1.f") << raw("\xfa\xbf\x80\0\0") << "-1.f";
|
||||
QTest::newRow("-1.") << raw("\xfb\xbf\xf0\0\0\0\0\0\0") << "-1.";
|
||||
QTest::newRow("65504.f16") << raw("\xf9\x7b\xff") << "65504.f16";
|
||||
QTest::newRow("16777215.f") << raw("\xfa\x4b\x7f\xff\xff") << "16777215.f";
|
||||
QTest::newRow("16777215.") << raw("\xfb\x41\x6f\xff\xff\xe0\0\0\0") << "16777215.";
|
||||
QTest::newRow("-16777215.f") << raw("\xfa\xcb\x7f\xff\xff") << "-16777215.f";
|
||||
QTest::newRow("-16777215.") << raw("\xfb\xc1\x6f\xff\xff\xe0\0\0\0") << "-16777215.";
|
||||
|
||||
QTest::newRow("0.5f16") << raw("\xf9\x38\0") << "0.5f16";
|
||||
QTest::newRow("0.5f") << raw("\xfa\x3f\0\0\0") << "0.5f";
|
||||
QTest::newRow("0.5") << raw("\xfb\x3f\xe0\0\0\0\0\0\0") << "0.5";
|
||||
QTest::newRow("2.f16^11-1") << raw("\xf9\x67\xff") << "2047.f16";
|
||||
QTest::newRow("2.f^24-1") << raw("\xfa\x4b\x7f\xff\xff") << "16777215.f";
|
||||
QTest::newRow("2.^53-1") << raw("\xfb\x43\x3f\xff\xff""\xff\xff\xff\xff") << "9007199254740991.";
|
||||
QTest::newRow("2.f^64-epsilon") << raw("\xfa\x5f\x7f\xff\xff") << "18446742974197923840.f";
|
||||
QTest::newRow("2.^64-epsilon") << raw("\xfb\x43\xef\xff\xff""\xff\xff\xff\xff") << "18446744073709549568.";
|
||||
QTest::newRow("2.f^64") << raw("\xfa\x5f\x80\0\0") << "1.8446744073709552e+19f";
|
||||
QTest::newRow("2.^64") << raw("\xfb\x43\xf0\0\0\0\0\0\0") << "1.8446744073709552e+19";
|
||||
|
||||
QTest::newRow("nan_f16") << raw("\xf9\x7e\x00") << "nan";
|
||||
QTest::newRow("nan_f") << raw("\xfa\x7f\xc0\0\0") << "nan";
|
||||
QTest::newRow("nan") << raw("\xfb\x7f\xf8\0\0\0\0\0\0") << "nan";
|
||||
QTest::newRow("-inf_f16") << raw("\xf9\xfc\x00") << "-inf";
|
||||
QTest::newRow("-inf_f") << raw("\xfa\xff\x80\0\0") << "-inf";
|
||||
QTest::newRow("-inf") << raw("\xfb\xff\xf0\0\0\0\0\0\0") << "-inf";
|
||||
QTest::newRow("+inf_f16") << raw("\xf9\x7c\x00") << "inf";
|
||||
QTest::newRow("+inf_f") << raw("\xfa\x7f\x80\0\0") << "inf";
|
||||
QTest::newRow("+inf") << raw("\xfb\x7f\xf0\0\0\0\0\0\0") << "inf";
|
||||
|
||||
QTest::newRow("emptybytestring") << raw("\x40") << "h''";
|
||||
QTest::newRow("bytestring1") << raw("\x41 ") << "h'20'";
|
||||
QTest::newRow("bytestring1-nul") << raw("\x41\0") << "h'00'";
|
||||
QTest::newRow("bytestring5") << raw("\x45Hello") << "h'48656c6c6f'";
|
||||
QTest::newRow("bytestring24") << raw("\x58\x18""123456789012345678901234")
|
||||
<< "h'313233343536373839303132333435363738393031323334'";
|
||||
|
||||
QTest::newRow("tag0") << raw("\xc0\x00") << "0(0)";
|
||||
QTest::newRow("tag1") << raw("\xc1\x00") << "1(0)";
|
||||
QTest::newRow("tag24") << raw("\xd8\x18\x00") << "24(0)";
|
||||
QTest::newRow("tagUINT64_MAX") << raw("\xdb" "\xff\xff\xff\xff" "\xff\xff\xff\xff" "\x00")
|
||||
<< QString::number(std::numeric_limits<uint64_t>::max()) + "(0)";
|
||||
|
||||
QTest::newRow("emptyarray") << raw("\x80") << "[]";
|
||||
QTest::newRow("emptymap") << raw("\xa0") << "{}";
|
||||
QTest::newRow("_emptyarray") << raw("\x9f\xff") << "[_ ]";
|
||||
QTest::newRow("_emptymap") << raw("\xbf\xff") << "{_ }";
|
||||
|
||||
QTest::newRow("map-0-24") << raw("\xa1\0\x18\x18") << "{0: 24}";
|
||||
QTest::newRow("map-24-0") << raw("\xa1\x18\x18\0") << "{24: 0}";
|
||||
QTest::newRow("_map-0-24") << raw("\xbf\0\x18\x18\xff") << "{_ 0: 24}";
|
||||
QTest::newRow("_map-24-0") << raw("\xbf\x18\x18\0\xff") << "{_ 24: 0}";
|
||||
}
|
||||
|
||||
void tst_ToJson::nonStringKeyMaps()
|
||||
{
|
||||
QFETCH(QByteArray, data);
|
||||
QFETCH(QString, expected);
|
||||
|
||||
data = "\xa1" + data + "\1";
|
||||
compareOne(data, "{\"" + expected + "\":1}", CborConvertStringifyMapKeys);
|
||||
|
||||
// and verify that they fail if we use CborConvertRequireMapStringKeys
|
||||
CborParser parser;
|
||||
CborValue first;
|
||||
QString decoded;
|
||||
cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &first);
|
||||
CborError err = parseOne(&first, &decoded, CborConvertRequireMapStringKeys);
|
||||
QCOMPARE(err, CborErrorJsonObjectKeyNotString);
|
||||
}
|
||||
|
||||
void tst_ToJson::tagsToObjects_data()
|
||||
{
|
||||
addColumns();
|
||||
QTest::newRow("0(0)") << raw("\xc0\0") << "{\"tag0\":0}";
|
||||
QTest::newRow("0(-1)") << raw("\xc0\x20") << "{\"tag0\":-1}";
|
||||
QTest::newRow("0(\"hello\")") << raw("\xc0\x65hello") << "{\"tag0\":\"hello\"}";
|
||||
QTest::newRow("22(h'48656c6c6f')") << raw("\xd6\x45Hello") << "{\"tag22\":\"SGVsbG8\"}";
|
||||
QTest::newRow("0([1,2,3])") << raw("\xc0\x83\1\2\3") << "{\"tag0\":[1,2,3]}";
|
||||
QTest::newRow("0({\"z\":true,\"y\":1})") << raw("\xc0\xa2\x61z\xf5\x61y\1") << "{\"tag0\":{\"z\":true,\"y\":1}}";
|
||||
|
||||
// large tags
|
||||
QTest::newRow("55799(0)") << raw("\xd9\xd9\xf7\0") << "{\"tag55799\":0}";
|
||||
QTest::newRow("4294967295") << raw("\xda\xff\xff\xff\xff\0") << "{\"tag4294967295\":0}";
|
||||
QTest::newRow("18446744073709551615(0)") << raw("\xdb\xff\xff\xff\xff""\xff\xff\xff\xff\0")
|
||||
<< "{\"tag18446744073709551615\":0}";
|
||||
|
||||
// nested tags
|
||||
QTest::newRow("0(1(2))") << raw("\xc0\xc1\2") << "{\"tag0\":{\"tag1\":2}}";
|
||||
QTest::newRow("0({\"z\":1(2)})") << raw("\xc0\xa1\x61z\xc1\2") << "{\"tag0\":{\"z\":{\"tag1\":2}}}";
|
||||
}
|
||||
|
||||
void tst_ToJson::tagsToObjects()
|
||||
{
|
||||
QFETCH(QByteArray, data);
|
||||
QFETCH(QString, expected);
|
||||
|
||||
compareOne(data, expected, CborConvertTagsToObjects);
|
||||
}
|
||||
|
||||
void tst_ToJson::taggedByteStringsToBase16_data()
|
||||
{
|
||||
QTest::addColumn<QByteArray>("data");
|
||||
QTest::addColumn<QString>("base64url");
|
||||
QTest::addColumn<QString>("base64");
|
||||
QTest::addColumn<QString>("base16");
|
||||
|
||||
QTest::newRow("emptybytestring") << raw("\x40") << "" << "" << "";
|
||||
QTest::newRow("bytestring1") << raw("\x41 ") << "IA" << "IA==" << "20";
|
||||
QTest::newRow("bytestring1-nul") << raw("\x41\0") << "AA" << "AA==" << "00";
|
||||
QTest::newRow("bytestring1-ff") << raw("\x41\xff") << "_w" << "/w==" << "ff";
|
||||
QTest::newRow("bytestring2") << raw("\x42Hi") << "SGk" << "SGk=" << "4869";
|
||||
QTest::newRow("bytestring3") << raw("\x43Hey") << "SGV5" << "SGV5" << "486579";
|
||||
QTest::newRow("bytestring4") << raw("\x44Hola") << "SG9sYQ" << "SG9sYQ==" << "486f6c61";
|
||||
QTest::newRow("bytestring5") << raw("\x45Hello") << "SGVsbG8" << "SGVsbG8=" << "48656c6c6f";
|
||||
QTest::newRow("bytestring24") << raw("\x58\x18""123456789012345678901234")
|
||||
<< "MTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0"
|
||||
<< "MTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0"
|
||||
<< "313233343536373839303132333435363738393031323334";
|
||||
|
||||
// strings with undefined length
|
||||
QTest::newRow("_emptybytestring") << raw("\x5f\xff") << "" << "" << "";
|
||||
QTest::newRow("_emptybytestring2") << raw("\x5f\x40\xff") << "" << "" << "";
|
||||
QTest::newRow("_emptybytestring3") << raw("\x5f\x40\x40\xff") << "" << "" << "";
|
||||
QTest::newRow("_bytestring5*2") << raw("\x5f\x43Hel\x42lo\xff") << "SGVsbG8" << "SGVsbG8=" << "48656c6c6f";
|
||||
QTest::newRow("_bytestring5*5") << raw("\x5f\x41H\x41""e\x41l\x41l\x41o\xff")
|
||||
<< "SGVsbG8" << "SGVsbG8=" << "48656c6c6f";
|
||||
QTest::newRow("_bytestring5*6") << raw("\x5f\x41H\x41""e\x40\x41l\x41l\x41o\xff")
|
||||
<< "SGVsbG8" << "SGVsbG8=" << "48656c6c6f";
|
||||
}
|
||||
|
||||
void tst_ToJson::taggedByteStringsToBase16()
|
||||
{
|
||||
QFETCH(QByteArray, data);
|
||||
QFETCH(QString, base16);
|
||||
|
||||
compareOne('\xd7' + data, '"' + base16 + '"', 0);
|
||||
}
|
||||
|
||||
void tst_ToJson::taggedByteStringsToBase64()
|
||||
{
|
||||
QFETCH(QByteArray, data);
|
||||
QFETCH(QString, base64);
|
||||
|
||||
compareOne('\xd6' + data, '"' + base64 + '"', 0);
|
||||
}
|
||||
|
||||
void tst_ToJson::taggedByteStringsToBigNum()
|
||||
{
|
||||
QFETCH(QByteArray, data);
|
||||
QFETCH(QString, base64url);
|
||||
|
||||
compareOne('\xc3' + data, "\"~" + base64url + '"', 0);
|
||||
}
|
||||
|
||||
void tst_ToJson::otherTags_data()
|
||||
{
|
||||
addColumns();
|
||||
addFixedData();
|
||||
addTextStringsData();
|
||||
addNonJsonData();
|
||||
addByteStringsData();
|
||||
addEmptyContainersData();
|
||||
}
|
||||
|
||||
void tst_ToJson::otherTags()
|
||||
{
|
||||
QFETCH(QByteArray, data);
|
||||
QFETCH(QString, expected);
|
||||
|
||||
// other tags produce no change in output
|
||||
compareOne("\xc0" + data, expected, 0);
|
||||
compareOne("\xc1" + data, expected, 0);
|
||||
compareOne("\xc2" + data, expected, 0);
|
||||
compareOne("\xc4" + data, expected, 0);
|
||||
compareOne("\xc5" + data, expected, 0);
|
||||
compareOne("\xd8\x20" + data, expected, 0);
|
||||
compareOne("\xd8\x21" + data, expected, 0);
|
||||
compareOne("\xd8\x22" + data, expected, 0);
|
||||
compareOne("\xd8\x23" + data, expected, 0);
|
||||
compareOne("\xd8\x24" + data, expected, 0);
|
||||
compareOne("\xd9\xd9\xf7" + data, expected, 0);
|
||||
}
|
||||
|
||||
void tst_ToJson::metaData_data()
|
||||
{
|
||||
addColumns();
|
||||
|
||||
// booleans, null, strings, double precision numbers, regular maps, arrays and integers that
|
||||
// didn't get rounded don't have metadata
|
||||
QTest::newRow("0") << raw("\x00") << QString();
|
||||
QTest::newRow("1") << raw("\x01") << QString();
|
||||
QTest::newRow("2^53-1") << raw("\x1b\0\x1f\xff\xff""\xff\xff\xff\xff") << QString();
|
||||
QTest::newRow("2^64-epsilon") << raw("\x1b\xff\xff\xff\xff""\xff\xff\xf8\x00") << QString();
|
||||
QTest::newRow("-1") << raw("\x20") << QString();
|
||||
QTest::newRow("-2") << raw("\x21") << QString();
|
||||
QTest::newRow("-2^53+1") << raw("\x3b\0\x1f\xff\xff""\xff\xff\xff\xfe") << QString();
|
||||
QTest::newRow("-2^64+epsilon") << raw("\x3b\xff\xff\xff\xff""\xff\xff\xf8\x00") << QString();
|
||||
QTest::newRow("emptytextstring") << raw("\x60") << QString();
|
||||
QTest::newRow("textstring1") << raw("\x61 ") << QString();
|
||||
QTest::newRow("0.5") << raw("\xfb\x3f\xe0\0\0\0\0\0\0") << QString();
|
||||
QTest::newRow("2.^64") << raw("\xfb\x43\xf0\0\0\0\0\0\0") << QString();
|
||||
QTest::newRow("false") << raw("\xf4") << QString();
|
||||
QTest::newRow("true") << raw("\xf5") << QString();
|
||||
QTest::newRow("null") << raw("\xf6") << QString();
|
||||
QTest::newRow("emptyarray") << raw("\x80") << QString();
|
||||
QTest::newRow("emptymap") << raw("\xa0") << QString();
|
||||
QTest::newRow("array*1") << raw("\x81\xf6") << QString();
|
||||
QTest::newRow("map*1") << raw("\xa1\x61z\xf4") << QString();
|
||||
|
||||
// ---- everything from here on has at least the type ----
|
||||
QTest::newRow("emptybytestring") << raw("\x40") << "\"t\":64";
|
||||
QTest::newRow("bytestring1") << raw("\x41 ") << "\"t\":64";
|
||||
QTest::newRow("undefined") << raw("\xf7") << "\"t\":247";
|
||||
QTest::newRow("0.f16") << raw("\xf9\0\0") << "\"t\":249";
|
||||
QTest::newRow("-1.f16") << raw("\xf9\xbc\x00") << "\"t\":249";
|
||||
QTest::newRow("0.f") << raw("\xfa\0\0\0\0") << "\"t\":250";
|
||||
QTest::newRow("-1.f") << raw("\xfa\xbf\x80\0\0") << "\"t\":250";
|
||||
QTest::newRow("16777215.f") << raw("\xfa\x4b\x7f\xff\xff") << "\"t\":250";
|
||||
QTest::newRow("-16777215.f") << raw("\xfa\xcb\x7f\xff\xff") << "\"t\":250";
|
||||
QTest::newRow("0.") << raw("\xfb\0\0\0\0\0\0\0\0") << "\"t\":251";
|
||||
QTest::newRow("-1.") << raw("\xfb\xbf\xf0\0\0\0\0\0\0") << "\"t\":251";
|
||||
QTest::newRow("16777215.") << raw("\xfb\x41\x6f\xff\xff\xe0\0\0\0") << "\"t\":251";
|
||||
QTest::newRow("-16777215.") << raw("\xfb\xc1\x6f\xff\xff\xe0\0\0\0") << "\"t\":251";
|
||||
QTest::newRow("2.^53-1") << raw("\xfb\x43\x3f\xff\xff""\xff\xff\xff\xff") << "\"t\":251";
|
||||
QTest::newRow("2.^64-epsilon") << raw("\xfb\x43\xef\xff\xff""\xff\xff\xff\xff") << "\"t\":251";
|
||||
|
||||
// integers that are too precise for double
|
||||
QTest::newRow("2^53+1") << raw("\x1b\0\x20\0\0""\0\0\0\1")
|
||||
<< "\"t\":0,\"v\":\"+20000000000001\"";
|
||||
QTest::newRow("INT64_MAX-1") << raw("\x1b\x7f\xff\xff\xff""\xff\xff\xff\xfe")
|
||||
<< "\"t\":0,\"v\":\"+7ffffffffffffffe\"";
|
||||
QTest::newRow("INT64_MAX+1") << raw("\x1b\x80\0\0\0""\0\0\0\1")
|
||||
<< "\"t\":0,\"v\":\"+8000000000000001\"";
|
||||
QTest::newRow("-2^53-1") << raw("\x3b\0\x20\0\0""\0\0\0\0")
|
||||
<< "\"t\":0,\"v\":\"-20000000000000\"";
|
||||
|
||||
// simple values
|
||||
QTest::newRow("simple0") << raw("\xe0") << "\"t\":224,\"v\":0";
|
||||
QTest::newRow("simple19") << raw("\xf3") << "\"t\":224,\"v\":19";
|
||||
QTest::newRow("simple32") << raw("\xf8\x20") << "\"t\":224,\"v\":32";
|
||||
QTest::newRow("simple255") << raw("\xf8\xff") << "\"t\":224,\"v\":255";
|
||||
|
||||
// infinities and NaN are not supported in JSON, they convert to null
|
||||
QTest::newRow("nan_f16") << raw("\xf9\x7e\x00") << "\"t\":249,\"v\":\"nan\"";
|
||||
QTest::newRow("nan_f") << raw("\xfa\x7f\xc0\0\0") << "\"t\":250,\"v\":\"nan\"";
|
||||
QTest::newRow("nan") << raw("\xfb\x7f\xf8\0\0\0\0\0\0") << "\"t\":251,\"v\":\"nan\"";
|
||||
QTest::newRow("-inf_f16") << raw("\xf9\xfc\x00") << "\"t\":249,\"v\":\"-inf\"";
|
||||
QTest::newRow("-inf_f") << raw("\xfa\xff\x80\0\0") << "\"t\":250,\"v\":\"-inf\"";
|
||||
QTest::newRow("-inf") << raw("\xfb\xff\xf0\0\0\0\0\0\0") << "\"t\":251,\"v\":\"-inf\"";
|
||||
QTest::newRow("+inf_f16") << raw("\xf9\x7c\x00") << "\"t\":249,\"v\":\"inf\"";
|
||||
QTest::newRow("+inf_f") << raw("\xfa\x7f\x80\0\0") << "\"t\":250,\"v\":\"inf\"";
|
||||
QTest::newRow("+inf") << raw("\xfb\x7f\xf0\0\0\0\0\0\0") << "\"t\":251,\"v\":\"inf\"";
|
||||
|
||||
// tags on native types
|
||||
QTest::newRow("tag+0") << raw("\xc0\x00") << "\"tag\":\"0\"";
|
||||
QTest::newRow("tag+-2") << raw("\xc0\x21") << "\"tag\":\"0\"";
|
||||
QTest::newRow("tag+0.5") << raw("\xc0\xfb\x3f\xe0\0\0\0\0\0\0") << "\"tag\":\"0\"";
|
||||
QTest::newRow("tag+emptytextstring") << raw("\xc0\x60") << "\"tag\":\"0\"";
|
||||
QTest::newRow("tag+textstring1") << raw("\xc0\x61 ") << "\"tag\":\"0\"";
|
||||
QTest::newRow("tag+false") << raw("\xc0\xf4") << "\"tag\":\"0\"";
|
||||
QTest::newRow("tag+true") << raw("\xc0\xf5") << "\"tag\":\"0\"";
|
||||
QTest::newRow("tag+null") << raw("\xc0\xf6") << "\"tag\":\"0\"";
|
||||
QTest::newRow("tag+emptyarray") << raw("\xc0\x80") << "\"tag\":\"0\"";
|
||||
QTest::newRow("tag+emptymap") << raw("\xc0\xa0") << "\"tag\":\"0\"";
|
||||
QTest::newRow("tag+array*1") << raw("\xc0\x81\xf6") << "\"tag\":\"0\"";
|
||||
QTest::newRow("tag+map*1") << raw("\xc0\xa1\x61z\xf4") << "\"tag\":\"0\"";
|
||||
|
||||
// tags on non-native types
|
||||
QTest::newRow("tag+emptybytestring") << raw("\xc0\x40") << "\"tag\":\"0\",\"t\":64";
|
||||
QTest::newRow("tag+bytestring1") << raw("\xc0\x41 ") << "\"tag\":\"0\",\"t\":64";
|
||||
QTest::newRow("tag+undefined") << raw("\xc0\xf7") << "\"tag\":\"0\",\"t\":247";
|
||||
QTest::newRow("tag+0.f") << raw("\xc0\xfa\0\0\0\0") << "\"tag\":\"0\",\"t\":250";
|
||||
QTest::newRow("tag+-1.f") << raw("\xc0\xfa\xbf\x80\0\0") << "\"tag\":\"0\",\"t\":250";
|
||||
QTest::newRow("tag+16777215.f") << raw("\xc0\xfa\x4b\x7f\xff\xff") << "\"tag\":\"0\",\"t\":250";
|
||||
QTest::newRow("tag+-16777215.f") << raw("\xc0\xfa\xcb\x7f\xff\xff") << "\"tag\":\"0\",\"t\":250";
|
||||
QTest::newRow("tag+0.") << raw("\xc0\xfb\0\0\0\0\0\0\0\0") << "\"tag\":\"0\",\"t\":251";
|
||||
QTest::newRow("tag+-1.") << raw("\xc0\xfb\xbf\xf0\0\0\0\0\0\0") << "\"tag\":\"0\",\"t\":251";
|
||||
QTest::newRow("tag+16777215.") << raw("\xc0\xfb\x41\x6f\xff\xff\xe0\0\0\0") << "\"tag\":\"0\",\"t\":251";
|
||||
QTest::newRow("tag+-16777215.") << raw("\xc0\xfb\xc1\x6f\xff\xff\xe0\0\0\0") << "\"tag\":\"0\",\"t\":251";
|
||||
|
||||
// big tags (don't fit in JS numbers)
|
||||
QTest::newRow("bigtag1") << raw("\xdb\0\x20\0\0""\0\0\0\1\x60") << "\"tag\":\"9007199254740993\"";
|
||||
QTest::newRow("bigtag2") << raw("\xdb\xff\xff\xff\xff""\xff\xff\xff\xfe\x60")
|
||||
<< "\"tag\":\"18446744073709551614\"";
|
||||
|
||||
// specially-handled tags
|
||||
QTest::newRow("negativebignum") << raw("\xc3\x41 ") << "\"tag\":\"3\",\"t\":64";
|
||||
QTest::newRow("base64") << raw("\xd6\x41 ") << "\"tag\":\"22\",\"t\":64";
|
||||
QTest::newRow("base16") << raw("\xd7\x41 ") << "\"tag\":\"23\",\"t\":64";
|
||||
}
|
||||
|
||||
void compareMetaData(QByteArray data, const QString &expected, int otherFlags = 0)
|
||||
{
|
||||
QString decoded;
|
||||
|
||||
// needs to be in one map, with the entry called "v"
|
||||
data = "\xa1\x61v" + data;
|
||||
|
||||
{
|
||||
CborParser parser;
|
||||
CborValue first;
|
||||
CborError err = cbor_parser_init(reinterpret_cast<const quint8 *>(data.constData()), data.length(), 0, &parser, &first);
|
||||
QVERIFY2(!err, QByteArrayLiteral(": Got error \"") + cbor_error_string(err) + "\"");
|
||||
|
||||
err = parseOne(&first, &decoded, CborConvertAddMetadata | otherFlags);
|
||||
QVERIFY2(!err, QByteArrayLiteral(": Got error \"") + cbor_error_string(err) +
|
||||
"\"; decoded stream:\n" + decoded.toLatin1());
|
||||
|
||||
// check that we consumed everything
|
||||
QCOMPARE((void*)cbor_value_get_next_byte(&first), (void*)data.constEnd());
|
||||
}
|
||||
|
||||
QVERIFY(decoded.startsWith("{\"v\":"));
|
||||
QVERIFY(decoded.endsWith('}'));
|
||||
// qDebug() << "was" << decoded;
|
||||
|
||||
// extract just the metadata
|
||||
static const char needle[] = "\"v$cbor\":{";
|
||||
int pos = decoded.indexOf(needle);
|
||||
QCOMPARE(pos == -1, expected.isEmpty());
|
||||
if (pos != -1) {
|
||||
decoded.chop(2);
|
||||
decoded = std::move(decoded).mid(pos + strlen(needle));
|
||||
QCOMPARE(decoded, expected);
|
||||
}
|
||||
}
|
||||
|
||||
void tst_ToJson::metaData()
|
||||
{
|
||||
QFETCH(QByteArray, data);
|
||||
QFETCH(QString, expected);
|
||||
compareMetaData(data, expected);
|
||||
}
|
||||
|
||||
void tst_ToJson::metaDataAndTagsToObjects()
|
||||
{
|
||||
QFETCH(QByteArray, data);
|
||||
|
||||
// when a tag is converted to an object, the object gets metadata indicating it was a tag
|
||||
compareMetaData(data, "\"t\":192", CborConvertTagsToObjects);
|
||||
}
|
||||
|
||||
void tst_ToJson::metaDataForKeys_data()
|
||||
{
|
||||
nonStringKeyMaps_data();
|
||||
|
||||
// string keys generate no metadata
|
||||
QTest::newRow("string") << raw("\x60") << QString();
|
||||
}
|
||||
|
||||
void tst_ToJson::metaDataForKeys()
|
||||
{
|
||||
QFETCH(QByteArray, data);
|
||||
QFETCH(QString, expected);
|
||||
if (expected.isEmpty())
|
||||
expected = "{\"\":false}";
|
||||
else
|
||||
expected = "{\"" + expected + "\":false,\"" + expected + "$keycbordump\":true}";
|
||||
compareOne('\xa1' + data + '\xf4', expected,
|
||||
CborConvertAddMetadata | CborConvertStringifyMapKeys);
|
||||
}
|
||||
|
||||
QTEST_MAIN(tst_ToJson)
|
||||
Reference in New Issue
Block a user