tests/single.c

/*
 * Copyright (c) 2011, Stefan Götz <stefan.goetz@web.de>
 * 
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */

#include <stdlib.h>
#include <string.h>
#include <asm/signal.h>
#include <check.h>

#include "rlist/single.h"

START_TEST(test_srl_init_valid)
{
    struct srl_list list;
    struct srl_list cmp = SRL_INIT;

    srl_init(&list, NULL);

    fail_unless(list.node_count == cmp.node_count && list.free_fn == cmp.free_fn && list.head == cmp.head, NULL);
}
END_TEST

START_TEST(test_srl_init_valid_free_fn)
{
    struct srl_list list;
    struct srl_list cmp = SRL_INIT_WITH(free);

    srl_init(&list, free);

    fail_unless(list.node_count == cmp.node_count && list.free_fn == cmp.free_fn && list.head == cmp.head, NULL);
}
END_TEST

START_TEST(test_srl_size_valid)
{
    struct srl_list list = SRL_INIT;

    fail_unless(srl_size(&list) == 0, NULL);
}
END_TEST

START_TEST(test_srl_first_empty)
{
    struct srl_list     list = SRL_INIT;
    struct srl_iterator iter;

    fail_unless(srl_first(&list, &iter) == &iter, NULL);
    fail_unless(srl_is_eol(&iter), NULL);
}
END_TEST

START_TEST(test_srl_next_valid)
{
    struct srl_list     list = SRL_INIT;
    struct srl_iterator iter;

    srl_first(&list, &iter);
    srl_insert_before(&iter, &list);
    srl_insert_before(&iter, &iter);
    
    /* get the first node */
    srl_first(&list, &iter);
    /* get the second node */
    fail_unless(srl_next(&iter) == &iter, NULL);
    /* is this really the second node in terms of the payload? */
    fail_unless(srl_payload(&iter) == &iter, NULL);
    /* since there are only two nodes, advance iter again to the end of list */
    fail_unless(srl_next(&iter) == &iter, NULL);
    /* this must be the end of the list */
    fail_unless(srl_is_eol(&iter), NULL);
}
END_TEST

START_TEST(test_srl_next_eol)
{
    struct srl_list     list = SRL_INIT;
    struct srl_iterator iter;

    /* get the first node */
    srl_first(&list, &iter);
    /* does srl_next() work? */
    fail_unless(srl_next(&iter) == &iter, NULL);
    /* is this (again) the end of the list? */
    fail_unless(srl_is_eol(&iter), NULL);
}
END_TEST

START_TEST(test_srl_insert_before_empty_list)
{
    struct srl_list      list = SRL_INIT;
    struct srl_iterator  iter;

    srl_first(&list, &iter);
    fail_unless(srl_insert_before(&iter, &iter), NULL);
    fail_unless(srl_size(&list) == 1, NULL);
    fail_unless(srl_is_eol(&iter), NULL);
    fail_unless(srl_payload(srl_first(&list, &iter)) == &iter, NULL);
}
END_TEST

START_TEST(test_srl_size_insert_before_reverse)
{
    /* insert numbers in reverse order into a list and check that order */
    unsigned            numbers[] = { 0, 1, 2 , 3, 4, 5, 6, 7 };
    const unsigned      SIZE = sizeof(numbers) / sizeof(*numbers);
    struct srl_iterator iter;
    struct srl_list     list = SRL_INIT;

    for (unsigned idx = 0; idx < SIZE; idx += 1) {
        /* sanity check */
        fail_unless(srl_size(&list) == idx, NULL);
        /* get the first node to insert at the list head */
        srl_first(&list, &iter);
        /* insert the number at idx */
        fail_unless(srl_insert_before(&iter, &numbers[idx]), NULL);
        /* sanity check */
        fail_unless(srl_size(&list) == (idx + 1), NULL);

        /* get the first node to check it */
        srl_first(&list, &iter);
        /* check the payload pointer */
        fail_unless(srl_payload(&iter) == &numbers[idx], NULL);
    }

    /* get the first node to iterate from the list head */
    srl_first(&list, &iter);
    /* do another pass over the list to check whether it has the intended order */
    for (int idx = SIZE - 1; idx >= 0; idx -= 1) {
        /* check the payload pointer */
        fail_unless(srl_payload(&iter) == &numbers[idx], NULL);
        /* get the next node to check it */
        srl_next(&iter);
    }
    /* sanity check: are we at the end of the list as expected? */
    fail_unless(srl_is_eol(&iter), NULL);
}
END_TEST

START_TEST(test_srl_size_insert_before_forward)
{
    /* insert numbers into a list and check their order */
    unsigned            numbers[] = { 0, 1, 2 , 3, 4, 5, 6, 7 };
    const unsigned      SIZE = sizeof(numbers) / sizeof(*numbers);
    struct srl_iterator iter;
    struct srl_list     list = SRL_INIT;

    /* get the first node to insert the first element */
    srl_first(&list, &iter);
    for (unsigned idx = 0; idx < SIZE; idx += 1) {
        /* sanity check */
        fail_unless(srl_size(&list) == idx, NULL);
        /* sanity check: we expect iter to always refer to the end of the list */
        fail_unless(srl_is_eol(&iter), NULL);
        /* insert the number at idx */
        fail_unless(srl_insert_before(&iter, &numbers[idx]), NULL);
        /* sanity check */
        fail_unless(srl_size(&list) == (idx + 1), NULL);
    }

    /* get the first node to iterate from the list head */
    srl_first(&list, &iter);
    /* do another pass over the list to check whether it has the intended order */
    for (unsigned idx = 0; idx < SIZE; idx += 1) {
        /* check the payload pointer */
        fail_unless(srl_payload(&iter) == &numbers[idx], NULL);
        /* get the next node to check it */
        srl_next(&iter);
    }
    /* sanity check: are we at the end of the list as expected? */
    fail_unless(srl_is_eol(&iter), NULL);
}
END_TEST

START_TEST(test_srl_size_del_first)
{
    const unsigned      SIZE = 16;
    struct srl_iterator iter;
    struct srl_list     list = SRL_INIT_WITH(free);

    for (unsigned i = 0; i < SIZE; i += 1) {
        srl_insert_before(srl_first(&list, &iter), malloc(4));
    }
    for (unsigned i = SIZE; i > 0; i -= 1) {
        fail_unless(srl_size(&list) == i, NULL);
        fail_unless(srl_del(srl_first(&list, &iter)) == NULL, NULL);
        fail_unless(srl_size(&list) == (i - 1), NULL);
    }
}
END_TEST

START_TEST(test_srl_size_del_iterate)
{
    const unsigned      SIZE = 16;
    struct srl_iterator iter;
    struct srl_list     list = SRL_INIT_WITH(free);

    for (unsigned i = 0; i < SIZE; i += 1) {
        srl_insert_before(srl_first(&list, &iter), malloc(4));
    }
    srl_first(&list, &iter);
    for (unsigned i = 0; i < SIZE; i += 1) {
        fail_unless(srl_del(&iter) == NULL, NULL);
        fail_unless(srl_next(&iter) == &iter, NULL);
    }
    fail_unless(srl_size(&list) == 0, NULL);
}
END_TEST

static void reset_number(void *const payload)
{
    *(unsigned *) payload = 0;
}

START_TEST(test_srl_insert_before_first_next_payload_del_valid)
{
    unsigned             numbers[16];
    const unsigned       SIZE = sizeof(numbers) / sizeof(numbers[0]);
    struct srl_list      list = SRL_INIT_WITH(reset_number);
    struct srl_iterator  iter;
    struct srl_iterator *tmp;
    unsigned             i;

    // fill the numbers array slots with their respective index
    for (i = 0; i < SIZE; i += 1) {
        numbers[i] = i;
    }

    // add numbers from 0..SIZE in reverse order to the list
    for (i = 0; i < SIZE; i += 1) {
        void *payload;

        fail_unless(srl_insert_before(srl_first(&list, &iter), &numbers[i]), NULL);
        // check that the first list element looks as expected
        fail_unless(srl_first(&list, &iter) != NULL, NULL);
        fail_unless((payload = srl_payload(&iter)) != NULL, NULL);
        fail_unless(payload == &numbers[i]);
        fail_unless(*(unsigned *) payload == numbers[i]);
    }

    // iterate through the list and check whether the nodes refer to the
    // numbers array in reverse order
    i = SIZE - 1;
    for (tmp = srl_first(&list, &iter); !srl_is_eol(tmp); srl_next(tmp)) {
        void *payload;

        fail_unless((payload = srl_payload(&iter)) != NULL, NULL);
        fail_unless(payload == &numbers[i]);
        fail_unless(*(unsigned *) payload == numbers[i]);

        i -= 1;
    }

    // iterate through the list and check whether nodes can be deleted in the
    // iteration and if the registered call-back function is called
    i = SIZE - 1;
    for (tmp = srl_first(&list, &iter); !srl_is_eol(tmp); srl_next(tmp)) {
        fail_unless(numbers[i] == i, NULL);
        fail_unless(srl_del(&iter) == NULL, NULL);
        fail_unless(numbers[i] == 0, NULL);

        i -= 1;
    }

    fail_unless(srl_size(&list) == 0, NULL);
}
END_TEST

START_TEST(test_srl_insert_before_null_payload)
{
    struct srl_list     list = SRL_INIT_WITH(free);
    struct srl_iterator iter;

    fail_unless(srl_insert_before(srl_first(&list, &iter), NULL), NULL);
    // check that the first list element looks as expected
    fail_unless(srl_first(&list, &iter) != NULL, NULL);
    fail_unless(srl_payload(&iter) == NULL, NULL);
}
END_TEST

START_TEST(test_srl_del_all_valid)
{
    const unsigned      SIZE = 16;
    struct srl_iterator iter;
    struct srl_list     list = SRL_INIT_WITH(free);

    srl_first(&list, &iter);
    for (unsigned i = 0; i < SIZE; i += 1) {
        fail_unless(srl_insert_before(&iter, malloc(4)), NULL);
    }
    fail_unless(srl_size(&list) == SIZE, NULL);
    srl_del_all(&list);
    fail_unless(srl_size(&list) == 0, NULL);
    fail_unless(srl_is_eol(srl_first(&list, &iter)), NULL);
}
END_TEST

static bool match_unsigned(void *const payload,
                           void *const context)
{
    return *(unsigned *)payload == *(unsigned *)context;
}

START_TEST(test_srl_find_valid)
{
    unsigned numbers[] = { 0, 1, 2, 3, 4, 5, 6, 0 };
    unsigned needle = 0;
    struct srl_iterator iter;
    struct srl_list list = SRL_INIT;
    
    // append numbers in ascending order
    srl_first(&list, &iter);
    for (unsigned idx = 0; idx < sizeof(numbers) / sizeof(numbers[0]); idx += 1) {
        srl_insert_before(&iter, &numbers[idx]);
    }
    
    srl_first(&list, &iter);
    // does srl_find() return a non-NULL value as advertised?
    fail_unless(srl_find(&iter, match_unsigned, &needle) != NULL, NULL);
    // srl_find() should find something
    fail_unless(!srl_is_eol(&iter), NULL);
    // srl_find() should find the correct number
    fail_unless(srl_payload(&iter) == &numbers[0], NULL);

    // go to the next list node
    srl_next(&iter);
    // does srl_find() return iter as advertised?
    fail_unless(srl_find(&iter, match_unsigned, &needle) == &iter, NULL);
    // srl_find() should find something
    fail_unless(!srl_is_eol(&iter), NULL);
    // srl_find() should find the correct number
    fail_unless(srl_payload(&iter) == &numbers[7], NULL);

    // go to the next list node (i.e., EOL)
    srl_next(&iter);
    // does srl_find() return iter as advertised?
    fail_unless(srl_find(&iter, match_unsigned, &needle) == &iter, NULL);
    // srl_find() should not find anything
    fail_unless(srl_is_eol(&iter), NULL);

    needle = 2;
    srl_first(&list, &iter);
    // does srl_find() return iter as advertised?
    fail_unless(srl_find(&iter, match_unsigned, &needle) == &iter, NULL);
    // srl_find() should find something
    fail_unless(!srl_is_eol(&iter), NULL);
    // srl_find() should find the correct number
    fail_unless(srl_payload(&iter) == &numbers[needle], NULL);

    // go to the next list node
    srl_next(&iter);
    // does srl_find() return iter as advertised?
    fail_unless(srl_find(&iter, match_unsigned, &needle) == &iter, NULL);
    // srl_find() should not find anything
    fail_unless(srl_is_eol(&iter), NULL);
}
END_TEST

START_TEST(test_srl_find_payload_valid)
{
    unsigned numbers[] = { 0, 1, 2, 3, 4, 5, 6, 7 };
    struct srl_iterator iter;
    struct srl_list list = SRL_INIT;
    
    // append numbers in ascending order
    srl_first(&list, &iter);
    for (unsigned idx = 0; idx < sizeof(numbers) / sizeof(numbers[0]); idx += 1) {
        srl_insert_before(&iter, &numbers[idx]);
    }
    
    // find '0' from list head
    srl_first(&list, &iter);
    // does srl_find_payload() return iter as advertised?
    fail_unless(srl_find_payload(&iter, &numbers[0]) == &iter, NULL);
    // srl_find_payload() should find something
    fail_unless(!srl_is_eol(&iter), NULL);
    // srl_find_payload() should find the correct number
    fail_unless(srl_payload(&iter) == &numbers[0], NULL);

    // find '2' from '0' (== list head)
    // does srl_find_payload() return iter as advertised?
    fail_unless(srl_find_payload(&iter, &numbers[2]) == &iter, NULL);
    // srl_find_payload() should find something
    fail_unless(!srl_is_eol(&iter), NULL);
    // srl_find_payload() should find the correct number
    fail_unless(srl_payload(&iter) == &numbers[2], NULL);

    // find '0' from '2'
    // does srl_find_payload() return iter as advertised?
    fail_unless(srl_find_payload(&iter, &numbers[0]) == &iter, NULL);
    // srl_find_payload() should not find anything
    fail_unless(srl_is_eol(&iter), NULL);

    // find '7' (last node) from list head
    srl_first(&list, &iter);
    // does srl_find_payload() return iter as advertised?
    fail_unless(srl_find_payload(&iter, &numbers[7]) == &iter, NULL);
    // srl_find_payload() should find something
    fail_unless(!srl_is_eol(&iter), NULL);
    // srl_find_payload() should find the correct number
    fail_unless(srl_payload(&iter) == &numbers[7], NULL);

    // find NULL
    srl_first(&list, &iter);
    // does srl_find_payload() return iter as advertised?
    fail_unless(srl_find_payload(&iter, NULL) == &iter, NULL);
    // srl_find_payload() should not find anything
    fail_unless(srl_is_eol(&iter), NULL);

    // find pointer not in list
    srl_first(&list, &iter);
    // does srl_find_payload() return iter as advertised?
    fail_unless(srl_find_payload(&iter, &iter) == &iter, NULL);
    // srl_find_payload() should not find anything
    fail_unless(srl_is_eol(&iter), NULL);
}
END_TEST

