mirror of
https://github.com/libretro/RetroArch
synced 2025-02-01 20:54:10 +00:00
32d6eeaf07
Reworked the test a bit to make it separate from RA's build system for simplicity. Reworked the testing a bit to ensure coverage is properly generated. This needs more work since it's rather manual and verbose
1301 lines
35 KiB
C
1301 lines
35 KiB
C
/* Copyright (C) 2010-2020 The RetroArch team
|
|
*
|
|
* ---------------------------------------------------------------------------------------
|
|
* The following license statement only applies to this file (test_linked_list.c).
|
|
* ---------------------------------------------------------------------------------------
|
|
*
|
|
* Permission is hereby granted, free of charge,
|
|
* to any person obtaining a copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation the rights to
|
|
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
|
|
* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
|
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
|
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
|
|
#include <check.h>
|
|
#include <stdarg.h>
|
|
#include <stdlib.h>
|
|
|
|
#include <lists/linked_list.h>
|
|
|
|
#define SUITE_NAME "Linked List"
|
|
|
|
static char *_value_1 = "value1";
|
|
static char *_value_2 = "value2";
|
|
static char *_value_3 = "value3";
|
|
|
|
START_TEST (test_linked_list_create)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
ck_assert_ptr_nonnull(list);
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_free)
|
|
{
|
|
linked_list_t *queue = linked_list_new();
|
|
linked_list_free(queue, NULL);
|
|
linked_list_free(NULL, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
static int _free_alloced_value_count;
|
|
static void _free_alloced_value(void *value)
|
|
{
|
|
_free_alloced_value_count++;
|
|
free(value);
|
|
}
|
|
|
|
START_TEST (test_linked_list_free_with_fn)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, malloc(1));
|
|
linked_list_add(list, malloc(1));
|
|
linked_list_add(list, malloc(1));
|
|
|
|
_free_alloced_value_count = 0;
|
|
linked_list_free(list, &_free_alloced_value);
|
|
|
|
ck_assert_int_eq(3, _free_alloced_value_count);
|
|
}
|
|
END_TEST
|
|
|
|
static void _verify_list(linked_list_t *list, int size, ...)
|
|
{
|
|
va_list values_list;
|
|
void **values;
|
|
int i;
|
|
linked_list_iterator_t *iterator;
|
|
|
|
values = (void **)malloc(size * sizeof(void *));
|
|
|
|
ck_assert_int_eq(linked_list_size(list), size);
|
|
|
|
va_start(values_list, size);
|
|
for (i = 0; i < size; i++)
|
|
{
|
|
values[i] = va_arg(values_list, void *);
|
|
ck_assert_ptr_eq(values[i], linked_list_get(list, i));
|
|
}
|
|
va_end(values_list);
|
|
|
|
iterator = linked_list_iterator(list, true);
|
|
for (i = 0; i < size; i++)
|
|
{
|
|
ck_assert_ptr_nonnull(iterator);
|
|
ck_assert_ptr_eq(values[i], linked_list_iterator_value(iterator));
|
|
iterator = linked_list_iterator_next(iterator);
|
|
}
|
|
ck_assert_ptr_null(iterator);
|
|
|
|
iterator = linked_list_iterator(list, false);
|
|
for (i = size - 1; i >= 0; i--)
|
|
{
|
|
ck_assert_ptr_nonnull(iterator);
|
|
ck_assert_ptr_eq(values[i], linked_list_iterator_value(iterator));
|
|
iterator = linked_list_iterator_next(iterator);
|
|
}
|
|
ck_assert_ptr_null(iterator);
|
|
|
|
free(values);
|
|
}
|
|
|
|
START_TEST (test_linked_list_add)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
|
|
_verify_list(list, 3, _value_1, _value_2, _value_3);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_insert_empty)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_insert(list, 0, _value_1);
|
|
|
|
ck_assert_int_eq(linked_list_size(list), 1);
|
|
ck_assert_ptr_eq(linked_list_get(list, 0), _value_1);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_insert_first)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
linked_list_insert(list, 0, _value_1);
|
|
|
|
_verify_list(list, 3, _value_1, _value_2, _value_3);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_insert_middle)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_3);
|
|
linked_list_insert(list, 1, _value_2);
|
|
|
|
_verify_list(list, 3, _value_1, _value_2, _value_3);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_insert_last)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_insert(list, 2, _value_3);
|
|
|
|
_verify_list(list, 3, _value_1, _value_2, _value_3);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_insert_invalid)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_insert(list, 2, _value_1);
|
|
|
|
ck_assert_int_eq(linked_list_size(list), 0);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_insert_null)
|
|
{
|
|
linked_list_insert(NULL, 0, _value_1);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_get_invalid)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
ck_assert_ptr_null(linked_list_get(list, 2));
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_get_null)
|
|
{
|
|
ck_assert_ptr_null(linked_list_get(NULL, 0));
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_get_first_matching_null)
|
|
{
|
|
ck_assert_ptr_null(linked_list_get_first_matching(NULL, NULL, NULL));
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_get_first_matching_function_null)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
ck_assert_ptr_null(linked_list_get_first_matching(list, NULL, NULL));
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
|
|
bool _matches_function(void *value, void *state)
|
|
{
|
|
ck_assert_ptr_eq(_value_1, state);
|
|
return value == _value_2;
|
|
}
|
|
|
|
START_TEST (test_linked_list_get_first_matching_no_match)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
ck_assert_ptr_null(linked_list_get_first_matching(list, &_matches_function, _value_1));
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_get_first_matching_with_match)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
|
|
ck_assert_ptr_eq(_value_2, linked_list_get_first_matching(list, &_matches_function, _value_1));
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_get_last_matching_null)
|
|
{
|
|
ck_assert_ptr_null(linked_list_get_last_matching(NULL, NULL, NULL));
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_get_last_matching_function_null)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
ck_assert_ptr_null(linked_list_get_last_matching(list, NULL, NULL));
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
|
|
START_TEST (test_linked_list_get_last_matching_no_match)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
ck_assert_ptr_null(linked_list_get_last_matching(list, &_matches_function, _value_1));
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_get_last_matching_with_match)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
|
|
ck_assert_ptr_eq(_value_2, linked_list_get_last_matching(list, &_matches_function, _value_1));
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_at_null)
|
|
{
|
|
ck_assert_ptr_null(linked_list_remove_at(NULL, 0));
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_at_empty)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
ck_assert_ptr_null(linked_list_remove_at(list, 0));
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_at_invalid)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
|
|
linked_list_remove_at(list, 3);
|
|
|
|
_verify_list(list, 3, _value_1, _value_2, _value_3);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_at_first)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
|
|
linked_list_remove_at(list, 0);
|
|
|
|
_verify_list(list, 2, _value_2, _value_3);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_at_middle)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
|
|
linked_list_remove_at(list, 1);
|
|
|
|
_verify_list(list, 2, _value_1, _value_3);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_at_last)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
|
|
linked_list_remove_at(list, 2);
|
|
|
|
_verify_list(list, 2, _value_1, _value_2);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_at_only)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
|
|
linked_list_remove_at(list, 0);
|
|
|
|
_verify_list(list, 0);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_first_null)
|
|
{
|
|
ck_assert_ptr_null(linked_list_remove_first(NULL, _value_1));
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_first_empty)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
ck_assert_ptr_null(linked_list_remove_first(list, _value_1));
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_first_not_found)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
|
|
ck_assert_ptr_null(linked_list_remove_first(list, "foo"));
|
|
|
|
_verify_list(list, 3, _value_1, _value_2, _value_3);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_first_first)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
|
|
ck_assert_ptr_eq(linked_list_remove_first(list, _value_1), _value_1);
|
|
|
|
_verify_list(list, 2, _value_2, _value_3);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_first_middle)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
|
|
ck_assert_ptr_eq(linked_list_remove_first(list, _value_2), _value_2);
|
|
|
|
_verify_list(list, 2, _value_1, _value_3);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_first_last)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
|
|
ck_assert_ptr_eq(linked_list_remove_first(list, _value_3), _value_3);
|
|
|
|
_verify_list(list, 2, _value_1, _value_2);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_first_only)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
|
|
ck_assert_ptr_eq(linked_list_remove_first(list, _value_1), _value_1);
|
|
|
|
_verify_list(list, 0);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_first_multiple)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_1);
|
|
|
|
ck_assert_ptr_eq(linked_list_remove_first(list, _value_1), _value_1);
|
|
|
|
_verify_list(list, 2, _value_2, _value_1);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_last_null)
|
|
{
|
|
ck_assert_ptr_null(linked_list_remove_last(NULL, _value_1));
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_last_empty)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
ck_assert_ptr_null(linked_list_remove_last(list, _value_1));
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_last_not_found)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
|
|
ck_assert_ptr_null(linked_list_remove_last(list, "foo"));
|
|
|
|
_verify_list(list, 3, _value_1, _value_2, _value_3);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_last_first)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
|
|
ck_assert_ptr_eq(linked_list_remove_last(list, _value_1), _value_1);
|
|
|
|
_verify_list(list, 2, _value_2, _value_3);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_last_middle)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
|
|
ck_assert_ptr_eq(linked_list_remove_last(list, _value_2), _value_2);
|
|
|
|
_verify_list(list, 2, _value_1, _value_3);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_last_last)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
|
|
ck_assert_ptr_eq(linked_list_remove_last(list, _value_3), _value_3);
|
|
|
|
_verify_list(list, 2, _value_1, _value_2);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_last_only)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
|
|
ck_assert_ptr_eq(linked_list_remove_last(list, _value_1), _value_1);
|
|
|
|
_verify_list(list, 0);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_last_multiple)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_1);
|
|
|
|
ck_assert_ptr_eq(linked_list_remove_last(list, _value_1), _value_1);
|
|
|
|
_verify_list(list, 2, _value_1, _value_2);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_all_null)
|
|
{
|
|
ck_assert_ptr_null(linked_list_remove_all(NULL, _value_1));
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_all_empty)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
ck_assert_ptr_null(linked_list_remove_all(list, _value_1));
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_all_not_found)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
|
|
ck_assert_ptr_null(linked_list_remove_all(list, "foo"));
|
|
|
|
_verify_list(list, 3, _value_1, _value_2, _value_3);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_all_first)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
|
|
ck_assert_ptr_eq(linked_list_remove_all(list, _value_1), _value_1);
|
|
|
|
_verify_list(list, 2, _value_2, _value_3);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_all_middle)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
|
|
ck_assert_ptr_eq(linked_list_remove_all(list, _value_2), _value_2);
|
|
|
|
_verify_list(list, 2, _value_1, _value_3);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_all_last)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
|
|
ck_assert_ptr_eq(linked_list_remove_all(list, _value_3), _value_3);
|
|
|
|
_verify_list(list, 2, _value_1, _value_2);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_all_only)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
|
|
ck_assert_ptr_eq(linked_list_remove_all(list, _value_1), _value_1);
|
|
|
|
_verify_list(list, 0);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_all_multiple)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_1);
|
|
|
|
ck_assert_ptr_eq(linked_list_remove_all(list, _value_1), _value_1);
|
|
|
|
_verify_list(list, 1, _value_2);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
bool _match_value_1(void *value)
|
|
{
|
|
return _value_1 == value;
|
|
}
|
|
|
|
bool _no_match(void *value)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
START_TEST (test_linked_list_remove_first_matching_null)
|
|
{
|
|
ck_assert_ptr_null(linked_list_remove_first_matching(NULL, &_match_value_1));
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_first_matching_empty)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
ck_assert_ptr_null(linked_list_remove_first_matching(list, &_match_value_1));
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_first_matching_not_found)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
|
|
ck_assert_ptr_null(linked_list_remove_first_matching(list, &_no_match));
|
|
|
|
_verify_list(list, 3, _value_1, _value_2, _value_3);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_first_matching_first)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
|
|
ck_assert_ptr_eq(linked_list_remove_first_matching(list, &_match_value_1), _value_1);
|
|
|
|
_verify_list(list, 2, _value_2, _value_3);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_first_matching_middle)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_3);
|
|
|
|
ck_assert_ptr_eq(linked_list_remove_first_matching(list, &_match_value_1), _value_1);
|
|
|
|
_verify_list(list, 2, _value_2, _value_3);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_first_matching_last)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
linked_list_add(list, _value_1);
|
|
|
|
ck_assert_ptr_eq(linked_list_remove_first_matching(list, &_match_value_1), _value_1);
|
|
|
|
_verify_list(list, 2, _value_2, _value_3);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_first_matching_only)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
|
|
ck_assert_ptr_eq(linked_list_remove_first_matching(list, &_match_value_1), _value_1);
|
|
|
|
_verify_list(list, 0);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_first_matching_multiple)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_1);
|
|
|
|
ck_assert_ptr_eq(linked_list_remove_first_matching(list, &_match_value_1), _value_1);
|
|
|
|
_verify_list(list, 2, _value_2, _value_1);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_last_matching_null)
|
|
{
|
|
ck_assert_ptr_null(linked_list_remove_last_matching(NULL, &_match_value_1));
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_last_matching_empty)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
ck_assert_ptr_null(linked_list_remove_last_matching(list, &_match_value_1));
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_last_matching_not_found)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
|
|
ck_assert_ptr_null(linked_list_remove_last_matching(list, &_no_match));
|
|
|
|
_verify_list(list, 3, _value_1, _value_2, _value_3);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_last_matching_first)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
|
|
ck_assert_ptr_eq(linked_list_remove_last_matching(list, &_match_value_1), _value_1);
|
|
|
|
_verify_list(list, 2, _value_2, _value_3);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_last_matching_middle)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_3);
|
|
|
|
ck_assert_ptr_eq(linked_list_remove_last_matching(list, &_match_value_1), _value_1);
|
|
|
|
_verify_list(list, 2, _value_2, _value_3);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_last_matching_last)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
linked_list_add(list, _value_1);
|
|
|
|
ck_assert_ptr_eq(linked_list_remove_last_matching(list, &_match_value_1), _value_1);
|
|
|
|
_verify_list(list, 2, _value_2, _value_3);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_last_matching_only)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
|
|
ck_assert_ptr_eq(linked_list_remove_last_matching(list, &_match_value_1), _value_1);
|
|
|
|
_verify_list(list, 0);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_last_matching_multiple)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_1);
|
|
|
|
ck_assert_ptr_eq(linked_list_remove_last_matching(list, &_match_value_1), _value_1);
|
|
|
|
_verify_list(list, 2, _value_1, _value_2);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_all_matching_null)
|
|
{
|
|
linked_list_remove_all_matching(NULL, &_match_value_1);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_all_matching_empty)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_remove_all_matching(list, &_match_value_1);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_all_matching_not_found)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
|
|
linked_list_remove_all_matching(list, &_no_match);
|
|
|
|
_verify_list(list, 3, _value_1, _value_2, _value_3);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_all_matching_first)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
|
|
linked_list_remove_all_matching(list, &_match_value_1);
|
|
|
|
_verify_list(list, 2, _value_2, _value_3);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_all_matching_middle)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_3);
|
|
|
|
linked_list_remove_all_matching(list, &_match_value_1);
|
|
|
|
_verify_list(list, 2, _value_2, _value_3);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_all_matching_last)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
linked_list_add(list, _value_1);
|
|
|
|
linked_list_remove_all_matching(list, &_match_value_1);
|
|
|
|
_verify_list(list, 2, _value_2, _value_3);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_all_matching_only)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
|
|
linked_list_remove_all_matching(list, &_match_value_1);
|
|
|
|
_verify_list(list, 0);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_remove_all_matching_multiple)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_1);
|
|
|
|
linked_list_remove_all_matching(list, &_match_value_1);
|
|
|
|
_verify_list(list, 1, _value_2);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_set_at_null)
|
|
{
|
|
ck_assert_int_eq(linked_list_set_at(NULL, 0, _value_1) == true, 0);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_set_at_empty)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
ck_assert_int_eq(linked_list_set_at(list, 0, _value_1) == true, 0);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_set_at_invalid)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
ck_assert_int_eq(linked_list_set_at(list, 1, _value_2) == true, 0);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
static char *_replacement_value = "foo";
|
|
|
|
START_TEST (test_linked_list_set_at_first)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
|
|
ck_assert_int_eq(linked_list_set_at(list, 0, _replacement_value) == false, 0);
|
|
|
|
_verify_list(list, 3, _replacement_value, _value_2, _value_3);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_set_at_middle)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
|
|
ck_assert_int_eq(linked_list_set_at(list, 1, _replacement_value) == false, 0);
|
|
|
|
_verify_list(list, 3, _value_1, _replacement_value, _value_3);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_set_at_last)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
|
|
ck_assert_int_eq(linked_list_set_at(list, 2, _replacement_value) == false, 0);
|
|
|
|
_verify_list(list, 3, _value_1, _value_2, _replacement_value);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_iterator_remove_null)
|
|
{
|
|
ck_assert_ptr_null(linked_list_iterator_remove(NULL));
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_iterator_remove_first)
|
|
{
|
|
linked_list_t *list;
|
|
linked_list_iterator_t *iterator;
|
|
|
|
list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
|
|
iterator = linked_list_iterator(list, true);
|
|
iterator = linked_list_iterator_remove(iterator);
|
|
|
|
ck_assert_ptr_nonnull(iterator);
|
|
ck_assert_ptr_eq(linked_list_iterator_value(iterator), _value_2);
|
|
_verify_list(list, 2, _value_2, _value_3);
|
|
|
|
linked_list_iterator_free(iterator);
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_iterator_remove_middle)
|
|
{
|
|
linked_list_t *list;
|
|
linked_list_iterator_t *iterator;
|
|
|
|
list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
|
|
iterator = linked_list_iterator(list, true);
|
|
iterator = linked_list_iterator_next(iterator);
|
|
iterator = linked_list_iterator_remove(iterator);
|
|
|
|
ck_assert_ptr_nonnull(iterator);
|
|
ck_assert_ptr_eq(linked_list_iterator_value(iterator), _value_3);
|
|
_verify_list(list, 2, _value_1, _value_3);
|
|
|
|
linked_list_iterator_free(iterator);
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_iterator_remove_last)
|
|
{
|
|
linked_list_t *list;
|
|
linked_list_iterator_t *iterator;
|
|
|
|
list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
|
|
iterator = linked_list_iterator(list, true);
|
|
iterator = linked_list_iterator_next(iterator);
|
|
iterator = linked_list_iterator_next(iterator);
|
|
iterator = linked_list_iterator_remove(iterator);
|
|
|
|
ck_assert_ptr_null(iterator);
|
|
_verify_list(list, 2, _value_1, _value_2);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_iterator_free_null)
|
|
{
|
|
linked_list_iterator_free(NULL);
|
|
}
|
|
END_TEST
|
|
|
|
static size_t _foreach_count;
|
|
static void _foreach_fn(size_t index, void *value)
|
|
{
|
|
_foreach_count++;
|
|
}
|
|
|
|
START_TEST (test_linked_list_foreach_null_list)
|
|
{
|
|
linked_list_foreach(NULL, _foreach_fn);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_foreach_null_fn)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
|
|
linked_list_foreach(list, NULL);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST (test_linked_list_foreach_valid)
|
|
{
|
|
linked_list_t *list = linked_list_new();
|
|
linked_list_add(list, _value_1);
|
|
linked_list_add(list, _value_2);
|
|
linked_list_add(list, _value_3);
|
|
|
|
_foreach_count = 0;
|
|
linked_list_foreach(list, &_foreach_fn);
|
|
ck_assert_uint_eq(3, _foreach_count);
|
|
|
|
linked_list_free(list, NULL);
|
|
}
|
|
|
|
Suite *create_suite(void)
|
|
{
|
|
Suite *s = suite_create(SUITE_NAME);
|
|
|
|
TCase *tc_core = tcase_create("Core");
|
|
tcase_add_test(tc_core, test_linked_list_create);
|
|
tcase_add_test(tc_core, test_linked_list_free);
|
|
tcase_add_test(tc_core, test_linked_list_free_with_fn);
|
|
tcase_add_test(tc_core, test_linked_list_add);
|
|
tcase_add_test(tc_core, test_linked_list_insert_empty);
|
|
tcase_add_test(tc_core, test_linked_list_insert_first);
|
|
tcase_add_test(tc_core, test_linked_list_insert_middle);
|
|
tcase_add_test(tc_core, test_linked_list_insert_last);
|
|
tcase_add_test(tc_core, test_linked_list_insert_invalid);
|
|
tcase_add_test(tc_core, test_linked_list_insert_null);
|
|
tcase_add_test(tc_core, test_linked_list_get_invalid);
|
|
tcase_add_test(tc_core, test_linked_list_get_null);
|
|
tcase_add_test(tc_core, test_linked_list_get_first_matching_null);
|
|
tcase_add_test(tc_core, test_linked_list_get_first_matching_function_null);
|
|
tcase_add_test(tc_core, test_linked_list_get_first_matching_no_match);
|
|
tcase_add_test(tc_core, test_linked_list_get_first_matching_with_match);
|
|
tcase_add_test(tc_core, test_linked_list_get_last_matching_null);
|
|
tcase_add_test(tc_core, test_linked_list_get_last_matching_function_null);
|
|
tcase_add_test(tc_core, test_linked_list_get_last_matching_no_match);
|
|
tcase_add_test(tc_core, test_linked_list_get_last_matching_with_match);
|
|
tcase_add_test(tc_core, test_linked_list_remove_at_null);
|
|
tcase_add_test(tc_core, test_linked_list_remove_at_empty);
|
|
tcase_add_test(tc_core, test_linked_list_remove_at_invalid);
|
|
tcase_add_test(tc_core, test_linked_list_remove_at_first);
|
|
tcase_add_test(tc_core, test_linked_list_remove_at_middle);
|
|
tcase_add_test(tc_core, test_linked_list_remove_at_last);
|
|
tcase_add_test(tc_core, test_linked_list_remove_at_only);
|
|
tcase_add_test(tc_core, test_linked_list_remove_first_null);
|
|
tcase_add_test(tc_core, test_linked_list_remove_first_empty);
|
|
tcase_add_test(tc_core, test_linked_list_remove_first_not_found);
|
|
tcase_add_test(tc_core, test_linked_list_remove_first_first);
|
|
tcase_add_test(tc_core, test_linked_list_remove_first_middle);
|
|
tcase_add_test(tc_core, test_linked_list_remove_first_last);
|
|
tcase_add_test(tc_core, test_linked_list_remove_first_only);
|
|
tcase_add_test(tc_core, test_linked_list_remove_first_multiple);
|
|
tcase_add_test(tc_core, test_linked_list_remove_last_null);
|
|
tcase_add_test(tc_core, test_linked_list_remove_last_empty);
|
|
tcase_add_test(tc_core, test_linked_list_remove_last_not_found);
|
|
tcase_add_test(tc_core, test_linked_list_remove_last_first);
|
|
tcase_add_test(tc_core, test_linked_list_remove_last_middle);
|
|
tcase_add_test(tc_core, test_linked_list_remove_last_last);
|
|
tcase_add_test(tc_core, test_linked_list_remove_last_only);
|
|
tcase_add_test(tc_core, test_linked_list_remove_last_multiple);
|
|
tcase_add_test(tc_core, test_linked_list_remove_all_null);
|
|
tcase_add_test(tc_core, test_linked_list_remove_all_empty);
|
|
tcase_add_test(tc_core, test_linked_list_remove_all_not_found);
|
|
tcase_add_test(tc_core, test_linked_list_remove_all_first);
|
|
tcase_add_test(tc_core, test_linked_list_remove_all_middle);
|
|
tcase_add_test(tc_core, test_linked_list_remove_all_last);
|
|
tcase_add_test(tc_core, test_linked_list_remove_all_only);
|
|
tcase_add_test(tc_core, test_linked_list_remove_all_multiple);
|
|
tcase_add_test(tc_core, test_linked_list_remove_first_matching_null);
|
|
tcase_add_test(tc_core, test_linked_list_remove_first_matching_empty);
|
|
tcase_add_test(tc_core, test_linked_list_remove_first_matching_not_found);
|
|
tcase_add_test(tc_core, test_linked_list_remove_first_matching_first);
|
|
tcase_add_test(tc_core, test_linked_list_remove_first_matching_middle);
|
|
tcase_add_test(tc_core, test_linked_list_remove_first_matching_last);
|
|
tcase_add_test(tc_core, test_linked_list_remove_first_matching_only);
|
|
tcase_add_test(tc_core, test_linked_list_remove_first_matching_multiple);
|
|
tcase_add_test(tc_core, test_linked_list_remove_last_matching_null);
|
|
tcase_add_test(tc_core, test_linked_list_remove_last_matching_empty);
|
|
tcase_add_test(tc_core, test_linked_list_remove_last_matching_not_found);
|
|
tcase_add_test(tc_core, test_linked_list_remove_last_matching_first);
|
|
tcase_add_test(tc_core, test_linked_list_remove_last_matching_middle);
|
|
tcase_add_test(tc_core, test_linked_list_remove_last_matching_last);
|
|
tcase_add_test(tc_core, test_linked_list_remove_last_matching_only);
|
|
tcase_add_test(tc_core, test_linked_list_remove_last_matching_multiple);
|
|
tcase_add_test(tc_core, test_linked_list_remove_all_matching_null);
|
|
tcase_add_test(tc_core, test_linked_list_remove_all_matching_empty);
|
|
tcase_add_test(tc_core, test_linked_list_remove_all_matching_not_found);
|
|
tcase_add_test(tc_core, test_linked_list_remove_all_matching_first);
|
|
tcase_add_test(tc_core, test_linked_list_remove_all_matching_middle);
|
|
tcase_add_test(tc_core, test_linked_list_remove_all_matching_last);
|
|
tcase_add_test(tc_core, test_linked_list_remove_all_matching_only);
|
|
tcase_add_test(tc_core, test_linked_list_remove_all_matching_multiple);
|
|
tcase_add_test(tc_core, test_linked_list_set_at_null);
|
|
tcase_add_test(tc_core, test_linked_list_set_at_empty);
|
|
tcase_add_test(tc_core, test_linked_list_set_at_invalid);
|
|
tcase_add_test(tc_core, test_linked_list_set_at_first);
|
|
tcase_add_test(tc_core, test_linked_list_set_at_middle);
|
|
tcase_add_test(tc_core, test_linked_list_set_at_last);
|
|
tcase_add_test(tc_core, test_linked_list_iterator_remove_null);
|
|
tcase_add_test(tc_core, test_linked_list_iterator_remove_first);
|
|
tcase_add_test(tc_core, test_linked_list_iterator_remove_middle);
|
|
tcase_add_test(tc_core, test_linked_list_iterator_remove_last);
|
|
tcase_add_test(tc_core, test_linked_list_iterator_free_null);
|
|
tcase_add_test(tc_core, test_linked_list_foreach_null_list);
|
|
tcase_add_test(tc_core, test_linked_list_foreach_null_fn);
|
|
tcase_add_test(tc_core, test_linked_list_foreach_valid);
|
|
suite_add_tcase(s, tc_core);
|
|
|
|
return s;
|
|
}
|
|
|
|
int main(void)
|
|
{
|
|
int num_fail;
|
|
Suite *s = create_suite();
|
|
SRunner *sr = srunner_create(s);
|
|
srunner_run_all(sr, CK_NORMAL);
|
|
num_fail = srunner_ntests_failed(sr);
|
|
srunner_free(sr);
|
|
return (num_fail == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
|
|
}
|