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

Last change on this file since 4923 was 4923, checked in by matszpk, 12 months ago

CLRadeonExtender: ROCm: Add parsing printf infos in MsgPack? metadata. Fixing next testcase in ROCmMsgPack.

File size: 98.5 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, 0x14,
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            0xa7, 'i', 'n', 't', '8', '_', '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, 'u', 'c', 'h', 'a', 'r', '*',
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, 'i', 'n', 't', '1', '6', '*',
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            0xa9, 'u', 'i', 'n', 't', '1', '6', '_', '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    0x89,   // 4
1617        0xae, '.', 'a', 'd', 'd', 'r', 'e', 's', 's', '_', 's', 'p', 'a', 'c', 'e',
1618            0xa5, 'l', 'o', 'c', 'a', 'l',
1619        0xa9, '.', 'i', 's', '_', 'c', 'o', 'n', 's', 't', 0xc3,
1620        0xa5, '.', 'n', 'a', 'm', 'e', 0xa4, 'i', 'n', '3', 'x',
1621        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x20,
1622        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1623        0xae, '.', 'p', 'o', 'i', 'n', 't', 'e', 'e', '_', 'a', 'l', 'i', 'g', 'n', 0x08,
1624        0xaa, '.', 't', 'y', 'p', 'e', '_', 'n', 'a', 'm', 'e',
1625            0xa5, 'h', 'a', 'l', 'f', '*',
1626        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1627            0xad, 'g', 'l', 'o', 'b', 'a', 'l', '_', 'b', 'u', 'f', 'f', 'e', 'r',
1628        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'f', '1', '6',
1629    0x88,   // 5
1630        0xae, '.', 'a', 'd', 'd', 'r', 'e', 's', 's', '_', 's', 'p', 'a', 'c', 'e',
1631            0xa7, 'g', 'e', 'n', 'e', 'r', 'i', 'c',
1632        0xa9, '.', 'i', 's', '_', 'c', 'o', 'n', 's', 't', 0xc3,
1633        0xa5, '.', 'n', 'a', 'm', 'e', 0xa3, 'i', 'n', '4',
1634        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x28,
1635        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1636        0xaa, '.', 't', 'y', 'p', 'e', '_', 'n', 'a', 'm', 'e',
1637            0xa6, 'i', 'n', 't', '3', '2', '*',
1638        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1639            0xad, 'g', 'l', 'o', 'b', 'a', 'l', '_', 'b', 'u', 'f', 'f', 'e', 'r',
1640        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'i', '3', '2',
1641    0x88,   // 6
1642        0xae, '.', 'a', 'd', 'd', 'r', 'e', 's', 's', '_', 's', 'p', 'a', 'c', 'e',
1643            0xa6, 'r', 'e', 'g', 'i', 'o', 'n',
1644        0xa9, '.', 'i', 's', '_', 'c', 'o', 'n', 's', 't', 0xc3,
1645        0xa5, '.', 'n', 'a', 'm', 'e', 0xa3, 'i', 'n', '5',
1646        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x30,
1647        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1648        0xaa, '.', 't', 'y', 'p', 'e', '_', 'n', 'a', 'm', 'e',
1649            0xa7, 'u', 'i', 'n', 't', '3', '2', '*',
1650        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1651            0xad, 'g', 'l', 'o', 'b', 'a', 'l', '_', 'b', 'u', 'f', 'f', 'e', 'r',
1652        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'u', '3', '2',
1653    0x88,   // 7
1654        0xae, '.', 'a', 'd', 'd', 'r', 'e', 's', 's', '_', 's', 'p', 'a', 'c', 'e',
1655            0xa6, 'g', 'l', 'o', 'b', 'a', 'l',
1656        0xa9, '.', 'i', 's', '_', 'c', 'o', 'n', 's', 't', 0xc3,
1657        0xa5, '.', 'n', 'a', 'm', 'e', 0xa3, 'i', 'n', '6',
1658        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x38,
1659        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1660        0xaa, '.', 't', 'y', 'p', 'e', '_', 'n', 'a', 'm', 'e',
1661            0xa6, 'f', 'l', 'o', 'a', 't', '*',
1662        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1663            0xa5, 'q', 'u', 'e', 'u', 'e',
1664        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'f', '3', '2',
1665    0x89,   // 8
1666        0xae, '.', 'a', 'd', 'd', 'r', 'e', 's', 's', '_', 's', 'p', 'a', 'c', 'e',
1667            0xa6, 'g', 'l', 'o', 'b', 'a', 'l',
1668        0xa8, '.', 'i', 's', '_', 'p', 'i', 'p', 'e', 0xc3,
1669        0xa5, '.', 'n', 'a', 'm', 'e', 0xa3, 'i', 'n', '7',
1670        0xa7, '.', 'a', 'c', 'c', 'e', 's', 's',
1671            0xa9, 'r', 'e', 'a', 'd', '_', 'o', 'n', 'l', 'y',
1672        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x40,
1673        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1674        0xaa, '.', 't', 'y', 'p', 'e', '_', 'n', 'a', 'm', 'e',
1675            0xa5, 'l', 'o', 'n', 'g', '*',
1676        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1677            0xa4, 'p', 'i', 'p', 'e',
1678        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'i', '6', '4',
1679    0x88,   // 9
1680        0xae, '.', 'a', 'd', 'd', 'r', 'e', 's', 's', '_', 's', 'p', 'a', 'c', 'e',
1681            0xa6, 'g', 'l', 'o', 'b', 'a', 'l',
1682        0xa7, '.', 'a', 'c', 'c', 'e', 's', 's',
1683            0xaa, 'r', 'e', 'a', 'd', '_', 'w', 'r', 'i', 't', 'e',
1684        0xa5, '.', 'n', 'a', 'm', 'e', 0xa3, 'i', 'n', '8',
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, 'i', 'm', 'a', 'g', 'e', '2', 'd', '_', 't',
1689        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1690            0xa5, 'i', 'm', 'a', 'g', 'e',
1691        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'u', '6', '4',
1692    0x87,   // 10
1693        0xae, '.', 'a', 'd', 'd', 'r', 'e', 's', 's', '_', 's', 'p', 'a', 'c', 'e',
1694            0xa6, 'g', 'l', 'o', 'b', 'a', 'l',
1695        0xa5, '.', 'n', 'a', 'm', 'e', 0xa3, 'i', 'n', '9',
1696        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x50,
1697        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1698        0xaa, '.', 't', 'y', 'p', 'e', '_', 'n', 'a', 'm', 'e',
1699            0xa9, 's', 'a', 'm', 'p', 'l', 'e', 'r', '_', 't',
1700        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1701            0xa7, 's', 'a', 'm', 'p', 'l', 'e', 'r',
1702        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'f', '6', '4',
1703    0x87,   // 11
1704        0xae, '.', 'a', 'd', 'd', 'r', 'e', 's', 's', '_', 's', 'p', 'a', 'c', 'e',
1705            0xa6, 'g', 'l', 'o', 'b', 'a', 'l',
1706        0xa5, '.', 'n', 'a', 'm', 'e', 0xa4, 'i', 'n', '1', '0',
1707        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x58,
1708        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1709        0xaa, '.', 't', 'y', 'p', 'e', '_', 'n', 'a', 'm', 'e',
1710            0xa6, 's', 't', 'r', 'u', 'c', '*',
1711        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1712            0xb6, 'd', 'y', 'n', 'a', 'm', 'i', 'c', '_', 's', 'h', 'a', 'r', 'e', 'd', '_',
1713                'p', 'o', 'i', 'n', 't', 'e', 'r',
1714        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e',
1715            0xa6, 's', 't', 'r', 'u', 'c', 't',
1716    0x86,   // 12
1717        0xa5, '.', 'n', 'a', 'm', 'e', 0xa1, 'n',
1718        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x60,
1719        0xa5, '.', 's', 'i', 'z', 'e', 0x04,
1720        0xaa, '.', 't', 'y', 'p', 'e', '_', 'n', 'a', 'm', 'e', 0xa3, 'i', 'n', 't',
1721        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1722            0xa8, 'b', 'y', '_', 'v', 'a', 'l', 'u', 'e',
1723        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'i', '3', '2',
1724    0x84,   // 13
1725        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x70,
1726        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1727        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1728            0xb6, 'h', 'i', 'd', 'd', 'e', 'n', '_', 'g', 'l', 'o', 'b', 'a', 'l', '_',
1729            'o', 'f', 'f', 's', 'e', 't', '_', 'x',
1730        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'i', '6', '4',
1731    0x84,   // 14
1732        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x78,
1733        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1734        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1735            0xb6, 'h', 'i', 'd', 'd', 'e', 'n', '_', 'g', 'l', 'o', 'b', 'a', 'l', '_',
1736            'o', 'f', 'f', 's', 'e', 't', '_', 'y',
1737        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'i', '6', '4',
1738    0x84,   // 15
1739        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0xcc, 0x80,
1740        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1741        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1742            0xb6, 'h', 'i', 'd', 'd', 'e', 'n', '_', 'g', 'l', 'o', 'b', 'a', 'l', '_',
1743            'o', 'f', 'f', 's', 'e', 't', '_', 'z',
1744        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'i', '6', '4',
1745    0x84,   // 16
1746        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0xcc, 0x88,
1747        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1748        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1749            0xb4, 'h', 'i', 'd', 'd', 'e', 'n', '_', 'p', 'r', 'i', 'n', 't', 'f', '_',
1750            'b', 'u', 'f', 'f', 'e', 'r',
1751        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'i', '6', '4',
1752    0x84,   // 17
1753        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0xcc, 0x90,
1754        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1755        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1756            0xb4, 'h', 'i', 'd', 'd', 'e', 'n', '_', 'd', 'e', 'f', 'a', 'u', 'l', 't',
1757            '_', 'q', 'u', 'e', 'u', 'e',
1758        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'i', '6', '4',
1759    0x84,   // 18
1760        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0xcc, 0x98,
1761        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1762        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1763            0xb8, 'h', 'i', 'd', 'd', 'e', 'n', '_', 'c', 'o', 'm', 'p', 'l', 'e', 't',
1764            'i', 'o', 'n', '_', 'a', 'c', 't', 'i', 'o', 'n',
1765        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'i', '6', '4',
1766    0x84,   // 19
1767        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0xcc, 0xa0,
1768        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1769        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1770            0xb9, 'h', 'i', 'd', 'd', 'e', 'n', '_', 'm', 'u', 'l', 't', 'i', 'g', 'r',
1771            'i', 'd', '_', 's', 'y', 'n', 'c', '_', 'a', 'r', 'g',
1772        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'i', '6', '4',
1773    0xb6, '.', 'd', 'e', 'v', 'i', 'c', 'e', '_', 'e', 'n', 'q', 'u', 'e', 'u', 'e', '_',
1774        's', 'y', 'm', 'b', 'o', 'l', 0xa4, 'a', 'b', 'c', 'd',
1775    0xb9, '.', 'g', 'r', 'o', 'u', 'p', '_', 's', 'e', 'g', 'm', 'e', 'n', 't', '_',
1776        'f', 'i', 'x', 'e', 'd', '_', 's', 'i', 'z', 'e', 0x48,
1777    0xb6, '.', 'k', 'e', 'r', 'n', 'a', 'r', 'g', '_', 's', 'e', 'g', 'm', 'e', 'n', 't',
1778        '_', 'a', 'l', 'i', 'g', 'n', 0x10,
1779    0xb5, '.', 'k', 'e', 'r', 'n', 'a', 'r', 'g', '_', 's', 'e', 'g', 'm', 'e', 'n', 't',
1780        '_', 's', 'i', 'z', 'e', 0xcc, 0xa0,
1781    0xa9, '.', 'l', 'a', 'n', 'g', 'u', 'a', 'g', 'e',
1782        0xa8, 'O', 'p', 'e', 'n', 'C', 'L', ' ', 'C',
1783    0xb1, '.', 'l', 'a', 'n', 'g', 'u', 'a', 'g', 'e', '_',
1784        'v', 'e', 'r', 's', 'i', 'o', 'n', 0x92, 0x03, 0x02,
1785    0xb8, '.', 'm', 'a', 'x', '_', 'f', 'l', 'a', 't', '_', 'w', 'o', 'r', 'k',
1786        'g', 'r', 'o', 'u', 'p', '_', 's', 'i', 'z', 'e', 0xcd, 0x01, 0x8c,
1787    0xa5, '.', 'n', 'a', 'm', 'e', 0xa8, 't', 'e', 's', 't', 'e', 'r', 'e', 'k',
1788    0xbb, '.', 'p', 'r', 'i', 'v', 'a', 't', 'e', '_', 's', 'e', 'g', 'm', 'e', 'n', 't',
1789        '_', 'f', 'i', 'x', 'e', 'd', '_', 's', 'i', 'z', 'e', 0x20,
1790    0xb4, '.', 'r', 'e', 'q', 'd', '_', 'w', 'o', 'r', 'k', 'g', 'r', 'o', 'u', 'p', '_',
1791            's', 'i', 'z', 'e', 0x93, 0x06, 0x09, 0x11,
1792    0xab, '.', 's', 'g', 'p', 'r', '_', 'c', 'o', 'u', 'n', 't', 0x2b,
1793    0xb1, '.', 's', 'g', 'p', 'r', '_', 's', 'p', 'i', 'l', 'l', '_',
1794            'c', 'o', 'u', 'n', 't', 0x05,
1795    0xa7, '.', 's', 'y', 'm', 'b', 'o', 'l',
1796        0xab, 't', 'e', 's', 't', 'e', 'r', 'e', 'k', '.', 'k', 'd',
1797    0xae, '.', 'v', 'e', 'c', '_', 't', 'y', 'p', 'e', '_', 'h', 'i', 'n', 't',
1798        0xa5, 'i', 'n', 't', '1', '6',
1799    0xab, '.', 'v', 'g', 'p', 'r', '_', 'c', 'o', 'u', 'n', 't', 0x09,
1800    0xb1, '.', 'v', 'g', 'p', 'r', '_', 's', 'p', 'i', 'l', 'l', '_',
1801            'c', 'o', 'u', 'n', 't', 0x08,
1802    0xaf, '.', 'w', 'a', 'v', 'e', 'f', 'r', 'o', 'n', 't', '_', 's', 'i', 'z', 'e', 0x40,
1803    0xb4, '.', 'w', 'o', 'r', 'k', 'g', 'r', 'o', 'u', 'p', '_', 's', 'i', 'z', 'e', '_',
1804            'h', 'i', 'n', 't', 0x93, 0x04, 0x0b, 0x05,
1805    // printf infos
1806    0xad, 'a', 'm', 'd', 'h', 's', 'a', '.', 'p', 'r', 'i', 'n', 't', 'f', 0x92,
1807        0xd9, 0x20, '2', ':', '4', ':', '4', ':', '4', ':', '4', ':', '4', ':','i', '=',
1808        '%', 'd', ',', 'a', '=', '%', 'f', ',', 'b', '=', '%', 'f', ',',
1809        'c', '=', '%', 'f', 0x0a,
1810        0xaf, '1', ':', '1', ':', '4', ':', 'i', 'n', 'd', 'e', 'x', 'a', '%', 'd', 0x0a,
1811    // version
1812    0xae, 'a', 'm', 'd', 'h', 's', 'a', '.', 'v', 'e', 'r', 's', 'i', 'o', 'n',
1813        0x92, 0x27, 0x34
1814};
1815
1816static const ROCmMsgPackMDTestCase rocmMsgPackMDTestCases[] =
1817{
1818    {   // testcase 0
1819        sizeof(rocmMsgPackInput0), rocmMsgPackInput0,
1820        { { 1, 0 }, { }, // printinfos
1821            {
1822                {   // kernel 1
1823                    "vecproc", "vecproc.kd",
1824                    {   // args
1825                        { "in", "float*", 8, 0, 0, ROCmValueKind::GLOBAL_BUFFER,
1826                            ROCmValueType::FLOAT32, ROCmAddressSpace::GLOBAL,
1827                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1828                            true, false, false, false },
1829                        { "out", "float*", 8, 8, 0, ROCmValueKind::GLOBAL_BUFFER,
1830                            ROCmValueType::FLOAT32, ROCmAddressSpace::GLOBAL,
1831                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1832                            false, false, false, false },
1833                        { "n", "int", 4, 16, 0, ROCmValueKind::BY_VALUE,
1834                            ROCmValueType::INT32, ROCmAddressSpace::NONE,
1835                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1836                            false, false, false, false },
1837                        { "", "", 8, 24, 0, ROCmValueKind::HIDDEN_GLOBAL_OFFSET_X,
1838                            ROCmValueType::INT64, ROCmAddressSpace::NONE,
1839                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1840                            false, false, false, false },
1841                        { "", "", 8, 32, 0, ROCmValueKind::HIDDEN_GLOBAL_OFFSET_Y,
1842                            ROCmValueType::INT64, ROCmAddressSpace::NONE,
1843                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1844                            false, false, false, false },
1845                        { "", "", 8, 40, 0, ROCmValueKind::HIDDEN_GLOBAL_OFFSET_Z,
1846                            ROCmValueType::INT64, ROCmAddressSpace::NONE,
1847                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1848                            false, false, false, false },
1849                        { "", "", 8, 48, 0, ROCmValueKind::HIDDEN_NONE,
1850                            ROCmValueType::INT8, ROCmAddressSpace::GLOBAL,
1851                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1852                            false, false, false, false },
1853                        { "", "", 8, 56, 0, ROCmValueKind::HIDDEN_NONE,
1854                            ROCmValueType::INT8, ROCmAddressSpace::GLOBAL,
1855                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1856                            false, false, false, false }
1857                    },
1858                    "OpenCL C", { 1, 2 }, { 0, 0, 0 }, { 0, 0, 0 }, "", "",
1859                    64, 0, 0, 8, 32, 26, 6, 256, { 0, 0, 0 }, 2, 3, ""
1860                }
1861            }
1862        }, true, ""
1863    },
1864    {   // testcase 1
1865        sizeof(rocmMsgPackInput1), rocmMsgPackInput1,
1866        {
1867            { 39, 52 },
1868            {   // printfInfos
1869                { 2, { 4, 4, 4, 4 }, "i=%d,a=%f,b=%f,c=%f\n" },
1870                { 1, { 4 }, "indexa%d\n" },
1871            },
1872            {   // kernels
1873                { // kernel 1
1874                    "testerek", "testerek.kd",
1875                    {   // args
1876                        { "in0", "int8_t*", 8, 0, 0, ROCmValueKind::GLOBAL_BUFFER,
1877                            ROCmValueType::INT8, ROCmAddressSpace::GLOBAL,
1878                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1879                            true, false, false, false },
1880                        { "in1", "uchar*", 8, 8, 0, ROCmValueKind::GLOBAL_BUFFER,
1881                            ROCmValueType::UINT8, ROCmAddressSpace::CONSTANT,
1882                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1883                            false, false, true, false },
1884                        { "in2", "int16*", 8, 16, 0, ROCmValueKind::GLOBAL_BUFFER,
1885                            ROCmValueType::INT16, ROCmAddressSpace::PRIVATE,
1886                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1887                            false, true, false, false },
1888                        { "in3", "uint16_t*", 8, 24, 0, ROCmValueKind::GLOBAL_BUFFER,
1889                            ROCmValueType::UINT16, ROCmAddressSpace::LOCAL,
1890                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1891                            true, false, false, false },
1892                        { "in3x", "half*", 8, 32, 8, ROCmValueKind::GLOBAL_BUFFER,
1893                            ROCmValueType::FLOAT16, ROCmAddressSpace::LOCAL,
1894                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1895                            true, false, false, false },
1896                        { "in4", "int32*", 8, 40, 0, ROCmValueKind::GLOBAL_BUFFER,
1897                            ROCmValueType::INT32, ROCmAddressSpace::GENERIC,
1898                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1899                            true, false, false, false },
1900                        { "in5", "uint32*", 8, 48, 0, ROCmValueKind::GLOBAL_BUFFER,
1901                            ROCmValueType::UINT32, ROCmAddressSpace::REGION,
1902                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1903                            true, false, false, false },
1904                        { "in6", "float*", 8, 56, 0, ROCmValueKind::QUEUE,
1905                            ROCmValueType::FLOAT32, ROCmAddressSpace::GLOBAL,
1906                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1907                            true, false, false, false },
1908                        { "in7", "long*", 8, 64, 0, ROCmValueKind::PIPE,
1909                            ROCmValueType::INT64, ROCmAddressSpace::GLOBAL,
1910                            ROCmAccessQual::READ_ONLY, ROCmAccessQual::DEFAULT,
1911                            false, false, false, true },
1912                        { "in8", "image2d_t", 8, 72, 0, ROCmValueKind::IMAGE,
1913                            ROCmValueType::UINT64, ROCmAddressSpace::GLOBAL,
1914                            ROCmAccessQual::READ_WRITE, ROCmAccessQual::DEFAULT,
1915                            false, false, false, false },
1916                        { "in9", "sampler_t", 8, 80, 0, ROCmValueKind::SAMPLER,
1917                            ROCmValueType::FLOAT64, ROCmAddressSpace::GLOBAL,
1918                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1919                            false, false, false, false },
1920                        { "in10", "struc*", 8, 88, 0, ROCmValueKind::DYN_SHARED_PTR,
1921                            ROCmValueType::STRUCTURE, ROCmAddressSpace::GLOBAL,
1922                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1923                            false, false, false, false },
1924                        { "n", "int", 4, 96, 0, ROCmValueKind::BY_VALUE,
1925                            ROCmValueType::INT32, ROCmAddressSpace::NONE,
1926                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1927                            false, false, false, false },
1928                        { "", "", 8, 112, 0, ROCmValueKind::HIDDEN_GLOBAL_OFFSET_X,
1929                            ROCmValueType::INT64, ROCmAddressSpace::NONE,
1930                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1931                            false, false, false, false },
1932                        { "", "", 8, 120, 0, ROCmValueKind::HIDDEN_GLOBAL_OFFSET_Y,
1933                            ROCmValueType::INT64, ROCmAddressSpace::NONE,
1934                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1935                            false, false, false, false },
1936                        { "", "", 8, 128, 0, ROCmValueKind::HIDDEN_GLOBAL_OFFSET_Z,
1937                            ROCmValueType::INT64, ROCmAddressSpace::NONE,
1938                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1939                            false, false, false, false },
1940                        { "", "", 8, 136, 0, ROCmValueKind::HIDDEN_PRINTF_BUFFER,
1941                            ROCmValueType::INT64, ROCmAddressSpace::NONE,
1942                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1943                            false, false, false, false },
1944                        { "", "", 8, 144, 0, ROCmValueKind::HIDDEN_DEFAULT_QUEUE,
1945                            ROCmValueType::INT64, ROCmAddressSpace::NONE,
1946                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1947                            false, false, false, false },
1948                        { "", "", 8, 152, 0, ROCmValueKind::HIDDEN_COMPLETION_ACTION,
1949                            ROCmValueType::INT64, ROCmAddressSpace::NONE,
1950                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1951                            false, false, false, false },
1952                        { "", "", 8, 160, 0, ROCmValueKind::HIDDEN_MULTIGRID_SYNC_ARG,
1953                            ROCmValueType::INT64, ROCmAddressSpace::NONE,
1954                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1955                            false, false, false, false }
1956                    }
1957                }
1958            }
1959        },
1960        true, ""
1961    }
1962};
1963
1964static void testParseROCmMsgPackMDCase(cxuint testId, const ROCmMsgPackMDTestCase& testCase)
1965{
1966    //
1967    ROCmMetadata result{};
1968    result.initialize();
1969    bool good = true;
1970    std::string error;
1971    try
1972    { result.parseMsgPack(testCase.inputSize, testCase.input); }
1973    catch(const std::exception& ex)
1974    {
1975        good = false;
1976        error = ex.what();
1977    }
1978    const ROCmMetadata& expected = testCase.expected;
1979    char testName[30];
1980    snprintf(testName, 30, "Test #%u", testId);
1981    assertValue(testName, "good", testCase.good, good);
1982    assertString(testName, "error", testCase.error, error.c_str());
1983    if (!good)
1984        // do not check if test failed
1985        return;
1986   
1987    assertValue(testName, "version[0]", expected.version[0], result.version[0]);
1988    assertValue(testName, "version[1]", expected.version[1], result.version[1]);
1989    assertValue(testName, "printfInfosNum", expected.printfInfos.size(),
1990                result.printfInfos.size());
1991    char buf[32];
1992    for (cxuint i = 0; i < expected.printfInfos.size(); i++)
1993    {
1994        snprintf(buf, 32, "Printf[%u].", i);
1995        std::string caseName(buf);
1996        const ROCmPrintfInfo& expPrintf = expected.printfInfos[i];
1997        const ROCmPrintfInfo& resPrintf = result.printfInfos[i];
1998        assertValue(testName, caseName+"id", expPrintf.id, resPrintf.id);
1999        assertValue(testName, caseName+"argSizesNum", expPrintf.argSizes.size(),
2000                    resPrintf.argSizes.size());
2001        char buf2[32];
2002        for (cxuint j = 0; j < expPrintf.argSizes.size(); j++)
2003        {
2004            snprintf(buf2, 32, "argSizes[%u]", j);
2005            std::string caseName2(caseName);
2006            caseName2 += buf2;
2007            assertValue(testName, caseName2, expPrintf.argSizes[j], resPrintf.argSizes[j]);
2008        }
2009        assertValue(testName, caseName+"format", expPrintf.format, resPrintf.format);
2010    }
2011   
2012    assertValue(testName, "kernelsNum", expected.kernels.size(), result.kernels.size());
2013    // kernels
2014    for (cxuint i = 0; i < expected.kernels.size(); i++)
2015    {
2016        snprintf(buf, 32, "Kernel[%u].", i);
2017        std::string caseName(buf);
2018        const ROCmKernelMetadata& expKernel = expected.kernels[i];
2019        const ROCmKernelMetadata& resKernel = result.kernels[i];
2020       
2021        assertValue(testName, caseName+"name", expKernel.name, resKernel.name);
2022        assertValue(testName, caseName+"symbolName",
2023                    expKernel.symbolName, resKernel.symbolName);
2024        assertValue(testName, caseName+"argsNum",
2025                    expKernel.argInfos.size(), resKernel.argInfos.size());
2026       
2027        char buf2[32];
2028        for (cxuint j = 0; j < expKernel.argInfos.size(); j++)
2029        {
2030            snprintf(buf2, 32, "args[%u].", j);
2031            std::string caseName2(caseName);
2032            caseName2 += buf2;
2033            const ROCmKernelArgInfo& expArgInfo = expKernel.argInfos[j];
2034            const ROCmKernelArgInfo& resArgInfo = resKernel.argInfos[j];
2035            assertValue(testName, caseName2+"name", expArgInfo.name, resArgInfo.name);
2036            assertValue(testName, caseName2+"typeName",
2037                        expArgInfo.typeName, resArgInfo.typeName);
2038            assertValue(testName, caseName2+"size",
2039                        expArgInfo.size, resArgInfo.size);
2040            assertValue(testName, caseName2+"offset",
2041                        expArgInfo.offset, resArgInfo.offset);
2042            assertValue(testName, caseName2+"pointeeAlign",
2043                        expArgInfo.pointeeAlign, resArgInfo.pointeeAlign);
2044            assertValue(testName, caseName2+"valueKind",
2045                        cxuint(expArgInfo.valueKind), cxuint(resArgInfo.valueKind));
2046            assertValue(testName, caseName2+"valueType",
2047                        cxuint(expArgInfo.valueType), cxuint(resArgInfo.valueType));
2048            assertValue(testName, caseName2+"addressSpace",
2049                        cxuint(expArgInfo.addressSpace), cxuint(resArgInfo.addressSpace));
2050            assertValue(testName, caseName2+"accessQual",
2051                        cxuint(expArgInfo.accessQual), cxuint(resArgInfo.accessQual));
2052            assertValue(testName, caseName2+"actualAccessQual",
2053                cxuint(expArgInfo.actualAccessQual), cxuint(resArgInfo.actualAccessQual));
2054            assertValue(testName, caseName2+"isConst",
2055                        cxuint(expArgInfo.isConst), cxuint(resArgInfo.isConst));
2056            assertValue(testName, caseName2+"isRestrict",
2057                        cxuint(expArgInfo.isRestrict), cxuint(resArgInfo.isRestrict));
2058            assertValue(testName, caseName2+"isPipe",
2059                        cxuint(expArgInfo.isPipe), cxuint(resArgInfo.isPipe));
2060            assertValue(testName, caseName2+"isVolatile",
2061                        cxuint(expArgInfo.isVolatile), cxuint(resArgInfo.isVolatile));
2062        }
2063       
2064        assertValue(testName, caseName+"language", expKernel.language, resKernel.language);
2065        assertValue(testName, caseName+"langVersion[0]", expKernel.langVersion[0],
2066                    resKernel.langVersion[0]);
2067        assertValue(testName, caseName+"langVersion[1]", expKernel.langVersion[1],
2068                    resKernel.langVersion[1]);
2069        assertValue(testName, caseName+"reqdWorkGroupSize[0]",
2070                    expKernel.reqdWorkGroupSize[0], resKernel.reqdWorkGroupSize[0]);
2071        assertValue(testName, caseName+"reqdWorkGroupSize[1]",
2072                    expKernel.reqdWorkGroupSize[1], resKernel.reqdWorkGroupSize[1]);
2073        assertValue(testName, caseName+"reqdWorkGroupSize[2]",
2074                    expKernel.reqdWorkGroupSize[2], resKernel.reqdWorkGroupSize[2]);
2075        assertValue(testName, caseName+"workGroupSizeHint[0]",
2076                    expKernel.workGroupSizeHint[0], resKernel.workGroupSizeHint[0]);
2077        assertValue(testName, caseName+"workGroupSizeHint[1]",
2078                    expKernel.workGroupSizeHint[1], resKernel.workGroupSizeHint[1]);
2079        assertValue(testName, caseName+"workGroupSizeHint[2]",
2080                    expKernel.workGroupSizeHint[2], resKernel.workGroupSizeHint[2]);
2081        assertValue(testName, caseName+"vecTypeHint",
2082                    expKernel.vecTypeHint, resKernel.vecTypeHint);
2083        assertValue(testName, caseName+"runtimeHandle",
2084                    expKernel.runtimeHandle, resKernel.runtimeHandle);
2085        assertValue(testName, caseName+"deviceEnqueueSymbol",
2086                    expKernel.deviceEnqueueSymbol, resKernel.deviceEnqueueSymbol);
2087        assertValue(testName, caseName+"kernargSegmentSize",
2088                    expKernel.kernargSegmentSize, resKernel.kernargSegmentSize);
2089        assertValue(testName, caseName+"groupSegmentFixedSize",
2090                    expKernel.groupSegmentFixedSize, resKernel.groupSegmentFixedSize);
2091        assertValue(testName, caseName+"privateSegmentFixedSize",
2092                    expKernel.privateSegmentFixedSize, resKernel.privateSegmentFixedSize);
2093        assertValue(testName, caseName+"kernargSegmentAlign",
2094                    expKernel.kernargSegmentAlign, resKernel.kernargSegmentAlign);
2095        assertValue(testName, caseName+"wavefrontSize",
2096                    expKernel.wavefrontSize, resKernel.wavefrontSize);
2097        assertValue(testName, caseName+"sgprsNum", expKernel.sgprsNum, resKernel.sgprsNum);
2098        assertValue(testName, caseName+"vgprsNum", expKernel.vgprsNum, resKernel.vgprsNum);
2099        assertValue(testName, caseName+"maxFlatWorkGroupSize",
2100                    expKernel.maxFlatWorkGroupSize, resKernel.maxFlatWorkGroupSize);
2101        assertValue(testName, caseName+"fixedWorkGroupSize[0]",
2102                    expKernel.fixedWorkGroupSize[0], resKernel.fixedWorkGroupSize[0]);
2103        assertValue(testName, caseName+"fixedWorkGroupSize[1]",
2104                    expKernel.fixedWorkGroupSize[1], resKernel.fixedWorkGroupSize[1]);
2105        assertValue(testName, caseName+"fixedWorkGroupSize[2]",
2106                    expKernel.fixedWorkGroupSize[2], resKernel.fixedWorkGroupSize[2]);
2107        assertValue(testName, caseName+"spilledSgprs",
2108                    expKernel.spilledSgprs, resKernel.spilledSgprs);
2109        assertValue(testName, caseName+"spilledVgprs",
2110                    expKernel.spilledVgprs, resKernel.spilledVgprs);
2111    }
2112};
2113
2114int main(int argc, const char** argv)
2115{
2116    int retVal = 0;
2117    retVal |= callTest(testMsgPackBytes);
2118    retVal |= callTest(testMsgPackSkip);
2119    for (cxuint i = 0; i < sizeof(rocmMsgPackMDTestCases)/
2120                            sizeof(ROCmMsgPackMDTestCase); i++)
2121        try
2122        { testParseROCmMsgPackMDCase(i, rocmMsgPackMDTestCases[i]); }
2123        catch(const std::exception& ex)
2124        {
2125            std::cerr << ex.what() << std::endl;
2126            retVal = 1;
2127        }
2128    return retVal;
2129}
Note: See TracBrowser for help on using the repository browser.