bird/lib/lists_test.c

290 lines
5.7 KiB
C

/*
* BIRD Library -- Linked Lists Tests
*
* (c) 2015 CZ.NIC z.s.p.o.
*
* Can be freely distributed and used under the terms of the GNU GPL.
*/
#include "test/birdtest.h"
#include "lib/lists.h"
#define MAX_NUM 1000
static node nodes[MAX_NUM];
static list l;
static void
show_list(void)
{
bt_debug("\n");
bt_debug("list.null is at %p and point to %p\n", &l.null, l.null);
bt_debug("list.head is at %p and point to %p\n", &l.head, l.head);
bt_debug("list.tail is at %p and point to %p\n", &l.tail, l.tail);
int i;
for (i = 0; i < MAX_NUM; i++)
{
bt_debug("n[%3i] is at %p\n", i, &nodes[i]);
bt_debug(" prev is at %p and point to %p\n", &(nodes[i].prev), nodes[i].prev);
bt_debug(" next is at %p and point to %p\n", &(nodes[i].next), nodes[i].next);
}
}
static int
is_filled_list_well_linked(void)
{
int i;
bt_assert(l.head == &nodes[0]);
bt_assert(l.tail == &nodes[MAX_NUM-1]);
bt_assert((void *) nodes[0].prev == (void *) &l.head);
bt_assert((void *) nodes[MAX_NUM-1].next == (void *) &l.null);
for (i = 0; i < MAX_NUM; i++)
{
if (i < (MAX_NUM-1))
bt_assert(nodes[i].next == &nodes[i+1]);
if (i > 0)
bt_assert(nodes[i].prev == &nodes[i-1]);
}
return 1;
}
static int
is_empty_list_well_unlinked(void)
{
int i;
bt_assert(l.head == NODE &l.null);
bt_assert(l.tail == NODE &l.head);
bt_assert(EMPTY_LIST(l));
for (i = 0; i < MAX_NUM; i++)
{
bt_assert(nodes[i].next == NULL);
bt_assert(nodes[i].prev == NULL);
}
return 1;
}
static void
init_list__(list *l, struct node nodes[])
{
init_list(l);
int i;
for (i = 0; i < MAX_NUM; i++)
{
nodes[i].next = NULL;
nodes[i].prev = NULL;
}
}
static void
init_list_(void)
{
init_list__(&l, (node *) nodes);
}
static int
t_add_tail(void)
{
int i;
init_list_();
for (i = 0; i < MAX_NUM; i++)
{
add_tail(&l, &nodes[i]);
bt_debug(".");
bt_assert(l.tail == &nodes[i]);
bt_assert(l.head == &nodes[0]);
bt_assert((void *) nodes[i].next == (void *) &l.null);
if (i > 0)
{
bt_assert(nodes[i-1].next == &nodes[i]);
bt_assert(nodes[i].prev == &nodes[i-1]);
}
}
show_list();
bt_assert(is_filled_list_well_linked());
return 1;
}
static int
t_add_head(void)
{
int i;
init_list_();
for (i = MAX_NUM-1; i >= 0; i--)
{
add_head(&l, &nodes[i]);
bt_debug(".");
bt_assert(l.head == &nodes[i]);
bt_assert(l.tail == &nodes[MAX_NUM-1]);
if (i < MAX_NUM-1)
{
bt_assert(nodes[i+1].prev == &nodes[i]);
bt_assert(nodes[i].next == &nodes[i+1]);
}
}
show_list();
bt_assert(is_filled_list_well_linked());
return 1;
}
static void
insert_node_(node *n, node *after)
{
insert_node(n, after);
bt_debug(".");
}
static int
t_insert_node(void)
{
int i;
init_list_();
// add first node
insert_node_(&nodes[0], NODE &l.head);
// add odd nodes
for (i = 2; i < MAX_NUM; i+=2)
insert_node_(&nodes[i], &nodes[i-2]);
// add even nodes
for (i = 1; i < MAX_NUM; i+=2)
insert_node_(&nodes[i], &nodes[i-1]);
bt_debug("\n");
bt_assert(is_filled_list_well_linked());
return 1;
}
static void
fill_list2(list *l, node nodes[])
{
int i;
for (i = 0; i < MAX_NUM; i++)
add_tail(l, &nodes[i]);
}
static void
fill_list(void)
{
fill_list2(&l, (node *) nodes);
}
static int
t_remove_node(void)
{
int i;
init_list_();
/* Fill & Remove & Check */
fill_list();
for (i = 0; i < MAX_NUM; i++)
rem_node(&nodes[i]);
bt_assert(is_empty_list_well_unlinked());
/* Fill & Remove the half of nodes & Check & Remove the rest nodes & Check */
fill_list();
for (i = 0; i < MAX_NUM; i+=2)
rem_node(&nodes[i]);
int tail_node_index = (MAX_NUM % 2) ? MAX_NUM - 2 : MAX_NUM - 1;
bt_assert(l.head == &nodes[1]);
bt_assert(l.tail == &nodes[tail_node_index]);
bt_assert(nodes[tail_node_index].next == NODE &l.null);
for (i = 1; i < MAX_NUM; i+=2)
{
if (i > 1)
bt_assert(nodes[i].prev == &nodes[i-2]);
if (i < tail_node_index)
bt_assert(nodes[i].next == &nodes[i+2]);
}
for (i = 1; i < MAX_NUM; i+=2)
rem_node(&nodes[i]);
bt_assert(is_empty_list_well_unlinked());
return 1;
}
static int
t_update_node(void)
{
node head, inside, tail;
init_list_();
fill_list();
head = nodes[0];
update_node(&head);
bt_assert(l.head == &head);
bt_assert(head.prev == NODE &l.head);
bt_assert(head.next == &nodes[1]);
bt_assert(nodes[1].prev == &head);
inside = nodes[MAX_NUM/2];
update_node(&inside);
bt_assert(nodes[MAX_NUM/2-1].next == &inside);
bt_assert(nodes[MAX_NUM/2+1].prev == &inside);
bt_assert(inside.prev == &nodes[MAX_NUM/2-1]);
bt_assert(inside.next == &nodes[MAX_NUM/2+1]);
tail = nodes[MAX_NUM-1];
update_node(&tail);
bt_assert(l.tail == &tail);
bt_assert(tail.prev == &nodes[MAX_NUM-2]);
bt_assert(tail.next == NODE &l.null);
bt_assert(nodes[MAX_NUM-2].next == &tail);
return 1;
}
static int
t_add_tail_list(void)
{
node nodes2[MAX_NUM];
list l2;
init_list__(&l, (node *) nodes);
fill_list2(&l, (node *) nodes);
init_list__(&l2, (node *) nodes2);
fill_list2(&l2, (node *) nodes2);
add_tail_list(&l, &l2);
bt_assert(nodes[MAX_NUM-1].next == &nodes2[0]);
bt_assert(nodes2[0].prev == &nodes[MAX_NUM-1]);
bt_assert(l.tail == &nodes2[MAX_NUM-1]);
return 1;
}
int
main(int argc, char *argv[])
{
bt_init(argc, argv);
bt_test_suite(t_add_tail, "Adding nodes to tail of list");
bt_test_suite(t_add_head, "Adding nodes to head of list");
bt_test_suite(t_insert_node, "Inserting nodes to list");
bt_test_suite(t_remove_node, "Removing nodes from list");
bt_test_suite(t_update_node, "Updating nodes in list");
bt_test_suite(t_add_tail_list, "At the tail of a list adding the another list");
return bt_exit_value();
}