ReactOS 0.4.16-dev-91-g764881a
RtlBitmap.c
Go to the documentation of this file.
1
2#include "precomp.h"
3#include <versionhelpers.h>
4
5#include <pseh/pseh2.h>
6
7static BOOL IsBroken = FALSE;
8
9void
10Test_RtlFindMostSignificantBit(void)
11{
12 ok_int(RtlFindMostSignificantBit(0), -1);
13
14 ok_int(RtlFindMostSignificantBit(0x0000000000000001ULL), 0);
15 ok_int(RtlFindMostSignificantBit(0x0000000000000002ULL), 1);
16 ok_int(RtlFindMostSignificantBit(0x1000000000000000ULL), 60);
17 ok_int(RtlFindMostSignificantBit(0x8000000000000000ULL), 63);
18 ok_int(RtlFindMostSignificantBit(0x8000000000000001ULL), 63);
19 ok_int(RtlFindMostSignificantBit(0xFFFFFFFFFFFFFFFFULL), 63);
20 ok_int(RtlFindMostSignificantBit(0x0000000070000000ULL), 30);
21}
22
23void
24Test_RtlFindLeastSignificantBit(void)
25{
26 ok_int(RtlFindLeastSignificantBit(0), -1);
27
28 ok_int(RtlFindLeastSignificantBit(0x0000000000000001ULL), 0);
29 ok_int(RtlFindLeastSignificantBit(0x0000000000000002ULL), 1);
30 ok_int(RtlFindLeastSignificantBit(0x1000000000000000ULL), 60);
31 ok_int(RtlFindLeastSignificantBit(0x8000000000000000ULL), 63);
32 ok_int(RtlFindLeastSignificantBit(0x8000000000000000ULL), 63);
33 ok_int(RtlFindLeastSignificantBit(0xFFFFFFFFFFFFFFFFULL), 0);
34 ok_int(RtlFindLeastSignificantBit(0x0000000070000000ULL), 28);
35}
36
37void
38Test_RtlInitializeBitMap(void)
39{
40 RTL_BITMAP BitMapHeader;
41 ULONG Buffer[2];
42 BOOLEAN Exception = FALSE;
43
44 _SEH2_TRY
45 {
46 RtlInitializeBitMap(NULL, NULL, 0);
47 }
48 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
49 {
50 Exception = TRUE;
51 }
52 _SEH2_END;
53 ok_int(Exception, 1);
54
55 RtlInitializeBitMap(&BitMapHeader, NULL, -1);
56 ok_int(BitMapHeader.SizeOfBitMap, -1);
57 ok_ptr(BitMapHeader.Buffer, NULL);
58
59 memset(Buffer, 0xcc, sizeof(Buffer));
60 RtlInitializeBitMap(&BitMapHeader, Buffer, 0);
61 ok_int(BitMapHeader.SizeOfBitMap, 0);
62 ok_ptr(BitMapHeader.Buffer, Buffer);
63 ok_hex(Buffer[0], 0xcccccccc);
64
65 RtlInitializeBitMap(&BitMapHeader, Buffer, 8);
66 ok_int(BitMapHeader.SizeOfBitMap, 8);
67 ok_hex(Buffer[0], 0xcccccccc);
68}
69
70void
71Test_RtlClearAllBits(void)
72{
73 RTL_BITMAP BitMapHeader;
74 ULONG *Buffer;
75 ULONG BufferSize = 2 * sizeof(*Buffer);
76
77 Buffer = AllocateGuarded(BufferSize);
78 RtlInitializeBitMap(&BitMapHeader, Buffer, 19);
79 memset(Buffer, 0xcc, BufferSize);
80 RtlClearAllBits(&BitMapHeader);
81 ok_hex(Buffer[0], 0x00000000);
82 ok_hex(Buffer[1], 0xcccccccc);
83
84 RtlInitializeBitMap(&BitMapHeader, Buffer, 0);
85 memset(Buffer, 0xcc, BufferSize);
86 RtlClearAllBits(&BitMapHeader);
87 ok_hex(Buffer[0], 0xcccccccc);
88 ok_hex(Buffer[1], 0xcccccccc);
89
90 RtlInitializeBitMap(&BitMapHeader, Buffer, 64);
91 memset(Buffer, 0xcc, BufferSize);
92 RtlClearAllBits(&BitMapHeader);
93 ok_hex(Buffer[0], 0x00000000);
94 ok_hex(Buffer[1], 0x00000000);
95 FreeGuarded(Buffer);
96}
97
98void
99Test_RtlSetAllBits(void)
100{
101 RTL_BITMAP BitMapHeader;
102 ULONG *Buffer;
103 ULONG BufferSize = 2 * sizeof(*Buffer);
104
105 Buffer = AllocateGuarded(BufferSize);
106 RtlInitializeBitMap(&BitMapHeader, Buffer, 19);
107 memset(Buffer, 0xcc, BufferSize);
108 RtlSetAllBits(&BitMapHeader);
109 ok_hex(Buffer[0], 0xffffffff);
110 ok_hex(Buffer[1], 0xcccccccc);
111
112 RtlInitializeBitMap(&BitMapHeader, Buffer, 0);
113 memset(Buffer, 0xcc, BufferSize);
114 RtlSetAllBits(&BitMapHeader);
115 ok_hex(Buffer[0], 0xcccccccc);
116 ok_hex(Buffer[1], 0xcccccccc);
117
118 RtlInitializeBitMap(&BitMapHeader, Buffer, 64);
119 memset(Buffer, 0xcc, BufferSize);
120 RtlSetAllBits(&BitMapHeader);
121 ok_hex(Buffer[0], 0xffffffff);
122 ok_hex(Buffer[1], 0xffffffff);
123 FreeGuarded(Buffer);
124}
125
126void
127Test_RtlClearBits(void)
128{
129 RTL_BITMAP BitMapHeader;
130 ULONG *Buffer;
131 ULONG BufferSize = 2 * sizeof(*Buffer);
132
133 Buffer = AllocateGuarded(BufferSize);
134 RtlInitializeBitMap(&BitMapHeader, Buffer, 19);
135
136 memset(Buffer, 0xff, BufferSize);
137 RtlClearBits(&BitMapHeader, 0, 0);
138 ok_hex(Buffer[0], 0xffffffff);
139 ok_hex(Buffer[1], 0xffffffff);
140
141 memset(Buffer, 0xff, BufferSize);
142 RtlClearBits(&BitMapHeader, 0, 1);
143 ok_hex(Buffer[0], 0xfffffffe);
144 ok_hex(Buffer[1], 0xffffffff);
145
146 memset(Buffer, 0xff, BufferSize);
147 RtlClearBits(&BitMapHeader, 21, 1);
148 ok_hex(Buffer[0], 0xffdfffff);
149 ok_hex(Buffer[1], 0xffffffff);
150
151 memset(Buffer, 0xff, BufferSize);
152 RtlClearBits(&BitMapHeader, 7, 9);
153 ok_hex(Buffer[0], 0xffff007f);
154 ok_hex(Buffer[1], 0xffffffff);
155
156 memset(Buffer, 0xff, BufferSize);
157 RtlClearBits(&BitMapHeader, 13, 22);
158 ok_hex(Buffer[0], 0x00001fff);
159 ok_hex(Buffer[1], 0xfffffff8);
160
161 memset(Buffer, 0xff, BufferSize);
162 RtlClearBits(&BitMapHeader, 63, 1);
163 ok_hex(Buffer[0], 0xffffffff);
164 ok_hex(Buffer[1], 0x7fffffff);
165
166 memset(Buffer, 0xcc, BufferSize);
167 RtlClearBits(&BitMapHeader, 3, 6);
168 RtlClearBits(&BitMapHeader, 11, 5);
169 RtlClearBits(&BitMapHeader, 21, 7);
170 RtlClearBits(&BitMapHeader, 37, 4);
171 ok_hex(Buffer[0], 0xc00c0404);
172 ok_hex(Buffer[1], 0xcccccc0c);
173 FreeGuarded(Buffer);
174}
175
176void
177Test_RtlSetBits(void)
178{
179 RTL_BITMAP BitMapHeader;
180 ULONG *Buffer;
181 ULONG BufferSize = 2 * sizeof(*Buffer);
182
183 Buffer = AllocateGuarded(BufferSize);
184 RtlInitializeBitMap(&BitMapHeader, Buffer, 19);
185
186 memset(Buffer, 0x00, BufferSize);
187 RtlSetBits(&BitMapHeader, 0, 0);
188 ok_hex(Buffer[0], 0x00000000);
189 ok_hex(Buffer[1], 0x00000000);
190
191 memset(Buffer, 0x00, BufferSize);
192 RtlSetBits(&BitMapHeader, 0, 1);
193 ok_hex(Buffer[0], 0x00000001);
194 ok_hex(Buffer[1], 0x00000000);
195
196 memset(Buffer, 0x00, BufferSize);
197 RtlSetBits(&BitMapHeader, 21, 1);
198 ok_hex(Buffer[0], 0x00200000);
199 ok_hex(Buffer[1], 0x00000000);
200
201 memset(Buffer, 0x00, BufferSize);
202 RtlSetBits(&BitMapHeader, 7, 9);
203 ok_hex(Buffer[0], 0x0000ff80);
204 ok_hex(Buffer[1], 0x00000000);
205
206 memset(Buffer, 0x00, BufferSize);
207 RtlSetBits(&BitMapHeader, 13, 22);
208 ok_hex(Buffer[0], 0xffffe000);
209 ok_hex(Buffer[1], 0x00000007);
210
211 memset(Buffer, 0x00, BufferSize);
212 RtlSetBits(&BitMapHeader, 63, 1);
213 ok_hex(Buffer[0], 0x00000000);
214 ok_hex(Buffer[1], 0x80000000);
215
216 memset(Buffer, 0xcc, BufferSize);
217 RtlSetBits(&BitMapHeader, 3, 6);
218 RtlSetBits(&BitMapHeader, 11, 5);
219 RtlSetBits(&BitMapHeader, 21, 7);
220 RtlSetBits(&BitMapHeader, 37, 4);
221 ok_hex(Buffer[0], 0xcfecfdfc);
222 ok_hex(Buffer[1], 0xcccccdec);
223 FreeGuarded(Buffer);
224}
225
226void
227Test_RtlAreBitsClear(void)
228{
229 RTL_BITMAP BitMapHeader;
230 ULONG *Buffer;
231
232 Buffer = AllocateGuarded(2 * sizeof(*Buffer));
233 RtlInitializeBitMap(&BitMapHeader, Buffer, 19);
234 Buffer[0] = 0x00ff00ff;
235 Buffer[1] = 0xc0cfc0cf;
236
237 ok_hex(RtlAreBitsClear(&BitMapHeader, 0, 8), FALSE);
238 ok_hex(RtlAreBitsClear(&BitMapHeader, 8, 8), TRUE);
239 ok_hex(RtlAreBitsClear(&BitMapHeader, 7, 8), FALSE);
240 ok_hex(RtlAreBitsClear(&BitMapHeader, 8, 9), FALSE);
241 ok_hex(RtlAreBitsClear(&BitMapHeader, 24, 1), FALSE);
242
243 RtlInitializeBitMap(&BitMapHeader, Buffer, 31);
244 ok_hex(RtlAreBitsClear(&BitMapHeader, 24, 1), TRUE);
245 ok_hex(RtlAreBitsClear(&BitMapHeader, 24, 7), TRUE);
246 ok_hex(RtlAreBitsClear(&BitMapHeader, 24, 8), FALSE);
247
248 RtlInitializeBitMap(&BitMapHeader, Buffer, 64);
249 ok_hex(RtlAreBitsClear(&BitMapHeader, 60, 4), FALSE);
250 FreeGuarded(Buffer);
251}
252
253void
254Test_RtlAreBitsSet(void)
255{
256 RTL_BITMAP BitMapHeader;
257 ULONG *Buffer;
258
259 Buffer = AllocateGuarded(2 * sizeof(*Buffer));
260 RtlInitializeBitMap(&BitMapHeader, Buffer, 19);
261 Buffer[0] = 0xff00ff00;
262 Buffer[1] = 0x3F303F30;
263
264 ok_hex(RtlAreBitsSet(&BitMapHeader, 0, 8), FALSE);
265 ok_hex(RtlAreBitsSet(&BitMapHeader, 8, 8), TRUE);
266 ok_hex(RtlAreBitsSet(&BitMapHeader, 7, 8), FALSE);
267 ok_hex(RtlAreBitsSet(&BitMapHeader, 8, 9), FALSE);
268 ok_hex(RtlAreBitsSet(&BitMapHeader, 24, 1), FALSE);
269
270 RtlInitializeBitMap(&BitMapHeader, Buffer, 31);
271 ok_hex(RtlAreBitsSet(&BitMapHeader, 24, 1), TRUE);
272 ok_hex(RtlAreBitsSet(&BitMapHeader, 24, 7), TRUE);
273 ok_hex(RtlAreBitsSet(&BitMapHeader, 24, 8), FALSE);
274
275 RtlInitializeBitMap(&BitMapHeader, Buffer, 64);
276 ok_hex(RtlAreBitsSet(&BitMapHeader, 60, 4), FALSE);
277 FreeGuarded(Buffer);
278}
279
280void
281Test_RtlNumberOfSetBits(void)
282{
283 RTL_BITMAP BitMapHeader;
284 ULONG *Buffer;
285
286 Buffer = AllocateGuarded(2 * sizeof(*Buffer));
287 Buffer[0] = 0xff00ff0f;
288 Buffer[1] = 0x3F303F30;
289
290 RtlInitializeBitMap(&BitMapHeader, Buffer, 64);
291 ok_int(RtlNumberOfSetBits(&BitMapHeader), 36);
292 ok_hex(Buffer[0], 0xff00ff0f);
293 ok_hex(Buffer[1], 0x3F303F30);
294
295 RtlInitializeBitMap(&BitMapHeader, Buffer, 56);
296 ok_int(RtlNumberOfSetBits(&BitMapHeader), 30);
297 ok_hex(Buffer[0], 0xff00ff0f);
298 ok_hex(Buffer[1], 0x3F303F30);
299
300 RtlInitializeBitMap(&BitMapHeader, Buffer, 31);
301 ok_int(RtlNumberOfSetBits(&BitMapHeader), 19);
302 ok_hex(Buffer[0], IsBroken ? 0x7f00ff0f : 0xff00ff0f);
303 ok_hex(Buffer[1], 0x3F303F30);
304
305 RtlInitializeBitMap(&BitMapHeader, Buffer, 4);
306 ok_int(RtlNumberOfSetBits(&BitMapHeader), 4);
307 ok_hex(Buffer[0], IsBroken ? 0x7f00ff0f : 0xff00ff0f);
308 ok_hex(Buffer[1], 0x3F303F30);
309
310 RtlInitializeBitMap(&BitMapHeader, Buffer, 0);
311 ok_int(RtlNumberOfSetBits(&BitMapHeader), 0);
312 ok_hex(Buffer[0], IsBroken ? 0x7f00ff0f : 0xff00ff0f);
313 ok_hex(Buffer[1], 0x3F303F30);
314
315 FreeGuarded(Buffer);
316}
317
318void
319Test_RtlNumberOfClearBits(void)
320{
321 RTL_BITMAP BitMapHeader;
322 ULONG *Buffer;
323
324 Buffer = AllocateGuarded(2 * sizeof(*Buffer));
325 Buffer[0] = 0xff00fff0;
326 Buffer[1] = 0x3F303F30;
327
328 RtlInitializeBitMap(&BitMapHeader, Buffer, 64);
329 ok_int(RtlNumberOfClearBits(&BitMapHeader), 28);
330 ok_hex(Buffer[0], 0xff00fff0);
331 ok_hex(Buffer[1], 0x3F303F30);
332
333 RtlInitializeBitMap(&BitMapHeader, Buffer, 56);
334 ok_int(RtlNumberOfClearBits(&BitMapHeader), 26);
335 ok_hex(Buffer[0], 0xff00fff0);
336 ok_hex(Buffer[1], 0x3F303F30);
337
338 RtlInitializeBitMap(&BitMapHeader, Buffer, 31);
339 ok_int(RtlNumberOfClearBits(&BitMapHeader), 12);
340 ok_hex(Buffer[0], IsBroken ? 0x7f00fff0 : 0xff00fff0);
341 ok_hex(Buffer[1], 0x3F303F30);
342
343 RtlInitializeBitMap(&BitMapHeader, Buffer, 4);
344 ok_int(RtlNumberOfClearBits(&BitMapHeader), 4);
345 ok_hex(Buffer[0], IsBroken ? 0x7f00ff00 : 0xff00fff0);
346 ok_hex(Buffer[1], 0x3F303F30);
347
348 RtlInitializeBitMap(&BitMapHeader, Buffer, 0);
349 ok_int(RtlNumberOfClearBits(&BitMapHeader), 0);
350 ok_hex(Buffer[0], IsBroken ? 0x7f00ff00 : 0xff00fff0);
351 ok_hex(Buffer[1], 0x3F303F30);
352
353 FreeGuarded(Buffer);
354}
355
356void
357Test_RtlFindClearBits(void)
358{
359 RTL_BITMAP BitMapHeader;
360 ULONG *Buffer;
361
362 Buffer = AllocateGuarded(2 * sizeof(*Buffer));
363 Buffer[0] = 0x060F874D;
364 Buffer[1] = 0x3F303F30;
365
366 RtlInitializeBitMap(&BitMapHeader, Buffer, 0);
367 ok_int(RtlFindClearBits(&BitMapHeader, 0, 0), 0);
368 ok_int(RtlFindClearBits(&BitMapHeader, 0, 3), 0);
369 ok_int(RtlFindClearBits(&BitMapHeader, 1, 0), -1);
370 ok_int(RtlFindClearBits(&BitMapHeader, 1, 1), -1);
371
372 RtlInitializeBitMap(&BitMapHeader, Buffer, 8);
373 ok_int(RtlFindClearBits(&BitMapHeader, 0, 3), 0);
374 ok_int(RtlFindClearBits(&BitMapHeader, 1, 0), 1);
375 ok_int(RtlFindClearBits(&BitMapHeader, 1, 1), 1);
376 ok_int(RtlFindClearBits(&BitMapHeader, 1, 2), 4);
377
378 ok_int(RtlFindClearBits(&BitMapHeader, 2, 0), 4);
379 ok_int(RtlFindClearBits(&BitMapHeader, 3, 0), -1);
380
381 RtlInitializeBitMap(&BitMapHeader, Buffer, 32);
382 ok_int(RtlFindClearBits(&BitMapHeader, 0, 3), 0);
383 ok_int(RtlFindClearBits(&BitMapHeader, 0, 21), 16);
384 ok_int(RtlFindClearBits(&BitMapHeader, 0, 12), 8);
385 ok_int(RtlFindClearBits(&BitMapHeader, 0, 31), 24);
386 ok_int(RtlFindClearBits(&BitMapHeader, 0, 32), 0);
387 ok_int(RtlFindClearBits(&BitMapHeader, 0, 39), 0);
388 ok_int(RtlFindClearBits(&BitMapHeader, 4, 0), 11);
389 ok_int(RtlFindClearBits(&BitMapHeader, 5, 0), 20);
390 ok_int(RtlFindClearBits(&BitMapHeader, 4, 11), 11);
391 ok_int(RtlFindClearBits(&BitMapHeader, 4, 12), 20);
392 ok_int(RtlFindClearBits(&BitMapHeader, 2, 11), 11);
393 ok_int(RtlFindClearBits(&BitMapHeader, 2, 12), 12);
394 ok_int(RtlFindClearBits(&BitMapHeader, 1, 32), 1);
395 ok_int(RtlFindClearBits(&BitMapHeader, 4, 32), 11);
396 ok_int(RtlFindClearBits(&BitMapHeader, 5, 32), 20);
397
398 RtlInitializeBitMap(&BitMapHeader, Buffer, 64);
399 ok_int(RtlFindClearBits(&BitMapHeader, 5, 64), 20);
400 ok_int(RtlFindClearBits(&BitMapHeader, 9, 28), 27);
401 ok_int(RtlFindClearBits(&BitMapHeader, 10, 0), -1);
402 Buffer[1] = 0xFF303F30;
403 ok_int(RtlFindClearBits(&BitMapHeader, 1, 56), 1);
404 FreeGuarded(Buffer);
405}
406
407void
408Test_RtlFindSetBits(void)
409{
410 RTL_BITMAP BitMapHeader;
411 ULONG *Buffer;
412
413 Buffer = AllocateGuarded(2 * sizeof(*Buffer));
414 Buffer[0] = 0xF9F078B2;
415 Buffer[1] = 0x3F303F30;
416
417 RtlInitializeBitMap(&BitMapHeader, Buffer, 0);
418 ok_int(RtlFindSetBits(&BitMapHeader, 0, 0), 0);
419 ok_int(RtlFindSetBits(&BitMapHeader, 0, 3), 0);
420 ok_int(RtlFindSetBits(&BitMapHeader, 1, 0), -1);
421 ok_int(RtlFindSetBits(&BitMapHeader, 1, 1), -1);
422
423 RtlInitializeBitMap(&BitMapHeader, Buffer, 8);
424 ok_int(RtlFindSetBits(&BitMapHeader, 0, 3), 0);
425 ok_int(RtlFindSetBits(&BitMapHeader, 1, 0), 1);
426 ok_int(RtlFindSetBits(&BitMapHeader, 1, 1), 1);
427 ok_int(RtlFindSetBits(&BitMapHeader, 1, 2), 4);
428
429 ok_int(RtlFindSetBits(&BitMapHeader, 2, 0), 4);
430 ok_int(RtlFindSetBits(&BitMapHeader, 3, 0), -1);
431
432 RtlInitializeBitMap(&BitMapHeader, Buffer, 32);
433 ok_int(RtlFindSetBits(&BitMapHeader, 0, 3), 0);
434 ok_int(RtlFindSetBits(&BitMapHeader, 0, 21), 16);
435 ok_int(RtlFindSetBits(&BitMapHeader, 0, 12), 8);
436 ok_int(RtlFindSetBits(&BitMapHeader, 0, 31), 24);
437 ok_int(RtlFindSetBits(&BitMapHeader, 0, 32), 0);
438 ok_int(RtlFindSetBits(&BitMapHeader, 0, 39), 0);
439 ok_int(RtlFindSetBits(&BitMapHeader, 4, 0), 11);
440 ok_int(RtlFindSetBits(&BitMapHeader, 5, 0), 20);
441 ok_int(RtlFindSetBits(&BitMapHeader, 4, 11), 11);
442 ok_int(RtlFindSetBits(&BitMapHeader, 4, 12), 20);
443 ok_int(RtlFindSetBits(&BitMapHeader, 2, 11), 11);
444 ok_int(RtlFindSetBits(&BitMapHeader, 1, 32), 1);
445 ok_int(RtlFindSetBits(&BitMapHeader, 4, 32), 11);
446 ok_int(RtlFindSetBits(&BitMapHeader, 5, 32), 20);
447
448 RtlInitializeBitMap(&BitMapHeader, Buffer, 64);
449 ok_int(RtlFindSetBits(&BitMapHeader, 5, 64), 20);
450 ok_int(RtlFindSetBits(&BitMapHeader, 6, 57), 40);
451 ok_int(RtlFindSetBits(&BitMapHeader, 7, 0), -1);
452 ok_int(RtlFindSetBits(&BitMapHeader, 1, 62), 1);
453 FreeGuarded(Buffer);
454}
455
456void
457Test_RtlFindClearBitsAndSet(void)
458{
459 RTL_BITMAP BitMapHeader;
460 ULONG *Buffer;
461
462 Buffer = AllocateGuarded(2 * sizeof(*Buffer));
463 Buffer[0] = 0x060F874D;
464 Buffer[1] = 0x3F303F30;
465
466 RtlInitializeBitMap(&BitMapHeader, Buffer, 0);
467 ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 0, 0), 0);
468 ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 0, 3), 0);
469 ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 1, 0), -1);
470 ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 1, 1), -1);
471 ok_hex(Buffer[0], 0x060F874D);
472
473 Buffer[0] = 0x060F874D;
474 RtlInitializeBitMap(&BitMapHeader, Buffer, 8);
475 ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 1, 0), 1);
476 ok_hex(Buffer[0], 0x60f874f);
477 ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 1, 1), 4);
478 ok_hex(Buffer[0], 0x60f875f);
479 ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 1, 2), 5);
480 ok_hex(Buffer[0], 0x60f877f);
481 ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 2, 0), -1);
482 ok_hex(Buffer[0], 0x60f877f);
483
484 Buffer[0] = 0x060F874D;
485 RtlInitializeBitMap(&BitMapHeader, Buffer, 32);
486 ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 4, 0), 11);
487 ok_hex(Buffer[0], 0x60fff4d);
488 ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 5, 0), 20);
489 ok_hex(Buffer[0], 0x7ffff4d);
490 ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 4, 11), 27);
491 ok_hex(Buffer[0], 0x7fffff4d);
492
493 Buffer[0] = 0x060F874D;
494 ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 4, 12), 20);
495 ok_hex(Buffer[0], 0x6ff874d);
496 ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 2, 11), 11);
497 ok_hex(Buffer[0], 0x6ff9f4d);
498 ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 2, 12), 13);
499 ok_hex(Buffer[0], 0x6ffff4d);
500 FreeGuarded(Buffer);
501}
502
503void
504Test_RtlFindSetBitsAndClear(void)
505{
506 RTL_BITMAP BitMapHeader;
507 ULONG *Buffer;
508
509 Buffer = AllocateGuarded(2 * sizeof(*Buffer));
510 Buffer[0] = 0xF9F078B2;
511 Buffer[1] = 0x3F303F30;
512
513 RtlInitializeBitMap(&BitMapHeader, Buffer, 0);
514 ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 0, 0), 0);
515 ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 0, 3), 0);
516 ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 1, 0), -1);
517 ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 1, 1), -1);
518 ok_hex(Buffer[0], 0xF9F078B2);
519
520 Buffer[0] = 0xF9F078B2;
521 RtlInitializeBitMap(&BitMapHeader, Buffer, 8);
522 ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 1, 0), 1);
523 ok_hex(Buffer[0], 0xf9f078b0);
524 ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 1, 1), 4);
525 ok_hex(Buffer[0], 0xf9f078a0);
526 ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 1, 2), 5);
527 ok_hex(Buffer[0], 0xf9f07880);
528 ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 2, 0), -1);
529 ok_hex(Buffer[0], 0xf9f07880);
530
531 Buffer[0] = 0xF9F078B2;
532 RtlInitializeBitMap(&BitMapHeader, Buffer, 32);
533 ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 4, 0), 11);
534 ok_hex(Buffer[0], 0xf9f000b2);
535 ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 5, 0), 20);
536 ok_hex(Buffer[0], 0xf80000b2);
537 ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 4, 11), 27);
538 ok_hex(Buffer[0], 0x800000b2);
539
540 Buffer[0] = 0xF9F078B2;
541 ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 4, 12), 20);
542 ok_hex(Buffer[0], 0xf90078b2);
543 ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 2, 11), 11);
544 ok_hex(Buffer[0], 0xf90060b2);
545 ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 2, 12), 13);
546 ok_hex(Buffer[0], 0xf90000b2);
547 FreeGuarded(Buffer);
548}
549
550void
551Test_RtlFindNextForwardRunClear(void)
552{
553 RTL_BITMAP BitMapHeader;
554 ULONG *Buffer;
555 ULONG Index;
556
557 Buffer = AllocateGuarded(2 * sizeof(*Buffer));
558 Buffer[0] = 0xF9F078B2;
559 Buffer[1] = 0x3F303F30;
560
561 RtlInitializeBitMap(&BitMapHeader, Buffer, 0);
562 ok_int(RtlFindNextForwardRunClear(&BitMapHeader, 0, &Index), 0);
563 ok_int(Index, 0);
564 ok_int(RtlFindNextForwardRunClear(&BitMapHeader, 1, &Index), 0);
565 ok_int(Index, 1);
566
567 Index = -1;
568 RtlInitializeBitMap(&BitMapHeader, Buffer, 8);
569 ok_int(RtlFindNextForwardRunClear(&BitMapHeader, 0, &Index), 1);
570 ok_int(Index, 0);
571 ok_int(RtlFindNextForwardRunClear(&BitMapHeader, 1, &Index), 2);
572 ok_int(Index, 2);
573 ok_int(RtlFindNextForwardRunClear(&BitMapHeader, 7, &Index), 0);
574 ok_int(Index, 8);
575 ok_int(RtlFindNextForwardRunClear(&BitMapHeader, 17, &Index), 0);
576 ok_int(Index, 17);
577 ok_int(RtlFindNextForwardRunClear(&BitMapHeader, 39, &Index), 0);
578 ok_int(Index, 39);
579 FreeGuarded(Buffer);
580}
581
582void
583Test_RtlFindFirstRunClear(void)
584{
585}
586
587void
588Test_RtlFindLastBackwardRunClear(void)
589{
590}
591
592void
593Test_RtlFindClearRuns(void)
594{
595}
596
597void
598Test_RtlFindLongestRunClear(void)
599{
600}
601
602
603START_TEST(RtlBitmap)
604{
605 /* Windows 2003 has broken bitmap code that modifies the buffer */
606 if (!IsWindows7OrGreater() && !IsReactOS())
607 {
608 IsBroken = TRUE;
609 }
610
611 Test_RtlFindMostSignificantBit();
612 Test_RtlFindLeastSignificantBit();
613 Test_RtlInitializeBitMap();
614 Test_RtlClearAllBits();
615 Test_RtlSetAllBits();
616 Test_RtlClearBits();
617 Test_RtlSetBits();
618 Test_RtlAreBitsClear();
619 Test_RtlAreBitsSet();
620 Test_RtlNumberOfSetBits();
621 Test_RtlNumberOfClearBits();
622 Test_RtlFindClearBits();
623 Test_RtlFindSetBits();
624 Test_RtlFindClearBitsAndSet();
625 Test_RtlFindSetBitsAndClear();
626 Test_RtlFindNextForwardRunClear();
627 Test_RtlFindFirstRunClear();
628 Test_RtlFindLastBackwardRunClear();
629 Test_RtlFindClearRuns();
630 Test_RtlFindLongestRunClear();
631}
632
BOOLEAN
unsigned char BOOLEAN
Definition: ProcessorBind.h:185
Test_RtlFindLeastSignificantBit
void Test_RtlFindLeastSignificantBit(void)
Definition: RtlBitmap.c:24
Test_RtlSetBits
void Test_RtlSetBits(void)
Definition: RtlBitmap.c:177
Test_RtlInitializeBitMap
void Test_RtlInitializeBitMap(void)
Definition: RtlBitmap.c:38
Test_RtlFindNextForwardRunClear
void Test_RtlFindNextForwardRunClear(void)
Definition: RtlBitmap.c:551
Test_RtlClearAllBits
void Test_RtlClearAllBits(void)
Definition: RtlBitmap.c:71
Test_RtlClearBits
void Test_RtlClearBits(void)
Definition: RtlBitmap.c:127
Test_RtlFindClearBits
void Test_RtlFindClearBits(void)
Definition: RtlBitmap.c:357
Test_RtlFindLastBackwardRunClear
void Test_RtlFindLastBackwardRunClear(void)
Definition: RtlBitmap.c:588
Test_RtlFindLongestRunClear
void Test_RtlFindLongestRunClear(void)
Definition: RtlBitmap.c:598
Test_RtlFindClearRuns
void Test_RtlFindClearRuns(void)
Definition: RtlBitmap.c:593
Test_RtlFindSetBits
void Test_RtlFindSetBits(void)
Definition: RtlBitmap.c:408
IsBroken
static BOOL IsBroken
Definition: RtlBitmap.c:7
Test_RtlAreBitsSet
void Test_RtlAreBitsSet(void)
Definition: RtlBitmap.c:254
Test_RtlFindMostSignificantBit
void Test_RtlFindMostSignificantBit(void)
Definition: RtlBitmap.c:10
Test_RtlFindSetBitsAndClear
void Test_RtlFindSetBitsAndClear(void)
Definition: RtlBitmap.c:504
Test_RtlSetAllBits
void Test_RtlSetAllBits(void)
Definition: RtlBitmap.c:99
Test_RtlFindClearBitsAndSet
void Test_RtlFindClearBitsAndSet(void)
Definition: RtlBitmap.c:457
Test_RtlFindFirstRunClear
void Test_RtlFindFirstRunClear(void)
Definition: RtlBitmap.c:583
Test_RtlNumberOfClearBits
void Test_RtlNumberOfClearBits(void)
Definition: RtlBitmap.c:319
Test_RtlAreBitsClear
void Test_RtlAreBitsClear(void)
Definition: RtlBitmap.c:227
Test_RtlNumberOfSetBits
void Test_RtlNumberOfSetBits(void)
Definition: RtlBitmap.c:281
FreeGuarded
static VOID FreeGuarded(_In_ PVOID Pointer)
Definition: apitest_guard.h:45
AllocateGuarded
static PVOID AllocateGuarded(_In_ SIZE_T SizeRequested)
Definition: apitest_guard.h:10
ok_hex
#define ok_hex(expression, result)
Definition: atltest.h:94
START_TEST
#define START_TEST(x)
Definition: atltest.h:75
ok_int
#define ok_int(expression, result)
Definition: atltest.h:134
ok_ptr
#define ok_ptr(expression, result)
Definition: atltest.h:108
Buffer
Definition: bufpool.h:45
RtlAreBitsSet
#define RtlAreBitsSet
Definition: dbgbitmap.h:328
RtlFindClearBits
#define RtlFindClearBits
Definition: dbgbitmap.h:332
RtlClearBits
#define RtlClearBits
Definition: dbgbitmap.h:331
RtlAreBitsClear
#define RtlAreBitsClear
Definition: dbgbitmap.h:327
RtlInitializeBitMap
#define RtlInitializeBitMap
Definition: dbgbitmap.h:326
RtlFindNextForwardRunClear
#define RtlFindNextForwardRunClear
Definition: dbgbitmap.h:338
RtlClearAllBits
#define RtlClearAllBits
Definition: dbgbitmap.h:329
RtlFindClearBitsAndSet
#define RtlFindClearBitsAndSet
Definition: dbgbitmap.h:333
RtlNumberOfSetBits
#define RtlNumberOfSetBits
Definition: dbgbitmap.h:343
RtlSetAllBits
#define RtlSetAllBits
Definition: dbgbitmap.h:346
RtlFindSetBitsAndClear
#define RtlFindSetBitsAndClear
Definition: dbgbitmap.h:341
RtlNumberOfClearBits
#define RtlNumberOfClearBits
Definition: dbgbitmap.h:342
RtlSetBits
#define RtlSetBits
Definition: dbgbitmap.h:345
RtlFindSetBits
#define RtlFindSetBits
Definition: dbgbitmap.h:340
NULL
#define NULL
Definition: types.h:112
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117
_SEH2_END
#define _SEH2_END
Definition: filesup.c:22
_SEH2_TRY
#define _SEH2_TRY
Definition: filesup.c:19
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
EXCEPTION_EXECUTE_HANDLER
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
RtlFindMostSignificantBit
NTSYSAPI CCHAR WINAPI RtlFindMostSignificantBit(ULONGLONG)
Definition: bitmap.c:211
RtlFindLeastSignificantBit
NTSYSAPI CCHAR WINAPI RtlFindLeastSignificantBit(ULONGLONG)
Definition: bitmap.c:235
_SEH2_EXCEPT
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:66
memset
#define memset(x, y, z)
Definition: compat.h:39
_RTL_BITMAP
Definition: typedefs.h:89
_RTL_BITMAP::SizeOfBitMap
ULONG SizeOfBitMap
Definition: typedefs.h:90
_RTL_BITMAP::Buffer
PULONG Buffer
Definition: typedefs.h:91
ULONG
uint32_t ULONG
Definition: typedefs.h:59
IsWindows7OrGreater
VERSIONHELPERAPI IsWindows7OrGreater()
Definition: versionhelpers.h:88
Index
_In_ WDFCOLLECTION _In_ ULONG Index
Definition: wdfcollection.h:182
BufferSize
_In_ WDFMEMORY _Out_opt_ size_t * BufferSize
Definition: wdfmemory.h:254