source: CLRX/CLRadeonExtender/trunk/tests/amdbin/ROCmMsgPackWrite.cpp @ 4957

Last change on this file since 4957 was 4957, checked in by matszpk, 13 months ago

CLRadeonExtender: ROCmBin: Add next testcases to ROCmMsgPackWrite (for MsgPackMapWriter?).

File size: 8.6 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 <cstring>
23#include <cstdio>
24#include <vector>
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 testMsgPackBytesWrite()
33{
34    {
35        static const cxbyte outBytes0[3] = { 0x92, 0xc3, 0xc2 };
36        std::vector<cxbyte> out;
37        MsgPackArrayWriter awriter(2, out);
38        awriter.putBool(true);
39        awriter.putBool(false);
40        assertArray("MsgPackWrite0", "tc0",
41                    Array<cxbyte>(outBytes0, outBytes0 + sizeof(outBytes0)), out);
42    }
43    {
44        static const cxbyte outBytes1[16] = { 0x9f, 0, 1, 2, 3, 4, 5, 6, 7,
45            8, 9, 10, 11, 12, 13, 14 };
46        std::vector<cxbyte> out;
47        MsgPackArrayWriter awriter(15, out);
48        for (cxuint i = 0; i < 15; i++)
49            awriter.putUInt(i);
50        assertArray("MsgPackWrite0", "tc1",
51                    Array<cxbyte>(outBytes1, outBytes1 + sizeof(outBytes1)), out);
52    }
53    {   // longer array
54        static const cxbyte outBytes2[21] = { 0xdc, 0x0, 0x12, 0, 1, 2, 3, 4, 5, 6, 7,
55            8, 9, 10, 11, 12, 13, 14, 15, 16, 17 };
56        std::vector<cxbyte> out;
57        MsgPackArrayWriter awriter(18, out);
58        for (cxuint i = 0; i < 18; i++)
59            awriter.putUInt(i);
60        assertArray("MsgPackWrite0", "tc2",
61                    Array<cxbyte>(outBytes2, outBytes2 + sizeof(outBytes2)), out);
62    }
63    {   // long array (12222 elements)
64        Array<cxbyte> outBytes3(12222+3);
65        outBytes3[0] = 0xdc;
66        outBytes3[1] = 12222>>8;
67        outBytes3[2] = 12222&0xff;
68        std::vector<cxbyte> out;
69        MsgPackArrayWriter awriter(12222, out);
70        for (cxuint i = 0; i < 12222; i++)
71        {
72            awriter.putUInt(i&0x7f);
73            outBytes3[i+3] = i&0x7f;
74        }
75        assertArray("MsgPackWrite0", "tc3", outBytes3, out);
76    }
77    {   // long array (1777777 elements)
78        Array<cxbyte> outBytes4(1777777+5);
79        outBytes4[0] = 0xdd;
80        outBytes4[1] = 1777777>>24;
81        outBytes4[2] = (1777777>>16)&0xff;
82        outBytes4[3] = (1777777>>8)&0xff;
83        outBytes4[4] = 1777777&0xff;
84        std::vector<cxbyte> out;
85        MsgPackArrayWriter awriter(1777777, out);
86        for (cxuint i = 0; i < 1777777; i++)
87        {
88            awriter.putUInt(i&0x7f);
89            outBytes4[i+5] = i&0x7f;
90        }
91        assertArray("MsgPackWrite0", "tc4", outBytes4, out);
92    }
93    /* test putting values */
94    {
95        static const cxbyte outBytes5[21] = { 0x95, 0x12, 0xcc, 0xd1, 0xcd, 0xab, 0x73,
96            0xce, 0xa1, 0x18, 0xb9, 0x31,
97            0xcf, 0x11, 0x88, 0x99, 0xa1, 0xb6, 0xa1, 0x9e, 0x1a };
98        std::vector<cxbyte> out;
99        MsgPackArrayWriter awriter(5, out);
100        awriter.putUInt(0x12);
101        awriter.putUInt(0xd1);
102        awriter.putUInt(0xab73);
103        awriter.putUInt(0xa118b931U);
104        awriter.putUInt(0x118899a1b6a19e1aULL);
105        assertArray("MsgPackWrite0", "tc5",
106                    Array<cxbyte>(outBytes5, outBytes5 + sizeof(outBytes5)), out);
107    }
108    // testing string putting (short)
109    {
110        static const cxbyte outBytes6[7] = { 0x91, 0xa5, 0x4a, 0x5b, 0x31, 0x28, 0x44 };
111        std::vector<cxbyte> out;
112        MsgPackArrayWriter awriter(1, out);
113        awriter.putString("\x4a\x5b\x31\x28\x44");
114        assertArray("MsgPackWrite0", "tc6",
115                    Array<cxbyte>(outBytes6, outBytes6 + sizeof(outBytes6)), out);
116    }
117    {
118        Array<cxbyte> outBytes7(187+3);
119        outBytes7[0] = 0x91;
120        outBytes7[1] = 0xd9;
121        outBytes7[2] = 187;
122        std::vector<cxbyte> out;
123        MsgPackArrayWriter awriter(1, out);
124        for (cxuint i = 0; i < 187; i++)
125            outBytes7[i+3] = (i&0x7f)+10;
126        std::string s(reinterpret_cast<cxbyte*>(outBytes7.data())+3,
127                    reinterpret_cast<cxbyte*>(outBytes7.data())+187+3);
128        awriter.putString(s.c_str());
129        assertArray("MsgPackWrite0", "tc7", outBytes7, out);
130    }
131    {
132        Array<cxbyte> outBytes8(18529+4);
133        outBytes8[0] = 0x91;
134        outBytes8[1] = 0xda;
135        outBytes8[2] = 18529>>8;
136        outBytes8[3] = 18529&0xff;
137        std::vector<cxbyte> out;
138        MsgPackArrayWriter awriter(1, out);
139        for (cxuint i = 0; i < 18529; i++)
140            outBytes8[i+4] = (i&0x7f)+10;
141        std::string s(reinterpret_cast<cxbyte*>(outBytes8.data())+4,
142                    reinterpret_cast<cxbyte*>(outBytes8.data())+18529+4);
143        awriter.putString(s.c_str());
144        assertArray("MsgPackWrite0", "tc8", outBytes8, out);
145    }
146    {
147        Array<cxbyte> outBytes9(9838391+6);
148        outBytes9[0] = 0x91;
149        outBytes9[1] = 0xdb;
150        outBytes9[2] = 9838391>>24;
151        outBytes9[3] = (9838391>>16)&0xff;
152        outBytes9[4] = (9838391>>8)&0xff;
153        outBytes9[5] = 9838391&0xff;
154        std::vector<cxbyte> out;
155        MsgPackArrayWriter awriter(1, out);
156        for (cxuint i = 0; i < 9838391; i++)
157            outBytes9[i+6] = (i&0x7f)+10;
158        std::string s(reinterpret_cast<cxbyte*>(outBytes9.data())+6,
159                    reinterpret_cast<cxbyte*>(outBytes9.data())+9838391+6);
160        awriter.putString(s.c_str());
161        assertArray("MsgPackWrite0", "tc9", outBytes9, out);
162    }
163    /* map writer class */
164    {
165        static const cxbyte outBytes10[21] = { 0x83,
166            0xa4, 'a', 'b', 'a', 'b', 15,
167            0xa3, 'c', 'o', 'b', 0xcd, 0xe9, 0x11,
168            0xa5, 'e', 'x', 't', 'r', 'a', 11 };
169        std::vector<cxbyte> out;
170        MsgPackMapWriter mwriter(3, out);
171        mwriter.putKeyString("abab");
172        mwriter.putValueUInt(15);
173        mwriter.putKeyString("cob");
174        mwriter.putValueUInt(0xe911);
175        mwriter.putKeyString("extra");
176        mwriter.putValueUInt(11);
177        assertArray("MsgPackWrite0", "tc10",
178                    Array<cxbyte>(outBytes10, outBytes10 + sizeof(outBytes10)), out);
179    }
180    // longer map testcase
181    {
182        Array<cxbyte> outBytes11(14821*10+3);
183        outBytes11[0] = 0xde;
184        outBytes11[1] = 14821>>8;
185        outBytes11[2] = 14821&0xff;
186        std::vector<cxbyte> out;
187        MsgPackMapWriter mwriter(14821, out);
188        for (cxuint i = 0; i < 14821; i++)
189        {
190            char kbuf[8], vbuf[8];
191            ::snprintf(kbuf, 8, "%04x", i);
192            ::snprintf(vbuf, 8, "%04x", i^0xdca1);
193            outBytes11[3+i*10] = 0xa4;
194            std::copy(kbuf, kbuf+4, ((char*)outBytes11.data())+3 + i*10 + 1);
195            outBytes11[3+i*10 + 5] = 0xa4;
196            std::copy(vbuf, vbuf+4, ((char*)outBytes11.data())+3 + i*10 + 6);
197           
198            mwriter.putKeyString(kbuf);
199            mwriter.putValueString(vbuf);
200        }
201        assertArray("MsgPackWrite0", "tc11", outBytes11, out);
202    }
203    // longer map testcase
204    {
205        Array<cxbyte> outBytes12(793894*14+5);
206        outBytes12[0] = 0xdf;
207        outBytes12[1] = 793894>>24;
208        outBytes12[2] = (793894>>16)&0xff;
209        outBytes12[3] = (793894>>8)&0xff;
210        outBytes12[4] = 793894&0xff;
211        std::vector<cxbyte> out;
212        MsgPackMapWriter mwriter(793894, out);
213        for (cxuint i = 0; i < 793894; i++)
214        {
215            char kbuf[10], vbuf[10];
216            ::snprintf(kbuf, 10, "%06x", i);
217            ::snprintf(vbuf, 10, "%06x", (i^0x11b3dca1U)&0xffffffU);
218            outBytes12[5+i*14] = 0xa6;
219            std::copy(kbuf, kbuf+6, ((char*)outBytes12.data())+5 + i*14 + 1);
220            outBytes12[5+i*14 + 7] = 0xa6;
221            std::copy(vbuf, vbuf+6, ((char*)outBytes12.data())+5 + i*14 + 8);
222           
223            mwriter.putKeyString(kbuf);
224            mwriter.putValueString(vbuf);
225        }
226        assertArray("MsgPackWrite0", "tc12", outBytes12, out);
227    }
228}
229
230int main(int argc, const char** argv)
231{
232    int retVal = 0;
233    retVal |= callTest(testMsgPackBytesWrite);
234    return retVal;
235}
Note: See TracBrowser for help on using the repository browser.