Sapian
/
asterisk
mirror of http://gerrit.asterisk.org/asterisk
3
0
Fork 0
Code Issues Releases Wiki Activity

Doubly linked lists unit test and update to implementation.

Browse Source 
Update the doubly linked list implementation.  Now safe traversing can
insert before and after the current node when traversing in either
direction.

Updated the linked lists unit test test_linkedlist to also test doubly
linked lists.  The old test_dlinkedlist requires a manual check of results
and probably should be removed.

Review: https://reviewboard.asterisk.org/r/1569/


git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@347110 65c4cc65-6c06-0410-ace0-fbb531ad65f3
certified/11.2
Richard Mudgett 14 years ago
parent b8dba87a4c
commit ca41b4aba0
2 changed files with 1442 additions and 857 deletions
Show Stats Download Patch File Download Diff File

1918
include/asterisk/dlinkedlists.h
View File

File diff suppressed because it is too large Load Diff

381
tests/test_linkedlists.c
Unescape View File

@ -37,10 +37,12 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
#include "asterisk/strings.h"
#include "asterisk/logger.h"
#include "asterisk/linkedlists.h"
#include "asterisk/dlinkedlists.h"
struct test_val {
const char *name;
AST_LIST_ENTRY(test_val) list;
AST_DLLIST_ENTRY(test_val) dbl_list;
};
static struct test_val a = { "A" };
@ -49,6 +51,7 @@ static struct test_val c = { "C" };
static struct test_val d = { "D" };
AST_LIST_HEAD_NOLOCK(test_llist, test_val);
AST_DLLIST_HEAD_NOLOCK(test_dbl_llist, test_val);
static int list_expect(struct test_llist *test_list, const char *expect, struct ast_str **buf)
{
@ -62,6 +65,43 @@ static int list_expect(struct test_llist *test_list, const char *expect, struct
return strcmp(expect, ast_str_buffer(*buf));
}
static int dbl_list_expect_forward(struct test_dbl_llist *test_list, const char *expect, struct ast_str **buf)
{
struct test_val *i;
ast_str_reset(*buf);
AST_DLLIST_TRAVERSE(test_list, i, dbl_list) {
ast_str_append(buf, 0, "%s", i->name);
}
return strcmp(expect, ast_str_buffer(*buf));
}
static int dbl_list_expect_reverse(struct test_dbl_llist *test_list, const char *expect, struct ast_str **buf)
{
struct test_val *i;
char *str;
int len = strlen(expect);
int idx;
ast_str_reset(*buf);
AST_DLLIST_TRAVERSE_BACKWARDS(test_list, i, dbl_list) {
ast_str_append(buf, 0, "%s", i->name);
}
/* Check reverse string. */
str = ast_str_buffer(*buf);
if (len != strlen(str)) {
return 1;
}
for (idx = 0; idx < len; ++idx) {
if (expect[idx] != str[len - idx - 1]) {
return 1;
}
}
return 0;
}
#define MATCH_OR_FAIL(list, val, retbuf) \
if (list_expect(list, val, &retbuf)) { \
ast_test_status_update(test, "Expected: %s, Got: %s\n", val, ast_str_buffer(retbuf)); \
@ -69,6 +109,18 @@ static int list_expect(struct test_llist *test_list, const char *expect, struct
return AST_TEST_FAIL; \
}
#define MATCH_OR_FAIL_DBL(list, val, retbuf) \
if (dbl_list_expect_forward(list, val, &retbuf)) { \
ast_test_status_update(test, "Expected: %s, Got: %s\n", val, ast_str_buffer(retbuf)); \
ast_free(retbuf); \
return AST_TEST_FAIL; \
} \
if (dbl_list_expect_reverse(list, val, &retbuf)) { \
ast_test_status_update(test, "Expected reverse of: %s, Got: %s\n", val, ast_str_buffer(retbuf)); \
ast_free(retbuf); \
return AST_TEST_FAIL; \
}
#define ELEM_OR_FAIL(x,y) \
if ((x) != (y)) { \
ast_test_status_update(test, "Expected: %s, Got: %s\n", (x)->name, (y)->name); \
@ -122,14 +174,14 @@ AST_TEST_DEFINE(single_ll_tests)
}
MATCH_OR_FAIL(&test_list, "", buf);
/* ** */
/* Check empty list test */
if (!AST_LIST_EMPTY(&test_list)) {
ast_test_status_update(test, "List should be empty\n");
return AST_TEST_FAIL;
}
/* ** */
/* Insert tail and remove specific item tests. */
AST_LIST_INSERT_TAIL(&test_list, &a, list);
MATCH_OR_FAIL(&test_list, "A", buf);
@ -165,7 +217,7 @@ AST_TEST_DEFINE(single_ll_tests)
return AST_TEST_FAIL;
}
/* ** */
/* Insert item after specific item tests */
AST_LIST_INSERT_HEAD(&test_list, &a, list);
MATCH_OR_FAIL(&test_list, "A", buf);
@ -190,7 +242,7 @@ AST_TEST_DEFINE(single_ll_tests)
return AST_TEST_FAIL;
}
/* ** */
/* Append list test */
AST_LIST_INSERT_HEAD(&test_list, &a, list);
MATCH_OR_FAIL(&test_list, "A", buf);
@ -212,7 +264,7 @@ AST_TEST_DEFINE(single_ll_tests)
return AST_TEST_FAIL;
}
/* ** */
/* Insert list after specific item in middle test */
AST_LIST_INSERT_HEAD(&test_list, &a, list);
MATCH_OR_FAIL(&test_list, "A", buf);
@ -234,7 +286,7 @@ AST_TEST_DEFINE(single_ll_tests)
return AST_TEST_FAIL;
}
/* ** */
/* Insert list after specific item on end test */
AST_LIST_INSERT_HEAD(&test_list, &a, list);
MATCH_OR_FAIL(&test_list, "A", buf);
@ -256,7 +308,7 @@ AST_TEST_DEFINE(single_ll_tests)
return AST_TEST_FAIL;
}
/* ** */
/* Safe traversal list modification tests */
AST_LIST_INSERT_HEAD(&test_list, &a, list);
MATCH_OR_FAIL(&test_list, "A", buf);
@ -286,15 +338,330 @@ AST_TEST_DEFINE(single_ll_tests)
return AST_TEST_PASS;
}
AST_TEST_DEFINE(double_ll_tests)
{
struct ast_str *buf;
struct test_dbl_llist test_list = { 0, };
struct test_dbl_llist other_list = { 0, };
struct test_val *bogus;
switch (cmd) {
case TEST_INIT:
info->name = "double_ll_tests";
info->category = "/main/linkedlists";
info->summary = "double linked list unit test";
info->description =
"Test the double linked list API";
return AST_TEST_NOT_RUN;
case TEST_EXECUTE:
break;
}
if (!(buf = ast_str_create(16))) {
return AST_TEST_FAIL;
}
if (!(bogus = alloca(sizeof(*bogus)))) {
return AST_TEST_FAIL;
}
if (AST_DLLIST_REMOVE_VERIFY(&test_list, bogus, dbl_list)) {
ast_test_status_update(test, "AST_DLLIST_REMOVE_VERIFY should safely return NULL for missing element from empty list\n");
return AST_TEST_FAIL;
}
/* INSERT_HEAD and REMOVE_HEAD tests */
AST_DLLIST_INSERT_HEAD(&test_list, &a, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "A", buf);
AST_DLLIST_INSERT_HEAD(&test_list, &b, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "BA", buf);
AST_DLLIST_REMOVE_HEAD(&test_list, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "A", buf);
AST_DLLIST_REMOVE_HEAD(&test_list, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "", buf);
if (AST_DLLIST_REMOVE_HEAD(&test_list, dbl_list)) {
ast_test_status_update(test, "Somehow removed an item from the head of a list that didn't exist\n");
return AST_TEST_FAIL;
}
MATCH_OR_FAIL_DBL(&test_list, "", buf);
/* Check empty list test */
if (!AST_DLLIST_EMPTY(&test_list)) {
ast_test_status_update(test, "List should be empty\n");
return AST_TEST_FAIL;
}
/* Insert tail and remove specific item tests. */
AST_DLLIST_INSERT_TAIL(&test_list, &a, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "A", buf);
AST_DLLIST_INSERT_TAIL(&test_list, &b, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "AB", buf);
AST_DLLIST_INSERT_TAIL(&test_list, &c, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "ABC", buf);
AST_DLLIST_INSERT_TAIL(&test_list, &d, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "ABCD", buf);
if (AST_DLLIST_REMOVE_VERIFY(&test_list, bogus, dbl_list)) {
ast_test_status_update(test, "AST_DLLIST_REMOVE_VERIFY should safely return NULL for missing element\n");
return AST_TEST_FAIL;
}
bogus = NULL;
if (AST_DLLIST_REMOVE_VERIFY(&test_list, bogus, dbl_list)) {
ast_test_status_update(test, "AST_DLLIST_REMOVE_VERIFY should safely return NULL for element set to NULL\n");
return AST_TEST_FAIL;
}
AST_DLLIST_REMOVE(&test_list, &b, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "ACD", buf);
AST_DLLIST_REMOVE(&test_list, &d, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "AC", buf);
AST_DLLIST_REMOVE(&test_list, &a, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "C", buf);
AST_DLLIST_REMOVE(&test_list, &c, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "", buf);
if (!AST_DLLIST_EMPTY(&test_list)) {
ast_test_status_update(test, "List should be empty\n");
return AST_TEST_FAIL;
}
if (AST_DLLIST_REMOVE_VERIFY(&test_list, bogus, dbl_list)) {
ast_test_status_update(test, "AST_DLLIST_REMOVE_VERIFY should safely return NULL asked to remove a NULL pointer from an empty list\n");
return AST_TEST_FAIL;
}
/* Insert item after and before specific item tests */
AST_DLLIST_INSERT_HEAD(&test_list, &a, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "A", buf);
AST_DLLIST_INSERT_TAIL(&test_list, &c, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "AC", buf);
AST_DLLIST_INSERT_AFTER(&test_list, &a, &b, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "ABC", buf);
AST_DLLIST_INSERT_AFTER(&test_list, &c, &d, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "ABCD", buf);
AST_DLLIST_REMOVE_TAIL(&test_list, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "ABC", buf);
AST_DLLIST_REMOVE_TAIL(&test_list, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "AB", buf);
AST_DLLIST_INSERT_TAIL(&test_list, &d, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "ABD", buf);
AST_DLLIST_INSERT_BEFORE(&test_list, &d, &c, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "ABCD", buf);
AST_DLLIST_REMOVE_HEAD(&test_list, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "BCD", buf);
AST_DLLIST_INSERT_BEFORE(&test_list, &b, &a, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "ABCD", buf);
ELEM_OR_FAIL(AST_DLLIST_FIRST(&test_list), &a);
ELEM_OR_FAIL(AST_DLLIST_LAST(&test_list), &d);
ELEM_OR_FAIL(AST_DLLIST_NEXT(&a, dbl_list), &b);
ELEM_OR_FAIL(AST_DLLIST_PREV(&b, dbl_list), &a);
AST_DLLIST_TRAVERSE_SAFE_BEGIN(&test_list, bogus, dbl_list) {
AST_DLLIST_REMOVE_CURRENT(dbl_list);
}
AST_DLLIST_TRAVERSE_SAFE_END;
if (!AST_DLLIST_EMPTY(&test_list)) {
ast_test_status_update(test, "List should be empty after traversing and removal. It wasn't.\n");
return AST_TEST_FAIL;
}
/* Append list test */
AST_DLLIST_INSERT_HEAD(&test_list, &a, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "A", buf);
AST_DLLIST_INSERT_TAIL(&test_list, &b, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "AB", buf);
AST_DLLIST_INSERT_HEAD(&other_list, &c, dbl_list);
MATCH_OR_FAIL_DBL(&other_list, "C", buf);
AST_DLLIST_INSERT_TAIL(&other_list, &d, dbl_list);
MATCH_OR_FAIL_DBL(&other_list, "CD", buf);
AST_DLLIST_APPEND_DLLIST(&test_list, &other_list, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "ABCD", buf);
MATCH_OR_FAIL_DBL(&other_list, "", buf);
AST_DLLIST_TRAVERSE_SAFE_BEGIN(&test_list, bogus, dbl_list) {
AST_DLLIST_REMOVE_CURRENT(dbl_list);
}
AST_DLLIST_TRAVERSE_SAFE_END;
if (!AST_DLLIST_EMPTY(&test_list)) {
ast_test_status_update(test, "List should be empty after traversing and removal. It wasn't.\n");
return AST_TEST_FAIL;
}
/*
* Safe traversal list modification tests
* Traverse starting from first element
*/
AST_DLLIST_INSERT_HEAD(&test_list, &a, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "A", buf);
AST_DLLIST_INSERT_TAIL(&test_list, &d, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "AD", buf);
AST_DLLIST_TRAVERSE_SAFE_BEGIN(&test_list, bogus, dbl_list) {
if (bogus == &d) {
AST_DLLIST_INSERT_BEFORE_CURRENT(&b, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "ABD", buf);
AST_DLLIST_INSERT_BEFORE_CURRENT(&c, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "ABCD", buf);
AST_DLLIST_REMOVE_CURRENT(dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "ABC", buf);
}
}
AST_DLLIST_TRAVERSE_SAFE_END;
MATCH_OR_FAIL_DBL(&test_list, "ABC", buf);
AST_DLLIST_TRAVERSE_SAFE_BEGIN(&test_list, bogus, dbl_list) {
AST_DLLIST_REMOVE_CURRENT(dbl_list);
}
AST_DLLIST_TRAVERSE_SAFE_END;
if (!AST_DLLIST_EMPTY(&test_list)) {
ast_test_status_update(test, "List should be empty after traversing and removal. It wasn't.\n");
return AST_TEST_FAIL;
}
AST_DLLIST_INSERT_HEAD(&test_list, &b, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "B", buf);
AST_DLLIST_INSERT_TAIL(&test_list, &d, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "BD", buf);
AST_DLLIST_TRAVERSE_SAFE_BEGIN(&test_list, bogus, dbl_list) {
if (bogus == &b) {
AST_DLLIST_INSERT_BEFORE_CURRENT(&a, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "ABD", buf);
AST_DLLIST_INSERT_AFTER_CURRENT(&c, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "ABCD", buf);
AST_DLLIST_REMOVE_CURRENT(dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "ACD", buf);
}
}
AST_DLLIST_TRAVERSE_SAFE_END;
MATCH_OR_FAIL_DBL(&test_list, "ACD", buf);
AST_DLLIST_TRAVERSE_SAFE_BEGIN(&test_list, bogus, dbl_list) {
AST_DLLIST_REMOVE_CURRENT(dbl_list);
}
AST_DLLIST_TRAVERSE_SAFE_END;
if (!AST_DLLIST_EMPTY(&test_list)) {
ast_test_status_update(test, "List should be empty after traversing and removal. It wasn't.\n");
return AST_TEST_FAIL;
}
AST_DLLIST_INSERT_HEAD(&test_list, &b, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "B", buf);
AST_DLLIST_TRAVERSE_SAFE_BEGIN(&test_list, bogus, dbl_list) {
if (bogus == &b) {
AST_DLLIST_INSERT_BEFORE_CURRENT(&a, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "AB", buf);
AST_DLLIST_INSERT_AFTER_CURRENT(&d, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "ABD", buf);
AST_DLLIST_INSERT_AFTER_CURRENT(&c, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "ABCD", buf);
AST_DLLIST_REMOVE_CURRENT(dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "ACD", buf);
}
}
AST_DLLIST_TRAVERSE_SAFE_END;
MATCH_OR_FAIL_DBL(&test_list, "ACD", buf);
AST_DLLIST_TRAVERSE_SAFE_BEGIN(&test_list, bogus, dbl_list) {
AST_DLLIST_REMOVE_CURRENT(dbl_list);
}
AST_DLLIST_TRAVERSE_SAFE_END;
if (!AST_DLLIST_EMPTY(&test_list)) {
ast_test_status_update(test, "List should be empty after traversing and removal. It wasn't.\n");
return AST_TEST_FAIL;
}
/*
* Safe traversal list modification tests
* Traverse starting from last element
*/
AST_DLLIST_INSERT_HEAD(&test_list, &a, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "A", buf);
AST_DLLIST_INSERT_TAIL(&test_list, &d, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "AD", buf);
AST_DLLIST_TRAVERSE_BACKWARDS_SAFE_BEGIN(&test_list, bogus, dbl_list) {
if (bogus == &d) {
AST_DLLIST_INSERT_BEFORE_CURRENT(&b, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "ABD", buf);
AST_DLLIST_INSERT_BEFORE_CURRENT(&c, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "ABCD", buf);
AST_DLLIST_REMOVE_CURRENT(dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "ABC", buf);
}
}
AST_DLLIST_TRAVERSE_BACKWARDS_SAFE_END;
MATCH_OR_FAIL_DBL(&test_list, "ABC", buf);
AST_DLLIST_TRAVERSE_BACKWARDS_SAFE_BEGIN(&test_list, bogus, dbl_list) {
AST_DLLIST_REMOVE_CURRENT(dbl_list);
}
AST_DLLIST_TRAVERSE_BACKWARDS_SAFE_END;
if (!AST_DLLIST_EMPTY(&test_list)) {
ast_test_status_update(test, "List should be empty after traversing and removal. It wasn't.\n");
return AST_TEST_FAIL;
}
AST_DLLIST_INSERT_HEAD(&test_list, &b, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "B", buf);
AST_DLLIST_INSERT_TAIL(&test_list, &d, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "BD", buf);
AST_DLLIST_TRAVERSE_BACKWARDS_SAFE_BEGIN(&test_list, bogus, dbl_list) {
if (bogus == &b) {
AST_DLLIST_INSERT_BEFORE_CURRENT(&a, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "ABD", buf);
AST_DLLIST_INSERT_AFTER_CURRENT(&c, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "ABCD", buf);
AST_DLLIST_REMOVE_CURRENT(dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "ACD", buf);
}
}
AST_DLLIST_TRAVERSE_BACKWARDS_SAFE_END;
MATCH_OR_FAIL_DBL(&test_list, "ACD", buf);
AST_DLLIST_TRAVERSE_SAFE_BEGIN(&test_list, bogus, dbl_list) {
AST_DLLIST_REMOVE_CURRENT(dbl_list);
}
AST_DLLIST_TRAVERSE_SAFE_END;
if (!AST_DLLIST_EMPTY(&test_list)) {
ast_test_status_update(test, "List should be empty after traversing and removal. It wasn't.\n");
return AST_TEST_FAIL;
}
AST_DLLIST_INSERT_HEAD(&test_list, &b, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "B", buf);
AST_DLLIST_TRAVERSE_BACKWARDS_SAFE_BEGIN(&test_list, bogus, dbl_list) {
if (bogus == &b) {
AST_DLLIST_INSERT_BEFORE_CURRENT(&a, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "AB", buf);
AST_DLLIST_INSERT_AFTER_CURRENT(&d, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "ABD", buf);
AST_DLLIST_INSERT_AFTER_CURRENT(&c, dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "ABCD", buf);
AST_DLLIST_REMOVE_CURRENT(dbl_list);
MATCH_OR_FAIL_DBL(&test_list, "ACD", buf);
}
}
AST_DLLIST_TRAVERSE_BACKWARDS_SAFE_END;
MATCH_OR_FAIL_DBL(&test_list, "ACD", buf);
AST_DLLIST_TRAVERSE_SAFE_BEGIN(&test_list, bogus, dbl_list) {
AST_DLLIST_REMOVE_CURRENT(dbl_list);
}
AST_DLLIST_TRAVERSE_SAFE_END;
if (!AST_DLLIST_EMPTY(&test_list)) {
ast_test_status_update(test, "List should be empty after traversing and removal. It wasn't.\n");
return AST_TEST_FAIL;
}
return AST_TEST_PASS;
}
static int unload_module(void)
{
AST_TEST_UNREGISTER(single_ll_tests);
AST_TEST_UNREGISTER(double_ll_tests);
return 0;
}
static int load_module(void)
{
AST_TEST_REGISTER(single_ll_tests);
AST_TEST_REGISTER(double_ll_tests);
return AST_MODULE_LOAD_SUCCESS;
}

Write Preview
Loading…
Cancel
Save