BITVEC *reads_elsewhere_in_set(CJOB *settings, READSET *set, int i) { char *sbvfname = get_bvfname_from_one_fafname(settings, set->filenames[i]); BITVEC *sbv = bv_read_from_file(sbvfname); BITVEC *others = bv_create(sbv->num_bits); int j = 0; for(j = 0; j < set->num_files; j++) { if(j != i) { char *isbvfname = get_bvfname_of_index_and_search(settings, set->filenames[j], set->filenames[i]); BITVEC *isbv = bv_copy(bv_read_from_file(isbvfname)); bv_ior(others, isbv); } } bv_iand(others, sbv); bv_destroy(sbv); free(sbvfname); return others; }
static void frt_bv_free(void *p) { object_del(p); bv_destroy((BitVector *)p); }
/** * Stress test BitVector Scanning as well as bv_set_fast. This test has been * run successfully with BV_DENSE_SCAN_SIZE set to 20000000 and BV_SCAN_INC * set to 97. When running this test with high numbers, be sure use -q on the * command line or the test will take a very long time. */ static void test_bv_scan_stress(TestCase *tc, void *data) { int i; BitVector *bv = bv_new_capa(BV_SCAN_SIZE); BitVector *not_bv; (void)data; /* suppress unused argument warning */ for (i = BV_SCAN_INC; i < BV_SCAN_SIZE; i += BV_SCAN_INC) { bv_set_fast(bv, i); Aiequal(bv_get(bv, i), 1); Aiequal(bv_get(bv, i-1), 0); Aiequal(bv_get(bv, i+1), 0); } not_bv = bv_not(bv); for (i = BV_SCAN_INC; i < BV_SCAN_SIZE; i += BV_SCAN_INC) { Aiequal(i, bv_scan_next_from(bv, i - BV_SCAN_INC / 2)); Aiequal(i, bv_scan_next_unset_from(not_bv, i - BV_SCAN_INC / 2)); } Aiequal(-1, bv_scan_next_from(bv, i - BV_SCAN_INC / 2)); Aiequal(-1, bv_scan_next_unset_from(not_bv, i - BV_SCAN_INC / 2)); /* test scan_next_from where size is actually greater than the highest set * bit */ bv_unset(bv, bv->size); bv_set(not_bv, not_bv->size); bv_scan_reset(bv); bv_scan_reset(not_bv); for (i = BV_SCAN_INC; i < BV_SCAN_SIZE; i += BV_SCAN_INC) { Aiequal(i, bv_scan_next_from(bv, i - BV_SCAN_INC / 2)); Aiequal(i, bv_scan_next_unset_from(not_bv, i - BV_SCAN_INC / 2)); } Aiequal(-1, bv_scan_next_from(bv, i - BV_SCAN_INC / 2)); Aiequal(-1, bv_scan_next_unset_from(not_bv, i - BV_SCAN_INC / 2)); bv_scan_reset(bv); bv_scan_reset(not_bv); for (i = BV_SCAN_INC; i < BV_SCAN_SIZE; i += BV_SCAN_INC) { Aiequal(i, bv_scan_next(bv)); Aiequal(i, bv_scan_next_unset(not_bv)); } Aiequal(-1, bv_scan_next(bv)); Aiequal(-1, bv_scan_next_unset(not_bv)); bv_clear(bv); bv_destroy(not_bv); for (i = 0; i < BV_DENSE_SCAN_SIZE; i++) { bv_set(bv, i); } not_bv = bv_not(bv); for (i = 0; i < BV_DENSE_SCAN_SIZE; i++) { Aiequal(i, bv_scan_next_from(bv, i)); Aiequal(i, bv_scan_next_unset_from(not_bv, i)); } Aiequal(-1, bv_scan_next_from(bv, i)); Aiequal(-1, bv_scan_next_unset_from(not_bv, i)); bv_scan_reset(bv); bv_scan_reset(not_bv); for (i = 0; i < BV_DENSE_SCAN_SIZE; i++) { Aiequal(i, bv_scan_next(bv)); Aiequal(i, bv_scan_next_unset(not_bv)); } Aiequal(-1, bv_scan_next(bv)); Aiequal(-1, bv_scan_next_unset(not_bv)); bv_destroy(bv); bv_destroy(not_bv); }
static void test_bv_combined_boolean_ops(TestCase *tc, void *data) { BitVector *bv1 = bv_new(); BitVector *bv2 = bv_new(); BitVector *bv3; BitVector *bv4; BitVector *bv5; BitVector *bv_empty = bv_new(); (void)data; set_bits(bv1, "1, 5, 7"); set_bits(bv2, "1, 8, 20"); bv3 = bv_not(bv1); Aiequal(bv3->size, bv1->size); bv4 = bv_and(bv1, bv3); Assert(bv_eq(bv4, bv_empty), "bv & ~bv == empty BitVector"); bv_destroy(bv4); bv4 = bv_and(bv2, bv3); bv5 = set_bits(bv_new(), "8, 20"); Assert(bv_eq(bv4, bv5), "~[1,5,7] & [1,8,20] == [8,20]"); bv_destroy(bv4); bv_destroy(bv5); bv4 = bv_or(bv1, bv3); bv5 = bv_not(bv_empty); Assert(bv_eq(bv4, bv5), "bv | ~bv == all 1s"); bv_destroy(bv4); bv_destroy(bv5); bv4 = bv_or(bv2, bv3); bv5 = bv_not_x(set_bits(bv_new(), "5, 7")); Assert(bv_eq(bv4, bv5), "~[1,5,7] | [1,8,20] == ~[5, 7]"); bv_destroy(bv4); bv_destroy(bv5); bv4 = bv_xor(bv1, bv3); bv5 = bv_not(bv_empty); Assert(bv_eq(bv4, bv5), "bv ^ ~bv == full BitVector"); bv_destroy(bv4); bv_destroy(bv5); bv4 = bv_xor(bv2, bv3); bv5 = bv_not_x(set_bits(bv_new(), "5, 7, 8, 20")); Assert(bv_eq(bv4, bv5), "~[1,5,7] ^ [1,8,20] == ~[5, 7, 8, 20]"); bv_destroy(bv4); bv_destroy(bv5); bv_destroy(bv1); bv_destroy(bv2); bv_destroy(bv3); bv_destroy(bv_empty); }
/** * Test basic BitVector get/set/unset operations */ static void test_bv(TestCase *tc, void *data) { int i; BitVector *bv = bv_new(); (void)data; /* suppress unused argument warning */ Aiequal(0, bv->size); Aiequal(0, bv->count); Aiequal(0, bv_recount(bv)); bv_set(bv, 10); Aiequal(1, bv_get(bv, 10)); Aiequal(11, bv->size); Aiequal(1, bv->count); Aiequal(1, bv_recount(bv)); bv_set(bv, 10); Aiequal(1, bv_get(bv, 10)); Aiequal(11, bv->size); Aiequal(1, bv->count); Aiequal(1, bv_recount(bv)); bv_set(bv, 20); Aiequal(1, bv_get(bv, 20)); Aiequal(21, bv->size); Aiequal(2, bv->count); Aiequal(2, bv_recount(bv)); bv_unset(bv, 21); Aiequal(0, bv_get(bv, 21)); Aiequal(22, bv->size); Aiequal(2, bv->count); Aiequal(2, bv_recount(bv)); bv_unset(bv, 20); Aiequal(0, bv_get(bv, 20)); Aiequal(22, bv->size); Aiequal(1, bv->count); Aiequal(1, bv_recount(bv)); Aiequal(1, bv_get(bv, 10)); bv_set(bv, 100); Aiequal(1, bv_get(bv, 100)); Aiequal(101, bv->size); Aiequal(2, bv->count); Aiequal(2, bv_recount(bv)); Aiequal(1, bv_get(bv, 10)); bv_clear(bv); Aiequal(0, bv_get(bv, 10)); Aiequal(0, bv->size); Aiequal(0, bv->count); Aiequal(0, bv_recount(bv)); bv_unset(bv, 20); Aiequal(21, bv->size); /* test setting bits at intervals for a large number of bits */ bv_clear(bv); for (i = BV_INT; i < BV_SIZE; i += BV_INT) { bv_set(bv, i); } for (i = BV_INT; i < BV_SIZE; i += BV_INT) { Aiequal(1, bv_get(bv, i)); Aiequal(0, bv_get(bv, i - 1)); Aiequal(0, bv_get(bv, i + 1)); } /* test setting all bits */ bv_clear(bv); for (i = 0; i < BV_SIZE; i++) { bv_set(bv, i); } for (i = 0; i < BV_SIZE; i++) { Aiequal(1, bv_get(bv, i)); } /* test random bits */ bv_clear(bv); for (i = 0; i < BV_SIZE; i++) { if ((rand() % 2) == 0) { bv_set(bv, i); Aiequal(1, bv_get(bv, i)); } } bv_destroy(bv); }
static void test_bv_and(TestCase *tc, void *data) { # define AND_SIZE 1000 static const int and_cnt = 500; BitVector *and_bv; BitVector *bv1 = bv_new(); BitVector *bv2 = bv_new(); BitVector *not_bv1, *not_bv2, *or_bv, *not_and_bv; char set1[AND_SIZE]; char set2[AND_SIZE]; int i; int count = 0; (void)data; memset(set1, 0, AND_SIZE); memset(set2, 0, AND_SIZE); for (i = 0; i < and_cnt; i++) { int bit = rand() % AND_SIZE; bv_set(bv1, bit); set1[bit] = 1; } for (i = 0; i < and_cnt; i++) { int bit = rand() % AND_SIZE; bv_set(bv2, bit); if (1 == set1[bit] && !set2[bit]) { count++; set2[bit] = 1; } } not_bv1 = bv_not(bv1); not_bv2 = bv_not(bv2); and_bv = bv_and(not_bv1, not_bv2); not_and_bv = bv_not(and_bv); or_bv = bv_or(bv1, bv2); Assert(bv_eq(not_and_bv, or_bv), "BitVectors should be equal"); bv_destroy(not_bv1); bv_destroy(not_bv2); bv_destroy(and_bv); bv_destroy(not_and_bv); bv_destroy(or_bv); and_bv = bv_and(bv1, bv2); Aiequal(count, and_bv->count); for (i = 0; i < AND_SIZE; i++) { Aiequal(set2[i], bv_get(and_bv, i)); } bv1 = bv_and_x(bv1, bv2); Assert(bv_eq(bv1, and_bv), "BitVectors should be equal"); bv_destroy(bv2); bv_destroy(and_bv); bv2 = bv_new(); and_bv = bv_and(bv1, bv2); Assert(bv_eq(bv2, and_bv), "ANDed BitVector should be empty"); bv_destroy(bv1); bv_destroy(bv2); bv_destroy(and_bv); bv1 = bv_new(); bv_not_x(bv1); bv2 = bv_new(); bv_set(bv2, 10); bv_set(bv2, 11); bv_set(bv2, 20); and_bv = bv_and(bv1, bv2); Assert(bv_eq(bv2, and_bv), "ANDed BitVector should be equal"); bv_destroy(bv1); bv_destroy(bv2); bv_destroy(and_bv); }