[NTDLL_APITEST]
[reactos.git] / rostests / apitests / ntdll / RtlBitmap.c
1
2 #define WIN32_NO_STATUS
3 #include <stdio.h>
4 #include <wine/test.h>
5 #include <ndk/rtlfuncs.h>
6 #include <pseh/pseh2.h>
7
8 void
9 Test_RtlFindMostSignificantBit(void)
10 {
11 ok_int(RtlFindMostSignificantBit(0), -1);
12
13 ok_int(RtlFindMostSignificantBit(0x0000000000000001ULL), 0);
14 ok_int(RtlFindMostSignificantBit(0x0000000000000002ULL), 1);
15 ok_int(RtlFindMostSignificantBit(0x1000000000000000ULL), 60);
16 ok_int(RtlFindMostSignificantBit(0x8000000000000000ULL), 63);
17 ok_int(RtlFindMostSignificantBit(0x8000000000000001ULL), 63);
18 ok_int(RtlFindMostSignificantBit(0xFFFFFFFFFFFFFFFFULL), 63);
19 ok_int(RtlFindMostSignificantBit(0x0000000070000000ULL), 30);
20 }
21
22 void
23 Test_RtlFindLeastSignificantBit(void)
24 {
25 ok_int(RtlFindLeastSignificantBit(0), -1);
26
27 ok_int(RtlFindLeastSignificantBit(0x0000000000000001ULL), 0);
28 ok_int(RtlFindLeastSignificantBit(0x0000000000000002ULL), 1);
29 ok_int(RtlFindLeastSignificantBit(0x1000000000000000ULL), 60);
30 ok_int(RtlFindLeastSignificantBit(0x8000000000000000ULL), 63);
31 ok_int(RtlFindLeastSignificantBit(0x8000000000000000ULL), 63);
32 ok_int(RtlFindLeastSignificantBit(0xFFFFFFFFFFFFFFFFULL), 0);
33 ok_int(RtlFindLeastSignificantBit(0x0000000070000000ULL), 28);
34 }
35
36 void
37 Test_RtlInitializeBitMap(void)
38 {
39 RTL_BITMAP BitMapHeader;
40 ULONG Buffer[2];
41 BOOLEAN Exception = FALSE;
42
43 _SEH2_TRY
44 {
45 RtlInitializeBitMap(NULL, NULL, 0);
46 }
47 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
48 {
49 Exception = TRUE;
50 }
51 _SEH2_END;
52 ok_int(Exception, 1);
53
54 memset(Buffer, 0xcc, sizeof(Buffer));
55 RtlInitializeBitMap(&BitMapHeader, Buffer, 0);
56 ok_int(BitMapHeader.SizeOfBitMap, 0);
57 ok_ptr(BitMapHeader.Buffer, Buffer);
58 ok_hex(Buffer[0], 0xcccccccc);
59
60 RtlInitializeBitMap(&BitMapHeader, Buffer, 8);
61 ok_int(BitMapHeader.SizeOfBitMap, 8);
62 ok_hex(Buffer[0], 0xcccccccc);
63 }
64
65 void
66 Test_RtlClearAllBits(void)
67 {
68 RTL_BITMAP BitMapHeader;
69 ULONG Buffer[2];
70
71 RtlInitializeBitMap(&BitMapHeader, Buffer, 19);
72 memset(Buffer, 0xcc, sizeof(Buffer));
73 RtlClearAllBits(&BitMapHeader);
74 ok_hex(Buffer[0], 0x00000000);
75 ok_hex(Buffer[1], 0xcccccccc);
76
77 RtlInitializeBitMap(&BitMapHeader, Buffer, 0);
78 memset(Buffer, 0xcc, sizeof(Buffer));
79 RtlClearAllBits(&BitMapHeader);
80 ok_hex(Buffer[0], 0xcccccccc);
81 ok_hex(Buffer[1], 0xcccccccc);
82 }
83
84 void
85 Test_RtlSetAllBits(void)
86 {
87 RTL_BITMAP BitMapHeader;
88 ULONG Buffer[2];
89
90 RtlInitializeBitMap(&BitMapHeader, Buffer, 19);
91 memset(Buffer, 0xcc, sizeof(Buffer));
92 RtlSetAllBits(&BitMapHeader);
93 ok_hex(Buffer[0], 0xffffffff);
94 ok_hex(Buffer[1], 0xcccccccc);
95
96 RtlInitializeBitMap(&BitMapHeader, Buffer, 0);
97 memset(Buffer, 0xcc, sizeof(Buffer));
98 RtlSetAllBits(&BitMapHeader);
99 ok_hex(Buffer[0], 0xcccccccc);
100 ok_hex(Buffer[1], 0xcccccccc);
101 }
102
103 void
104 Test_RtlClearBits(void)
105 {
106 RTL_BITMAP BitMapHeader;
107 ULONG Buffer[2];
108
109 RtlInitializeBitMap(&BitMapHeader, Buffer, 19);
110
111 memset(Buffer, 0xff, sizeof(Buffer));
112 RtlClearBits(&BitMapHeader, 0, 0);
113 ok_hex(Buffer[0], 0xffffffff);
114 ok_hex(Buffer[1], 0xffffffff);
115
116 memset(Buffer, 0xff, sizeof(Buffer));
117 RtlClearBits(&BitMapHeader, 0, 1);
118 ok_hex(Buffer[0], 0xfffffffe);
119 ok_hex(Buffer[1], 0xffffffff);
120
121 memset(Buffer, 0xff, sizeof(Buffer));
122 RtlClearBits(&BitMapHeader, 21, 1);
123 ok_hex(Buffer[0], 0xffdfffff);
124 ok_hex(Buffer[1], 0xffffffff);
125
126 memset(Buffer, 0xff, sizeof(Buffer));
127 RtlClearBits(&BitMapHeader, 7, 9);
128 ok_hex(Buffer[0], 0xffff007f);
129 ok_hex(Buffer[1], 0xffffffff);
130
131 memset(Buffer, 0xff, sizeof(Buffer));
132 RtlClearBits(&BitMapHeader, 13, 22);
133 ok_hex(Buffer[0], 0x00001fff);
134 ok_hex(Buffer[1], 0xfffffff8);
135
136 memset(Buffer, 0xcc, sizeof(Buffer));
137 RtlClearBits(&BitMapHeader, 3, 6);
138 RtlClearBits(&BitMapHeader, 11, 5);
139 RtlClearBits(&BitMapHeader, 21, 7);
140 RtlClearBits(&BitMapHeader, 37, 4);
141 ok_hex(Buffer[0], 0xc00c0404);
142 ok_hex(Buffer[1], 0xcccccc0c);
143 }
144
145 void
146 Test_RtlSetBits(void)
147 {
148 RTL_BITMAP BitMapHeader;
149 ULONG Buffer[2];
150
151 RtlInitializeBitMap(&BitMapHeader, Buffer, 19);
152
153 memset(Buffer, 0x00, sizeof(Buffer));
154 RtlSetBits(&BitMapHeader, 0, 0);
155 ok_hex(Buffer[0], 0x00000000);
156 ok_hex(Buffer[1], 0x00000000);
157
158 memset(Buffer, 0x00, sizeof(Buffer));
159 RtlSetBits(&BitMapHeader, 0, 1);
160 ok_hex(Buffer[0], 0x00000001);
161 ok_hex(Buffer[1], 0x00000000);
162
163 memset(Buffer, 0x00, sizeof(Buffer));
164 RtlSetBits(&BitMapHeader, 21, 1);
165 ok_hex(Buffer[0], 0x00200000);
166 ok_hex(Buffer[1], 0x00000000);
167
168 memset(Buffer, 0x00, sizeof(Buffer));
169 RtlSetBits(&BitMapHeader, 7, 9);
170 ok_hex(Buffer[0], 0x0000ff80);
171 ok_hex(Buffer[1], 0x00000000);
172
173 memset(Buffer, 0x00, sizeof(Buffer));
174 RtlSetBits(&BitMapHeader, 13, 22);
175 ok_hex(Buffer[0], 0xffffe000);
176 ok_hex(Buffer[1], 0x00000007);
177
178 memset(Buffer, 0xcc, sizeof(Buffer));
179 RtlSetBits(&BitMapHeader, 3, 6);
180 RtlSetBits(&BitMapHeader, 11, 5);
181 RtlSetBits(&BitMapHeader, 21, 7);
182 RtlSetBits(&BitMapHeader, 37, 4);
183 ok_hex(Buffer[0], 0xcfecfdfc);
184 ok_hex(Buffer[1], 0xcccccdec);
185 }
186
187 void
188 Test_RtlAreBitsClear(void)
189 {
190 RTL_BITMAP BitMapHeader;
191 ULONG Buffer[2];
192
193 RtlInitializeBitMap(&BitMapHeader, Buffer, 19);
194 Buffer[0] = 0x00ff00ff;
195 Buffer[1] = 0xc0cfc0cf;
196
197 ok_hex(RtlAreBitsClear(&BitMapHeader, 0, 8), FALSE);
198 ok_hex(RtlAreBitsClear(&BitMapHeader, 8, 8), TRUE);
199 ok_hex(RtlAreBitsClear(&BitMapHeader, 7, 8), FALSE);
200 ok_hex(RtlAreBitsClear(&BitMapHeader, 8, 9), FALSE);
201 ok_hex(RtlAreBitsClear(&BitMapHeader, 24, 1), FALSE);
202
203 RtlInitializeBitMap(&BitMapHeader, Buffer, 31);
204 ok_hex(RtlAreBitsClear(&BitMapHeader, 24, 1), TRUE);
205 ok_hex(RtlAreBitsClear(&BitMapHeader, 24, 7), TRUE);
206 ok_hex(RtlAreBitsClear(&BitMapHeader, 24, 8), FALSE);
207
208 }
209
210 void
211 Test_RtlAreBitsSet(void)
212 {
213 RTL_BITMAP BitMapHeader;
214 ULONG Buffer[2];
215
216 RtlInitializeBitMap(&BitMapHeader, Buffer, 19);
217 Buffer[0] = 0xff00ff00;
218 Buffer[1] = 0x3F303F30;
219
220 ok_hex(RtlAreBitsSet(&BitMapHeader, 0, 8), FALSE);
221 ok_hex(RtlAreBitsSet(&BitMapHeader, 8, 8), TRUE);
222 ok_hex(RtlAreBitsSet(&BitMapHeader, 7, 8), FALSE);
223 ok_hex(RtlAreBitsSet(&BitMapHeader, 8, 9), FALSE);
224 ok_hex(RtlAreBitsSet(&BitMapHeader, 24, 1), FALSE);
225
226 RtlInitializeBitMap(&BitMapHeader, Buffer, 31);
227 ok_hex(RtlAreBitsSet(&BitMapHeader, 24, 1), TRUE);
228 ok_hex(RtlAreBitsSet(&BitMapHeader, 24, 7), TRUE);
229 ok_hex(RtlAreBitsSet(&BitMapHeader, 24, 8), FALSE);
230
231 }
232
233 void
234 Test_RtlNumberOfSetBits(void)
235 {
236 RTL_BITMAP BitMapHeader;
237 ULONG Buffer[2];
238
239 Buffer[0] = 0xff00ff0f;
240 Buffer[1] = 0x3F303F30;
241
242 RtlInitializeBitMap(&BitMapHeader, Buffer, 0);
243 ok_int(RtlNumberOfSetBits(&BitMapHeader), 0);
244
245 RtlInitializeBitMap(&BitMapHeader, Buffer, 4);
246 ok_int(RtlNumberOfSetBits(&BitMapHeader), 4);
247
248 RtlInitializeBitMap(&BitMapHeader, Buffer, 31);
249 ok_int(RtlNumberOfSetBits(&BitMapHeader), 19);
250
251 RtlInitializeBitMap(&BitMapHeader, Buffer, 56);
252 ok_int(RtlNumberOfSetBits(&BitMapHeader), 30);
253 }
254
255 void
256 Test_RtlNumberOfClearBits(void)
257 {
258 RTL_BITMAP BitMapHeader;
259 ULONG Buffer[2];
260
261 Buffer[0] = 0xff00fff0;
262 Buffer[1] = 0x3F303F30;
263
264 RtlInitializeBitMap(&BitMapHeader, Buffer, 0);
265 ok_int(RtlNumberOfClearBits(&BitMapHeader), 0);
266
267 RtlInitializeBitMap(&BitMapHeader, Buffer, 4);
268 ok_int(RtlNumberOfClearBits(&BitMapHeader), 4);
269
270 RtlInitializeBitMap(&BitMapHeader, Buffer, 31);
271 ok_int(RtlNumberOfClearBits(&BitMapHeader), 12);
272
273 RtlInitializeBitMap(&BitMapHeader, Buffer, 56);
274 ok_int(RtlNumberOfClearBits(&BitMapHeader), 26);
275 }
276
277 void
278 Test_RtlFindClearBits(void)
279 {
280 RTL_BITMAP BitMapHeader;
281 ULONG Buffer[2];
282
283 Buffer[0] = 0x060F874D;
284 Buffer[1] = 0x3F303F30;
285
286 RtlInitializeBitMap(&BitMapHeader, Buffer, 0);
287 ok_int(RtlFindClearBits(&BitMapHeader, 0, 0), 0);
288 ok_int(RtlFindClearBits(&BitMapHeader, 0, 3), 0);
289 ok_int(RtlFindClearBits(&BitMapHeader, 1, 0), -1);
290 ok_int(RtlFindClearBits(&BitMapHeader, 1, 1), -1);
291
292 RtlInitializeBitMap(&BitMapHeader, Buffer, 8);
293 ok_int(RtlFindClearBits(&BitMapHeader, 1, 0), 1);
294 ok_int(RtlFindClearBits(&BitMapHeader, 1, 1), 1);
295 ok_int(RtlFindClearBits(&BitMapHeader, 1, 2), 4);
296
297 ok_int(RtlFindClearBits(&BitMapHeader, 2, 0), 4);
298 ok_int(RtlFindClearBits(&BitMapHeader, 3, 0), -1);
299
300 RtlInitializeBitMap(&BitMapHeader, Buffer, 32);
301 ok_int(RtlFindClearBits(&BitMapHeader, 4, 0), 11);
302 ok_int(RtlFindClearBits(&BitMapHeader, 5, 0), 20);
303 ok_int(RtlFindClearBits(&BitMapHeader, 4, 11), 11);
304 ok_int(RtlFindClearBits(&BitMapHeader, 4, 12), 20);
305 ok_int(RtlFindClearBits(&BitMapHeader, 2, 11), 11);
306 ok_int(RtlFindClearBits(&BitMapHeader, 2, 12), 12);
307 ok_int(RtlFindClearBits(&BitMapHeader, 0, 12), 8);
308 ok_int(RtlFindClearBits(&BitMapHeader, 0, 39), 0);
309
310 }
311
312 void
313 Test_RtlFindSetBits(void)
314 {
315 RTL_BITMAP BitMapHeader;
316 ULONG Buffer[2];
317
318 Buffer[0] = 0xF9F078B2;
319 Buffer[1] = 0x3F303F30;
320
321 RtlInitializeBitMap(&BitMapHeader, Buffer, 0);
322 ok_int(RtlFindSetBits(&BitMapHeader, 0, 0), 0);
323 ok_int(RtlFindSetBits(&BitMapHeader, 0, 3), 0);
324 ok_int(RtlFindSetBits(&BitMapHeader, 1, 0), -1);
325 ok_int(RtlFindSetBits(&BitMapHeader, 1, 1), -1);
326
327 RtlInitializeBitMap(&BitMapHeader, Buffer, 8);
328 ok_int(RtlFindSetBits(&BitMapHeader, 1, 0), 1);
329 ok_int(RtlFindSetBits(&BitMapHeader, 1, 1), 1);
330 ok_int(RtlFindSetBits(&BitMapHeader, 1, 2), 4);
331
332 ok_int(RtlFindSetBits(&BitMapHeader, 2, 0), 4);
333 ok_int(RtlFindSetBits(&BitMapHeader, 3, 0), -1);
334
335 RtlInitializeBitMap(&BitMapHeader, Buffer, 32);
336 ok_int(RtlFindSetBits(&BitMapHeader, 4, 0), 11);
337 ok_int(RtlFindSetBits(&BitMapHeader, 5, 0), 20);
338 ok_int(RtlFindSetBits(&BitMapHeader, 4, 11), 11);
339 ok_int(RtlFindSetBits(&BitMapHeader, 4, 12), 20);
340 ok_int(RtlFindSetBits(&BitMapHeader, 2, 11), 11);
341 ok_int(RtlFindSetBits(&BitMapHeader, 2, 12), 12);
342 ok_int(RtlFindSetBits(&BitMapHeader, 0, 12), 8);
343 ok_int(RtlFindSetBits(&BitMapHeader, 0, 39), 0);
344
345 }
346
347 void
348 Test_RtlFindClearBitsAndSet(void)
349 {
350 RTL_BITMAP BitMapHeader;
351 ULONG Buffer[2];
352
353 Buffer[0] = 0x060F874D;
354 Buffer[1] = 0x3F303F30;
355
356 RtlInitializeBitMap(&BitMapHeader, Buffer, 0);
357 ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 0, 0), 0);
358 ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 0, 3), 0);
359 ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 1, 0), -1);
360 ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 1, 1), -1);
361 ok_hex(Buffer[0], 0x060F874D);
362
363 Buffer[0] = 0x060F874D;
364 RtlInitializeBitMap(&BitMapHeader, Buffer, 8);
365 ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 1, 0), 1);
366 ok_hex(Buffer[0], 0x60f874f);
367 ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 1, 1), 4);
368 ok_hex(Buffer[0], 0x60f875f);
369 ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 1, 2), 5);
370 ok_hex(Buffer[0], 0x60f877f);
371 ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 2, 0), -1);
372 ok_hex(Buffer[0], 0x60f877f);
373
374 Buffer[0] = 0x060F874D;
375 RtlInitializeBitMap(&BitMapHeader, Buffer, 32);
376 ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 4, 0), 11);
377 ok_hex(Buffer[0], 0x60fff4d);
378 ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 5, 0), 20);
379 ok_hex(Buffer[0], 0x7ffff4d);
380 ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 4, 11), 27);
381 ok_hex(Buffer[0], 0x7fffff4d);
382
383 Buffer[0] = 0x060F874D;
384 ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 4, 12), 20);
385 ok_hex(Buffer[0], 0x6ff874d);
386 ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 2, 11), 11);
387 ok_hex(Buffer[0], 0x6ff9f4d);
388 ok_int(RtlFindClearBitsAndSet(&BitMapHeader, 2, 12), 13);
389 ok_hex(Buffer[0], 0x6ffff4d);
390 }
391
392 void
393 Test_RtlFindSetBitsAndClear(void)
394 {
395 RTL_BITMAP BitMapHeader;
396 ULONG Buffer[2];
397
398 Buffer[0] = 0xF9F078B2;
399 Buffer[1] = 0x3F303F30;
400
401 RtlInitializeBitMap(&BitMapHeader, Buffer, 0);
402 ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 0, 0), 0);
403 ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 0, 3), 0);
404 ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 1, 0), -1);
405 ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 1, 1), -1);
406 ok_hex(Buffer[0], 0xF9F078B2);
407
408 Buffer[0] = 0xF9F078B2;
409 RtlInitializeBitMap(&BitMapHeader, Buffer, 8);
410 ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 1, 0), 1);
411 ok_hex(Buffer[0], 0xf9f078b0);
412 ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 1, 1), 4);
413 ok_hex(Buffer[0], 0xf9f078a0);
414 ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 1, 2), 5);
415 ok_hex(Buffer[0], 0xf9f07880);
416 ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 2, 0), -1);
417 ok_hex(Buffer[0], 0xf9f07880);
418
419 Buffer[0] = 0xF9F078B2;
420 RtlInitializeBitMap(&BitMapHeader, Buffer, 32);
421 ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 4, 0), 11);
422 ok_hex(Buffer[0], 0xf9f000b2);
423 ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 5, 0), 20);
424 ok_hex(Buffer[0], 0xf80000b2);
425 ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 4, 11), 27);
426 ok_hex(Buffer[0], 0x800000b2);
427
428 Buffer[0] = 0xF9F078B2;
429 ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 4, 12), 20);
430 ok_hex(Buffer[0], 0xf90078b2);
431 ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 2, 11), 11);
432 ok_hex(Buffer[0], 0xf90060b2);
433 ok_int(RtlFindSetBitsAndClear(&BitMapHeader, 2, 12), 13);
434 ok_hex(Buffer[0], 0xf90000b2);
435
436 }
437
438 void
439 Test_RtlFindNextForwardRunClear(void)
440 {
441 RTL_BITMAP BitMapHeader;
442 ULONG Buffer[2];
443 ULONG Index;
444
445 Buffer[0] = 0xF9F078B2;
446 Buffer[1] = 0x3F303F30;
447
448 RtlInitializeBitMap(&BitMapHeader, Buffer, 0);
449 ok_int(RtlFindNextForwardRunClear(&BitMapHeader, 0, &Index), 0);
450 ok_int(Index, 0);
451 ok_int(RtlFindNextForwardRunClear(&BitMapHeader, 1, &Index), 0);
452 ok_int(Index, 1);
453
454 Index = -1;
455 RtlInitializeBitMap(&BitMapHeader, Buffer, 8);
456 ok_int(RtlFindNextForwardRunClear(&BitMapHeader, 0, &Index), 1);
457 ok_int(Index, 0);
458 ok_int(RtlFindNextForwardRunClear(&BitMapHeader, 1, &Index), 2);
459 ok_int(Index, 2);
460 ok_int(RtlFindNextForwardRunClear(&BitMapHeader, 7, &Index), 0);
461 ok_int(Index, 8);
462 ok_int(RtlFindNextForwardRunClear(&BitMapHeader, 17, &Index), 0);
463 ok_int(Index, 17);
464 ok_int(RtlFindNextForwardRunClear(&BitMapHeader, 39, &Index), 0);
465 ok_int(Index, 39);
466 }
467
468 void
469 Test_RtlFindFirstRunClear(void)
470 {
471 }
472
473 void
474 Test_RtlFindLastBackwardRunClear(void)
475 {
476 }
477
478 void
479 Test_RtlFindClearRuns(void)
480 {
481 }
482
483 void
484 Test_RtlFindLongestRunClear(void)
485 {
486 }
487
488
489 START_TEST(RtlBitmap)
490 {
491 Test_RtlFindMostSignificantBit();
492 Test_RtlFindLeastSignificantBit();
493 Test_RtlInitializeBitMap();
494 Test_RtlClearAllBits();
495 Test_RtlSetAllBits();
496 Test_RtlClearBits();
497 Test_RtlSetBits();
498 Test_RtlAreBitsClear();
499 Test_RtlAreBitsSet();
500 Test_RtlNumberOfSetBits();
501 Test_RtlNumberOfClearBits();
502 Test_RtlFindClearBits();
503 Test_RtlFindSetBits();
504 Test_RtlFindClearBitsAndSet();
505 Test_RtlFindSetBitsAndClear();
506 Test_RtlFindNextForwardRunClear();
507 Test_RtlFindFirstRunClear();
508 Test_RtlFindLastBackwardRunClear();
509 Test_RtlFindClearRuns();
510 Test_RtlFindLongestRunClear();
511 }
512