t_nb *naive_multp(t_nb *nb1, t_nb *nb2, int base)
{
t_nb *i;
t_nb *j;
t_nb *cpy;
if (nb2->nb[0] == 0 || nb1->nb[0] == 0)
return (create_tnbzero());
i = create_tnbone();
j = create_tnbone();
cpy = malloc(sizeof(t_nb));
if (cpy == NULL)
return (NULL);
cpy->nb = malloc(sizeof(unsigned char) * (nb1->len + 2));
cpy->nb = my_nbcpy(nb1->nb, nb1->len, cpy->nb);
cpy->len = nb1->len;
if (cpy->nb == NULL)
return (NULL);
while (nbr_cmp(i, nb2) == -1)
{
nb1 = testadd(nb1, cpy, base);
cpy->nb = my_revnbr(cpy->nb, cpy->len);
i = testadd(i, j, base);
}
free_multp(i, j);
return (nb1);
}
void
inittestbitop()
{
testadd("testbitand", datatestbitand, testbitand, freetestbitop);
testadd("testbitor", datatestbitor, testbitor, freetestbitop);
testadd("testbitxor", datatestbitxor, testbitxor, freetestbitop);
TESTADD(testbitnot);
TESTADD(testbitreverse);
}
/** test with long sequence of adds, removes and updates, and lookups */
static void
test_long_table(struct lruhash* table)
{
/* assuming it all fits in the hastable, this check will work */
testdata_t* ref[HASHTESTMAX * 100];
size_t i;
memset(ref, 0, sizeof(ref));
/* test assumption */
if(0) log_info(" size %d x %d < %d", (int)test_slabhash_sizefunc(NULL, NULL),
(int)HASHTESTMAX, (int)table->space_max);
unit_assert( test_slabhash_sizefunc(NULL, NULL)*HASHTESTMAX < table->space_max);
if(0) lruhash_status(table, "unit test", 1);
srandom(48);
for(i=0; i<1000; i++) {
/* what to do? */
if(i == 500) {
lruhash_clear(table);
memset(ref, 0, sizeof(ref));
continue;
}
switch(random() % 4) {
case 0:
case 3:
testadd(table, ref);
break;
case 1:
testremove(table, ref);
break;
case 2:
testlookup(table, ref);
break;
default:
unit_assert(0);
}
if(0) lruhash_status(table, "unit test", 1);
check_table(table);
unit_assert( table->num <= HASHTESTMAX );
}
/* test more, but 'ref' assumption does not hold anymore */
for(i=0; i<1000; i++) {
/* what to do? */
switch(random() % 4) {
case 0:
case 3:
testadd_unlim(table, ref);
break;
case 1:
testremove_unlim(table, ref);
break;
case 2:
testlookup_unlim(table, ref);
break;
default:
unit_assert(0);
}
if(0) lruhash_status(table, "unlim", 1);
check_table(table);
}
}
t_nb *naive_mod(t_nb *nb1, t_nb *nb2, int base)
{
t_nb *i;
t_nb *j;
t_nb *cpy;
if (nb2->nb[0] == 0)
{
my_putstr("error: modulo by zero\n");
return (NULL);
}
if (nb2->nb[0] == 1 && nb2->nb[1] == 255)
return (nb1);
if (nbr_cmp(nb1, nb2) < 0)
return (create_tnbzero());
i = create_tnbzero();
j = create_tnbone();
while (nbr_cmp(nb1, nb2) >= 0)
{
cpy = my_tnbcpy(nb2);
nb1 = my_substract(nb1, cpy, base);
i = testadd(i, j, base);
free_snb(cpy);
}
free_snb(j);
return (nb1);
}
static void *test_thr_main(void *arg)
{
struct test_thr *t = (struct test_thr *)arg;
int i;
for(i = 0; i < 1000; i++) {
switch(random() % 4) {
case 0:
case 3:
testadd(t->table, NULL);
break;
case 1:
testremove(t->table, NULL);
break;
case 2:
testlookup(t->table, NULL);
break;
default:
unit_assert(0);
}
if(i % 100 == 0)
check_table(t->table);
}
check_table(t->table);
return NULL;
}
static void test_long_table(struct lruhash* table)
{
testdata *ref[MAXHASH * 100];
size_t i;
memset(ref, 0, sizeof(ref));
unit_assert(sizefunc(NULL, NULL)*MAXHASH < table->space_max);
srandom(48);
for(i = 0; i < 1000; i++) {
if(i == 500) {
lruhash_clear(table);
memset(ref, 0, sizeof(ref));
continue;
}
switch(random() % 4) {
case 0:
case 3:
testadd(table, ref);
break;
case 1:
testremove(table, ref);
break;
case 2:
testlookup(table, ref);
break;
default:
unit_assert(0);
}
check_table(table);
unit_assert(table->num <= MAXHASH);
}
}
/** test with long sequence of adds, removes and updates, and lookups */
static void
test_long_table(struct slabhash* table)
{
/* assuming it all fits in the hashtable, this check will work */
testdata_type* ref[HASHTESTMAX * 100];
size_t i;
memset(ref, 0, sizeof(ref));
/* test assumption */
if(0) slabhash_status(table, "unit test", 1);
srandom(48);
for(i=0; i<1000; i++) {
/* what to do? */
if(i == 500) {
slabhash_clear(table);
memset(ref, 0, sizeof(ref));
continue;
}
switch(random() % 4) {
case 0:
case 3:
testadd(table, ref);
break;
case 1:
testremove(table, ref);
break;
case 2:
testlookup(table, ref);
break;
default:
unit_assert(0);
}
if(0) slabhash_status(table, "unit test", 1);
check_table(table);
}
/* test more, but 'ref' assumption does not hold anymore */
for(i=0; i<1000; i++) {
/* what to do? */
switch(random() % 4) {
case 0:
case 3:
testadd_unlim(table, ref);
break;
case 1:
testremove_unlim(table, ref);
break;
case 2:
testlookup_unlim(table, ref);
break;
default:
unit_assert(0);
}
if(0) slabhash_status(table, "unlim", 1);
check_table(table);
}
}
