From 8dd91e1e56cc2d74b4327dedd50ba63fc794c828 Mon Sep 17 00:00:00 2001 From: Andreas Schneider Date: Tue, 20 May 2008 12:05:53 +0200 Subject: [PATCH] Add test for c_list functions. --- tests/CMakeLists.txt | 1 + tests/std_tests/check_std_c_list.c | 354 +++++++++++++++++++++++++++++ 2 files changed, 355 insertions(+) create mode 100644 tests/std_tests/check_std_c_list.c diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index adbfa9920f..baff29c1ad 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -22,6 +22,7 @@ macro_add_check_test(check_std_c_alloc std_tests/check_std_c_alloc.c ${TEST_TARG macro_add_check_test(check_std_c_dir std_tests/check_std_c_dir.c ${TEST_TARGET_LIBRARIES}) macro_add_check_test(check_std_c_file std_tests/check_std_c_file.c ${TEST_TARGET_LIBRARIES}) macro_add_check_test(check_std_c_jhash std_tests/check_std_c_jhash.c ${TEST_TARGET_LIBRARIES}) +macro_add_check_test(check_std_c_list std_tests/check_std_c_list.c ${TEST_TARGET_LIBRARIES}) macro_add_check_test(check_std_c_path std_tests/check_std_c_path.c ${TEST_TARGET_LIBRARIES}) macro_add_check_test(check_std_c_rbtree std_tests/check_std_c_rbtree.c ${TEST_TARGET_LIBRARIES}) macro_add_check_test(check_std_c_str std_tests/check_std_c_str.c ${TEST_TARGET_LIBRARIES}) diff --git a/tests/std_tests/check_std_c_list.c b/tests/std_tests/check_std_c_list.c new file mode 100644 index 0000000000..2fcbacdbb1 --- /dev/null +++ b/tests/std_tests/check_std_c_list.c @@ -0,0 +1,354 @@ +#include +#include + +#include "support.h" + +#include "std/c_list.h" + +static c_list_t *list = NULL; + +typedef struct test_s { + int key; + int number; +} test_t; + +/* compare function for sorting */ +static int list_cmp(const void *key, const void *data) { + test_t *a, *b; + + a = (test_t *) key; + b = (test_t *) data; + + if (a->key < b->key) { + return -1; + } else if (a->key > b->key) { + return 1; + } + + return 0; +} + +static void setup_complete_list(void) { + int i = 0; + srand(1); + + for (i = 0; i < 100; i++) { + test_t *testdata = NULL; + + testdata = c_malloc(sizeof(test_t)); + fail_if(testdata == NULL, NULL); + + testdata->key = i; + testdata->number = rand() % 100; + + list = c_list_append(list, (void *) testdata); + + fail_if(list == NULL, "Setup failed"); + } +} + +static void setup_random_list(void) { + int i = 0; + srand(1); + + for (i = 0; i < 100; i++) { + test_t *testdata = NULL; + + testdata = c_malloc(sizeof(test_t)); + fail_if(testdata == NULL, NULL); + + testdata->key = i; + testdata->number = rand() % 100; + + /* random insert */ + if (testdata->number > 49) { + list = c_list_prepend(list, (void *) testdata); + } else { + list = c_list_append(list, (void *) testdata); + } + + fail_if(list == NULL, "Setup failed"); + } +} + +static void teardown_destroy_list(void) { + c_list_t *walk = NULL; + + for (walk = c_list_first(list); walk != NULL; walk = c_list_next(walk)) { + test_t *data = NULL; + + data = (test_t *) walk->data; + SAFE_FREE(data); + } + c_list_free(list); + list = NULL; +} + +/* + * Start tests + */ +START_TEST (check_c_list_alloc) +{ + c_list_t *new = NULL; + new = c_list_alloc(); + fail_if(new == NULL, NULL); + + SAFE_FREE(new); +} +END_TEST + +START_TEST (check_c_list_remove_null) +{ + fail_unless(c_list_remove(NULL, NULL) == NULL, NULL); +} +END_TEST + +START_TEST (check_c_list_append) +{ + list = c_list_append(list, (void *) 5); + fail_if(list == NULL, NULL); + + list = c_list_remove(list, (void *) 5); + fail_unless(list == NULL, NULL); +} +END_TEST + +START_TEST (check_c_list_prepend) +{ + list = c_list_prepend(list, (void *) 5); + fail_if(list == NULL, NULL); + + list = c_list_remove(list, (void *) 5); + fail_unless(list == NULL, NULL); +} +END_TEST + +START_TEST (check_c_list_first) +{ + c_list_t *first = NULL; + test_t *data = NULL; + + first = c_list_first(list); + fail_if(first == NULL); + + data = first->data; + fail_unless(data->key == 0, NULL); +} +END_TEST + +START_TEST (check_c_list_last) +{ + c_list_t *last = NULL; + test_t *data = NULL; + + last = c_list_last(list); + fail_if(last == NULL); + + data = last->data; + fail_unless(data->key == 99, NULL); +} +END_TEST + +START_TEST (check_c_list_next) +{ + c_list_t *first = NULL; + c_list_t *next = NULL; + test_t *data = NULL; + + first = c_list_first(list); + fail_if(first == NULL); + next = c_list_next(first); + fail_if(next == NULL); + + data = next->data; + fail_unless(data->key == 1, NULL); +} +END_TEST + +START_TEST (check_c_list_prev) +{ + c_list_t *last = NULL; + c_list_t *prev = NULL; + test_t *data = NULL; + + last = c_list_last(list); + fail_if(last == NULL); + prev = c_list_prev(last); + fail_if(prev == NULL); + + data = prev->data; + fail_unless(data->key == 98, NULL); +} +END_TEST + +START_TEST (check_c_list_length) +{ + unsigned long len = 0; + + len = c_list_length(list); + fail_unless(len == 100, "len = %lu", len); +} +END_TEST + +START_TEST (check_c_list_position) +{ + c_list_t *pos = NULL; + test_t *data = NULL; + + pos = c_list_position(list, 50); + fail_if(pos == NULL, NULL); + + data = pos->data; + fail_unless(data->key == 50, "key: %d", data->key); +} +END_TEST + +START_TEST (check_c_list_insert) +{ + c_list_t *pos = NULL; + test_t *data = NULL; + + data = c_malloc(sizeof(test_t)); + fail_if(data == NULL, NULL); + + data->key = data->number = 123; + + list = c_list_insert(list, (void *) data, 50); + data = NULL; + + pos = c_list_position(list, 50); + fail_if(pos == NULL, NULL); + + data = pos->data; + fail_unless(data->key == 123, "key: %d", data->key); +} +END_TEST + +START_TEST (check_c_list_find) +{ + c_list_t *find = NULL; + test_t *data = NULL; + + data = c_malloc(sizeof(test_t)); + fail_if(data == NULL, NULL); + + data->key = data->number = 123; + + list = c_list_insert(list, (void *) data, 50); + + find = c_list_find(list, data); + fail_unless(data == (test_t *) find->data, NULL); +} +END_TEST + +START_TEST (check_c_list_find_custom) +{ + c_list_t *find = NULL; + test_t *data = NULL; + + data = c_malloc(sizeof(test_t)); + fail_if(data == NULL, NULL); + + data->key = data->number = 123; + + list = c_list_insert(list, (void *) data, 50); + + find = c_list_find_custom(list, data, list_cmp); + fail_unless(data == (test_t *) find->data, NULL); +} +END_TEST + +START_TEST (check_c_list_insert_sorted) +{ + int i = 0; + c_list_t *walk = NULL; + c_list_t *new = NULL; + test_t *data = NULL; + + /* create the list */ + for (walk = c_list_first(list); walk != NULL; walk = c_list_next(walk)) { + new = c_list_insert_sorted(new, walk->data, list_cmp); + } + + /* check the list */ + for (walk = c_list_first(new); walk != NULL; walk = c_list_next(walk)) { + data = (test_t *) walk->data; + fail_unless(data->key == i, "key: %d, i: %d", data->key, i); + i++; + } + + c_list_free(new); +} +END_TEST + +START_TEST (check_c_list_sort) +{ + int i = 0; + test_t *data = NULL; + c_list_t *walk = NULL; + + /* sort list */ + list = c_list_sort(list, list_cmp); + fail_if(list == NULL, NULL); + + /* check the list */ + for (walk = c_list_first(list); walk != NULL; walk = c_list_next(walk)) { + data = (test_t *) walk->data; + fail_unless(data->key == i, "key: %d, i: %d", data->key, i); + i++; + } +} +END_TEST + +#if 0 +START_TEST (check_c_list_x) +{ +} +END_TEST +#endif + +static Suite *make_std_c_suite(void) { + Suite *s = suite_create("std:path:c_basename"); + + create_case(s, "check_c_list_alloc", check_c_list_alloc); + create_case(s, "check_c_list_remove_null", check_c_list_remove_null); + create_case(s, "check_c_list_append", check_c_list_append); + create_case(s, "check_c_list_prepend", check_c_list_prepend); + create_case_fixture(s, "check_c_list_first", check_c_list_first, setup_complete_list, teardown_destroy_list); + create_case_fixture(s, "check_c_list_last", check_c_list_last, setup_complete_list, teardown_destroy_list); + create_case_fixture(s, "check_c_list_next", check_c_list_next, setup_complete_list, teardown_destroy_list); + create_case_fixture(s, "check_c_list_prev", check_c_list_prev, setup_complete_list, teardown_destroy_list); + create_case_fixture(s, "check_c_list_length", check_c_list_length, setup_complete_list, teardown_destroy_list); + create_case_fixture(s, "check_c_list_position", check_c_list_position, setup_complete_list, teardown_destroy_list); + create_case_fixture(s, "check_c_list_find", check_c_list_find, setup_complete_list, teardown_destroy_list); + create_case_fixture(s, "check_c_list_find_custom", check_c_list_find_custom, setup_complete_list, teardown_destroy_list); + create_case_fixture(s, "check_c_list_insert", check_c_list_insert, setup_complete_list, teardown_destroy_list); + create_case_fixture(s, "check_c_list_insert_sorted", check_c_list_insert_sorted, setup_random_list, teardown_destroy_list); + create_case_fixture(s, "check_c_list_sort", check_c_list_sort, setup_random_list, teardown_destroy_list); + + return s; +} + +int main(int argc, char **argv) { + Suite *s = NULL; + SRunner *sr = NULL; + struct argument_s arguments; + int nf; + + ZERO_STRUCT(arguments); + + cmdline_parse(argc, argv, &arguments); + + s = make_std_c_suite(); + + sr = srunner_create(s); + if (arguments.nofork) { + srunner_set_fork_status(sr, CK_NOFORK); + } + srunner_run_all(sr, CK_VERBOSE); + nf = srunner_ntests_failed(sr); + srunner_free(sr); + + return (nf == 0) ? EXIT_SUCCESS : EXIT_FAILURE; +} +