1 #include "test-ebitmap.h"
2
3 #include <stdlib.h>
4 #include <time.h>
5
6 #include <sepol/debug.h>
7 #include <sepol/policydb/ebitmap.h>
8
9 #define RANDOM_ROUNDS 10
10
11
ebitmap_init_random(ebitmap_t * e,unsigned int length,int set_chance)12 static int ebitmap_init_random(ebitmap_t *e, unsigned int length, int set_chance)
13 {
14 unsigned int i;
15 int rc;
16
17 if (set_chance <= 0 || set_chance > 100)
18 return -EINVAL;
19
20 ebitmap_init(e);
21
22 for (i = 0; i < length; i++) {
23 if ((random() % 100) < set_chance) {
24 rc = ebitmap_set_bit(e, i, 1);
25 if (rc)
26 return rc;
27 }
28 }
29
30 return 0;
31 }
32
test_ebitmap_init_destroy(void)33 static void test_ebitmap_init_destroy(void)
34 {
35 ebitmap_t e;
36
37 /* verify idempotence */
38 ebitmap_init(&e);
39 ebitmap_init(&e);
40 ebitmap_init(&e);
41
42 CU_ASSERT(ebitmap_is_empty(&e));
43 CU_ASSERT_PTR_NULL(ebitmap_startnode(&e));
44
45 /* verify idempotence */
46 ebitmap_destroy(&e);
47 ebitmap_destroy(&e);
48 ebitmap_destroy(&e);
49
50 CU_ASSERT(ebitmap_is_empty(&e));
51 CU_ASSERT_PTR_NULL(ebitmap_startnode(&e));
52 }
53
test_ebitmap_cmp(void)54 static void test_ebitmap_cmp(void)
55 {
56 ebitmap_t e1, e2;
57
58 ebitmap_init(&e1);
59 ebitmap_init(&e2);
60
61 CU_ASSERT(ebitmap_cmp(&e1, &e2));
62
63 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 10, 1), 0);
64 CU_ASSERT_FALSE(ebitmap_cmp(&e1, &e2));
65 CU_ASSERT_EQUAL(ebitmap_set_bit(&e2, 10, 1), 0);
66 CU_ASSERT(ebitmap_cmp(&e1, &e2));
67
68 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 63, 1), 0);
69 CU_ASSERT_FALSE(ebitmap_cmp(&e1, &e2));
70 CU_ASSERT_EQUAL(ebitmap_set_bit(&e2, 63, 1), 0);
71 CU_ASSERT(ebitmap_cmp(&e1, &e2));
72
73 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 64, 1), 0);
74 CU_ASSERT_FALSE(ebitmap_cmp(&e1, &e2));
75 CU_ASSERT_EQUAL(ebitmap_set_bit(&e2, 64, 1), 0);
76 CU_ASSERT(ebitmap_cmp(&e1, &e2));
77
78 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 1022, 1), 0);
79 CU_ASSERT_FALSE(ebitmap_cmp(&e1, &e2));
80 CU_ASSERT_EQUAL(ebitmap_set_bit(&e2, 1022, 1), 0);
81 CU_ASSERT(ebitmap_cmp(&e1, &e2));
82
83 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 1023, 1), 0);
84 CU_ASSERT_FALSE(ebitmap_cmp(&e1, &e2));
85 CU_ASSERT_EQUAL(ebitmap_set_bit(&e2, 1023, 1), 0);
86 CU_ASSERT(ebitmap_cmp(&e1, &e2));
87
88 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 1024, 1), 0);
89 CU_ASSERT_FALSE(ebitmap_cmp(&e1, &e2));
90 CU_ASSERT_EQUAL(ebitmap_set_bit(&e2, 1024, 1), 0);
91 CU_ASSERT(ebitmap_cmp(&e1, &e2));
92
93 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 1025, 1), 0);
94 CU_ASSERT_FALSE(ebitmap_cmp(&e1, &e2));
95 CU_ASSERT_EQUAL(ebitmap_set_bit(&e2, 1025, 1), 0);
96 CU_ASSERT(ebitmap_cmp(&e1, &e2));
97
98 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 255, 1), 0);
99 CU_ASSERT_FALSE(ebitmap_cmp(&e1, &e2));
100 CU_ASSERT_EQUAL(ebitmap_set_bit(&e2, 255, 1), 0);
101 CU_ASSERT(ebitmap_cmp(&e1, &e2));
102
103 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 256, 1), 0);
104 CU_ASSERT_FALSE(ebitmap_cmp(&e1, &e2));
105 CU_ASSERT_EQUAL(ebitmap_set_bit(&e2, 256, 1), 0);
106 CU_ASSERT(ebitmap_cmp(&e1, &e2));
107
108 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 639, 1), 0);
109 CU_ASSERT_FALSE(ebitmap_cmp(&e1, &e2));
110 CU_ASSERT_EQUAL(ebitmap_set_bit(&e2, 639, 1), 0);
111 CU_ASSERT(ebitmap_cmp(&e1, &e2));
112
113 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 640, 1), 0);
114 CU_ASSERT_FALSE(ebitmap_cmp(&e1, &e2));
115 CU_ASSERT_EQUAL(ebitmap_set_bit(&e2, 640, 1), 0);
116 CU_ASSERT(ebitmap_cmp(&e1, &e2));
117
118 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 900, 1), 0);
119 CU_ASSERT_FALSE(ebitmap_cmp(&e1, &e2));
120 CU_ASSERT_EQUAL(ebitmap_set_bit(&e2, 900, 1), 0);
121 CU_ASSERT(ebitmap_cmp(&e1, &e2));
122
123 ebitmap_destroy(&e2);
124
125 CU_ASSERT_FALSE(ebitmap_cmp(&e1, &e2));
126
127 ebitmap_destroy(&e1);
128
129 CU_ASSERT(ebitmap_cmp(&e1, &e2));
130 }
131
test_ebitmap_set_and_get(void)132 static void test_ebitmap_set_and_get(void)
133 {
134 ebitmap_t e;
135
136 ebitmap_init(&e);
137
138 CU_ASSERT(ebitmap_is_empty(&e));
139 CU_ASSERT_TRUE(ebitmap_is_empty(&e));
140 CU_ASSERT_EQUAL(ebitmap_cardinality(&e), 0);
141 CU_ASSERT_EQUAL(ebitmap_highest_set_bit(&e), 0);
142 CU_ASSERT_EQUAL(ebitmap_get_bit(&e, 10), 0);
143
144 CU_ASSERT_EQUAL(ebitmap_set_bit(&e, UINT32_MAX, 1), -EINVAL);
145
146 CU_ASSERT_EQUAL(ebitmap_set_bit(&e, 10, 0), 0);
147 CU_ASSERT(ebitmap_is_empty(&e));
148 CU_ASSERT_EQUAL(ebitmap_cardinality(&e), 0);
149 CU_ASSERT_EQUAL(ebitmap_highest_set_bit(&e), 0);
150 CU_ASSERT_EQUAL(ebitmap_get_bit(&e, 10), 0);
151
152 CU_ASSERT_EQUAL(ebitmap_set_bit(&e, 10, 1), 0);
153 CU_ASSERT_FALSE(ebitmap_is_empty(&e));
154 CU_ASSERT_EQUAL(ebitmap_cardinality(&e), 1);
155 CU_ASSERT_EQUAL(ebitmap_highest_set_bit(&e), 10);
156 CU_ASSERT_EQUAL(ebitmap_get_bit(&e, 10), 1);
157
158 CU_ASSERT_EQUAL(ebitmap_set_bit(&e, 100, 1), 0);
159 CU_ASSERT_FALSE(ebitmap_is_empty(&e));
160 CU_ASSERT_EQUAL(ebitmap_cardinality(&e), 2);
161 CU_ASSERT_EQUAL(ebitmap_highest_set_bit(&e), 100);
162 CU_ASSERT_EQUAL(ebitmap_get_bit(&e, 100), 1);
163
164 CU_ASSERT_EQUAL(ebitmap_set_bit(&e, 50, 1), 0);
165 CU_ASSERT_FALSE(ebitmap_is_empty(&e));
166 CU_ASSERT_EQUAL(ebitmap_cardinality(&e), 3);
167 CU_ASSERT_EQUAL(ebitmap_highest_set_bit(&e), 100);
168 CU_ASSERT_EQUAL(ebitmap_get_bit(&e, 50), 1);
169
170 CU_ASSERT_EQUAL(ebitmap_set_bit(&e, 1023, 1), 0);
171 CU_ASSERT_FALSE(ebitmap_is_empty(&e));
172 CU_ASSERT_EQUAL(ebitmap_cardinality(&e), 4);
173 CU_ASSERT_EQUAL(ebitmap_highest_set_bit(&e), 1023);
174 CU_ASSERT_EQUAL(ebitmap_get_bit(&e, 1023), 1);
175
176 CU_ASSERT_EQUAL(ebitmap_set_bit(&e, 1024, 1), 0);
177 CU_ASSERT_FALSE(ebitmap_is_empty(&e));
178 CU_ASSERT_EQUAL(ebitmap_cardinality(&e), 5);
179 CU_ASSERT_EQUAL(ebitmap_highest_set_bit(&e), 1024);
180 CU_ASSERT_EQUAL(ebitmap_get_bit(&e, 1024), 1);
181
182 CU_ASSERT_EQUAL(ebitmap_set_bit(&e, 1050, 1), 0);
183 CU_ASSERT_FALSE(ebitmap_is_empty(&e));
184 CU_ASSERT_EQUAL(ebitmap_cardinality(&e), 6);
185 CU_ASSERT_EQUAL(ebitmap_highest_set_bit(&e), 1050);
186 CU_ASSERT_EQUAL(ebitmap_get_bit(&e, 1050), 1);
187
188 {
189 ebitmap_node_t *n;
190 unsigned int bit, count;
191
192 /* iterate all allocated bits */
193 count = 0;
194 ebitmap_for_each_bit(&e, n, bit) {
195 CU_ASSERT( bit < 64 ||
196 (64 <= bit && bit < 128) ||
197 (960 <= bit && bit < 1024) ||
198 (1024 <= bit && bit < 1088));
199 count++;
200 }
201 CU_ASSERT_EQUAL(count, 4 * 64);
202
203 count = 0;
204 ebitmap_for_each_positive_bit(&e, n, bit) {
205 CU_ASSERT(bit == 10 ||
206 bit == 50 ||
207 bit == 100 ||
208 bit == 1023 ||
209 bit == 1024 ||
210 bit == 1050);
211 CU_ASSERT_EQUAL(ebitmap_get_bit(&e, bit), 1);
212 count++;
213 }
214 CU_ASSERT_EQUAL(count, 6);
215 }
216
217 CU_ASSERT_EQUAL(ebitmap_set_bit(&e, 1024, 0), 0);
218 CU_ASSERT_FALSE(ebitmap_is_empty(&e));
219 CU_ASSERT_EQUAL(ebitmap_cardinality(&e), 5);
220 CU_ASSERT_EQUAL(ebitmap_highest_set_bit(&e), 1050);
221 CU_ASSERT_EQUAL(ebitmap_get_bit(&e, 1024), 0);
222
223 CU_ASSERT_EQUAL(ebitmap_set_bit(&e, 1050, 0), 0);
224 CU_ASSERT_FALSE(ebitmap_is_empty(&e));
225 CU_ASSERT_EQUAL(ebitmap_cardinality(&e), 4);
226 CU_ASSERT_EQUAL(ebitmap_highest_set_bit(&e), 1023);
227 CU_ASSERT_EQUAL(ebitmap_get_bit(&e, 1050), 0);
228
229 CU_ASSERT_EQUAL(ebitmap_set_bit(&e, 100, 0), 0);
230 CU_ASSERT_FALSE(ebitmap_is_empty(&e));
231 CU_ASSERT_EQUAL(ebitmap_cardinality(&e), 3);
232 CU_ASSERT_EQUAL(ebitmap_highest_set_bit(&e), 1023);
233 CU_ASSERT_EQUAL(ebitmap_get_bit(&e, 100), 0);
234
235 CU_ASSERT_EQUAL(ebitmap_set_bit(&e, 10, 0), 0);
236 CU_ASSERT_FALSE(ebitmap_is_empty(&e));
237 CU_ASSERT_EQUAL(ebitmap_cardinality(&e), 2);
238 CU_ASSERT_EQUAL(ebitmap_highest_set_bit(&e), 1023);
239 CU_ASSERT_EQUAL(ebitmap_get_bit(&e, 10), 0);
240
241 CU_ASSERT_EQUAL(ebitmap_set_bit(&e, 50, 0), 0);
242 CU_ASSERT_FALSE(ebitmap_is_empty(&e));
243 CU_ASSERT_EQUAL(ebitmap_cardinality(&e), 1);
244 CU_ASSERT_EQUAL(ebitmap_highest_set_bit(&e), 1023);
245 CU_ASSERT_EQUAL(ebitmap_get_bit(&e, 50), 0);
246
247 CU_ASSERT_EQUAL(ebitmap_set_bit(&e, 1023, 0), 0);
248 CU_ASSERT_TRUE(ebitmap_is_empty(&e));
249 CU_ASSERT_EQUAL(ebitmap_cardinality(&e), 0);
250 CU_ASSERT_EQUAL(ebitmap_highest_set_bit(&e), 0);
251 CU_ASSERT_EQUAL(ebitmap_get_bit(&e, 1023), 0);
252
253 ebitmap_destroy(&e);
254 }
255
test_ebitmap_init_range(void)256 static void test_ebitmap_init_range(void)
257 {
258 ebitmap_t e1, e2, e3, e4, e5, e6;
259
260 CU_ASSERT_EQUAL(ebitmap_init_range(&e1, 0, 0), 0);
261 CU_ASSERT_EQUAL(ebitmap_highest_set_bit(&e1), 0);
262 CU_ASSERT_EQUAL(ebitmap_cardinality(&e1), 1);
263
264 CU_ASSERT_EQUAL(ebitmap_init_range(&e2, 0, 5), 0);
265 CU_ASSERT_EQUAL(ebitmap_highest_set_bit(&e2), 5);
266 CU_ASSERT_EQUAL(ebitmap_cardinality(&e2), 6);
267
268 CU_ASSERT_EQUAL(ebitmap_init_range(&e3, 20, 100), 0);
269 CU_ASSERT_EQUAL(ebitmap_highest_set_bit(&e3), 100);
270 CU_ASSERT_EQUAL(ebitmap_cardinality(&e3), 81);
271
272 CU_ASSERT_EQUAL(ebitmap_init_range(&e4, 100, 400), 0);
273 CU_ASSERT_EQUAL(ebitmap_highest_set_bit(&e4), 400);
274 CU_ASSERT_EQUAL(ebitmap_cardinality(&e4), 301);
275
276 CU_ASSERT_EQUAL(ebitmap_init_range(&e5, 10, 5), -EINVAL);
277 CU_ASSERT_EQUAL(ebitmap_init_range(&e6, 0, UINT32_MAX), -EOVERFLOW);
278
279 ebitmap_destroy(&e6);
280 ebitmap_destroy(&e5);
281 ebitmap_destroy(&e4);
282 ebitmap_destroy(&e3);
283 ebitmap_destroy(&e2);
284 ebitmap_destroy(&e1);
285 }
286
test_ebitmap_or(void)287 static void test_ebitmap_or(void)
288 {
289 ebitmap_t e1, e2, e3, e4;
290
291 ebitmap_init(&e1);
292 ebitmap_init(&e2);
293 ebitmap_init(&e3);
294 ebitmap_init(&e4);
295
296 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 10, 1), 0);
297 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 100, 1), 0);
298 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 101, 1), 0);
299 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 318, 1), 0);
300 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 319, 1), 0);
301 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 383, 1), 0);
302 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 384, 1), 0);
303 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 449, 1), 0);
304 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 1013, 1), 0);
305
306 CU_ASSERT_EQUAL(ebitmap_set_bit(&e2, 11, 1), 0);
307 CU_ASSERT_EQUAL(ebitmap_set_bit(&e2, 101, 1), 0);
308 CU_ASSERT_EQUAL(ebitmap_set_bit(&e2, 430, 1), 0);
309 CU_ASSERT_EQUAL(ebitmap_set_bit(&e2, 665, 1), 0);
310
311 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 10, 1), 0);
312 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 11, 1), 0);
313 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 100, 1), 0);
314 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 101, 1), 0);
315 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 318, 1), 0);
316 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 319, 1), 0);
317 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 383, 1), 0);
318 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 384, 1), 0);
319 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 430, 1), 0);
320 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 449, 1), 0);
321 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 665, 1), 0);
322 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 1013, 1), 0);
323
324 {
325 ebitmap_t dst;
326
327 CU_ASSERT_EQUAL(ebitmap_or(&dst, &e1, &e1), 0);
328 CU_ASSERT(ebitmap_cmp(&dst, &e1));
329
330 ebitmap_destroy(&dst);
331 }
332
333 {
334 ebitmap_t dst;
335
336 CU_ASSERT_EQUAL(ebitmap_or(&dst, &e2, &e2), 0);
337 CU_ASSERT(ebitmap_cmp(&dst, &e2));
338
339 ebitmap_destroy(&dst);
340 }
341
342 {
343 ebitmap_t dst;
344
345 CU_ASSERT_EQUAL(ebitmap_or(&dst, &e1, &e2), 0);
346 CU_ASSERT(ebitmap_cmp(&dst, &e3));
347
348 ebitmap_destroy(&dst);
349 }
350
351 {
352 ebitmap_t dst;
353
354 CU_ASSERT_EQUAL(ebitmap_or(&dst, &e3, &e3), 0);
355 CU_ASSERT(ebitmap_cmp(&dst, &e3));
356
357 ebitmap_destroy(&dst);
358 }
359
360 {
361 ebitmap_t dst;
362
363 CU_ASSERT_EQUAL(ebitmap_or(&dst, &e3, &e4), 0);
364 CU_ASSERT(ebitmap_cmp(&dst, &e3));
365
366 ebitmap_destroy(&dst);
367 }
368
369 {
370 ebitmap_t dst;
371
372 CU_ASSERT_EQUAL(ebitmap_or(&dst, &e4, &e4), 0);
373 CU_ASSERT(ebitmap_cmp(&dst, &e4));
374
375 ebitmap_destroy(&dst);
376 }
377
378 ebitmap_destroy(&e4);
379 ebitmap_destroy(&e3);
380 ebitmap_destroy(&e2);
381 ebitmap_destroy(&e1);
382 }
383
test_ebitmap_and(void)384 static void test_ebitmap_and(void)
385 {
386 {
387 ebitmap_t e1, e2, e12, e3, e4;
388
389 ebitmap_init(&e1);
390 ebitmap_init(&e2);
391 ebitmap_init(&e12);
392 ebitmap_init(&e3);
393 ebitmap_init(&e4);
394
395 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 10, 1), 0);
396 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 100, 1), 0);
397 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 101, 1), 0);
398 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 318, 1), 0);
399 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 319, 1), 0);
400 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 383, 1), 0);
401 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 384, 1), 0);
402 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 449, 1), 0);
403 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 1013, 1), 0);
404
405 CU_ASSERT_EQUAL(ebitmap_set_bit(&e2, 11, 1), 0);
406 CU_ASSERT_EQUAL(ebitmap_set_bit(&e2, 101, 1), 0);
407 CU_ASSERT_EQUAL(ebitmap_set_bit(&e2, 319, 1), 0);
408 CU_ASSERT_EQUAL(ebitmap_set_bit(&e2, 665, 1), 0);
409
410 CU_ASSERT_EQUAL(ebitmap_set_bit(&e12, 101, 1), 0);
411 CU_ASSERT_EQUAL(ebitmap_set_bit(&e12, 319, 1), 0);
412
413 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 10, 1), 0);
414 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 11, 1), 0);
415 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 100, 1), 0);
416 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 101, 1), 0);
417 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 318, 1), 0);
418 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 319, 1), 0);
419 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 383, 1), 0);
420 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 384, 1), 0);
421 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 430, 1), 0);
422 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 449, 1), 0);
423 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 665, 1), 0);
424 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 1013, 1), 0);
425
426 {
427 ebitmap_t dst;
428
429 CU_ASSERT_EQUAL(ebitmap_and(&dst, &e1, &e1), 0);
430 CU_ASSERT(ebitmap_cmp(&dst, &e1));
431
432 ebitmap_destroy(&dst);
433 }
434
435 {
436 ebitmap_t dst;
437
438 CU_ASSERT_EQUAL(ebitmap_and(&dst, &e2, &e2), 0);
439 CU_ASSERT(ebitmap_cmp(&dst, &e2));
440
441 ebitmap_destroy(&dst);
442 }
443
444 {
445 ebitmap_t dst;
446
447 CU_ASSERT_EQUAL(ebitmap_and(&dst, &e1, &e2), 0);
448 CU_ASSERT(ebitmap_cmp(&dst, &e12));
449
450 ebitmap_destroy(&dst);
451 }
452
453 {
454 ebitmap_t dst;
455
456 CU_ASSERT_EQUAL(ebitmap_and(&dst, &e3, &e3), 0);
457 CU_ASSERT(ebitmap_cmp(&dst, &e3));
458
459 ebitmap_destroy(&dst);
460 }
461
462 {
463 ebitmap_t dst;
464
465 CU_ASSERT_EQUAL(ebitmap_and(&dst, &e1, &e3), 0);
466 CU_ASSERT(ebitmap_cmp(&dst, &e1));
467
468 ebitmap_destroy(&dst);
469 }
470
471 {
472 ebitmap_t dst;
473
474 CU_ASSERT_EQUAL(ebitmap_and(&dst, &e2, &e3), 0);
475 CU_ASSERT(ebitmap_cmp(&dst, &e2));
476
477 ebitmap_destroy(&dst);
478 }
479
480 {
481 ebitmap_t dst;
482
483 CU_ASSERT_EQUAL(ebitmap_and(&dst, &e4, &e4), 0);
484 CU_ASSERT(ebitmap_cmp(&dst, &e4));
485
486 ebitmap_destroy(&dst);
487 }
488
489 {
490 ebitmap_t dst;
491
492 CU_ASSERT_EQUAL(ebitmap_and(&dst, &e3, &e4), 0);
493 CU_ASSERT(ebitmap_cmp(&dst, &e4));
494
495 ebitmap_destroy(&dst);
496 }
497
498 ebitmap_destroy(&e4);
499 ebitmap_destroy(&e3);
500 ebitmap_destroy(&e12);
501 ebitmap_destroy(&e2);
502 ebitmap_destroy(&e1);
503 }
504
505 {
506 ebitmap_t e5;
507 ebitmap_t e6;
508 ebitmap_t e56;
509 ebitmap_t dst;
510
511 ebitmap_init(&e5);
512 ebitmap_init(&e6);
513 ebitmap_init(&e56);
514
515 CU_ASSERT_EQUAL(ebitmap_set_bit(&e5, 63, 1), 0);
516 CU_ASSERT_EQUAL(ebitmap_set_bit(&e5, 191, 1), 0);
517 CU_ASSERT_EQUAL(ebitmap_set_bit(&e5, 192, 1), 0);
518 CU_ASSERT_EQUAL(ebitmap_set_bit(&e5, 318, 1), 0);
519 CU_ASSERT_EQUAL(ebitmap_set_bit(&e5, 319, 1), 0);
520
521 CU_ASSERT_EQUAL(ebitmap_set_bit(&e6, 64, 1), 0);
522 CU_ASSERT_EQUAL(ebitmap_set_bit(&e6, 192, 1), 0);
523 CU_ASSERT_EQUAL(ebitmap_set_bit(&e6, 319, 1), 0);
524 CU_ASSERT_EQUAL(ebitmap_set_bit(&e6, 320, 1), 0);
525
526 CU_ASSERT_EQUAL(ebitmap_set_bit(&e56, 192, 1), 0);
527 CU_ASSERT_EQUAL(ebitmap_set_bit(&e56, 319, 1), 0);
528
529 CU_ASSERT_EQUAL(ebitmap_and(&dst, &e5, &e6), 0);
530 CU_ASSERT(ebitmap_cmp(&dst, &e56));
531
532 ebitmap_destroy(&dst);
533 ebitmap_destroy(&e56);
534 ebitmap_destroy(&e6);
535 ebitmap_destroy(&e5);
536 }
537 }
538
test_ebitmap_xor(void)539 static void test_ebitmap_xor(void)
540 {
541 {
542 ebitmap_t e1, e2, e3, e4;
543
544 ebitmap_init(&e1);
545 ebitmap_init(&e2);
546 ebitmap_init(&e3);
547 ebitmap_init(&e4);
548
549 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 1, 1), 0);
550 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 5, 1), 0);
551 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 10, 1), 0);
552
553 CU_ASSERT_EQUAL(ebitmap_set_bit(&e2, 1, 1), 0);
554 CU_ASSERT_EQUAL(ebitmap_set_bit(&e2, 3, 1), 0);
555 CU_ASSERT_EQUAL(ebitmap_set_bit(&e2, 6, 1), 0);
556 CU_ASSERT_EQUAL(ebitmap_set_bit(&e2, 9, 1), 0);
557
558 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 3, 1), 0);
559 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 5, 1), 0);
560 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 6, 1), 0);
561 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 9, 1), 0);
562 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 10, 1), 0);
563
564 {
565 ebitmap_t dst1, dst2;
566
567 CU_ASSERT_EQUAL(ebitmap_xor(&dst1, &e1, &e1), 0);
568 CU_ASSERT(ebitmap_cmp(&dst1, &e4));
569 CU_ASSERT_EQUAL(ebitmap_xor(&dst2, &dst1, &e1), 0);
570 CU_ASSERT(ebitmap_cmp(&dst2, &e1));
571
572 ebitmap_destroy(&dst2);
573 ebitmap_destroy(&dst1);
574 }
575
576 {
577 ebitmap_t dst;
578
579 CU_ASSERT_EQUAL(ebitmap_xor(&dst, &e2, &e2), 0);
580 CU_ASSERT(ebitmap_cmp(&dst, &e4));
581
582 ebitmap_destroy(&dst);
583 }
584
585 {
586 ebitmap_t dst;
587
588 CU_ASSERT_EQUAL(ebitmap_xor(&dst, &e3, &e3), 0);
589 CU_ASSERT(ebitmap_cmp(&dst, &e4));
590
591 ebitmap_destroy(&dst);
592 }
593
594 {
595 ebitmap_t dst;
596
597 CU_ASSERT_EQUAL(ebitmap_xor(&dst, &e4, &e4), 0);
598 CU_ASSERT(ebitmap_cmp(&dst, &e4));
599
600 ebitmap_destroy(&dst);
601 }
602
603 {
604 ebitmap_t dst;
605
606 CU_ASSERT_EQUAL(ebitmap_xor(&dst, &e1, &e2), 0);
607 CU_ASSERT(ebitmap_cmp(&dst, &e3));
608
609 ebitmap_destroy(&dst);
610 }
611
612 {
613 ebitmap_t dst;
614
615 CU_ASSERT_EQUAL(ebitmap_xor(&dst, &e2, &e4), 0);
616 CU_ASSERT(ebitmap_cmp(&dst, &e2));
617
618 ebitmap_destroy(&dst);
619 }
620
621 ebitmap_destroy(&e4);
622 ebitmap_destroy(&e3);
623 ebitmap_destroy(&e2);
624 ebitmap_destroy(&e1);
625 }
626
627 {
628 ebitmap_t e5;
629 ebitmap_t e6;
630 ebitmap_t e56;
631 ebitmap_t dst;
632
633 ebitmap_init(&e5);
634 ebitmap_init(&e6);
635 ebitmap_init(&e56);
636
637 CU_ASSERT_EQUAL(ebitmap_set_bit(&e5, 63, 1), 0);
638 CU_ASSERT_EQUAL(ebitmap_set_bit(&e5, 191, 1), 0);
639 CU_ASSERT_EQUAL(ebitmap_set_bit(&e5, 192, 1), 0);
640 CU_ASSERT_EQUAL(ebitmap_set_bit(&e5, 318, 1), 0);
641 CU_ASSERT_EQUAL(ebitmap_set_bit(&e5, 319, 1), 0);
642
643 CU_ASSERT_EQUAL(ebitmap_set_bit(&e6, 64, 1), 0);
644 CU_ASSERT_EQUAL(ebitmap_set_bit(&e6, 192, 1), 0);
645 CU_ASSERT_EQUAL(ebitmap_set_bit(&e6, 319, 1), 0);
646 CU_ASSERT_EQUAL(ebitmap_set_bit(&e6, 320, 1), 0);
647
648 CU_ASSERT_EQUAL(ebitmap_set_bit(&e56, 63, 1), 0);
649 CU_ASSERT_EQUAL(ebitmap_set_bit(&e56, 64, 1), 0);
650 CU_ASSERT_EQUAL(ebitmap_set_bit(&e56, 191, 1), 0);
651 CU_ASSERT_EQUAL(ebitmap_set_bit(&e56, 318, 1), 0);
652 CU_ASSERT_EQUAL(ebitmap_set_bit(&e56, 320, 1), 0);
653
654 CU_ASSERT_EQUAL(ebitmap_xor(&dst, &e5, &e6), 0);
655 CU_ASSERT(ebitmap_cmp(&dst, &e56));
656
657 ebitmap_destroy(&dst);
658 ebitmap_destroy(&e56);
659 ebitmap_destroy(&e6);
660 ebitmap_destroy(&e5);
661 }
662 }
663
test_ebitmap_not(void)664 static void test_ebitmap_not(void)
665 {
666 {
667 ebitmap_t e1, e2, e3, e4;
668
669 ebitmap_init(&e1);
670 ebitmap_init(&e2);
671 ebitmap_init(&e3);
672 ebitmap_init(&e4);
673
674 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 0, 1), 0);
675 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 1, 1), 0);
676 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 5, 1), 0);
677 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 10, 1), 0);
678
679 CU_ASSERT_EQUAL(ebitmap_set_bit(&e2, 2, 1), 0);
680 CU_ASSERT_EQUAL(ebitmap_set_bit(&e2, 3, 1), 0);
681 CU_ASSERT_EQUAL(ebitmap_set_bit(&e2, 4, 1), 0);
682 CU_ASSERT_EQUAL(ebitmap_set_bit(&e2, 6, 1), 0);
683 CU_ASSERT_EQUAL(ebitmap_set_bit(&e2, 7, 1), 0);
684 CU_ASSERT_EQUAL(ebitmap_set_bit(&e2, 8, 1), 0);
685 CU_ASSERT_EQUAL(ebitmap_set_bit(&e2, 9, 1), 0);
686
687 {
688 ebitmap_t dst1, dst2;
689
690 CU_ASSERT_EQUAL(ebitmap_not(&dst1, &e3, 10), 0);
691 CU_ASSERT_EQUAL(ebitmap_highest_set_bit(&dst1), 9);
692 CU_ASSERT_EQUAL(ebitmap_cardinality(&dst1), 10);
693
694 CU_ASSERT_EQUAL(ebitmap_not(&dst2, &dst1, 10), 0);
695 CU_ASSERT(ebitmap_cmp(&dst2, &e3));
696
697 ebitmap_destroy(&dst2);
698 ebitmap_destroy(&dst1);
699 }
700
701 {
702 ebitmap_t dst1, dst2;
703
704 CU_ASSERT_EQUAL(ebitmap_not(&dst1, &e1, 11), 0);
705 CU_ASSERT(ebitmap_cmp(&dst1, &e2));
706 CU_ASSERT_EQUAL(ebitmap_not(&dst2, &dst1, 11), 0);
707 CU_ASSERT(ebitmap_cmp(&dst2, &e1));
708
709 ebitmap_destroy(&dst2);
710 ebitmap_destroy(&dst1);
711 }
712
713 {
714 ebitmap_t dst;
715
716 CU_ASSERT_EQUAL(ebitmap_not(&dst, &e1, 8), 0);
717 CU_ASSERT_EQUAL(ebitmap_highest_set_bit(&dst), 7);
718 CU_ASSERT_EQUAL(ebitmap_cardinality(&dst), 5);
719
720 ebitmap_destroy(&dst);
721 }
722
723 {
724 ebitmap_t dst;
725
726 CU_ASSERT_EQUAL(ebitmap_not(&dst, &e1, 12), 0);
727 CU_ASSERT_EQUAL(ebitmap_highest_set_bit(&dst), 11);
728 CU_ASSERT_EQUAL(ebitmap_cardinality(&dst), 8);
729
730 ebitmap_destroy(&dst);
731 }
732
733 ebitmap_destroy(&e3);
734 ebitmap_destroy(&e2);
735 ebitmap_destroy(&e1);
736 }
737
738 {
739 ebitmap_t e5;
740 ebitmap_t e5not;
741 ebitmap_node_t *n;
742 unsigned int bit;
743
744 ebitmap_init(&e5);
745 ebitmap_init(&e5not);
746
747 CU_ASSERT_EQUAL(ebitmap_set_bit(&e5, 63, 1), 0);
748 CU_ASSERT_EQUAL(ebitmap_set_bit(&e5, 191, 1), 0);
749 CU_ASSERT_EQUAL(ebitmap_set_bit(&e5, 192, 1), 0);
750 CU_ASSERT_EQUAL(ebitmap_set_bit(&e5, 318, 1), 0);
751 CU_ASSERT_EQUAL(ebitmap_set_bit(&e5, 319, 1), 0);
752
753 for (bit = 0; bit < 317; bit++)
754 CU_ASSERT_EQUAL(ebitmap_set_bit(&e5not, bit, 1), 0);
755 ebitmap_for_each_positive_bit(&e5, n, bit)
756 CU_ASSERT_EQUAL(ebitmap_set_bit(&e5not, bit, 0), 0);
757
758 {
759 ebitmap_t dst;
760
761 CU_ASSERT_EQUAL(ebitmap_not(&dst, &e5, 317), 0);
762 CU_ASSERT(ebitmap_cmp(&dst, &e5not));
763
764 ebitmap_destroy(&dst);
765 }
766
767 {
768 ebitmap_t dst;
769
770 CU_ASSERT_EQUAL(ebitmap_not(&dst, &e5, 318), 0);
771 CU_ASSERT_FALSE(ebitmap_cmp(&dst, &e5not));
772
773 CU_ASSERT_EQUAL(ebitmap_set_bit(&e5not, 317, 1), 0);
774 CU_ASSERT(ebitmap_cmp(&dst, &e5not));
775
776 ebitmap_destroy(&dst);
777 }
778
779 {
780 ebitmap_t dst;
781
782 CU_ASSERT_EQUAL(ebitmap_not(&dst, &e5, 319), 0);
783 CU_ASSERT(ebitmap_cmp(&dst, &e5not));
784
785 ebitmap_destroy(&dst);
786 }
787
788 ebitmap_destroy(&e5not);
789 ebitmap_destroy(&e5);
790 }
791 }
792
test_ebitmap_andnot(void)793 static void test_ebitmap_andnot(void)
794 {
795 {
796 ebitmap_t e1, e2, e12, e3, e4;
797
798 ebitmap_init(&e1);
799 ebitmap_init(&e2);
800 ebitmap_init(&e12);
801 ebitmap_init(&e3);
802 ebitmap_init(&e4);
803
804 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 10, 1), 0);
805 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 100, 1), 0);
806 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 101, 1), 0);
807 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 430, 1), 0);
808 CU_ASSERT_EQUAL(ebitmap_set_bit(&e1, 1013, 1), 0);
809
810 CU_ASSERT_EQUAL(ebitmap_set_bit(&e2, 11, 1), 0);
811 CU_ASSERT_EQUAL(ebitmap_set_bit(&e2, 101, 1), 0);
812 CU_ASSERT_EQUAL(ebitmap_set_bit(&e2, 665, 1), 0);
813
814 CU_ASSERT_EQUAL(ebitmap_set_bit(&e12, 10, 1), 0);
815 CU_ASSERT_EQUAL(ebitmap_set_bit(&e12, 100, 1), 0);
816 CU_ASSERT_EQUAL(ebitmap_set_bit(&e12, 430, 1), 0);
817 CU_ASSERT_EQUAL(ebitmap_set_bit(&e12, 1013, 1), 0);
818
819 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 10, 1), 0);
820 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 11, 1), 0);
821 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 100, 1), 0);
822 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 101, 1), 0);
823 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 430, 1), 0);
824 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 665, 1), 0);
825 CU_ASSERT_EQUAL(ebitmap_set_bit(&e3, 1013, 1), 0);
826
827 {
828 ebitmap_t dst;
829
830 CU_ASSERT_EQUAL(ebitmap_andnot(&dst, &e1, &e1, 1024), 0);
831 CU_ASSERT(ebitmap_cmp(&dst, &e4));
832
833 ebitmap_destroy(&dst);
834 }
835
836 {
837 ebitmap_t dst;
838
839 CU_ASSERT_EQUAL(ebitmap_andnot(&dst, &e2, &e2, 1024), 0);
840 CU_ASSERT(ebitmap_cmp(&dst, &e4));
841
842 ebitmap_destroy(&dst);
843 }
844
845 {
846 ebitmap_t dst;
847
848 CU_ASSERT_EQUAL(ebitmap_andnot(&dst, &e1, &e2, 1024), 0);
849 CU_ASSERT(ebitmap_cmp(&dst, &e12));
850
851 ebitmap_destroy(&dst);
852 }
853
854 {
855 ebitmap_t dst;
856
857 CU_ASSERT_EQUAL(ebitmap_andnot(&dst, &e3, &e3, 1024), 0);
858 CU_ASSERT(ebitmap_cmp(&dst, &e4));
859
860 ebitmap_destroy(&dst);
861 }
862
863 {
864 ebitmap_t dst;
865
866 CU_ASSERT_EQUAL(ebitmap_andnot(&dst, &e1, &e3, 1024), 0);
867 CU_ASSERT(ebitmap_cmp(&dst, &e4));
868
869 ebitmap_destroy(&dst);
870 }
871
872 {
873 ebitmap_t dst;
874
875 CU_ASSERT_EQUAL(ebitmap_andnot(&dst, &e2, &e12, 1024), 0);
876 CU_ASSERT(ebitmap_cmp(&dst, &e2));
877
878 ebitmap_destroy(&dst);
879 }
880
881 {
882 ebitmap_t dst;
883
884 CU_ASSERT_EQUAL(ebitmap_andnot(&dst, &e4, &e4, 1024), 0);
885 CU_ASSERT(ebitmap_cmp(&dst, &e4));
886
887 ebitmap_destroy(&dst);
888 }
889
890 {
891 ebitmap_t dst;
892
893 CU_ASSERT_EQUAL(ebitmap_andnot(&dst, &e3, &e4, 1024), 0);
894 CU_ASSERT(ebitmap_cmp(&dst, &e3));
895
896 ebitmap_destroy(&dst);
897 }
898
899 ebitmap_destroy(&e4);
900 ebitmap_destroy(&e3);
901 ebitmap_destroy(&e12);
902 ebitmap_destroy(&e2);
903 ebitmap_destroy(&e1);
904 }
905
906 {
907 ebitmap_t e5;
908 ebitmap_t e6;
909 ebitmap_t e56;
910
911 ebitmap_init(&e5);
912 ebitmap_init(&e6);
913 ebitmap_init(&e56);
914
915 CU_ASSERT_EQUAL(ebitmap_set_bit(&e5, 63, 1), 0);
916 CU_ASSERT_EQUAL(ebitmap_set_bit(&e5, 191, 1), 0);
917 CU_ASSERT_EQUAL(ebitmap_set_bit(&e5, 192, 1), 0);
918 CU_ASSERT_EQUAL(ebitmap_set_bit(&e5, 318, 1), 0);
919 CU_ASSERT_EQUAL(ebitmap_set_bit(&e5, 319, 1), 0);
920
921 CU_ASSERT_EQUAL(ebitmap_set_bit(&e6, 64, 1), 0);
922 CU_ASSERT_EQUAL(ebitmap_set_bit(&e6, 192, 1), 0);
923 CU_ASSERT_EQUAL(ebitmap_set_bit(&e6, 319, 1), 0);
924 CU_ASSERT_EQUAL(ebitmap_set_bit(&e6, 320, 1), 0);
925
926 CU_ASSERT_EQUAL(ebitmap_set_bit(&e56, 63, 1), 0);
927 CU_ASSERT_EQUAL(ebitmap_set_bit(&e56, 191, 1), 0);
928
929 {
930 ebitmap_t dst;
931
932 CU_ASSERT_EQUAL(ebitmap_andnot(&dst, &e5, &e6, 317), 0);
933 CU_ASSERT(ebitmap_cmp(&dst, &e56));
934
935 ebitmap_destroy(&dst);
936 }
937
938 {
939 ebitmap_t dst;
940
941 CU_ASSERT_EQUAL(ebitmap_andnot(&dst, &e5, &e6, 318), 0);
942 CU_ASSERT(ebitmap_cmp(&dst, &e56));
943
944 ebitmap_destroy(&dst);
945 }
946
947 {
948 ebitmap_t dst;
949
950 CU_ASSERT_EQUAL(ebitmap_andnot(&dst, &e5, &e6, 319), 0);
951 CU_ASSERT_FALSE(ebitmap_cmp(&dst, &e56));
952
953 CU_ASSERT_EQUAL(ebitmap_set_bit(&e56, 318, 1), 0);
954 CU_ASSERT(ebitmap_cmp(&dst, &e56));
955
956 ebitmap_destroy(&dst);
957 }
958
959 {
960 ebitmap_t dst;
961
962 CU_ASSERT_EQUAL(ebitmap_andnot(&dst, &e5, &e6, 320), 0);
963 CU_ASSERT(ebitmap_cmp(&dst, &e56));
964
965 ebitmap_destroy(&dst);
966 }
967
968 ebitmap_destroy(&e56);
969 ebitmap_destroy(&e6);
970 ebitmap_destroy(&e5);
971 }
972 }
973
test_ebitmap__random_impl(unsigned int length,int set_chance)974 static void test_ebitmap__random_impl(unsigned int length, int set_chance)
975 {
976 ebitmap_t e1, e2, dst_cpy, dst_or, dst_and, dst_xor1, dst_xor2, dst_not1, dst_not2, dst_andnot;
977 unsigned int i;
978
979 CU_ASSERT_EQUAL(ebitmap_init_random(&e1, length, set_chance), 0);
980 CU_ASSERT_EQUAL(ebitmap_init_random(&e2, length, set_chance), 0);
981
982 CU_ASSERT_EQUAL(ebitmap_cpy(&dst_cpy, &e1), 0);
983 CU_ASSERT(ebitmap_cmp(&dst_cpy, &e1));
984
985 CU_ASSERT_EQUAL(ebitmap_or(&dst_or, &e1, &e2), 0);
986 for (i = 0; i < length; i++)
987 CU_ASSERT_EQUAL(ebitmap_get_bit(&dst_or, i), ebitmap_get_bit(&e1, i) | ebitmap_get_bit(&e2, i));
988
989 CU_ASSERT_EQUAL(ebitmap_and(&dst_and, &e1, &e2), 0);
990 for (i = 0; i < length; i++)
991 CU_ASSERT_EQUAL(ebitmap_get_bit(&dst_and, i), ebitmap_get_bit(&e1, i) & ebitmap_get_bit(&e2, i));
992
993 CU_ASSERT_EQUAL(ebitmap_xor(&dst_xor1, &e1, &e2), 0);
994 for (i = 0; i < length; i++)
995 CU_ASSERT_EQUAL(ebitmap_get_bit(&dst_xor1, i), ebitmap_get_bit(&e1, i) ^ ebitmap_get_bit(&e2, i));
996 CU_ASSERT_EQUAL(ebitmap_xor(&dst_xor2, &dst_xor1, &e2), 0);
997 CU_ASSERT(ebitmap_cmp(&dst_xor2, &e1));
998
999 CU_ASSERT_EQUAL(ebitmap_not(&dst_not1, &e1, length), 0);
1000 for (i = 0; i < length; i++)
1001 CU_ASSERT_EQUAL(ebitmap_get_bit(&dst_not1, i), !ebitmap_get_bit(&e1, i));
1002 CU_ASSERT_EQUAL(ebitmap_not(&dst_not2, &dst_not1, length), 0);
1003 CU_ASSERT(ebitmap_cmp(&dst_not2, &e1));
1004
1005 CU_ASSERT_EQUAL(ebitmap_andnot(&dst_andnot, &e1, &e2, length), 0);
1006 for (i = 0; i < length; i++)
1007 CU_ASSERT_EQUAL(ebitmap_get_bit(&dst_andnot, i), ebitmap_get_bit(&e1, i) & !ebitmap_get_bit(&e2, i));
1008
1009 ebitmap_destroy(&dst_andnot);
1010 ebitmap_destroy(&dst_not2);
1011 ebitmap_destroy(&dst_not1);
1012 ebitmap_destroy(&dst_xor2);
1013 ebitmap_destroy(&dst_xor1);
1014 ebitmap_destroy(&dst_and);
1015 ebitmap_destroy(&dst_or);
1016 ebitmap_destroy(&dst_cpy);
1017 ebitmap_destroy(&e2);
1018 ebitmap_destroy(&e1);
1019 }
1020
test_ebitmap__random(void)1021 static void test_ebitmap__random(void)
1022 {
1023 unsigned int i;
1024
1025 for (i = 0; i < RANDOM_ROUNDS; i++)
1026 test_ebitmap__random_impl(5, 10);
1027
1028 for (i = 0; i < RANDOM_ROUNDS; i++)
1029 test_ebitmap__random_impl(5, 90);
1030
1031 for (i = 0; i < RANDOM_ROUNDS; i++)
1032 test_ebitmap__random_impl(1024, 50);
1033
1034 for (i = 0; i < RANDOM_ROUNDS; i++)
1035 test_ebitmap__random_impl(8000, 5);
1036
1037 for (i = 0; i < RANDOM_ROUNDS; i++)
1038 test_ebitmap__random_impl(8000, 95);
1039 }
1040
1041 /*
1042 * External hooks
1043 */
1044
ebitmap_test_init(void)1045 int ebitmap_test_init(void)
1046 {
1047 srandom(time(NULL));
1048
1049 /* silence ebitmap_set_bit() failure message */
1050 sepol_debug(0);
1051
1052 return 0;
1053 }
1054
ebitmap_test_cleanup(void)1055 int ebitmap_test_cleanup(void)
1056 {
1057 return 0;
1058 }
1059
1060 #define ADD_TEST(name) \
1061 do { \
1062 if (NULL == CU_add_test(suite, #name, test_##name)) { \
1063 return CU_get_error(); \
1064 } \
1065 } while (0)
1066
ebitmap_add_tests(CU_pSuite suite)1067 int ebitmap_add_tests(CU_pSuite suite)
1068 {
1069 ADD_TEST(ebitmap_init_destroy);
1070 ADD_TEST(ebitmap_cmp);
1071 ADD_TEST(ebitmap_set_and_get);
1072 ADD_TEST(ebitmap_init_range);
1073 ADD_TEST(ebitmap_or);
1074 ADD_TEST(ebitmap_and);
1075 ADD_TEST(ebitmap_xor);
1076 ADD_TEST(ebitmap_not);
1077 ADD_TEST(ebitmap_andnot);
1078 ADD_TEST(ebitmap__random);
1079 return 0;
1080 }
1081