1/****************************************************************************
2**
3** Copyright (C) 2018 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
27static float myNaNf()
28{
29 uint32_t v = 0x7fc00000;
30 float f;
31 memcpy(dest: &f, src: &v, n: sizeof(f));
32 Q_ASSERT(qIsNaN(f));
33 return f;
34}
35
36static float myInff()
37{
38 uint32_t v = 0x7f800000;
39 float f;
40 memcpy(dest: &f, src: &v, n: sizeof(f));
41 Q_ASSERT(qIsInf(f));
42 return f;
43}
44
45static float myNInff()
46{
47 uint32_t v = 0xff800000;
48 float f;
49 memcpy(dest: &f, src: &v, n: sizeof(f));
50 Q_ASSERT(qIsInf(f));
51 return f;
52}
53
54static double myNaN()
55{
56 uint64_t v = UINT64_C(0x7ff8000000000000);
57 double f;
58 memcpy(dest: &f, src: &v, n: sizeof(f));
59 Q_ASSERT(qIsNaN(f));
60 return f;
61}
62
63static double myInf()
64{
65 uint64_t v = UINT64_C(0x7ff0000000000000);
66 double f;
67 memcpy(dest: &f, src: &v, n: sizeof(f));
68 Q_ASSERT(qIsInf(f));
69 return f;
70}
71
72static double myNInf()
73{
74 uint64_t v = UINT64_C(0xfff0000000000000);
75 double f;
76 memcpy(dest: &f, src: &v, n: sizeof(f));
77 Q_ASSERT(qIsInf(f));
78 return f;
79}
80
81template <size_t N> QByteArray raw(const char (&data)[N])
82{
83 return QByteArray::fromRawData(data, size: N - 1);
84}
85
86struct NegativeInteger { quint64 abs; };
87Q_DECLARE_METATYPE(NegativeInteger)
88
89struct SimpleType { uint8_t type; };
90Q_DECLARE_METATYPE(SimpleType)
91
92struct Float16Standin { uint16_t val; };
93Q_DECLARE_METATYPE(Float16Standin)
94
95struct Tag { CborTag tag; QVariant tagged; };
96Q_DECLARE_METATYPE(Tag)
97
98template <typename... Args>
99QVariant make_list(const Args &... args)
100{
101 return QVariantList{args...};
102}
103
104typedef QVector<QPair<QVariant, QVariant>> Map;
105Q_DECLARE_METATYPE(Map)
106QVariant make_map(const std::initializer_list<QPair<QVariant, QVariant>> &list)
107{
108 return QVariant::fromValue(value: Map(list));
109}
110
111struct IndeterminateLengthArray : QVariantList { using QVariantList::QVariantList; };
112struct IndeterminateLengthMap : Map { using Map::Map; };
113Q_DECLARE_METATYPE(IndeterminateLengthArray)
114Q_DECLARE_METATYPE(IndeterminateLengthMap)
115
116QVariant make_ilarray(const std::initializer_list<QVariant> &list)
117{
118 return QVariant::fromValue(value: IndeterminateLengthArray(list));
119}
120
121QVariant make_ilmap(const std::initializer_list<QPair<QVariant, QVariant>> &list)
122{
123 return QVariant::fromValue(value: IndeterminateLengthMap(list));
124}
125
126void addHalfFloat()
127{
128 QTest::addColumn<QByteArray>(name: "output");
129 QTest::addColumn<unsigned>(name: "rawInput");
130 QTest::addColumn<double>(name: "floatInput");
131
132 QTest::newRow(dataTag: "+0") << raw(data: "\x00\x00") << 0U << 0.0;
133 QTest::newRow(dataTag: "-0") << raw(data: "\x80\x00") << 0x8000U << 0.0;
134
135 QTest::newRow(dataTag: "min.denorm") << raw(data: "\x00\x01") << 1U << ldexp(x: 1.0, exponent: -14) * ldexp(x: 1.0, exponent: -10);
136 QTest::newRow(dataTag: "-min.denorm") << raw(data: "\x80\x01") << 0x8001U << ldexp(x: -1.0, exponent: -14) * ldexp(x: 1.0, exponent: -10);
137
138 QTest::newRow(dataTag: "max.denorm") << raw(data: "\x03\xff") << 0x03ffU << ldexp(x: 1.0, exponent: -14) * (1.0 - ldexp(x: 1.0, exponent: -10));
139 QTest::newRow(dataTag: "-max.denorm") << raw(data: "\x83\xff") << 0x83ffU << ldexp(x: -1.0, exponent: -14) * (1.0 - ldexp(x: 1.0, exponent: -10));
140
141 QTest::newRow(dataTag: "min.norm") << raw(data: "\x04\x00") << 0x0400U << ldexp(x: 1.0, exponent: -14);
142 QTest::newRow(dataTag: "-min.norm") << raw(data: "\x84\x00") << 0x8400U << ldexp(x: -1.0, exponent: -14);
143
144 QTest::newRow(dataTag: "1.0") << raw(data: "\x3c\x00") << 0x3c00U << 1.0;
145 QTest::newRow(dataTag: "-1.0") << raw(data: "\xbc\x00") << 0xbc00U << -1.0;
146
147 QTest::newRow(dataTag: "1.5") << raw(data: "\x3e\x00") << 0x3e00U << 1.5;
148 QTest::newRow(dataTag: "-1.5") << raw(data: "\xbe\x00") << 0xbe00U << -1.5;
149
150 QTest::newRow(dataTag: "max") << raw(data: "\x7b\xff") << 0x7bffU << ldexp(x: 1.0, exponent: 15) * (2.0 - ldexp(x: 1.0, exponent: -10));
151 QTest::newRow(dataTag: "-max") << raw(data: "\xfb\xff") << 0xfbffU << ldexp(x: -1.0, exponent: 15) * (2.0 - ldexp(x: 1.0, exponent: -10));
152
153 QTest::newRow(dataTag: "inf") << raw(data: "\x7c\x00") << 0x7c00U << myInf();
154 QTest::newRow(dataTag: "-inf") << raw(data: "\xfc\x00") << 0xfc00U << myNInf();
155
156 QTest::newRow(dataTag: "nan1") << raw(data: "\x7c\x01") << 0x7c01U << myNaN();
157 QTest::newRow(dataTag: "nan2") << raw(data: "\xfc\x01") << 0xfc01U << myNaN();
158 QTest::newRow(dataTag: "nan3") << raw(data: "\x7e\x00") << 0x7e00U << myNaN();
159 QTest::newRow(dataTag: "nan4") << raw(data: "\xfe\x00") << 0xfe00U << myNaN();
160}
161
162void addColumns()
163{
164 QTest::addColumn<QByteArray>(name: "output");
165 QTest::addColumn<QVariant>(name: "input");
166}
167
168void addFixedData()
169{
170 // unsigned integers
171 QTest::newRow(dataTag: "0U") << raw(data: "\x00") << QVariant(0U);
172 QTest::newRow(dataTag: "1U") << raw(data: "\x01") << QVariant(1U);
173 QTest::newRow(dataTag: "10U") << raw(data: "\x0a") << QVariant(10U);
174 QTest::newRow(dataTag: "23U") << raw(data: "\x17") << QVariant(23U);
175 QTest::newRow(dataTag: "24U") << raw(data: "\x18\x18") << QVariant(24U);
176 QTest::newRow(dataTag: "255U") << raw(data: "\x18\xff") << QVariant(255U);
177 QTest::newRow(dataTag: "256U") << raw(data: "\x19\x01\x00") << QVariant(256U);
178 QTest::newRow(dataTag: "65535U") << raw(data: "\x19\xff\xff") << QVariant(65535U);
179 QTest::newRow(dataTag: "65536U") << raw(data: "\x1a\0\1\x00\x00") << QVariant(65536U);
180 QTest::newRow(dataTag: "4294967295U") << raw(data: "\x1a\xff\xff\xff\xff") << QVariant(4294967295U);
181 QTest::newRow(dataTag: "4294967296U") << raw(data: "\x1b\0\0\0\1\0\0\0\0") << QVariant(Q_UINT64_C(4294967296));
182 QTest::newRow(dataTag: "UINT64_MAX") << raw(data: "\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(dataTag: "0") << raw(data: "\x00") << QVariant(0);
187 QTest::newRow(dataTag: "1") << raw(data: "\x01") << QVariant(1);
188 QTest::newRow(dataTag: "10") << raw(data: "\x0a") << QVariant(10);
189 QTest::newRow(dataTag: "23") << raw(data: "\x17") << QVariant(23);
190 QTest::newRow(dataTag: "24") << raw(data: "\x18\x18") << QVariant(24);
191 QTest::newRow(dataTag: "255") << raw(data: "\x18\xff") << QVariant(255);
192 QTest::newRow(dataTag: "256") << raw(data: "\x19\x01\x00") << QVariant(256);
193 QTest::newRow(dataTag: "65535") << raw(data: "\x19\xff\xff") << QVariant(65535);
194 QTest::newRow(dataTag: "65536") << raw(data: "\x1a\0\1\x00\x00") << QVariant(65536);
195 QTest::newRow(dataTag: "4294967295") << raw(data: "\x1a\xff\xff\xff\xff") << QVariant(Q_INT64_C(4294967295));
196 QTest::newRow(dataTag: "4294967296") << raw(data: "\x1b\0\0\0\1\0\0\0\0") << QVariant(Q_INT64_C(4294967296));
197
198 // signed integers containing negative numbers
199 QTest::newRow(dataTag: "-1") << raw(data: "\x20") << QVariant(-1);
200 QTest::newRow(dataTag: "-2") << raw(data: "\x21") << QVariant(-2);
201 QTest::newRow(dataTag: "-24") << raw(data: "\x37") << QVariant(-24);
202 QTest::newRow(dataTag: "-25") << raw(data: "\x38\x18") << QVariant(-25);
203 QTest::newRow(dataTag: "-UINT8_MAX") << raw(data: "\x38\xff") << QVariant(-256);
204 QTest::newRow(dataTag: "-UINT8_MAX-1") << raw(data: "\x39\x01\x00") << QVariant(-257);
205 QTest::newRow(dataTag: "-UINT16_MAX") << raw(data: "\x39\xff\xff") << QVariant(-65536);
206 QTest::newRow(dataTag: "-UINT16_MAX-1") << raw(data: "\x3a\0\1\x00\x00") << QVariant(-65537);
207 QTest::newRow(dataTag: "-UINT32_MAX") << raw(data: "\x3a\xff\xff\xff\xff") << QVariant(Q_INT64_C(-4294967296));
208 QTest::newRow(dataTag: "-UINT32_MAX-1") << raw(data: "\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>(value: {.abs: v}); };
212 QTest::newRow(dataTag: "negative1") << raw(data: "\x20") << neg(1);
213 QTest::newRow(dataTag: "negative2") << raw(data: "\x21") << neg(2);
214 QTest::newRow(dataTag: "negative24") << raw(data: "\x37") << neg(24);
215 QTest::newRow(dataTag: "negative25") << raw(data: "\x38\x18") << neg(25);
216 QTest::newRow(dataTag: "negativeUINT8_MAX") << raw(data: "\x38\xff") << neg(256);
217 QTest::newRow(dataTag: "negativeUINT8_MAX-1") << raw(data: "\x39\x01\x00") << neg(257);
218 QTest::newRow(dataTag: "negativeUINT16_MAX") << raw(data: "\x39\xff\xff") << neg(65536);
219 QTest::newRow(dataTag: "negativeUINT16_MAX-1") << raw(data: "\x3a\0\1\x00\x00") << neg(65537);
220 QTest::newRow(dataTag: "negativeUINT32_MAX") << raw(data: "\x3a\xff\xff\xff\xff") << neg(Q_UINT64_C(4294967296));
221 QTest::newRow(dataTag: "negativeUINT32_MAX-1") << raw(data: "\x3b\0\0\0\1\0\0\0\0") << neg(Q_UINT64_C(4294967297));
222 QTest::newRow(dataTag: "negativeUINT64_MAX") << raw(data: "\x3b" "\xff\xff\xff\xff" "\xff\xff\xff\xfe")
223 << neg(std::numeric_limits<quint64>::max());
224 QTest::newRow(dataTag: "negativeUINT64_MAX+1") << raw(data: "\x3b" "\xff\xff\xff\xff" "\xff\xff\xff\xff") << neg(0);
225
226 QTest::newRow(dataTag: "simple0") << raw(data: "\xe0") << QVariant::fromValue(value: SimpleType{.type: 0});
227 QTest::newRow(dataTag: "simple19") << raw(data: "\xf3") << QVariant::fromValue(value: SimpleType{.type: 19});
228 QTest::newRow(dataTag: "false") << raw(data: "\xf4") << QVariant(false);
229 QTest::newRow(dataTag: "true") << raw(data: "\xf5") << QVariant(true);
230 QTest::newRow(dataTag: "null") << raw(data: "\xf6") << QVariant::fromValue<void *>(value: nullptr);
231 QTest::newRow(dataTag: "undefined") << raw(data: "\xf7") << QVariant();
232 QTest::newRow(dataTag: "simple32") << raw(data: "\xf8\x20") << QVariant::fromValue(value: SimpleType{.type: 32});
233 QTest::newRow(dataTag: "simple255") << raw(data: "\xf8\xff") << QVariant::fromValue(value: SimpleType{.type: 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(dataTag: "0.f16") << raw(data: "\xf9\0\0") << QVariant::fromValue(value: qfloat16(0));
240 QTest::newRow(dataTag: "-1.f16") << raw(data: "\xf9\xbc\0") << QVariant::fromValue(value: qfloat16(-1));
241 QTest::newRow(dataTag: "1.5f16") << raw(data: "\xf9\x3e\0") << QVariant::fromValue(value: qfloat16(1.5));
242 QTest::newRow(dataTag: "nan_f16") << raw(data: "\xf9\x7e\0") << QVariant::fromValue<qfloat16>(value: myNaNf());
243 QTest::newRow(dataTag: "-inf_f16") << raw(data: "\xf9\xfc\0") << QVariant::fromValue<qfloat16>(value: myNInff());
244 QTest::newRow(dataTag: "+inf_f16") << raw(data: "\xf9\x7c\0") << QVariant::fromValue<qfloat16>(value: myInff());
245#endif
246
247 QTest::newRow(dataTag: "0.f") << raw(data: "\xfa\0\0\0\0") << QVariant::fromValue(value: 0.f);
248 QTest::newRow(dataTag: "0.") << raw(data: "\xfb\0\0\0\0\0\0\0\0") << QVariant(0.);
249 QTest::newRow(dataTag: "-1.f") << raw(data: "\xfa\xbf\x80\0\0") << QVariant::fromValue(value: -1.f);
250 QTest::newRow(dataTag: "-1.") << raw(data: "\xfb\xbf\xf0\0\0\0\0\0\0") << QVariant(-1.);
251 QTest::newRow(dataTag: "16777215.f") << raw(data: "\xfa\x4b\x7f\xff\xff") << QVariant::fromValue(value: 16777215.f);
252 QTest::newRow(dataTag: "16777215.") << raw(data: "\xfb\x41\x6f\xff\xff\xe0\0\0\0") << QVariant::fromValue(value: 16777215.);
253 QTest::newRow(dataTag: "-16777215.f") << raw(data: "\xfa\xcb\x7f\xff\xff") << QVariant(-16777215.f);
254 QTest::newRow(dataTag: "-16777215.") << raw(data: "\xfb\xc1\x6f\xff\xff\xe0\0\0\0") << QVariant::fromValue(value: -16777215.);
255
256 QTest::newRow(dataTag: "nan_f") << raw(data: "\xfa\x7f\xc0\0\0") << QVariant::fromValue<float>(value: myNaNf());
257 QTest::newRow(dataTag: "nan") << raw(data: "\xfb\x7f\xf8\0\0\0\0\0\0") << QVariant(myNaN());
258 QTest::newRow(dataTag: "-inf_f") << raw(data: "\xfa\xff\x80\0\0") << QVariant::fromValue<float>(value: myNInff());
259 QTest::newRow(dataTag: "-inf") << raw(data: "\xfb\xff\xf0\0\0\0\0\0\0") << QVariant(myNInf());
260 QTest::newRow(dataTag: "+inf_f") << raw(data: "\xfa\x7f\x80\0\0") << QVariant::fromValue<float>(value: myInff());
261 QTest::newRow(dataTag: "+inf") << raw(data: "\xfb\x7f\xf0\0\0\0\0\0\0") << QVariant(myInf());
262}
263
264void addStringsData()
265{
266 // byte strings
267 QTest::newRow(dataTag: "emptybytestring") << raw(data: "\x40") << QVariant(QByteArray(""));
268 QTest::newRow(dataTag: "bytestring1") << raw(data: "\x41 ") << QVariant(QByteArray(" "));
269 QTest::newRow(dataTag: "bytestring1-nul") << raw(data: "\x41\0") << QVariant(QByteArray("", 1));
270 QTest::newRow(dataTag: "bytestring5") << raw(data: "\x45Hello") << QVariant(QByteArray("Hello"));
271 QTest::newRow(dataTag: "bytestring24") << raw(data: "\x58\x18""123456789012345678901234")
272 << QVariant(QByteArray("123456789012345678901234"));
273 QTest::newRow(dataTag: "bytestring256") << raw(data: "\x59\1\0") + QByteArray(256, '3')
274 << QVariant(QByteArray(256, '3'));
275
276 // text strings
277 QTest::newRow(dataTag: "emptytextstring") << raw(data: "\x60") << QVariant("");
278 QTest::newRow(dataTag: "textstring1") << raw(data: "\x61 ") << QVariant(" ");
279 QTest::newRow(dataTag: "textstring1-nul") << raw(data: "\x61\0") << QVariant(QString::fromLatin1(str: "", size: 1));
280 QTest::newRow(dataTag: "textstring5") << raw(data: "\x65Hello") << QVariant("Hello");
281 QTest::newRow(dataTag: "textstring24") << raw(data: "\x78\x18""123456789012345678901234")
282 << QVariant("123456789012345678901234");
283 QTest::newRow(dataTag: "textstring256") << raw(data: "\x79\1\0") + QByteArray(256, '3')
284 << QVariant(QString(256, '3'));
285}
286
287void addArraysAndMaps()
288{
289 QTest::newRow(dataTag: "emptyarray") << raw(data: "\x80") << make_list();
290 QTest::newRow(dataTag: "emptymap") << raw(data: "\xa0") << make_map(list: {});
291
292 QTest::newRow(dataTag: "array-0") << raw(data: "\x81\0") << make_list(args: 0);
293 QTest::newRow(dataTag: "array-{0-0}") << raw(data: "\x82\0\0") << make_list(args: 0, args: 0);
294 QTest::newRow(dataTag: "array-Hello") << raw(data: "\x81\x65Hello") << make_list(args: "Hello");
295 QTest::newRow(dataTag: "array-array-0") << raw(data: "\x81\x81\0") << make_list(args: make_list(args: 0));
296 QTest::newRow(dataTag: "array-array-{0-0}") << raw(data: "\x81\x82\0\0") << make_list(args: make_list(args: 0, args: 0));
297 QTest::newRow(dataTag: "array-array-0-0") << raw(data: "\x82\x81\0\0") << make_list(args: make_list(args: 0),args: 0);
298 QTest::newRow(dataTag: "array-array-Hello") << raw(data: "\x81\x81\x65Hello") << make_list(args: make_list(args: "Hello"));
299
300 QTest::newRow(dataTag: "map-0:0") << raw(data: "\xa1\0\0") << make_map(list: {{0,0}});
301 QTest::newRow(dataTag: "map-0:0-1:1") << raw(data: "\xa2\0\0\1\1") << make_map(list: {{0,0}, {1,1}});
302 QTest::newRow(dataTag: "map-0:{map-0:0-1:1}") << raw(data: "\xa1\0\xa2\0\0\1\1") << make_map(list: {{0, make_map(list: {{0,0}, {1,1}})}});
303
304 QTest::newRow(dataTag: "array-map1") << raw(data: "\x81\xa1\0\0") << make_list(args: make_map(list: {{0,0}}));
305 QTest::newRow(dataTag: "array-map2") << raw(data: "\x82\xa1\0\0\xa1\1\1") << make_list(args: make_map(list: {{0,0}}), args: make_map(list: {{1,1}}));
306
307 QTest::newRow(dataTag: "map-array1") << raw(data: "\xa1\x62oc\x81\0") << make_map(list: {{"oc", make_list(args: 0)}});
308 QTest::newRow(dataTag: "map-array2") << raw(data: "\xa1\x62oc\x84\0\1\2\3") << make_map(list: {{"oc", make_list(args: 0, args: 1, args: 2, args: 3)}});
309 QTest::newRow(dataTag: "map-array3") << raw(data: "\xa2\x62oc\x82\0\1\2\3") << make_map(list: {{"oc", make_list(args: 0, args: 1)}, {2, 3}});
310
311 // indeterminate length
312 QTest::newRow(dataTag: "_emptyarray") << raw(data: "\x9f\xff") << QVariant::fromValue(value: IndeterminateLengthArray{});
313 QTest::newRow(dataTag: "_emptymap") << raw(data: "\xbf\xff") << make_ilmap(list: {});
314
315 QTest::newRow(dataTag: "_array-0") << raw(data: "\x9f\0\xff") << make_ilarray(list: {0});
316 QTest::newRow(dataTag: "_array-{0-0}") << raw(data: "\x9f\0\0\xff") << make_ilarray(list: {0, 0});
317 QTest::newRow(dataTag: "_array-Hello") << raw(data: "\x9f\x65Hello\xff") << make_ilarray(list: {"Hello"});
318 QTest::newRow(dataTag: "_array-array-0") << raw(data: "\x9f\x81\0\xff") << make_ilarray(list: {make_list(args: 0)});
319 QTest::newRow(dataTag: "_array-_array-0") << raw(data: "\x9f\x9f\0\xff\xff") << make_ilarray(list: {make_ilarray(list: {0})});
320 QTest::newRow(dataTag: "_array-_array-{0-0}") << raw(data: "\x9f\x9f\0\0\xff\xff") << make_ilarray(list: {make_ilarray(list: {0, 0})});
321 QTest::newRow(dataTag: "_array-_array-0-0") << raw(data: "\x9f\x9f\0\xff\0\xff") << make_ilarray(list: {make_ilarray(list: {0}),0});
322 QTest::newRow(dataTag: "_array-_array-Hello") << raw(data: "\x9f\x9f\x65Hello\xff\xff") << make_ilarray(list: {make_ilarray(list: {"Hello"})});
323
324 QTest::newRow(dataTag: "_map-0:0") << raw(data: "\xbf\0\0\xff") << make_ilmap(list: {{0,0}});
325 QTest::newRow(dataTag: "_map-0:0-1:1") << raw(data: "\xbf\0\0\1\1\xff") << make_ilmap(list: {{0,0}, {1,1}});
326 QTest::newRow(dataTag: "_map-0:{map-0:0-1:1}") << raw(data: "\xbf\0\xa2\0\0\1\1\xff") << make_ilmap(list: {{0, make_map(list: {{0,0}, {1,1}})}});
327 QTest::newRow(dataTag: "_map-0:{_map-0:0-1:1}") << raw(data: "\xbf\0\xbf\0\0\1\1\xff\xff") << make_ilmap(list: {{0, make_ilmap(list: {{0,0}, {1,1}})}});
328
329 QTest::newRow(dataTag: "_array-map1") << raw(data: "\x9f\xa1\0\0\xff") << make_ilarray(list: {make_map(list: {{0,0}})});
330 QTest::newRow(dataTag: "_array-_map1") << raw(data: "\x9f\xbf\0\0\xff\xff") << make_ilarray(list: {make_ilmap(list: {{0,0}})});
331 QTest::newRow(dataTag: "_array-map2") << raw(data: "\x9f\xa1\0\0\xa1\1\1\xff") << make_ilarray(list: {make_map(list: {{0,0}}), make_map(list: {{1,1}})});
332 QTest::newRow(dataTag: "_array-_map2") << raw(data: "\x9f\xbf\0\0\xff\xbf\1\1\xff\xff") << make_ilarray(list: {make_ilmap(list: {{0,0}}), make_ilmap(list: {{1,1}})});
333
334 QTest::newRow(dataTag: "_map-array1") << raw(data: "\xbf\x62oc\x81\0\xff") << make_ilmap(list: {{"oc", make_list(args: 0)}});
335 QTest::newRow(dataTag: "_map-_array1") << raw(data: "\xbf\x62oc\x9f\0\xff\xff") << make_ilmap(list: {{"oc", make_ilarray(list: {0})}});
336 QTest::newRow(dataTag: "_map-array2") << raw(data: "\xbf\x62oc\x84\0\1\2\3\xff") << make_ilmap(list: {{"oc", make_list(args: 0, args: 1, args: 2, args: 3)}});
337 QTest::newRow(dataTag: "_map-_array2") << raw(data: "\xbf\x62oc\x9f\0\1\2\3\xff\xff") << make_ilmap(list: {{"oc", make_ilarray(list: {0, 1, 2, 3})}});
338 QTest::newRow(dataTag: "_map-array3") << raw(data: "\xbf\x62oc\x82\0\1\2\3\xff") << make_ilmap(list: {{"oc", make_list(args: 0, args: 1)}, {2, 3}});
339 QTest::newRow(dataTag: "_map-_array3") << raw(data: "\xbf\x62oc\x9f\0\1\xff\2\3\xff") << make_ilmap(list: {{"oc", make_ilarray(list: {0, 1})}, {2, 3}});
340
341 // tagged
342 QTest::newRow(dataTag: "array-1(0)") << raw(data: "\x81\xc1\0") << make_list(args: QVariant::fromValue(value: Tag{.tag: 1, .tagged: 0}));
343 QTest::newRow(dataTag: "array-1(map)") << raw(data: "\x81\xc1\xa0") << make_list(args: QVariant::fromValue(value: Tag{.tag: 1, .tagged: make_map(list: {})}));
344 QTest::newRow(dataTag: "map-1(2):3(4)") << raw(data: "\xa1\xc1\2\xc3\4") << make_map(list: {{QVariant::fromValue(value: Tag{.tag: 1, .tagged: 2}), QVariant::fromValue(value: Tag{.tag: 3, .tagged: 4})}});
345}
346
347

source code of qtbase/src/3rdparty/tinycbor/tests/encoder/data.cpp