static int map_multiply(struct srl_iterator *const iter,
                        void *const context)
{
    unsigned *const number = srl_payload(iter);
    unsigned *const sum = context;
    
    *number *= 3;
    *sum += *number;

    return 0;
}

static int map_return_one(__attribute__ ((unused)) struct srl_iterator *const iter,
                          __attribute__ ((unused)) void *const context)
{
    return 1;
}

static bool match_first_two(__attribute__ ((unused)) void *const payload,
                            __attribute__ ((unused)) void *const context)
{
    static unsigned invocations = 0;
    invocations += 1;
    return invocations <= 2;
}

START_TEST(test_srl_map_valid)
{
    unsigned numbers[] = { 0, 1, 2, 3, 4, 5, 6, 7 };
    unsigned sum = 0;
    struct srl_iterator iter;
    struct srl_list list = SRL_INIT;
    
    // append numbers in ascending order
    srl_first(&list, &iter);
    for (unsigned idx = 0; idx < sizeof(numbers) / sizeof(numbers[0]); idx += 1) {
        srl_insert_before(&iter, &numbers[idx]);
    }
    
    // multiply the values of all list nodes by 3 and store the total in sum
    fail_unless(srl_map(srl_first(&list, &iter), map_multiply, &sum, NULL, NULL) == 0, NULL);
    // map should have covered the whole list
    fail_unless(srl_is_eol(&iter), NULL);
    // all numbers in the array should have been multiplied by three
    for (unsigned idx = 0; idx < sizeof(numbers) / sizeof(numbers[0]); idx += 1) {
        fail_unless(numbers[idx] == idx * 3, NULL);
    }
    // the sum of the array elements should have been correctly computed by the map function
    fail_unless(sum == 84, NULL);
    
    sum = 0;
    // multiply the value of only the second and third list node and store the total sum
    fail_unless(srl_map(srl_next(srl_first(&list, &iter)), map_multiply, &sum, match_first_two, NULL) == 0, NULL);
    // map should have covered the whole list
    fail_unless(srl_is_eol(&iter), NULL);
    // the second and third number in the array should have been multiplied by three
    fail_unless(numbers[0] == 0);
    for (unsigned idx = 1; idx < 3; idx += 1) {
        fail_unless(numbers[idx] == idx * 9, NULL);
    }
    for (unsigned idx = 3; idx < sizeof(numbers) / sizeof(numbers[0]); idx += 1) {
        fail_unless(numbers[idx] == idx * 3, NULL);
    }
    // the sum of the array elements should have been correctly computed by the map function
    fail_unless(sum == 27, NULL);
    
    // does map() return the value the map callback function returns?
    fail_unless(srl_map(srl_first(&list, &iter), map_return_one, NULL, NULL, NULL) == 1, NULL);
}
END_TEST

#ifndef NDEBUG // The following tests rely on assertions being enabled
START_TEST(test_srl_init_null)
{
    srl_init(NULL, NULL);
}
END_TEST

START_TEST(test_srl_size_null)
{
    srl_size(NULL);
}
END_TEST

START_TEST(test_srl_insert_before_null_iter)
{
    srl_insert_before(NULL, NULL);
}
END_TEST

START_TEST(test_srl_first_null_list)
{
    struct srl_iterator i;
    srl_first(NULL, &i);
}
END_TEST

START_TEST(test_srl_first_null_iter)
{
    struct srl_list l = SRL_INIT;

    srl_first(&l, NULL);
}
END_TEST

START_TEST(test_srl_next_null)
{
    srl_next(NULL);
}
END_TEST

START_TEST(test_srl_del_null)
{
    srl_del(NULL);
}
END_TEST

START_TEST(test_srl_del_eol)
{
    struct srl_list     l = SRL_INIT;
    struct srl_iterator i;

    srl_del(srl_first(&l, &i));
}
END_TEST

