VirtualBox

Changeset 18365 in vbox


Ignore:
Timestamp:
Mar 27, 2009 2:03:40 AM (16 years ago)
Author:
vboxsync
Message:

tstBitOperations: Use RTTest.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Runtime/testcase/tstBitOperations.cpp

    r8245 r18365  
    3434*******************************************************************************/
    3535#include <iprt/asm.h>
     36#include <iprt/test.h>
    3637#include <iprt/stream.h>
    3738#include <iprt/string.h>
     39#include <iprt/test.h>
     40#include <iprt/initterm.h>
    3841
    3942
    4043int main()
    4144{
     45    /*
     46     * Init the runtime and stuff.
     47     */
     48    RTTEST hTest;
     49    if (    RT_FAILURE(RTR3Init())
     50        ||  RT_FAILURE(RTTestCreate("tstBitOperations", &hTest)))
     51    {
     52        RTPrintf("tstBitOperation: fatal initialization error\n");
     53        return 1;
     54    }
     55    RTTestBanner(hTest);
     56
    4257    int rcRet = 0;
    4358    int i;
    4459    int j;
    4560    int k;
    46     RTPrintf("tstBitOperations: TESTING\n");
    47 
    4861
    4962    /*
    5063     * Tests
    5164     */
    52     uint32_t au32[4];
    53     #define MAP_CLEAR(a) memset(&a,    0, sizeof(a));
    54     #define MAP_SET(a)   memset(&a, 0xff, sizeof(a));
    55     #define DUMP()       RTPrintf("au32={%08x,%08x,%08x,%08x}\n", au32[0], au32[1], au32[2], au32[3])
    56     #define CHECK(expr)  do { if (!(expr)) { RTPrintf("tstBitOperations: error line %d: %s\n", __LINE__, #expr); DUMP(); rcRet++; } } while (0)
    57     #define CHECK_BIT(expr,  b1)            do { if (!(expr)) { RTPrintf("tstBitOperations: error line %d, b1=%d: %s\n", __LINE__, b1, #expr); rcRet++; } } while (0)
    58     #define CHECK_BIT2(expr, b1, b2)        do { if (!(expr)) { RTPrintf("tstBitOperations: error line %d, b1=%d b2=%d: %s\n", __LINE__, b1, b2, #expr); rcRet++; } } while (0)
    59     #define CHECK_BIT3(expr, b1, b2, b3)    do { if (!(expr)) { RTPrintf("tstBitOperations: error line %d, b1=%d b2=%d b3=%d: %s\n", __LINE__, b1, b2, b3, #expr); rcRet++; } } while (0)
     65    struct TestMap
     66    {
     67        uint32_t au32[4];
     68    };
     69#if 0
     70    struct TestMap sTest;
     71    struct TestMap *p = &sTest;
     72#else
     73    struct TestMap *p = (struct TestMap *)RTTestGuardedAllocTail(hTest, sizeof(*p));
     74#endif
     75#define DUMP()          RTTestPrintf(hTest, "au32={%08x,%08x,%08x,%08x}", p->au32[0], p->au32[1], p->au32[2], p->au32[3])
     76#define CHECK(expr)     do { if (!(expr)) { RTTestFailed(hTest, "line %d: %s", __LINE__, #expr); DUMP(); } CHECK_GUARD(s); } while (0)
     77#define CHECK_BIT(expr,  b1)            do { if (!(expr)) { RTTestFailed(hTest, "line %d, b1=%d: %s", __LINE__, b1, #expr); } CHECK_GUARD(s); } while (0)
     78#define CHECK_BIT2(expr, b1, b2)        do { if (!(expr)) { RTTestFailed(hTest, "line %d, b1=%d b2=%d: %s", __LINE__, b1, b2, #expr); } CHECK_GUARD(s); } while (0)
     79#define CHECK_BIT3(expr, b1, b2, b3)    do { if (!(expr)) { RTTestFailed(hTest, "line %d, b1=%d b2=%d b3=%d: %s", __LINE__, b1, b2, b3, #expr); } CHECK_GUARD(s); } while (0)
     80
     81#define GUARD_MAP(p)    do {  } while (0)
     82#define CHECK_GUARD(p)  do {  } while (0)
     83#define MAP_CLEAR(p)    do { memset(p,    0, sizeof(*(p))); GUARD_MAP(p); } while (0)
     84#define MAP_SET(p)      do { memset(p, 0xff, sizeof(*(p))); GUARD_MAP(p); } while (0)
     85
     86    /* self check. */
     87    MAP_CLEAR(p);
     88    CHECK_GUARD(p);
    6089
    6190    /* set */
    62     MAP_CLEAR(au32);
    63     ASMBitSet(&au32[0], 0);
    64     ASMBitSet(&au32[0], 31);
    65     ASMBitSet(&au32[0], 65);
    66     CHECK(au32[0] == 0x80000001U);
    67     CHECK(au32[2] == 0x00000002U);
    68     CHECK(ASMBitTestAndSet(&au32[0], 0)   && au32[0] == 0x80000001U);
    69     CHECK(!ASMBitTestAndSet(&au32[0], 16) && au32[0] == 0x80010001U);
    70     CHECK(ASMBitTestAndSet(&au32[0], 16)  && au32[0] == 0x80010001U);
    71     CHECK(!ASMBitTestAndSet(&au32[0], 80) && au32[2] == 0x00010002U);
    72 
    73     MAP_CLEAR(au32);
    74     ASMAtomicBitSet(&au32[0], 0);
    75     ASMAtomicBitSet(&au32[0], 30);
    76     ASMAtomicBitSet(&au32[0], 64);
    77     CHECK(au32[0] == 0x40000001U);
    78     CHECK(au32[2] == 0x00000001U);
    79     CHECK(ASMAtomicBitTestAndSet(&au32[0], 0)   && au32[0] == 0x40000001U);
    80     CHECK(!ASMAtomicBitTestAndSet(&au32[0], 16) && au32[0] == 0x40010001U);
    81     CHECK(ASMAtomicBitTestAndSet(&au32[0], 16)  && au32[0] == 0x40010001U);
    82     CHECK(!ASMAtomicBitTestAndSet(&au32[0], 80) && au32[2] == 0x00010001U);
     91    MAP_CLEAR(p);
     92    ASMBitSet(&p->au32[0], 0);
     93    ASMBitSet(&p->au32[0], 31);
     94    ASMBitSet(&p->au32[0], 65);
     95    CHECK(p->au32[0] == 0x80000001U);
     96    CHECK(p->au32[2] == 0x00000002U);
     97    CHECK(ASMBitTestAndSet(&p->au32[0], 0)   && p->au32[0] == 0x80000001U);
     98    CHECK(!ASMBitTestAndSet(&p->au32[0], 16) && p->au32[0] == 0x80010001U);
     99    CHECK(ASMBitTestAndSet(&p->au32[0], 16)  && p->au32[0] == 0x80010001U);
     100    CHECK(!ASMBitTestAndSet(&p->au32[0], 80) && p->au32[2] == 0x00010002U);
     101
     102    MAP_CLEAR(p);
     103    ASMAtomicBitSet(&p->au32[0], 0);
     104    ASMAtomicBitSet(&p->au32[0], 30);
     105    ASMAtomicBitSet(&p->au32[0], 64);
     106    CHECK(p->au32[0] == 0x40000001U);
     107    CHECK(p->au32[2] == 0x00000001U);
     108    CHECK(ASMAtomicBitTestAndSet(&p->au32[0], 0)   && p->au32[0] == 0x40000001U);
     109    CHECK(!ASMAtomicBitTestAndSet(&p->au32[0], 16) && p->au32[0] == 0x40010001U);
     110    CHECK(ASMAtomicBitTestAndSet(&p->au32[0], 16)  && p->au32[0] == 0x40010001U);
     111    CHECK(!ASMAtomicBitTestAndSet(&p->au32[0], 80) && p->au32[2] == 0x00010001U);
    83112
    84113    /* clear */
    85     MAP_SET(au32);
    86     ASMBitClear(&au32[0], 0);
    87     ASMBitClear(&au32[0], 31);
    88     ASMBitClear(&au32[0], 65);
    89     CHECK(au32[0] == ~0x80000001U);
    90     CHECK(au32[2] == ~0x00000002U);
    91     CHECK(!ASMBitTestAndClear(&au32[0], 0)   && au32[0] == ~0x80000001U);
    92     CHECK(ASMBitTestAndClear(&au32[0], 16)   && au32[0] == ~0x80010001U);
    93     CHECK(!ASMBitTestAndClear(&au32[0], 16)  && au32[0] == ~0x80010001U);
    94     CHECK(ASMBitTestAndClear(&au32[0], 80)   && au32[2] == ~0x00010002U);
    95 
    96     MAP_SET(au32);
    97     ASMAtomicBitClear(&au32[0], 0);
    98     ASMAtomicBitClear(&au32[0], 30);
    99     ASMAtomicBitClear(&au32[0], 64);
    100     CHECK(au32[0] == ~0x40000001U);
    101     CHECK(au32[2] == ~0x00000001U);
    102     CHECK(!ASMAtomicBitTestAndClear(&au32[0], 0)   && au32[0] == ~0x40000001U);
    103     CHECK(ASMAtomicBitTestAndClear(&au32[0], 16)   && au32[0] == ~0x40010001U);
    104     CHECK(!ASMAtomicBitTestAndClear(&au32[0], 16)  && au32[0] == ~0x40010001U);
    105     CHECK(ASMAtomicBitTestAndClear(&au32[0], 80)   && au32[2] == ~0x00010001U);
     114    MAP_SET(p);
     115    ASMBitClear(&p->au32[0], 0);
     116    ASMBitClear(&p->au32[0], 31);
     117    ASMBitClear(&p->au32[0], 65);
     118    CHECK(p->au32[0] == ~0x80000001U);
     119    CHECK(p->au32[2] == ~0x00000002U);
     120    CHECK(!ASMBitTestAndClear(&p->au32[0], 0)   && p->au32[0] == ~0x80000001U);
     121    CHECK(ASMBitTestAndClear(&p->au32[0], 16)   && p->au32[0] == ~0x80010001U);
     122    CHECK(!ASMBitTestAndClear(&p->au32[0], 16)  && p->au32[0] == ~0x80010001U);
     123    CHECK(ASMBitTestAndClear(&p->au32[0], 80)   && p->au32[2] == ~0x00010002U);
     124
     125    MAP_SET(p);
     126    ASMAtomicBitClear(&p->au32[0], 0);
     127    ASMAtomicBitClear(&p->au32[0], 30);
     128    ASMAtomicBitClear(&p->au32[0], 64);
     129    CHECK(p->au32[0] == ~0x40000001U);
     130    CHECK(p->au32[2] == ~0x00000001U);
     131    CHECK(!ASMAtomicBitTestAndClear(&p->au32[0], 0)   && p->au32[0] == ~0x40000001U);
     132    CHECK(ASMAtomicBitTestAndClear(&p->au32[0], 16)   && p->au32[0] == ~0x40010001U);
     133    CHECK(!ASMAtomicBitTestAndClear(&p->au32[0], 16)  && p->au32[0] == ~0x40010001U);
     134    CHECK(ASMAtomicBitTestAndClear(&p->au32[0], 80)   && p->au32[2] == ~0x00010001U);
    106135
    107136    /* toggle */
    108     MAP_SET(au32);
    109     ASMBitToggle(&au32[0], 0);
    110     ASMBitToggle(&au32[0], 31);
    111     ASMBitToggle(&au32[0], 65);
    112     ASMBitToggle(&au32[0], 47);
    113     ASMBitToggle(&au32[0], 47);
    114     CHECK(au32[0] == ~0x80000001U);
    115     CHECK(au32[2] == ~0x00000002U);
    116     CHECK(!ASMBitTestAndToggle(&au32[0], 0)   && au32[0] == ~0x80000000U);
    117     CHECK(ASMBitTestAndToggle(&au32[0], 0)    && au32[0] == ~0x80000001U);
    118     CHECK(ASMBitTestAndToggle(&au32[0], 16)   && au32[0] == ~0x80010001U);
    119     CHECK(!ASMBitTestAndToggle(&au32[0], 16)  && au32[0] == ~0x80000001U);
    120     CHECK(ASMBitTestAndToggle(&au32[0], 80)   && au32[2] == ~0x00010002U);
    121 
    122     MAP_SET(au32);
    123     ASMAtomicBitToggle(&au32[0], 0);
    124     ASMAtomicBitToggle(&au32[0], 30);
    125     ASMAtomicBitToggle(&au32[0], 64);
    126     ASMAtomicBitToggle(&au32[0], 47);
    127     ASMAtomicBitToggle(&au32[0], 47);
    128     CHECK(au32[0] == ~0x40000001U);
    129     CHECK(au32[2] == ~0x00000001U);
    130     CHECK(!ASMAtomicBitTestAndToggle(&au32[0], 0)   && au32[0] == ~0x40000000U);
    131     CHECK(ASMAtomicBitTestAndToggle(&au32[0], 0)    && au32[0] == ~0x40000001U);
    132     CHECK(ASMAtomicBitTestAndToggle(&au32[0], 16)   && au32[0] == ~0x40010001U);
    133     CHECK(!ASMAtomicBitTestAndToggle(&au32[0], 16)  && au32[0] == ~0x40000001U);
    134     CHECK(ASMAtomicBitTestAndToggle(&au32[0], 80)   && au32[2] == ~0x00010001U);
     137    MAP_SET(p);
     138    ASMBitToggle(&p->au32[0], 0);
     139    ASMBitToggle(&p->au32[0], 31);
     140    ASMBitToggle(&p->au32[0], 65);
     141    ASMBitToggle(&p->au32[0], 47);
     142    ASMBitToggle(&p->au32[0], 47);
     143    CHECK(p->au32[0] == ~0x80000001U);
     144    CHECK(p->au32[2] == ~0x00000002U);
     145    CHECK(!ASMBitTestAndToggle(&p->au32[0], 0)   && p->au32[0] == ~0x80000000U);
     146    CHECK(ASMBitTestAndToggle(&p->au32[0], 0)    && p->au32[0] == ~0x80000001U);
     147    CHECK(ASMBitTestAndToggle(&p->au32[0], 16)   && p->au32[0] == ~0x80010001U);
     148    CHECK(!ASMBitTestAndToggle(&p->au32[0], 16)  && p->au32[0] == ~0x80000001U);
     149    CHECK(ASMBitTestAndToggle(&p->au32[0], 80)   && p->au32[2] == ~0x00010002U);
     150
     151    MAP_SET(p);
     152    ASMAtomicBitToggle(&p->au32[0], 0);
     153    ASMAtomicBitToggle(&p->au32[0], 30);
     154    ASMAtomicBitToggle(&p->au32[0], 64);
     155    ASMAtomicBitToggle(&p->au32[0], 47);
     156    ASMAtomicBitToggle(&p->au32[0], 47);
     157    CHECK(p->au32[0] == ~0x40000001U);
     158    CHECK(p->au32[2] == ~0x00000001U);
     159    CHECK(!ASMAtomicBitTestAndToggle(&p->au32[0], 0)   && p->au32[0] == ~0x40000000U);
     160    CHECK(ASMAtomicBitTestAndToggle(&p->au32[0], 0)    && p->au32[0] == ~0x40000001U);
     161    CHECK(ASMAtomicBitTestAndToggle(&p->au32[0], 16)   && p->au32[0] == ~0x40010001U);
     162    CHECK(!ASMAtomicBitTestAndToggle(&p->au32[0], 16)  && p->au32[0] == ~0x40000001U);
     163    CHECK(ASMAtomicBitTestAndToggle(&p->au32[0], 80)   && p->au32[2] == ~0x00010001U);
    135164
    136165    /* test bit. */
    137166    for (i = 0; i < 128; i++)
    138167    {
    139         MAP_SET(au32);
    140         CHECK_BIT(ASMBitTest(&au32[0], i), i);
    141         ASMBitToggle(&au32[0], i);
    142         CHECK_BIT(!ASMBitTest(&au32[0], i), i);
    143         CHECK_BIT(!ASMBitTestAndToggle(&au32[0], i), i);
    144         CHECK_BIT(ASMBitTest(&au32[0], i), i);
    145         CHECK_BIT(ASMBitTestAndToggle(&au32[0], i), i);
    146         CHECK_BIT(!ASMBitTest(&au32[0], i), i);
    147 
    148         MAP_SET(au32);
    149         CHECK_BIT(ASMBitTest(&au32[0], i), i);
    150         ASMAtomicBitToggle(&au32[0], i);
    151         CHECK_BIT(!ASMBitTest(&au32[0], i), i);
    152         CHECK_BIT(!ASMAtomicBitTestAndToggle(&au32[0], i), i);
    153         CHECK_BIT(ASMBitTest(&au32[0], i), i);
    154         CHECK_BIT(ASMAtomicBitTestAndToggle(&au32[0], i), i);
    155         CHECK_BIT(!ASMBitTest(&au32[0], i), i);
    156 
     168        MAP_SET(p);
     169        CHECK_BIT(ASMBitTest(&p->au32[0], i), i);
     170        ASMBitToggle(&p->au32[0], i);
     171        CHECK_BIT(!ASMBitTest(&p->au32[0], i), i);
     172        CHECK_BIT(!ASMBitTestAndToggle(&p->au32[0], i), i);
     173        CHECK_BIT(ASMBitTest(&p->au32[0], i), i);
     174        CHECK_BIT(ASMBitTestAndToggle(&p->au32[0], i), i);
     175        CHECK_BIT(!ASMBitTest(&p->au32[0], i), i);
     176
     177        MAP_SET(p);
     178        CHECK_BIT(ASMBitTest(&p->au32[0], i), i);
     179        ASMAtomicBitToggle(&p->au32[0], i);
     180        CHECK_BIT(!ASMBitTest(&p->au32[0], i), i);
     181        CHECK_BIT(!ASMAtomicBitTestAndToggle(&p->au32[0], i), i);
     182        CHECK_BIT(ASMBitTest(&p->au32[0], i), i);
     183        CHECK_BIT(ASMAtomicBitTestAndToggle(&p->au32[0], i), i);
     184        CHECK_BIT(!ASMBitTest(&p->au32[0], i), i);
    157185    }
    158186
    159187    /* bit searching */
    160     MAP_SET(au32);
    161     CHECK(ASMBitFirstClear(&au32[0], sizeof(au32) * 8) == -1);
    162     CHECK(ASMBitFirstSet(&au32[0], sizeof(au32) * 8) == 0);
    163 
    164     ASMBitClear(&au32[0], 1);
    165     CHECK(ASMBitFirstClear(&au32[0], sizeof(au32) * 8) == 1);
    166     CHECK(ASMBitFirstSet(&au32[0], sizeof(au32) * 8) == 0);
    167 
    168     MAP_SET(au32);
    169     ASMBitClear(&au32[0], 95);
    170     CHECK(ASMBitFirstClear(&au32[0], sizeof(au32) * 8) == 95);
    171     CHECK(ASMBitFirstSet(&au32[0], sizeof(au32) * 8) == 0);
    172 
    173     MAP_SET(au32);
    174     ASMBitClear(&au32[0], 127);
    175     CHECK(ASMBitFirstClear(&au32[0], sizeof(au32) * 8) == 127);
    176     CHECK(ASMBitFirstSet(&au32[0], sizeof(au32) * 8) == 0);
    177     CHECK(ASMBitNextSet(&au32[0], sizeof(au32) * 8, 0) == 1);
    178     CHECK(ASMBitNextSet(&au32[0], sizeof(au32) * 8, 1) == 2);
    179     CHECK(ASMBitNextSet(&au32[0], sizeof(au32) * 8, 2) == 3);
    180 
    181 
    182     MAP_SET(au32);
    183     CHECK(ASMBitNextClear(&au32[0], sizeof(au32) * 8, 0) == -1);
    184     ASMBitClear(&au32[0], 32);
    185     CHECK(ASMBitNextClear(&au32[0], sizeof(au32) * 8, 32) == -1);
    186     ASMBitClear(&au32[0], 88);
    187     CHECK(ASMBitNextClear(&au32[0], sizeof(au32) * 8,  57) ==  88);
    188 
    189     MAP_SET(au32);
    190     ASMBitClear(&au32[0], 31);
    191     ASMBitClear(&au32[0], 57);
    192     ASMBitClear(&au32[0], 88);
    193     ASMBitClear(&au32[0], 101);
    194     ASMBitClear(&au32[0], 126);
    195     ASMBitClear(&au32[0], 127);
    196     CHECK(ASMBitFirstClear(&au32[0], sizeof(au32) * 8) == 31);
    197     CHECK(ASMBitNextClear(&au32[0], sizeof(au32) * 8,  31) ==  57);
    198     CHECK(ASMBitNextClear(&au32[0], sizeof(au32) * 8,  57) ==  88);
    199     CHECK(ASMBitNextClear(&au32[0], sizeof(au32) * 8,  88) == 101);
    200     CHECK(ASMBitNextClear(&au32[0], sizeof(au32) * 8, 101) == 126);
    201     CHECK(ASMBitNextClear(&au32[0], sizeof(au32) * 8, 126) == 127);
    202     CHECK(ASMBitNextClear(&au32[0], sizeof(au32) * 8, 127) == -1);
    203 
    204     CHECK(ASMBitNextSet(&au32[0], sizeof(au32) * 8, 29) == 30);
    205     CHECK(ASMBitNextSet(&au32[0], sizeof(au32) * 8, 30) == 32);
    206 
    207     MAP_CLEAR(au32);
     188    MAP_SET(p);
     189    CHECK(ASMBitFirstClear(&p->au32[0], sizeof(p->au32) * 8) == -1);
     190    CHECK(ASMBitFirstSet(&p->au32[0], sizeof(p->au32) * 8) == 0);
     191
     192    ASMBitClear(&p->au32[0], 1);
     193    CHECK(ASMBitFirstClear(&p->au32[0], sizeof(p->au32) * 8) == 1);
     194    CHECK(ASMBitFirstSet(&p->au32[0], sizeof(p->au32) * 8) == 0);
     195
     196    MAP_SET(p);
     197    ASMBitClear(&p->au32[0], 95);
     198    CHECK(ASMBitFirstClear(&p->au32[0], sizeof(p->au32) * 8) == 95);
     199    CHECK(ASMBitFirstSet(&p->au32[0], sizeof(p->au32) * 8) == 0);
     200
     201    MAP_SET(p);
     202    ASMBitClear(&p->au32[0], 127);
     203    CHECK(ASMBitFirstClear(&p->au32[0], sizeof(p->au32) * 8) == 127);
     204    CHECK(ASMBitFirstSet(&p->au32[0], sizeof(p->au32) * 8) == 0);
     205    CHECK(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, 0) == 1);
     206    CHECK(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, 1) == 2);
     207    CHECK(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, 2) == 3);
     208
     209
     210    MAP_SET(p);
     211    CHECK(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8, 0) == -1);
     212    ASMBitClear(&p->au32[0], 32);
     213    CHECK(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8, 32) == -1);
     214    ASMBitClear(&p->au32[0], 88);
     215    CHECK(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8,  57) ==  88);
     216
     217    MAP_SET(p);
     218    ASMBitClear(&p->au32[0], 31);
     219    ASMBitClear(&p->au32[0], 57);
     220    ASMBitClear(&p->au32[0], 88);
     221    ASMBitClear(&p->au32[0], 101);
     222    ASMBitClear(&p->au32[0], 126);
     223    ASMBitClear(&p->au32[0], 127);
     224    CHECK(ASMBitFirstClear(&p->au32[0], sizeof(p->au32) * 8) == 31);
     225    CHECK(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8,  31) ==  57);
     226    CHECK(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8,  57) ==  88);
     227    CHECK(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8,  88) == 101);
     228    CHECK(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8, 101) == 126);
     229    CHECK(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8, 126) == 127);
     230    CHECK(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8, 127) == -1);
     231
     232    CHECK(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, 29) == 30);
     233    CHECK(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, 30) == 32);
     234
     235    MAP_CLEAR(p);
    208236    for (i = 1; i < 128; i++)
    209         CHECK_BIT(ASMBitNextClear(&au32[0], sizeof(au32) * 8, i - 1) == i, i);
     237        CHECK_BIT(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8, i - 1) == i, i);
    210238    for (i = 0; i < 128; i++)
    211239    {
    212         MAP_SET(au32);
    213         ASMBitClear(&au32[0], i);
    214         CHECK_BIT(ASMBitFirstClear(&au32[0], sizeof(au32) * 8) == i, i);
     240        MAP_SET(p);
     241        ASMBitClear(&p->au32[0], i);
     242        CHECK_BIT(ASMBitFirstClear(&p->au32[0], sizeof(p->au32) * 8) == i, i);
    215243        for (j = 0; j < i; j++)
    216             CHECK_BIT(ASMBitNextClear(&au32[0], sizeof(au32) * 8, j) == i, i);
     244            CHECK_BIT(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8, j) == i, i);
    217245        for (j = i; j < 128; j++)
    218             CHECK_BIT(ASMBitNextClear(&au32[0], sizeof(au32) * 8, j) == -1, i);
     246            CHECK_BIT(ASMBitNextClear(&p->au32[0], sizeof(p->au32) * 8, j) == -1, i);
    219247    }
    220248
    221249    /* clear range. */
    222     MAP_SET(au32);
    223     ASMBitClearRange(&au32, 0, 128);
    224     CHECK(!au32[0] && !au32[1] && !au32[2] && !au32[3]);
     250    MAP_SET(p);
     251    ASMBitClearRange(&p->au32, 0, 128);
     252    CHECK(!p->au32[0] && !p->au32[1] && !p->au32[2] && !p->au32[3]);
    225253    for (i = 0; i < 128; i++)
    226254    {
    227255        for (j = i + 1; j <= 128; j++)
    228256        {
    229             MAP_SET(au32);
    230             ASMBitClearRange(&au32, i, j);
     257            MAP_SET(p);
     258            ASMBitClearRange(&p->au32, i, j);
    231259            for (k = 0; k < i; k++)
    232                 CHECK_BIT3(ASMBitTest(&au32[0], k), i, j, k);
     260                CHECK_BIT3(ASMBitTest(&p->au32[0], k), i, j, k);
    233261            for (k = i; k < j; k++)
    234                 CHECK_BIT3(!ASMBitTest(&au32[0], k), i, j, k);
     262                CHECK_BIT3(!ASMBitTest(&p->au32[0], k), i, j, k);
    235263            for (k = j; k < 128; k++)
    236                 CHECK_BIT3(ASMBitTest(&au32[0], k), i, j, k);
     264                CHECK_BIT3(ASMBitTest(&p->au32[0], k), i, j, k);
    237265        }
    238266    }
    239267
    240268    /* searching for set bits. */
    241     MAP_CLEAR(au32);
    242     CHECK(ASMBitFirstSet(&au32[0], sizeof(au32) * 8) == -1);
    243 
    244     ASMBitSet(&au32[0], 65);
    245     CHECK(ASMBitFirstSet(&au32[0], sizeof(au32) * 8) == 65);
    246     CHECK(ASMBitNextSet(&au32[0], sizeof(au32) * 8, 65) == -1);
     269    MAP_CLEAR(p);
     270    CHECK(ASMBitFirstSet(&p->au32[0], sizeof(p->au32) * 8) == -1);
     271
     272    ASMBitSet(&p->au32[0], 65);
     273    CHECK(ASMBitFirstSet(&p->au32[0], sizeof(p->au32) * 8) == 65);
     274    CHECK(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, 65) == -1);
    247275    for (i = 0; i < 65; i++)
    248         CHECK(ASMBitNextSet(&au32[0], sizeof(au32) * 8, i) == 65);
     276        CHECK(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, i) == 65);
    249277    for (i = 65; i < 128; i++)
    250         CHECK(ASMBitNextSet(&au32[0], sizeof(au32) * 8, i) == -1);
    251 
    252     ASMBitSet(&au32[0], 17);
    253     CHECK(ASMBitFirstSet(&au32[0], sizeof(au32) * 8) == 17);
    254     CHECK(ASMBitNextSet(&au32[0], sizeof(au32) * 8, 17) == 65);
     278        CHECK(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, i) == -1);
     279
     280    ASMBitSet(&p->au32[0], 17);
     281    CHECK(ASMBitFirstSet(&p->au32[0], sizeof(p->au32) * 8) == 17);
     282    CHECK(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, 17) == 65);
    255283    for (i = 0; i < 16; i++)
    256         CHECK(ASMBitNextSet(&au32[0], sizeof(au32) * 8, i) == 17);
     284        CHECK(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, i) == 17);
    257285    for (i = 17; i < 65; i++)
    258         CHECK(ASMBitNextSet(&au32[0], sizeof(au32) * 8, i) == 65);
    259 
    260     MAP_SET(au32);
     286        CHECK(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, i) == 65);
     287
     288    MAP_SET(p);
    261289    for (i = 1; i < 128; i++)
    262         CHECK_BIT(ASMBitNextSet(&au32[0], sizeof(au32) * 8, i - 1) == i, i);
     290        CHECK_BIT(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, i - 1) == i, i);
    263291    for (i = 0; i < 128; i++)
    264292    {
    265         MAP_CLEAR(au32);
    266         ASMBitSet(&au32[0], i);
    267         CHECK_BIT(ASMBitFirstSet(&au32[0], sizeof(au32) * 8) == i, i);
     293        MAP_CLEAR(p);
     294        ASMBitSet(&p->au32[0], i);
     295        CHECK_BIT(ASMBitFirstSet(&p->au32[0], sizeof(p->au32) * 8) == i, i);
    268296        for (j = 0; j < i; j++)
    269             CHECK_BIT(ASMBitNextSet(&au32[0], sizeof(au32) * 8, j) == i, i);
     297            CHECK_BIT(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, j) == i, i);
    270298        for (j = i; j < 128; j++)
    271             CHECK_BIT(ASMBitNextSet(&au32[0], sizeof(au32) * 8, j) == -1, i);
     299            CHECK_BIT(ASMBitNextSet(&p->au32[0], sizeof(p->au32) * 8, j) == -1, i);
    272300    }
    273301
    … …  
    292320     * Summary
    293321     */
    294     if (!rcRet)
    295         RTPrintf("tstBitOperations: SUCCESS\n");
    296     else
    297         RTPrintf("tstBitOperations: FAILURE - %d errors\n", rcRet);
    298     return rcRet;
     322    return RTTestSummaryAndDestroy(hTest);
    299323}
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette