forked from 131/lab6_list
init commit
This commit is contained in:
dzruyk
341
list_test.c
Normal file
341
list_test.c
Normal file
@@ -0,0 +1,341 @@
|
||||
#include <stdio.h>
|
||||
|
||||
#include "list.h"
|
||||
#include "util.h"
|
||||
#include "macro.h"
|
||||
#include "munit/munit.h"
|
||||
|
||||
#define NAMELEN 128
|
||||
|
||||
typedef struct num_node {
|
||||
list_node l;
|
||||
int n;
|
||||
} num_node;
|
||||
|
||||
static num_node *
|
||||
new_num_node(int n)
|
||||
{
|
||||
num_node *res;
|
||||
res = xmalloc(sizeof(*res));
|
||||
res->n = n;
|
||||
return res;
|
||||
}
|
||||
|
||||
//#define NEW_ITEM(tp) xmalloc(sizeof(tp))
|
||||
/*
|
||||
list l;
|
||||
list_init(&l);
|
||||
|
||||
list_clear(&l, NULL);
|
||||
*/
|
||||
|
||||
int n_hardfrees = 0;
|
||||
|
||||
static void
|
||||
hardmode_free(list_node *n)
|
||||
{
|
||||
n_hardfrees++;
|
||||
memset(n, 0, sizeof(*n));
|
||||
free(n);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
list_num_print(list *l)
|
||||
{
|
||||
struct list_node *iter;
|
||||
const char *hdrfmt = "%16.10s|%16.10s|%16.10s|%5.5s\n";
|
||||
const char *itemfmt = "%16.10p|%16.10p|%16.10p|%5d\n";
|
||||
printf("head = %p tail = %p\n", l->head, l->tail);
|
||||
printf(hdrfmt, "ptr", "next", "prev", "n");
|
||||
printf(" -------------------------------------------\n");
|
||||
list_for_each(iter, l) {
|
||||
num_node *ni;
|
||||
ni = (num_node *)iter;
|
||||
printf(itemfmt, ni, ni->l.next, ni->l.prev, ni->n);
|
||||
}
|
||||
}
|
||||
|
||||
static MunitResult
|
||||
test_list_stage1(const MunitParameter params[], void * data)
|
||||
{
|
||||
//Tests for: list_init, list_clear, list_push_front, list_first, list_last
|
||||
int num_arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
|
||||
int reverse_arr[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
|
||||
num_node *ni;
|
||||
int i;
|
||||
list l;
|
||||
|
||||
munit_logf(MUNIT_LOG_INFO, "Tests for %s", "list_init, list_clear, list_push_front, list_first, list_last");
|
||||
|
||||
munit_log(MUNIT_LOG_INFO, "Intializing num_node list...");
|
||||
list_init(&l);
|
||||
|
||||
list_clear(&l, NULL);
|
||||
munit_assert_null(l.head);
|
||||
munit_assert_null(l.tail);
|
||||
|
||||
|
||||
munit_log(MUNIT_LOG_INFO, "Checking list_push_front...");
|
||||
// Insert first element, check list sanity
|
||||
ni = new_num_node(num_arr[0]);
|
||||
list_push_front(&l, (list_node *)ni);
|
||||
|
||||
munit_assert_null(ni->l.next);
|
||||
munit_assert_null(ni->l.prev);
|
||||
munit_assert_ptr(l.head, ==, ni);
|
||||
munit_assert_ptr(l.tail, ==, ni);
|
||||
|
||||
// Insert second element, check list sanity
|
||||
ni = new_num_node(num_arr[1]);
|
||||
list_push_front(&l, (list_node *)ni);
|
||||
munit_assert_not_null(ni->l.next);
|
||||
munit_assert_null(ni->l.prev);
|
||||
munit_assert_ptr(l.head, ==, ni);
|
||||
munit_assert_ptr(l.tail, !=, ni);
|
||||
|
||||
for (i = 2; i < ARRSZ(num_arr); i++) {
|
||||
munit_logf(MUNIT_LOG_DEBUG, "list_push_front i = %d", i);
|
||||
ni = new_num_node(num_arr[i]);
|
||||
list_push_front(&l, (list_node *)ni);
|
||||
}
|
||||
//list_num_print(&l);
|
||||
|
||||
munit_log(MUNIT_LOG_INFO, "Checking list contents after list_push_front calls");
|
||||
|
||||
// Manually traverse list and check it
|
||||
for (i = 0, ni = (num_node *) l.head;
|
||||
ni != NULL;
|
||||
i++, ni = (num_node *) (ni->l.next)) {
|
||||
munit_assert_int(ni->n, ==, reverse_arr[i]);
|
||||
}
|
||||
|
||||
ni = (num_node *) list_first(&l);
|
||||
munit_assert_not_null(ni);
|
||||
munit_assert_int(ni->n, ==, reverse_arr[0]);
|
||||
|
||||
ni = (num_node *) list_last(&l);
|
||||
|
||||
munit_assert_not_null(ni);
|
||||
munit_assert_int(ni->n, ==, num_arr[0]);
|
||||
|
||||
munit_assert_size(list_len(&l), ==, ARRSZ(num_arr));
|
||||
|
||||
list_clear(&l, (list_free_cb) free);
|
||||
munit_assert_size(list_len(&l), ==, 0);
|
||||
|
||||
munit_log(MUNIT_LOG_INFO, "try to free every node and zero it memory");
|
||||
for (i = 0; i < ARRSZ(num_arr); i++) {
|
||||
ni = xmalloc(sizeof(*ni));
|
||||
ni->n = num_arr[i];
|
||||
list_push_front(&l, (list_node *)ni);
|
||||
}
|
||||
size_t lsz = list_len(&l);
|
||||
list_clear(&l, hardmode_free);
|
||||
if (lsz != n_hardfrees) {
|
||||
munit_log(MUNIT_LOG_WARNING, "not all objects are freed. Bug in list_clear??");
|
||||
}
|
||||
munit_assert_int(lsz, ==, n_hardfrees);
|
||||
|
||||
munit_assert_size(list_len(&l), ==, 0);
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
static MunitResult
|
||||
test_list_stage2(const MunitParameter params[], void * data)
|
||||
{
|
||||
//tests for list_push_back list_get list_insert list_pop_front list_pop_back
|
||||
int num_arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
|
||||
int res_arr[] = {42, 43, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 44, 10};
|
||||
num_node *n1, *n2;
|
||||
num_node *ni;
|
||||
int i;
|
||||
int idx;
|
||||
list l;
|
||||
|
||||
list_init(&l);
|
||||
|
||||
munit_log(MUNIT_LOG_INFO, "Checking list_push_back");
|
||||
for (i = 2; i < ARRSZ(num_arr); i++) {
|
||||
ni = new_num_node(num_arr[i]);
|
||||
list_push_back(&l, (list_node *)ni);
|
||||
}
|
||||
|
||||
munit_log(MUNIT_LOG_INFO, "Checking list_get");
|
||||
for (i = 0; i < ARRSZ(num_arr) - 2; i++) {
|
||||
ni = (num_node *) list_get(&l, i);
|
||||
munit_assert_int(ni->n, ==, num_arr[i + 2]);
|
||||
|
||||
}
|
||||
|
||||
list_insert(&l, (list_node *) new_num_node(num_arr[0]), 0);
|
||||
list_insert(&l, (list_node *) new_num_node(num_arr[1]), 1);
|
||||
|
||||
// manually traverse list and check it
|
||||
for (i = 0, ni = (num_node *) l.head;
|
||||
ni != NULL;
|
||||
i++, ni = (num_node *) (ni->l.next)) {
|
||||
munit_assert_int(ni->n, ==, num_arr[i]);
|
||||
}
|
||||
|
||||
list_insert(&l, (list_node *) new_num_node(42), 0);
|
||||
list_insert(&l, (list_node *) new_num_node(43), 1);
|
||||
list_insert(&l, (list_node *) new_num_node(44), list_len(&l) - 1);
|
||||
|
||||
// manually traverse list and check it
|
||||
for (i = 0, ni = (num_node *) l.head;
|
||||
ni != NULL;
|
||||
i++, ni = (num_node *) (ni->l.next)) {
|
||||
munit_assert_int(ni->n, ==, res_arr[i]);
|
||||
}
|
||||
|
||||
n2 = (num_node *) list_pop_front(&l);
|
||||
munit_assert_not_null(n2);
|
||||
munit_assert_int(n2->n, ==, 42);
|
||||
|
||||
n1 = (num_node *) list_pop_back(&l);
|
||||
munit_assert_not_null(n1);
|
||||
munit_assert_int(n1->n, ==, 10);
|
||||
|
||||
idx = list_index(&l, (list_node *) n2);
|
||||
munit_assert_int(idx, ==, -1);
|
||||
|
||||
for (i = 0; i < 5; i++) {
|
||||
munit_assert_int(
|
||||
i, ==,
|
||||
list_index(&l, list_get(&l, i))
|
||||
);
|
||||
}
|
||||
|
||||
list_clear(&l, (list_free_cb) free);
|
||||
|
||||
list_push_front(&l, (list_node *) n1);
|
||||
list_push_front(&l, (list_node *) n2);
|
||||
|
||||
ni = (num_node *) list_pop_front(&l);
|
||||
munit_assert_ptr(ni, ==, n2);
|
||||
|
||||
ni = (num_node *) list_pop_front(&l);
|
||||
munit_assert_ptr(ni, ==, n1);
|
||||
|
||||
munit_assert_size(list_len(&l), ==, 0);
|
||||
|
||||
list_clear(&l, (list_free_cb) free);
|
||||
munit_assert_null(list_pop_front(&l));
|
||||
munit_assert_null(list_pop_back(&l));
|
||||
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
/*
|
||||
static MunitResult
|
||||
test_list_tmp(const MunitParameter params[], void * data)
|
||||
{
|
||||
//Tests for: list_remove list_reverse
|
||||
int num_arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
|
||||
int reverse_arr[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
|
||||
num_node *ni;
|
||||
int i;
|
||||
list l;
|
||||
|
||||
list_init(&l);
|
||||
list_clear(&l, (list_free_cb) free);
|
||||
return MUNIT_OK;
|
||||
}
|
||||
*/
|
||||
|
||||
static MunitResult
|
||||
test_list_remove(const MunitParameter params[], void * data)
|
||||
{
|
||||
//Tests for: list_remove list_reverse
|
||||
int num_arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
|
||||
num_node *ni;
|
||||
int i;
|
||||
list l;
|
||||
|
||||
list_init(&l);
|
||||
for (i = 0; i < ARRSZ(num_arr); i++) {
|
||||
ni = new_num_node(num_arr[i]);
|
||||
list_push_back(&l, (list_node *)ni);
|
||||
}
|
||||
|
||||
ni = (num_node *) list_remove(&l, 122);
|
||||
munit_assert_null(ni);
|
||||
|
||||
ni = (num_node *) list_remove(&l, 0);
|
||||
munit_assert_not_null(ni);
|
||||
munit_assert_int(ni->n, ==, num_arr[0]);
|
||||
|
||||
ni = (num_node *) list_remove(&l, list_len(&l) - 1);
|
||||
munit_assert_not_null(ni);
|
||||
munit_assert_int(ni->n, ==, num_arr[ARRSZ(num_arr) - 1]);
|
||||
|
||||
size_t sz = list_len(&l);
|
||||
for (i = 0; i < sz; i++) {
|
||||
ni = (num_node *) list_remove(&l, 0);
|
||||
munit_assert_not_null(ni);
|
||||
}
|
||||
|
||||
list_clear(&l, (list_free_cb) free);
|
||||
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
static MunitResult
|
||||
test_list_reverse(const MunitParameter params[], void * data)
|
||||
{
|
||||
int num_arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
|
||||
int reverse_arr[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
|
||||
num_node *ni;
|
||||
int i;
|
||||
list l;
|
||||
|
||||
list_init(&l);
|
||||
list_reverse(&l);
|
||||
munit_assert_size(0, ==, list_len(&l));
|
||||
|
||||
for (i = 0; i < ARRSZ(num_arr); i++) {
|
||||
ni = new_num_node(num_arr[i]);
|
||||
list_push_back(&l, (list_node *)ni);
|
||||
}
|
||||
|
||||
list_reverse(&l);
|
||||
|
||||
munit_assert_size(list_len(&l), ==, ARRSZ(reverse_arr));
|
||||
//manually traverse list and check it
|
||||
for (i = 0, ni = (num_node *) l.head;
|
||||
ni != NULL;
|
||||
i++, ni = (num_node *) (ni->l.next)) {
|
||||
munit_assert_int(ni->n, ==, reverse_arr[i]);
|
||||
}
|
||||
|
||||
return MUNIT_OK;
|
||||
}
|
||||
|
||||
#define TEST_ITEM(func) {#func, func, NULL, NULL, MUNIT_TEST_OPTION_NONE }
|
||||
|
||||
static MunitTest test_suite_tests[] = {
|
||||
|
||||
TEST_ITEM(test_list_stage1),
|
||||
TEST_ITEM(test_list_stage2),
|
||||
TEST_ITEM(test_list_remove),
|
||||
TEST_ITEM(test_list_reverse),
|
||||
|
||||
{ NULL, NULL, NULL, NULL, MUNIT_TEST_OPTION_NONE, NULL }
|
||||
};
|
||||
|
||||
static const MunitSuite test_suite = {
|
||||
(char *) "",
|
||||
test_suite_tests,
|
||||
NULL,
|
||||
1,
|
||||
MUNIT_SUITE_OPTION_NONE
|
||||
};
|
||||
|
||||
|
||||
int
|
||||
main(int argc, const char *argv[])
|
||||
{
|
||||
munit_suite_main(&test_suite, (void *) "vector_test", argc, (char * const*) argv);
|
||||
return 0;
|
||||
}
|
||||
Reference in New Issue
Block a user