Changeset 4899 in CLRX


Ignore:
Timestamp:
Aug 16, 2019, 8:37:17 AM (5 weeks ago)
Author:
matszpk
Message:

CLRadeonExtender: ROCm: Add next testcases for ROCm MsgPack? parser. Fix parseMsgPackInteger.

Location:
CLRadeonExtender/trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • CLRadeonExtender/trunk/amdbin/ROCmMetadata.cpp

    r4896 r4899  
    13661366        v = *dataPtr++;
    13671367    else if (*dataPtr >= 0xe0)
     1368    {
    13681369        v = uint64_t(-32) + ((*dataPtr++) & 0x1f);
     1370        if (signess == MSGPACK_WS_UNSIGNED && v >= (1ULL<<63))
     1371            throw ParseException("MsgPack: Negative value for unsigned integer");
     1372    }
    13691373    else
    13701374    {
     
    13761380                if (dataPtr>=dataEnd)
    13771381                    throw ParseException("MsgPack: Can't parse integer value");
    1378                 v = *dataPtr++;
     1382                if (code==0xcc)
     1383                    v = *dataPtr++;
     1384                else
     1385                    v = int8_t(*dataPtr++);
    13791386                break;
    13801387            case 0xcd:
     
    13831390                    throw ParseException("MsgPack: Can't parse integer value");
    13841391                v = *dataPtr++;
    1385                 v |= uint32_t(*dataPtr++)<<8;
     1392                v |= uint16_t(*dataPtr++)<<8;
     1393                if (code==0xd1 && (v&(1ULL<<15))!=0)
     1394                    v |= (0xffffffffffffULL<<16);
    13861395                break;
    13871396            case 0xce:
     
    13911400                for (cxuint i = 0; i < 32; i+=8)
    13921401                    v |= uint32_t(*dataPtr++)<<i;
     1402                if (code==0xd2 && (v&(1ULL<<31))!=0)
     1403                    v |= (0xffffffffULL<<32);
    13931404                break;
    13941405            case 0xcf:
  • CLRadeonExtender/trunk/tests/amdbin/ROCmMsgPack.cpp

    r4898 r4899  
    3434    const cxbyte tc0[2] = { 0x91, 0xc0 };
    3535    const cxbyte* dataPtr;
     36    // parseNil
    3637    dataPtr = tc0;
    3738    {
     
    4849    }
    4950   
     51    // parseBool
    5052    const cxbyte tc1[2] = { 0x91, 0xc2 };
    5153    dataPtr = tc1;
     
    7173    }
    7274   
    73     const cxbyte tc3[2] = { 0x91, 0x21 };
    74     dataPtr = tc3;
    75     {
    76         MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc3));
    77         assertValue("MsgPack0", "tc3.value0", uint64_t(33),
    78                    arrParser.parseInteger(MSGPACK_WS_UNSIGNED));
    79         assertValue("MsgPack0", "tc3.DataPtr", dataPtr, tc3 + sizeof(tc3));
    80     }
    81     dataPtr = tc3;
    82     {
    83         MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc3)-1);
    84         assertCLRXException("MsgPack0", "tc3_1.Ex", "MsgPack: Can't parse integer value",
    85                     [&arrParser]() { arrParser.parseInteger(MSGPACK_WS_UNSIGNED); });
    86         assertValue("MsgPack0", "tc3_1.DataPtr", dataPtr, tc3 + sizeof(tc3)-1);
    87     }
    88     const cxbyte tc4[2] = { 0x91, 0x5b };
     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 };
    8985    dataPtr = tc4;
    9086    {
    9187        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc4));
    92         assertValue("MsgPack0", "tc4.value0", uint64_t(91),
     88        assertValue("MsgPack0", "tc4.value0", uint64_t(33),
    9389                   arrParser.parseInteger(MSGPACK_WS_UNSIGNED));
    9490        assertValue("MsgPack0", "tc4.DataPtr", dataPtr, tc4 + sizeof(tc4));
    9591    }
     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, 0x37, 0x1c };
     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, 0x7e, 0xb3 };
     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, 0x37, 0x1c };
     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, 0x7e, 0xb3 };
     214    dataPtr = tc10_1;
     215    {
     216        MsgPackArrayParser arrParser(dataPtr, dataPtr + sizeof(tc10_1));
     217        assertValue("MsgPack0", "tc10_1.value0", uint64_t(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
    96238}
    97239
     
    102244    return retVal;
    103245}
    104 
Note: See TracChangeset for help on using the changeset viewer.