1
2 #include "precomp.h"
3 #include <versionhelpers.h>
4
5 #include <pseh/pseh2.h>
6
7 static BOOL IsBroken = FALSE;
8
9 void
Test_RtlFindMostSignificantBit(void)10 Test_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
23 void
Test_RtlFindLeastSignificantBit(void)24 Test_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
37 void
Test_RtlInitializeBitMap(void)38 Test_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
70 void
Test_RtlClearAllBits(void)71 Test_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
98 void
Test_RtlSetAllBits(void)99 Test_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
126 void
Test_RtlClearBits(void)127 Test_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
176 void
Test_RtlSetBits(void)177 Test_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
226 void
Test_RtlAreBitsClear(void)227 Test_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
253 void
Test_RtlAreBitsSet(void)254 Test_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
280 void
Test_RtlNumberOfSetBits(void)281 Test_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
318 void
Test_RtlNumberOfClearBits(void)319 Test_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
356 void
Test_RtlFindClearBits(void)357 Test_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
407 void
Test_RtlFindSetBits(void)408 Test_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
456 void
Test_RtlFindClearBitsAndSet(void)457 Test_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
503 void
Test_RtlFindSetBitsAndClear(void)504 Test_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
550 void
Test_RtlFindNextForwardRunClear(void)551 Test_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
582 void
Test_RtlFindFirstRunClear(void)583 Test_RtlFindFirstRunClear(void)
584 {
585 }
586
587 void
Test_RtlFindLastBackwardRunClear(void)588 Test_RtlFindLastBackwardRunClear(void)
589 {
590 }
591
592 void
Test_RtlFindClearRuns(void)593 Test_RtlFindClearRuns(void)
594 {
595 }
596
597 void
Test_RtlFindLongestRunClear(void)598 Test_RtlFindLongestRunClear(void)
599 {
600 }
601
602
START_TEST(RtlBitmap)603 START_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
633