World_t *world_create(void)
{
World_t *out = obj_create_autoreleased(&Class_World);
out->cpSpace = cpSpaceNew();
out->cpSpace->data = out;
cpSpaceAddCollisionHandler(out->cpSpace, 0, 0,
collisionWillBegin,
NULL,
collisionDidBegin,
collisionDidEnd, NULL);
out->entities = obj_retain(llist_create((InsertionCallback_t)&obj_retain, &obj_release));
// Create the static entity
out->staticEntity = obj_create(&Class_WorldEntity);
out->staticEntity->world = out;
out->staticEntity->owner = out;
out->staticEntity->cpBody = out->cpSpace->staticBody;
out->staticEntity->luaUpdateHandler = -1;
out->staticEntity->luaPreCollisionHandler = -1;
out->staticEntity->luaCollisionHandler = -1;
out->staticEntity->luaPostCollisionHandler = -1;
out->cpSpace->staticBody->data = out->staticEntity;
out->staticEntity->shapes = obj_retain(llist_create((InsertionCallback_t)&obj_retain, &obj_release));
return out;
}
InputManager_t *input_createManager()
{
InputManager_t *out = obj_create_autoreleased(&Class_InputManager);
out->observers = obj_retain(llist_create((InsertionCallback_t)&obj_retain, (RemovalCallback_t)&obj_release));
out->activeEvents = obj_retain(llist_create(NULL, NULL));
return out;
}
/**
* Initializes File I/O
*/
void _fs_init() {
filelist = llist_create();
fslist = llist_create();
creation_mask = 0777;
nextfh = 3;
// Init current workdir
memset(&workdir,0,sizeof(workdir));
chdir("/");
}
END_TEST
START_TEST ( llist_07_test_stack )
{
int retval;
llist listToTest = NULL;
llist_node retptr;
listToTest = llist_create ( NULL, NULL, test_mt ? MT_SUPPORT_FALSE : MT_SUPPORT_TRUE );
// Push 1000 nodes
for ( unsigned long i = 0; i < 1000; i ++ )
{
retval = llist_push ( listToTest, ( llist_node ) i );
ck_assert_int_eq ( retval, LLIST_SUCCESS );
}
// Peek at the head
retptr = llist_peek ( listToTest );
ck_assert_int_eq ( ( unsigned long ) retptr, 999 );
for ( unsigned long i = 999; i > 0; i-- )
{
retptr = llist_pop ( listToTest );
ck_assert_int_eq ( ( unsigned long ) retptr, i );
}
printf ( "Count = %d\n", llist_size ( listToTest ) );
retptr = llist_pop ( listToTest );
ck_assert_ptr_eq ( retptr, NULL );
llist_destroy ( listToTest, false, NULL );
}
END_TEST
START_TEST ( llist_09_list_sort )
{
int retval;
llist listToTest = NULL;
listToTest = llist_create ( trivial_comperator , NULL, test_mt ? MT_SUPPORT_FALSE : MT_SUPPORT_TRUE );
// Insert a 5 nodes 1..5
retval = llist_add_node ( listToTest, ( llist_node ) 3, ADD_NODE_REAR );
retval = llist_add_node ( listToTest, ( llist_node ) 2, ADD_NODE_REAR );
retval = llist_add_node ( listToTest, ( llist_node ) 1, ADD_NODE_REAR );
retval = llist_add_node ( listToTest, ( llist_node ) 4, ADD_NODE_REAR );
retval = llist_add_node ( listToTest, ( llist_node ) 5, ADD_NODE_REAR );
printf ( "List before sorting: " );
print_llist ( listToTest );
retval = llist_sort ( listToTest, SORT_LIST_ASCENDING );
ck_assert_int_eq ( retval, LLIST_SUCCESS );
printf ( "List After sorting ascending: " );
print_llist ( listToTest );
retval = llist_sort ( listToTest, SORT_LIST_DESCENDING );
ck_assert_int_eq ( retval, LLIST_SUCCESS );
printf ( "List After sorting descending: " );
print_llist ( listToTest );
llist_destroy ( listToTest, false, NULL );
}
/* id can be NULL */
xacml_obligation_t * xacml_obligation_create(const char * id) {
xacml_obligation_t * obligation= calloc(1,sizeof(xacml_obligation_t));
if (obligation == NULL) {
log_error("xacml_obligation_create: can't allocate xacml_obligation_t.");
return NULL;
}
obligation->id= NULL;
if (id != NULL) {
size_t size= strlen(id);
obligation->id= calloc(size + 1,sizeof(char));
if (obligation->id == NULL) {
log_error("xacml_obligation_create: can't allocate id (%d bytes).",(int)size);
free(obligation);
return NULL;
}
strncpy(obligation->id,id,size);
}
obligation->assignments= llist_create();
if (obligation->assignments == NULL) {
log_error("xacml_obligation_create: can't create assignments list.");
free(obligation->id);
free(obligation);
return NULL;
}
obligation->fulfillon= XACML_FULFILLON_DENY;
return obligation;
}
END_TEST
START_TEST ( llist_11_find_min_max )
{
int retval;
llist_node min_max;
llist listToTest = NULL;
listToTest = llist_create ( trivial_comperator, NULL, test_mt ? MT_SUPPORT_FALSE : MT_SUPPORT_TRUE );
// Insert a 5 nodes 1..5
retval = llist_add_node ( listToTest, ( llist_node ) 2, ADD_NODE_REAR );
retval = llist_add_node ( listToTest, ( llist_node ) 5, ADD_NODE_REAR );
retval = llist_add_node ( listToTest, ( llist_node ) 3, ADD_NODE_REAR );
retval = llist_add_node ( listToTest, ( llist_node ) 4, ADD_NODE_REAR );
retval = llist_add_node ( listToTest, ( llist_node ) 1, ADD_NODE_REAR );
retval = llist_get_max( listToTest, &min_max);
ck_assert_int_eq ( retval, LLIST_SUCCESS );
ck_assert_int_eq ( min_max, 5 );
retval = llist_get_min( listToTest, &min_max);
ck_assert_int_eq ( retval, LLIST_SUCCESS );
ck_assert_int_eq ( min_max, 1 );
llist_destroy ( listToTest, false, NULL );
}
static quadtree_node *quadtree_node_create() {
quadtree_node *qn = malloc(sizeof(quadtree_node));
if (!qn) {
return NULL;
}
qn->points = llist_create();
if (!qn->points) {
free(qn);
return NULL;
}
qn->children = malloc(sizeof(quadtree_node *) * 4);
if (!qn->children) {
free(qn->points);
free(qn);
return NULL;
}
for (int i = 0; i < 4; i++) {
qn->children[i] = NULL;
}
return qn;
}
END_TEST
START_TEST ( llist_05_list_for_each )
{
int retval;
llist listToTest = NULL;
listToTest = llist_create ( NULL, NULL, test_mt ? MT_SUPPORT_FALSE : MT_SUPPORT_TRUE );
// Insert a 5 nodes 1..5
retval = llist_add_node ( listToTest, ( llist_node ) 1, ADD_NODE_REAR );
ck_assert_int_eq ( retval, LLIST_SUCCESS );
retval = llist_add_node ( listToTest, ( llist_node ) 2, ADD_NODE_REAR );
ck_assert_int_eq ( retval, LLIST_SUCCESS );
retval = llist_add_node ( listToTest, ( llist_node ) 3, ADD_NODE_REAR );
ck_assert_int_eq ( retval, LLIST_SUCCESS );
retval = llist_add_node ( listToTest, ( llist_node ) 4, ADD_NODE_REAR );
ck_assert_int_eq ( retval, LLIST_SUCCESS );
retval = llist_add_node ( listToTest, ( llist_node ) 5, ADD_NODE_REAR );
ck_assert_int_eq ( retval, LLIST_SUCCESS );
retval = llist_for_each ( listToTest, trivial_node_func );
ck_assert_int_eq ( retval, LLIST_SUCCESS );
llist_destroy ( listToTest, false, NULL );
}
END_TEST
START_TEST ( llist_08_list_reverse )
{
int retval;
llist listToTest = NULL;
listToTest = llist_create ( NULL, NULL, test_mt ? MT_SUPPORT_FALSE : MT_SUPPORT_TRUE );
// Insert a 5 nodes 1..5
retval = llist_add_node ( listToTest, ( llist_node ) 1, ADD_NODE_REAR );
retval = llist_add_node ( listToTest, ( llist_node ) 2, ADD_NODE_REAR );
retval = llist_add_node ( listToTest, ( llist_node ) 3, ADD_NODE_REAR );
retval = llist_add_node ( listToTest, ( llist_node ) 4, ADD_NODE_REAR );
retval = llist_add_node ( listToTest, ( llist_node ) 5, ADD_NODE_REAR );
printf ( "List before reversing: " );
print_llist ( listToTest );
retval = llist_reverse ( listToTest );
ck_assert_int_eq ( retval, LLIST_SUCCESS );
printf ( "List After reversing: " );
print_llist ( listToTest );
llist_destroy ( listToTest, false, NULL );
}
SpriteBatch_t *spriteBatch_create(TextureAtlas_t *aAtlas)
{
SpriteBatch_t *out = obj_create_autoreleased(&Class_SpriteBatch);
out->spriteCount = 0;
out->sprites = obj_retain(llist_create((InsertionCallback_t)&obj_retain, (RemovalCallback_t)&obj_release));
out->displayCallback = (RenderableDisplayCallback_t)&_spriteBatch_draw;
return out;
}
static int register_callback (llist_t **list, /* {{{ */
const char *name, callback_func_t *cf)
{
llentry_t *le;
char *key;
if (*list == NULL)
{
*list = llist_create ();
if (*list == NULL)
{
ERROR ("plugin: register_callback: "
"llist_create failed.");
destroy_callback (cf);
return (-1);
}
}
key = strdup (name);
if (key == NULL)
{
ERROR ("plugin: register_callback: strdup failed.");
destroy_callback (cf);
return (-1);
}
le = llist_search (*list, name);
if (le == NULL)
{
le = llentry_create (key, cf);
if (le == NULL)
{
ERROR ("plugin: register_callback: "
"llentry_create failed.");
free (key);
destroy_callback (cf);
return (-1);
}
llist_append (*list, le);
}
else
{
callback_func_t *old_cf;
old_cf = le->value;
le->value = cf;
WARNING ("plugin: register_callback: "
"a callback named `%s' already exists - "
"overwriting the old entry!", name);
destroy_callback (old_cf);
sfree (key);
}
return (0);
} /* }}} int register_callback */
extern t_symtab *symtab_create(void)
{
t_symtab *symtab = calloc(sizeof(t_symtab), 1);
if (symtab == NULL) {
error_message("Out of memory when creating a symbol table");
exit(-1);
}
symtab->list = llist_create();
return symtab;
}
int create_testcols_table( Arb_connection *conn)
{
int rc;
int col;
COLUMN_DEF *colp;
ARBOR_LLIST *columns;
rc = llist_create( &columns,
LLIST_COMPARISON_FUNC, column_cmp,
LLIST_DELETE_ITEM_FUNC, free,
LLIST_DUPLICATE_STRATEGY, LLIST_DUPLICATES_NOT_ALLOWED,
LLIST_SORT_STRATEGY, LLIST_UNORDERED_LIST,
LLIST_NO_MORE_ARGS);
if( rc != SUCCESS)
abort();
for( col = 0; col < WIDGET_TABLE_NUM_COLS; ++col)
{
colp = (COLUMN_DEF *) calloc (1, sizeof (COLUMN_DEF));
assert( colp != NULL);
colp->row_position = col;
switch(col)
{
case 0: initcol_id(colp); break;
case 1: initcol_quantity(colp); break;
case 2: initcol_category(colp); break;
case 3: initcol_langcode(colp); break;
case 4: initcol_shortdesc(colp); break;
case 5: initcol_wdesc(colp); break;
case 6: initcol_opcode(colp); break;
case 7: initcol_inceptdate(colp); break;
case 8: initcol_termdate(colp); break;
case 9: initcol_weight(colp); break;
case 10: initcol_volume(colp); break;
case 11: initcol_bitflags(colp); break;
case 12: initcol_license(colp); break;
default: abort();
}
rc = llist_insert( columns, colp);
if( rc != SUCCESS)
abort();
} /* loop */
rc = arb_create_table( conn, TABLENAME, columns);
if( rc != SUCCESS)
abort();
llist_delete( columns);
return 0;
}
llist *quadtree_retrieve(quadtree *q, quadtree_rect *r) {
if (!q || !r) {
return NULL;
}
llist *list = llist_create();
if (!list) {
return NULL;
}
return quadtree_retrieve_node(q, q->root, r, list);
}
int rpc_init() {
rpc_functions = llist_create();
rpc_lastid = 0;
if (syscall_create(SYSCALL_RPC_CREATE,rpc_function_create,4)==-1) return -1;
if (syscall_create(SYSCALL_RPC_DESTROY,rpc_function_destroy,1)==-1) return -1;
if (syscall_create(SYSCALL_RPC_GETINFO,rpc_function_getinfo,8)==-1) return -1;
if (syscall_create(SYSCALL_RPC_CALL,rpc_function_call,5)==-1) return -1;
if (syscall_create(SYSCALL_RPC_POLL,rpc_call_poll,4)==-1) return -1;
if (syscall_create(SYSCALL_RPC_RETURN,rpc_call_return,3)==-1) return -1;
if (syscall_create(SYSCALL_RPC_LIST,rpc_list,3)==-1) return -1;
return 0;
}
// void llist_add(struct linkedList* list, double value)
void llist_add(struct linkedList** list, double value) // add node as head
{
struct linkedList *item = llist_create(value);
if(item)
{
item->next = *list;
*list = item;
}
// struct linkedList* item = llist_create(value);
// item->next = list->next;
// list->next = item;
}
/**
* Initializes process management
* @return -1=Success; 0=Failure
*/
int proc_init() {
proc_all = llist_create();
proc_running = llist_create();
proc_sleeping = llist_create();
proc_nextpid = 1;
proc_current = NULL;
if (syscall_create(SYSCALL_PROC_GETPID,proc_getpid,0)==-1) return -1;
if (syscall_create(SYSCALL_PROC_GETUID,proc_getuid,1)==-1) return -1;
if (syscall_create(SYSCALL_PROC_GETGID,proc_getgid,1)==-1) return -1;
if (syscall_create(SYSCALL_PROC_SETUID,proc_setuid,2)==-1) return -1;
if (syscall_create(SYSCALL_PROC_SETGID,proc_setgid,2)==-1) return -1;
if (syscall_create(SYSCALL_PROC_GETPARENT,proc_getparent,1)==-1) return -1;
if (syscall_create(SYSCALL_PROC_GETCHILD,proc_getchild,2)==-1) return -1;
if (syscall_create(SYSCALL_PROC_GETNAME,proc_getname,3)==-1) return -1;
if (syscall_create(SYSCALL_PROC_SETNAME,proc_setname,2)==-1) return -1;
if (syscall_create(SYSCALL_PROC_GETPIDBYNAME,proc_getpidbyname,1)==-1) return -1;
if (syscall_create(SYSCALL_PROC_GETVAR,proc_getvar,1)==-1) return -1;
if (syscall_create(SYSCALL_PROC_SETVAR,proc_setvar,2)==-1) return -1;
if (syscall_create(SYSCALL_PROC_EXIT,proc_exit,1)==-1) return -1;
if (syscall_create(SYSCALL_PROC_ABORT,proc_abort,0)==-1) return -1;
if (syscall_create(SYSCALL_PROC_STOP,proc_stop,0)==-1) return -1;
if (syscall_create(SYSCALL_PROC_CREATE,proc_create_syscall,4)==-1) return -1;
if (syscall_create(SYSCALL_PROC_DESTROY,proc_destroy_syscall,1)==-1) return -1;
if (syscall_create(SYSCALL_PROC_MEMMAP,proc_memmap,6)==-1) return -1;
if (syscall_create(SYSCALL_PROC_MEMALLOC,proc_memalloc,4)==-1) return -1;
if (syscall_create(SYSCALL_PROC_MEMUNMAP,proc_memunmap,2)==-1) return -1;
if (syscall_create(SYSCALL_PROC_MEMFREE,proc_memfree,2)==-1) return -1;
if (syscall_create(SYSCALL_PROC_MEMGET,proc_memget,6)==-1) return -1;
if (syscall_create(SYSCALL_PROC_MEMPAGELIST,proc_mempagelist,6)==-1) return -1;
if (syscall_create(SYSCALL_PROC_SYSTEM,proc_system,2)==-1) return -1;
if (syscall_create(SYSCALL_PROC_JUMP,proc_jump,2)==-1) return -1;
if (syscall_create(SYSCALL_PROC_CREATESTACK,proc_createstack,1)==-1) return -1;
if (syscall_create(SYSCALL_PROC_GETSTACK,proc_getstack,1)==-1) return -1;
if (syscall_create(SYSCALL_PROC_SETSTACK,proc_setstack,2)==-1) return -1;
if (syscall_create(SYSCALL_PROC_WAITPID,proc_waitpid,3)==-1) return -1;
return 0;
}
static int mr_config_add_meta_regex(llist_t **meta, /* {{{ */
oconfig_item_t *ci) {
char *meta_key;
llentry_t *entry;
mr_regex_t *re_head;
int status;
char buffer[1024];
if ((ci->values_num != 2) || (ci->values[0].type != OCONFIG_TYPE_STRING) ||
(ci->values[1].type != OCONFIG_TYPE_STRING)) {
log_warn("`%s' needs exactly two string arguments.", ci->key);
return -1;
}
if (*meta == NULL) {
*meta = llist_create();
if (*meta == NULL) {
log_err("mr_config_add_meta_regex: llist_create failed.");
return -1;
}
}
meta_key = ci->values[0].value.string;
entry = llist_search(*meta, meta_key);
if (entry == NULL) {
meta_key = strdup(meta_key);
if (meta_key == NULL) {
log_err("mr_config_add_meta_regex: strdup failed.");
return -1;
}
entry = llentry_create(meta_key, NULL);
if (entry == NULL) {
log_err("mr_config_add_meta_regex: llentry_create failed.");
sfree(meta_key);
return -1;
}
/* meta_key and entry will now be freed by mr_free_match(). */
llist_append(*meta, entry);
}
snprintf(buffer, sizeof(buffer), "%s `%s'", ci->key, meta_key);
/* Can't pass &entry->value into mr_add_regex, so copy in/out. */
re_head = entry->value;
status = mr_add_regex(&re_head, ci->values[1].value.string, buffer);
if (status == 0) {
entry->value = re_head;
}
return status;
} /* }}} int mr_config_add_meta_regex */
int main()
{
struct score tmp,*datap;
int i,id,ret;
char name[] = "sstu1";
LLIST *handle;
handle = llist_create(sizeof(struct score));
if(handle == NULL)
return -1;
for(i = 0; i < 6 ;i++)
{
tmp.id = i;
tmp.math = 100-i;
snprintf(tmp.name,NAMESIZE,"stu%d",i);
llist_insert(handle,&tmp,LLIST_BACKWARD);
}
llist_travel(handle,print_s);
printf("\n\n");
id = 3;
ret = llist_fetch(handle,&id,id_cmp,&tmp);
if(ret != -1)
print_s(&tmp);
printf("\n\n");
llist_travel(handle,print_s);
llist_destroy(handle);
// llist_delete(handle,&id,id_cmp);
// llist_travel(handle,print_s);
#if 0
// datap = llist_find(handle,&id,id_cmp);
datap = llist_find(handle,name,name_cmp);
if(datap == NULL)
printf("can not find!\n");
else
print_s(datap);
#endif
return 0;
}
xacml_response_t * xacml_response_create() {
xacml_response_t * response= calloc(1,sizeof(xacml_response_t));
if (response == NULL) {
log_error("xacml_response_create: can't allocate xacml_response_t.");
return NULL;
}
response->results= llist_create();
if (response->results == NULL) {
log_error("xacml_response_create: can't create results list.");
free(response);
return NULL;
}
response->request= NULL;
return response;
}
int evdev_register_device(evdev_device_info_t *info)
{
dev_t minor;
evdev_device_t *dev = heapmm_alloc(sizeof(evdev_device_t));
if (!dev)
return ENOMEM;
minor = evdev_minor_counter++;
dev->info = info;
dev->queue_count = 0;
dev->event_wait = 0;
llist_create(&(dev->queue));
evdev_list[minor] = dev;
info->device = MAKEDEV(EVDEV_MAJOR, minor);
return 0;
}
t_llist *array_to_llist(void **array, size_t size, size_t val_size)
{
t_llist *list;
size_t i;
llist_create(&list);
if (list == NULL)
return (NULL);
i = 0;
while (i < size)
{
llist_add_last(list, array[i], val_size);
i++;
}
return (list);
}
static int powerdns_config (oconfig_item_t *ci) /* {{{ */
{
int i;
DEBUG ("powerdns plugin: powerdns_config (ci = %p);", (void *) ci);
if (list == NULL)
{
list = llist_create ();
if (list == NULL)
{
ERROR ("powerdns plugin: `llist_create' failed.");
return (-1);
}
}
for (i = 0; i < ci->children_num; i++)
{
oconfig_item_t *option = ci->children + i;
if ((strcasecmp ("Server", option->key) == 0)
|| (strcasecmp ("Recursor", option->key) == 0))
powerdns_config_add_server (option);
else if (strcasecmp ("LocalSocket", option->key) == 0)
{
if ((option->values_num != 1) || (option->values[0].type != OCONFIG_TYPE_STRING))
{
WARNING ("powerdns plugin: `%s' needs exactly one string argument.", option->key);
}
else
{
char *temp = strdup (option->values[0].value.string);
if (temp == NULL)
return (1);
sfree (local_sockpath);
local_sockpath = temp;
}
}
else
{
ERROR ("powerdns plugin: Option `%s' not allowed here.", option->key);
}
} /* for (i = 0; i < ci->children_num; i++) */
return (0);
} /* }}} int powerdns_config */
/**************************************************************************//**
*
* mss_timer_init
*
* @brief initialize mss timer module
*
* @param -
*
* @return -
*
******************************************************************************/
void mss_timer_init(void)
{
uint8_t i;
// initialize timer blocks
for(i=0 ; i<MSS_MAX_NUM_OF_TIMER ; i++)
{
timer_tbl[i].task_id = MSS_INVALID_TASK_ID;
timer_tbl[i].state = MSS_TIMER_STATE_IDLE;
timer_tbl[i].expired_tick = 0;
timer_tbl[i].reload_tick = 0;
}
// initialize linked list timer
active_timer_llist = llist_create();
MSS_DEBUG_CHECK(active_timer_llist != LLIST_INVALID_HDL);
}
WorldEntity_t *worldEnt_create(World_t *aWorld, Obj_t *aOwner, GLMFloat aMass, GLMFloat amoment)
{
WorldEntity_t *out = obj_create_autoreleased(&Class_WorldEntity);
out->world = aWorld;
out->owner = aOwner;
out->cpBody = cpBodyNew(aMass, amoment);
out->cpBody->data = out;
out->shapes = obj_retain(llist_create((InsertionCallback_t)&obj_retain, &obj_release));
out->luaUpdateHandler = -1;
out->luaPreCollisionHandler = -1;
out->luaCollisionHandler = -1;
out->luaPostCollisionHandler = -1;
return out;
}
static int cdrom_init() {
if (cdrom_buf_init()==-1) return -1;
devfs_init();
cdrom_devices = llist_create();
llist_t list = rpc_list();
char *name;
while ((name = llist_pop(list))) {
if (strncmp(name,"scsi_request_atapi",18)==0) {
char *dev = name+13; // dev = "atapiXX"
if (cdrom_device_init(dev)==-1) fprintf(stderr,"Could not initialize ATAPI device %s\n",dev);
}
free(name);
}
llist_destroy(list);
return 0;
}
int main()
{
LLIST *handle;
int i ,ret, id = 3;
char *name = "person2";
struct person_st tmp, *datap;
handle = llist_create(sizeof(struct person_st));
if(handle== NULL)
return -1;
for(i = 0; i < 6; i++)
{
tmp.id = i;
tmp.age = 20 + i;
snprintf(tmp.name,NAMESIZE,"person%d",i);
llist_insert(handle,&tmp,LLIST_FORWARD);
}
llist_travel(handle,print_s);
printf("\n\n");
ret = llist_fetch(handle,name,name_cmp,&tmp);
if(ret == 0)
print_s(&tmp);
printf("\n\n");
// llist_delete(handle,&id,id_cmp);
// llist_travel(handle,print_s);
#if 0
//datap = llist_find(handle,&id,id_cmp);
datap = llist_find(handle,name,name_cmp);
if(datap == NULL)
printf("ca not find!\n");
else
print_s(datap);
#endif
llist_destroy(handle);
return 0;
}
static int powerdns_config (oconfig_item_t *ci) /* {{{ */
{
int i;
DEBUG ("powerdns plugin: powerdns_config (ci = %p);", (void *) ci);
if (list == NULL)
{
list = llist_create ();
if (list == NULL)
{
ERROR ("powerdns plugin: `llist_create' failed.");
return (-1);
}
}
for (i = 0; i < ci->children_num; i++)
{
oconfig_item_t *option = ci->children + i;
if ((strcasecmp ("Server", option->key) == 0)
|| (strcasecmp ("Recursor", option->key) == 0))
powerdns_config_add_server (option);
else if (strcasecmp ("LocalSocket", option->key) == 0)
{
char *temp = strdup (option->key);
if (temp == NULL)
return (1);
sfree (local_sockpath);
local_sockpath = temp;
}
else
{
ERROR ("powerdns plugin: Option `%s' not allowed here.", option->key);
}
} /* for (i = 0; i < ci->children_num; i++) */
return (0);
} /* }}} int powerdns_config */
END_TEST
START_TEST ( llist_03_add_dynamic_nodes )
{
int retval;
int *data[5];
for ( int i = 0; i < 5; i++ )
{
data[i] = malloc ( sizeof ( int ) );
}
llist listToTest = NULL;
llist_node retptr;
listToTest = llist_create ( NULL, trivial_equal, test_mt ? MT_SUPPORT_FALSE : MT_SUPPORT_TRUE );
// Insert a 5 nodes 1..5
retval = llist_add_node ( listToTest, ( llist_node ) data[0], ADD_NODE_FRONT );
ck_assert_int_eq ( retval, LLIST_SUCCESS );
retval = llist_add_node ( listToTest, ( llist_node ) data[1], ADD_NODE_REAR );
ck_assert_int_eq ( retval, LLIST_SUCCESS );
retval = llist_add_node ( listToTest, ( llist_node ) data[2], ADD_NODE_FRONT );
ck_assert_int_eq ( retval, LLIST_SUCCESS );
retval = llist_add_node ( listToTest, ( llist_node ) data[3], ADD_NODE_REAR );
ck_assert_int_eq ( retval, LLIST_SUCCESS );
retval = llist_add_node ( listToTest, ( llist_node ) data[4], ADD_NODE_FRONT );
ck_assert_int_eq ( retval, LLIST_SUCCESS );
// find node
retval = llist_find_node ( listToTest, ( llist_node ) data[2], &retptr );
ck_assert_int_eq ( retval, LLIST_SUCCESS );
ck_assert_ptr_eq ( retptr, ( llist_node ) data[2] );
// destroy list, and also free the data
llist_destroy ( listToTest, true, NULL );
}
