partial ntdll_winetest sync to wine 1.1.35
[reactos.git] / rostests / winetests / ntdll / 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 (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 %d %d\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 }