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

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

CLRadeonExtender: ROCm: Fixed first bugs in routine to parse ROCm MsgPack? metadata - first testcase passed.

File size: 77.3 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 rocmMsgPackInput[] =
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, 0x88,
1460        0xae, '.', 'a', 'd', 'd', 'r', 'e', 's', 's', '_', 's', 'p', 'a', 'c', 'e',
1461            0xa6, 'g', 'l', 'o', 'b', 'a', 'l',
1462        0xa9, '.', 'i', 's', '_', 'c', 'o', 'n', 's', 't', 0xc3,
1463        0xa5, '.', 'n', 'a', 'm', 'e', 0xa2, 'i', 'n',
1464        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x00,
1465        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1466        0xaa, '.', 't', 'y', 'p', 'e', '_', 'n', 'a', 'm', 'e',
1467            0xa6, 'f', 'l', 'o', 'a', 't', '*',
1468        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1469            0xad, 'g', 'l', 'o', 'b', 'a', 'l', '_', 'b', 'u', 'f', 'f', 'e', 'r',
1470        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'f', '3', '2',
1471    0x87,
1472        0xae, '.', 'a', 'd', 'd', 'r', 'e', 's', 's', '_', 's', 'p', 'a', 'c', 'e',
1473            0xa6, 'g', 'l', 'o', 'b', 'a', 'l',
1474        0xa5, '.', 'n', 'a', 'm', 'e', 0xa3, 'o', 'u', 't',
1475        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x08,
1476        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1477        0xaa, '.', 't', 'y', 'p', 'e', '_', 'n', 'a', 'm', 'e',
1478            0xa6, 'f', 'l', 'o', 'a', 't', '*',
1479        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1480            0xad, 'g', 'l', 'o', 'b', 'a', 'l', '_', 'b', 'u', 'f', 'f', 'e', 'r',
1481        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'f', '3', '2',
1482    0x86,
1483        0xa5, '.', 'n', 'a', 'm', 'e', 0xa1, 'n',
1484        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x10,
1485        0xa5, '.', 's', 'i', 'z', 'e', 0x04,
1486        0xaa, '.', 't', 'y', 'p', 'e', '_', 'n', 'a', 'm', 'e', 0xa3, 'i', 'n', 't',
1487        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1488            0xa8, 'b', 'y', '_', 'v', 'a', 'l', 'u', 'e',
1489        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'i', '3', '2',
1490    0x84,
1491        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x18,
1492        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1493        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1494            0xb6, 'h', 'i', 'd', 'd', 'e', 'n', '_', 'g', 'l', 'o', 'b', 'a', 'l', '_',
1495            'o', 'f', 'f', 's', 'e', 't', '_', 'x',
1496        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'i', '6', '4',
1497    0x84,
1498        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x20,
1499        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1500        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1501            0xb6, 'h', 'i', 'd', 'd', 'e', 'n', '_', 'g', 'l', 'o', 'b', 'a', 'l', '_',
1502            'o', 'f', 'f', 's', 'e', 't', '_', 'y',
1503        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'i', '6', '4',
1504    0x84,
1505        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x28,
1506        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1507        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1508            0xb6, 'h', 'i', 'd', 'd', 'e', 'n', '_', 'g', 'l', 'o', 'b', 'a', 'l', '_',
1509            'o', 'f', 'f', 's', 'e', 't', '_', 'z',
1510        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa3, 'i', '6', '4',
1511    0x85,
1512        0xae, '.', 'a', 'd', 'd', 'r', 'e', 's', 's', '_', 's', 'p', 'a', 'c', 'e',
1513            0xa6, 'g', 'l', 'o', 'b', 'a', 'l',
1514        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x30,
1515        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1516        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1517            0xab, 'h', 'i', 'd', 'd', 'e', 'n', '_', 'n', 'o', 'n', 'e',
1518        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa2, 'i', '8',
1519    0x85,
1520        0xae, '.', 'a', 'd', 'd', 'r', 'e', 's', 's', '_', 's', 'p', 'a', 'c', 'e',
1521            0xa6, 'g', 'l', 'o', 'b', 'a', 'l',
1522        0xa7, '.', 'o', 'f', 'f', 's', 'e', 't', 0x38,
1523        0xa5, '.', 's', 'i', 'z', 'e', 0x08,
1524        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 'k', 'i', 'n', 'd',
1525            0xab, 'h', 'i', 'd', 'd', 'e', 'n', '_', 'n', 'o', 'n', 'e',
1526        0xab, '.', 'v', 'a', 'l', 'u', 'e', '_', 't', 'y', 'p', 'e', 0xa2, 'i', '8',
1527    // rest of kernel metadata
1528    0xb9, '.', 'g', 'r', 'o', 'u', 'p', '_', 's', 'e', 'g', 'm', 'e', 'n', 't', '_',
1529        'f', 'i', 'x', 'e', 'd', '_', 's', 'i', 'z', 'e', 0x00,
1530    0xb6, '.', 'k', 'e', 'r', 'n', 'a', 'r', 'g', '_', 's', 'e', 'g', 'm', 'e', 'n', 't',
1531        '_', 'a', 'l', 'i', 'g', 'n', 0x08,
1532    0xb5, '.', 'k', 'e', 'r', 'n', 'a', 'r', 'g', '_', 's', 'e', 'g', 'm', 'e', 'n', 't',
1533        '_', 's', 'i', 'z', 'e', 0x40,
1534    0xa9, '.', 'l', 'a', 'n', 'g', 'u', 'a', 'g', 'e',
1535        0xa8, 'O', 'p', 'e', 'n', 'C', 'L', ' ', 'C',
1536    0xb1, '.', 'l', 'a', 'n', 'g', 'u', 'a', 'g', 'e', '_',
1537        'v', 'e', 'r', 's', 'i', 'o', 'n', 0x92, 0x01, 0x02,
1538    0xb8, '.', 'm', 'a', 'x', '_', 'f', 'l', 'a', 't', '_', 'w', 'o', 'r', 'k',
1539        'g', 'r', 'o', 'u', 'p', '_', 's', 'i', 'z', 'e', 0xcd, 0x01, 0x00,
1540    0xa5, '.', 'n', 'a', 'm', 'e', 0xa7, 'v', 'e', 'c', 'p', 'r', 'o', 'c',
1541    0xbb, '.', 'p', 'r', 'i', 'v', 'a', 't', 'e', '_', 's', 'e', 'g', 'm', 'e', 'n', 't',
1542        '_', 'f', 'i', 'x', 'e', 'd', '_', 's', 'i', 'z', 'e', 0x00,
1543    0xab, '.', 's', 'g', 'p', 'r', '_', 'c', 'o', 'u', 'n', 't', 0x1a,
1544    0xb1, '.', 's', 'g', 'p', 'r', '_', 's', 'p', 'i', 'l', 'l', '_',
1545            'c', 'o', 'u', 'n', 't', 0x02,
1546    0xa7, '.', 's', 'y', 'm', 'b', 'o', 'l',
1547        0xaa, 'v', 'e', 'c', 'p', 'r', 'o', 'c', '.', 'k', 'd',
1548    0xab, '.', 'v', 'g', 'p', 'r', '_', 'c', 'o', 'u', 'n', 't', 0x06,
1549    0xb1, '.', 'v', 'g', 'p', 'r', '_', 's', 'p', 'i', 'l', 'l', '_',
1550            'c', 'o', 'u', 'n', 't', 0x03,
1551    0xaf, '.', 'w', 'a', 'v', 'e', 'f', 'r', 'o', 'n', 't', '_', 's', 'i', 'z', 'e', 0x20,
1552    // version
1553    0xae, 'a', 'm', 'd', 'h', 's', 'a', '.', 'v', 'e', 'r', 's', 'i', 'o', 'n',
1554        0x92, 0x01, 0x00
1555};
1556
1557static const ROCmMsgPackMDTestCase rocmMsgPackMDTestCases[] =
1558{
1559    {
1560        sizeof(rocmMsgPackInput), rocmMsgPackInput,
1561        {
1562            { 1, 0 },
1563            { }, // printinfos
1564            {
1565                {
1566                    "vecproc", "vecproc.kd",
1567                    {   // args
1568                        { "in", "float*", 8, 0, 0, ROCmValueKind::GLOBAL_BUFFER,
1569                            ROCmValueType::FLOAT32, ROCmAddressSpace::GLOBAL,
1570                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1571                            true, false, false, false },
1572                        { "out", "float*", 8, 8, 0, ROCmValueKind::GLOBAL_BUFFER,
1573                            ROCmValueType::FLOAT32, ROCmAddressSpace::GLOBAL,
1574                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1575                            false, false, false, false },
1576                        { "n", "int", 4, 16, 0, ROCmValueKind::BY_VALUE,
1577                            ROCmValueType::INT32, ROCmAddressSpace::NONE,
1578                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1579                            false, false, false, false },
1580                        { "", "", 8, 24, 0, ROCmValueKind::HIDDEN_GLOBAL_OFFSET_X,
1581                            ROCmValueType::INT64, ROCmAddressSpace::NONE,
1582                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1583                            false, false, false, false },
1584                        { "", "", 8, 32, 0, ROCmValueKind::HIDDEN_GLOBAL_OFFSET_Y,
1585                            ROCmValueType::INT64, ROCmAddressSpace::NONE,
1586                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1587                            false, false, false, false },
1588                        { "", "", 8, 40, 0, ROCmValueKind::HIDDEN_GLOBAL_OFFSET_Z,
1589                            ROCmValueType::INT64, ROCmAddressSpace::NONE,
1590                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1591                            false, false, false, false },
1592                        { "", "", 8, 48, 0, ROCmValueKind::HIDDEN_NONE,
1593                            ROCmValueType::INT8, ROCmAddressSpace::GLOBAL,
1594                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1595                            false, false, false, false },
1596                        { "", "", 8, 56, 0, ROCmValueKind::HIDDEN_NONE,
1597                            ROCmValueType::INT8, ROCmAddressSpace::GLOBAL,
1598                            ROCmAccessQual::DEFAULT, ROCmAccessQual::DEFAULT,
1599                            false, false, false, false }
1600                    },
1601                    "OpenCL C", { 1, 2 }, { 0, 0, 0 }, { 0, 0, 0 }, "", "",
1602                    64, 0, 0, 8, 32, 26, 6, 256, { 0, 0, 0 }, 2, 3, ""
1603                }
1604            }
1605        }, true, ""
1606    },
1607};
1608
1609static void testParseROCmMsgPackMDCase(cxuint testId, const ROCmMsgPackMDTestCase& testCase)
1610{
1611    //
1612    ROCmMetadata result{};
1613    result.initialize();
1614    bool good = true;
1615    std::string error;
1616    try
1617    { result.parseMsgPack(testCase.inputSize, testCase.input); }
1618    catch(const std::exception& ex)
1619    {
1620        good = false;
1621        error = ex.what();
1622    }
1623    const ROCmMetadata& expected = testCase.expected;
1624    char testName[30];
1625    snprintf(testName, 30, "Test #%u", testId);
1626    assertValue(testName, "good", testCase.good, good);
1627    assertString(testName, "error", testCase.error, error.c_str());
1628    if (!good)
1629        // do not check if test failed
1630        return;
1631   
1632    assertValue(testName, "version[0]", expected.version[0], result.version[0]);
1633    assertValue(testName, "version[1]", expected.version[1], result.version[1]);
1634    assertValue(testName, "printfInfosNum", expected.printfInfos.size(),
1635                result.printfInfos.size());
1636    char buf[32];
1637    for (cxuint i = 0; i < expected.printfInfos.size(); i++)
1638    {
1639        snprintf(buf, 32, "Printf[%u].", i);
1640        std::string caseName(buf);
1641        const ROCmPrintfInfo& expPrintf = expected.printfInfos[i];
1642        const ROCmPrintfInfo& resPrintf = result.printfInfos[i];
1643        assertValue(testName, caseName+"id", expPrintf.id, resPrintf.id);
1644        assertValue(testName, caseName+"argSizesNum", expPrintf.argSizes.size(),
1645                    resPrintf.argSizes.size());
1646        char buf2[32];
1647        for (cxuint j = 0; j < expPrintf.argSizes.size(); j++)
1648        {
1649            snprintf(buf2, 32, "argSizes[%u]", j);
1650            std::string caseName2(caseName);
1651            caseName2 += buf2;
1652            assertValue(testName, caseName2, expPrintf.argSizes[j], resPrintf.argSizes[j]);
1653        }
1654        assertValue(testName, caseName+"format", expPrintf.format, resPrintf.format);
1655    }
1656   
1657    assertValue(testName, "kernelsNum", expected.kernels.size(), result.kernels.size());
1658    // kernels
1659    for (cxuint i = 0; i < expected.kernels.size(); i++)
1660    {
1661        snprintf(buf, 32, "Kernel[%u].", i);
1662        std::string caseName(buf);
1663        const ROCmKernelMetadata& expKernel = expected.kernels[i];
1664        const ROCmKernelMetadata& resKernel = result.kernels[i];
1665       
1666        assertValue(testName, caseName+"name", expKernel.name, resKernel.name);
1667        assertValue(testName, caseName+"symbolName",
1668                    expKernel.symbolName, resKernel.symbolName);
1669        assertValue(testName, caseName+"argsNum",
1670                    expKernel.argInfos.size(), resKernel.argInfos.size());
1671       
1672        char buf2[32];
1673        for (cxuint j = 0; j < expKernel.argInfos.size(); j++)
1674        {
1675            snprintf(buf2, 32, "args[%u].", j);
1676            std::string caseName2(caseName);
1677            caseName2 += buf2;
1678            const ROCmKernelArgInfo& expArgInfo = expKernel.argInfos[j];
1679            const ROCmKernelArgInfo& resArgInfo = resKernel.argInfos[j];
1680            assertValue(testName, caseName2+"name", expArgInfo.name, resArgInfo.name);
1681            assertValue(testName, caseName2+"typeName",
1682                        expArgInfo.typeName, resArgInfo.typeName);
1683            assertValue(testName, caseName2+"size",
1684                        expArgInfo.size, resArgInfo.size);
1685            assertValue(testName, caseName2+"offset",
1686                        expArgInfo.offset, resArgInfo.offset);
1687            assertValue(testName, caseName2+"pointeeAlign",
1688                        expArgInfo.pointeeAlign, resArgInfo.pointeeAlign);
1689            assertValue(testName, caseName2+"valueKind",
1690                        cxuint(expArgInfo.valueKind), cxuint(resArgInfo.valueKind));
1691            assertValue(testName, caseName2+"valueType",
1692                        cxuint(expArgInfo.valueType), cxuint(resArgInfo.valueType));
1693            assertValue(testName, caseName2+"addressSpace",
1694                        cxuint(expArgInfo.addressSpace), cxuint(resArgInfo.addressSpace));
1695            assertValue(testName, caseName2+"accessQual",
1696                        cxuint(expArgInfo.accessQual), cxuint(resArgInfo.accessQual));
1697            assertValue(testName, caseName2+"actualAccessQual",
1698                cxuint(expArgInfo.actualAccessQual), cxuint(resArgInfo.actualAccessQual));
1699            assertValue(testName, caseName2+"isConst",
1700                        cxuint(expArgInfo.isConst), cxuint(resArgInfo.isConst));
1701            assertValue(testName, caseName2+"isRestrict",
1702                        cxuint(expArgInfo.isRestrict), cxuint(resArgInfo.isRestrict));
1703            assertValue(testName, caseName2+"isPipe",
1704                        cxuint(expArgInfo.isPipe), cxuint(resArgInfo.isPipe));
1705            assertValue(testName, caseName2+"isVolatile",
1706                        cxuint(expArgInfo.isVolatile), cxuint(resArgInfo.isVolatile));
1707        }
1708       
1709        assertValue(testName, caseName+"language", expKernel.language, resKernel.language);
1710        assertValue(testName, caseName+"langVersion[0]", expKernel.langVersion[0],
1711                    resKernel.langVersion[0]);
1712        assertValue(testName, caseName+"langVersion[1]", expKernel.langVersion[1],
1713                    resKernel.langVersion[1]);
1714        assertValue(testName, caseName+"reqdWorkGroupSize[0]",
1715                    expKernel.reqdWorkGroupSize[0], resKernel.reqdWorkGroupSize[0]);
1716        assertValue(testName, caseName+"reqdWorkGroupSize[1]",
1717                    expKernel.reqdWorkGroupSize[1], resKernel.reqdWorkGroupSize[1]);
1718        assertValue(testName, caseName+"reqdWorkGroupSize[2]",
1719                    expKernel.reqdWorkGroupSize[2], resKernel.reqdWorkGroupSize[2]);
1720        assertValue(testName, caseName+"workGroupSizeHint[0]",
1721                    expKernel.workGroupSizeHint[0], resKernel.workGroupSizeHint[0]);
1722        assertValue(testName, caseName+"workGroupSizeHint[1]",
1723                    expKernel.workGroupSizeHint[1], resKernel.workGroupSizeHint[1]);
1724        assertValue(testName, caseName+"workGroupSizeHint[2]",
1725                    expKernel.workGroupSizeHint[2], resKernel.workGroupSizeHint[2]);
1726        assertValue(testName, caseName+"vecTypeHint",
1727                    expKernel.vecTypeHint, resKernel.vecTypeHint);
1728        assertValue(testName, caseName+"runtimeHandle",
1729                    expKernel.runtimeHandle, resKernel.runtimeHandle);
1730        assertValue(testName, caseName+"deviceEnqueueSymbol",
1731                    expKernel.deviceEnqueueSymbol, resKernel.deviceEnqueueSymbol);
1732        assertValue(testName, caseName+"kernargSegmentSize",
1733                    expKernel.kernargSegmentSize, resKernel.kernargSegmentSize);
1734        assertValue(testName, caseName+"groupSegmentFixedSize",
1735                    expKernel.groupSegmentFixedSize, resKernel.groupSegmentFixedSize);
1736        assertValue(testName, caseName+"privateSegmentFixedSize",
1737                    expKernel.privateSegmentFixedSize, resKernel.privateSegmentFixedSize);
1738        assertValue(testName, caseName+"kernargSegmentAlign",
1739                    expKernel.kernargSegmentAlign, resKernel.kernargSegmentAlign);
1740        assertValue(testName, caseName+"wavefrontSize",
1741                    expKernel.wavefrontSize, resKernel.wavefrontSize);
1742        assertValue(testName, caseName+"sgprsNum", expKernel.sgprsNum, resKernel.sgprsNum);
1743        assertValue(testName, caseName+"vgprsNum", expKernel.vgprsNum, resKernel.vgprsNum);
1744        assertValue(testName, caseName+"maxFlatWorkGroupSize",
1745                    expKernel.maxFlatWorkGroupSize, resKernel.maxFlatWorkGroupSize);
1746        assertValue(testName, caseName+"fixedWorkGroupSize[0]",
1747                    expKernel.fixedWorkGroupSize[0], resKernel.fixedWorkGroupSize[0]);
1748        assertValue(testName, caseName+"fixedWorkGroupSize[1]",
1749                    expKernel.fixedWorkGroupSize[1], resKernel.fixedWorkGroupSize[1]);
1750        assertValue(testName, caseName+"fixedWorkGroupSize[2]",
1751                    expKernel.fixedWorkGroupSize[2], resKernel.fixedWorkGroupSize[2]);
1752        assertValue(testName, caseName+"spilledSgprs",
1753                    expKernel.spilledSgprs, resKernel.spilledSgprs);
1754        assertValue(testName, caseName+"spilledVgprs",
1755                    expKernel.spilledVgprs, resKernel.spilledVgprs);
1756    }
1757};
1758
1759int main(int argc, const char** argv)
1760{
1761    int retVal = 0;
1762    retVal |= callTest(testMsgPackBytes);
1763    retVal |= callTest(testMsgPackSkip);
1764    for (cxuint i = 0; i < sizeof(rocmMsgPackMDTestCases)/
1765                            sizeof(ROCmMsgPackMDTestCase); i++)
1766        try
1767        { testParseROCmMsgPackMDCase(i, rocmMsgPackMDTestCases[i]); }
1768        catch(const std::exception& ex)
1769        {
1770            std::cerr << ex.what() << std::endl;
1771            retVal = 1;
1772        }
1773    return retVal;
1774}
Note: See TracBrowser for help on using the repository browser.