rostests/apitests/ntdll/RtlBitmap.c

   1
   2 #include <apitest.h>
   3
   4 #define WIN32_NO_STATUS
   5 #include <ndk/rtlfuncs.h>
   6
   7 void
   8 Test_RtlFindMostSignificantBit(void)
   9 {
  10     ok_int(RtlFindMostSignificantBit(0), -1);
  11
  12     ok_int(RtlFindMostSignificantBit(0x0000000000000001ULL), 0);
  13     ok_int(RtlFindMostSignificantBit(0x0000000000000002ULL), 1);
  14     ok_int(RtlFindMostSignificantBit(0x1000000000000000ULL), 60);
  15     ok_int(RtlFindMostSignificantBit(0x8000000000000000ULL), 63);
  16     ok_int(RtlFindMostSignificantBit(0x8000000000000001ULL), 63);
  17     ok_int(RtlFindMostSignificantBit(0xFFFFFFFFFFFFFFFFULL), 63);
  18     ok_int(RtlFindMostSignificantBit(0x0000000070000000ULL), 30);
  19 }
  20
  21 void
  22 Test_RtlFindLeastSignificantBit(void)
  23 {
  24     ok_int(RtlFindLeastSignificantBit(0), -1);
  25
  26     ok_int(RtlFindLeastSignificantBit(0x0000000000000001ULL), 0);
  27     ok_int(RtlFindLeastSignificantBit(0x0000000000000002ULL), 1);
  28     ok_int(RtlFindLeastSignificantBit(0x1000000000000000ULL), 60);
  29     ok_int(RtlFindLeastSignificantBit(0x8000000000000000ULL), 63);
  30     ok_int(RtlFindLeastSignificantBit(0x8000000000000000ULL), 63);
  31     ok_int(RtlFindLeastSignificantBit(0xFFFFFFFFFFFFFFFFULL), 0);
  32     ok_int(RtlFindLeastSignificantBit(0x0000000070000000ULL), 28);
  33 }
  34
  35 void
  36 Test_RtlInitializeBitMap(void)
  37 {
  38     RTL_BITMAP BitMapHeader;
  39     ULONG Buffer[2];
  40     BOOLEAN Exception = FALSE;
  41
  42     _SEH2_TRY
  43     {
  44         RtlInitializeBitMap(NULL, NULL, 0);
  45     }
  46     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
  47     {
  48         Exception = TRUE;
  49     }
  50     _SEH2_END;
  51     ok_int(Exception, 1);
  52
  53     memset(Buffer, 0xcc, sizeof(Buffer));
  54     RtlInitializeBitMap(&BitMapHeader, Buffer, 0);
  55     ok_int(BitMapHeader.SizeOfBitMap, 0);
  56     ok_ptr(BitMapHeader.Buffer, Buffer);
  57     ok_hex(Buffer[0], 0xcccccccc);
  58
  59     RtlInitializeBitMap(&BitMapHeader, Buffer, 8);
  60     ok_int(BitMapHeader.SizeOfBitMap, 8);
  61     ok_hex(Buffer[0], 0xcccccccc);
  62 }
  63
  64 void
  65 Test_RtlClearAllBits(void)
  66 {
  67     RTL_BITMAP BitMapHeader;
  68     ULONG Buffer[2];
  69
  70     RtlInitializeBitMap(&BitMapHeader, Buffer, 19);
  71     memset(Buffer, 0xcc, sizeof(Buffer));
  72     RtlClearAllBits(&BitMapHeader);
  73     ok_hex(Buffer[0], 0x00000000);
  74     ok_hex(Buffer[1], 0xcccccccc);
  75
  76     RtlInitializeBitMap(&BitMapHeader, Buffer, 0);
  77     memset(Buffer, 0xcc, sizeof(Buffer));
  78     RtlClearAllBits(&BitMapHeader);
  79     ok_hex(Buffer[0], 0xcccccccc);
  80     ok_hex(Buffer[1], 0xcccccccc);
  81 }
  82
  83 void
  84 Test_RtlSetAllBits(void)
  85 {
  86     RTL_BITMAP BitMapHeader;
  87     ULONG Buffer[2];
  88
  89     RtlInitializeBitMap(&BitMapHeader, Buffer, 19);
  90     memset(Buffer, 0xcc, sizeof(Buffer));
  91     RtlSetAllBits(&BitMapHeader);
  92     ok_hex(Buffer[0], 0xffffffff);
  93     ok_hex(Buffer[1], 0xcccccccc);
  94
  95     RtlInitializeBitMap(&BitMapHeader, Buffer, 0);
  96     memset(Buffer, 0xcc, sizeof(Buffer));
  97     RtlSetAllBits(&BitMapHeader);
  98     ok_hex(Buffer[0], 0xcccccccc);
  99     ok_hex(Buffer[1], 0xcccccccc);
 100 }
 101
 102 void
 103 Test_RtlClearBits(void)
 104 {
 105     RTL_BITMAP BitMapHeader;
 106     ULONG Buffer[2];
 107
 108     RtlInitializeBitMap(&BitMapHeader, Buffer, 19);
 109
 110     memset(Buffer, 0xff, sizeof(Buffer));
 111     RtlClearBits(&BitMapHeader, 0, 0);
 112     ok_hex(Buffer[0], 0xffffffff);
 113     ok_hex(Buffer[1], 0xffffffff);
 114
 115     memset(Buffer, 0xff, sizeof(Buffer));
 116     RtlClearBits(&BitMapHeader, 0, 1);
 117     ok_hex(Buffer[0], 0xfffffffe);
 118     ok_hex(Buffer[1], 0xffffffff);
 119
 120     memset(Buffer, 0xff, sizeof(Buffer));
 121     RtlClearBits(&BitMapHeader, 21, 1);
 122     ok_hex(Buffer[0], 0xffdfffff);
 123     ok_hex(Buffer[1], 0xffffffff);
 124
 125     memset(Buffer, 0xff, sizeof(Buffer));
 126     RtlClearBits(&BitMapHeader, 7, 9);
 127     ok_hex(Buffer[0], 0xffff007f);
 128     ok_hex(Buffer[1], 0xffffffff);
 129
 130     memset(Buffer, 0xff, sizeof(Buffer));
 131     RtlClearBits(&BitMapHeader, 13, 22);
 132     ok_hex(Buffer[0], 0x00001fff);
 133     ok_hex(Buffer[1], 0xfffffff8);
 134
 135     memset(Buffer, 0xcc, sizeof(Buffer));
 136     RtlClearBits(&BitMapHeader, 3, 6);
 137     RtlClearBits(&BitMapHeader, 11, 5);
 138     RtlClearBits(&BitMapHeader, 21, 7);
 139     RtlClearBits(&BitMapHeader, 37, 4);
 140     ok_hex(Buffer[0], 0xc00c0404);
 141     ok_hex(Buffer[1], 0xcccccc0c);
 142 }
 143
 144 void
 145 Test_RtlSetBits(void)
 146 {
 147     RTL_BITMAP BitMapHeader;
 148     ULONG Buffer[2];
 149
 150     RtlInitializeBitMap(&BitMapHeader, Buffer, 19);
 151
 152     memset(Buffer, 0x00, sizeof(Buffer));
 153     RtlSetBits(&BitMapHeader, 0, 0);
 154     ok_hex(Buffer[0], 0x00000000);
 155     ok_hex(Buffer[1], 0x00000000);
 156
 157     memset(Buffer, 0x00, sizeof(Buffer));
 158     RtlSetBits(&BitMapHeader, 0, 1);
 159     ok_hex(Buffer[0], 0x00000001);
 160     ok_hex(Buffer[1], 0x00000000);
 161
 162     memset(Buffer, 0x00, sizeof(Buffer));
 163     RtlSetBits(&BitMapHeader, 21, 1);
 164     ok_hex(Buffer[0], 0x00200000);
 165     ok_hex(Buffer[1], 0x00000000);
 166
 167     memset(Buffer, 0x00, sizeof(Buffer));
 168     RtlSetBits(&BitMapHeader, 7, 9);
 169     ok_hex(Buffer[0], 0x0000ff80);
 170     ok_hex(Buffer[1], 0x00000000);
 171
 172     memset(Buffer, 0x00, sizeof(Buffer));
 173     RtlSetBits(&BitMapHeader, 13, 22);
 174     ok_hex(Buffer[0], 0xffffe000);
 175     ok_hex(Buffer[1], 0x00000007);
 176
 177     memset(Buffer, 0xcc, sizeof(Buffer));
 178     RtlSetBits(&BitMapHeader, 3, 6);
 179     RtlSetBits(&BitMapHeader, 11, 5);
 180     RtlSetBits(&BitMapHeader, 21, 7);
 181     RtlSetBits(&BitMapHeader, 37, 4);
 182     ok_hex(Buffer[0], 0xcfecfdfc);
 183     ok_hex(Buffer[1], 0xcccccdec);
 184 }
 185
 186 void
 187 Test_RtlAreBitsClear(void)
 188 {
 189     RTL_BITMAP BitMapHeader;
 190     ULONG Buffer[2];
 191
 192     RtlInitializeBitMap(&BitMapHeader, Buffer, 19);
 193     Buffer[0] = 0x00ff00ff;
 194     Buffer[1] = 0xc0cfc0cf;
 195
 196     ok_hex(RtlAreBitsClear(&BitMapHeader, 0, 8), FALSE);
 197     ok_hex(RtlAreBitsClear(&BitMapHeader, 8, 8), TRUE);
 198     ok_hex(RtlAreBitsClear(&BitMapHeader, 7, 8), FALSE);
 199     ok_hex(RtlAreBitsClear(&BitMapHeader, 8, 9), FALSE);
 200     ok_hex(RtlAreBitsClear(&BitMapHeader, 24, 1), FALSE);
 201
 202     RtlInitializeBitMap(&BitMapHeader, Buffer, 31);
 203     ok_hex(RtlAreBitsClear(&BitMapHeader, 24, 1), TRUE);
 204     ok_hex(RtlAreBitsClear(&BitMapHeader, 24, 7), TRUE);
 205     ok_hex(RtlAreBitsClear(&BitMapHeader, 24, 8), FALSE);
 206
 207 }
 208
 209 void
 210 Test_RtlAreBitsSet(void)
 211 {
 212     RTL_BITMAP BitMapHeader;
 213     ULONG Buffer[2];
 214
 215     RtlInitializeBitMap(&BitMapHeader, Buffer, 19);
 216     Buffer[0] = 0xff00ff00;
 217     Buffer[1] = 0x3F303F30;
 218
 219     ok_hex(RtlAreBitsSet(&BitMapHeader, 0, 8), FALSE);
 220     ok_hex(RtlAreBitsSet(&BitMapHeader, 8, 8), TRUE);
 221     ok_hex(RtlAreBitsSet(&BitMapHeader, 7, 8), FALSE);
 222     ok_hex(RtlAreBitsSet(&BitMapHeader, 8, 9), FALSE);
 223     ok_hex(RtlAreBitsSet(&BitMapHeader, 24, 1), FALSE);
 224
 225     RtlInitializeBitMap(&BitMapHeader, Buffer, 31);
 226     ok_hex(RtlAreBitsSet(&BitMapHeader, 24, 1), TRUE);
 227     ok_hex(RtlAreBitsSet(&BitMapHeader, 24, 7), TRUE);
 228     ok_hex(RtlAreBitsSet(&BitMapHeader, 24, 8), FALSE);
 229
 230 }
 231
 232 void
 233 Test_RtlNumberOfSetBits(void)
 234 {
 235     RTL_BITMAP BitMapHeader;
 236     ULONG Buffer[2];
 237
 238     Buffer[0] = 0xff00ff0f;
 239     Buffer[1] = 0x3F303F30;
 240
 241     RtlInitializeBitMap(&BitMapHeader, Buffer, 0);
 242     ok_int(RtlNumberOfSetBits(&BitMapHeader), 0);
 243
 244     RtlInitializeBitMap(&BitMapHeader, Buffer, 4);
 245     ok_int(RtlNumberOfSetBits(&BitMapHeader), 4);
 246
 247     RtlInitializeBitMap(&BitMapHeader, Buffer, 31);
 248     ok_int(RtlNumberOfSetBits(&BitMapHeader), 19);
 249
 250     RtlInitializeBitMap(&BitMapHeader, Buffer, 56);
 251     ok_int(RtlNumberOfSetBits(&BitMapHeader), 30);
 252 }
 253
 254 void
 255 Test_RtlNumberOfClearBits(void)
 256 {
 257     RTL_BITMAP BitMapHeader;
 258     ULONG Buffer[2];
 259
 260     Buffer[0] = 0xff00fff0;
 261     Buffer[1] = 0x3F303F30;
 262
 263     RtlInitializeBitMap(&BitMapHeader, Buffer, 0);
 264     ok_int(RtlNumberOfClearBits(&BitMapHeader), 0);
 265
 266     RtlInitializeBitMap(&BitMapHeader, Buffer, 4);
 267     ok_int(RtlNumberOfClearBits(&BitMapHeader), 4);
 268
 269     RtlInitializeBitMap(&BitMapHeader, Buffer, 31);
 270     ok_int(RtlNumberOfClearBits(&BitMapHeader), 12);
 271
 272     RtlInitializeBitMap(&BitMapHeader, Buffer, 56);
 273     ok_int(RtlNumberOfClearBits(&BitMapHeader), 26);
 274 }
 275
 276 void
 277 Test_RtlFindClearBits(void)
 278 {
 279     RTL_BITMAP BitMapHeader;
 280     ULONG Buffer[2];
 281
 282     Buffer[0] = 0x060F874D;
 283     Buffer[1] = 0x3F303F30;
 284
 285     RtlInitializeBitMap(&BitMapHeader, Buffer, 0);
 286     ok_int(RtlFindClearBits(&BitMapHeader, 0, 0), 0);
 287     ok_int(RtlFindClearBits(&BitMapHeader, 0, 3), 0);
 288     ok_int(RtlFindClearBits(&BitMapHeader, 1, 0), -1);
 289     ok_int(RtlFindClearBits(&BitMapHeader, 1, 1), -1);
 290
 291     RtlInitializeBitMap(&BitMapHeader, Buffer, 8);
 292     ok_int(RtlFindClearBits(&BitMapHeader, 0, 3), 0);
 293     ok_int(RtlFindClearBits(&BitMapHeader, 1, 0), 1);
 294     ok_int(RtlFindClearBits(&BitMapHeader, 1, 1), 1);
 295     ok_int(RtlFindClearBits(&BitMapHeader, 1, 2), 4);
 296
 297     ok_int(RtlFindClearBits(&BitMapHeader, 2, 0), 4);
 298     ok_int(RtlFindClearBits(&BitMapHeader, 3, 0), -1);
 299
 300     RtlInitializeBitMap(&BitMapHeader, Buffer, 32);
 301     ok_int(RtlFindClearBits(&BitMapHeader, 0, 3), 0);
 302     ok_int(RtlFindClearBits(&BitMapHeader, 0, 21), 16);
 303     ok_int(RtlFindClearBits(&BitMapHeader, 0, 12), 8);
 304     ok_int(RtlFindClearBits(&BitMapHeader, 0, 31), 24);
 305     ok_int(RtlFindClearBits(&BitMapHeader, 0, 32), 0);
 306     ok_int(RtlFindClearBits(&BitMapHeader, 0, 39), 0);
 307     ok_int(RtlFindClearBits(&BitMapHeader, 4, 0), 11);
 308     ok_int(RtlFindClearBits(&BitMapHeader, 5, 0), 20);
 309     ok_int(RtlFindClearBits(&BitMapHeader, 4, 11), 11);
 310     ok_int(RtlFindClearBits(&BitMapHeader, 4, 12), 20);
 311     ok_int(RtlFindClearBits(&BitMapHeader, 2, 11), 11);
 312     ok_int(RtlFindClearBits(&BitMapHeader, 2, 12), 12);
 313     ok_int(RtlFindClearBits(&BitMapHeader, 1, 32), 1);
 314     ok_int(RtlFindClearBits(&BitMapHeader, 4, 32), 11);
 315     ok_int(RtlFindClearBits(&BitMapHeader, 5, 32), 20);
 316
 317 }
 318
 319 void
 320 Test_RtlFindSetBits(void)
 321 {
 322     RTL_BITMAP BitMapHeader;
 323     ULONG Buffer[2];
 324
 325     Buffer[0] = 0xF9F078B2;
 326     Buffer[1] = 0x3F303F30;
 327
 328     RtlInitializeBitMap(&BitMapHeader, Buffer, 0);
 329     ok_int(RtlFindSetBits(&BitMapHeader, 0, 0), 0);
 330     ok_int(RtlFindSetBits(&BitMapHeader, 0, 3), 0);
 331     ok_int(RtlFindSetBits(&BitMapHeader, 1, 0), -1);
 332     ok_int(RtlFindSetBits(&BitMapHeader, 1, 1), -1);
 333
 334     RtlInitializeBitMap(&BitMapHeader, Buffer, 8);
 335     ok_int(RtlFindSetBits(&BitMapHeader, 0, 3), 0);
 336     ok_int(RtlFindSetBits(&BitMapHeader, 1, 0), 1);
 337     ok_int(RtlFindSetBits(&BitMapHeader, 1, 1), 1);
 338     ok_int(RtlFindSetBits(&BitMapHeader, 1, 2), 4);
 339
 340     ok_int(RtlFindSetBits(&BitMapHeader, 2, 0), 4);
 341     ok_int(RtlFindSetBits(&BitMapHeader, 3, 0), -1);
 342
 343     RtlInitializeBitMap(&BitMapHeader, Buffer, 32);
 344     ok_int(RtlFindSetBits(&BitMapHeader, 0, 3), 0);
 345     ok_int(RtlFindSetBits(&BitMapHeader, 0, 21), 16);
 346     ok_int(RtlFindSetBits(&BitMapHeader, 0, 12), 8);
 347     ok_int(RtlFindSetBits(&BitMapHeader, 0, 31), 24);
 348     ok_int(RtlFindSetBits(&BitMapHeader, 0, 32), 0);
 349     ok_int(RtlFindSetBits(&BitMapHeader, 0, 39), 0);
 350     ok_int(RtlFindSetBits(&BitMapHeader, 4, 0), 11);
 351     ok_int(RtlFindSetBits(&BitMapHeader, 5, 0), 20);
 352     ok_int(RtlFindSetBits(&BitMapHeader, 4, 11), 11);
 353     ok_int(RtlFindSetBits(&BitMapHeader, 4, 12), 20);
 354     ok_int(RtlFindSetBits(&BitMapHeader, 2, 11), 11);
 355     ok_int(RtlFindSetBits(&BitMapHeader, 1, 32), 1);
 356     ok_int(RtlFindSetBits(&BitMapHeader, 4, 32), 11);
 357     ok_int(RtlFindSetBits(&BitMapHeader, 5, 32), 20);
 358
 359 }
 360
 361 void
 362 Test_RtlFindClearBitsAndSet(void)
 363 {
 364     RTL_BITMAP BitMapHeader;
 365     ULONG Buffer[2];
 366
 367     Buffer[0] = 0x060F874D;
 368     Buffer[1] = 0x3F303F30;
 369
 370     RtlInitializeBitMap(&BitMapHeader, Buffer, 0);
 371     ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 0, 0), 0);
 372     ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 0, 3), 0);
 373     ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 1, 0), -1);
 374     ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 1, 1), -1);
 375     ok_hex(Buffer[0], 0x060F874D);
 376
 377     Buffer[0] = 0x060F874D;
 378     RtlInitializeBitMap(&BitMapHeader, Buffer, 8);
 379     ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 1, 0), 1);
 380     ok_hex(Buffer[0], 0x60f874f);
 381     ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 1, 1), 4);
 382     ok_hex(Buffer[0], 0x60f875f);
 383     ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 1, 2), 5);
 384     ok_hex(Buffer[0], 0x60f877f);
 385     ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 2, 0), -1);
 386     ok_hex(Buffer[0], 0x60f877f);
 387
 388     Buffer[0] = 0x060F874D;
 389     RtlInitializeBitMap(&BitMapHeader, Buffer, 32);
 390     ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 4, 0), 11);
 391     ok_hex(Buffer[0], 0x60fff4d);
 392     ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 5, 0), 20);
 393     ok_hex(Buffer[0], 0x7ffff4d);
 394     ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 4, 11), 27);
 395     ok_hex(Buffer[0], 0x7fffff4d);
 396
 397     Buffer[0] = 0x060F874D;
 398     ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 4, 12), 20);
 399     ok_hex(Buffer[0], 0x6ff874d);
 400     ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 2, 11), 11);
 401     ok_hex(Buffer[0], 0x6ff9f4d);
 402     ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 2, 12), 13);
 403     ok_hex(Buffer[0], 0x6ffff4d);
 404 }
 405
 406 void
 407 Test_RtlFindSetBitsAndClear(void)
 408 {
 409     RTL_BITMAP BitMapHeader;
 410     ULONG Buffer[2];
 411
 412     Buffer[0] = 0xF9F078B2;
 413     Buffer[1] = 0x3F303F30;
 414
 415     RtlInitializeBitMap(&BitMapHeader, Buffer, 0);
 416     ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 0, 0), 0);
 417     ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 0, 3), 0);
 418     ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 1, 0), -1);
 419     ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 1, 1), -1);
 420     ok_hex(Buffer[0], 0xF9F078B2);
 421
 422     Buffer[0] = 0xF9F078B2;
 423     RtlInitializeBitMap(&BitMapHeader, Buffer, 8);
 424     ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 1, 0), 1);
 425     ok_hex(Buffer[0], 0xf9f078b0);
 426     ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 1, 1), 4);
 427     ok_hex(Buffer[0], 0xf9f078a0);
 428     ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 1, 2), 5);
 429     ok_hex(Buffer[0], 0xf9f07880);
 430     ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 2, 0), -1);
 431     ok_hex(Buffer[0], 0xf9f07880);
 432
 433     Buffer[0] = 0xF9F078B2;
 434     RtlInitializeBitMap(&BitMapHeader, Buffer, 32);
 435     ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 4, 0), 11);
 436     ok_hex(Buffer[0], 0xf9f000b2);
 437     ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 5, 0), 20);
 438     ok_hex(Buffer[0], 0xf80000b2);
 439     ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 4, 11), 27);
 440     ok_hex(Buffer[0], 0x800000b2);
 441
 442     Buffer[0] = 0xF9F078B2;
 443     ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 4, 12), 20);
 444     ok_hex(Buffer[0], 0xf90078b2);
 445     ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 2, 11), 11);
 446     ok_hex(Buffer[0], 0xf90060b2);
 447     ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 2, 12), 13);
 448     ok_hex(Buffer[0], 0xf90000b2);
 449
 450 }
 451
 452 void
 453 Test_RtlFindNextForwardRunClear(void)
 454 {
 455     RTL_BITMAP BitMapHeader;
 456     ULONG Buffer[2];
 457     ULONG Index;
 458
 459     Buffer[0] = 0xF9F078B2;
 460     Buffer[1] = 0x3F303F30;
 461
 462     RtlInitializeBitMap(&BitMapHeader, Buffer, 0);
 463     ok_int(RtlFindNextForwardRunClear(&BitMapHeader, 0, &Index), 0);
 464     ok_int(Index, 0);
 465     ok_int(RtlFindNextForwardRunClear(&BitMapHeader, 1, &Index), 0);
 466     ok_int(Index, 1);
 467
 468     Index = -1;
 469     RtlInitializeBitMap(&BitMapHeader, Buffer, 8);
 470     ok_int(RtlFindNextForwardRunClear(&BitMapHeader, 0, &Index), 1);
 471     ok_int(Index, 0);
 472     ok_int(RtlFindNextForwardRunClear(&BitMapHeader, 1, &Index), 2);
 473     ok_int(Index, 2);
 474     ok_int(RtlFindNextForwardRunClear(&BitMapHeader, 7, &Index), 0);
 475     ok_int(Index, 8);
 476     ok_int(RtlFindNextForwardRunClear(&BitMapHeader, 17, &Index), 0);
 477     ok_int(Index, 17);
 478     ok_int(RtlFindNextForwardRunClear(&BitMapHeader, 39, &Index), 0);
 479     ok_int(Index, 39);
 480 }
 481
 482 void
 483 Test_RtlFindFirstRunClear(void)
 484 {
 485 }
 486
 487 void
 488 Test_RtlFindLastBackwardRunClear(void)
 489 {
 490 }
 491
 492 void
 493 Test_RtlFindClearRuns(void)
 494 {
 495 }
 496
 497 void
 498 Test_RtlFindLongestRunClear(void)
 499 {
 500 }
 501
 502
 503 START_TEST(RtlBitmap)
 504 {
 505     Test_RtlFindMostSignificantBit();
 506     Test_RtlFindLeastSignificantBit();
 507     Test_RtlInitializeBitMap();
 508     Test_RtlClearAllBits();
 509     Test_RtlSetAllBits();
 510     Test_RtlClearBits();
 511     Test_RtlSetBits();
 512     Test_RtlAreBitsClear();
 513     Test_RtlAreBitsSet();
 514     Test_RtlNumberOfSetBits();
 515     Test_RtlNumberOfClearBits();
 516     Test_RtlFindClearBits();
 517     Test_RtlFindSetBits();
 518     Test_RtlFindClearBitsAndSet();
 519     Test_RtlFindSetBitsAndClear();
 520     Test_RtlFindNextForwardRunClear();
 521     Test_RtlFindFirstRunClear();
 522     Test_RtlFindLastBackwardRunClear();
 523     Test_RtlFindClearRuns();
 524     Test_RtlFindLongestRunClear();
 525 }
 526