Skip to content

Commit 87a7a93

Browse files
thiagomacieirathiagomacieira
committed
Move the testdata out to a separate .cpp so they can be reused
Signed-off-by: Thiago Macieira <[email protected]>
1 parent e26ff9a commit 87a7a93

File tree

4 files changed

+956
-879
lines changed

4 files changed

+956
-879
lines changed

‎tests/encoder/data.cpp

Lines changed: 346 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,346 @@
1+
/****************************************************************************
2+
**
3+
** Copyright (C) 2021 Intel Corporation
4+
**
5+
** Permission is hereby granted, free of charge, to any person obtaining a copy
6+
** of this software and associated documentation files (the "Software"), to deal
7+
** in the Software without restriction, including without limitation the rights
8+
** to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9+
** copies of the Software, and to permit persons to whom the Software is
10+
** furnished to do so, subject to the following conditions:
11+
**
12+
** The above copyright notice and this permission notice shall be included in
13+
** all copies or substantial portions of the Software.
14+
**
15+
** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16+
** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17+
** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18+
** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19+
** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20+
** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21+
** THE SOFTWARE.
22+
**
23+
****************************************************************************/
24+
25+
#include <QtTest>
26+
27+
static float myNaNf()
28+
{
29+
uint32_t v = 0x7fc00000;
30+
float f;
31+
memcpy(&f, &v, sizeof(f));
32+
Q_ASSERT(qIsNaN(f));
33+
return f;
34+
}
35+
36+
static float myInff()
37+
{
38+
uint32_t v = 0x7f800000;
39+
float f;
40+
memcpy(&f, &v, sizeof(f));
41+
Q_ASSERT(qIsInf(f));
42+
return f;
43+
}
44+
45+
static float myNInff()
46+
{
47+
uint32_t v = 0xff800000;
48+
float f;
49+
memcpy(&f, &v, sizeof(f));
50+
Q_ASSERT(qIsInf(f));
51+
return f;
52+
}
53+
54+
static double myNaN()
55+
{
56+
uint64_t v = UINT64_C(0x7ff8000000000000);
57+
double f;
58+
memcpy(&f, &v, sizeof(f));
59+
Q_ASSERT(qIsNaN(f));
60+
return f;
61+
}
62+
63+
static double myInf()
64+
{
65+
uint64_t v = UINT64_C(0x7ff0000000000000);
66+
double f;
67+
memcpy(&f, &v, sizeof(f));
68+
Q_ASSERT(qIsInf(f));
69+
return f;
70+
}
71+
72+
static double myNInf()
73+
{
74+
uint64_t v = UINT64_C(0xfff0000000000000);
75+
double f;
76+
memcpy(&f, &v, sizeof(f));
77+
Q_ASSERT(qIsInf(f));
78+
return f;
79+
}
80+
81+
template <size_t N> QByteArray raw(const char (&data)[N])
82+
{
83+
return QByteArray::fromRawData(data, N - 1);
84+
}
85+
86+
struct NegativeInteger { quint64 abs; };
87+
Q_DECLARE_METATYPE(NegativeInteger)
88+
89+
struct SimpleType { uint8_t type; };
90+
Q_DECLARE_METATYPE(SimpleType)
91+
92+
struct Float16Standin { uint16_t val; };
93+
Q_DECLARE_METATYPE(Float16Standin)
94+
95+
struct Tag { CborTag tag; QVariant tagged; };
96+
Q_DECLARE_METATYPE(Tag)
97+
98+
template <typename... Args>
99+
QVariant make_list(const Args &... args)
100+
{
101+
return QVariantList{args...};
102+
}
103+
104+
typedef QVector<QPair<QVariant, QVariant>> Map;
105+
Q_DECLARE_METATYPE(Map)
106+
QVariant make_map(const std::initializer_list<QPair<QVariant, QVariant>> &list)
107+
{
108+
return QVariant::fromValue(Map(list));
109+
}
110+
111+
struct IndeterminateLengthArray : QVariantList { using QVariantList::QVariantList; };
112+
struct IndeterminateLengthMap : Map { using Map::Map; };
113+
Q_DECLARE_METATYPE(IndeterminateLengthArray)
114+
Q_DECLARE_METATYPE(IndeterminateLengthMap)
115+
116+
QVariant make_ilarray(const std::initializer_list<QVariant> &list)
117+
{
118+
return QVariant::fromValue(IndeterminateLengthArray(list));
119+
}
120+
121+
QVariant make_ilmap(const std::initializer_list<QPair<QVariant, QVariant>> &list)
122+
{
123+
return QVariant::fromValue(IndeterminateLengthMap(list));
124+
}
125+
126+
void addHalfFloat()
127+
{
128+
QTest::addColumn<QByteArray>("output");
129+
QTest::addColumn<unsigned>("rawInput");
130+
QTest::addColumn<double>("floatInput");
131+
132+
QTest::newRow("+0") << raw("\x00\x00") << 0U << 0.0;
133+
QTest::newRow("-0") << raw("\x80\x00") << 0x8000U << 0.0;
134+
135+
QTest::newRow("min.denorm") << raw("\x00\x01") << 1U << ldexp(1.0, -14) * ldexp(1.0, -10);
136+
QTest::newRow("-min.denorm") << raw("\x80\x01") << 0x8001U << ldexp(-1.0, -14) * ldexp(1.0, -10);
137+
138+
QTest::newRow("max.denorm") << raw("\x03\xff") << 0x03ffU << ldexp(1.0, -14) * (1.0 - ldexp(1.0, -10));
139+
QTest::newRow("-max.denorm") << raw("\x83\xff") << 0x83ffU << ldexp(-1.0, -14) * (1.0 - ldexp(1.0, -10));
140+
141+
QTest::newRow("min.norm") << raw("\x04\x00") << 0x0400U << ldexp(1.0, -14);
142+
QTest::newRow("-min.norm") << raw("\x84\x00") << 0x8400U << ldexp(-1.0, -14);
143+
144+
QTest::newRow("1.0") << raw("\x3c\x00") << 0x3c00U << 1.0;
145+
QTest::newRow("-1.0") << raw("\xbc\x00") << 0xbc00U << -1.0;
146+
147+
QTest::newRow("1.5") << raw("\x3e\x00") << 0x3e00U << 1.5;
148+
QTest::newRow("-1.5") << raw("\xbe\x00") << 0xbe00U << -1.5;
149+
150+
QTest::newRow("max") << raw("\x7b\xff") << 0x7bffU << ldexp(1.0, 15) * (2.0 - ldexp(1.0, -10));
151+
QTest::newRow("-max") << raw("\xfb\xff") << 0xfbffU << ldexp(-1.0, 15) * (2.0 - ldexp(1.0, -10));
152+
153+
QTest::newRow("inf") << raw("\x7c\x00") << 0x7c00U << myInf();
154+
QTest::newRow("-inf") << raw("\xfc\x00") << 0xfc00U << myNInf();
155+
156+
QTest::newRow("nan1") << raw("\x7c\x01") << 0x7c01U << myNaN();
157+
QTest::newRow("nan2") << raw("\xfc\x01") << 0xfc01U << myNaN();
158+
QTest::newRow("nan3") << raw("\x7e\x00") << 0x7e00U << myNaN();
159+
QTest::newRow("nan4") << raw("\xfe\x00") << 0xfe00U << myNaN();
160+
}
161+
162+
void addColumns()
163+
{
164+
QTest::addColumn<QByteArray>("output");
165+
QTest::addColumn<QVariant>("input");
166+
}
167+
168+
void addFixedData()
169+
{
170+
// unsigned integers
171+
QTest::newRow("0U") << raw("\x00") << QVariant(0U);
172+
QTest::newRow("1U") << raw("\x01") << QVariant(1U);
173+
QTest::newRow("10U") << raw("\x0a") << QVariant(10U);
174+
QTest::newRow("23U") << raw("\x17") << QVariant(23U);
175+
QTest::newRow("24U") << raw("\x18\x18") << QVariant(24U);
176+
QTest::newRow("255U") << raw("\x18\xff") << QVariant(255U);
177+
QTest::newRow("256U") << raw("\x19\x01\x00") << QVariant(256U);
178+
QTest::newRow("65535U") << raw("\x19\xff\xff") << QVariant(65535U);
179+
QTest::newRow("65536U") << raw("\x1a\0\1\x00\x00") << QVariant(65536U);
180+
QTest::newRow("4294967295U") << raw("\x1a\xff\xff\xff\xff") << QVariant(4294967295U);
181+
QTest::newRow("4294967296U") << raw("\x1b\0\0\0\1\0\0\0\0") << QVariant(Q_UINT64_C(4294967296));
182+
QTest::newRow("UINT64_MAX") << raw("\x1b" "\xff\xff\xff\xff" "\xff\xff\xff\xff")
183+
<< QVariant(std::numeric_limits<quint64>::max());
184+
185+
// signed integers containing non-negative numbers
186+
QTest::newRow("0") << raw("\x00") << QVariant(0);
187+
QTest::newRow("1") << raw("\x01") << QVariant(1);
188+
QTest::newRow("10") << raw("\x0a") << QVariant(10);
189+
QTest::newRow("23") << raw("\x17") << QVariant(23);
190+
QTest::newRow("24") << raw("\x18\x18") << QVariant(24);
191+
QTest::newRow("255") << raw("\x18\xff") << QVariant(255);
192+
QTest::newRow("256") << raw("\x19\x01\x00") << QVariant(256);
193+
QTest::newRow("65535") << raw("\x19\xff\xff") << QVariant(65535);
194+
QTest::newRow("65536") << raw("\x1a\0\1\x00\x00") << QVariant(65536);
195+
QTest::newRow("4294967295") << raw("\x1a\xff\xff\xff\xff") << QVariant(Q_INT64_C(4294967295));
196+
QTest::newRow("4294967296") << raw("\x1b\0\0\0\1\0\0\0\0") << QVariant(Q_INT64_C(4294967296));
197+
198+
// signed integers containing negative numbers
199+
QTest::newRow("-1") << raw("\x20") << QVariant(-1);
200+
QTest::newRow("-2") << raw("\x21") << QVariant(-2);
201+
QTest::newRow("-24") << raw("\x37") << QVariant(-24);
202+
QTest::newRow("-25") << raw("\x38\x18") << QVariant(-25);
203+
QTest::newRow("-UINT8_MAX") << raw("\x38\xff") << QVariant(-256);
204+
QTest::newRow("-UINT8_MAX-1") << raw("\x39\x01\x00") << QVariant(-257);
205+
QTest::newRow("-UINT16_MAX") << raw("\x39\xff\xff") << QVariant(-65536);
206+
QTest::newRow("-UINT16_MAX-1") << raw("\x3a\0\1\x00\x00") << QVariant(-65537);
207+
QTest::newRow("-UINT32_MAX") << raw("\x3a\xff\xff\xff\xff") << QVariant(Q_INT64_C(-4294967296));
208+
QTest::newRow("-UINT32_MAX-1") << raw("\x3b\0\0\0\1\0\0\0\0") << QVariant(Q_INT64_C(-4294967297));
209+
210+
// negative integers
211+
auto neg = [](quint64 v) { return QVariant::fromValue<NegativeInteger>({v}); };
212+
QTest::newRow("negative1") << raw("\x20") << neg(1);
213+
QTest::newRow("negative2") << raw("\x21") << neg(2);
214+
QTest::newRow("negative24") << raw("\x37") << neg(24);
215+
QTest::newRow("negative25") << raw("\x38\x18") << neg(25);
216+
QTest::newRow("negativeUINT8_MAX") << raw("\x38\xff") << neg(256);
217+
QTest::newRow("negativeUINT8_MAX-1") << raw("\x39\x01\x00") << neg(257);
218+
QTest::newRow("negativeUINT16_MAX") << raw("\x39\xff\xff") << neg(65536);
219+
QTest::newRow("negativeUINT16_MAX-1") << raw("\x3a\0\1\x00\x00") << neg(65537);
220+
QTest::newRow("negativeUINT32_MAX") << raw("\x3a\xff\xff\xff\xff") << neg(Q_UINT64_C(4294967296));
221+
QTest::newRow("negativeUINT32_MAX-1") << raw("\x3b\0\0\0\1\0\0\0\0") << neg(Q_UINT64_C(4294967297));
222+
QTest::newRow("negativeUINT64_MAX") << raw("\x3b" "\xff\xff\xff\xff" "\xff\xff\xff\xfe")
223+
<< neg(std::numeric_limits<quint64>::max());
224+
QTest::newRow("negativeUINT64_MAX+1") << raw("\x3b" "\xff\xff\xff\xff" "\xff\xff\xff\xff") << neg(0);
225+
226+
QTest::newRow("simple0") << raw("\xe0") << QVariant::fromValue(SimpleType{0});
227+
QTest::newRow("simple19") << raw("\xf3") << QVariant::fromValue(SimpleType{19});
228+
QTest::newRow("false") << raw("\xf4") << QVariant(false);
229+
QTest::newRow("true") << raw("\xf5") << QVariant(true);
230+
QTest::newRow("null") << raw("\xf6") << QVariant::fromValue<void *>(nullptr);
231+
QTest::newRow("undefined") << raw("\xf7") << QVariant();
232+
QTest::newRow("simple32") << raw("\xf8\x20") << QVariant::fromValue(SimpleType{32});
233+
QTest::newRow("simple255") << raw("\xf8\xff") << QVariant::fromValue(SimpleType{255});
234+
235+
// floating point
236+
#if QT_VERSION < QT_VERSION_CHECK(5, 9, 0)
237+
QTest::newRow("0.f16") << raw("\xf9\0\0") << QVariant::fromValue(Float16Standin{0x0000});
238+
#else
239+
QTest::newRow("0.f16") << raw("\xf9\0\0") << QVariant::fromValue(qfloat16(0));
240+
QTest::newRow("-1.f16") << raw("\xf9\xbc\0") << QVariant::fromValue(qfloat16(-1));
241+
QTest::newRow("1.5f16") << raw("\xf9\x3e\0") << QVariant::fromValue(qfloat16(1.5));
242+
QTest::newRow("nan_f16") << raw("\xf9\x7e\0") << QVariant::fromValue<qfloat16>(myNaNf());
243+
QTest::newRow("-inf_f16") << raw("\xf9\xfc\0") << QVariant::fromValue<qfloat16>(myNInff());
244+
QTest::newRow("+inf_f16") << raw("\xf9\x7c\0") << QVariant::fromValue<qfloat16>(myInff());
245+
#endif
246+
247+
QTest::newRow("0.f") << raw("\xfa\0\0\0\0") << QVariant::fromValue(0.f);
248+
QTest::newRow("0.") << raw("\xfb\0\0\0\0\0\0\0\0") << QVariant(0.);
249+
QTest::newRow("-1.f") << raw("\xfa\xbf\x80\0\0") << QVariant::fromValue(-1.f);
250+
QTest::newRow("-1.") << raw("\xfb\xbf\xf0\0\0\0\0\0\0") << QVariant(-1.);
251+
QTest::newRow("16777215.f") << raw("\xfa\x4b\x7f\xff\xff") << QVariant::fromValue(16777215.f);
252+
QTest::newRow("16777215.") << raw("\xfb\x41\x6f\xff\xff\xe0\0\0\0") << QVariant::fromValue(16777215.);
253+
QTest::newRow("-16777215.f") << raw("\xfa\xcb\x7f\xff\xff") << QVariant(-16777215.f);
254+
QTest::newRow("-16777215.") << raw("\xfb\xc1\x6f\xff\xff\xe0\0\0\0") << QVariant::fromValue(-16777215.);
255+
256+
QTest::newRow("nan_f") << raw("\xfa\x7f\xc0\0\0") << QVariant::fromValue<float>(myNaNf());
257+
QTest::newRow("nan") << raw("\xfb\x7f\xf8\0\0\0\0\0\0") << QVariant(myNaN());
258+
QTest::newRow("-inf_f") << raw("\xfa\xff\x80\0\0") << QVariant::fromValue<float>(myNInff());
259+
QTest::newRow("-inf") << raw("\xfb\xff\xf0\0\0\0\0\0\0") << QVariant(myNInf());
260+
QTest::newRow("+inf_f") << raw("\xfa\x7f\x80\0\0") << QVariant::fromValue<float>(myInff());
261+
QTest::newRow("+inf") << raw("\xfb\x7f\xf0\0\0\0\0\0\0") << QVariant(myInf());
262+
}
263+
264+
void addStringsData()
265+
{
266+
// byte strings
267+
QTest::newRow("emptybytestring") << raw("\x40") << QVariant(QByteArray(""));
268+
QTest::newRow("bytestring1") << raw("\x41 ") << QVariant(QByteArray(" "));
269+
QTest::newRow("bytestring1-nul") << raw("\x41\0") << QVariant(QByteArray("", 1));
270+
QTest::newRow("bytestring5") << raw("\x45Hello") << QVariant(QByteArray("Hello"));
271+
QTest::newRow("bytestring24") << raw("\x58\x18""123456789012345678901234")
272+
<< QVariant(QByteArray("123456789012345678901234"));
273+
QTest::newRow("bytestring256") << raw("\x59\1\0") + QByteArray(256, '3')
274+
<< QVariant(QByteArray(256, '3'));
275+
276+
// text strings
277+
QTest::newRow("emptytextstring") << raw("\x60") << QVariant("");
278+
QTest::newRow("textstring1") << raw("\x61 ") << QVariant(" ");
279+
QTest::newRow("textstring1-nul") << raw("\x61\0") << QVariant(QString::fromLatin1("", 1));
280+
QTest::newRow("textstring5") << raw("\x65Hello") << QVariant("Hello");
281+
QTest::newRow("textstring24") << raw("\x78\x18""123456789012345678901234")
282+
<< QVariant("123456789012345678901234");
283+
QTest::newRow("textstring256") << raw("\x79\1\0") + QByteArray(256, '3')
284+
<< QVariant(QString(256, '3'));
285+
}
286+
287+
void addArraysAndMaps()
288+
{
289+
QTest::newRow("emptyarray") << raw("\x80") << make_list();
290+
QTest::newRow("emptymap") << raw("\xa0") << make_map({});
291+
292+
QTest::newRow("array-0") << raw("\x81\0") << make_list(0);
293+
QTest::newRow("array-{0-0}") << raw("\x82\0\0") << make_list(0, 0);
294+
QTest::newRow("array-Hello") << raw("\x81\x65Hello") << make_list("Hello");
295+
QTest::newRow("array-array-0") << raw("\x81\x81\0") << make_list(make_list(0));
296+
QTest::newRow("array-array-{0-0}") << raw("\x81\x82\0\0") << make_list(make_list(0, 0));
297+
QTest::newRow("array-array-0-0") << raw("\x82\x81\0\0") << make_list(make_list(0),0);
298+
QTest::newRow("array-array-Hello") << raw("\x81\x81\x65Hello") << make_list(make_list("Hello"));
299+
300+
QTest::newRow("map-0:0") << raw("\xa1\0\0") << make_map({{0,0}});
301+
QTest::newRow("map-0:0-1:1") << raw("\xa2\0\0\1\1") << make_map({{0,0}, {1,1}});
302+
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}})}});
303+
304+
QTest::newRow("array-map1") << raw("\x81\xa1\0\0") << make_list(make_map({{0,0}}));
305+
QTest::newRow("array-map2") << raw("\x82\xa1\0\0\xa1\1\1") << make_list(make_map({{0,0}}), make_map({{1,1}}));
306+
307+
QTest::newRow("map-array1") << raw("\xa1\x62oc\x81\0") << make_map({{"oc", make_list(0)}});
308+
QTest::newRow("map-array2") << raw("\xa1\x62oc\x84\0\1\2\3") << make_map({{"oc", make_list(0, 1, 2, 3)}});
309+
QTest::newRow("map-array3") << raw("\xa2\x62oc\x82\0\1\2\3") << make_map({{"oc", make_list(0, 1)}, {2, 3}});
310+
311+
// indeterminate length
312+
QTest::newRow("_emptyarray") << raw("\x9f\xff") << QVariant::fromValue(IndeterminateLengthArray{});
313+
QTest::newRow("_emptymap") << raw("\xbf\xff") << make_ilmap({});
314+
315+
QTest::newRow("_array-0") << raw("\x9f\0\xff") << make_ilarray({0});
316+
QTest::newRow("_array-{0-0}") << raw("\x9f\0\0\xff") << make_ilarray({0, 0});
317+
QTest::newRow("_array-Hello") << raw("\x9f\x65Hello\xff") << make_ilarray({"Hello"});
318+
QTest::newRow("_array-array-0") << raw("\x9f\x81\0\xff") << make_ilarray({make_list(0)});
319+
QTest::newRow("_array-_array-0") << raw("\x9f\x9f\0\xff\xff") << make_ilarray({make_ilarray({0})});
320+
QTest::newRow("_array-_array-{0-0}") << raw("\x9f\x9f\0\0\xff\xff") << make_ilarray({make_ilarray({0, 0})});
321+
QTest::newRow("_array-_array-0-0") << raw("\x9f\x9f\0\xff\0\xff") << make_ilarray({make_ilarray({0}),0});
322+
QTest::newRow("_array-_array-Hello") << raw("\x9f\x9f\x65Hello\xff\xff") << make_ilarray({make_ilarray({"Hello"})});
323+
324+
QTest::newRow("_map-0:0") << raw("\xbf\0\0\xff") << make_ilmap({{0,0}});
325+
QTest::newRow("_map-0:0-1:1") << raw("\xbf\0\0\1\1\xff") << make_ilmap({{0,0}, {1,1}});
326+
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}})}});
327+
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}})}});
328+
329+
QTest::newRow("_array-map1") << raw("\x9f\xa1\0\0\xff") << make_ilarray({make_map({{0,0}})});
330+
QTest::newRow("_array-_map1") << raw("\x9f\xbf\0\0\xff\xff") << make_ilarray({make_ilmap({{0,0}})});
331+
QTest::newRow("_array-map2") << raw("\x9f\xa1\0\0\xa1\1\1\xff") << make_ilarray({make_map({{0,0}}), make_map({{1,1}})});
332+
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}})});
333+
334+
QTest::newRow("_map-array1") << raw("\xbf\x62oc\x81\0\xff") << make_ilmap({{"oc", make_list(0)}});
335+
QTest::newRow("_map-_array1") << raw("\xbf\x62oc\x9f\0\xff\xff") << make_ilmap({{"oc", make_ilarray({0})}});
336+
QTest::newRow("_map-array2") << raw("\xbf\x62oc\x84\0\1\2\3\xff") << make_ilmap({{"oc", make_list(0, 1, 2, 3)}});
337+
QTest::newRow("_map-_array2") << raw("\xbf\x62oc\x9f\0\1\2\3\xff\xff") << make_ilmap({{"oc", make_ilarray({0, 1, 2, 3})}});
338+
QTest::newRow("_map-array3") << raw("\xbf\x62oc\x82\0\1\2\3\xff") << make_ilmap({{"oc", make_list(0, 1)}, {2, 3}});
339+
QTest::newRow("_map-_array3") << raw("\xbf\x62oc\x9f\0\1\xff\2\3\xff") << make_ilmap({{"oc", make_ilarray({0, 1})}, {2, 3}});
340+
341+
// tagged
342+
QTest::newRow("array-1(0)") << raw("\x81\xc1\0") << make_list(QVariant::fromValue(Tag{1, 0}));
343+
QTest::newRow("array-1(map)") << raw("\x81\xc1\xa0") << make_list(QVariant::fromValue(Tag{1, make_map({})}));
344+
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})}});
345+
}
346+

0 commit comments

Comments
 (0)