START_TEST(test_srl_del_all_null)
{
    srl_del_all(NULL);
}
END_TEST

START_TEST(test_srl_find_iter_null)
{
    srl_find(NULL, match_unsigned, NULL);
}
END_TEST

START_TEST(test_srl_find_match_fn_null)
{
    struct srl_list list = SRL_INIT;
    struct srl_iterator iter;
    
    srl_find(srl_first(&list, &iter), NULL, NULL);
}
END_TEST

START_TEST(test_srl_find_payload_iter_null)
{
    srl_find_payload(NULL, NULL);
}
END_TEST

START_TEST(test_srl_map_iter_null)
{
    unsigned sum = 0;

    srl_map(NULL, map_multiply, &sum, match_first_two, NULL);
}
END_TEST

START_TEST(test_srl_map_map_fn_null)
{
    struct srl_list list = SRL_INIT;
    struct srl_iterator iter;
    srl_map(srl_first(&list, &iter), NULL, NULL, match_first_two, NULL);
}
END_TEST
#endif // NDEBUG

Suite *single(void);

Suite *single(void)
{
    Suite *s = suite_create("single");

    TCase *tc_core = tcase_create("Core");
    tcase_add_test(tc_core, test_srl_init_valid);
    tcase_add_test(tc_core, test_srl_init_valid_free_fn);
    tcase_add_test(tc_core, test_srl_size_valid);
    tcase_add_test(tc_core, test_srl_first_empty);
    tcase_add_test(tc_core, test_srl_next_valid);
    tcase_add_test(tc_core, test_srl_next_eol);
    tcase_add_test(tc_core, test_srl_insert_before_empty_list);
    tcase_add_test(tc_core, test_srl_size_insert_before_reverse);
    tcase_add_test(tc_core, test_srl_size_insert_before_forward);
    tcase_add_test(tc_core, test_srl_size_del_first);
    tcase_add_test(tc_core, test_srl_size_del_iterate);
    tcase_add_test(tc_core, test_srl_insert_before_first_next_payload_del_valid);
    tcase_add_test(tc_core, test_srl_insert_before_null_payload);
    tcase_add_test(tc_core, test_srl_del_all_valid);
    tcase_add_test(tc_core, test_srl_find_valid);
    tcase_add_test(tc_core, test_srl_find_payload_valid);
    tcase_add_test(tc_core, test_srl_map_valid);

#ifndef NDEBUG // The following tests rely on assertions being enabled
    tcase_add_test_raise_signal(tc_core, test_srl_init_null, SIGABRT);
    tcase_add_test_raise_signal(tc_core, test_srl_size_null, SIGABRT);
    tcase_add_test_raise_signal(tc_core, test_srl_insert_before_null_iter, SIGABRT);
    tcase_add_test_raise_signal(tc_core, test_srl_first_null_list, SIGABRT);
    tcase_add_test_raise_signal(tc_core, test_srl_first_null_iter, SIGABRT);
    tcase_add_test_raise_signal(tc_core, test_srl_next_null, SIGABRT);
    tcase_add_test_raise_signal(tc_core, test_srl_del_null, SIGABRT);
    tcase_add_test_raise_signal(tc_core, test_srl_del_eol, SIGABRT);
    tcase_add_test_raise_signal(tc_core, test_srl_del_all_null, SIGABRT);
    tcase_add_test_raise_signal(tc_core, test_srl_find_iter_null, SIGABRT);
    tcase_add_test_raise_signal(tc_core, test_srl_find_match_fn_null, SIGABRT);
    tcase_add_test_raise_signal(tc_core, test_srl_find_payload_iter_null, SIGABRT);
    tcase_add_test_raise_signal(tc_core, test_srl_map_iter_null, SIGABRT);
    tcase_add_test_raise_signal(tc_core, test_srl_map_map_fn_null, SIGABRT);
#endif // NDEBUG

    suite_add_tcase(s, tc_core);

    return s;
}