dlls/ntdll/tests/rtlbitmap.c

   1 /* Unit test suite for Rtl bitmap functions
   2  *
   3  * Copyright 2002 Jon Griffiths
   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 St, Fifth Floor, Boston, MA 02110-1301, USA
  18  *
  19  * NOTES
  20  * We use function pointers here as some of the bitmap functions exist only
  21  * in later versions of ntdll.
  22  */
  23
  24 #include "ntdll_test.h"
  25
  26 #ifdef __WINE_WINTERNL_H
  27
  28 /* Function ptrs for ordinal calls */
  29 static HMODULE hntdll = 0;
  30 static VOID (WINAPI *pRtlInitializeBitMap)(PRTL_BITMAP,LPBYTE,ULONG);
  31 static VOID (WINAPI *pRtlSetAllBits)(PRTL_BITMAP);
  32 static VOID (WINAPI *pRtlClearAllBits)(PRTL_BITMAP);
  33 static VOID (WINAPI *pRtlSetBits)(PRTL_BITMAP,ULONG,ULONG);
  34 static VOID (WINAPI *pRtlClearBits)(PRTL_BITMAP,ULONG,ULONG);
  35 static BOOLEAN (WINAPI *pRtlAreBitsSet)(PRTL_BITMAP,ULONG,ULONG);
  36 static BOOLEAN (WINAPI *pRtlAreBitsClear)(PRTL_BITMAP,ULONG,ULONG);
  37 static ULONG (WINAPI *pRtlFindSetBitsAndClear)(PRTL_BITMAP,ULONG,ULONG);
  38 static ULONG (WINAPI *pRtlFindClearBitsAndSet)(PRTL_BITMAP,ULONG,ULONG);
  39 static CCHAR (WINAPI *pRtlFindMostSignificantBit)(ULONGLONG);
  40 static CCHAR (WINAPI *pRtlFindLeastSignificantBit)(ULONGLONG);
  41 static ULONG (WINAPI *pRtlFindSetRuns)(PRTL_BITMAP,PRTL_BITMAP_RUN,ULONG,BOOLEAN);
  42 static ULONG (WINAPI *pRtlFindClearRuns)(PRTL_BITMAP,PRTL_BITMAP_RUN,ULONG,BOOLEAN);
  43 static ULONG (WINAPI *pRtlNumberOfSetBits)(PRTL_BITMAP);
  44 static ULONG (WINAPI *pRtlNumberOfClearBits)(PRTL_BITMAP);
  45 static ULONG (WINAPI *pRtlFindLongestRunSet)(PRTL_BITMAP,PULONG);
  46 static ULONG (WINAPI *pRtlFindLongestRunClear)(PRTL_BITMAP,PULONG);
  47
  48 static BYTE buff[256];
  49 static RTL_BITMAP bm;
  50
  51 static void InitFunctionPtrs(void)
  52 {
  53   hntdll = LoadLibraryA("ntdll.dll");
  54   ok(hntdll != 0, "LoadLibrary failed\n");
  55   if (hntdll)
  56   {
  57     pRtlInitializeBitMap = (void *)GetProcAddress(hntdll, "RtlInitializeBitMap");
  58     pRtlSetAllBits = (void *)GetProcAddress(hntdll, "RtlSetAllBits");
  59     pRtlClearAllBits = (void *)GetProcAddress(hntdll, "RtlClearAllBits");
  60     pRtlSetBits = (void *)GetProcAddress(hntdll, "RtlSetBits");
  61     pRtlClearBits = (void *)GetProcAddress(hntdll, "RtlClearBits");
  62     pRtlAreBitsSet = (void *)GetProcAddress(hntdll, "RtlAreBitsSet");
  63     pRtlAreBitsClear = (void *)GetProcAddress(hntdll, "RtlAreBitsClear");
  64     pRtlNumberOfSetBits = (void *)GetProcAddress(hntdll, "RtlNumberOfSetBits");
  65     pRtlNumberOfClearBits = (void *)GetProcAddress(hntdll, "RtlNumberOfClearBits");
  66     pRtlFindSetBitsAndClear = (void *)GetProcAddress(hntdll, "RtlFindSetBitsAndClear");
  67     pRtlFindClearBitsAndSet = (void *)GetProcAddress(hntdll, "RtlFindClearBitsAndSet");
  68     pRtlFindMostSignificantBit = (void *)GetProcAddress(hntdll, "RtlFindMostSignificantBit");
  69     pRtlFindLeastSignificantBit = (void *)GetProcAddress(hntdll, "RtlFindLeastSignificantBit");
  70     pRtlFindSetRuns = (void *)GetProcAddress(hntdll, "RtlFindSetRuns");
  71     pRtlFindClearRuns = (void *)GetProcAddress(hntdll, "RtlFindClearRuns");
  72     pRtlFindLongestRunSet = (void *)GetProcAddress(hntdll, "RtlFindLongestRunSet");
  73     pRtlFindLongestRunClear = (void *)GetProcAddress(hntdll, "RtlFindLongestRunClear");
  74   }
  75 }
  76
  77 static void test_RtlInitializeBitMap(void)
  78 {
  79   bm.SizeOfBitMap = 0;
  80   bm.Buffer = 0;
  81
  82   memset(buff, 0, sizeof(buff));
  83   buff[0] = 77; /* Check buffer is not written to during init */
  84   buff[79] = 77;
  85
  86   pRtlInitializeBitMap(&bm, buff, 800);
  87   ok(bm.SizeOfBitMap == 800, "size uninitialised\n");
  88   ok(bm.Buffer == (PULONG)buff,"buffer uninitialised\n");
  89   ok(buff[0] == 77 && buff[79] == 77, "wrote to buffer\n");
  90 }
  91
  92 static void test_RtlSetAllBits(void)
  93 {
  94   if (!pRtlSetAllBits)
  95     return;
  96
  97   memset(buff, 0 , sizeof(buff));
  98   pRtlInitializeBitMap(&bm, buff, 1);
  99
 100   pRtlSetAllBits(&bm);
 101   ok(buff[0] == 0xff && buff[1] == 0xff && buff[2] == 0xff &&
 102      buff[3] == 0xff, "didn't round up size\n");
 103   ok(buff[4] == 0, "set more than rounded size\n");
 104 }
 105
 106 static void test_RtlClearAllBits(void)
 107 {
 108   if (!pRtlClearAllBits)
 109     return;
 110
 111   memset(buff, 0xff , sizeof(buff));
 112   pRtlInitializeBitMap(&bm, buff, 1);
 113
 114   pRtlClearAllBits(&bm);
 115   ok(!buff[0] && !buff[1] && !buff[2] && !buff[3], "didn't round up size\n");
 116   ok(buff[4] == 0xff, "cleared more than rounded size\n");
 117 }
 118
 119 static void test_RtlSetBits(void)
 120 {
 121   if (!pRtlSetBits)
 122     return;
 123
 124   memset(buff, 0 , sizeof(buff));
 125   pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);
 126
 127   pRtlSetBits(&bm, 0, 1);
 128   ok(buff[0] == 1, "didn't set 1st bit\n");
 129
 130   buff[0] = 0;
 131   pRtlSetBits(&bm, 7, 2);
 132   ok(buff[0] == 0x80 && buff[1] == 1, "didn't span w/len < 8\n");
 133
 134   buff[0] = buff[1] = 0;
 135   pRtlSetBits(&bm, 7, 10);
 136   ok(buff[0] == 0x80 && buff[1] == 0xff && buff[2] == 1, "didn't span w/len > 8\n");
 137
 138   buff[0] = buff[1] = buff[2] = 0;
 139   pRtlSetBits(&bm, 0, 8); /* 1st byte */
 140   ok(buff[0] == 0xff, "didn't set all bits\n");
 141   ok(!buff[1], "set too many bits\n");
 142
 143   pRtlSetBits(&bm, sizeof(buff)*8-1, 1); /* last bit */
 144   ok(buff[sizeof(buff)-1] == 0x80, "didn't set last bit\n");
 145 }
 146
 147 static void test_RtlClearBits(void)
 148 {
 149   if (!pRtlClearBits)
 150     return;
 151
 152   memset(buff, 0xff , sizeof(buff));
 153   pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);
 154
 155   pRtlClearBits(&bm, 0, 1);
 156   ok(buff[0] == 0xfe, "didn't clear 1st bit\n");
 157
 158   buff[0] = 0xff;
 159   pRtlClearBits(&bm, 7, 2);
 160   ok(buff[0] == 0x7f && buff[1] == 0xfe, "didn't span w/len < 8\n");
 161
 162   buff[0] = buff[1] = 0xff;
 163   pRtlClearBits(&bm, 7, 10);
 164   ok(buff[0] == 0x7f && buff[1] == 0 && buff[2] == 0xfe, "didn't span w/len > 8\n");
 165
 166   buff[0] = buff[1] = buff[2] = 0xff;
 167   pRtlClearBits(&bm, 0, 8);  /* 1st byte */
 168   ok(!buff[0], "didn't clear all bits\n");
 169   ok(buff[1] == 0xff, "cleared too many bits\n");
 170
 171   pRtlClearBits(&bm, sizeof(buff)*8-1, 1);
 172   ok(buff[sizeof(buff)-1] == 0x7f, "didn't set last bit\n");
 173 }
 174
 175 static void test_RtlCheckBit(void)
 176 {
 177   BOOLEAN bRet;
 178
 179   memset(buff, 0 , sizeof(buff));
 180   pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);
 181   pRtlSetBits(&bm, 0, 1);
 182   pRtlSetBits(&bm, 7, 2);
 183   pRtlSetBits(&bm, sizeof(buff)*8-1, 1);
 184
 185   bRet = RtlCheckBit(&bm, 0);
 186   ok (bRet, "didn't find set bit\n");
 187   bRet = RtlCheckBit(&bm, 7);
 188   ok (bRet, "didn't find set bit\n");
 189   bRet = RtlCheckBit(&bm, 8);
 190   ok (bRet, "didn't find set bit\n");
 191   bRet = RtlCheckBit(&bm, sizeof(buff)*8-1);
 192   ok (bRet, "didn't find set bit\n");
 193   bRet = RtlCheckBit(&bm, 1);
 194   ok (!bRet, "found non set bit\n");
 195   bRet = RtlCheckBit(&bm, sizeof(buff)*8-2);
 196   ok (!bRet, "found non set bit\n");
 197 }
 198
 199 static void test_RtlAreBitsSet(void)
 200 {
 201   BOOLEAN bRet;
 202
 203   if (!pRtlAreBitsSet)
 204     return;
 205
 206   memset(buff, 0 , sizeof(buff));
 207   pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);
 208
 209   bRet = pRtlAreBitsSet(&bm, 0, 1);
 210   ok (!bRet, "found set bits after init\n");
 211
 212   pRtlSetBits(&bm, 0, 1);
 213   bRet = pRtlAreBitsSet(&bm, 0, 1);
 214   ok (bRet, "didn't find set bits\n");
 215
 216   buff[0] = 0;
 217   pRtlSetBits(&bm, 7, 2);
 218   bRet = pRtlAreBitsSet(&bm, 7, 2);
 219   ok(bRet, "didn't find w/len < 8\n");
 220   bRet = pRtlAreBitsSet(&bm, 6, 3);
 221   ok(!bRet, "found non set bit\n");
 222   bRet = pRtlAreBitsSet(&bm, 7, 3);
 223   ok(!bRet, "found non set bit\n");
 224
 225   buff[0] = buff[1] = 0;
 226   pRtlSetBits(&bm, 7, 10);
 227   bRet = pRtlAreBitsSet(&bm, 7, 10);
 228   ok(bRet, "didn't find w/len < 8\n");
 229   bRet = pRtlAreBitsSet(&bm, 6, 11);
 230   ok(!bRet, "found non set bit\n");
 231   bRet = pRtlAreBitsSet(&bm, 7, 11);
 232   ok(!bRet, "found non set bit\n");
 233
 234   buff[0] = buff[1] = buff[2] = 0;
 235   pRtlSetBits(&bm, 0, 8); /* 1st byte */
 236   bRet = pRtlAreBitsSet(&bm, 0, 8);
 237   ok(bRet, "didn't find whole byte\n");
 238
 239   pRtlSetBits(&bm, sizeof(buff)*8-1, 1);
 240   bRet = pRtlAreBitsSet(&bm, sizeof(buff)*8-1, 1);
 241   ok(bRet, "didn't find last bit\n");
 242 }
 243
 244 static void test_RtlAreBitsClear(void)
 245 {
 246   BOOLEAN bRet;
 247
 248   if (!pRtlAreBitsClear)
 249     return;
 250
 251   memset(buff, 0xff , sizeof(buff));
 252   pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);
 253
 254   bRet = pRtlAreBitsClear(&bm, 0, 1);
 255   ok (!bRet, "found clear bits after init\n");
 256
 257   pRtlClearBits(&bm, 0, 1);
 258   bRet = pRtlAreBitsClear(&bm, 0, 1);
 259   ok (bRet, "didn't find set bits\n");
 260
 261   buff[0] = 0xff;
 262   pRtlClearBits(&bm, 7, 2);
 263   bRet = pRtlAreBitsClear(&bm, 7, 2);
 264   ok(bRet, "didn't find w/len < 8\n");
 265   bRet = pRtlAreBitsClear(&bm, 6, 3);
 266   ok(!bRet, "found non clear bit\n");
 267   bRet = pRtlAreBitsClear(&bm, 7, 3);
 268   ok(!bRet, "found non clear bit\n");
 269
 270   buff[0] = buff[1] = 0xff;
 271   pRtlClearBits(&bm, 7, 10);
 272   bRet = pRtlAreBitsClear(&bm, 7, 10);
 273   ok(bRet, "didn't find w/len < 8\n");
 274   bRet = pRtlAreBitsClear(&bm, 6, 11);
 275   ok(!bRet, "found non clear bit\n");
 276   bRet = pRtlAreBitsClear(&bm, 7, 11);
 277   ok(!bRet, "found non clear bit\n");
 278
 279   buff[0] = buff[1] = buff[2] = 0xff;
 280   pRtlClearBits(&bm, 0, 8); /* 1st byte */
 281   bRet = pRtlAreBitsClear(&bm, 0, 8);
 282   ok(bRet, "didn't find whole byte\n");
 283
 284   pRtlClearBits(&bm, sizeof(buff)*8-1, 1);
 285   bRet = pRtlAreBitsClear(&bm, sizeof(buff)*8-1, 1);
 286   ok(bRet, "didn't find last bit\n");
 287 }
 288
 289 static void test_RtlNumberOfSetBits(void)
 290 {
 291   ULONG ulCount;
 292
 293   if (!pRtlNumberOfSetBits)
 294     return;
 295
 296   memset(buff, 0 , sizeof(buff));
 297   pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);
 298
 299   ulCount = pRtlNumberOfSetBits(&bm);
 300   ok(ulCount == 0, "set bits after init\n");
 301
 302   pRtlSetBits(&bm, 0, 1); /* Set 1st bit */
 303   ulCount = pRtlNumberOfSetBits(&bm);
 304   ok(ulCount == 1, "count wrong\n");
 305
 306   pRtlSetBits(&bm, 7, 8); /* 8 more, spanning bytes 1-2 */
 307   ulCount = pRtlNumberOfSetBits(&bm);
 308   ok(ulCount == 8+1, "count wrong\n");
 309
 310   pRtlSetBits(&bm, 17, 33); /* 33 more crossing ULONG boundary */
 311   ulCount = pRtlNumberOfSetBits(&bm);
 312   ok(ulCount == 8+1+33, "count wrong\n");
 313
 314   pRtlSetBits(&bm, sizeof(buff)*8-1, 1); /* Set last bit */
 315   ulCount = pRtlNumberOfSetBits(&bm);
 316   ok(ulCount == 8+1+33+1, "count wrong\n");
 317 }
 318
 319 static void test_RtlNumberOfClearBits(void)
 320 {
 321   ULONG ulCount;
 322
 323   if (!pRtlNumberOfClearBits)
 324     return;
 325
 326   memset(buff, 0xff , sizeof(buff));
 327   pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);
 328
 329   ulCount = pRtlNumberOfClearBits(&bm);
 330   ok(ulCount == 0, "cleared bits after init\n");
 331
 332   pRtlClearBits(&bm, 0, 1); /* Set 1st bit */
 333   ulCount = pRtlNumberOfClearBits(&bm);
 334   ok(ulCount == 1, "count wrong\n");
 335
 336   pRtlClearBits(&bm, 7, 8); /* 8 more, spanning bytes 1-2 */
 337   ulCount = pRtlNumberOfClearBits(&bm);
 338   ok(ulCount == 8+1, "count wrong\n");
 339
 340   pRtlClearBits(&bm, 17, 33); /* 33 more crossing ULONG boundary */
 341   ulCount = pRtlNumberOfClearBits(&bm);
 342   ok(ulCount == 8+1+33, "count wrong\n");
 343
 344   pRtlClearBits(&bm, sizeof(buff)*8-1, 1); /* Set last bit */
 345   ulCount = pRtlNumberOfClearBits(&bm);
 346   ok(ulCount == 8+1+33+1, "count wrong\n");
 347 }
 348
 349 /* Note: this tests RtlFindSetBits also */
 350 static void test_RtlFindSetBitsAndClear(void)
 351 {
 352   BOOLEAN bRet;
 353   ULONG ulPos;
 354
 355   if (!pRtlFindSetBitsAndClear)
 356     return;
 357
 358   memset(buff, 0, sizeof(buff));
 359   pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);
 360
 361   pRtlSetBits(&bm, 0, 32);
 362   ulPos = pRtlFindSetBitsAndClear(&bm, 32, 0);
 363   ok (ulPos == 0, "didn't find bits\n");
 364   if(ulPos == 0)
 365   {
 366     bRet = pRtlAreBitsClear(&bm, 0, 32);
 367     ok (bRet, "found but didn't clear\n");
 368   }
 369
 370   memset(buff, 0 , sizeof(buff));
 371   pRtlSetBits(&bm, 40, 77);
 372   ulPos = pRtlFindSetBitsAndClear(&bm, 77, 0);
 373   ok (ulPos == 40, "didn't find bits\n");
 374   if(ulPos == 40)
 375   {
 376     bRet = pRtlAreBitsClear(&bm, 40, 77);
 377     ok (bRet, "found but didn't clear\n");
 378   }
 379 }
 380
 381 /* Note: this tests RtlFindClearBits also */
 382 static void test_RtlFindClearBitsAndSet(void)
 383 {
 384   BOOLEAN bRet;
 385   ULONG ulPos;
 386
 387   if (!pRtlFindClearBitsAndSet)
 388     return;
 389
 390   pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);
 391
 392   memset(buff, 0xff, sizeof(buff));
 393   pRtlSetBits(&bm, 0, 32);
 394   ulPos = pRtlFindSetBitsAndClear(&bm, 32, 0);
 395   ok (ulPos == 0, "didn't find bits\n");
 396   if(ulPos == 0)
 397   {
 398       bRet = pRtlAreBitsClear(&bm, 0, 32);
 399       ok (bRet, "found but didn't clear\n");
 400   }
 401
 402   memset(buff, 0xff , sizeof(buff));
 403   pRtlClearBits(&bm, 40, 77);
 404   ulPos = pRtlFindClearBitsAndSet(&bm, 77, 50);
 405   ok (ulPos == 40, "didn't find bits\n");
 406   if(ulPos == 40)
 407   {
 408     bRet = pRtlAreBitsSet(&bm, 40, 77);
 409     ok (bRet, "found but didn't set\n");
 410   }
 411 }
 412
 413 static void test_RtlFindMostSignificantBit(void)
 414 {
 415   int i;
 416   signed char cPos;
 417   ULONGLONG ulLong;
 418
 419   if (!pRtlFindMostSignificantBit)
 420     return;
 421
 422   for (i = 0; i < 64; i++)
 423   {
 424     ulLong = 1ul;
 425     ulLong <<= i;
 426
 427     cPos = pRtlFindMostSignificantBit(ulLong);
 428     ok (cPos == i, "didn't find MSB 0x%x%08x %d %d\n",
 429         (DWORD)(ulLong >> 32), (DWORD)ulLong, i, cPos);
 430
 431     /* Set all bits lower than bit i */
 432     ulLong = ((ulLong - 1) << 1) | 1;
 433
 434     cPos = pRtlFindMostSignificantBit(ulLong);
 435     ok (cPos == i, "didn't find MSB 0x%x%08x %d %d\n",
 436         (DWORD)(ulLong >> 32), (DWORD)ulLong, i, cPos);
 437   }
 438   cPos = pRtlFindMostSignificantBit(0);
 439   ok (cPos == -1, "found bit when not set\n");
 440 }
 441
 442 static void test_RtlFindLeastSignificantBit(void)
 443 {
 444   int i;
 445   signed char cPos;
 446   ULONGLONG ulLong;
 447
 448   if (!pRtlFindLeastSignificantBit)
 449     return;
 450
 451   for (i = 0; i < 64; i++)
 452   {
 453     ulLong = (ULONGLONG)1 << i;
 454
 455     cPos = pRtlFindLeastSignificantBit(ulLong);
 456     ok (cPos == i, "didn't find LSB 0x%x%08x %d %d\n",
 457         (DWORD)(ulLong >> 32), (DWORD)ulLong, i, cPos);
 458
 459     ulLong = ~((ULONGLONG)0) << i;
 460
 461     cPos = pRtlFindLeastSignificantBit(ulLong);
 462     ok (cPos == i, "didn't find LSB 0x%x%08x %d %d\n",
 463         (DWORD)(ulLong >> 32), (DWORD)ulLong, i, cPos);
 464   }
 465   cPos = pRtlFindLeastSignificantBit(0);
 466   ok (cPos == -1, "found bit when not set\n");
 467 }
 468
 469 /* Note: Also tests RtlFindLongestRunSet() */
 470 static void test_RtlFindSetRuns(void)
 471 {
 472   RTL_BITMAP_RUN runs[16];
 473   ULONG ulCount;
 474
 475   if (!pRtlFindSetRuns)
 476     return;
 477
 478   pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);
 479
 480   memset(buff, 0, sizeof(buff));
 481   ulCount = pRtlFindSetRuns(&bm, runs, 16, TRUE);
 482   ok (ulCount == 0, "found set bits in empty bitmap\n");
 483
 484   memset(runs, 0, sizeof(runs));
 485   memset(buff, 0xff, sizeof(buff));
 486   ulCount = pRtlFindSetRuns(&bm, runs, 16, TRUE);
 487   ok (ulCount == 1, "didn't find set bits\n");
 488   ok (runs[0].StartingIndex == 0,"bad start\n");
 489   ok (runs[0].NumberOfBits == sizeof(buff)*8,"bad size\n");
 490
 491   /* Set up 3 runs */
 492   memset(runs, 0, sizeof(runs));
 493   memset(buff, 0, sizeof(buff));
 494   pRtlSetBits(&bm, 7, 19);
 495   pRtlSetBits(&bm, 101, 3);
 496   pRtlSetBits(&bm, 1877, 33);
 497
 498   /* Get first 2 */
 499   ulCount = pRtlFindSetRuns(&bm, runs, 2, FALSE);
 500   ok(ulCount == 2, "RtlFindClearRuns returned %d, expected 2\n", ulCount);
 501   ok (runs[0].StartingIndex == 7 || runs[0].StartingIndex == 101,"bad find\n");
 502   ok (runs[1].StartingIndex == 7 || runs[1].StartingIndex == 101,"bad find\n");
 503   ok (runs[0].NumberOfBits + runs[1].NumberOfBits == 19 + 3,"bad size\n");
 504   ok (runs[0].StartingIndex != runs[1].StartingIndex,"found run twice\n");
 505   ok (runs[2].StartingIndex == 0,"found extra run\n");
 506
 507   /* Get longest 3 */
 508   memset(runs, 0, sizeof(runs));
 509   ulCount = pRtlFindSetRuns(&bm, runs, 2, TRUE);
 510   ok(ulCount == 2, "RtlFindClearRuns returned %d, expected 2\n", ulCount);
 511   ok (runs[0].StartingIndex == 7 || runs[0].StartingIndex == 1877,"bad find\n");
 512   ok (runs[1].StartingIndex == 7 || runs[1].StartingIndex == 1877,"bad find\n");
 513   ok (runs[0].NumberOfBits + runs[1].NumberOfBits == 33 + 19,"bad size\n");
 514   ok (runs[0].StartingIndex != runs[1].StartingIndex,"found run twice\n");
 515   ok (runs[2].StartingIndex == 0,"found extra run\n");
 516
 517   /* Get all 3 */
 518   memset(runs, 0, sizeof(runs));
 519   ulCount = pRtlFindSetRuns(&bm, runs, 3, TRUE);
 520   ok(ulCount == 3, "RtlFindClearRuns returned %d, expected 3\n", ulCount);
 521   ok (runs[0].StartingIndex == 7 || runs[0].StartingIndex == 101 ||
 522       runs[0].StartingIndex == 1877,"bad find\n");
 523   ok (runs[1].StartingIndex == 7 || runs[1].StartingIndex == 101 ||
 524       runs[1].StartingIndex == 1877,"bad find\n");
 525   ok (runs[2].StartingIndex == 7 || runs[2].StartingIndex == 101 ||
 526       runs[2].StartingIndex == 1877,"bad find\n");
 527   ok (runs[0].NumberOfBits + runs[1].NumberOfBits
 528       + runs[2].NumberOfBits == 19 + 3 + 33,"bad size\n");
 529   ok (runs[0].StartingIndex != runs[1].StartingIndex,"found run twice\n");
 530   ok (runs[1].StartingIndex != runs[2].StartingIndex,"found run twice\n");
 531   ok (runs[3].StartingIndex == 0,"found extra run\n");
 532
 533   if (pRtlFindLongestRunSet)
 534   {
 535     ULONG ulStart = 0;
 536
 537     ulCount = pRtlFindLongestRunSet(&bm, &ulStart);
 538     ok(ulCount == 33 && ulStart == 1877,"didn't find longest %d %d\n",ulCount,ulStart);
 539
 540     memset(buff, 0, sizeof(buff));
 541     ulCount = pRtlFindLongestRunSet(&bm, &ulStart);
 542     ok(ulCount == 0,"found longest when none set\n");
 543   }
 544 }
 545
 546 /* Note: Also tests RtlFindLongestRunClear() */
 547 static void test_RtlFindClearRuns(void)
 548 {
 549   RTL_BITMAP_RUN runs[16];
 550   ULONG ulCount;
 551
 552   if (!pRtlFindClearRuns)
 553     return;
 554
 555   pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);
 556
 557   memset(buff, 0xff, sizeof(buff));
 558   ulCount = pRtlFindClearRuns(&bm, runs, 16, TRUE);
 559   ok (ulCount == 0, "found clear bits in full bitmap\n");
 560
 561   memset(runs, 0, sizeof(runs));
 562   memset(buff, 0, sizeof(buff));
 563   ulCount = pRtlFindClearRuns(&bm, runs, 16, TRUE);
 564   ok (ulCount == 1, "didn't find clear bits\n");
 565   ok (runs[0].StartingIndex == 0,"bad start\n");
 566   ok (runs[0].NumberOfBits == sizeof(buff)*8,"bad size\n");
 567
 568   /* Set up 3 runs */
 569   memset(runs, 0, sizeof(runs));
 570   memset(buff, 0xff, sizeof(buff));
 571   pRtlClearBits(&bm, 7, 19);
 572   pRtlClearBits(&bm, 101, 3);
 573   pRtlClearBits(&bm, 1877, 33);
 574
 575   /* Get first 2 */
 576   ulCount = pRtlFindClearRuns(&bm, runs, 2, FALSE);
 577   ok(ulCount == 2, "RtlFindClearRuns returned %d, expected 2\n", ulCount);
 578   ok (runs[0].StartingIndex == 7 || runs[0].StartingIndex == 101,"bad find\n");
 579   ok (runs[1].StartingIndex == 7 || runs[1].StartingIndex == 101,"bad find\n");
 580   ok (runs[0].NumberOfBits + runs[1].NumberOfBits == 19 + 3,"bad size\n");
 581   ok (runs[0].StartingIndex != runs[1].StartingIndex,"found run twice\n");
 582   ok (runs[2].StartingIndex == 0,"found extra run\n");
 583
 584   /* Get longest 3 */
 585   memset(runs, 0, sizeof(runs));
 586   ulCount = pRtlFindClearRuns(&bm, runs, 2, TRUE);
 587   ok(ulCount == 2, "RtlFindClearRuns returned %d, expected 2\n", ulCount);
 588   ok (runs[0].StartingIndex == 7 || runs[0].StartingIndex == 1877,"bad find\n");
 589   ok (runs[1].StartingIndex == 7 || runs[1].StartingIndex == 1877,"bad find\n");
 590   ok (runs[0].NumberOfBits + runs[1].NumberOfBits == 33 + 19,"bad size\n");
 591   ok (runs[0].StartingIndex != runs[1].StartingIndex,"found run twice\n");
 592   ok (runs[2].StartingIndex == 0,"found extra run\n");
 593
 594   /* Get all 3 */
 595   memset(runs, 0, sizeof(runs));
 596   ulCount = pRtlFindClearRuns(&bm, runs, 3, TRUE);
 597   ok(ulCount == 3, "RtlFindClearRuns returned %d, expected 3\n", ulCount);
 598   ok (runs[0].StartingIndex == 7 || runs[0].StartingIndex == 101 ||
 599       runs[0].StartingIndex == 1877,"bad find\n");
 600   ok (runs[1].StartingIndex == 7 || runs[1].StartingIndex == 101 ||
 601       runs[1].StartingIndex == 1877,"bad find\n");
 602   ok (runs[2].StartingIndex == 7 || runs[2].StartingIndex == 101 ||
 603       runs[2].StartingIndex == 1877,"bad find\n");
 604   ok (runs[0].NumberOfBits + runs[1].NumberOfBits
 605       + runs[2].NumberOfBits == 19 + 3 + 33,"bad size\n");
 606   ok (runs[0].StartingIndex != runs[1].StartingIndex,"found run twice\n");
 607   ok (runs[1].StartingIndex != runs[2].StartingIndex,"found run twice\n");
 608   ok (runs[3].StartingIndex == 0,"found extra run\n");
 609
 610   if (pRtlFindLongestRunClear)
 611   {
 612     ULONG ulStart = 0;
 613
 614     ulCount = pRtlFindLongestRunClear(&bm, &ulStart);
 615     ok(ulCount == 33 && ulStart == 1877,"didn't find longest\n");
 616
 617     memset(buff, 0xff, sizeof(buff));
 618     ulCount = pRtlFindLongestRunClear(&bm, &ulStart);
 619     ok(ulCount == 0,"found longest when none clear\n");
 620   }
 621
 622 }
 623 #endif
 624
 625 START_TEST(rtlbitmap)
 626 {
 627 #ifdef __WINE_WINTERNL_H
 628   InitFunctionPtrs();
 629
 630   if (pRtlInitializeBitMap)
 631   {
 632     test_RtlInitializeBitMap();
 633     test_RtlSetAllBits();
 634     test_RtlClearAllBits();
 635     test_RtlSetBits();
 636     test_RtlClearBits();
 637     test_RtlCheckBit();
 638     test_RtlAreBitsSet();
 639     test_RtlAreBitsClear();
 640     test_RtlNumberOfSetBits();
 641     test_RtlNumberOfClearBits();
 642     test_RtlFindSetBitsAndClear();
 643     test_RtlFindClearBitsAndSet();
 644     test_RtlFindMostSignificantBit();
 645     test_RtlFindLeastSignificantBit();
 646     test_RtlFindSetRuns();
 647     test_RtlFindClearRuns();
 648   }
 649 #endif
 650 }