void KeyValueCountingBloomFilterTest::testRemove() {
//cout << endl;
bloom::KeyValueCountingBloomFilter Filter1(hashFunction_, *storage1, "",
10, false, 0.01);
bloom::KeyValueCountingBloomFilter Filter2(hashFunction_, *storage2, "",
10, false, 0.01);
bloom::KeyValueCountingBloomFilter Filter3(hashFunction_, *storage3, "",
10, false, 0.01);
// test signature (const unsigned char* key)
unsigned char cad1[hashFunction_.getHashSize()];
hashFunction_(cad1, "ejemplo");
CPPUNIT_ASSERT(!Filter1.remove(cad1));
Filter1.add(cad1);
CPPUNIT_ASSERT_EQUAL(true, Filter1.contains(cad1));
bool removed = Filter1.remove(cad1);
CPPUNIT_ASSERT(removed);
CPPUNIT_ASSERT_EQUAL(false, Filter1.contains(cad1));
CPPUNIT_ASSERT(!Filter1.remove(cad1));
// test signature (const std::string& key)
Filter1.AbstractBloomFilter::add(string("hello"));
Filter1.AbstractBloomFilter::add(string("hello"));
CPPUNIT_ASSERT(Filter1.AbstractBloomFilter::contains(string("hello")));
CPPUNIT_ASSERT(Filter1.CountingBloomFilter::remove(string("hello")));
CPPUNIT_ASSERT(!Filter1.AbstractBloomFilter::contains(string("hello")));
// test signature (const char* key)
CPPUNIT_ASSERT(!Filter1.CountingBloomFilter::remove("bye"));
Filter1.AbstractBloomFilter::add("bye");
CPPUNIT_ASSERT(Filter1.AbstractBloomFilter::contains("bye"));
CPPUNIT_ASSERT(Filter1.CountingBloomFilter::remove("bye"));
CPPUNIT_ASSERT(!Filter1.CountingBloomFilter::remove("bye"));
Filter1.AbstractBloomFilter::add("bla1");
Filter2.AbstractBloomFilter::add("bla1");
Filter2.clear();
Filter1.AbstractBloomFilter::add("bla2");
Filter2.AbstractBloomFilter::add("bla2");
Filter2.clear();
Filter1.AbstractBloomFilter::add("bla3");
Filter2.AbstractBloomFilter::add("bla3");
Filter2.clear();
CPPUNIT_ASSERT(Filter1.CountingBloomFilter::remove("bla1"));
CPPUNIT_ASSERT(Filter1.CountingBloomFilter::remove("bla2"));
CPPUNIT_ASSERT(Filter1.AbstractBloomFilter::contains("bla3"));
CPPUNIT_ASSERT(Filter1.CountingBloomFilter::remove("bla3"));
/// Testing transaction code
Filter3.AbstractBloomFilter::add("bla1");
Filter3.AbstractBloomFilter::add("bla2");
Filter3.AbstractBloomFilter::add("bla3");
CPPUNIT_ASSERT(Filter3.CountingBloomFilter::remove("bla1"));
CPPUNIT_ASSERT(Filter3.CountingBloomFilter::remove("bla2"));
CPPUNIT_ASSERT(Filter3.CountingBloomFilter::remove("bla3"));
}
/*=== BEGIN tests for class 'BloomFilter' ===*/
void BloomFilterTest::testLoad() {
bloom::BloomFilter Filter1(hash, 10, false, 0.01);
bloom::BloomFilter Filter2(hash, 10, false, 0.01);
string s1 = "hello";
string s2 = "byebye";
Filter1.AbstractBloomFilter::add(s1);
CPPUNIT_ASSERT_EQUAL(true, Filter1.AbstractBloomFilter::contains(s1));
CPPUNIT_ASSERT_EQUAL(false, Filter2.AbstractBloomFilter::contains(s1));
std::stringstream buf;
Filter1.save(buf);
Filter2.load(buf, Filter1.numberOfElements());
CPPUNIT_ASSERT_EQUAL(true, Filter2.AbstractBloomFilter::contains(s1));
CPPUNIT_ASSERT_EQUAL(Filter1.numberOfElements(), Filter2.numberOfElements());
}
void KeyValueCountingBloomFilterTest::testConstructor() {
bloom::KeyValueCountingBloomFilter Filter1(hashFunction_, *storage1, "",
10, false, 0.01);
Filter1.AbstractBloomFilter::add("bla1");
Filter1.AbstractBloomFilter::add("bla2");
Filter1.AbstractBloomFilter::add("bla3");
Filter1.AbstractBloomFilter::add("bla4");
bloom::KeyValueCountingBloomFilter Filter2(hashFunction_, *storage1, "",
10, false, 0.01);
CPPUNIT_ASSERT(Filter1.AbstractBloomFilter::contains("bla1"));
CPPUNIT_ASSERT(Filter2.AbstractBloomFilter::contains("bla1"));
CPPUNIT_ASSERT(Filter2.AbstractBloomFilter::contains("bla2"));
CPPUNIT_ASSERT(Filter2.AbstractBloomFilter::contains("bla3"));
CPPUNIT_ASSERT(Filter2.AbstractBloomFilter::contains("bla4"));
}
void BloomFilterTest::testContainsAll() {
bloom::BloomFilter Filter2(hash, 8196);
unsigned char hashes[100 * hash.getHashSize()];
for (int j = 0; j < 100; j++) {
unsigned char word[8];
for (int i = 0; i < 8; i++) {
word[i] = 33 + rand() % (126 - 23);
}
hash(hashes + hash.getHashSize() * j, word, 8);
}
for (int i = 0; i < 100; i++) {
Filter2.add(hashes + i * hash.getHashSize());
}
Filter2.containsAll(hashes, 100);
CPPUNIT_ASSERT(Filter2.containsAll(hashes, 100));
}
void KeyValueCountingBloomFilterTest::testLoad() {
bloom::KeyValueCountingBloomFilter Filter1(hashFunction_, *storage1, "",
10, false, 0.01);
bloom::KeyValueCountingBloomFilter Filter2(hashFunction_, *storage2, "",
10, false, 0.01);
Filter1.AbstractBloomFilter::add("hello");
CPPUNIT_ASSERT_EQUAL(true, Filter1.AbstractBloomFilter::contains("hello"));
CPPUNIT_ASSERT_EQUAL(false, Filter2.AbstractBloomFilter::contains("hello"));
std::stringstream buf;
Filter1.save(buf);
Filter2.load(buf, Filter1.numberOfElements());
CPPUNIT_ASSERT_EQUAL(Filter1.numberOfElements(), Filter2.numberOfElements());
// std::cout << std::endl << Filter1.toString() << std::endl;
// std::cout << std::endl << Filter2.toString() << std::endl;
CPPUNIT_ASSERT(Filter1 == Filter2);
CPPUNIT_ASSERT(Filter2.AbstractBloomFilter::contains("hello"));
}
void KeyValueCountingBloomFilterTest::testContainsAll() {
bloom::KeyValueCountingBloomFilter Filter2(hashFunction_, *storage2, "",
8196);
unsigned char hashes[100 * hashFunction_.getHashSize()];
for (int j = 0; j < 100; j++) {
unsigned char word[8];
for (int i = 0; i <= 7; i++) {
word[i] = 33 + rand() % (126 - 23);
}
hashFunction_(hashes + hashFunction_.getHashSize() * j, word, 8);
}
for (int i = 0; i < 100; i++) {
Filter2.add(hashes + i * hashFunction_.getHashSize());
}
Filter2.containsAll(hashes, 100);
CPPUNIT_ASSERT(Filter2.containsAll(hashes, 100));
}
/*--------------------------------------*/
void mulcol_sp(csr_t *A, options_t *opts,
precon_t *prec, int *perm) {
/*---------------------------------------*/
PREC_TYPE ptype;
int n,i,maxcol,ncol,*kolrs,*il,err,k;
double tol;
csr_t *C,*B;
/*---------------------------------------*/
n = A->n;
ptype = opts->prectype;
if (ptype == MCSOR) {
maxcol = opts->mcsor_opt->maxcol;
tol = opts->mcsor_opt->tol;
}
else {
maxcol = opts->mcilu0_opt->maxcol;
tol = opts->mcilu0_opt->tol;
}
printf("begin Sparsified MULTI-COLOR ...\n");
/*-------------------------------------*/
Calloc(kolrs, n, int);
Calloc(il, maxcol+1, int);
/*------------- filter out small terms */
/*------------- B: sparsified matrix */
Calloc(B, 1, csr_t);
Filter(A, B, tol);
/*--------------------*/
Calloc(C, 1, csr_t);
for (k=0; k<MAXLOOP; k++) {
/*----- symetrize matrix B */
symmgraph(B, C);
/*----- init ordering */
for (i=0; i<n; i++)
perm[i] = i+1;
/*----- multi-color */
multic_(&n, C->ja, C->ia, &ncol, kolrs,
il, perm, &maxcol, &err);
printf(" # of colors: %d\n", ncol);
if (err != 0) {
printf("exceed max num of colors\n");
exit(-1);
}
/*-------------------------*/
free(C->ja);
free(C->ia);
/*-------------------------------*/
if (tol*2 > MAXTOL || ncol < 5)
break;
tol = tol*2;
/*------- further filtering */
/*---- drop small entries in long rows */
Filter2(B, tol, ncol);
}
/*----------------------------------*/
if (ptype == MCSOR) {
Calloc(prec->mcsor, 1, mcsor_prec_t);
prec->mcsor->ncol = ncol;
prec->mcsor->kolrs = kolrs;
prec->mcsor->il = il;
} else {
Calloc(prec->mcilu0, 1, mcilu0_prec_t);
prec->mcilu0->ncol = ncol;
prec->mcilu0->kolrs = kolrs;
prec->mcilu0->il = il;
}
/*----------------- done */
free_csr(B);
free(C);
}
