Debian Codegraph @

lang-maps/test/libbmtest.c

raw
1 /*
2 BitMagic Library C - unit test.
3 */
4
5
6 /*
7 Copyright(c) 2002-2018 Anatoliy Kuznetsov(anatoliy_kuznetsov at yahoo.com)
8
9 Licensed under the Apache License, Version 2.0 (the "License");
10 you may not use this file except in compliance with the License.
11 You may obtain a copy of the License at
12
13 http://www.apache.org/licenses/LICENSE-2.0
14
15 Unless required by applicable law or agreed to in writing, software
16 distributed under the License is distributed on an "AS IS" BASIS,
17 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 See the License for the specific language governing permissions and
19 limitations under the License.
20
21 For more information please visit: http://bitmagic.io
22 */
23
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27
28 #include "libbm.h"
29
30
31 static
32 int check_report_error(int res, const char* msg)
33 {
34 if (res != BM_OK)
35 {
36 printf("Error: %s. err_code=%i \'%s\'\n", msg, res, BM_error_msg(res));
37 }
38 return res;
39 }
40
41 #define BMERR_CHECK(x, y) if (check_report_error(x, y) != 0) return x;
42 #define BMERR_CHECK_GOTO(x, y, z) if (check_report_error(x, y) != 0) goto z;
43
44 static
45 int InitTest()
46 {
47 int res = 0;
48 const char* c;
49 int major, minor, patch;
50 const char* msg;
51 int simd_version;
52
53
54 res = BM_init(0);
55 BMERR_CHECK(res, "BM_init()");
56
57 c = BM_version(&major, &minor, &patch);
58 BMERR_CHECK(res, "BM_version()");
59
60 msg = BM_error_msg(BM_ERR_BADARG);
61 if (!msg)
62 {
63 printf("BM_error_msg() failed \n");
64 return 1;
65 }
66 else
67 {
68 printf("Test message, ignore. %s\n", msg);
69 }
70
71 printf ("%s\n", c);
72
73 simd_version = BM_simd_version();
74 switch(simd_version)
75 {
76 case BM_SIMD_NO:
77 printf("BitMagic vanilla.\n");
78 break;
79 case BM_SIMD_SSE2:
80 printf("BitMagic for SSE2 \n");
81 break;
82 case BM_SIMD_SSE42:
83 printf("BitMagic for SSE4.2 \n");
84 break;
85 case BM_SIMD_AVX2:
86 printf("BitMagic for AVX2 \n");
87 break;
88 default:
89 printf("Unknown SIMD code \n");
90 break;
91 }
92
93 return 0;
94 }
95
96 static
97 int ConstructionTest()
98 {
99 int res = 0;
100 BM_BVHANDLE bmh = 0;
101
102 res = BM_bvector_construct(&bmh, 0);
103 BMERR_CHECK(res, "BM_bvector_construct()");
104
105 res = BM_bvector_free(bmh);
106 BMERR_CHECK(res, "BM_bvector_free()");
107
108 return res;
109 }
110
111 static
112 int FreezeTest()
113 {
114 int res = 0;
115 int val;
116 BM_BVHANDLE bmh = 0;
117 BM_BVHANDLE bmh2 = 0;
118 BM_BVHANDLE bmh3 = 0;
119
120 res = BM_bvector_construct(&bmh, 0);
121 BMERR_CHECK(res, "BM_bvector_construct()");
122
123 res = BM_bvector_is_ro(bmh, &val);
124 BMERR_CHECK_GOTO(res, "BM_bvector_is_ro()", free_mem);
125 if (val)
126 {
127 printf("BM_bvector_is_ro incorrect value \n");
128 res = 1; goto free_mem;
129 }
130
131 res = BM_bvector_set_bit(bmh, 10, BM_TRUE); // vector has to be not empty to freeze
132 BMERR_CHECK_GOTO(res, "BM_bvector_set_bit()", free_mem);
133
134 res = BM_bvector_construct_copy_ro(&bmh2, bmh);
135 BMERR_CHECK(res, "BM_bvector_construct()");
136
137 res = BM_bvector_is_ro(bmh2, &val);
138 BMERR_CHECK_GOTO(res, "BM_bvector_is_ro()", free_mem);
139 if (!val)
140 {
141 printf("BM_bvector_is_ro (bmh2) incorrect value \n");
142 res = 1; goto free_mem;
143 }
144
145
146 res = BM_bvector_freeze(bmh);
147 BMERR_CHECK_GOTO(res, "BM_bvector_freeze()", free_mem);
148
149 res = BM_bvector_is_ro(bmh, &val);
150 BMERR_CHECK_GOTO(res, "BM_bvector_is_ro()", free_mem);
151 if (!val)
152 {
153 printf("BM_bvector_is_ro incorrect value \n");
154 res = 1; goto free_mem;
155 }
156
157 res = BM_bvector_get_bit(bmh, 10, &val);
158 BMERR_CHECK_GOTO(res, "BM_bvector_get_bit()", free_mem);
159 if (!val)
160 {
161 printf("bvector get_bit incorrect value \n");
162 res = 1; goto free_mem;
163 }
164
165 res = BM_bvector_get_bit(bmh2, 10, &val);
166 BMERR_CHECK_GOTO(res, "BM_bvector_get_bit()", free_mem);
167 if (!val)
168 {
169 printf("bvector get_bit incorrect value \n");
170 res = 1; goto free_mem;
171 }
172
173
174
175 res = BM_bvector_construct_copy_rw(&bmh3, bmh2);
176 BMERR_CHECK(res, "BM_bvector_construct()");
177 if (!bmh3)
178 {
179 printf("BM_bvector_construct_copy_rw incorrect value \n");
180 res = 1; goto free_mem;
181 }
182
183 res = BM_bvector_is_ro(bmh3, &val);
184 BMERR_CHECK_GOTO(res, "BM_bvector_is_ro()", free_mem);
185 printf("%i\n", val);
186 if (val)
187 {
188 printf("BM_bvector_is_ro incorrect value \n");
189 res = 1; goto free_mem;
190 }
191 res = BM_bvector_get_bit(bmh3, 10, &val);
192 BMERR_CHECK_GOTO(res, "BM_bvector_get_bit()", free_mem);
193 if (!val)
194 {
195 printf("bvector get_bit incorrect value \n");
196 res = 1; goto free_mem;
197 }
198
199 free_mem:
200 res = BM_bvector_free(bmh);
201 BMERR_CHECK(res, "BM_bvector_free()");
202 res = BM_bvector_free(bmh2);
203 BMERR_CHECK(res, "BM_bvector_free()");
204 res = BM_bvector_free(bmh3);
205 BMERR_CHECK(res, "BM_bvector_free()");
206
207 return res;
208 }
209
210
211
212 static
213 int ResizeTest()
214 {
215 int res = 0;
216 BM_BVHANDLE bmh = 0;
217 unsigned int size1 = 100000;
218 unsigned int size2 = 100000;
219 unsigned int size;
220
221
222 res = BM_bvector_construct(&bmh, size1);
223 BMERR_CHECK(res, "BM_bvector_construct()");
224
225
226 res = BM_bvector_get_size(bmh, &size);
227 BMERR_CHECK_GOTO(res, "BM_bvector_get_size()", free_mem);
228 if (size != size1)
229 {
230 printf("get size test failed %i\n", size);
231 res = 1; goto free_mem;
232 }
233 /*
234 {
235 unsigned int capacity;
236 res = BM_bvector_get_capacity(bmh, &capacity);
237 BMERR_CHECK_GOTO(res, "BM_bvector_get_capacity()", free_mem);
238 printf("cap=%i", capacity);
239 }
240 */
241
242 res = BM_bvector_set_size(bmh, size2);
243 BMERR_CHECK_GOTO(res, "BM_bvector_get_size", free_mem);
244
245 res = BM_bvector_get_size(bmh, &size);
246 BMERR_CHECK_GOTO(res, "BM_bvector_get_size()", free_mem);
247 if (size != size2)
248 {
249 printf("bvector get size failed %i\n", size);
250 res = 1; goto free_mem;
251 }
252
253
254 free_mem:
255 res = BM_bvector_free(bmh);
256 BMERR_CHECK(res, "BM_bvector_free()");
257 return res;
258 }
259
260 static
261 int ConstructionCopyMoveTest()
262 {
263 int res = 0;
264 BM_BVHANDLE bmh1 = 0;
265 BM_BVHANDLE bmh2 = 0;
266 BM_BVHANDLE bmh3 = 0;
267 unsigned int count1, count2, count3;
268
269 res = BM_bvector_construct(&bmh1, 0);
270 BMERR_CHECK(res, "BM_bvector_construct()");
271 res = BM_bvector_construct(&bmh2, 0);
272 BMERR_CHECK_GOTO(res, "BM_bvector_construct()", free_mem);
273 res = BM_bvector_construct(&bmh3, 0);
274 BMERR_CHECK_GOTO(res, "BM_bvector_construct()", free_mem);
275
276
277
278 res = BM_bvector_set_bit(bmh1, 10, BM_TRUE);
279 BMERR_CHECK_GOTO(res, "BM_bvector_set_bit()", free_mem);
280
281 res = BM_bvector_set_bit(bmh2, 100, BM_TRUE);
282 BMERR_CHECK_GOTO(res, "BM_bvector_set_bit()", free_mem);
283 res = BM_bvector_set_bit(bmh2, 101, BM_TRUE);
284 BMERR_CHECK_GOTO(res, "BM_bvector_set_bit()", free_mem);
285
286
287 res = BM_bvector_swap(bmh1, bmh2);
288 BMERR_CHECK_GOTO(res, "BM_bvector_swap()", free_mem);
289
290 res = BM_bvector_count(bmh1, &count1);
291 BMERR_CHECK_GOTO(res, "BM_bvector_count()", free_mem);
292 if (count1 != 2)
293 {
294 printf("1. incorrrect count %i \n", count1);
295 res = 1; goto free_mem;
296 }
297 res = BM_bvector_count(bmh2, &count2);
298 BMERR_CHECK_GOTO(res, "BM_bvector_count()", free_mem);
299 if (count2 != 1)
300 {
301 printf("2. incorrrect count %i \n", count2);
302 res = 1; goto free_mem;
303 }
304
305 res = BM_bvector_swap(bmh1, bmh3);
306 BMERR_CHECK_GOTO(res, "BM_bvector_swap()", free_mem);
307
308 res = BM_bvector_count(bmh3, &count3);
309 BMERR_CHECK_GOTO(res, "BM_bvector_count()", free_mem);
310 if (count3 != 2)
311 {
312 printf("3. incorrrect count %i \n", count3);
313 res = 1; goto free_mem;
314 }
315 res = BM_bvector_count(bmh1, &count1);
316 BMERR_CHECK_GOTO(res, "BM_bvector_count()", free_mem);
317 if (count1 != 0)
318 {
319 printf("4. incorrrect count %i \n", count1);
320 res = 1; goto free_mem;
321 }
322
323 {
324 BM_BVHANDLE bmh4 = 0;
325 unsigned count4;
326 unsigned pos;
327 int cmp, found;
328
329 res = BM_bvector_construct_copy(&bmh4, bmh3);
330 BMERR_CHECK_GOTO(res, "BM_bvector_construct_copy()", free_mem);
331 res = BM_bvector_count(bmh4, &count4);
332 BMERR_CHECK_GOTO(res, "BM_bvector_count()", free_mem1);
333 if (count4 != 2)
334 {
335 printf("5. incorrrect count %i \n", count4);
336 res = BM_bvector_free(bmh4);
337 res = 1; goto free_mem1;
338 }
339
340 res = BM_bvector_compare(bmh4, bmh3, &cmp);
341 BMERR_CHECK_GOTO(res, "BM_bvector_compare()", free_mem1);
342 if (cmp != 0)
343 {
344 printf("5. incorrrect compare result %i \n", cmp);
345 res = 1; goto free_mem1;
346 }
347 res = BM_bvector_find_first_mismatch(bmh4, bmh3, &pos, &found);
348 BMERR_CHECK_GOTO(res, "BM_bvector_find_first_mismatch()", free_mem1);
349 if (found)
350 {
351 printf("6. incorrrect find mismatch result %i \n", found);
352 res = 1; goto free_mem1;
353 }
354
355
356 free_mem1:
357 res = BM_bvector_free(bmh4);
358 }
359
360
361 free_mem:
362 res = BM_bvector_free(bmh1);
363 res = BM_bvector_free(bmh2);
364 res = BM_bvector_free(bmh3);
365
366 return res;
367 }
368
369
370 static
371 int SetGetTest()
372 {
373 int res = 0;
374 BM_BVHANDLE bmh1 = 0;
375 BM_BVHANDLE bmh2 = 0;
376 int val;
377 unsigned int count;
378 int carry_over;
379
380 res = BM_bvector_construct(&bmh1, 200);
381 BMERR_CHECK(res, "BM_bvector_construct()");
382
383 res = BM_bvector_construct(&bmh2, 0);
384 BMERR_CHECK_GOTO(res, "BM_bvector_construct()", free_mem);
385
386 res = BM_bvector_init(bmh2);
387 BMERR_CHECK_GOTO(res, "BM_bvector_init()", free_mem);
388
389 res = BM_bvector_any(bmh1, &val);
390 BMERR_CHECK_GOTO(res, "BM_bvector_any()", free_mem);
391 if (val)
392 {
393 printf("bvector any() incorrect value \n");
394 res = 1; goto free_mem;
395 }
396
397 res = BM_bvector_set_bit(bmh1, 10, BM_TRUE);
398 BMERR_CHECK_GOTO(res, "BM_bvector_set_bit()", free_mem);
399
400 res = BM_bvector_set_bit_no_check(bmh2, 10);
401 BMERR_CHECK_GOTO(res, "BM_bvector_set_bit_no_check()", free_mem);
402
403
404 res = BM_bvector_any(bmh1, &val);
405 BMERR_CHECK_GOTO(res, "BM_bvector_any()", free_mem);
406 if (val==0)
407 {
408 printf("bvector any() incorrect value \n");
409 res = 1; goto free_mem;
410 }
411
412
413 res = BM_bvector_get_bit(bmh1, 10, &val);
414 BMERR_CHECK_GOTO(res, "BM_bvector_get_bit()", free_mem);
415 if (!val)
416 {
417 printf("bvector get_bit incorrect value \n");
418 res = 1; goto free_mem;
419 }
420
421 res = BM_bvector_get_bit(bmh2, 10, &val);
422 BMERR_CHECK_GOTO(res, "BM_bvector_get_bit()", free_mem);
423 if (!val)
424 {
425 printf("bvector get_bit incorrect value \n");
426 res = 1; goto free_mem;
427 }
428
429 res = BM_bvector_inc_bit(bmh2, 10, &carry_over);
430 BMERR_CHECK_GOTO(res, "BM_bvector_inc_bit()", free_mem);
431 if (!carry_over)
432 {
433 printf("bvector inc_bit incorrect value \n");
434 res = 1; goto free_mem;
435 }
436
437 res = BM_bvector_inc_bit(bmh2, 10, &carry_over);
438 BMERR_CHECK_GOTO(res, "BM_bvector_inc_bit()", free_mem);
439 if (carry_over)
440 {
441 printf("bvector inc_bit incorrect value \n");
442 res = 1; goto free_mem;
443 }
444
445
446 res = BM_bvector_get_bit(bmh1, 0, &val);
447 BMERR_CHECK_GOTO(res, "BM_bvector_get_bit()", free_mem);
448 if (val)
449 {
450 printf("bvector get_bit incorrect value \n");
451 res = 1; goto free_mem;
452 }
453
454 res = BM_bvector_flip_bit(bmh1, 0);
455 BMERR_CHECK_GOTO(res, "BM_bvector_flip_bit()", free_mem);
456
457 res = BM_bvector_get_bit(bmh1, 0, &val);
458 BMERR_CHECK_GOTO(res, "BM_bvector_get_bit()", free_mem);
459 if (val == 0)
460 {
461 printf("bvector get_bit incorrect value \n");
462 res = 1; goto free_mem;
463 }
464 res = BM_bvector_flip_bit(bmh1, 0);
465 BMERR_CHECK_GOTO(res, "BM_bvector_flip_bit()", free_mem);
466
467
468 res = BM_bvector_count(bmh1, &count);
469 BMERR_CHECK_GOTO(res, "BM_bvector_count()", free_mem);
470 if (count != 1)
471 {
472 printf("incorrrect count %i \n", count);
473 res = 1; goto free_mem;
474 }
475
476 res = BM_bvector_set_bit(bmh1, 10, BM_FALSE);
477 BMERR_CHECK_GOTO(res, "BM_bvector_set_bit()", free_mem);
478
479 res = BM_bvector_get_bit(bmh1, 0, &val);
480 BMERR_CHECK_GOTO(res, "BM_bvector_get_bit()", free_mem);
481 if (val != BM_FALSE)
482 {
483 printf("bvector get_bit incorrect value %i\n", val);
484 res = 1; goto free_mem;
485 }
486 res = BM_bvector_count(bmh1, &count);
487 BMERR_CHECK_GOTO(res, "BM_bvector_count()", free_mem);
488 if (count != 0)
489 {
490 printf("incorrrect count %i \n", count);
491 res = 1; goto free_mem;
492 }
493
494 {
495 int change;
496 res = BM_bvector_set_bit_conditional(bmh1, 0, BM_TRUE, BM_FALSE, &change);
497 BMERR_CHECK_GOTO(res, "BM_bvector_set_bit_conditional()", free_mem);
498 if (!change)
499 {
500 printf("bvector set_bit_conditional error \n");
501 res = 1; goto free_mem;
502 }
503 res = BM_bvector_count(bmh1, &count);
504 BMERR_CHECK_GOTO(res, "BM_bvector_count()", free_mem);
505 if (count != 1)
506 {
507 printf("incorrrect count %i \n", count);
508 res = 1; goto free_mem;
509 }
510 res = BM_bvector_set_bit_conditional(bmh1, 0, BM_TRUE, BM_FALSE, &change);
511 BMERR_CHECK_GOTO(res, "BM_bvector_set_bit_conditional()", free_mem);
512 if (change)
513 {
514 printf("bvector set_bit_conditional error \n");
515 res = 1; goto free_mem;
516 }
517 }
518
519 res = BM_bvector_set(bmh1);
520 BMERR_CHECK_GOTO(res, "BM_bvector_set()", free_mem);
521
522 res = BM_bvector_count(bmh1, &count);
523 BMERR_CHECK_GOTO(res, "BM_bvector_count()", free_mem);
524 if (count == 0)
525 {
526 printf("incorrrect count %i \n", count);
527 res = 1; goto free_mem;
528 }
529 res = BM_bvector_clear(bmh1, BM_TRUE);
530 BMERR_CHECK_GOTO(res, "BM_bvector_clear()", free_mem);
531
532 res = BM_bvector_count(bmh1, &count);
533 BMERR_CHECK_GOTO(res, "BM_bvector_count()", free_mem);
534 if (count != 0)
535 {
536 printf("incorrrect count %i \n", count);
537 res = 1; goto free_mem;
538 }
539
540
541
542 free_mem:
543 res = BM_bvector_free(bmh1);
544 BMERR_CHECK(res, "bvector free failed");
545 res = BM_bvector_free(bmh2);
546 BMERR_CHECK(res, "bvector free failed");
547
548 return res;
549 }
550
551 int RangeTest()
552 {
553 int res = 0;
554 BM_BVHANDLE bmh = 0;
555 unsigned count;
556
557 res = BM_bvector_construct(&bmh, 200);
558 BMERR_CHECK(res, "BM_bvector_construct()");
559
560 res = BM_bvector_set_range(bmh, 10, 20, BM_TRUE);
561 BMERR_CHECK_GOTO(res, "BM_bvector_set_range()", free_mem);
562
563 res = BM_bvector_count(bmh, &count);
564 BMERR_CHECK_GOTO(res, "BM_bvector_count()", free_mem);
565 if (count != 11)
566 {
567 printf("incorrrect count %i \n", count);
568 res = 1; goto free_mem;
569 }
570
571 res = BM_bvector_count_range(bmh, 10, 20, &count);
572 BMERR_CHECK_GOTO(res, "BM_bvector_count_range()", free_mem);
573 if (count != 11)
574 {
575 printf("incorrrect count_range %i \n", count);
576 res = 1; goto free_mem;
577 }
578
579 {
580 unsigned int idx;
581 int found;
582 res = BM_bvector_find_rank(bmh, 10, 11, &idx, &found);
583 BMERR_CHECK_GOTO(res, "BM_bvector_find_rank()", free_mem);
584 if (idx != 20)
585 {
586 printf("incorrrect find_rank %i \n", idx);
587 res = 1; goto free_mem;
588 }
589 }
590
591 res = BM_bvector_count_range(bmh, 0, 9, &count);
592 BMERR_CHECK_GOTO(res, "BM_bvector_count_range()", free_mem);
593 if (count != 0)
594 {
595 printf("incorrrect count_range %i \n", count);
596 res = 1; goto free_mem;
597 }
598
599 res = BM_bvector_set_range(bmh, 10, 20, BM_FALSE);
600 BMERR_CHECK_GOTO(res, "BM_bvector_set_range()", free_mem);
601
602 res = BM_bvector_count(bmh, &count);
603 BMERR_CHECK_GOTO(res, "BM_bvector_count()", free_mem);
604 if (count != 0)
605 {
606 printf("incorrrect count %i \n", count);
607 res = 1; goto free_mem;
608 }
609
610 res = BM_bvector_invert(bmh);
611 BMERR_CHECK_GOTO(res, "BM_bvector_invert()", free_mem);
612
613 res = BM_bvector_count(bmh, &count);
614 BMERR_CHECK_GOTO(res, "BM_bvector_count()", free_mem);
615 if (count == 0)
616 {
617 printf("incorrrect count %i \n", count);
618 res = 1; goto free_mem;
619 }
620 res = BM_bvector_invert(bmh);
621 BMERR_CHECK_GOTO(res, "BM_bvector_invert()", free_mem);
622
623 res = BM_bvector_count(bmh, &count);
624 BMERR_CHECK_GOTO(res, "BM_bvector_count()", free_mem);
625 if (count != 0)
626 {
627 printf("incorrrect count %i \n", count);
628 res = 1; goto free_mem;
629 }
630
631
632
633 free_mem:
634 res = BM_bvector_free(bmh);
635 BMERR_CHECK(res, "bvector free failed");
636
637 return res;
638 }
639
640
641 int GetNextTest()
642 {
643 int res = 0;
644 BM_BVHANDLE bmh = 0;
645 unsigned int idx;
646 int found;
647
648 res = BM_bvector_construct(&bmh, 0);
649 BMERR_CHECK(res, "BM_bvector_construct()");
650
651
652 res = BM_bvector_get_first(bmh, &idx, &found);
653 BMERR_CHECK_GOTO(res, "BM_bvector_get_first()", free_mem);
654 if (found || idx != 0)
655 {
656 printf("1. incorrrect get first found on an empty vector \n");
657 res = 1; goto free_mem;
658 }
659
660 res = BM_bvector_find(bmh, 0, &idx, &found);
661 BMERR_CHECK_GOTO(res, "BM_bvector_find()", free_mem);
662 if (found)
663 {
664 printf("1.1 incorrrect find found on an empty vector \n");
665 res = 1; goto free_mem;
666 }
667 res = BM_bvector_find_reverse(bmh, &idx, &found);
668 BMERR_CHECK_GOTO(res, "BM_bvector_find_reverse()", free_mem);
669 if (found)
670 {
671 printf("1.2 incorrrect find_reverse found on an empty vector \n");
672 res = 1; goto free_mem;
673 }
674
675 res = BM_bvector_set_bit(bmh, 0, BM_TRUE);
676 BMERR_CHECK_GOTO(res, "BM_bvector_set_bit()", free_mem);
677
678 res = BM_bvector_get_first(bmh, &idx, &found);
679 BMERR_CHECK_GOTO(res, "BM_bvector_get_first()", free_mem);
680 if (!found || idx != 0)
681 {
682 printf("2. incorrrect get first %i\n", idx);
683 res = 1; goto free_mem;
684 }
685 res = BM_bvector_find(bmh, 0, &idx, &found);
686 BMERR_CHECK_GOTO(res, "BM_bvector_find()", free_mem);
687 if (!found || idx != 0)
688 {
689 printf("2.1 incorrrect find found in 0 position \n");
690 res = 1; goto free_mem;
691 }
692 res = BM_bvector_find_reverse(bmh, &idx, &found);
693 BMERR_CHECK_GOTO(res, "BM_bvector_find_reverse()", free_mem);
694 if (!found || idx != 0)
695 {
696 printf("1.2 incorrrect find_reverse found in 0 position \n");
697 res = 1; goto free_mem;
698 }
699
700 res = BM_bvector_get_next(bmh, idx, &idx);
701 BMERR_CHECK_GOTO(res, "BM_bvector_get_next()", free_mem);
702 if (idx != 0)
703 {
704 printf("4. incorrrect get next \n");
705 res = 1; goto free_mem;
706 }
707
708
709 res = BM_bvector_set_range(bmh, 100000, 100002, BM_TRUE);
710 BMERR_CHECK_GOTO(res, "BM_bvector_set_range()", free_mem);
711
712 res = BM_bvector_get_next(bmh, idx, &idx);
713 BMERR_CHECK_GOTO(res, "BM_bvector_get_next()", free_mem);
714 if (idx != 100000)
715 {
716 printf("4. incorrrect get next \n");
717 res = 1; goto free_mem;
718 }
719
720 res = BM_bvector_extract_next(bmh, 0, &idx);
721 BMERR_CHECK_GOTO(res, "BM_bvector_extract_next()", free_mem);
722 if (idx != 100000)
723 {
724 printf("5. incorrrect extract next \n");
725 res = 1; goto free_mem;
726 }
727
728 res = BM_bvector_get_next(bmh, idx, &idx);
729 BMERR_CHECK_GOTO(res, "BM_bvector_get_next()", free_mem);
730 if (idx != 100001)
731 {
732 printf("6. incorrrect get next \n");
733 res = 1; goto free_mem;
734 }
735
736
737
738 free_mem:
739 res = BM_bvector_free(bmh);
740 BMERR_CHECK(res, "bvector free failed");
741
742 return res;
743 }
744
745 static
746 int PrintVector(BM_BVHANDLE bmh, unsigned int size)
747 {
748 unsigned int count;
749 int res = 0;
750 int val;
751
752 res = BM_bvector_count(bmh, &count);
753 BMERR_CHECK_GOTO(res, "BM_bvector_count()", ret);
754
755 printf("%u : ", count);
756
757 for (unsigned int i = 0; i < size; ++i)
758 {
759 res = BM_bvector_get_bit(bmh, i, &val);
760 BMERR_CHECK_GOTO(res, "BM_bvector_get_bit()", ret);
761 printf("%u", val);
762
763 } // for
764 ret:
765 printf("\n");
766 return res;
767 }
768
769 static
770 int CompareVectors(BM_BVHANDLE bmh1, BM_BVHANDLE bmh2, int* is_equal)
771 {
772 int res = 0;
773 BM_BVEHANDLE bmeh1 = 0;
774 BM_BVEHANDLE bmeh2 = 0;
775 int valid1, valid2;
776 unsigned pos1, pos2;
777
778 res = BM_bvector_enumerator_construct(bmh1, &bmeh1);
779 BMERR_CHECK_GOTO(res, "BM_bvector_enumerator_construct()", free_mem);
780 res = BM_bvector_enumerator_construct(bmh2, &bmeh2);
781 BMERR_CHECK_GOTO(res, "BM_bvector_enumerator_construct()", free_mem);
782
783 res = BM_bvector_enumerator_is_valid(bmeh1, &valid1);
784 BMERR_CHECK_GOTO(res, "BM_bvector_enumerator_is_valid()", free_mem);
785 res = BM_bvector_enumerator_is_valid(bmeh2, &valid2);
786 BMERR_CHECK_GOTO(res, "BM_bvector_enumerator_is_valid()", free_mem);
787
788 if (!valid1)
789 {
790 if (!valid2)
791 *is_equal = 1;
792 else
793 *is_equal = 0;
794 return 0;
795 }
796 res = BM_bvector_enumerator_get_value(bmeh1, &pos1);
797 BMERR_CHECK_GOTO(res, "BM_bvector_enumerator_get_value()", free_mem);
798 res = BM_bvector_enumerator_get_value(bmeh2, &pos2);
799 BMERR_CHECK_GOTO(res, "BM_bvector_enumerator_get_value()", free_mem);
800
801 while(valid1 && valid2)
802 {
803 if (pos1 != pos2)
804 {
805 *is_equal = 0;
806 goto free_mem;
807 }
808 res = BM_bvector_enumerator_next(bmeh1, &valid1, &pos1);
809 BMERR_CHECK_GOTO(res, "BM_bvector_enumerator_next()", free_mem);
810 res = BM_bvector_enumerator_next(bmeh2, &valid2, &pos2);
811 BMERR_CHECK_GOTO(res, "BM_bvector_enumerator_next()", free_mem);
812 }
813
814 if (valid1 == valid2)
815 {
816 *is_equal = 1;
817 }
818
819
820 free_mem:
821 res = BM_bvector_enumerator_free(bmeh1);
822 res = BM_bvector_enumerator_free(bmeh2);
823
824 return res;
825 }
826
827
828 int OperationsTest_AND()
829 {
830 int res = 0;
831 BM_BVHANDLE bmh0 = 0;
832 BM_BVHANDLE bmh1 = 0;
833 BM_BVHANDLE bmh2 = 0;
834 unsigned int i;
835 unsigned int count1, count2;
836 int cmp;
837
838 res = BM_bvector_construct(&bmh0, 0);
839 BMERR_CHECK(res, "BM_bvector_construct()");
840 res = BM_bvector_construct(&bmh1, 0);
841 BMERR_CHECK(res, "BM_bvector_construct()");
842 res = BM_bvector_construct(&bmh2, 0);
843 BMERR_CHECK_GOTO(res, "BM_bvector_construct()", free_mem);
844
845
846 for (i = 1; i < 4; ++i)
847 {
848 res = BM_bvector_set_bit(bmh1, i, BM_TRUE);
849 BMERR_CHECK_GOTO(res, "BM_bvector_set_bit()", free_mem);
850 } // for
851
852 for (i = 0; i < 3; ++i)
853 {
854 res = BM_bvector_set_bit(bmh2, i, BM_TRUE);
855 BMERR_CHECK_GOTO(res, "BM_bvector_set_bit()", free_mem);
856 } // for
857
858 PrintVector(bmh1, 10);
859 PrintVector(bmh2, 10);
860 printf("AND\n");
861
862 res = BM_bvector_combine_AND_2sc(bmh0, bmh1, bmh2, 1);
863 BMERR_CHECK_GOTO(res, "BM_bvector_combine_AND_2sc()", free_mem);
864
865 res = BM_bvector_combine_AND(bmh1, bmh2);
866 BMERR_CHECK_GOTO(res, "BM_bvector_combine_AND()", free_mem);
867
868 res = BM_bvector_compare(bmh1, bmh0, &cmp);
869 BMERR_CHECK_GOTO(res, "BM_bvector_compare()", free_mem);
870 if (cmp != 0)
871 {
872 printf("0. incorrrect compare result %i \n", cmp);
873 res = 1; goto free_mem;
874 }
875
876 res = BM_bvector_count(bmh1, &count1);
877 BMERR_CHECK_GOTO(res, "BM_bvector_count()", free_mem);
878 if (count1 != 2)
879 {
880 printf("1. incorrrect count %i \n", count1);
881 res = 1; goto free_mem;
882 }
883 res = BM_bvector_count(bmh2, &count2);
884 BMERR_CHECK_GOTO(res, "BM_bvector_count()", free_mem);
885 if (count2 != 3)
886 {
887 printf("2. incorrrect count %i \n", count2);
888 res = 1; goto free_mem;
889 }
890
891 PrintVector(bmh1, 10);
892 printf("\n");
893 free_mem:
894 res = BM_bvector_free(bmh0);
895 BMERR_CHECK(res, "bvector free failed");
896 res = BM_bvector_free(bmh1);
897 BMERR_CHECK(res, "bvector free failed");
898 res = BM_bvector_free(bmh2);
899 BMERR_CHECK(res, "bvector free failed");
900
901 return res;
902 }
903
904 int OperationsTest_OR()
905 {
906 int res = 0;
907 BM_BVHANDLE bmh0 = 0;
908 BM_BVHANDLE bmh1 = 0;
909 BM_BVHANDLE bmh2 = 0;
910 unsigned int i;
911 int cmp;
912
913 res = BM_bvector_construct(&bmh0, 0);
914 BMERR_CHECK(res, "BM_bvector_construct()");
915 res = BM_bvector_construct(&bmh1, 0);
916 BMERR_CHECK(res, "BM_bvector_construct()");
917 res = BM_bvector_construct(&bmh2, 0);
918 BMERR_CHECK_GOTO(res, "BM_bvector_construct()", free_mem);
919
920
921 for (i = 1; i < 4; ++i)
922 {
923 res = BM_bvector_set_bit(bmh1, i, BM_TRUE);
924 BMERR_CHECK_GOTO(res, "BM_bvector_set_bit()", free_mem);
925 } // for
926
927 for (i = 0; i < 3; ++i)
928 {
929 res = BM_bvector_set_bit(bmh2, i, BM_TRUE);
930 BMERR_CHECK_GOTO(res, "BM_bvector_set_bit()", free_mem);
931 } // for
932
933 PrintVector(bmh1, 10);
934 PrintVector(bmh2, 10);
935 printf("OR\n");
936
937 res = BM_bvector_combine_OR_2sc(bmh0, bmh1, bmh2, 1);
938 BMERR_CHECK_GOTO(res, "BM_bvector_combine_OR_2sc()", free_mem);
939
940 res = BM_bvector_combine_OR(bmh1, bmh2);
941 BMERR_CHECK_GOTO(res, "BM_bvector_combine_OR()", free_mem);
942
943 res = BM_bvector_compare(bmh1, bmh0, &cmp);
944 BMERR_CHECK_GOTO(res, "BM_bvector_compare()", free_mem);
945 if (cmp != 0)
946 {
947 printf("0. incorrrect compare result %i \n", cmp);
948 res = 1; goto free_mem;
949 }
950
951 PrintVector(bmh1, 10);
952 printf("\n");
953
954 free_mem:
955 res = BM_bvector_free(bmh0);
956 BMERR_CHECK(res, "bvector free failed");
957 res = BM_bvector_free(bmh1);
958 BMERR_CHECK(res, "bvector free failed");
959 res = BM_bvector_free(bmh2);
960 BMERR_CHECK(res, "bvector free failed");
961
962 return res;
963 }
964
965 int OperationsTest_XOR()
966 {
967 int res = 0;
968 BM_BVHANDLE bmh0 = 0;
969 BM_BVHANDLE bmh1 = 0;
970 BM_BVHANDLE bmh2 = 0;
971 unsigned int i;
972 int cmp;
973
974 res = BM_bvector_construct(&bmh0, 0);
975 BMERR_CHECK(res, "BM_bvector_construct()");
976 res = BM_bvector_construct(&bmh1, 0);
977 BMERR_CHECK(res, "BM_bvector_construct()");
978 res = BM_bvector_construct(&bmh2, 0);
979 BMERR_CHECK_GOTO(res, "BM_bvector_construct()", free_mem);
980
981
982 for (i = 1; i < 4; ++i)
983 {
984 res = BM_bvector_set_bit(bmh1, i, BM_TRUE);
985 BMERR_CHECK_GOTO(res, "BM_bvector_set_bit()", free_mem);
986 } // for
987
988 for (i = 0; i < 3; ++i)
989 {
990 res = BM_bvector_set_bit(bmh2, i, BM_TRUE);
991 BMERR_CHECK_GOTO(res, "BM_bvector_set_bit()", free_mem);
992 } // for
993
994 PrintVector(bmh1, 10);
995 PrintVector(bmh2, 10);
996 printf("XOR\n");
997
998 res = BM_bvector_combine_XOR_2sc(bmh0, bmh1, bmh2, 1);
999 BMERR_CHECK_GOTO(res, "BM_bvector_combine_OR_2sc()", free_mem);
1000
1001 res = BM_bvector_combine_XOR(bmh1, bmh2);
1002 BMERR_CHECK_GOTO(res, "BM_bvector_combine_OR()", free_mem);
1003
1004 res = BM_bvector_compare(bmh1, bmh0, &cmp);
1005 BMERR_CHECK_GOTO(res, "BM_bvector_compare()", free_mem);
1006 if (cmp != 0)
1007 {
1008 printf("0. incorrrect compare result %i \n", cmp);
1009 res = 1; goto free_mem;
1010 }
1011
1012 PrintVector(bmh1, 10);
1013 printf("\n");
1014
1015 free_mem:
1016 res = BM_bvector_free(bmh0);
1017 BMERR_CHECK(res, "bvector free failed");
1018 res = BM_bvector_free(bmh1);
1019 BMERR_CHECK(res, "bvector free failed");
1020 res = BM_bvector_free(bmh2);
1021 BMERR_CHECK(res, "bvector free failed");
1022
1023 return res;
1024 }
1025
1026 int OperationsTest_SUB()
1027 {
1028 int res = 0;
1029 BM_BVHANDLE bmh0 = 0;
1030 BM_BVHANDLE bmh1 = 0;
1031 BM_BVHANDLE bmh2 = 0;
1032 unsigned int i;
1033 int cmp;
1034
1035 res = BM_bvector_construct(&bmh0, 0);
1036 BMERR_CHECK(res, "BM_bvector_construct()");
1037 res = BM_bvector_construct(&bmh1, 0);
1038 BMERR_CHECK(res, "BM_bvector_construct()");
1039 res = BM_bvector_construct(&bmh2, 0);
1040 BMERR_CHECK_GOTO(res, "BM_bvector_construct()", free_mem);
1041
1042
1043 for (i = 1; i < 4; ++i)
1044 {
1045 res = BM_bvector_set_bit(bmh1, i, BM_TRUE);
1046 BMERR_CHECK_GOTO(res, "BM_bvector_set_bit()", free_mem);
1047 } // for
1048
1049 for (i = 0; i < 3; ++i)
1050 {
1051 res = BM_bvector_set_bit(bmh2, i, BM_TRUE);
1052 BMERR_CHECK_GOTO(res, "BM_bvector_set_bit()", free_mem);
1053 } // for
1054
1055 PrintVector(bmh1, 10);
1056 PrintVector(bmh2, 10);
1057 printf("SUB\n");
1058
1059 res = BM_bvector_combine_SUB_2sc(bmh0, bmh1, bmh2, 1);
1060 BMERR_CHECK_GOTO(res, "BM_bvector_combine_SUB_2sc()", free_mem);
1061
1062 res = BM_bvector_combine_SUB(bmh1, bmh2);
1063 BMERR_CHECK_GOTO(res, "BM_bvector_combine_SUB()", free_mem);
1064
1065 res = BM_bvector_compare(bmh1, bmh0, &cmp);
1066 BMERR_CHECK_GOTO(res, "BM_bvector_compare()", free_mem);
1067 if (cmp != 0)
1068 {
1069 printf("0. incorrrect compare result %i \n", cmp);
1070 res = 1; goto free_mem;
1071 }
1072
1073 PrintVector(bmh1, 10);
1074 printf("\n");
1075
1076 free_mem:
1077 res = BM_bvector_free(bmh0);
1078 BMERR_CHECK(res, "bvector free failed");
1079 res = BM_bvector_free(bmh1);
1080 BMERR_CHECK(res, "bvector free failed");
1081 res = BM_bvector_free(bmh2);
1082 BMERR_CHECK(res, "bvector free failed");
1083
1084 return res;
1085 }
1086
1087
1088 int OperationsArrTest()
1089 {
1090 unsigned int arr1[] = {100, 10, 10000};
1091 unsigned int arr2[] = {1, 10, 5};
1092 unsigned int arr3_sorted[] = {1, 5, 10, 10000};
1093 int res = 0;
1094 BM_BVHANDLE bmh1 = 0;
1095 unsigned int count1;
1096
1097 res = BM_bvector_construct(&bmh1, 0);
1098 BMERR_CHECK(res, "BM_bvector_construct()");
1099
1100
1101 res = BM_bvector_combine_OR_arr(bmh1, &arr1[0], &arr1[0] + (sizeof(arr1)/sizeof(arr1[0])));
1102 BMERR_CHECK_GOTO(res, "BM_bvector_combine_OR_arr()", free_mem);
1103 res = BM_bvector_count(bmh1, &count1);
1104 BMERR_CHECK_GOTO(res, "BM_bvector_count()", free_mem);
1105 if (count1 != 3)
1106 {
1107 printf("1. incorrrect count %i \n", count1);
1108 res = 1; goto free_mem;
1109 }
1110
1111 res = BM_bvector_combine_AND_arr(bmh1, &arr2[0], &arr2[0] + (sizeof(arr2)/sizeof(arr2[0])));
1112 BMERR_CHECK_GOTO(res, "BM_bvector_combine_AND_arr()", free_mem);
1113 res = BM_bvector_count(bmh1, &count1);
1114 BMERR_CHECK_GOTO(res, "BM_bvector_count()", free_mem);
1115 if (count1 != 1)
1116 {
1117 printf("2. incorrrect count %i \n", count1);
1118 res = 1; goto free_mem;
1119 }
1120
1121 res = BM_bvector_combine_OR_arr(bmh1, &arr1[0], &arr1[0] + (sizeof(arr1)/sizeof(arr1[0])));
1122 BMERR_CHECK_GOTO(res, "BM_bvector_combine_OR_arr()", free_mem);
1123 res = BM_bvector_combine_AND_arr_sorted(bmh1, &arr3_sorted[0],
1124 &arr3_sorted[0] + (sizeof(arr3_sorted)/sizeof(arr3_sorted[0])));
1125 BMERR_CHECK_GOTO(res, "BM_bvector_combine_AND_arr_sorted()", free_mem);
1126 res = BM_bvector_count(bmh1, &count1);
1127 BMERR_CHECK_GOTO(res, "BM_bvector_count()", free_mem);
1128 if (count1 != 2)
1129 {
1130 printf("3. incorrrect count %i \n", count1);
1131 res = 1; goto free_mem;
1132 }
1133
1134 res = BM_bvector_combine_SUB_arr(bmh1, &arr1[0], &arr1[0] + (sizeof(arr1)/sizeof(arr1[0])));
1135 BMERR_CHECK_GOTO(res, "BM_bvector_combine_SUB_arr()", free_mem);
1136 res = BM_bvector_count(bmh1, &count1);
1137 BMERR_CHECK_GOTO(res, "BM_bvector_count()", free_mem);
1138 if (count1 != 0)
1139 {
1140 printf("4. incorrrect count %i \n", count1);
1141 res = 1; goto free_mem;
1142 }
1143
1144 res = BM_bvector_combine_XOR_arr(bmh1, &arr3_sorted[0], &arr3_sorted[0] + (sizeof(arr3_sorted)/sizeof(arr3_sorted[0])));
1145 BMERR_CHECK_GOTO(res, "BM_bvector_combine_XOR_arr()", free_mem);
1146 res = BM_bvector_count(bmh1, &count1);
1147 BMERR_CHECK_GOTO(res, "BM_bvector_count()", free_mem);
1148 if (count1 != 4)
1149 {
1150 printf("5. incorrrect count %i \n", count1);
1151 res = 1; goto free_mem;
1152 }
1153
1154
1155 free_mem:
1156 res = BM_bvector_free(bmh1);
1157 BMERR_CHECK(res, "bvector free failed");
1158
1159 return res;
1160 }
1161
1162 int EnumeratorTest()
1163 {
1164 int res = 0;
1165 BM_BVHANDLE bmh1 = 0;
1166 BM_BVEHANDLE bmeh1 = 0;
1167 BM_BVEHANDLE bmeh2 = 0;
1168 int valid;
1169 unsigned int pos;
1170
1171 unsigned int i;
1172
1173 res = BM_bvector_construct(&bmh1, 0);
1174 BMERR_CHECK(res, "BM_bvector_construct()");
1175
1176 res = BM_bvector_enumerator_construct(bmh1, &bmeh1);
1177 BMERR_CHECK_GOTO(res, "BM_bvector_enumerator_construct()", free_mem);
1178 res = BM_bvector_enumerator_is_valid(bmeh1, &valid);
1179 BMERR_CHECK_GOTO(res, "BM_bvector_enumerator_is_valid()", free_mem);
1180 if (valid)
1181 {
1182 printf("1. incorrrect enumerator valid %i \n", valid);
1183 res = 1; goto free_mem;
1184 }
1185 res = BM_bvector_enumerator_free(bmeh1);
1186
1187
1188 for (i = 1; i < 4; ++i)
1189 {
1190 res = BM_bvector_set_bit(bmh1, i, BM_TRUE);
1191 BMERR_CHECK_GOTO(res, "BM_bvector_set_bit()", free_mem);
1192 } // for
1193
1194 res = BM_bvector_enumerator_construct(bmh1, &bmeh1);
1195 BMERR_CHECK_GOTO(res, "BM_bvector_enumerator_construct()", free_mem);
1196
1197 res = BM_bvector_enumerator_is_valid(bmeh1, &valid);
1198 BMERR_CHECK_GOTO(res, "BM_bvector_enumerator_is_valid()", free_mem);
1199 if (!valid)
1200 {
1201 printf("2. incorrrect enumerator valid %i \n", valid);
1202 res = 1; goto free_mem;
1203 }
1204
1205 res = BM_bvector_enumerator_get_value(bmeh1, &pos);
1206 BMERR_CHECK_GOTO(res, "BM_bvector_enumerator_get_value()", free_mem);
1207 if (pos != 1)
1208 {
1209 printf("3. incorrrect enumerator traversal position %u \n", pos);
1210 res = 1; goto free_mem;
1211 }
1212
1213 res = BM_bvector_enumerator_next(bmeh1, &valid, &pos);
1214 BMERR_CHECK_GOTO(res, "BM_bvector_enumerator_next()", free_mem);
1215 if (!valid)
1216 {
1217 printf("3. incorrrect enumerator valid %i \n", valid);
1218 res = 1; goto free_mem;
1219 }
1220 if (pos != 2)
1221 {
1222 printf("4. incorrrect enumerator traversal position %u \n", pos);
1223 res = 1; goto free_mem;
1224 }
1225
1226 res = BM_bvector_enumerator_construct_from(bmh1, &bmeh2, 3);
1227 BMERR_CHECK_GOTO(res, "BM_bvector_enumerator_construct_from()", free_mem);
1228
1229 res = BM_bvector_enumerator_get_value(bmeh2, &pos);
1230 BMERR_CHECK_GOTO(res, "BM_bvector_enumerator_get_value()", free_mem);
1231 if (pos != 3)
1232 {
1233 printf("4. incorrrect enumerator traversal position %u \n", pos);
1234 res = 1; goto free_mem;
1235 }
1236
1237 res = BM_bvector_enumerator_goto(bmeh1, 3, &valid, &pos);
1238 BMERR_CHECK_GOTO(res, "BM_bvector_enumerator_next()", free_mem);
1239 if (!valid)
1240 {
1241 printf("5. incorrrect enumerator valid %i \n", valid);
1242 res = 1; goto free_mem;
1243 }
1244 if (pos != 3)
1245 {
1246 printf("6. incorrrect enumerator goto position %u \n", pos);
1247 res = 1; goto free_mem;
1248 }
1249
1250
1251 free_mem:
1252 res = BM_bvector_enumerator_free(bmeh2);
1253 res = BM_bvector_enumerator_free(bmeh1);
1254 res = BM_bvector_free(bmh1);
1255
1256 return res;
1257 }
1258
1259
1260 int SerializationTest()
1261 {
1262 int res = 0;
1263 BM_BVHANDLE bmh1 = 0;
1264 BM_BVHANDLE bmh2 = 0;
1265 BM_BVHANDLE bmh3 = 0;
1266 char* sbuf1 = 0;
1267 char* sbuf2 = 0;
1268 unsigned int i;
1269 struct BM_bvector_statistics bv_stat;
1270 size_t blob_size;
1271 int is_equal;
1272
1273 res = BM_bvector_construct(&bmh1, 0);
1274 BMERR_CHECK(res, "BM_bvector_construct()");
1275 res = BM_bvector_construct(&bmh2, 0);
1276 BMERR_CHECK_GOTO(res, "BM_bvector_construct()", free_mem);
1277 res = BM_bvector_construct(&bmh3, 0);
1278 BMERR_CHECK_GOTO(res, "BM_bvector_construct()", free_mem);
1279
1280
1281 for (i = 1; i < 4; ++i)
1282 {
1283 res = BM_bvector_set_bit(bmh1, i, BM_TRUE);
1284 BMERR_CHECK_GOTO(res, "BM_bvector_set_bit()", free_mem);
1285 res = BM_bvector_set_bit(bmh2, i, BM_TRUE);
1286 BMERR_CHECK_GOTO(res, "BM_bvector_set_bit()", free_mem);
1287 } // for
1288
1289 res = BM_bvector_optimize(bmh1, 3, &bv_stat);
1290 BMERR_CHECK_GOTO(res, "BM_bvector_calc_stat()", free_mem);
1291
1292 sbuf1 = (char*) malloc(bv_stat.max_serialize_mem);
1293 if (sbuf1 == 0)
1294 {
1295 printf("Failed to allocate serialization buffer.\n");
1296 res = 1; goto free_mem;
1297 }
1298
1299 res = BM_bvector_serialize(bmh1, sbuf1, bv_stat.max_serialize_mem, &blob_size);
1300 BMERR_CHECK_GOTO(res, "BM_bvector_serialize()", free_mem);
1301
1302 if (blob_size == 0 || blob_size > bv_stat.max_serialize_mem)
1303 {
1304 printf("Failed to serialize correctly.\n");
1305 res = 1; goto free_mem;
1306 }
1307
1308 sbuf2 = (char*) malloc(blob_size);
1309 if (sbuf1 == 0)
1310 {
1311 printf("Failed to allocate buffer.\n");
1312 res = 1; goto free_mem;
1313 }
1314
1315 memcpy(sbuf2, sbuf1, blob_size); // imitation of I/O
1316
1317 res = BM_bvector_deserialize(bmh3, sbuf2, blob_size);
1318 BMERR_CHECK_GOTO(res, "BM_bvector_deserialize()", free_mem);
1319
1320 res = CompareVectors(bmh1, bmh2, &is_equal);
1321 BMERR_CHECK_GOTO(res, "CompareVectors()", free_mem);
1322 if (is_equal)
1323 {
1324 res = CompareVectors(bmh1, bmh3, &is_equal);
1325 BMERR_CHECK_GOTO(res, "CompareVectors()", free_mem);
1326
1327 if (!is_equal)
1328 {
1329 printf("1.vectors comparison failed!\n");
1330
1331 PrintVector(bmh1, 10);
1332 PrintVector(bmh2, 10);
1333 PrintVector(bmh3, 10);
1334
1335 res = 1;
1336 goto free_mem;
1337 }
1338 }
1339 else
1340 {
1341 printf("2.vectors comparison failed!\n");
1342
1343 PrintVector(bmh1, 10);
1344 PrintVector(bmh2, 10);
1345 PrintVector(bmh3, 10);
1346
1347 res = 1;
1348 goto free_mem;
1349 }
1350
1351
1352 free_mem:
1353 if(sbuf1) free(sbuf1);
1354 if(sbuf2) free(sbuf2);
1355
1356 res = BM_bvector_free(bmh1);
1357 res = BM_bvector_free(bmh2);
1358 res = BM_bvector_free(bmh3);
1359
1360 return res;
1361 }
1362
1363 int SwapTest()
1364 {
1365 int res = 0;
1366 BM_BVHANDLE bmh1 = 0;
1367 int val;
1368 unsigned int count;
1369 int carry_over;
1370
1371 res = BM_bvector_construct(&bmh1, 0);
1372 BMERR_CHECK(res, "BM_bvector_construct()");
1373
1374
1375 res = BM_bvector_set_bit(bmh1, 10, BM_TRUE);
1376 BMERR_CHECK_GOTO(res, "BM_bvector_set_bit()", free_mem);
1377
1378 res = BM_bvector_swap_bits(bmh1, 10, 10000);
1379 BMERR_CHECK_GOTO(res, "BM_bvector_swap_bits()", free_mem);
1380
1381
1382 res = BM_bvector_get_bit(bmh1, 10000, &val);
1383 BMERR_CHECK_GOTO(res, "BM_bvector_get_bit()", free_mem);
1384 if (!val)
1385 {
1386 printf("bvector get_bit incorrect value \n");
1387 res = 1; goto free_mem;
1388 }
1389
1390 res = BM_bvector_get_bit(bmh1, 10, &val);
1391 BMERR_CHECK_GOTO(res, "BM_bvector_get_bit()", free_mem);
1392 if (val)
1393 {
1394 printf("bvector get_bit incorrect value \n");
1395 res = 1; goto free_mem;
1396 }
1397
1398 res = BM_bvector_count(bmh1, &count);
1399 BMERR_CHECK_GOTO(res, "BM_bvector_count()", free_mem);
1400 if (count != 1)
1401 {
1402 printf("incorrrect count %i \n", count);
1403 res = 1; goto free_mem;
1404 }
1405
1406
1407 free_mem:
1408 res = BM_bvector_free(bmh1);
1409 BMERR_CHECK(res, "bvector free failed");
1410
1411 return res;
1412 }
1413
1414
1415
1416 int main(void)
1417 {
1418 int res = 0;
1419
1420
1421 res = InitTest();
1422 if (res != 0)
1423 {
1424 printf("\nInitTest failed!\n");
1425 return res;
1426 }
1427 printf("\n---------------------------------- InitTest OK\n");
1428
1429 res = ConstructionTest();
1430 if (res != 0)
1431 {
1432 printf("\nConstructionTest failed!\n");
1433 return res;
1434 }
1435
1436 printf("\n---------------------------------- ConstructionTest OK\n");
1437
1438 res = ResizeTest();
1439 if (res != 0)
1440 {
1441 printf("\nResizeTest failed!\n");
1442 return res;
1443 }
1444 printf("\n---------------------------------- ResizeTest OK\n");
1445
1446 res = SetGetTest();
1447 if (res != 0)
1448 {
1449 printf("\nSetGetTest failed!\n");
1450 return res;
1451 }
1452 printf("\n---------------------------------- SetGetTest OK\n");
1453
1454 res = SwapTest();
1455 if (res != 0)
1456 {
1457 printf("\nSwapTest failed!\n");
1458 return res;
1459 }
1460 printf("\n---------------------------------- SwapTest OK\n");
1461
1462
1463
1464 res = ConstructionCopyMoveTest();
1465 if (res != 0)
1466 {
1467 printf("\nConstructionCopyMoveTest failed!\n");
1468 return res;
1469 }
1470
1471 printf("\n---------------------------------- ConstructionCopyMoveTest OK\n");
1472
1473
1474 res = RangeTest();
1475 if (res != 0)
1476 {
1477 printf("\nRangeTest failed!\n");
1478 return res;
1479 }
1480 printf("\n---------------------------------- RangeTest OK\n");
1481
1482
1483 res = GetNextTest();
1484 if (res != 0)
1485 {
1486 printf("\nGetNextTest failed!\n");
1487 return res;
1488 }
1489 printf("\n---------------------------------- GetNextTest OK\n");
1490
1491 res = FreezeTest();
1492 if (res != 0)
1493 {
1494 printf("\nFreezeTest failed!\n");
1495 return res;
1496 }
1497 printf("\n---------------------------------- FreezeTest OK\n");
1498
1499 res = OperationsTest_AND();
1500 if (res != 0)
1501 {
1502 printf("\nOperationsTest AND failed!\n");
1503 return res;
1504 }
1505
1506 res = OperationsTest_OR();
1507 if (res != 0)
1508 {
1509 printf("\nOperationsTest OR failed!\n");
1510 return res;
1511 }
1512
1513 res = OperationsTest_XOR();
1514 if (res != 0)
1515 {
1516 printf("\nOperationsTest XOR failed!\n");
1517 return res;
1518 }
1519
1520 res = OperationsTest_SUB();
1521 if (res != 0)
1522 {
1523 printf("\nOperationsTest SUB failed!\n");
1524 return res;
1525 }
1526
1527 printf("\n---------------------------------- OperationsTest OK\n");
1528
1529 res = OperationsArrTest();
1530 if (res != 0)
1531 {
1532 printf("\nOperationsArrTest failed!\n");
1533 return res;
1534 }
1535 printf("\n---------------------------------- OperationsArrTest OK\n");
1536
1537
1538 res = EnumeratorTest();
1539 if (res != 0)
1540 {
1541 printf("\nEnumeratorTest failed!\n");
1542 return res;
1543 }
1544 printf("\n---------------------------------- EnumeratorTest OK\n");
1545
1546
1547 res = SerializationTest();
1548 if (res != 0)
1549 {
1550 printf("\nSerializationTest failed!\n");
1551 return res;
1552 }
1553 printf("\n---------------------------------- SerializationTest OK\n");
1554
1555
1556
1557 printf("\nlibbm unit test OK\n");
1558
1559 return 0;
1560 }
1561