ntdll/tests: Print 64bit integers as two 32 bit integers.
[wine] / 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   CCHAR 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%lx%08lx %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%lx%08lx %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   CCHAR 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%lx%08lx %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%lx%08lx %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 (runs[0].StartingIndex == 7 || runs[0].StartingIndex == 101,"bad find\n");
501   ok (runs[1].StartingIndex == 7 || runs[1].StartingIndex == 101,"bad find\n");
502   ok (runs[0].NumberOfBits + runs[1].NumberOfBits == 19 + 3,"bad size\n");
503   ok (runs[0].StartingIndex != runs[1].StartingIndex,"found run twice\n");
504   ok (runs[2].StartingIndex == 0,"found extra run\n");
505
506   /* Get longest 3 */
507   memset(runs, 0, sizeof(runs));
508   ulCount = pRtlFindSetRuns(&bm, runs, 2, TRUE);
509   ok (runs[0].StartingIndex == 7 || runs[0].StartingIndex == 1877,"bad find\n");
510   ok (runs[1].StartingIndex == 7 || runs[1].StartingIndex == 1877,"bad find\n");
511   ok (runs[0].NumberOfBits + runs[1].NumberOfBits == 33 + 19,"bad size\n");
512   ok (runs[0].StartingIndex != runs[1].StartingIndex,"found run twice\n");
513   ok (runs[2].StartingIndex == 0,"found extra run\n");
514
515   /* Get all 3 */
516   memset(runs, 0, sizeof(runs));
517   ulCount = pRtlFindSetRuns(&bm, runs, 3, TRUE);
518   ok (runs[0].StartingIndex == 7 || runs[0].StartingIndex == 101 ||
519       runs[0].StartingIndex == 1877,"bad find\n");
520   ok (runs[1].StartingIndex == 7 || runs[1].StartingIndex == 101 ||
521       runs[1].StartingIndex == 1877,"bad find\n");
522   ok (runs[2].StartingIndex == 7 || runs[2].StartingIndex == 101 ||
523       runs[2].StartingIndex == 1877,"bad find\n");
524   ok (runs[0].NumberOfBits + runs[1].NumberOfBits
525       + runs[2].NumberOfBits == 19 + 3 + 33,"bad size\n");
526   ok (runs[0].StartingIndex != runs[1].StartingIndex,"found run twice\n");
527   ok (runs[1].StartingIndex != runs[2].StartingIndex,"found run twice\n");
528   ok (runs[3].StartingIndex == 0,"found extra run\n");
529
530   if (pRtlFindLongestRunSet)
531   {
532     ULONG ulStart = 0;
533
534     ulCount = pRtlFindLongestRunSet(&bm, &ulStart);
535     ok(ulCount == 33 && ulStart == 1877,"didn't find longest %ld %ld\n",ulCount,ulStart);
536
537     memset(buff, 0, sizeof(buff));
538     ulCount = pRtlFindLongestRunSet(&bm, &ulStart);
539     ok(ulCount == 0,"found longest when none set\n");
540   }
541 }
542
543 /* Note: Also tests RtlFindLongestRunClear() */
544 static void test_RtlFindClearRuns(void)
545 {
546   RTL_BITMAP_RUN runs[16];
547   ULONG ulCount;
548
549   if (!pRtlFindClearRuns)
550     return;
551
552   pRtlInitializeBitMap(&bm, buff, sizeof(buff)*8);
553
554   memset(buff, 0xff, sizeof(buff));
555   ulCount = pRtlFindClearRuns(&bm, runs, 16, TRUE);
556   ok (ulCount == 0, "found clear bits in full bitmap\n");
557
558   memset(runs, 0, sizeof(runs));
559   memset(buff, 0, sizeof(buff));
560   ulCount = pRtlFindClearRuns(&bm, runs, 16, TRUE);
561   ok (ulCount == 1, "didn't find clear bits\n");
562   ok (runs[0].StartingIndex == 0,"bad start\n");
563   ok (runs[0].NumberOfBits == sizeof(buff)*8,"bad size\n");
564
565   /* Set up 3 runs */
566   memset(runs, 0, sizeof(runs));
567   memset(buff, 0xff, sizeof(buff));
568   pRtlClearBits(&bm, 7, 19);
569   pRtlClearBits(&bm, 101, 3);
570   pRtlClearBits(&bm, 1877, 33);
571
572   /* Get first 2 */
573   ulCount = pRtlFindClearRuns(&bm, runs, 2, FALSE);
574   ok (runs[0].StartingIndex == 7 || runs[0].StartingIndex == 101,"bad find\n");
575   ok (runs[1].StartingIndex == 7 || runs[1].StartingIndex == 101,"bad find\n");
576   ok (runs[0].NumberOfBits + runs[1].NumberOfBits == 19 + 3,"bad size\n");
577   ok (runs[0].StartingIndex != runs[1].StartingIndex,"found run twice\n");
578   ok (runs[2].StartingIndex == 0,"found extra run\n");
579
580   /* Get longest 3 */
581   memset(runs, 0, sizeof(runs));
582   ulCount = pRtlFindClearRuns(&bm, runs, 2, TRUE);
583   ok (runs[0].StartingIndex == 7 || runs[0].StartingIndex == 1877,"bad find\n");
584   ok (runs[1].StartingIndex == 7 || runs[1].StartingIndex == 1877,"bad find\n");
585   ok (runs[0].NumberOfBits + runs[1].NumberOfBits == 33 + 19,"bad size\n");
586   ok (runs[0].StartingIndex != runs[1].StartingIndex,"found run twice\n");
587   ok (runs[2].StartingIndex == 0,"found extra run\n");
588
589   /* Get all 3 */
590   memset(runs, 0, sizeof(runs));
591   ulCount = pRtlFindClearRuns(&bm, runs, 3, TRUE);
592   ok (runs[0].StartingIndex == 7 || runs[0].StartingIndex == 101 ||
593       runs[0].StartingIndex == 1877,"bad find\n");
594   ok (runs[1].StartingIndex == 7 || runs[1].StartingIndex == 101 ||
595       runs[1].StartingIndex == 1877,"bad find\n");
596   ok (runs[2].StartingIndex == 7 || runs[2].StartingIndex == 101 ||
597       runs[2].StartingIndex == 1877,"bad find\n");
598   ok (runs[0].NumberOfBits + runs[1].NumberOfBits
599       + runs[2].NumberOfBits == 19 + 3 + 33,"bad size\n");
600   ok (runs[0].StartingIndex != runs[1].StartingIndex,"found run twice\n");
601   ok (runs[1].StartingIndex != runs[2].StartingIndex,"found run twice\n");
602   ok (runs[3].StartingIndex == 0,"found extra run\n");
603
604   if (pRtlFindLongestRunClear)
605   {
606     ULONG ulStart = 0;
607
608     ulCount = pRtlFindLongestRunClear(&bm, &ulStart);
609     ok(ulCount == 33 && ulStart == 1877,"didn't find longest\n");
610
611     memset(buff, 0xff, sizeof(buff));
612     ulCount = pRtlFindLongestRunClear(&bm, &ulStart);
613     ok(ulCount == 0,"found longest when none clear\n");
614   }
615
616 }
617 #endif
618
619 START_TEST(rtlbitmap)
620 {
621 #ifdef __WINE_WINTERNL_H
622   InitFunctionPtrs();
623
624   if (pRtlInitializeBitMap)
625   {
626     test_RtlInitializeBitMap();
627     test_RtlSetAllBits();
628     test_RtlClearAllBits();
629     test_RtlSetBits();
630     test_RtlClearBits();
631     test_RtlCheckBit();
632     test_RtlAreBitsSet();
633     test_RtlAreBitsClear();
634     test_RtlNumberOfSetBits();
635     test_RtlNumberOfClearBits();
636     test_RtlFindSetBitsAndClear();
637     test_RtlFindClearBitsAndSet();
638     test_RtlFindMostSignificantBit();
639     test_RtlFindLeastSignificantBit();
640     test_RtlFindSetRuns();
641     test_RtlFindClearRuns();
642   }
643 #endif
644 }