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);
}
