source: CLRX/CLRadeonExtender/trunk/tests/amdbin/ROCmMsgPack.cpp @ 4921

Last change on this file since 4921 was 4921, checked in by matszpk, 8 months ago

CLRadeonExtender: ROCm: Fixes in testsuite. Fixes in MsgPack? parser.

File size: 91.8 KB
Line 
1/*
2 *  CLRadeonExtender - Unofficial OpenCL Radeon Extensions Library
3 *  Copyright (C) 2014-2018 Mateusz Szpakowski
4 *
5 *  This library is free software; you can redistribute it and/or
6 *  modify it under the terms of the GNU Lesser General Public
7 *  License as published by the Free Software Foundation; either
8 *  version 2.1 of the License, or (at your option) any later version.
9 *
10 *  This library is distributed in the hope that it will be useful,
11 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13 *  Lesser General Public License for more details.
14 *
15 *  You should have received a copy of the GNU Lesser General Public
16 *  License along with this library; if not, write to the Free Software
17 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
18 */
19
20#include <CLRX/Config.h>
21#include <iostream>
22#include <sstream>
23#include <string>
24#include <cstring>
25#include <memory>
26#include <CLRX/utils/Containers.h>
27#include <CLRX/amdbin/ROCmBinaries.h>
28#include "../TestUtils.h"
29
30using namespace CLRX;
31
32static void testMsgPackBytes()
33{
34    const cxbyte tc0[2] = { 0x91, 0xc0 };
35    const cxbyte* dataPtr;
36    // parseNil
37    dataPtr = tc0;
38    {
39        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc0));
40        arrParser.parseNil();
41        assertValue("MsgPack0", "tc0: DataPtr", dataPtr, tc0 + sizeof(tc0));
42    }
43    dataPtr = tc0;
44    {
45        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc0)-1);
46        assertCLRXException("MsgPack0", "tc0_1.Ex", "MsgPack: Can't parse nil value",
47                    [&arrParser]() { arrParser.parseNil(); });
48        assertValue("MsgPack0", "tc0_1.DataPtr", dataPtr, tc0 + sizeof(tc0)-1);
49    }
50   
51    // parseBool
52    const cxbyte tc1[2] = { 0x91, 0xc2 };
53    dataPtr = tc1;
54    {
55        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc1));
56        assertTrue("MsgPack0", "tc1.value0", !arrParser.parseBool());
57        assertValue("MsgPack0", "tc1.DataPtr", dataPtr, tc1 + sizeof(tc1));
58    }
59    dataPtr = tc1;
60    {
61        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc1)-1);
62        assertCLRXException("MsgPack0", "tc1_1.Ex", "MsgPack: Can't parse bool value",
63                    [&arrParser]() { arrParser.parseBool(); });
64        assertValue("MsgPack0", "tc1_1.DataPtr", dataPtr, tc1 + sizeof(tc1)-1);
65    }
66   
67    const cxbyte tc2[2] = { 0x91, 0xc3 };
68    dataPtr = tc2;
69    {
70        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc2));
71        assertTrue("MsgPack0", "tc2.value0", arrParser.parseBool());
72        assertValue("MsgPack0", "tc2.DataPtr", dataPtr, tc2 + sizeof(tc2));
73    }
74   
75    dataPtr = tc0;
76    {
77        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc0));
78        assertCLRXException("MsgPack0", "tc3.Ex", "MsgPack: Can't parse bool value",
79                    [&arrParser]() { arrParser.parseBool(); });
80        assertValue("MsgPack0", "tc3.DataPtr", dataPtr, tc0 + sizeof(tc0)-1);
81    }
82   
83    // parseInteger
84    const cxbyte tc4[2] = { 0x91, 0x21 };
85    dataPtr = tc4;
86    {
87        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc4));
88        assertValue("MsgPack0", "tc4.value0", uint64_t(33),
89                   arrParser.parseInteger(MSGPACK_WS_UNSIGNED));
90        assertValue("MsgPack0", "tc4.DataPtr", dataPtr, tc4 + sizeof(tc4));
91    }
92    dataPtr = tc4;
93    {
94        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc4)-1);
95        assertCLRXException("MsgPack0", "tc4_1.Ex", "MsgPack: Can't parse integer value",
96                    [&arrParser]() { arrParser.parseInteger(MSGPACK_WS_UNSIGNED); });
97        assertValue("MsgPack0", "tc4_1.DataPtr", dataPtr, tc4 + sizeof(tc4)-1);
98    }
99    const cxbyte tc5[2] = { 0x91, 0x5b };
100    dataPtr = tc5;
101    {
102        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc5));
103        assertValue("MsgPack0", "tc5.value0", uint64_t(91),
104                   arrParser.parseInteger(MSGPACK_WS_UNSIGNED));
105        assertValue("MsgPack0", "tc5.DataPtr", dataPtr, tc5 + sizeof(tc5));
106    }
107    const cxbyte tc6[2] = { 0x91, 0xe9 };
108    dataPtr = tc6;
109    {
110        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc6));
111        assertValue("MsgPack0", "tc6.value0", uint64_t(-23),
112                   arrParser.parseInteger(MSGPACK_WS_SIGNED));
113        assertValue("MsgPack0", "tc6.DataPtr", dataPtr, tc6 + sizeof(tc6));
114    }
115    const cxbyte tc6_1[2] = { 0x91, 0xe0 };
116    dataPtr = tc6_1;
117    {
118        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc6_1));
119        assertValue("MsgPack0", "tc6_1.value0", uint64_t(-32),
120                   arrParser.parseInteger(MSGPACK_WS_SIGNED));
121        assertValue("MsgPack0", "tc6_1.DataPtr", dataPtr, tc6_1 + sizeof(tc6_1));
122    }
123    // longer integers
124    const cxbyte tc7[3] = { 0x91, 0xcc, 0x4d };
125    dataPtr = tc7;
126    {
127        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc7));
128        assertValue("MsgPack0", "tc7.value0", uint64_t(77),
129                   arrParser.parseInteger(MSGPACK_WS_UNSIGNED));
130        assertValue("MsgPack0", "tc7.DataPtr", dataPtr, tc7 + sizeof(tc7));
131    }
132    const cxbyte tc7_1[3] = { 0x91, 0xcc, 0xba };
133    dataPtr = tc7_1;
134    {
135        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc7_1));
136        assertValue("MsgPack0", "tc7_1.value0", uint64_t(0xba),
137                   arrParser.parseInteger(MSGPACK_WS_UNSIGNED));
138        assertValue("MsgPack0", "tc7_1.DataPtr", dataPtr, tc7_1 + sizeof(tc7_1));
139    }
140    const cxbyte tc7_2[2] = { 0x91, 0xcc };
141    dataPtr = tc7_2;
142    {
143        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc7_2));
144        assertCLRXException("MsgPack0", "tc7_2.Ex", "MsgPack: Can't parse integer value",
145                    [&arrParser]() { arrParser.parseInteger(MSGPACK_WS_UNSIGNED); });
146        assertValue("MsgPack0", "tc7_2.DataPtr", dataPtr, tc7_2 + sizeof(tc7_2));
147    }
148    const cxbyte tc8[3] = { 0x91, 0xd0, 0x4d };
149    dataPtr = tc8;
150    {
151        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc8));
152        assertValue("MsgPack0", "tc8.value0", uint64_t(77),
153                   arrParser.parseInteger(MSGPACK_WS_SIGNED));
154        assertValue("MsgPack0", "tc8.DataPtr", dataPtr, tc8 + sizeof(tc8));
155    }
156    const cxbyte tc8_1[3] = { 0x91, 0xd0, 0xba };
157    dataPtr = tc8_1;
158    {
159        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc8_1));
160        assertValue("MsgPack0", "tc8_1.value0", uint64_t(-70),
161                   arrParser.parseInteger(MSGPACK_WS_SIGNED));
162        assertValue("MsgPack0", "tc8_1.DataPtr", dataPtr, tc8_1 + sizeof(tc8_1));
163    }
164    dataPtr = tc8_1;
165    {
166        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc8_1));
167        assertCLRXException("MsgPack0", "tc8_2.Ex",
168                    "MsgPack: Negative value for unsigned integer",
169                    [&arrParser]() { arrParser.parseInteger(MSGPACK_WS_UNSIGNED); });
170        assertValue("MsgPack0", "tc8_2.DataPtr", dataPtr, tc8_1 + sizeof(tc8_1));
171    }
172    // 16-bit integers
173    const cxbyte tc9[4] = { 0x91, 0xcd, 0x1c, 0x37 };
174    dataPtr = tc9;
175    {
176        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc9));
177        assertValue("MsgPack0", "tc9.value0", uint64_t(0x1c37),
178                   arrParser.parseInteger(MSGPACK_WS_UNSIGNED));
179        assertValue("MsgPack0", "tc9.DataPtr", dataPtr, tc9 + sizeof(tc9));
180    }
181    const cxbyte tc9_1[4] = { 0x91, 0xcd, 0xb3, 0x7e };
182    dataPtr = tc9_1;
183    {
184        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc9_1));
185        assertValue("MsgPack0", "tc9_1.value0", uint64_t(0xb37e),
186                   arrParser.parseInteger(MSGPACK_WS_UNSIGNED));
187        assertValue("MsgPack0", "tc9_1.DataPtr", dataPtr, tc9_1 + sizeof(tc9_1));
188    }
189    const cxbyte tc9_2[3] = { 0x91, 0xcd, 0x7e };
190    dataPtr = tc9_2;
191    {
192        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc9_2));
193        assertCLRXException("MsgPack0", "tc9_2.Ex", "MsgPack: Can't parse integer value",
194                    [&arrParser]() { arrParser.parseInteger(MSGPACK_WS_UNSIGNED); });
195        assertValue("MsgPack0", "tc9_2.DataPtr", dataPtr, tc9_2 + sizeof(tc9_2)-1);
196    }
197    const cxbyte tc9_3[2] = { 0x91, 0xcd };
198    dataPtr = tc9_3;
199    {
200        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc9_3));
201        assertCLRXException("MsgPack0", "tc9_3.Ex", "MsgPack: Can't parse integer value",
202                    [&arrParser]() { arrParser.parseInteger(MSGPACK_WS_UNSIGNED); });
203        assertValue("MsgPack0", "tc9_3.DataPtr", dataPtr, tc9_3 + sizeof(tc9_3));
204    }
205    const cxbyte tc10[4] = { 0x91, 0xd1, 0x1c, 0x37 };
206    dataPtr = tc10;
207    {
208        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc10));
209        assertValue("MsgPack0", "tc10.value0", uint64_t(0x1c37),
210                   arrParser.parseInteger(MSGPACK_WS_SIGNED));
211        assertValue("MsgPack0", "tc10.DataPtr", dataPtr, tc10 + sizeof(tc10));
212    }
213    const cxbyte tc10_1[4] = { 0x91, 0xd1, 0xb3, 0x7e };
214    dataPtr = tc10_1;
215    {
216        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc10_1));
217        assertValue("MsgPack0", "tc10_1.value0", uint64_t(0)+int16_t(0xb37e),
218                   arrParser.parseInteger(MSGPACK_WS_SIGNED));
219        assertValue("MsgPack0", "tc10_1.DataPtr", dataPtr, tc10_1 + sizeof(tc10_1));
220    }
221    dataPtr = tc10_1;
222    {
223        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc10_1));
224        assertCLRXException("MsgPack0", "tc10_2.Ex",
225                    "MsgPack: Negative value for unsigned integer",
226                    [&arrParser]() { arrParser.parseInteger(MSGPACK_WS_UNSIGNED); });
227        assertValue("MsgPack0", "tc10_2.DataPtr", dataPtr, tc10_1 + sizeof(tc10_1));
228    }
229    const cxbyte tc10_3[3] = { 0x91, 0xcd, 0x7e };
230    dataPtr = tc10_3;
231    {
232        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc10_3));
233        assertCLRXException("MsgPack0", "tc10_3.Ex", "MsgPack: Can't parse integer value",
234                    [&arrParser]() { arrParser.parseInteger(MSGPACK_WS_SIGNED); });
235        assertValue("MsgPack0", "tc10_3.DataPtr", dataPtr, tc10_3+ sizeof(tc10_3)-1);
236    }
237    // 32-bit integers
238    const cxbyte tc11[6] = { 0x91, 0xce, 0x2e, 0x41, 0x96, 0xbe };
239    dataPtr = tc11;
240    {
241        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc11));
242        assertValue("MsgPack0", "tc11.value0", uint64_t(0x2e4196beU),
243                   arrParser.parseInteger(MSGPACK_WS_UNSIGNED));
244        assertValue("MsgPack0", "tc11.DataPtr", dataPtr, tc11 + sizeof(tc11));
245    }
246    const cxbyte tc11_1[6] = { 0x91, 0xce, 0xda, 0x42, 0x96, 0xbe };
247    dataPtr = tc11_1;
248    {
249        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc11_1));
250        assertValue("MsgPack0", "tc11_1.value0", uint64_t(0xda4296beU),
251                   arrParser.parseInteger(MSGPACK_WS_UNSIGNED));
252        assertValue("MsgPack0", "tc11_1.DataPtr", dataPtr, tc11_1 + sizeof(tc11_1));
253    }
254    for (cxuint i = 1; i <= 3; i++)
255    {
256        dataPtr = tc11_1;
257        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc11_1)-i);
258        assertCLRXException("MsgPack0", "tc11_2.Ex", "MsgPack: Can't parse integer value",
259                    [&arrParser]() { arrParser.parseInteger(MSGPACK_WS_UNSIGNED); });
260        assertValue("MsgPack0", "tc11_2.DataPtr", dataPtr, tc11_1 + 2);
261    }
262    const cxbyte tc12[6] = { 0x91, 0xd2, 0x2e, 0x41, 0x96, 0xbe };
263    dataPtr = tc12;
264    {
265        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc12));
266        assertValue("MsgPack0", "tc12.value0", uint64_t(0x2e4196beU),
267                   arrParser.parseInteger(MSGPACK_WS_SIGNED));
268        assertValue("MsgPack0", "tc12.DataPtr", dataPtr, tc12 + sizeof(tc12));
269    }
270    for (cxuint i = 1; i <= 3; i++)
271    {
272        dataPtr = tc12;
273        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc12)-i);
274        assertCLRXException("MsgPack0", "tc12_1.Ex", "MsgPack: Can't parse integer value",
275                    [&arrParser]() { arrParser.parseInteger(MSGPACK_WS_SIGNED); });
276        assertValue("MsgPack0", "tc12_1.DataPtr", dataPtr, tc12 + 2);
277    }
278    const cxbyte tc12_2[6] = { 0x91, 0xd2, 0xc1, 0x79, 0x11, 0xaf };
279    dataPtr = tc12_2;
280    {
281        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc12_2));
282        assertValue("MsgPack0", "tc12_2.value0", uint64_t(0)+int32_t(0xc17911afU),
283                   arrParser.parseInteger(MSGPACK_WS_SIGNED));
284        assertValue("MsgPack0", "tc12_2.DataPtr", dataPtr, tc12_2 + sizeof(tc12_2));
285    }
286    dataPtr = tc12_2;
287    {
288        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc12_2));
289        assertCLRXException("MsgPack0", "tc12_3.Ex",
290                    "MsgPack: Negative value for unsigned integer",
291                    [&arrParser]() { arrParser.parseInteger(MSGPACK_WS_UNSIGNED); });
292        assertValue("MsgPack0", "tc12_3.DataPtr", dataPtr, tc12_2 + sizeof(tc12_2));
293    }
294    // 64-bit integers
295    const cxbyte tc13[10] = { 0x91, 0xcf, 0x62, 0x1e, 0xd9, 0x13, 0x4b, 0xf1, 0x3a, 0x11 };
296    dataPtr = tc13;
297    {
298        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc13));
299        assertValue("MsgPack0", "tc13.value0", uint64_t(0x621ed9134bf13a11ULL),
300                   arrParser.parseInteger(MSGPACK_WS_UNSIGNED));
301        assertValue("MsgPack0", "tc13.DataPtr", dataPtr, tc13 + sizeof(tc13));
302    }
303    const cxbyte tc13_1[10] = { 0x91, 0xcf, 0xd7, 0x1e, 0xd9, 0x13, 0x4b,
304                            0xf1, 0x3a, 0x14 };
305    dataPtr = tc13_1;
306    {
307        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc13_1));
308        assertValue("MsgPack0", "tc13_1.value0", uint64_t(0xd71ed9134bf13a14ULL),
309                   arrParser.parseInteger(MSGPACK_WS_UNSIGNED));
310        assertValue("MsgPack0", "tc13_1.DataPtr", dataPtr, tc13_1 + sizeof(tc13_1));
311    }
312    for (cxuint i = 1; i <= 7; i++)
313    {
314        dataPtr = tc13_1;
315        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc13_1)-i);
316        assertCLRXException("MsgPack0", "tc13_2.Ex", "MsgPack: Can't parse integer value",
317                    [&arrParser]() { arrParser.parseInteger(MSGPACK_WS_UNSIGNED); });
318        assertValue("MsgPack0", "tc13_2.DataPtr", dataPtr, tc13_1 + 2);
319    }
320    dataPtr = tc13_1;
321    {
322        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc13_1));
323        assertCLRXException("MsgPack0", "tc13_3.Ex",
324                    "MsgPack: Positive value out of range for signed integer",
325                    [&arrParser]() { arrParser.parseInteger(MSGPACK_WS_SIGNED); });
326        assertValue("MsgPack0", "tc13_3.DataPtr", dataPtr, tc13_1 + sizeof(tc13_1));
327    }
328    const cxbyte tc14[10] = { 0x91, 0xd3, 0x62, 0x1e, 0xd9, 0x13, 0x4b, 0xf1, 0x3a, 0x17 };
329    dataPtr = tc14;
330    {
331        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc14));
332        assertValue("MsgPack0", "tc14.value0", uint64_t(0x621ed9134bf13a17ULL),
333                   arrParser.parseInteger(MSGPACK_WS_SIGNED));
334        assertValue("MsgPack0", "tc14.DataPtr", dataPtr, tc14 + sizeof(tc14));
335    }
336    const cxbyte tc14_1[10] = { 0x91, 0xd3, 0xd7, 0x1e, 0xd9, 0x13, 0x4b,
337                            0xf1, 0x3a, 0x14 };
338    dataPtr = tc14_1;
339    {
340        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc14_1));
341        assertValue("MsgPack0", "tc14_1.value0", uint64_t(0xd71ed9134bf13a14ULL),
342                   arrParser.parseInteger(MSGPACK_WS_SIGNED));
343        assertValue("MsgPack0", "tc14_1.DataPtr", dataPtr, tc14_1 + sizeof(tc14_1));
344    }
345    for (cxuint i = 1; i <= 7; i++)
346    {
347        dataPtr = tc14_1;
348        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc14_1)-i);
349        assertCLRXException("MsgPack0", "tc14_2.Ex", "MsgPack: Can't parse integer value",
350                    [&arrParser]() { arrParser.parseInteger(MSGPACK_WS_SIGNED); });
351        assertValue("MsgPack0", "tc14_2.DataPtr", dataPtr, tc14_1 + 2);
352    }
353   
354    // parseFloat
355    const cxbyte tc15[6] = { 0x91, 0xca, 0x42, 0x76, 0x9c, 0xf3 };
356    dataPtr = tc15;
357    {
358        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc15));
359        assertValue("MsgPack0", "tc15.value0", double(61.653271f), arrParser.parseFloat());
360        assertValue("MsgPack0", "tc15.DataPtr", dataPtr, tc15 + sizeof(tc15));
361    }
362    for (cxuint i = 1; i <= 3; i++)
363    {
364        dataPtr = tc15;
365        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc15)-i);
366        assertCLRXException("MsgPack0", "tc15_1.Ex", "MsgPack: Can't parse float value",
367                    [&arrParser]() { arrParser.parseFloat(); });
368        assertValue("MsgPack0", "tc15_1.DataPtr", dataPtr, tc15 + 2);
369    }
370    const cxbyte tc15_2[6] = { 0x91, 0xca, 0xc2, 0x76, 0x9c, 0xf3 };
371    dataPtr = tc15_2;
372    {
373        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc15_2));
374        assertValue("MsgPack0", "tc15_2.value0", double(-61.653271f),
375                            arrParser.parseFloat());
376        assertValue("MsgPack0", "tc15_2.DataPtr", dataPtr, tc15_2 + sizeof(tc15_2));
377    }
378    const cxbyte tc16[10] = { 0x91, 0xcb, 0x40, 0x8d, 0xd1, 0x3c, 0x99, 0x43, 0x0b, 0xa3 };
379    dataPtr = tc16;
380    {
381        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc16));
382        assertValue("MsgPack0", "tc16.value0", double(954.1545891988683663),
383                    arrParser.parseFloat());
384        assertValue("MsgPack0", "tc16.DataPtr", dataPtr, tc16 + sizeof(tc16));
385    }
386    for (cxuint i = 1; i <= 7; i++)
387    {
388        dataPtr = tc16;
389        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc16)-i);
390        assertCLRXException("MsgPack0", "tc16_1.Ex", "MsgPack: Can't parse float value",
391                    [&arrParser]() { arrParser.parseFloat(); });
392        assertValue("MsgPack0", "tc16_1.DataPtr", dataPtr, tc16 + 2);
393    }
394    const cxbyte tc16_1[10] = { 0x91, 0xcb, 0xc0, 0x8d, 0xd1, 0x3c, 0x99,
395                    0x43, 0x0b, 0xa3 };
396    dataPtr = tc16_1;
397    {
398        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc16_1));
399        assertValue("MsgPack0", "tc16_1.value0", double(-954.1545891988683663),
400                    arrParser.parseFloat());
401        assertValue("MsgPack0", "tc16_1.DataPtr", dataPtr, tc16_1 + sizeof(tc16_1));
402    }
403   
404    // parseData
405    const cxbyte tc17[8] = { 0x91, 0xc4, 0x05, 0x91, 0xff, 0xa1, 0x5e, 0x1b };
406    dataPtr = tc17;
407    {
408        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc17));
409        assertArray("MsgPack0", "tc17.value", Array<cxbyte>(tc17+3, tc17+sizeof(tc17)),
410                        arrParser.parseData());
411        assertValue("MsgPack0", "tc17.DataPtr", dataPtr, tc17 + sizeof(tc17));
412    }
413    for (cxuint i = 1; i <= 5; i ++)
414    {
415        dataPtr = tc17;
416        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc17)-i);
417        assertCLRXException("MsgPack0", "tc17_1.Ex", "MsgPack: Can't parse byte-array",
418                    [&arrParser]() { arrParser.parseData(); });
419        assertValue("MsgPack0", "tc17_1.DataPtr", dataPtr, tc17 + 3);
420    }
421    dataPtr = tc17;
422    {
423        MsgPackArrayParser arrParser(dataPtr, dataPtr + 2);
424        assertCLRXException("MsgPack0", "tc17_2.Ex", "MsgPack: Can't parse byte-array size",
425                    [&arrParser]() { arrParser.parseData(); });
426        assertValue("MsgPack0", "tc17_2.DataPtr", dataPtr, tc17 + 2);
427    }
428    // longer data (16-bit size)
429    {
430        Array<cxbyte> tc18(4 + 12615);
431        tc18[0] = 0x91;
432        tc18[1] = 0xc5;
433        tc18[2] = (12615>>8);
434        tc18[3] = (12615&0xff);
435        for (cxuint i = 0; i < tc18.size()-4; i++)
436            tc18[i+4] = ((i*0x71f)^i) + (12342%(i+1));
437        dataPtr = tc18.data();
438        const cxbyte* dataEnd = tc18.end();
439        MsgPackArrayParser arrParser(dataPtr, dataPtr + tc18.size());
440        assertArray("MsgPack0", "tc18.value", Array<cxbyte>(tc18.begin()+4, tc18.end()),
441                    arrParser.parseData());
442        assertValue("MsgPack0", "tc18.DataPtr", dataPtr, dataEnd);
443        for (cxuint i = 1; i <= 5; i ++)
444        {
445            dataPtr = tc18.data();
446            dataEnd = tc18.begin()+4;
447            MsgPackArrayParser arrParser(dataPtr, dataPtr + tc18.size()-i);
448            assertCLRXException("MsgPack0", "tc18_1.Ex", "MsgPack: Can't parse byte-array",
449                        [&arrParser]() { arrParser.parseData(); });
450            assertValue("MsgPack0", "tc18_1.DataPtr", dataPtr, dataEnd);
451        }
452        dataPtr = tc18.data();
453        {
454            MsgPackArrayParser arrParser(dataPtr, dataPtr + 2);
455            assertCLRXException("MsgPack0", "tc18_2.Ex",
456                        "MsgPack: Can't parse byte-array size",
457                        [&arrParser]() { arrParser.parseData(); });
458            dataEnd = tc18.begin()+2;
459            assertValue("MsgPack0", "tc18_2.DataPtr", dataPtr, dataEnd);
460        }
461        dataPtr = tc18.data();
462        {
463            MsgPackArrayParser arrParser(dataPtr, dataPtr + 3);
464            assertCLRXException("MsgPack0", "tc18_3.Ex",
465                        "MsgPack: Can't parse byte-array size",
466                        [&arrParser]() { arrParser.parseData(); });
467            dataEnd = tc18.begin()+2;
468            assertValue("MsgPack0", "tc18_3.DataPtr", dataPtr, dataEnd);
469        }
470    }
471    // longer data (32-bit size)
472    {
473        Array<cxbyte> tc19(6 + 20818241);
474        tc19[0] = 0x91;
475        tc19[1] = 0xc6;
476        tc19[2] = (20818241>>24);
477        tc19[3] = (20818241>>16)&0xff;
478        tc19[4] = (20818241>>8)&0xff;
479        tc19[5] = (20818241&0xff);
480        for (cxuint i = 0; i < tc19.size()-6; i++)
481            tc19[i+6] = ((i*0x11f)^i)*3 + (1334123421%(i*5+1));
482        dataPtr = tc19.data();
483        const cxbyte* dataEnd = tc19.end();
484        MsgPackArrayParser arrParser(dataPtr, dataPtr + tc19.size());
485        assertArray("MsgPack0", "tc19.value", Array<cxbyte>(tc19.begin()+6, tc19.end()),
486                        arrParser.parseData());
487        assertValue("MsgPack0", "tc19.DataPtr", dataPtr, dataEnd);
488        for (cxuint i = 1; i <= 5; i ++)
489        {
490            dataPtr = tc19.data();
491            dataEnd = tc19.begin()+6;
492            MsgPackArrayParser arrParser(dataPtr, dataPtr + tc19.size()-i);
493            assertCLRXException("MsgPack0", "tc19_1.Ex", "MsgPack: Can't parse byte-array",
494                        [&arrParser]() { arrParser.parseData(); });
495            assertValue("MsgPack0", "tc19_1.DataPtr", dataPtr, dataEnd);
496        }
497        for (cxuint i = 1; i <= 3; i++)
498        {
499            dataPtr = tc19.data();
500            MsgPackArrayParser arrParser(dataPtr, dataPtr + 2 + i);
501            assertCLRXException("MsgPack0", "tc19_2.Ex",
502                        "MsgPack: Can't parse byte-array size",
503                        [&arrParser]() { arrParser.parseData(); });
504            dataEnd = tc19.begin()+2;
505            assertValue("MsgPack0", "tc19_2.DataPtr", dataPtr, dataEnd);
506        }
507    }
508    // parseString
509    const cxbyte tc20[7] = { 0x91, 0xa5, 0x91, 0x7b, 0xa1, 0x5e, 0x1b };
510    dataPtr = tc20;
511    {
512        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc20));
513        const std::string v = arrParser.parseString();
514        assertArray("MsgPack0", "tc20.value", Array<cxbyte>(tc20+2, tc20+sizeof(tc20)),
515                        v.size(), reinterpret_cast<const cxbyte*>(v.c_str()));
516        assertValue("MsgPack0", "tc20.DataPtr", dataPtr, tc20 + sizeof(tc20));
517    }
518    for (cxuint i = 1; i <= 5; i ++)
519    {
520        dataPtr = tc20;
521        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc20)-i);
522        assertCLRXException("MsgPack0", "tc20_1.Ex", "MsgPack: Can't parse string",
523                    [&arrParser]() { arrParser.parseString(); });
524        assertValue("MsgPack0", "tc20_1.DataPtr", dataPtr, tc20 + 2);
525    }
526    const cxbyte tc21[0x2c] = { 0x91, 0xd9, 0x29,
527        0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x99,
528        0x17, 0x27, 0x73, 0x54, 0x55, 0x56, 0x33, 0xab,
529        0xff, 0xaa, 0xcc, 0x32, 0x44, 0x55, 0x66, 0x53,
530        0x32, 0x41, 0x52, 0x56, 0x6a, 0x7b, 0x4a, 0x49,
531        0x41, 0x9a, 0x12, 0x0f, 0x05, 0x0d, 0x13, 0x14, 0x12 };
532    dataPtr = tc21;
533    {
534        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc21));
535        const std::string v = arrParser.parseString();
536        assertArray("MsgPack0", "tc21.value", Array<cxbyte>(tc21+3, tc21+sizeof(tc21)),
537                        v.size(), reinterpret_cast<const cxbyte*>(v.c_str()));
538        assertValue("MsgPack0", "tc21.DataPtr", dataPtr, tc21 + sizeof(tc21));
539    }
540    for (cxuint i = 1; i <= 20; i ++)
541    {
542        dataPtr = tc21;
543        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc21)-i);
544        assertCLRXException("MsgPack0", "tc21_1.Ex", "MsgPack: Can't parse string",
545                    [&arrParser]() { arrParser.parseString(); });
546        assertValue("MsgPack0", "tc21_1.DataPtr", dataPtr, tc21 + 3);
547    }
548    dataPtr = tc21;
549    {
550        MsgPackArrayParser arrParser(dataPtr, dataPtr + 2);
551        assertCLRXException("MsgPack0", "tc21_2.Ex", "MsgPack: Can't parse string size",
552                    [&arrParser]() { arrParser.parseString(); });
553        assertValue("MsgPack0", "tc21_2.DataPtr", dataPtr, tc21 + 2);
554    }
555    // longer data (16-bit size)
556    {
557        Array<cxbyte> tc22(4 + 12615);
558        tc22[0] = 0x91;
559        tc22[1] = 0xda;
560        tc22[2] = (12615>>8);
561        tc22[3] = (12615&0xff);
562        for (cxuint i = 0; i < tc22.size()-4; i++)
563            tc22[i+4] = ((i*0x71f)^i) + (12342%(i+1));
564        dataPtr = tc22.data();
565        const cxbyte* dataEnd = tc22.end();
566        MsgPackArrayParser arrParser(dataPtr, dataPtr + tc22.size());
567        const std::string v = arrParser.parseString();
568        assertArray("MsgPack0", "tc22.value", Array<cxbyte>(tc22.begin()+4, tc22.end()),
569                    v.size(), reinterpret_cast<const cxbyte*>(v.c_str()));
570        assertValue("MsgPack0", "tc22.DataPtr", dataPtr, dataEnd);
571        for (cxuint i = 1; i <= 5; i ++)
572        {
573            dataPtr = tc22.data();
574            dataEnd = tc22.begin()+4;
575            MsgPackArrayParser arrParser(dataPtr, dataPtr + tc22.size()-i);
576            assertCLRXException("MsgPack0", "tc22_1.Ex", "MsgPack: Can't parse string",
577                        [&arrParser]() { arrParser.parseString(); });
578            assertValue("MsgPack0", "tc22_1.DataPtr", dataPtr, dataEnd);
579        }
580        dataPtr = tc22.data();
581        {
582            MsgPackArrayParser arrParser(dataPtr, dataPtr + 2);
583            assertCLRXException("MsgPack0", "tc18_2.Ex",
584                        "MsgPack: Can't parse string size",
585                        [&arrParser]() { arrParser.parseString(); });
586            dataEnd = tc22.begin()+2;
587            assertValue("MsgPack0", "tc22_2.DataPtr", dataPtr, dataEnd);
588        }
589        dataPtr = tc22.data();
590        {
591            MsgPackArrayParser arrParser(dataPtr, dataPtr + 3);
592            assertCLRXException("MsgPack0", "tc18_3.Ex",
593                        "MsgPack: Can't parse string size",
594                        [&arrParser]() { arrParser.parseString(); });
595            dataEnd = tc22.begin()+2;
596            assertValue("MsgPack0", "tc22_3.DataPtr", dataPtr, dataEnd);
597        }
598    }
599    // longer data (32-bit size)
600    {
601        Array<cxbyte> tc23(6 + 20818241);
602        tc23[0] = 0x91;
603        tc23[1] = 0xdb;
604        tc23[2] = (20818241>>24);
605        tc23[3] = (20818241>>16)&0xff;
606        tc23[4] = (20818241>>8)&0xff;
607        tc23[5] = (20818241&0xff);
608        for (cxuint i = 0; i < tc23.size()-6; i++)
609            tc23[i+6] = ((i*0x11f)^i)*3 + (1334123421%(i*5+1));
610        dataPtr = tc23.data();
611        const cxbyte* dataEnd = tc23.end();
612        MsgPackArrayParser arrParser(dataPtr, dataPtr + tc23.size());
613        const std::string v = arrParser.parseString();
614        assertArray("MsgPack0", "tc23.value", Array<cxbyte>(tc23.begin()+6, tc23.end()),
615                        v.size(), reinterpret_cast<const cxbyte*>(v.c_str()));
616        assertValue("MsgPack0", "tc23.DataPtr", dataPtr, dataEnd);
617        for (cxuint i = 1; i <= 5; i ++)
618        {
619            dataPtr = tc23.data();
620            dataEnd = tc23.begin()+6;
621            MsgPackArrayParser arrParser(dataPtr, dataPtr + tc23.size()-i);
622            assertCLRXException("MsgPack0", "tc23_1.Ex", "MsgPack: Can't parse string",
623                        [&arrParser]() { arrParser.parseString(); });
624            assertValue("MsgPack0", "tc23_1.DataPtr", dataPtr, dataEnd);
625        }
626        for (cxuint i = 1; i <= 3; i++)
627        {
628            dataPtr = tc23.data();
629            MsgPackArrayParser arrParser(dataPtr, dataPtr + 2 + i);
630            assertCLRXException("MsgPack0", "tc23_2.Ex",
631                        "MsgPack: Can't parse string size",
632                        [&arrParser]() { arrParser.parseString(); });
633            dataEnd = tc23.begin()+2;
634            assertValue("MsgPack0", "tc23_2.DataPtr", dataPtr, dataEnd);
635        }
636    }
637   
638    // parseArray
639    const cxbyte tc24[10] = { 0x91, 0x96, 0x11, 0x33, 0xcc, 0xb4, 0x74, 0xcc, 0x99, 0x21 };
640    {
641        dataPtr = tc24;
642        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc24));
643        MsgPackArrayParser childParser = arrParser.parseArray();
644        std::vector<cxuint> res;
645        while (childParser.haveElements())
646            res.push_back(childParser.parseInteger(MSGPACK_WS_BOTH));
647        const cxuint expected[6] = { 0x11, 0x33, 0xb4, 0x74, 0x99, 0x21 };
648        assertArray("MsgPack0", "tc24.value", Array<cxuint>(expected, expected + 6),
649                        Array<cxuint>(res.begin(), res.end()));
650        assertValue("MsgPack0", "tc24.DataPtr", dataPtr, tc24 + sizeof(tc24));
651        assertTrue("MsgPack0", "No elements", !childParser.haveElements());
652    }
653    // longer array (more than 15 elements)
654    const cxbyte tc25[39] = { 0x91, 0xdc, 0x00, 0x23,
655        0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x78,
656        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
657        0x21, 0x12, 0x23, 0x54, 0x25, 0x46, 0x77, 0x58,
658        0x0f, 0x0a, 0x0b, 0x0d, 0x0e, 0x01, 0x21, 0x22,
659        0x79, 0x7b, 0x7f };
660    {
661        dataPtr = tc25;
662        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc25));
663        MsgPackArrayParser childParser = arrParser.parseArray();
664        std::vector<cxuint> res;
665        while (childParser.haveElements())
666            res.push_back(childParser.parseInteger(MSGPACK_WS_BOTH));
667        const cxuint expected[35] = {
668            0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x78,
669            0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
670            0x21, 0x12, 0x23, 0x54, 0x25, 0x46, 0x77, 0x58,
671            0x0f, 0x0a, 0x0b, 0x0d, 0x0e, 0x01, 0x21, 0x22,
672            0x79, 0x7b, 0x7f };
673        assertArray("MsgPack0", "tc25.value", Array<cxuint>(expected, expected + 35),
674                        Array<cxuint>(res.begin(), res.end()));
675        assertValue("MsgPack0", "tc25.DataPtr", dataPtr, tc25 + sizeof(tc25));
676        assertTrue("MsgPack0", "tc25.No elements", !childParser.haveElements());
677    }
678    // longer array (16-bit size)
679    {
680        Array<cxbyte> tc26(4 + 12615);
681        tc26[0] = 0x91;
682        tc26[1] = 0xdc;
683        tc26[2] = (12615>>8);
684        tc26[3] = (12615&0xff);
685        for (cxuint i = 0; i < tc26.size()-4; i++)
686            tc26[i+4] = (((i*0x71f)^i) + (12342%(i+1)))&0x7f;
687        dataPtr = tc26.data();
688        const cxbyte* dataEnd = tc26.end();
689        std::vector<cxbyte> res;
690        MsgPackArrayParser arrParser(dataPtr, dataPtr + tc26.size());
691        MsgPackArrayParser childParser = arrParser.parseArray();
692        while (childParser.haveElements())
693            res.push_back(childParser.parseInteger(MSGPACK_WS_BOTH));
694        assertArray("MsgPack0", "tc26.value",
695                    Array<cxbyte>(tc26.begin()+4, tc26.end()), res);
696        assertValue("MsgPack0", "tc26.DataPtr", dataPtr, dataEnd);
697        dataPtr = tc26.data();
698        {
699            MsgPackArrayParser arrParser(dataPtr, dataPtr + 2);
700            assertCLRXException("MsgPack0", "tc26_2.Ex", "MsgPack: Can't parse array size",
701                        [&arrParser]() { arrParser.parseArray(); });
702            dataEnd = tc26.begin()+2;
703            assertValue("MsgPack0", "tc26_2.DataPtr", dataPtr, dataEnd);
704        }
705        dataPtr = tc26.data();
706        {
707            MsgPackArrayParser arrParser(dataPtr, dataPtr + 3);
708            assertCLRXException("MsgPack0", "tc26_3.Ex", "MsgPack: Can't parse array size",
709                        [&arrParser]() { arrParser.parseArray(); });
710            dataEnd = tc26.begin()+2;
711            assertValue("MsgPack0", "tc26_3.DataPtr", dataPtr, dataEnd);
712        }
713    }
714    // longer array (32-bit size)
715    {
716        Array<cxbyte> tc27(6 + 1818241);
717        tc27[0] = 0x91;
718        tc27[1] = 0xdd;
719        tc27[2] = (1818241>>24);
720        tc27[3] = (1818241>>16)&0xff;
721        tc27[4] = (1818241>>8)&0xff;
722        tc27[5] = (1818241&0xff);
723        for (cxuint i = 0; i < tc27.size()-6; i++)
724            tc27[i+6] = (((i*0x11f)^i)*3 + (1334123421%(i*5+1)))&0x7f;
725        dataPtr = tc27.data();
726        const cxbyte* dataEnd = tc27.end();
727        MsgPackArrayParser arrParser(dataPtr, dataPtr + tc27.size());
728        std::vector<cxbyte> res;
729        MsgPackArrayParser childParser = arrParser.parseArray();
730        while (childParser.haveElements())
731            res.push_back(childParser.parseInteger(MSGPACK_WS_BOTH));
732        assertArray("MsgPack0", "tc27.value",
733                    Array<cxbyte>(tc27.begin()+6, tc27.end()), res);
734        assertValue("MsgPack0", "tc27.DataPtr", dataPtr, dataEnd);
735        for (cxuint i = 1; i <= 3; i++)
736        {
737            dataPtr = tc27.data();
738            MsgPackArrayParser arrParser(dataPtr, dataPtr + 2 + i);
739            assertCLRXException("MsgPack0", "tc27_2.Ex", "MsgPack: Can't parse array size",
740                        [&arrParser]() { arrParser.parseArray(); });
741            dataEnd = tc27.begin()+2;
742            assertValue("MsgPack0", "tc27_2.DataPtr", dataPtr, dataEnd);
743        }
744    }
745   
746    // parseMap
747    const cxbyte tc28[16] = { 0x91, 0x85, 0x11, 0x33, 0xcc, 0xb4, 0x74, 0xcc, 0x99,
748                        0x21, 0xcc, 0xff, 0x42, 0x71, 0xcc, 0xca };
749    {
750        dataPtr = tc28;
751        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc28));
752        MsgPackMapParser childParser = arrParser.parseMap();
753        std::vector<cxuint> res;
754        while (childParser.haveElements())
755        {
756            res.push_back(childParser.parseKeyInteger(MSGPACK_WS_BOTH));
757            res.push_back(childParser.parseValueInteger(MSGPACK_WS_BOTH));
758        }
759        const cxuint expected[10] = { 0x11, 0x33, 0xb4, 0x74, 0x99,
760                                    0x21, 0xff, 0x42, 0x71, 0xca };
761        assertArray("MsgPack0", "tc28.value", Array<cxuint>(expected, expected + 10),
762                        Array<cxuint>(res.begin(), res.end()));
763        assertValue("MsgPack0", "tc28.DataPtr", dataPtr, tc28 + sizeof(tc28));
764        assertTrue("MsgPack0", "tc28.No elements", !childParser.haveElements());
765    }
766    {
767        dataPtr = tc28;
768        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc28));
769        MsgPackMapParser childParser = arrParser.parseMap();
770        for (cxuint i = 0; i < 4; i++)
771        {
772            childParser.parseKeyInteger(MSGPACK_WS_BOTH);
773            childParser.parseValueInteger(MSGPACK_WS_BOTH);
774        }
775        childParser.parseKeyInteger(MSGPACK_WS_BOTH);
776        assertTrue("MsgPack0", "tc28_1.HaveElements", childParser.haveElements());
777    }
778    {
779        dataPtr = tc28;
780        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc28));
781        MsgPackMapParser childParser = arrParser.parseMap();
782        assertCLRXException("MsgPack0", "tc28_2.IsNotValue",
783                    "MsgPack: This is not a value",
784                    [&childParser]() { childParser.parseValueBool(); });
785    }
786    {
787        dataPtr = tc28;
788        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc28));
789        MsgPackMapParser childParser = arrParser.parseMap();
790        childParser.parseKeyInteger(MSGPACK_WS_BOTH);
791        assertCLRXException("MsgPack0", "tc28_2.IsNotKey",
792                    "MsgPack: Key already parsed",
793                    [&childParser]() { childParser.parseKeyBool(); });
794    }
795    // longer map (16-bit size)
796    {
797        Array<cxbyte> tc29(4 + 12615*2);
798        tc29[0] = 0x91;
799        tc29[1] = 0xde;
800        tc29[2] = (12615>>8);
801        tc29[3] = (12615&0xff);
802        for (cxuint i = 0; i < tc29.size()-4; i++)
803            tc29[i+4] = (((i*0x71f)^i) + (12342%(i+1)))&0x7f;
804        dataPtr = tc29.data();
805        const cxbyte* dataEnd = tc29.end();
806        std::vector<cxbyte> res;
807        MsgPackArrayParser arrParser(dataPtr, dataPtr + tc29.size());
808        MsgPackMapParser childParser = arrParser.parseMap();
809        while (childParser.haveElements())
810        {
811            res.push_back(childParser.parseKeyInteger(MSGPACK_WS_BOTH));
812            res.push_back(childParser.parseValueInteger(MSGPACK_WS_BOTH));
813        }
814        assertArray("MsgPack0", "tc29.value",
815                    Array<cxbyte>(tc29.begin()+4, tc29.end()), res);
816        assertValue("MsgPack0", "tc29.DataPtr", dataPtr, dataEnd);
817        dataPtr = tc29.data();
818        {
819            MsgPackArrayParser arrParser(dataPtr, dataPtr + 2);
820            assertCLRXException("MsgPack0", "tc29_2.Ex", "MsgPack: Can't parse map size",
821                        [&arrParser]() { arrParser.parseMap(); });
822            dataEnd = tc29.begin()+2;
823            assertValue("MsgPack0", "tc29_2.DataPtr", dataPtr, dataEnd);
824        }
825        dataPtr = tc29.data();
826        {
827            MsgPackArrayParser arrParser(dataPtr, dataPtr + 3);
828            assertCLRXException("MsgPack0", "tc29_3.Ex", "MsgPack: Can't parse map size",
829                        [&arrParser]() { arrParser.parseMap(); });
830            dataEnd = tc29.begin()+2;
831            assertValue("MsgPack0", "tc29_3.DataPtr", dataPtr, dataEnd);
832        }
833    }
834    // longer map (32-bit size)
835    {
836        Array<cxbyte> tc30(6 + 1818241*2);
837        tc30[0] = 0x91;
838        tc30[1] = 0xdf;
839        tc30[2] = (1818241>>24);
840        tc30[3] = (1818241>>16)&0xff;
841        tc30[4] = (1818241>>8)&0xff;
842        tc30[5] = (1818241&0xff);
843        for (cxuint i = 0; i < tc30.size()-6; i++)
844            tc30[i+6] = (((i*0x11f)^i)*3 + (1334123421%(i*5+1)))&0x7f;
845        dataPtr = tc30.data();
846        const cxbyte* dataEnd = tc30.end();
847        MsgPackArrayParser arrParser(dataPtr, dataPtr + tc30.size());
848        std::vector<cxbyte> res;
849        MsgPackMapParser childParser = arrParser.parseMap();
850        while (childParser.haveElements())
851        {
852            res.push_back(childParser.parseKeyInteger(MSGPACK_WS_BOTH));
853            res.push_back(childParser.parseValueInteger(MSGPACK_WS_BOTH));
854        }
855        assertArray("MsgPack0", "tc30.value",
856                    Array<cxbyte>(tc30.begin()+6, tc30.end()), res);
857        assertValue("MsgPack0", "tc30.DataPtr", dataPtr, dataEnd);
858        for (cxuint i = 1; i <= 3; i++)
859        {
860            dataPtr = tc30.data();
861            MsgPackArrayParser arrParser(dataPtr, dataPtr + 2 + i);
862            assertCLRXException("MsgPack0", "tc30_2.Ex", "MsgPack: Can't parse map size",
863                        [&arrParser]() { arrParser.parseMap(); });
864            dataEnd = tc30.begin()+2;
865            assertValue("MsgPack0", "tc30_2.DataPtr", dataPtr, dataEnd);
866        }
867    }
868}
869
870static void testMsgPackSkip()
871{
872    const cxbyte tc0[3] = { 0x81, 0xc0, 0xc0 };
873    const cxbyte* dataPtr;
874    dataPtr = tc0;
875    {
876        MsgPackMapParser mapParser(dataPtr, dataPtr + sizeof(tc0));
877        mapParser.parseKeyNil();
878        mapParser.skipValue();
879        assertValue("MsgPackSkip", "tc0.DataPtr", dataPtr, tc0 + sizeof(tc0));
880    }
881   
882    // skip boolean
883    const cxbyte tc1[3] = { 0x81, 0xc0, 0xc2 };
884    dataPtr = tc1;
885    {
886        MsgPackMapParser mapParser(dataPtr, dataPtr + sizeof(tc1));
887        mapParser.parseKeyNil();
888        mapParser.skipValue();
889        assertValue("MsgPackSkip", "tc1.DataPtr", dataPtr, tc1 + sizeof(tc1));
890    }
891    const cxbyte tc1_1[3] = { 0x81, 0xc0, 0xc3 };
892    dataPtr = tc1_1;
893    {
894        MsgPackMapParser mapParser(dataPtr, dataPtr + sizeof(tc1_1));
895        mapParser.parseKeyNil();
896        mapParser.skipValue();
897        assertValue("MsgPackSkip", "tc1_1.DataPtr", dataPtr, tc1_1 + sizeof(tc1_1));
898    }
899    // skip integers
900    const cxbyte tc2[3] = { 0x81, 0xc0, 0x17 };
901    dataPtr = tc2;
902    {
903        MsgPackMapParser mapParser(dataPtr, dataPtr + sizeof(tc2));
904        mapParser.parseKeyNil();
905        mapParser.skipValue();
906        assertValue("MsgPackSkip", "tc2.DataPtr", dataPtr, tc2 + sizeof(tc2));
907    }
908    const cxbyte tc2_1[3] = { 0x81, 0xc0, 0xec };
909    dataPtr = tc2_1;
910    {
911        MsgPackMapParser mapParser(dataPtr, dataPtr + sizeof(tc2_1));
912        mapParser.parseKeyNil();
913        mapParser.skipValue();
914        assertValue("MsgPackSkip", "tc2_1.DataPtr", dataPtr, tc2_1 + sizeof(tc2_1));
915    }
916    const cxbyte tc3[4] = { 0x81, 0xc0, 0xcc, 0xda };
917    dataPtr = tc3;
918    {
919        MsgPackMapParser mapParser(dataPtr, dataPtr + sizeof(tc3));
920        mapParser.parseKeyNil();
921        mapParser.skipValue();
922        assertValue("MsgPackSkip", "tc3.DataPtr", dataPtr, tc3 + sizeof(tc3));
923    }
924    dataPtr = tc3;
925    {
926        MsgPackMapParser mapParser(dataPtr, dataPtr + sizeof(tc3)-1);
927        mapParser.parseKeyNil();
928        assertCLRXException("MsgPackSkip", "tc3_1.DataPtr", "MsgPack: Can't skip object",
929                    [&mapParser]() { mapParser.skipValue(); });
930    }
931    const cxbyte tc3_2[4] = { 0x81, 0xc0, 0xd0, 0xda };
932    dataPtr = tc3_2;
933    {
934        MsgPackMapParser mapParser(dataPtr, dataPtr + sizeof(tc3_2));
935        mapParser.parseKeyNil();
936        mapParser.skipValue();
937        assertValue("MsgPackSkip", "tc3_2.DataPtr", dataPtr, tc3_2 + sizeof(tc3_2));
938    }
939    dataPtr = tc3_2;
940    {
941        MsgPackMapParser mapParser(dataPtr, dataPtr + sizeof(tc3_2)-1);
942        mapParser.parseKeyNil();
943        assertCLRXException("MsgPackSkip", "tc3_3.DataPtr", "MsgPack: Can't skip object",
944                    [&mapParser]() { mapParser.skipValue(); });
945    }
946    const cxbyte tc4[5] = { 0x81, 0xc0, 0xcd, 0xda, 0x99 };
947    dataPtr = tc4;
948    {
949        MsgPackMapParser mapParser(dataPtr, dataPtr + sizeof(tc4));
950        mapParser.parseKeyNil();
951        mapParser.skipValue();
952        assertValue("MsgPackSkip", "tc4.DataPtr", dataPtr, tc4 + sizeof(tc4));
953    }
954    dataPtr = tc4;
955    {
956        MsgPackMapParser mapParser(dataPtr, dataPtr + sizeof(tc4)-1);
957        mapParser.parseKeyNil();
958        assertCLRXException("MsgPackSkip", "tc4_1.DataPtr", "MsgPack: Can't skip object",
959                    [&mapParser]() { mapParser.skipValue(); });
960    }
961    dataPtr = tc4;
962    {
963        MsgPackMapParser mapParser(dataPtr, dataPtr + sizeof(tc4)-2);
964        mapParser.parseKeyNil();
965        assertCLRXException("MsgPackSkip", "tc4_2.DataPtr", "MsgPack: Can't skip object",
966                    [&mapParser]() { mapParser.skipValue(); });
967    }
968    const cxbyte tc4_3[5] = { 0x81, 0xc0, 0xd1, 0xda, 0x99 };
969    dataPtr = tc4_3;
970    {
971        MsgPackMapParser mapParser(dataPtr, dataPtr + sizeof(tc4_3));
972        mapParser.parseKeyNil();
973        mapParser.skipValue();
974        assertValue("MsgPackSkip", "tc4_3.DataPtr", dataPtr, tc4_3 + sizeof(tc4_3));
975    }
976    const cxbyte tc5[7] = { 0x81, 0xc0, 0xce, 0x11, 0xbb, 0xd1, 0xe6 };
977    dataPtr = tc5;
978    {
979        MsgPackMapParser mapParser(dataPtr, dataPtr + sizeof(tc5));
980        mapParser.parseKeyNil();
981        mapParser.skipValue();
982        assertValue("MsgPackSkip", "tc5.DataPtr", dataPtr, tc5 + sizeof(tc5));
983    }
984    for (cxuint i = 1; i <= 3; i++)
985    {
986        dataPtr = tc5;
987        MsgPackMapParser mapParser(dataPtr, dataPtr + sizeof(tc5)-i);
988        mapParser.parseKeyNil();
989        assertCLRXException("MsgPackSkip", "tc5_1.DataPtr", "MsgPack: Can't skip object",
990                    [&mapParser]() { mapParser.skipValue(); });
991    }
992    const cxbyte tc5_2[7] = { 0x81, 0xc0, 0xd2, 0x11, 0xbb, 0xd1, 0xe6 };
993    dataPtr = tc5_2;
994    {
995        MsgPackMapParser mapParser(dataPtr, dataPtr + sizeof(tc5_2));
996        mapParser.parseKeyNil();
997        mapParser.skipValue();
998        assertValue("MsgPackSkip", "tc5_2.DataPtr", dataPtr, tc5_2 + sizeof(tc5_2));
999    }
1000    const cxbyte tc6[11] = { 0x81, 0xc0, 0xcf, 0x11, 0x77, 0xab, 0x3c,
1001                    0x1a, 0x88, 0x83, 0xde };
1002    dataPtr = tc6;
1003    {
1004        MsgPackMapParser mapParser(dataPtr, dataPtr + sizeof(tc6));
1005        mapParser.parseKeyNil();
1006        mapParser.skipValue();
1007        assertValue("MsgPackSkip", "tc6.DataPtr", dataPtr, tc6 + sizeof(tc6));
1008    }
1009    for (cxuint i = 1; i <= 7; i++)
1010    {
1011        dataPtr = tc6;
1012        MsgPackMapParser mapParser(dataPtr, dataPtr + sizeof(tc6)-i);
1013        mapParser.parseKeyNil();
1014        assertCLRXException("MsgPackSkip", "tc6_1.DataPtr", "MsgPack: Can't skip object",
1015                    [&mapParser]() { mapParser.skipValue(); });
1016    }
1017    const cxbyte tc6_2[11] = { 0x81, 0xc0, 0xd3, 0x11, 0x77, 0xab, 0x3c,
1018                    0x1a, 0x88, 0x83, 0xde };
1019    dataPtr = tc6_2;
1020    {
1021        MsgPackMapParser mapParser(dataPtr, dataPtr + sizeof(tc6_2));
1022        mapParser.parseKeyNil();
1023        mapParser.skipValue();
1024        assertValue("MsgPackSkip", "tc6_2.DataPtr", dataPtr, tc6_2 + sizeof(tc6_2));
1025    }
1026    // skip floats
1027    const cxbyte tc7[7] = { 0x81, 0xc0, 0xca, 0x11, 0xbb, 0xd1, 0xe6 };
1028    dataPtr = tc7;
1029    {
1030        MsgPackMapParser mapParser(dataPtr, dataPtr + sizeof(tc7));
1031        mapParser.parseKeyNil();
1032        mapParser.skipValue();
1033        assertValue("MsgPackSkip", "tc7.DataPtr", dataPtr, tc7 + sizeof(tc7));
1034    }
1035    for (cxuint i = 1; i <= 3; i++)
1036    {
1037        dataPtr = tc7;
1038        MsgPackMapParser mapParser(dataPtr, dataPtr + sizeof(tc7)-i);
1039        mapParser.parseKeyNil();
1040        assertCLRXException("MsgPackSkip", "tc7_1.DataPtr", "MsgPack: Can't skip object",
1041                    [&mapParser]() { mapParser.skipValue(); });
1042    }
1043    const cxbyte tc8[11] = { 0x81, 0xc0, 0xcf, 0x11, 0x77, 0xab, 0x3c,
1044                    0x1a, 0x88, 0x83, 0xde };
1045    dataPtr = tc8;
1046    {
1047        MsgPackMapParser mapParser(dataPtr, dataPtr + sizeof(tc8));
1048        mapParser.parseKeyNil();
1049        mapParser.skipValue();
1050        assertValue("MsgPackSkip", "tc8.DataPtr", dataPtr, tc8 + sizeof(tc8));
1051    }
1052    for (cxuint i = 1; i <= 7; i++)
1053    {
1054        dataPtr = tc8;
1055        MsgPackMapParser mapParser(dataPtr, dataPtr + sizeof(tc8)-i);
1056        mapParser.parseKeyNil();
1057        assertCLRXException("MsgPackSkip", "tc8_1.DataPtr", "MsgPack: Can't skip object",
1058                    [&mapParser]() { mapParser.skipValue(); });
1059    }
1060    /* skip string */
1061    const cxbyte tc9[8] = { 0x81, 0xc0, 0xa5, 0x41, 0x42, 0x53, 0x43, 0x47 };
1062    dataPtr = tc9;
1063    {
1064        MsgPackMapParser mapParser(dataPtr, dataPtr + sizeof(tc9));
1065        mapParser.parseKeyNil();
1066        mapParser.skipValue();
1067        assertValue("MsgPackSkip", "tc9.DataPtr", dataPtr, tc9 + sizeof(tc9));
1068    }
1069    dataPtr = tc9;
1070    {
1071        MsgPackMapParser mapParser(dataPtr, dataPtr + sizeof(tc9)-1);
1072        mapParser.parseKeyNil();
1073        assertCLRXException("MsgPackSkip", "tc9_1.DataPtr", "MsgPack: Can't skip object",
1074                    [&mapParser]() { mapParser.skipValue(); });
1075    }
1076    const cxbyte tc10[38] = { 0x81, 0xc0, 0xd9, 0x22,
1077        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
1078        0x01, 0x02, 0x03, 0x54, 0x05, 0x06, 0x07, 0x08,
1079        0x01, 0x04, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
1080        0x01, 0x02, 0x03, 0x04, 0xf5, 0x06, 0x07, 0x08,
1081        0x33, 0x66 };
1082    dataPtr = tc10;
1083    {
1084        MsgPackMapParser mapParser(dataPtr, dataPtr + sizeof(tc10));
1085        mapParser.parseKeyNil();
1086        mapParser.skipValue();
1087        assertValue("MsgPackSkip", "tc9.DataPtr", dataPtr, tc10 + sizeof(tc10));
1088    }
1089    dataPtr = tc10;
1090    {
1091        MsgPackMapParser mapParser(dataPtr, dataPtr + sizeof(tc10)-1);
1092        mapParser.parseKeyNil();
1093        assertCLRXException("MsgPackSkip", "tc10_1.DataPtr", "MsgPack: Can't skip object",
1094                    [&mapParser]() { mapParser.skipValue(); });
1095    }
1096    dataPtr = tc10;
1097    {
1098        MsgPackMapParser mapParser(dataPtr, dataPtr + 3);
1099        mapParser.parseKeyNil();
1100        assertCLRXException("MsgPackSkip", "tc10_2.DataPtr", "MsgPack: Can't skip object",
1101                    [&mapParser]() { mapParser.skipValue(); });
1102    }
1103    {
1104        Array<cxbyte> tc11(5 + 11232);
1105        tc11[0] = 0x81;
1106        tc11[1] = 0xc0;
1107        tc11[2] = 0xda;
1108        tc11[3] = (11232)>>8;
1109        tc11[4] = (11232)&255;
1110        for (size_t i = 0; i < tc11.size()-5; i++)
1111            tc11[i+5] = (i^0x80)&0xff;
1112        dataPtr = tc11.data();
1113        MsgPackMapParser mapParser(dataPtr, dataPtr + tc11.size());
1114        mapParser.parseKeyNil();
1115        mapParser.skipValue();
1116        const cxbyte* dataEnd = tc11.end();
1117        assertValue("MsgPackSkip", "tc11.DataPtr", dataPtr, dataEnd);
1118        {
1119            dataPtr = tc11.data();
1120            MsgPackMapParser mapParser(dataPtr, dataPtr + tc11.size()-1);
1121            mapParser.parseKeyNil();
1122            assertCLRXException("MsgPackSkip", "tc11_1.DataPtr",
1123                    "MsgPack: Can't skip object",
1124                    [&mapParser]() { mapParser.skipValue(); });
1125        }
1126        {
1127            dataPtr = tc11.data();
1128            MsgPackMapParser mapParser(dataPtr, dataPtr + 4);
1129            mapParser.parseKeyNil();
1130            assertCLRXException("MsgPackSkip", "tc11_2.DataPtr",
1131                    "MsgPack: Can't skip object",
1132                    [&mapParser]() { mapParser.skipValue(); });
1133        }
1134    }
1135    {
1136        Array<cxbyte> tc12(7 + 4511232);
1137        tc12[0] = 0x81;
1138        tc12[1] = 0xc0;
1139        tc12[2] = 0xdb;
1140        tc12[3] = ((4511232)>>24);
1141        tc12[4] = ((4511232)>>16)&255;
1142        tc12[5] = ((4511232)>>8)&255;
1143        tc12[6] = (4511232)&255;
1144        for (size_t i = 0; i < tc12.size()-7; i++)
1145            tc12[i+7] = (i^0x80)&0xff;
1146        dataPtr = tc12.data();
1147        MsgPackMapParser mapParser(dataPtr, dataPtr + tc12.size());
1148        mapParser.parseKeyNil();
1149        mapParser.skipValue();
1150        const cxbyte* dataEnd = tc12.end();
1151        assertValue("MsgPackSkip", "tc12.DataPtr", dataPtr, dataEnd);
1152        {
1153            dataPtr = tc12.data();
1154            MsgPackMapParser mapParser(dataPtr, dataPtr + tc12.size()-1);
1155            mapParser.parseKeyNil();
1156            assertCLRXException("MsgPackSkip", "tc12_1.DataPtr",
1157                    "MsgPack: Can't skip object",
1158                    [&mapParser]() { mapParser.skipValue(); });
1159        }
1160        {
1161            dataPtr = tc12.data();
1162            MsgPackMapParser mapParser(dataPtr, dataPtr + 6);
1163            mapParser.parseKeyNil();
1164            assertCLRXException("MsgPackSkip", "tc12_2.DataPtr",
1165                    "MsgPack: Can't skip object",
1166                    [&mapParser]() { mapParser.skipValue(); });
1167        }
1168    }
1169    /* skip bin data */
1170    const cxbyte tc13[38] = { 0x81, 0xc0, 0xc4, 0x22,
1171        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
1172        0x01, 0x02, 0x03, 0x54, 0x05, 0x06, 0x07, 0x08,
1173        0x01, 0x04, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
1174        0x01, 0x02, 0x03, 0x04, 0xf5, 0x06, 0x07, 0x08,
1175        0x33, 0x66 };
1176    dataPtr = tc13;
1177    {
1178        MsgPackMapParser mapParser(dataPtr, dataPtr + sizeof(tc13));
1179        mapParser.parseKeyNil();
1180        mapParser.skipValue();
1181        assertValue("MsgPackSkip", "tc13.DataPtr", dataPtr, tc13 + sizeof(tc13));
1182    }
1183    dataPtr = tc13;
1184    {
1185        MsgPackMapParser mapParser(dataPtr, dataPtr + sizeof(tc13)-1);
1186        mapParser.parseKeyNil();
1187        assertCLRXException("MsgPackSkip", "tc13_1.DataPtr", "MsgPack: Can't skip object",
1188                    [&mapParser]() { mapParser.skipValue(); });
1189    }
1190    dataPtr = tc13;
1191    {
1192        MsgPackMapParser mapParser(dataPtr, dataPtr + 3);
1193        mapParser.parseKeyNil();
1194        assertCLRXException("MsgPackSkip", "tc13_2.DataPtr", "MsgPack: Can't skip object",
1195                    [&mapParser]() { mapParser.skipValue(); });
1196    }
1197    {
1198        Array<cxbyte> tc14(5 + 11232);
1199        tc14[0] = 0x81;
1200        tc14[1] = 0xc0;
1201        tc14[2] = 0xc5;
1202        tc14[3] = (11232)>>8;
1203        tc14[4] = (11232)&255;
1204        for (size_t i = 0; i < tc14.size()-5; i++)
1205            tc14[i+5] = (i^0x80)&0xff;
1206        dataPtr = tc14.data();
1207        MsgPackMapParser mapParser(dataPtr, dataPtr + tc14.size());
1208        mapParser.parseKeyNil();
1209        mapParser.skipValue();
1210        const cxbyte* dataEnd = tc14.end();
1211        assertValue("MsgPackSkip", "tc14.DataPtr", dataPtr, dataEnd);
1212        {
1213            dataPtr = tc14.data();
1214            MsgPackMapParser mapParser(dataPtr, dataPtr + tc14.size()-1);
1215            mapParser.parseKeyNil();
1216            assertCLRXException("MsgPackSkip", "tc14_1.DataPtr",
1217                    "MsgPack: Can't skip object",
1218                    [&mapParser]() { mapParser.skipValue(); });
1219        }
1220        {
1221            dataPtr = tc14.data();
1222            MsgPackMapParser mapParser(dataPtr, dataPtr + 4);
1223            mapParser.parseKeyNil();
1224            assertCLRXException("MsgPackSkip", "tc14_2.DataPtr",
1225                    "MsgPack: Can't skip object",
1226                    [&mapParser]() { mapParser.skipValue(); });
1227        }
1228    }
1229    {
1230        Array<cxbyte> tc15(7 + 4511232);
1231        tc15[0] = 0x81;
1232        tc15[1] = 0xc0;
1233        tc15[2] = 0xc6;
1234        tc15[3] = ((4511232)>>24);
1235        tc15[4] = ((4511232)>>16)&255;
1236        tc15[5] = ((4511232)>>8)&255;
1237        tc15[6] = (4511232)&255;
1238        for (size_t i = 0; i < tc15.size()-7; i++)
1239            tc15[i+7] = (i^0x80)&0xff;
1240        dataPtr = tc15.data();
1241        MsgPackMapParser mapParser(dataPtr, dataPtr + tc15.size());
1242        mapParser.parseKeyNil();
1243        mapParser.skipValue();
1244        const cxbyte* dataEnd = tc15.end();
1245        assertValue("MsgPackSkip", "tc15.DataPtr", dataPtr, dataEnd);
1246        {
1247            dataPtr = tc15.data();
1248            MsgPackMapParser mapParser(dataPtr, dataPtr + tc15.size()-1);
1249            mapParser.parseKeyNil();
1250            assertCLRXException("MsgPackSkip", "tc15_1.DataPtr",
1251                    "MsgPack: Can't skip object",
1252                    [&mapParser]() { mapParser.skipValue(); });
1253        }
1254        {
1255            dataPtr = tc15.data();
1256            MsgPackMapParser mapParser(dataPtr, dataPtr + 6);
1257            mapParser.parseKeyNil();
1258            assertCLRXException("MsgPackSkip", "tc15_2.DataPtr",
1259                    "MsgPack: Can't skip object",
1260                    [&mapParser]() { mapParser.skipValue(); });
1261        }
1262    }
1263    /* skip arrays */
1264    const cxbyte tc16[10] = { 0x81, 0xc0, 0x93, 0x12, 0x92, 0xe9, 0xcd, 0x01, 0x27, 0x45 };
1265    dataPtr = tc16;
1266    {
1267        MsgPackMapParser mapParser(dataPtr, dataPtr + sizeof(tc16));
1268        mapParser.parseKeyNil();
1269        mapParser.skipValue();
1270        assertValue("MsgPackSkip", "tc16.DataPtr", dataPtr, tc16 + sizeof(tc16));
1271    }
1272    const cxbyte tc16_1[12] = { 0x81, 0xc0, 0x93, 0x12, 0xa4, 0x33,
1273                    0x35, 0x37, 0x4a, 0xcd, 0x01, 0x02 };
1274    dataPtr = tc16_1;
1275    {
1276        MsgPackMapParser mapParser(dataPtr, dataPtr + sizeof(tc16_1));
1277        mapParser.parseKeyNil();
1278        mapParser.skipValue();
1279        assertValue("MsgPackSkip", "tc16_1.DataPtr", dataPtr, tc16_1 + sizeof(tc16_1));
1280    }
1281    {
1282        Array<cxbyte> tc17(5 + 11277*3);
1283        tc17[0] = 0x81;
1284        tc17[1] = 0xc0;
1285        tc17[2] = 0xdc;
1286        tc17[3] = (11277)>>8;
1287        tc17[4] = (11277)&255;
1288        for (size_t i = 0; i < tc17.size()-5; i+=3)
1289        {
1290            tc17[i+5] = 0xcd;
1291            tc17[i+5+1] = (i&0xff);
1292            tc17[i+5+2] = ((i>>8)&0xff);
1293        }
1294        dataPtr = tc17.data();
1295        MsgPackMapParser mapParser(dataPtr, dataPtr + tc17.size());
1296        mapParser.parseKeyNil();
1297        mapParser.skipValue();
1298        const cxbyte* dataEnd = tc17.end();
1299        assertValue("MsgPackSkip", "tc17.DataPtr", dataPtr, dataEnd);
1300        {
1301            dataPtr = tc17.data();
1302            MsgPackMapParser mapParser(dataPtr, dataPtr + tc17.size()-1);
1303            mapParser.parseKeyNil();
1304            assertCLRXException("MsgPackSkip", "tc17_1.DataPtr",
1305                    "MsgPack: Can't skip object",
1306                    [&mapParser]() { mapParser.skipValue(); });
1307        }
1308        {
1309            dataPtr = tc17.data();
1310            MsgPackMapParser mapParser(dataPtr, dataPtr + 4);
1311            mapParser.parseKeyNil();
1312            assertCLRXException("MsgPackSkip", "tc17_2.DataPtr",
1313                    "MsgPack: Can't skip object",
1314                    [&mapParser]() { mapParser.skipValue(); });
1315        }
1316    }
1317    {
1318        Array<cxbyte> tc18(7 + 3788213*3);
1319        tc18[0] = 0x81;
1320        tc18[1] = 0xc0;
1321        tc18[2] = 0xdd;
1322        tc18[3] = (3788213)>>24;
1323        tc18[4] = ((3788213)>>16)&255;
1324        tc18[5] = ((3788213)>>8)&255;
1325        tc18[6] = (3788213)&255;
1326        for (size_t i = 0; i < tc18.size()-7; i+=3)
1327        {
1328            tc18[i+7] = 0xcd;
1329            tc18[i+7+1] = (i&0xff);
1330            tc18[i+7+2] = ((i>>8)&0xff);
1331        }
1332        dataPtr = tc18.data();
1333        MsgPackMapParser mapParser(dataPtr, dataPtr + tc18.size());
1334        mapParser.parseKeyNil();
1335        mapParser.skipValue();
1336        const cxbyte* dataEnd = tc18.end();
1337        assertValue("MsgPackSkip", "tc18.DataPtr", dataPtr, dataEnd);
1338        {
1339            dataPtr = tc18.data();
1340            MsgPackMapParser mapParser(dataPtr, dataPtr + tc18.size()-1);
1341            mapParser.parseKeyNil();
1342            assertCLRXException("MsgPackSkip", "tc18_1.DataPtr",
1343                    "MsgPack: Can't skip object",
1344                    [&mapParser]() { mapParser.skipValue(); });
1345        }
1346        {
1347            dataPtr = tc18.data();
1348            MsgPackMapParser mapParser(dataPtr, dataPtr + 6);
1349            mapParser.parseKeyNil();
1350            assertCLRXException("MsgPackSkip", "tc18_2.DataPtr",
1351                    "MsgPack: Can't skip object",
1352                    [&mapParser]() { mapParser.skipValue(); });
1353        }
1354    }
1355    /* skip maps */
1356    const cxbyte tc19[17] = { 0x81, 0xc0, 0x83, 0xcd, 0x01, 0x33, 0x57,
1357        0x19, 0x11, 0xd1, 0x4b, 0x5c, 0xd2, 0x01, 0x33, 0x55, 0xbf };
1358    dataPtr = tc19;
1359    {
1360        MsgPackMapParser mapParser(dataPtr, dataPtr + sizeof(tc19));
1361        mapParser.parseKeyNil();
1362        mapParser.skipValue();
1363        assertValue("MsgPackSkip", "tc19.DataPtr", dataPtr, tc19 + sizeof(tc19));
1364    }
1365    {
1366        Array<cxbyte> tc20(5 + 8214*3*2);
1367        tc20[0] = 0x81;
1368        tc20[1] = 0xc0;
1369        tc20[2] = 0xde;
1370        tc20[3] = (8214)>>8;
1371        tc20[4] = (8214)&255;
1372        for (size_t i = 0; i < tc20.size()-5; i+=3)
1373        {
1374            tc20[i+5] = 0xcd;
1375            tc20[i+5+1] = (i&0xff);
1376            tc20[i+5+2] = ((i>>8)&0xff);
1377        }
1378        dataPtr = tc20.data();
1379        MsgPackMapParser mapParser(dataPtr, dataPtr + tc20.size());
1380        mapParser.parseKeyNil();
1381        mapParser.skipValue();
1382        const cxbyte* dataEnd = tc20.end();
1383        assertValue("MsgPackSkip", "tc20.DataPtr", dataPtr, dataEnd);
1384        {
1385            dataPtr = tc20.data();
1386            MsgPackMapParser mapParser(dataPtr, dataPtr + tc20.size()-1);
1387            mapParser.parseKeyNil();
1388            assertCLRXException("MsgPackSkip", "tc20_1.DataPtr",
1389                    "MsgPack: Can't skip object",
1390                    [&mapParser]() { mapParser.skipValue(); });
1391        }
1392        {
1393            dataPtr = tc20.data();
1394            MsgPackMapParser mapParser(dataPtr, dataPtr + 4);
1395            mapParser.parseKeyNil();
1396            assertCLRXException("MsgPackSkip", "tc20_2.DataPtr",
1397                    "MsgPack: Can't skip object",
1398                    [&mapParser]() { mapParser.skipValue(); });
1399        }
1400    }
1401    {
1402        Array<cxbyte> tc21(7 + 1662135*3*2);
1403        tc21[0] = 0x81;
1404        tc21[1] = 0xc0;
1405        tc21[2] = 0xdf;
1406        tc21[3] = (1662135)>>24;
1407        tc21[4] = ((1662135)>>16)&255;
1408        tc21[5] = ((1662135)>>8)&255;
1409        tc21[6] = (1662135)&255;
1410        for (size_t i = 0; i < tc21.size()-7; i+=3)
1411        {
1412            tc21[i+7] = 0xcd;
1413            tc21[i+7+1] = (i&0xff);
1414            tc21[i+7+2] = ((i>>8)&0xff);
1415        }
1416        dataPtr = tc21.data();
1417        MsgPackMapParser mapParser(dataPtr, dataPtr + tc21.size());
1418        mapParser.parseKeyNil();
1419        mapParser.skipValue();
1420        const cxbyte* dataEnd = tc21.end();
1421        assertValue("MsgPackSkip", "tc21.DataPtr", dataPtr, dataEnd);
1422        {
1423            dataPtr = tc21.data();
1424            MsgPackMapParser mapParser(dataPtr, dataPtr + tc21.size()-1);
1425            mapParser.parseKeyNil();
1426            assertCLRXException("MsgPackSkip", "tc21_1.DataPtr",
1427                    "MsgPack: Can't skip object",
1428                    [&mapParser]() { mapParser.skipValue(); });
1429        }
1430        {
1431            dataPtr = tc21.data();
1432            MsgPackMapParser mapParser(dataPtr, dataPtr + 6);
1433            mapParser.parseKeyNil();
1434            assertCLRXException("MsgPackSkip", "tc21_2.DataPtr",
1435                    "MsgPack: Can't skip object",
1436                    [&mapParser]() { mapParser.skipValue(); });
1437        }
1438    }
1439}
1440
1441struct ROCmMsgPackMDTestCase
1442{
1443    size_t inputSize;
1444    const cxbyte* input;      // input metadata string
1445    ROCmMetadata expected;
1446    bool good;
1447    const char* error;
1448};
1449
1450static const cxbyte rocmMsgPackInput0[] =
1451{
1452    0x82,
1453    0xae, 'a', 'm', 'd', 'h', 's', 'a', '.', 'k', 'e', 'r', 'n', 'e', 'l', 's',
1454    0x91,
1455    // kernel A
1456    0x8f,
1457    0xa5, '.', 'a', 'r', 'g', 's',
1458    // kernel args
1459    0x98,
1460    0x88,
1461        0xae, '.', 'a', 'd', 'd', 'r', 'e', 's', 's', '_', 's', 'p', 'a', 'c', 'e',
1462            0xa6, 'g', 'l', 'o', 'b', 'a', 'l',
1463        0xa9, '.', 'i', 's', '_', 'c', 'o', 'n', 's', 't', 0xc3,
1464        0xa5, '.', 'n', 'a', 'm', 'e', 0xa2, 'i', 'n',
1465        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x00,
1466        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1467        0xaa, '.', 't', 'y', 'p', 'e', '_', 'n', 'a', 'm', 'e',
1468            0xa6, 'f', 'l', 'o', 'a', 't', '*',
1469        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1470            0xad, 'g', 'l', 'o', 'b', 'a', 'l', '_', 'b', 'u', 'f', 'f', 'e', 'r',
1471        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'f', '3', '2',
1472    0x87,
1473        0xae, '.', 'a', 'd', 'd', 'r', 'e', 's', 's', '_', 's', 'p', 'a', 'c', 'e',
1474            0xa6, 'g', 'l', 'o', 'b', 'a', 'l',
1475        0xa5, '.', 'n', 'a', 'm', 'e', 0xa3, 'o', 'u', 't',
1476        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x08,
1477        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1478        0xaa, '.', 't', 'y', 'p', 'e', '_', 'n', 'a', 'm', 'e',
1479            0xa6, 'f', 'l', 'o', 'a', 't', '*',
1480        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1481            0xad, 'g', 'l', 'o', 'b', 'a', 'l', '_', 'b', 'u', 'f', 'f', 'e', 'r',
1482        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'f', '3', '2',
1483    0x86,
1484        0xa5, '.', 'n', 'a', 'm', 'e', 0xa1, 'n',
1485        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x10,
1486        0xa5, '.', 's', 'i', 'z', 'e', 0x04,
1487        0xaa, '.', 't', 'y', 'p', 'e', '_', 'n', 'a', 'm', 'e', 0xa3, 'i', 'n', 't',
1488        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1489            0xa8, 'b', 'y', '_', 'v', 'a', 'l', 'u', 'e',
1490        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'i', '3', '2',
1491    0x84,
1492        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x18,
1493        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1494        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1495            0xb6, 'h', 'i', 'd', 'd', 'e', 'n', '_', 'g', 'l', 'o', 'b', 'a', 'l', '_',
1496            'o', 'f', 'f', 's', 'e', 't', '_', 'x',
1497        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'i', '6', '4',
1498    0x84,
1499        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x20,
1500        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1501        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1502            0xb6, 'h', 'i', 'd', 'd', 'e', 'n', '_', 'g', 'l', 'o', 'b', 'a', 'l', '_',
1503            'o', 'f', 'f', 's', 'e', 't', '_', 'y',
1504        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'i', '6', '4',
1505    0x84,
1506        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x28,
1507        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1508        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1509            0xb6, 'h', 'i', 'd', 'd', 'e', 'n', '_', 'g', 'l', 'o', 'b', 'a', 'l', '_',
1510            'o', 'f', 'f', 's', 'e', 't', '_', 'z',
1511        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'i', '6', '4',
1512    0x85,
1513        0xae, '.', 'a', 'd', 'd', 'r', 'e', 's', 's', '_', 's', 'p', 'a', 'c', 'e',
1514            0xa6, 'g', 'l', 'o', 'b', 'a', 'l',
1515        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x30,
1516        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1517        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1518            0xab, 'h', 'i', 'd', 'd', 'e', 'n', '_', 'n', 'o', 'n', 'e',
1519        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa2, 'i', '8',
1520    0x85,
1521        0xae, '.', 'a', 'd', 'd', 'r', 'e', 's', 's', '_', 's', 'p', 'a', 'c', 'e',
1522            0xa6, 'g', 'l', 'o', 'b', 'a', 'l',
1523        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x38,
1524        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1525        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1526            0xab, 'h', 'i', 'd', 'd', 'e', 'n', '_', 'n', 'o', 'n', 'e',
1527        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa2, 'i', '8',
1528    // rest of kernel metadata
1529    0xb9, '.', 'g', 'r', 'o', 'u', 'p', '_', 's', 'e', 'g', 'm', 'e', 'n', 't', '_',
1530        'f', 'i', 'x', 'e', 'd', '_', 's', 'i', 'z', 'e', 0x00,
1531    0xb6, '.', 'k', 'e', 'r', 'n', 'a', 'r', 'g', '_', 's', 'e', 'g', 'm', 'e', 'n', 't',
1532        '_', 'a', 'l', 'i', 'g', 'n', 0x08,
1533    0xb5, '.', 'k', 'e', 'r', 'n', 'a', 'r', 'g', '_', 's', 'e', 'g', 'm', 'e', 'n', 't',
1534        '_', 's', 'i', 'z', 'e', 0x40,
1535    0xa9, '.', 'l', 'a', 'n', 'g', 'u', 'a', 'g', 'e',
1536        0xa8, 'O', 'p', 'e', 'n', 'C', 'L', ' ', 'C',
1537    0xb1, '.', 'l', 'a', 'n', 'g', 'u', 'a', 'g', 'e', '_',
1538        'v', 'e', 'r', 's', 'i', 'o', 'n', 0x92, 0x01, 0x02,
1539    0xb8, '.', 'm', 'a', 'x', '_', 'f', 'l', 'a', 't', '_', 'w', 'o', 'r', 'k',
1540        'g', 'r', 'o', 'u', 'p', '_', 's', 'i', 'z', 'e', 0xcd, 0x01, 0x00,
1541    0xa5, '.', 'n', 'a', 'm', 'e', 0xa7, 'v', 'e', 'c', 'p', 'r', 'o', 'c',
1542    0xbb, '.', 'p', 'r', 'i', 'v', 'a', 't', 'e', '_', 's', 'e', 'g', 'm', 'e', 'n', 't',
1543        '_', 'f', 'i', 'x', 'e', 'd', '_', 's', 'i', 'z', 'e', 0x00,
1544    0xab, '.', 's', 'g', 'p', 'r', '_', 'c', 'o', 'u', 'n', 't', 0x1a,
1545    0xb1, '.', 's', 'g', 'p', 'r', '_', 's', 'p', 'i', 'l', 'l', '_',
1546            'c', 'o', 'u', 'n', 't', 0x02,
1547    0xa7, '.', 's', 'y', 'm', 'b', 'o', 'l',
1548        0xaa, 'v', 'e', 'c', 'p', 'r', 'o', 'c', '.', 'k', 'd',
1549    0xab, '.', 'v', 'g', 'p', 'r', '_', 'c', 'o', 'u', 'n', 't', 0x06,
1550    0xb1, '.', 'v', 'g', 'p', 'r', '_', 's', 'p', 'i', 'l', 'l', '_',
1551            'c', 'o', 'u', 'n', 't', 0x03,
1552    0xaf, '.', 'w', 'a', 'v', 'e', 'f', 'r', 'o', 'n', 't', '_', 's', 'i', 'z', 'e', 0x20,
1553    // version
1554    0xae, 'a', 'm', 'd', 'h', 's', 'a', '.', 'v', 'e', 'r', 's', 'i', 'o', 'n',
1555        0x92, 0x01, 0x00
1556};
1557
1558static const cxbyte rocmMsgPackInput1[] =
1559{
1560    0x83,
1561    0xae, 'a', 'm', 'd', 'h', 's', 'a', '.', 'k', 'e', 'r', 'n', 'e', 'l', 's',
1562    0x91,
1563    // kernel A
1564    0xde, 0x00, 0x13,
1565    0xa5, '.', 'a', 'r', 'g', 's',
1566    // kernel args
1567    0xdc, 0x00, 0x13,
1568    0x88,   // 0
1569        0xae, '.', 'a', 'd', 'd', 'r', 'e', 's', 's', '_', 's', 'p', 'a', 'c', 'e',
1570            0xa6, 'g', 'l', 'o', 'b', 'a', 'l',
1571        0xa9, '.', 'i', 's', '_', 'c', 'o', 'n', 's', 't', 0xc3,
1572        0xa5, '.', 'n', 'a', 'm', 'e', 0xa3, 'i', 'n', '0',
1573        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x00,
1574        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1575        0xaa, '.', 't', 'y', 'p', 'e', '_', 'n', 'a', 'm', 'e',
1576            0xa6, 'f', 'l', 'o', 'a', 't', '*',
1577        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1578            0xad, 'g', 'l', 'o', 'b', 'a', 'l', '_', 'b', 'u', 'f', 'f', 'e', 'r',
1579        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa2, 'i', '8',
1580    0x88,   // 1
1581        0xae, '.', 'a', 'd', 'd', 'r', 'e', 's', 's', '_', 's', 'p', 'a', 'c', 'e',
1582            0xa8, 'c', 'o', 'n', 's', 't', 'a', 'n', 't',
1583        0xac, '.', 'i', 's', '_', 'v', 'o', 'l', 'a', 't', 'i', 'l', 'e', 0xc3,
1584        0xa5, '.', 'n', 'a', 'm', 'e', 0xa3, 'i', 'n', '1',
1585        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x08,
1586        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1587        0xaa, '.', 't', 'y', 'p', 'e', '_', 'n', 'a', 'm', 'e',
1588            0xa6, 'f', 'l', 'o', 'a', 't', '*',
1589        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1590            0xad, 'g', 'l', 'o', 'b', 'a', 'l', '_', 'b', 'u', 'f', 'f', 'e', 'r',
1591        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa2, 'u', '8',
1592    0x88,   // 2
1593        0xae, '.', 'a', 'd', 'd', 'r', 'e', 's', 's', '_', 's', 'p', 'a', 'c', 'e',
1594            0xa7, 'p', 'r', 'i', 'v', 'a', 't', 'e',
1595        0xac, '.', 'i', 's', '_', 'r', 'e', 's', 't', 'r', 'i', 'c', 't', 0xc3,
1596        0xa5, '.', 'n', 'a', 'm', 'e', 0xa3, 'i', 'n', '2',
1597        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x10,
1598        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1599        0xaa, '.', 't', 'y', 'p', 'e', '_', 'n', 'a', 'm', 'e',
1600            0xa6, 'f', 'l', 'o', 'a', 't', '*',
1601        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1602            0xad, 'g', 'l', 'o', 'b', 'a', 'l', '_', 'b', 'u', 'f', 'f', 'e', 'r',
1603        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'i', '1', '6',
1604    0x88,   // 3
1605        0xae, '.', 'a', 'd', 'd', 'r', 'e', 's', 's', '_', 's', 'p', 'a', 'c', 'e',
1606            0xa5, 'l', 'o', 'c', 'a', 'l',
1607        0xa9, '.', 'i', 's', '_', 'c', 'o', 'n', 's', 't', 0xc3,
1608        0xa5, '.', 'n', 'a', 'm', 'e', 0xa3, 'i', 'n', '3',
1609        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x18,
1610        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1611        0xaa, '.', 't', 'y', 'p', 'e', '_', 'n', 'a', 'm', 'e',
1612            0xa6, 'f', 'l', 'o', 'a', 't', '*',
1613        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1614            0xad, 'g', 'l', 'o', 'b', 'a', 'l', '_', 'b', 'u', 'f', 'f', 'e', 'r',
1615        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'u', '1', '6',
1616    0x88,   // 4
1617        0xae, '.', 'a', 'd', 'd', 'r', 'e', 's', 's', '_', 's', 'p', 'a', 'c', 'e',
1618            0xa7, 'g', 'e', 'n', 'e', 'r', 'i', 'c',
1619        0xa9, '.', 'i', 's', '_', 'c', 'o', 'n', 's', 't', 0xc3,
1620        0xa5, '.', 'n', 'a', 'm', 'e', 0xa3, 'i', 'n', '4',
1621        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x20,
1622        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1623        0xaa, '.', 't', 'y', 'p', 'e', '_', 'n', 'a', 'm', 'e',
1624            0xa6, 'f', 'l', 'o', 'a', 't', '*',
1625        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1626            0xad, 'g', 'l', 'o', 'b', 'a', 'l', '_', 'b', 'u', 'f', 'f', 'e', 'r',
1627        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'i', '3', '2',
1628    0x88,   // 5
1629        0xae, '.', 'a', 'd', 'd', 'r', 'e', 's', 's', '_', 's', 'p', 'a', 'c', 'e',
1630            0xa6, 'r', 'e', 'g', 'i', 'o', 'n',
1631        0xa9, '.', 'i', 's', '_', 'c', 'o', 'n', 's', 't', 0xc3,
1632        0xa5, '.', 'n', 'a', 'm', 'e', 0xa3, 'i', 'n', '5',
1633        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x28,
1634        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1635        0xaa, '.', 't', 'y', 'p', 'e', '_', 'n', 'a', 'm', 'e',
1636            0xa6, 'f', 'l', 'o', 'a', 't', '*',
1637        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1638            0xad, 'g', 'l', 'o', 'b', 'a', 'l', '_', 'b', 'u', 'f', 'f', 'e', 'r',
1639        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'u', '3', '2',
1640    0x88,   // 6
1641        0xae, '.', 'a', 'd', 'd', 'r', 'e', 's', 's', '_', 's', 'p', 'a', 'c', 'e',
1642            0xa6, 'g', 'l', 'o', 'b', 'a', 'l',
1643        0xa9, '.', 'i', 's', '_', 'c', 'o', 'n', 's', 't', 0xc3,
1644        0xa5, '.', 'n', 'a', 'm', 'e', 0xa3, 'i', 'n', '6',
1645        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x30,
1646        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1647        0xaa, '.', 't', 'y', 'p', 'e', '_', 'n', 'a', 'm', 'e',
1648            0xa6, 'f', 'l', 'o', 'a', 't', '*',
1649        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1650            0xa5, 'q', 'u', 'e', 'u', 'e',
1651        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'f', '3', '2',
1652    0x89,   // 7
1653        0xae, '.', 'a', 'd', 'd', 'r', 'e', 's', 's', '_', 's', 'p', 'a', 'c', 'e',
1654            0xa6, 'g', 'l', 'o', 'b', 'a', 'l',
1655        0xa8, '.', 'i', 's', '_', 'p', 'i', 'p', 'e', 0xc3,
1656        0xa5, '.', 'n', 'a', 'm', 'e', 0xa3, 'i', 'n', '7',
1657        0xa7, '.', 'a', 'c', 'c', 'e', 's', 's',
1658            0xa9, 'r', 'e', 'a', 'd', '_', 'o', 'n', 'l', 'y',
1659        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x38,
1660        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1661        0xaa, '.', 't', 'y', 'p', 'e', '_', 'n', 'a', 'm', 'e',
1662            0xa6, 'f', 'l', 'o', 'a', 't', '*',
1663        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1664            0xa4, 'p', 'i', 'p', 'e',
1665        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'i', '6', '4',
1666    0x89,   // 8
1667        0xae, '.', 'a', 'd', 'd', 'r', 'e', 's', 's', '_', 's', 'p', 'a', 'c', 'e',
1668            0xa6, 'g', 'l', 'o', 'b', 'a', 'l',
1669        0xa9, '.', 'i', 's', '_', 'c', 'o', 'n', 's', 't', 0xc3,
1670        0xa7, '.', 'a', 'c', 'c', 'e', 's', 's',
1671            0xaa, 'r', 'e', 'a', 'd', '_', 'w', 'r', 'i', 't', 'e',
1672        0xa5, '.', 'n', 'a', 'm', 'e', 0xa3, 'i', 'n', '8',
1673        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x40,
1674        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1675        0xaa, '.', 't', 'y', 'p', 'e', '_', 'n', 'a', 'm', 'e',
1676            0xa9, 'i', 'm', 'a', 'g', 'e', '2', 'd', '_', 't',
1677        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1678            0xa5, 'i', 'm', 'a', 'g', 'e',
1679        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'u', '6', '4',
1680    0x88,   // 9
1681        0xae, '.', 'a', 'd', 'd', 'r', 'e', 's', 's', '_', 's', 'p', 'a', 'c', 'e',
1682            0xa6, 'g', 'l', 'o', 'b', 'a', 'l',
1683        0xa9, '.', 'i', 's', '_', 'c', 'o', 'n', 's', 't', 0xc3,
1684        0xa5, '.', 'n', 'a', 'm', 'e', 0xa3, 'i', 'n', '9',
1685        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x48,
1686        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1687        0xaa, '.', 't', 'y', 'p', 'e', '_', 'n', 'a', 'm', 'e',
1688            0xa9, 's', 'a', 'm', 'p', 'l', 'e', 'r', '_', 't',
1689        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1690            0xa7, 's', 'a', 'm', 'p', 'l', 'e', 'r',
1691        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'f', '6', '4',
1692    0x88,   // 10
1693        0xae, '.', 'a', 'd', 'd', 'r', 'e', 's', 's', '_', 's', 'p', 'a', 'c', 'e',
1694            0xa6, 'g', 'l', 'o', 'b', 'a', 'l',
1695        0xa9, '.', 'i', 's', '_', 'c', 'o', 'n', 's', 't', 0xc3,
1696        0xa5, '.', 'n', 'a', 'm', 'e', 0xa4, 'i', 'n', '1', '0',
1697        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x50,
1698        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1699        0xaa, '.', 't', 'y', 'p', 'e', '_', 'n', 'a', 'm', 'e',
1700            0xa6, 'f', 'l', 'o', 'a', 't', '*',
1701        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1702            0xb6, 'd', 'y', 'n', 'a', 'm', 'i', 'c', '_', 's', 'h', 'a', 'r', 'e', 'd', '_',
1703                'p', 'o', 'i', 'n', 't', 'e', 'r',
1704        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e',
1705            0xa6, 's', 't', 'r', 'u', 'c', 't',
1706    0x86,   // 11
1707        0xa5, '.', 'n', 'a', 'm', 'e', 0xa1, 'n',
1708        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x58,
1709        0xa5, '.', 's', 'i', 'z', 'e', 0x04,
1710        0xaa, '.', 't', 'y', 'p', 'e', '_', 'n', 'a', 'm', 'e', 0xa3, 'i', 'n', 't',
1711        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1712            0xa8, 'b', 'y', '_', 'v', 'a', 'l', 'u', 'e',
1713        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'i', '3', '2',
1714    0x84,   // 12
1715        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x68,
1716        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1717        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1718            0xb6, 'h', 'i', 'd', 'd', 'e', 'n', '_', 'g', 'l', 'o', 'b', 'a', 'l', '_',
1719            'o', 'f', 'f', 's', 'e', 't', '_', 'x',
1720        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'i', '6', '4',
1721    0x84,   // 13
1722        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x70,
1723        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1724        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1725            0xb6, 'h', 'i', 'd', 'd', 'e', 'n', '_', 'g', 'l', 'o', 'b', 'a', 'l', '_',
1726            'o', 'f', 'f', 's', 'e', 't', '_', 'y',
1727        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'i', '6', '4',
1728    0x84,   // 14
1729        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x78,
1730        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1731        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1732            0xb6, 'h', 'i', 'd', 'd', 'e', 'n', '_', 'g', 'l', 'o', 'b', 'a', 'l', '_',
1733            'o', 'f', 'f', 's', 'e', 't', '_', 'z',
1734        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'i', '6', '4',
1735    0x84,   // 15
1736        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0xcc, 0x80,
1737        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1738        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1739            0xb4, 'h', 'i', 'd', 'd', 'e', 'n', '_', 'p', 'r', 'i', 'n', 't', 'f', '_',
1740            'b', 'u', 'f', 'f', 'e', 'r',
1741        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'i', '6', '4',
1742    0x84,   // 16
1743        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0xcc, 0x88,
1744        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1745        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1746            0xb4, 'h', 'i', 'd', 'd', 'e', 'n', '_', 'd', 'e', 'f', 'a', 'u', 'l', 't',
1747            '_', 'q', 'u', 'e', 'u', 'e',
1748        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'i', '6', '4',
1749    0x84,   // 17
1750        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0xcc, 0x90,
1751        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1752        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1753            0xb8, 'h', 'i', 'd', 'd', 'e', 'n', '_', 'c', 'o', 'm', 'p', 'l', 'e', 't',
1754            'i', 'o', 'n', '_', 'a', 'c', 't', 'i', 'o', 'n',
1755        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'i', '6', '4',
1756    0x84,   // 18
1757        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0xcc, 0x98,
1758        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1759        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1760            0xb9, 'h', 'i', 'd', 'd', 'e', 'n', '_', 'm', 'u', 'l', 't', 'i', 'g', 'r',
1761            'i', 'd', '_', 's', 'y', 'n', 'c', '_', 'a', 'r', 'g',
1762        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'i', '6', '4',
1763    0xb6, '.', 'd', 'e', 'v', 'i', 'c', 'e', '_', 'e', 'n', 'q', 'u', 'e', 'u', 'e', '_',
1764        's', 'y', 'm', 'b', 'o', 'l', 0xa4, 'a', 'b', 'c', 'd',
1765    0xb9, '.', 'g', 'r', 'o', 'u', 'p', '_', 's', 'e', 'g', 'm', 'e', 'n', 't', '_',
1766        'f', 'i', 'x', 'e', 'd', '_', 's', 'i', 'z', 'e', 0x48,
1767    0xb6, '.', 'k', 'e', 'r', 'n', 'a', 'r', 'g', '_', 's', 'e', 'g', 'm', 'e', 'n', 't',
1768        '_', 'a', 'l', 'i', 'g', 'n', 0x10,
1769    0xb5, '.', 'k', 'e', 'r', 'n', 'a', 'r', 'g', '_', 's', 'e', 'g', 'm', 'e', 'n', 't',
1770        '_', 's', 'i', 'z', 'e', 0xcc, 0xa0,
1771    0xa9, '.', 'l', 'a', 'n', 'g', 'u', 'a', 'g', 'e',
1772        0xa8, 'O', 'p', 'e', 'n', 'C', 'L', ' ', 'C',
1773    0xb1, '.', 'l', 'a', 'n', 'g', 'u', 'a', 'g', 'e', '_',
1774        'v', 'e', 'r', 's', 'i', 'o', 'n', 0x92, 0x03, 0x02,
1775    0xb8, '.', 'm', 'a', 'x', '_', 'f', 'l', 'a', 't', '_', 'w', 'o', 'r', 'k',
1776        'g', 'r', 'o', 'u', 'p', '_', 's', 'i', 'z', 'e', 0xcd, 0x01, 0x8c,
1777    0xa5, '.', 'n', 'a', 'm', 'e', 0xa8, 't', 'e', 's', 't', 'e', 'r', 'e', 'k',
1778    0xbb, '.', 'p', 'r', 'i', 'v', 'a', 't', 'e', '_', 's', 'e', 'g', 'm', 'e', 'n', 't',
1779        '_', 'f', 'i', 'x', 'e', 'd', '_', 's', 'i', 'z', 'e', 0x20,
1780    0xb4, '.', 'r', 'e', 'q', 'd', '_', 'w', 'o', 'r', 'k', 'g', 'r', 'o', 'u', 'p', '_',
1781            's', 'i', 'z', 'e', 0x93, 0x06, 0x09, 0x11,
1782    0xab, '.', 's', 'g', 'p', 'r', '_', 'c', 'o', 'u', 'n', 't', 0x2b,
1783    0xb1, '.', 's', 'g', 'p', 'r', '_', 's', 'p', 'i', 'l', 'l', '_',
1784            'c', 'o', 'u', 'n', 't', 0x05,
1785    0xa7, '.', 's', 'y', 'm', 'b', 'o', 'l',
1786        0xab, 't', 'e', 's', 't', 'e', 'r', 'e', 'k', '.', 'k', 'd',
1787    0xae, '.', 'v', 'e', 'c', '_', 't', 'y', 'p', 'e', '_', 'h', 'i', 'n', 't',
1788        0xa5, 'i', 'n', 't', '1', '6',
1789    0xab, '.', 'v', 'g', 'p', 'r', '_', 'c', 'o', 'u', 'n', 't', 0x09,
1790    0xb1, '.', 'v', 'g', 'p', 'r', '_', 's', 'p', 'i', 'l', 'l', '_',
1791            'c', 'o', 'u', 'n', 't', 0x08,
1792    0xaf, '.', 'w', 'a', 'v', 'e', 'f', 'r', 'o', 'n', 't', '_', 's', 'i', 'z', 'e', 0x40,
1793    0xb4, '.', 'w', 'o', 'r', 'k', 'g', 'r', 'o', 'u', 'p', '_', 's', 'i', 'z', 'e', '_',
1794            'h', 'i', 'n', 't', 0x93, 0x04, 0x0b, 0x05,
1795    // printf infos
1796    0xad, 'a', 'm', 'd', 'h', 's', 'a', '.', 'p', 'r', 'i', 'n', 't', 'f', 0x92,
1797        0xd9, 0x20, '2', ':', '4', ':', '4', ':', '4', ':', '4', ':', '4', ':','i', '=',
1798        '%', 'd', ',', 'a', '=', '%', 'f', ',', 'b', '=', '%', 'f', ',',
1799        'c', '=', '%', 'f', 0x0d,
1800        0xaf, '1', ':', '1', ':', '4', ':', 'i', 'n', 'd', 'e', 'x', 'a', '%', 'd', 0x0d,
1801    // version
1802    0xae, 'a', 'm', 'd', 'h', 's', 'a', '.', 'v', 'e', 'r', 's', 'i', 'o', 'n',
1803        0x92, 0x27, 0x34
1804};
1805
1806static const ROCmMsgPackMDTestCase rocmMsgPackMDTestCases[] =
1807{
1808    {   // testcase 0
1809        sizeof(rocmMsgPackInput0), rocmMsgPackInput0,
1810        { { 1, 0 }, { }, // printinfos
1811            {
1812                {
1813                    "vecproc", "vecproc.kd",
1814                    {   // args
1815                        { "in", "float*", 8, 0, 0, ROCmValueKind::GLOBAL_BUFFER,
1816                            ROCmValueType::FLOAT32, ROCmAddressSpace::GLOBAL,
1817                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1818                            true, false, false, false },
1819                        { "out", "float*", 8, 8, 0, ROCmValueKind::GLOBAL_BUFFER,
1820                            ROCmValueType::FLOAT32, ROCmAddressSpace::GLOBAL,
1821                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1822                            false, false, false, false },
1823                        { "n", "int", 4, 16, 0, ROCmValueKind::BY_VALUE,
1824                            ROCmValueType::INT32, ROCmAddressSpace::NONE,
1825                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1826                            false, false, false, false },
1827                        { "", "", 8, 24, 0, ROCmValueKind::HIDDEN_GLOBAL_OFFSET_X,
1828                            ROCmValueType::INT64, ROCmAddressSpace::NONE,
1829                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1830                            false, false, false, false },
1831                        { "", "", 8, 32, 0, ROCmValueKind::HIDDEN_GLOBAL_OFFSET_Y,
1832                            ROCmValueType::INT64, ROCmAddressSpace::NONE,
1833                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1834                            false, false, false, false },
1835                        { "", "", 8, 40, 0, ROCmValueKind::HIDDEN_GLOBAL_OFFSET_Z,
1836                            ROCmValueType::INT64, ROCmAddressSpace::NONE,
1837                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1838                            false, false, false, false },
1839                        { "", "", 8, 48, 0, ROCmValueKind::HIDDEN_NONE,
1840                            ROCmValueType::INT8, ROCmAddressSpace::GLOBAL,
1841                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1842                            false, false, false, false },
1843                        { "", "", 8, 56, 0, ROCmValueKind::HIDDEN_NONE,
1844                            ROCmValueType::INT8, ROCmAddressSpace::GLOBAL,
1845                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1846                            false, false, false, false }
1847                    },
1848                    "OpenCL C", { 1, 2 }, { 0, 0, 0 }, { 0, 0, 0 }, "", "",
1849                    64, 0, 0, 8, 32, 26, 6, 256, { 0, 0, 0 }, 2, 3, ""
1850                }
1851            }
1852        }, true, ""
1853    }/*,
1854    {   // testcase 1
1855        sizeof(rocmMsgPackInput1), rocmMsgPackInput1,
1856        {
1857            { 39, 52 },
1858        },
1859        true, ""
1860    }*/
1861};
1862
1863static void testParseROCmMsgPackMDCase(cxuint testId, const ROCmMsgPackMDTestCase& testCase)
1864{
1865    //
1866    ROCmMetadata result{};
1867    result.initialize();
1868    bool good = true;
1869    std::string error;
1870    try
1871    { result.parseMsgPack(testCase.inputSize, testCase.input); }
1872    catch(const std::exception& ex)
1873    {
1874        good = false;
1875        error = ex.what();
1876    }
1877    const ROCmMetadata& expected = testCase.expected;
1878    char testName[30];
1879    snprintf(testName, 30, "Test #%u", testId);
1880    assertValue(testName, "good", testCase.good, good);
1881    assertString(testName, "error", testCase.error, error.c_str());
1882    if (!good)
1883        // do not check if test failed
1884        return;
1885   
1886    assertValue(testName, "version[0]", expected.version[0], result.version[0]);
1887    assertValue(testName, "version[1]", expected.version[1], result.version[1]);
1888    assertValue(testName, "printfInfosNum", expected.printfInfos.size(),
1889                result.printfInfos.size());
1890    char buf[32];
1891    for (cxuint i = 0; i < expected.printfInfos.size(); i++)
1892    {
1893        snprintf(buf, 32, "Printf[%u].", i);
1894        std::string caseName(buf);
1895        const ROCmPrintfInfo& expPrintf = expected.printfInfos[i];
1896        const ROCmPrintfInfo& resPrintf = result.printfInfos[i];
1897        assertValue(testName, caseName+"id", expPrintf.id, resPrintf.id);
1898        assertValue(testName, caseName+"argSizesNum", expPrintf.argSizes.size(),
1899                    resPrintf.argSizes.size());
1900        char buf2[32];
1901        for (cxuint j = 0; j < expPrintf.argSizes.size(); j++)
1902        {
1903            snprintf(buf2, 32, "argSizes[%u]", j);
1904            std::string caseName2(caseName);
1905            caseName2 += buf2;
1906            assertValue(testName, caseName2, expPrintf.argSizes[j], resPrintf.argSizes[j]);
1907        }
1908        assertValue(testName, caseName+"format", expPrintf.format, resPrintf.format);
1909    }
1910   
1911    assertValue(testName, "kernelsNum", expected.kernels.size(), result.kernels.size());
1912    // kernels
1913    for (cxuint i = 0; i < expected.kernels.size(); i++)
1914    {
1915        snprintf(buf, 32, "Kernel[%u].", i);
1916        std::string caseName(buf);
1917        const ROCmKernelMetadata& expKernel = expected.kernels[i];
1918        const ROCmKernelMetadata& resKernel = result.kernels[i];
1919       
1920        assertValue(testName, caseName+"name", expKernel.name, resKernel.name);
1921        assertValue(testName, caseName+"symbolName",
1922                    expKernel.symbolName, resKernel.symbolName);
1923        assertValue(testName, caseName+"argsNum",
1924                    expKernel.argInfos.size(), resKernel.argInfos.size());
1925       
1926        char buf2[32];
1927        for (cxuint j = 0; j < expKernel.argInfos.size(); j++)
1928        {
1929            snprintf(buf2, 32, "args[%u].", j);
1930            std::string caseName2(caseName);
1931            caseName2 += buf2;
1932            const ROCmKernelArgInfo& expArgInfo = expKernel.argInfos[j];
1933            const ROCmKernelArgInfo& resArgInfo = resKernel.argInfos[j];
1934            assertValue(testName, caseName2+"name", expArgInfo.name, resArgInfo.name);
1935            assertValue(testName, caseName2+"typeName",
1936                        expArgInfo.typeName, resArgInfo.typeName);
1937            assertValue(testName, caseName2+"size",
1938                        expArgInfo.size, resArgInfo.size);
1939            assertValue(testName, caseName2+"offset",
1940                        expArgInfo.offset, resArgInfo.offset);
1941            assertValue(testName, caseName2+"pointeeAlign",
1942                        expArgInfo.pointeeAlign, resArgInfo.pointeeAlign);
1943            assertValue(testName, caseName2+"valueKind",
1944                        cxuint(expArgInfo.valueKind), cxuint(resArgInfo.valueKind));
1945            assertValue(testName, caseName2+"valueType",
1946                        cxuint(expArgInfo.valueType), cxuint(resArgInfo.valueType));
1947            assertValue(testName, caseName2+"addressSpace",
1948                        cxuint(expArgInfo.addressSpace), cxuint(resArgInfo.addressSpace));
1949            assertValue(testName, caseName2+"accessQual",
1950                        cxuint(expArgInfo.accessQual), cxuint(resArgInfo.accessQual));
1951            assertValue(testName, caseName2+"actualAccessQual",
1952                cxuint(expArgInfo.actualAccessQual), cxuint(resArgInfo.actualAccessQual));
1953            assertValue(testName, caseName2+"isConst",
1954                        cxuint(expArgInfo.isConst), cxuint(resArgInfo.isConst));
1955            assertValue(testName, caseName2+"isRestrict",
1956                        cxuint(expArgInfo.isRestrict), cxuint(resArgInfo.isRestrict));
1957            assertValue(testName, caseName2+"isPipe",
1958                        cxuint(expArgInfo.isPipe), cxuint(resArgInfo.isPipe));
1959            assertValue(testName, caseName2+"isVolatile",
1960                        cxuint(expArgInfo.isVolatile), cxuint(resArgInfo.isVolatile));
1961        }
1962       
1963        assertValue(testName, caseName+"language", expKernel.language, resKernel.language);
1964        assertValue(testName, caseName+"langVersion[0]", expKernel.langVersion[0],
1965                    resKernel.langVersion[0]);
1966        assertValue(testName, caseName+"langVersion[1]", expKernel.langVersion[1],
1967                    resKernel.langVersion[1]);
1968        assertValue(testName, caseName+"reqdWorkGroupSize[0]",
1969                    expKernel.reqdWorkGroupSize[0], resKernel.reqdWorkGroupSize[0]);
1970        assertValue(testName, caseName+"reqdWorkGroupSize[1]",
1971                    expKernel.reqdWorkGroupSize[1], resKernel.reqdWorkGroupSize[1]);
1972        assertValue(testName, caseName+"reqdWorkGroupSize[2]",
1973                    expKernel.reqdWorkGroupSize[2], resKernel.reqdWorkGroupSize[2]);
1974        assertValue(testName, caseName+"workGroupSizeHint[0]",
1975                    expKernel.workGroupSizeHint[0], resKernel.workGroupSizeHint[0]);
1976        assertValue(testName, caseName+"workGroupSizeHint[1]",
1977                    expKernel.workGroupSizeHint[1], resKernel.workGroupSizeHint[1]);
1978        assertValue(testName, caseName+"workGroupSizeHint[2]",
1979                    expKernel.workGroupSizeHint[2], resKernel.workGroupSizeHint[2]);
1980        assertValue(testName, caseName+"vecTypeHint",
1981                    expKernel.vecTypeHint, resKernel.vecTypeHint);
1982        assertValue(testName, caseName+"runtimeHandle",
1983                    expKernel.runtimeHandle, resKernel.runtimeHandle);
1984        assertValue(testName, caseName+"deviceEnqueueSymbol",
1985                    expKernel.deviceEnqueueSymbol, resKernel.deviceEnqueueSymbol);
1986        assertValue(testName, caseName+"kernargSegmentSize",
1987                    expKernel.kernargSegmentSize, resKernel.kernargSegmentSize);
1988        assertValue(testName, caseName+"groupSegmentFixedSize",
1989                    expKernel.groupSegmentFixedSize, resKernel.groupSegmentFixedSize);
1990        assertValue(testName, caseName+"privateSegmentFixedSize",
1991                    expKernel.privateSegmentFixedSize, resKernel.privateSegmentFixedSize);
1992        assertValue(testName, caseName+"kernargSegmentAlign",
1993                    expKernel.kernargSegmentAlign, resKernel.kernargSegmentAlign);
1994        assertValue(testName, caseName+"wavefrontSize",
1995                    expKernel.wavefrontSize, resKernel.wavefrontSize);
1996        assertValue(testName, caseName+"sgprsNum", expKernel.sgprsNum, resKernel.sgprsNum);
1997        assertValue(testName, caseName+"vgprsNum", expKernel.vgprsNum, resKernel.vgprsNum);
1998        assertValue(testName, caseName+"maxFlatWorkGroupSize",
1999                    expKernel.maxFlatWorkGroupSize, resKernel.maxFlatWorkGroupSize);
2000        assertValue(testName, caseName+"fixedWorkGroupSize[0]",
2001                    expKernel.fixedWorkGroupSize[0], resKernel.fixedWorkGroupSize[0]);
2002        assertValue(testName, caseName+"fixedWorkGroupSize[1]",
2003                    expKernel.fixedWorkGroupSize[1], resKernel.fixedWorkGroupSize[1]);
2004        assertValue(testName, caseName+"fixedWorkGroupSize[2]",
2005                    expKernel.fixedWorkGroupSize[2], resKernel.fixedWorkGroupSize[2]);
2006        assertValue(testName, caseName+"spilledSgprs",
2007                    expKernel.spilledSgprs, resKernel.spilledSgprs);
2008        assertValue(testName, caseName+"spilledVgprs",
2009                    expKernel.spilledVgprs, resKernel.spilledVgprs);
2010    }
2011};
2012
2013int main(int argc, const char** argv)
2014{
2015    int retVal = 0;
2016    retVal |= callTest(testMsgPackBytes);
2017    retVal |= callTest(testMsgPackSkip);
2018    for (cxuint i = 0; i < sizeof(rocmMsgPackMDTestCases)/
2019                            sizeof(ROCmMsgPackMDTestCase); i++)
2020        try
2021        { testParseROCmMsgPackMDCase(i, rocmMsgPackMDTestCases[i]); }
2022        catch(const std::exception& ex)
2023        {
2024            std::cerr << ex.what() << std::endl;
2025            retVal = 1;
2026        }
2027    return retVal;
2028}
Note: See TracBrowser for help on using the repository browser.