static void
test_remove_node (void)
{
GtkRBTree *tree;
tree = create_rbtree (3, 16, g_test_thorough ());
while (tree->root->count > 1)
{
GtkRBTree *find_tree;
GtkRBNode *find_node;
guint i;
i = g_test_rand_int_range (0, tree->root->total_count);
if (!_gtk_rbtree_find_index (tree, i, &find_tree, &find_node))
{
/* We search an available index, so we mustn't fail. */
g_assert_not_reached ();
}
_gtk_rbtree_test (find_tree);
if (find_tree->root->count == 1)
{
_gtk_rbtree_remove (find_tree);
}
else
_gtk_rbtree_remove_node (find_tree, find_node);
_gtk_rbtree_test (tree);
}
_gtk_rbtree_free (tree);
}
static void
test_create (void)
{
GtkRBTree *tree;
tree = create_rbtree (5, 5, TRUE);
_gtk_rbtree_free (tree);
}
RBTREE copy_rbtree ( const RBTREE tree, void * (*copyvalue)(const void *) ){
assert(NULL!=tree);
RBTREE newtree = create_rbtree(tree->compfun,tree->copykey,tree->freekey);
if (NULL!=tree->root){
newtree->root = copy_rbnode_sub(tree->root,tree->copykey,copyvalue);
newtree->root->parent = NULL;
}
return newtree;
}
int main ( int argc, char * argv[]) {
unsigned int seed,nelt,keylen;
if ( argc!=4){
printf ("Usage: rbtree seed nelt keylen\n");
return EXIT_FAILURE;
}
sscanf(argv[1],"%u",&seed); srandom(seed);
sscanf(argv[2],"%u",&nelt);
sscanf(argv[3],"%u",&keylen);
RBTREE tree = create_rbtree(lexo,strcopykey,strfreekey);
char ** keys = random_keys(nelt,keylen);
printf ("Inserting elements\n");
for ( int i=0 ; i<nelt ; i++){
printf ("\tinserting %s\n",keys[i]);
insertelt_rbtree(tree,keys[i],"a");
check_rbtree(tree);
}
unsigned int ntree_elt = nmemb_rbtree(tree);
printf ("Tree contains %u elements in total\n",ntree_elt);
assert(ntree_elt<=nelt);
printf ("Copying tree\n");
RBTREE tree2 = copy_rbtree(tree,strcopykey);
check_rbtree(tree2);
printf("Freeing copied tree\n");
free_rbtree(tree2,free);
printf("Printing tree\n");
unsafemap_rbtree (tree,print_node);
printf("Iterating through tree\n");
unsigned int iter_count = 0;
for ( RBITER iter = iter_rbtree(tree) ; next_rbtree(iter) ; ){
const char * key = (const char *) iterkey_rbtree(iter);
printf("\tfound %s\n",key);
iter_count++;
}
assert(iter_count==ntree_elt);
printf ("Removing elements\n");
unsigned int * rperm = random_permutation(nelt);
fputs("Permutation: ",stdout);
print_rperm(rperm,nelt);
for ( int i=0 ; i<nelt ; i++){
printf("\tremoving %s\n",keys[rperm[i]]);
removeelt_rbtree(tree,keys[rperm[i]]);
check_rbtree(tree);
}
assert(nmemb_rbtree(tree)==0);
free_rbtree(tree,free);
}
//---------------rbtree debug------------------------------------//
int
rbtree_test(void)
{
int i, j, len, slice, ret;
struct timeval tv;
struct rbnode node, *pn = NULL;
struct ttlnode *tn = NULL;
struct rbtree *rbt = NULL;
rbt = create_rbtree(rbt_comp_ttl_gt, NULL);
if (rbt == NULL)
dns_error(0, "create rbtree");
node = rbt->nil; //nil
slice = 8000000;
//for(i = 0;i < n;i ++)
//{
for (j = 0; j < slice; j++) {
len = random() % 30;
tn = malloc(sizeof(struct ttlnode) + len);
if (tn == NULL)
printf("oom\n");
tn->exp = j;
for (i = 0; i < len; i++)
tn->data[i] = 'a' + i;
node.key = tn;
ret = insert_node(rbt, &node);
if (ret != 0)
printf("insert error\n");
}
printf("insert all\n");
sleep(2);
for (j = 0; j < slice; j++) {
pn = min_node(rbt);
if (pn != NULL) {
tn = delete_node(rbt, pn);
free(tn);
} else
printf("error\n");
}
printf("delete all\n");
sleep(5);
//}
if (free_rbtree(rbt) != 0)
dns_error(0, "free");
//get_time_usage(&tv,0);
return 0;
}
void create_tree (TREE * tree)
{
const char *tmp;
int old_sp;
assert(NULL==tree->tree);
tmp = tree->tstring;
old_sp = tree->n_sp;
tree->n_sp = 0;
tree->leaves = create_rbtree(lexo,strcopykey,strfreekey);
// Bifurcating tree is upper bound on number of branches
tree->branches = calloc(2*old_sp-3,sizeof(NODE *));
tree->tree = create_tree_sub (&tmp, NULL, tree);
tree->tree->bnumber = tree->n_br;
assert(old_sp == tree->n_sp);
CheckIsTree (tree);
}
static struct server *
server_init(void)
{
struct server *s = malloc(sizeof(struct server));
if (s == NULL)
dns_error(0, "out of memory in server_init");
s->nfetcher = FETCHER_NUM;
s->nquizzer = QUIZZER_NUM;
s->authors = NULL;
s->fetchers = NULL;
s->pkg = 0;
pthread_spin_init(&s->eventlist.lock, 0);
//pthread_mutex_init(&s->lock,NULL);
s->eventlist.head = NULL;
if ((s->ludp = create_listen_ports(SERVER_PORT, UDP, (uchar *)SRV_ADDR)) < 0)
dns_error(0, "can not open udp");
set_sock_buff(s->ludp, 10);
if ((s->ltcp = create_listen_ports(SERVER_PORT, TCP, (uchar *)SRV_ADDR)) < 0)
dns_error(0, "can not open tcp");
s->datasets =
htable_create(NULL, dict_comp_str_equ, HASH_TABLE_SIZE,
MULTI_HASH);
if (s->datasets == NULL)
dns_error(0, "htable create");
s->forward = htable_create(NULL, dict_comp_str_equ, 1024, 1);
if (s->forward == NULL)
dns_error(0, "create forward");
s->qlist =
htable_create(NULL, dict_comp_str_equ,
QLIST_TABLE_SIZE, 1);
if (s->qlist == NULL)
dns_error(0, "create qlist");
s->ttlexp = create_rbtree(rbt_comp_ttl_gt, NULL);
if (s->ttlexp == NULL)
dns_error(0, "create ttl tree");
s->recordsindb = 0;
s->refreshflag = 0;
s->lastrefresh = global_now;
s->is_forward = 0;
return s;
}
TREE *CloneTree (TREE * tree)
{
TREE *tree_new;
CheckIsTree (tree);
tree_new = calloc (1, sizeof (TREE));
if (NULL == tree_new)
return NULL;
tree_new->n_sp = tree->n_sp;
tree_new->n_br = tree->n_br;
tree_new->tstring = malloc ((1 + strlen (tree->tstring)) * sizeof (char));
strcpy (tree_new->tstring, tree->tstring);
tree_new->leaves = create_rbtree(lexo,strcopykey,strfreekey);
tree_new->branches = calloc(tree->n_br,sizeof(NODE *));
tree_new->tree = CloneTree_sub (tree->tree, NULL, tree, tree_new);
CheckIsTree (tree_new);
return tree_new;
}
int main()
{
mmnode ns[10];
int i = 0;
for( ; i < 10; ++i)
{
ns[i].key = i+1;
ns[i].base.key = &ns[i].key;
}
rbtree_t rb = create_rbtree(_comp);
for(i = 0; i < 10; ++i)
rbtree_insert(rb,(rbnode*)&ns[i]);
{
mmnode *n = (mmnode*)rbtree_first(rb);
while(n)
{
printf("%d\n",n->key);
n = (mmnode*)rbnode_next((rbnode*)n);
}
}
rbtree_check_vaild(rb);
mmnode *succ = (mmnode*)rbtree_remove(rb,(void*)&ns[3].key);
printf("%d\n",succ->key);
rbtree_check_vaild(rb);
{
mmnode *n = (mmnode*)rbtree_first(rb);
while(n)
{
printf("%d\n",n->key);
n = (mmnode*)rbnode_next((rbnode*)n);
}
}
{
mmnode *n = (mmnode*)rbtree_last(rb);
while(n)
{
printf("%d\n",n->key);
n = (mmnode*)rbnode_pre((rbnode*)n);
}
}
/*
map_t m = MAP_CREATE(int,int,_comp,NULL);
MAP_INSERT(int,int,m,1,1);
MAP_INSERT(int,int,m,2,2);
MAP_INSERT(int,int,m,3,3);
MAP_INSERT(int,int,m,4,4);
MAP_INSERT(int,int,m,5,5);
MAP_INSERT(int,int,m,6,6);
MAP_INSERT(int,int,m,7,7);
MAP_INSERT(int,int,m,8,8);
MAP_INSERT(int,int,m,9,9);
MAP_INSERT(int,int,m,10,10);
printf("------test iter------\n");
map_iter it = map_begin(m);
map_iter end = map_end(m);
for( ; !IT_EQ(it,end); IT_NEXT(it))
printf("%d\n",IT_GET_VAL(int,it));
printf("------test remove 4------\n");
MAP_REMOVE(int,m,4);
it = map_begin(m);
end = map_end(m);
for( ; !IT_EQ(it,end); IT_NEXT(it))
printf("%d\n",IT_GET_VAL(int,it));
*/
return 0;
}
