ReactOS 0.4.15-dev-7842-g558ab78
rtlbitmap.c
Go to the documentation of this file.
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 */
29static HMODULE hntdll = 0;
30static VOID (WINAPI *pRtlInitializeBitMap)(PRTL_BITMAP,LPBYTE,ULONG);
31static VOID (WINAPI *pRtlSetAllBits)(PRTL_BITMAP);
32static VOID (WINAPI *pRtlClearAllBits)(PRTL_BITMAP);
33static VOID (WINAPI *pRtlSetBits)(PRTL_BITMAP,ULONG,ULONG);
34static VOID (WINAPI *pRtlClearBits)(PRTL_BITMAP,ULONG,ULONG);
35static BOOLEAN (WINAPI *pRtlAreBitsSet)(PRTL_BITMAP,ULONG,ULONG);
36static BOOLEAN (WINAPI *pRtlAreBitsClear)(PRTL_BITMAP,ULONG,ULONG);
37static ULONG (WINAPI *pRtlFindSetBitsAndClear)(PRTL_BITMAP,ULONG,ULONG);
38static ULONG (WINAPI *pRtlFindClearBitsAndSet)(PRTL_BITMAP,ULONG,ULONG);
39static CCHAR (WINAPI *pRtlFindMostSignificantBit)(ULONGLONG);
40static CCHAR (WINAPI *pRtlFindLeastSignificantBit)(ULONGLONG);
41static ULONG (WINAPI *pRtlFindSetRuns)(PRTL_BITMAP,PRTL_BITMAP_RUN,ULONG,BOOLEAN);
42static ULONG (WINAPI *pRtlFindClearRuns)(PRTL_BITMAP,PRTL_BITMAP_RUN,ULONG,BOOLEAN);
43static ULONG (WINAPI *pRtlNumberOfSetBits)(PRTL_BITMAP);
44static ULONG (WINAPI *pRtlNumberOfClearBits)(PRTL_BITMAP);
45static ULONG (WINAPI *pRtlFindLongestRunSet)(PRTL_BITMAP,PULONG);
46static ULONG (WINAPI *pRtlFindLongestRunClear)(PRTL_BITMAP,PULONG);
47
48static BYTE buff[256];
49static RTL_BITMAP bm;
50
51static 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
77static 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
92static 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
106static 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
119static 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
147static 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
175static 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
199static 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
244static 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
289static 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
319static 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 */
350static 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 */
382static 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
413static 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%s %d %d\n",
429 wine_dbgstr_longlong(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%s %d %d\n",
436 wine_dbgstr_longlong(ulLong ), i, cPos);
437 }
438 cPos = pRtlFindMostSignificantBit(0);
439 ok (cPos == -1, "found bit when not set\n");
440}
441
442static 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%s %d %d\n",
457 wine_dbgstr_longlong(ulLong ), i, cPos);
458
459 ulLong = ~((ULONGLONG)0) << i;
460
461 cPos = pRtlFindLeastSignificantBit(ulLong);
462 ok (cPos == i, "didn't find LSB 0x%s %d %d\n",
463 wine_dbgstr_longlong(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() */
470static 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() */
547static 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
625START_TEST(rtlbitmap)
626{
627#ifdef __WINE_WINTERNL_H
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}
unsigned char BOOLEAN
#define VOID
Definition: acefi.h:82
#define ok(value,...)
Definition: atltest.h:57
#define START_TEST(x)
Definition: atltest.h:75
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define GetProcAddress(x, y)
Definition: compat.h:753
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
Definition: compat.h:49
HINSTANCE WINAPI DECLSPEC_HOTPATCH LoadLibraryA(LPCSTR lpLibFileName)
Definition: loader.c:111
static unsigned char buff[32768]
Definition: fatten.c:17
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
static void InitFunctionPtrs(void)
Definition: registry.c:132
static HINSTANCE hntdll
Definition: process.c:66
#define BOOLEAN
Definition: pedump.c:73
#define memset(x, y, z)
Definition: compat.h:39
ULONG SizeOfBitMap
Definition: typedefs.h:90
PULONG Buffer
Definition: typedefs.h:91
struct _RTL_BITMAP * PRTL_BITMAP
uint32_t * PULONG
Definition: typedefs.h:59
unsigned char * LPBYTE
Definition: typedefs.h:53
struct _RTL_BITMAP_RUN * PRTL_BITMAP_RUN
uint32_t ULONG
Definition: typedefs.h:59
uint64_t ULONGLONG
Definition: typedefs.h:67
char CCHAR
Definition: typedefs.h:51
#define WINAPI
Definition: msvc.h:6
_In_ ULONG StartingIndex
Definition: rtlfuncs.h:395
#define RtlCheckBit(BMH, BP)
Definition: rtlfuncs.h:3152
unsigned char BYTE
Definition: xxhash.c:193