ReactOS  0.4.15-dev-1397-g19779b3
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 */
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%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 
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%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() */
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
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 }
PULONG Buffer
Definition: typedefs.h:91
static void InitFunctionPtrs(void)
Definition: registry.c:132
#define TRUE
Definition: types.h:120
#define RtlCheckBit(BMH, BP)
Definition: rtlfuncs.h:3154
struct _RTL_BITMAP_RUN * PRTL_BITMAP_RUN
unsigned char * LPBYTE
Definition: typedefs.h:53
#define FALSE
Definition: types.h:117
HINSTANCE WINAPI DECLSPEC_HOTPATCH LoadLibraryA(LPCSTR lpLibFileName)
Definition: loader.c:111
unsigned char BOOLEAN
START_TEST(rtlbitmap)
Definition: rtlbitmap.c:625
char CCHAR
Definition: typedefs.h:51
uint64_t ULONGLONG
Definition: typedefs.h:67
#define WINAPI
Definition: msvc.h:6
#define VOID
Definition: acefi.h:82
ULONG SizeOfBitMap
Definition: typedefs.h:90
_In_ ULONG StartingIndex
Definition: rtlfuncs.h:395
unsigned char BYTE
Definition: xxhash.c:193
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
#define ok(value,...)
Definition: atltest.h:57
unsigned int * PULONG
Definition: retypes.h:1
struct _RTL_BITMAP * PRTL_BITMAP
static HINSTANCE hntdll
Definition: process.c:66
#define BOOLEAN
Definition: pedump.c:73
unsigned int ULONG
Definition: retypes.h:1
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
Definition: compat.h:49
#define GetProcAddress(x, y)
Definition: compat.h:612
#define memset(x, y, z)
Definition: compat.h:39
static unsigned char buff[32768]
Definition: fatten.c:17