static int dlist_int_test()
{
printf("double list test ... MAX=%d\n", MAX);
int arr[MAX];
int i;
int sum = 0;
int max = INT_MIN;
printf("MAX = %d\n", MAX);
struct dlist *list = dlist_init();
if (list) {
/*
* init arr
*/
for (i = 0; i < MAX; i++) {
arr[i] = i;
}
/*
* dlist_add/dlist_length test
*/
for (i = 0; i < MAX; i++) {
dlist_add(list, arr + i);
assert(dlist_length(list) == i + 1);
}
/*
* dlist_serch test
*/
for (i = 0; i < MAX; i++) {
assert(dlist_search(list, arr + i) == DLIST_RET_OK);
}
/*
* dlist_printf test
*/
assert(dlist_printf(list, user_printf) == DLIST_RET_OK);
assert(dlist_foreach(list, sum_cb, &sum) == DLIST_RET_OK);
assert(dlist_foreach(list, max_cb, &max) == DLIST_RET_OK);
/*
* dlist_delete test
*/
for (i = MAX - 1; i >= 0; i--) {
assert(dlist_length(list) == i + 1);
assert(dlist_delete(list, arr + i) == DLIST_RET_OK);
assert(dlist_length(list) == i);
}
/*
* dlist_destroy test
*/
assert(dlist_destroy(list) == DLIST_RET_OK);
}
printf("sum = %d\n", sum);
printf("max = %d\n", max);
return 0;
}
void htable_foreach(htable_t* ht, op_unary_t do_what)
{
int i;
for (i = 0; i < ht->size; i++) {
dlist_foreach(&ht->buckets[i], do_what);
}
}
int main() {
dlist *list;
list = dlist_new();
dlist_append(list, strdup("one"));
dlist_append(list, strdup("two"));
dlist_foreach(list, print_string_cb, NULL);
dlist_foreach(list, string_to_upper_cb, NULL);
dlist_foreach(list, print_string_cb, NULL);
dlist_foreach(list, free_string_cb, NULL);
dlist_free(list);
return 0;
}
static void test_int_dlist(void)
{
int i = 0;
int n = 100;
int data = 0;
DList* dlist = dlist_create(NULL, NULL, NULL);
for(i = 0; i < n; i++)
{
assert(dlist_append(dlist, (void*)i) == RET_OK);
assert(dlist_length(dlist) == (i + 1));
assert(dlist_get_by_index(dlist, i, (void**)&data) == RET_OK);
assert(data == i);
assert(dlist_set_by_index(dlist, i, (void*)(2*i)) == RET_OK);
assert(dlist_get_by_index(dlist, i, (void**)&data) == RET_OK);
assert(data == 2*i);
assert(dlist_set_by_index(dlist, i, (void*)i) == RET_OK);
assert(dlist_find(dlist, cmp_int, (void*)i) == i);
}
for(i = 0; i < n; i++)
{
assert(dlist_get_by_index(dlist, 0, (void**)&data) == RET_OK);
assert(data == (i));
assert(dlist_length(dlist) == (n-i));
assert(dlist_delete(dlist, 0) == RET_OK);
assert(dlist_length(dlist) == (n-i-1));
if((i + 1) < n)
{
assert(dlist_get_by_index(dlist, 0, (void**)&data) == RET_OK);
assert((int)data == (i+1));
}
}
assert(dlist_length(dlist) == 0);
for(i = 0; i < n; i++)
{
assert(dlist_prepend(dlist, (void*)i) == RET_OK);
assert(dlist_length(dlist) == (i + 1));
assert(dlist_get_by_index(dlist, 0, (void**)&data) == RET_OK);
assert(data == i);
assert(dlist_set_by_index(dlist, 0, (void*)(2*i)) == RET_OK);
assert(dlist_get_by_index(dlist, 0, (void**)&data) == RET_OK);
assert(data == 2*i);
assert(dlist_set_by_index(dlist, 0, (void*)i) == RET_OK);
}
i = n - 1;
assert(dlist_foreach(dlist, check_and_dec_int, &i) == RET_OK);
dlist_destroy(dlist);
return;
}
static int fds_select(struct timeval *timeout)
{
fd_set rfds, *rfdsp;
fd_set wfds, *wfdsp;
int count, nfds = -1;
/* concat any new fds to monitor now */
dlist_foreach(read_queue, fd_poll_setlist, read_fds);
dlist_concat(read_fds, read_queue);
dlist_foreach(write_queue, fd_poll_setlist, write_fds);
dlist_concat(write_fds, write_queue);
/* compose the sets of file descriptors to monitor */
rfdsp = fds_select_assemble(read_fds, &rfds, &nfds);
wfdsp = fds_select_assemble(write_fds, &wfds, &nfds);
/* find out which file descriptors have an event */
#ifdef _WIN32
if(nfds == -1)
{
if(timeout != NULL && timeout->tv_sec >= 0 && timeout->tv_usec >= 0)
Sleep((timeout->tv_sec * 1000) + (timeout->tv_usec / 1000));
count = 0;
}
else
#endif
if((count = select(nfds+1, rfdsp, wfdsp, NULL, timeout)) < 0)
{
printerror(errno, strerror, __func__, "select failed");
return -1;
}
/* if there are fds to check, then check them */
if(count > 0)
{
fds_select_check(rfdsp, read_fds, &count);
fds_select_check(wfdsp, write_fds, &count);
}
return 0;
}
void connline_cleanup(void)
{
dlist_foreach(contexts_list, __cleanup_context);
dlist_free_all(contexts_list);
contexts_list = NULL;
__connline_cleanup_event_loop(dbus_cnx);
if (dbus_cnx != NULL)
dbus_connection_unref(dbus_cnx);
dbus_cnx = NULL;
}
static void test_invalid_params(void)
{
printf("===========Warning is normal begin==============\n");
assert(dlist_length(NULL) == 0);
assert(dlist_prepend(NULL, 0) == RET_INVALID_PARAMS);
assert(dlist_append(NULL, 0) == RET_INVALID_PARAMS);
assert(dlist_delete(NULL, 0) == RET_INVALID_PARAMS);
assert(dlist_insert(NULL, 0, 0) == RET_INVALID_PARAMS);
assert(dlist_set_by_index(NULL, 0, 0) == RET_INVALID_PARAMS);
assert(dlist_get_by_index(NULL, 0, NULL) == RET_INVALID_PARAMS);
assert(dlist_find(NULL, NULL, NULL) < 0);
assert(dlist_foreach(NULL, NULL, NULL) == RET_INVALID_PARAMS);
printf("===========Warning is normal end==============\n");
return;
}
Ret hash_table_foreach(HashTable* thiz, DataVisitFunc visit, void* ctx)
{
size_t i = 0;
return_val_if_fail(thiz != NULL && visit != NULL, RET_INVALID_PARAMS);
for(i = 0; i < thiz->slot_nr; i++)
{
if(thiz->slots[i] != NULL)
{
dlist_foreach(thiz->slots[i], visit, ctx);
}
}
return RET_OK;
}
static int dlist_char_test()
{
char str[] = "dlist";
char str2[] = "thinking";
struct dlist *list = dlist_init();
assert(list != NULL);
return_val_if_fail(dlist_length(list) == 0, -1);
char *pstr = NULL;
dlist_add(list, str);
return_val_if_fail(dlist_length(list) == 1, -1);
dlist_add(list, str2);
dlist_add(list, pstr = strdup("test"));
dlist_foreach(list, string_toupper_cb, NULL);
dlist_printf(list, string_printf);
dlist_destroy(list);
list = NULL;
free(pstr);
return 0;
}
int main(int argc, char* argv[])
{
int i = 0;
int n = 101;
int last = n - 1;
DList* dlist = dlist_create(NULL, NULL);
for (i = 0; i < n; i++) {
dlist_append(dlist, (void*)i);
}
Iterator* forward = dlist_iterator_create(dlist);
Iterator* backward = dlist_iterator_create(dlist);
iterator_advance(backward, last);
invert(forward, backward);
dlist_foreach(dlist, check_and_dec_int, &last);
iterator_destroy(forward);
iterator_destroy(backward);
dlist_destroy(dlist);
return 0;
}
int main(int argc, char** argv)
{
char** groups;
int i;
int j;
DList* items_list;
printf("\n************ ini parser test *************\n");
INIParser* parser = ini_parser_create();
INIBuilder* builder = ini_builder_list_create();
ini_parser_set_builder(parser, builder);
ini_parser_load_from_file(parser, TEST_FILE, '#', '=');
items_list = ini_builder_get_list(builder);
dlist_foreach(items_list, data_visit_func, NULL);
/*
groups = ini_parser_get_groups(parser);
for (i = 0; groups[i] != NULL; i++) {
char** keys;
keys = ini_parser_get_keys(parser, groups[i]);
for (j = 0; keys[j] != NULL; j++) {
char* value = ini_parser_get_value(parser, groups[i], keys[j]);
printf("[%s]: %s = %s\n", groups[i], keys[j], value);
}
} */
ini_builder_destroy(builder);
ini_parser_destroy(parser);
return 0;
}
void __connline_reconnect_contexts(void)
{
dlist_foreach(contexts_list, reconnect_context);
}
void __connline_invalidate_contexts(void)
{
dlist_foreach(contexts_list, invalidate_context);
}
void dlist_free_external( struct dlistnode** list )
{
if( !list || !(*list) )
return;
dlist_foreach( list, freenode );
}
static Ret linear_container_dlist_foreach(LinearContainer* thiz, DataVisitFunc visit, void* ctx)
{
PrivInfo* priv = (PrivInfo*)thiz->priv;
return dlist_foreach(priv->dlist, visit, ctx);
}
Ret queue_foreach(Queue* thiz, DataVisitFunc visit, void* ctx)
{
return_val_if_fail(thiz != NULL && visit != NULL, RET_INVALID_PARAMS);
return dlist_foreach(thiz->dlist, visit, ctx);
}
void __connline_disconnect_contexts(void)
{
dlist_foreach(contexts_list, disconnect_context);
}
