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