diff --git a/src/cmc/heap.h b/src/cmc/heap.h index e04ac1c..e3d0285 100644 --- a/src/cmc/heap.h +++ b/src/cmc/heap.h @@ -112,6 +112,7 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " "capacity:%" PRIuMAX ", " "count:%" PRIuMAX ", " "type:%s, " + "flag:%d, " "f_val:%p, " "alloc:%p, " "callbacks: %p}"; @@ -547,7 +548,7 @@ struct cmc_callbacks_heap \ int n = snprintf(str.s, cmc_string_len, cmc_string_fmt_heap, #SNAME, \ #V, h_, h_->buffer, h_->capacity, h_->count, t, \ - h_->f_val, h_->alloc, h_->callbacks); \ + h_->flag, h_->f_val, h_->alloc, h_->callbacks); \ \ return n >= 0 ? str : (struct cmc_string){ 0 }; \ } \ diff --git a/src/cmc/intervalheap.h b/src/cmc/intervalheap.h index 5df8c90..5c9a5cc 100644 --- a/src/cmc/intervalheap.h +++ b/src/cmc/intervalheap.h @@ -89,6 +89,7 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " "capacity:%" PRIuMAX ", " "size:%" PRIuMAX ", " "count:%" PRIuMAX ", " + "flag:%d, " "f_val:%p, " "alloc:%p, " "callbacks:%p }"; @@ -739,7 +740,8 @@ struct cmc_callbacks_intervalheap \ int n = snprintf(str.s, cmc_string_len, cmc_string_fmt_intervalheap, \ #SNAME, #V, h_, h_->buffer, h_->capacity, h_->size, \ - h_->count, h_->f_val, h_->alloc, h_->callbacks); \ + h_->count, h_->flag, h_->f_val, h_->alloc, \ + h_->callbacks); \ \ return n >= 0 ? str : (struct cmc_string){ 0 }; \ } \ diff --git a/src/cmc/linkedlist.h b/src/cmc/linkedlist.h index 52af52d..e24f18f 100644 --- a/src/cmc/linkedlist.h +++ b/src/cmc/linkedlist.h @@ -95,6 +95,8 @@ static const char *cmc_string_fmt_linkedlist = "struct %s<%s> " "count:%" PRIuMAX ", " "head:%p, " "tail:%p, " + "flag:%d, " + "f_val:%p, " "alloc:%p, " "callbacks:%p }"; @@ -140,17 +142,23 @@ struct cmc_callbacks_linkedlist /* Current amount of elements in the list */ \ size_t count; \ \ - /* Function that returns an iterator to the start of the list */ \ - struct SNAME##_iter (*it_start)(struct SNAME *); \ + /* Flags indicating errors or success */ \ + int flag; \ \ - /* Function that returns an iterator to the end of the list */ \ - struct SNAME##_iter (*it_end)(struct SNAME *); \ + /* Value function table */ \ + struct SNAME##_ftab_val *f_val; \ \ /* Custom allocation functions */ \ struct cmc_alloc_node *alloc; \ \ /* Custom callback functions */ \ struct cmc_callbacks_linkedlist *callbacks; \ + \ + /* Function that returns an iterator to the start of the list */ \ + struct SNAME##_iter (*it_start)(struct SNAME *); \ + \ + /* Function that returns an iterator to the end of the list */ \ + struct SNAME##_iter (*it_end)(struct SNAME *); \ }; \ \ /* Doubly-linked list node */ \ @@ -166,6 +174,28 @@ struct cmc_callbacks_linkedlist struct SNAME##_node *prev; \ }; \ \ + /* Value struct function table */ \ + struct SNAME##_ftab_val \ + { \ + /* Comparator function */ \ + int (*cmp)(V, V); \ + \ + /* Copy function */ \ + V (*cpy)(V); \ + \ + /* To string function */ \ + bool (*str)(FILE *, V); \ + \ + /* Free from memory function */ \ + void (*free)(V); \ + \ + /* Hash function */ \ + size_t (*hash)(V); \ + \ + /* Priority function */ \ + int (*pri)(V, V); \ + }; \ + \ /* Linked List Iterator */ \ struct SNAME##_iter \ { \ @@ -187,12 +217,12 @@ struct cmc_callbacks_linkedlist \ /* Collection Functions */ \ /* Collection Allocation and Deallocation */ \ - struct SNAME *PFX##_new(void); \ + struct SNAME *PFX##_new(struct SNAME##_ftab_val *f_val); \ struct SNAME *PFX##_new_custom( \ - struct cmc_alloc_node *alloc, \ + struct SNAME##_ftab_val *f_val, struct cmc_alloc_node *alloc, \ struct cmc_callbacks_linkedlist *callbacks); \ - void PFX##_clear(struct SNAME *_list_, void (*deallocator)(V)); \ - void PFX##_free(struct SNAME *_list_, void (*deallocator)(V)); \ + void PFX##_clear(struct SNAME *_list_); \ + void PFX##_free(struct SNAME *_list_); \ /* Customization of Allocation and Callbacks */ \ void PFX##_customize(struct SNAME *_list_, struct cmc_alloc_node *alloc, \ struct cmc_callbacks_linkedlist *callbacks); \ @@ -209,14 +239,12 @@ struct cmc_callbacks_linkedlist V *PFX##_get_ref(struct SNAME *_list_, size_t index); \ V PFX##_back(struct SNAME *_list_); \ /* Collection State */ \ - bool PFX##_contains(struct SNAME *_list_, V element, \ - int (*comparator)(V, V)); \ + bool PFX##_contains(struct SNAME *_list_, V element); \ bool PFX##_empty(struct SNAME *_list_); \ size_t PFX##_count(struct SNAME *_list_); \ /* Collection Utility */ \ - struct SNAME *PFX##_copy_of(struct SNAME *_list_, V (*copy_func)(V)); \ - bool PFX##_equals(struct SNAME *_list1_, struct SNAME *_list2_, \ - int (*comparator)(V, V)); \ + struct SNAME *PFX##_copy_of(struct SNAME *_list_); \ + bool PFX##_equals(struct SNAME *_list1_, struct SNAME *_list2_); \ struct cmc_string PFX##_to_string(struct SNAME *_list_); \ \ /* Node Related Functions */ \ @@ -274,8 +302,11 @@ struct cmc_callbacks_linkedlist static struct SNAME##_iter PFX##_impl_it_start(struct SNAME *_list_); \ static struct SNAME##_iter PFX##_impl_it_end(struct SNAME *_list_); \ \ - struct SNAME *PFX##_new(void) \ + struct SNAME *PFX##_new(struct SNAME##_ftab_val *f_val) \ { \ + if (!f_val) \ + return NULL; \ + \ struct cmc_alloc_node *alloc = &cmc_alloc_node_default; \ \ struct SNAME *_list_ = alloc->malloc(sizeof(struct SNAME)); \ @@ -286,19 +317,23 @@ struct cmc_callbacks_linkedlist _list_->count = 0; \ _list_->head = NULL; \ _list_->tail = NULL; \ - \ - _list_->it_start = PFX##_impl_it_start; \ - _list_->it_end = PFX##_impl_it_end; \ - \ + _list_->flag = cmc_flags.OK; \ + _list_->f_val = f_val; \ _list_->alloc = alloc; \ _list_->callbacks = NULL; \ + _list_->it_start = PFX##_impl_it_start; \ + _list_->it_end = PFX##_impl_it_end; \ \ return _list_; \ } \ \ - struct SNAME *PFX##_new_custom(struct cmc_alloc_node *alloc, \ + struct SNAME *PFX##_new_custom(struct SNAME##_ftab_val *f_val, \ + struct cmc_alloc_node *alloc, \ struct cmc_callbacks_linkedlist *callbacks) \ { \ + if (!f_val) \ + return NULL; \ + \ if (!alloc) \ alloc = &cmc_alloc_node_default; \ \ @@ -310,17 +345,17 @@ struct cmc_callbacks_linkedlist _list_->count = 0; \ _list_->head = NULL; \ _list_->tail = NULL; \ - \ - _list_->it_start = PFX##_impl_it_start; \ - _list_->it_end = PFX##_impl_it_end; \ - \ + _list_->flag = cmc_flags.OK; \ + _list_->f_val = f_val; \ _list_->alloc = alloc; \ _list_->callbacks = callbacks; \ + _list_->it_start = PFX##_impl_it_start; \ + _list_->it_end = PFX##_impl_it_end; \ \ return _list_; \ } \ \ - void PFX##_clear(struct SNAME *_list_, void (*deallocator)(V)) \ + void PFX##_clear(struct SNAME *_list_) \ { \ struct SNAME##_node *scan = _list_->head; \ \ @@ -328,9 +363,9 @@ struct cmc_callbacks_linkedlist { \ _list_->head = _list_->head->next; \ \ - if (deallocator) \ + if (_list_->f_val->free) \ { \ - deallocator(scan->data); \ + _list_->f_val->free(scan->data); \ } \ \ _list_->alloc->free(scan); \ @@ -343,9 +378,9 @@ struct cmc_callbacks_linkedlist _list_->tail = NULL; \ } \ \ - void PFX##_free(struct SNAME *_list_, void (*deallocator)(V)) \ + void PFX##_free(struct SNAME *_list_) \ { \ - PFX##_clear(_list_, deallocator); \ + PFX##_clear(_list_); \ \ _list_->alloc->free(_list_); \ } \ @@ -556,14 +591,13 @@ struct cmc_callbacks_linkedlist return _list_->tail->data; \ } \ \ - bool PFX##_contains(struct SNAME *_list_, V element, \ - int (*comparator)(V, V)) \ + bool PFX##_contains(struct SNAME *_list_, V element) \ { \ struct SNAME##_node *scan = _list_->head; \ \ while (scan != NULL) \ { \ - if (comparator(scan->data, element) == 0) \ + if (_list_->f_val->cmp(scan->data, element) == 0) \ return true; \ \ scan = scan->next; \ @@ -582,10 +616,10 @@ struct cmc_callbacks_linkedlist return _list_->count; \ } \ \ - struct SNAME *PFX##_copy_of(struct SNAME *_list_, V (*copy_func)(V)) \ + struct SNAME *PFX##_copy_of(struct SNAME *_list_) \ { \ struct SNAME *result = \ - PFX##_new_custom(_list_->alloc, _list_->callbacks); \ + PFX##_new_custom(_list_->f_val, _list_->alloc, _list_->callbacks); \ \ if (!result) \ return NULL; \ @@ -598,8 +632,9 @@ struct cmc_callbacks_linkedlist /* possible to recover from it. That is why it isn't checked */ \ struct SNAME##_node *new_node; \ \ - if (copy_func) \ - new_node = PFX##_new_node(_list_, copy_func(scan->data)); \ + if (_list_->f_val->cpy) \ + new_node = \ + PFX##_new_node(_list_, _list_->f_val->cpy(scan->data)); \ else \ new_node = PFX##_new_node(_list_, scan->data); \ \ @@ -623,8 +658,7 @@ struct cmc_callbacks_linkedlist return result; \ } \ \ - bool PFX##_equals(struct SNAME *_list1_, struct SNAME *_list2_, \ - int (*comparator)(V, V)) \ + bool PFX##_equals(struct SNAME *_list1_, struct SNAME *_list2_) \ { \ if (PFX##_count(_list1_) != PFX##_count(_list2_)) \ return false; \ @@ -634,7 +668,7 @@ struct cmc_callbacks_linkedlist \ while (scan1 != NULL && scan2 != NULL) \ { \ - if (comparator(scan1->data, scan2->data) != 0) \ + if (_list1_->f_val->cmp(scan1->data, scan2->data) != 0) \ return false; \ \ scan1 = scan1->next; \ @@ -651,14 +685,9 @@ struct cmc_callbacks_linkedlist \ int n = snprintf(str.s, cmc_string_len, cmc_string_fmt_linkedlist, \ #SNAME, #V, l_, l_->count, l_->head, l_->tail, \ - l_->alloc, l_->callbacks); \ + l_->flag, l_->f_val, l_->alloc, l_->callbacks); \ \ - if (n < 0 || n == (int)cmc_string_len) \ - return (struct cmc_string){ 0 }; \ - \ - str.s[n] = '\0'; \ - \ - return str; \ + return n >= 0 ? str : (struct cmc_string){ 0 }; \ } \ \ struct SNAME##_node *PFX##_new_node(struct SNAME *_list_, V element) \ diff --git a/src/cmc/list.h b/src/cmc/list.h index 8575c78..c937799 100644 --- a/src/cmc/list.h +++ b/src/cmc/list.h @@ -110,6 +110,8 @@ static const char *cmc_string_fmt_list = "struct %s<%s> " "buffer:%p, " "capacity:%" PRIuMAX ", " "count:%" PRIuMAX ", " + "flag:%d, " + "f_val:%p, " "alloc:%p, " "callbacks:%p }"; @@ -155,6 +157,12 @@ struct cmc_callbacks_list /* Current amount of elements */ \ size_t count; \ \ + /* Flags indicating errors or success */ \ + int flag; \ + \ + /* Value function table */ \ + struct SNAME##_ftab_val *f_val; \ + \ /* Function that returns an iterator to the start of the list */ \ struct SNAME##_iter (*it_start)(struct SNAME *); \ \ @@ -168,6 +176,28 @@ struct cmc_callbacks_list struct cmc_callbacks_list *callbacks; \ }; \ \ + /* Value struct function table */ \ + struct SNAME##_ftab_val \ + { \ + /* Comparator function */ \ + int (*cmp)(V, V); \ + \ + /* Copy function */ \ + V (*cpy)(V); \ + \ + /* To string function */ \ + bool (*str)(FILE *, V); \ + \ + /* Free from memory function */ \ + void (*free)(V); \ + \ + /* Hash function */ \ + size_t (*hash)(V); \ + \ + /* Priority function */ \ + int (*pri)(V, V); \ + }; \ + \ /* List Iterator */ \ struct SNAME##_iter \ { \ @@ -186,12 +216,12 @@ struct cmc_callbacks_list \ /* Collection Functions */ \ /* Collection Allocation and Deallocation */ \ - struct SNAME *PFX##_new(size_t capacity); \ - struct SNAME *PFX##_new_custom(size_t capacity, \ - struct cmc_alloc_node *alloc, \ - struct cmc_callbacks_list *callbacks); \ - void PFX##_clear(struct SNAME *_list_, void (*deallocator)(V)); \ - void PFX##_free(struct SNAME *_list_, void (*deallocator)(V)); \ + struct SNAME *PFX##_new(size_t capacity, struct SNAME##_ftab_val *f_val); \ + struct SNAME *PFX##_new_custom( \ + size_t capacity, struct SNAME##_ftab_val *f_val, \ + struct cmc_alloc_node *alloc, struct cmc_callbacks_list *callbacks); \ + void PFX##_clear(struct SNAME *_list_); \ + void PFX##_free(struct SNAME *_list_); \ /* Customization of Allocation and Callbacks */ \ void PFX##_customize(struct SNAME *_list_, struct cmc_alloc_node *alloc, \ struct cmc_callbacks_list *callbacks); \ @@ -215,11 +245,9 @@ struct cmc_callbacks_list V PFX##_get(struct SNAME *_list_, size_t index); \ V *PFX##_get_ref(struct SNAME *_list_, size_t index); \ V PFX##_back(struct SNAME *_list_); \ - size_t PFX##_indexof(struct SNAME *_list_, V element, \ - int (*comparator)(V, V), bool from_start); \ + size_t PFX##_indexof(struct SNAME *_list_, V element, bool from_start); \ /* Collection State */ \ - bool PFX##_contains(struct SNAME *_list_, V element, \ - int (*comparator)(V, V)); \ + bool PFX##_contains(struct SNAME *_list_, V element); \ bool PFX##_empty(struct SNAME *_list_); \ bool PFX##_full(struct SNAME *_list_); \ size_t PFX##_count(struct SNAME *_list_); \ @@ -227,9 +255,8 @@ struct cmc_callbacks_list size_t PFX##_capacity(struct SNAME *_list_); \ /* Collection Utility */ \ bool PFX##_resize(struct SNAME *_list_, size_t capacity); \ - struct SNAME *PFX##_copy_of(struct SNAME *_list_, V (*copy_func)(V)); \ - bool PFX##_equals(struct SNAME *_list1_, struct SNAME *_list2_, \ - int (*comparator)(V, V)); \ + struct SNAME *PFX##_copy_of(struct SNAME *_list_); \ + bool PFX##_equals(struct SNAME *_list1_, struct SNAME *_list2_); \ struct cmc_string PFX##_to_string(struct SNAME *_list_); \ \ /* Iterator Functions */ \ @@ -263,7 +290,7 @@ struct cmc_callbacks_list static struct SNAME##_iter PFX##_impl_it_start(struct SNAME *_list_); \ static struct SNAME##_iter PFX##_impl_it_end(struct SNAME *_list_); \ \ - struct SNAME *PFX##_new(size_t capacity) \ + struct SNAME *PFX##_new(size_t capacity, struct SNAME##_ftab_val *f_val) \ { \ struct cmc_alloc_node *alloc = &cmc_alloc_node_default; \ \ @@ -285,23 +312,26 @@ struct cmc_callbacks_list \ _list_->capacity = capacity; \ _list_->count = 0; \ - \ - _list_->it_start = PFX##_impl_it_start; \ - _list_->it_end = PFX##_impl_it_end; \ - \ + _list_->flag = cmc_flags.OK; \ + _list_->f_val = f_val; \ _list_->alloc = alloc; \ _list_->callbacks = NULL; \ + _list_->it_start = PFX##_impl_it_start; \ + _list_->it_end = PFX##_impl_it_end; \ \ return _list_; \ } \ \ - struct SNAME *PFX##_new_custom(size_t capacity, \ - struct cmc_alloc_node *alloc, \ - struct cmc_callbacks_list *callbacks) \ + struct SNAME *PFX##_new_custom( \ + size_t capacity, struct SNAME##_ftab_val *f_val, \ + struct cmc_alloc_node *alloc, struct cmc_callbacks_list *callbacks) \ { \ if (capacity < 1) \ return NULL; \ \ + if (!f_val) \ + return NULL; \ + \ if (!alloc) \ alloc = &cmc_alloc_node_default; \ \ @@ -320,22 +350,22 @@ struct cmc_callbacks_list \ _list_->capacity = capacity; \ _list_->count = 0; \ - \ - _list_->it_start = PFX##_impl_it_start; \ - _list_->it_end = PFX##_impl_it_end; \ - \ + _list_->flag = cmc_flags.OK; \ + _list_->f_val = f_val; \ _list_->alloc = alloc; \ _list_->callbacks = callbacks; \ + _list_->it_start = PFX##_impl_it_start; \ + _list_->it_end = PFX##_impl_it_end; \ \ return _list_; \ } \ \ - void PFX##_clear(struct SNAME *_list_, void (*deallocator)(V)) \ + void PFX##_clear(struct SNAME *_list_) \ { \ - if (deallocator) \ + if (_list_->f_val->free) \ { \ for (size_t i = 0; i < _list_->count; i++) \ - deallocator(_list_->buffer[i]); \ + _list_->f_val->free(_list_->buffer[i]); \ } \ \ memset(_list_->buffer, 0, sizeof(V) * _list_->capacity); \ @@ -343,12 +373,12 @@ struct cmc_callbacks_list _list_->count = 0; \ } \ \ - void PFX##_free(struct SNAME *_list_, void (*deallocator)(V)) \ + void PFX##_free(struct SNAME *_list_) \ { \ - if (deallocator) \ + if (_list_->f_val->free) \ { \ for (size_t i = 0; i < _list_->count; i++) \ - deallocator(_list_->buffer[i]); \ + _list_->f_val->free(_list_->buffer[i]); \ } \ \ _list_->alloc->free(_list_->buffer); \ @@ -549,7 +579,7 @@ struct cmc_callbacks_list \ size_t length = to - from + 1; \ \ - struct SNAME *result = PFX##_new(length); \ + struct SNAME *result = PFX##_new(length, _list_->f_val); \ \ if (!result) \ return NULL; \ @@ -603,14 +633,13 @@ struct cmc_callbacks_list return _list_->buffer[_list_->count - 1]; \ } \ \ - size_t PFX##_indexof(struct SNAME *_list_, V element, \ - int (*comparator)(V, V), bool from_start) \ + size_t PFX##_indexof(struct SNAME *_list_, V element, bool from_start) \ { \ if (from_start) \ { \ for (size_t i = 0; i < _list_->count; i++) \ { \ - if (comparator(_list_->buffer[i], element) == 0) \ + if (_list_->f_val->cmp(_list_->buffer[i], element) == 0) \ return i; \ } \ } \ @@ -618,7 +647,7 @@ struct cmc_callbacks_list { \ for (size_t i = _list_->count; i > 0; i--) \ { \ - if (comparator(_list_->buffer[i - 1], element) == 0) \ + if (_list_->f_val->cmp(_list_->buffer[i - 1], element) == 0) \ return i - 1; \ } \ } \ @@ -626,12 +655,11 @@ struct cmc_callbacks_list return _list_->count; \ } \ \ - bool PFX##_contains(struct SNAME *_list_, V element, \ - int (*comparator)(V, V)) \ + bool PFX##_contains(struct SNAME *_list_, V element) \ { \ for (size_t i = 0; i < _list_->count; i++) \ { \ - if (comparator(_list_->buffer[i], element) == 0) \ + if (_list_->f_val->cmp(_list_->buffer[i], element) == 0) \ return true; \ } \ \ @@ -677,24 +705,27 @@ struct cmc_callbacks_list if (!new_buffer) \ return false; \ \ + /* TODO zero out new slots */ \ + \ _list_->buffer = new_buffer; \ _list_->capacity = capacity; \ \ return true; \ } \ \ - struct SNAME *PFX##_copy_of(struct SNAME *_list_, V (*copy_func)(V)) \ + struct SNAME *PFX##_copy_of(struct SNAME *_list_) \ { \ - struct SNAME *result = PFX##_new_custom( \ - _list_->capacity, _list_->alloc, _list_->callbacks); \ + struct SNAME *result = \ + PFX##_new_custom(_list_->capacity, _list_->f_val, _list_->alloc, \ + _list_->callbacks); \ \ if (!result) \ return NULL; \ \ - if (copy_func) \ + if (_list_->f_val->cpy) \ { \ for (size_t i = 0; i < _list_->count; i++) \ - result->buffer[i] = copy_func(_list_->buffer[i]); \ + result->buffer[i] = _list_->f_val->cpy(_list_->buffer[i]); \ } \ else \ memcpy(result->buffer, _list_->buffer, sizeof(V) * _list_->count); \ @@ -704,15 +735,15 @@ struct cmc_callbacks_list return result; \ } \ \ - bool PFX##_equals(struct SNAME *_list1_, struct SNAME *_list2_, \ - int (*comparator)(V, V)) \ + bool PFX##_equals(struct SNAME *_list1_, struct SNAME *_list2_) \ { \ if (PFX##_count(_list1_) != PFX##_count(_list2_)) \ return false; \ \ for (size_t i = 0; i < PFX##_count(_list1_); i++) \ { \ - if (comparator(_list1_->buffer[i], _list2_->buffer[i]) != 0) \ + if (_list1_->f_val->cmp(_list1_->buffer[i], _list2_->buffer[i]) != \ + 0) \ return false; \ } \ \ @@ -726,14 +757,9 @@ struct cmc_callbacks_list \ int n = snprintf(str.s, cmc_string_len, cmc_string_fmt_list, #SNAME, \ #V, l_, l_->buffer, l_->capacity, l_->count, \ - l_->alloc, l_->callbacks); \ + l_->flag, l_->f_val, l_->alloc, l_->callbacks); \ \ - if (n < 0 || n == (int)cmc_string_len) \ - return (struct cmc_string){ 0 }; \ - \ - str.s[n] = '\0'; \ - \ - return str; \ + return n >= 0 ? str : (struct cmc_string){ 0 }; \ } \ \ struct SNAME##_iter *PFX##_iter_new(struct SNAME *target) \ diff --git a/tests/main/unt/linkedlist.c b/tests/main/unt/linkedlist.c index b13ec31..6abedc2 100644 --- a/tests/main/unt/linkedlist.c +++ b/tests/main/unt/linkedlist.c @@ -7,20 +7,28 @@ CMC_GENERATE_LINKEDLIST(ll, linkedlist, size_t) +struct linkedlist_ftab_val *ll_ftab_val = + &(struct linkedlist_ftab_val){ .cmp = cmp, + .cpy = copy, + .str = str, + .free = custom_free, + .hash = hash, + .pri = pri }; + CMC_CREATE_UNIT(linkedlist_test, true, { CMC_CREATE_TEST(new, { - struct linkedlist *ll = ll_new(); + struct linkedlist *ll = ll_new(ll_ftab_val); cmc_assert_not_equals(ptr, NULL, ll); cmc_assert_equals(size_t, 0, ll_count(ll)); cmc_assert_equals(ptr, NULL, ll->head); cmc_assert_equals(ptr, NULL, ll->tail); - ll_free(ll, NULL); + ll_free(ll); }); CMC_CREATE_TEST(clear[count capacity], { - struct linkedlist *ll = ll_new(); + struct linkedlist *ll = ll_new(ll_ftab_val); cmc_assert_not_equals(ptr, NULL, ll); @@ -29,27 +37,27 @@ CMC_CREATE_UNIT(linkedlist_test, true, { cmc_assert_equals(size_t, 50, ll_count(ll)); - ll_clear(ll, NULL); + ll_clear(ll); cmc_assert_equals(size_t, 0, ll_count(ll)); - ll_free(ll, NULL); + ll_free(ll); }); CMC_CREATE_TEST(clear[count = 0], { - struct linkedlist *ll = ll_new(); + struct linkedlist *ll = ll_new(ll_ftab_val); cmc_assert_not_equals(ptr, NULL, ll); - ll_clear(ll, NULL); + ll_clear(ll); cmc_assert_equals(size_t, 0, ll_count(ll)); - ll_free(ll, NULL); + ll_free(ll); }); CMC_CREATE_TEST(push_front[count], { - struct linkedlist *ll = ll_new(); + struct linkedlist *ll = ll_new(ll_ftab_val); cmc_assert_not_equals(ptr, NULL, ll); @@ -59,11 +67,11 @@ CMC_CREATE_UNIT(linkedlist_test, true, { cmc_assert_not_equals(ptr, NULL, ll->tail); cmc_assert_equals(size_t, 1, ll_count(ll)); - ll_free(ll, NULL); + ll_free(ll); }); CMC_CREATE_TEST(push_front[item preservation], { - struct linkedlist *ll = ll_new(); + struct linkedlist *ll = ll_new(ll_ftab_val); cmc_assert_not_equals(ptr, NULL, ll); @@ -73,6 +81,6 @@ CMC_CREATE_UNIT(linkedlist_test, true, { for (size_t i = 0; i < ll_count(ll); i++) cmc_assert_equals(size_t, ll_get(ll, i), ll_count(ll) - i - 1); - ll_free(ll, NULL); + ll_free(ll); }); }); diff --git a/tests/main/unt/list.c b/tests/main/unt/list.c index 6611381..d08eda2 100644 --- a/tests/main/unt/list.c +++ b/tests/main/unt/list.c @@ -7,32 +7,39 @@ CMC_GENERATE_LIST(l, list, size_t) +struct list_ftab_val *l_ftab_val = &(struct list_ftab_val){ .cmp = cmp, + .cpy = copy, + .str = str, + .free = custom_free, + .hash = hash, + .pri = pri }; + CMC_CREATE_UNIT(list_test, true, { CMC_CREATE_TEST(new, { - struct list *l = l_new(1000000); + struct list *l = l_new(1000000, l_ftab_val); cmc_assert_not_equals(ptr, NULL, l); cmc_assert_not_equals(ptr, NULL, l->buffer); cmc_assert_equals(size_t, 1000000, l_capacity(l)); cmc_assert_equals(size_t, 0, l_count(l)); - l_free(l, NULL); + l_free(l); }); CMC_CREATE_TEST(new[capacity = 0], { - struct list *l = l_new(0); + struct list *l = l_new(0, l_ftab_val); cmc_assert_equals(ptr, NULL, l); }); CMC_CREATE_TEST(new[capacity = UINT64_MAX], { - struct list *l = l_new(UINT64_MAX); + struct list *l = l_new(UINT64_MAX, l_ftab_val); cmc_assert_equals(ptr, NULL, l); }); CMC_CREATE_TEST(clear[count capacity], { - struct list *l = l_new(100); + struct list *l = l_new(100, l_ftab_val); cmc_assert_not_equals(ptr, NULL, l); @@ -41,16 +48,16 @@ CMC_CREATE_UNIT(list_test, true, { cmc_assert_equals(size_t, 50, l_count(l)); - l_clear(l, NULL); + l_clear(l); cmc_assert_equals(size_t, 0, l_count(l)); cmc_assert_equals(size_t, 100, l_capacity(l)); - l_free(l, NULL); + l_free(l); }); CMC_CREATE_TEST(buffer_growth[capacity = 1], { - struct list *l = l_new(1); + struct list *l = l_new(1, l_ftab_val); cmc_assert_not_equals(ptr, NULL, l); @@ -62,11 +69,11 @@ CMC_CREATE_UNIT(list_test, true, { for (size_t i = 0; i < 100; i++) cmc_assert_equals(size_t, i, l_get(l, i)); - l_free(l, NULL); + l_free(l); }); CMC_CREATE_TEST(push_front[count], { - struct list *l = l_new(100); + struct list *l = l_new(100, l_ftab_val); cmc_assert_not_equals(ptr, NULL, l); @@ -75,11 +82,11 @@ CMC_CREATE_UNIT(list_test, true, { cmc_assert_equals(size_t, 250, l_count(l)); - l_free(l, NULL); + l_free(l); }); CMC_CREATE_TEST(push_front[capacity], { - struct list *l = l_new(100); + struct list *l = l_new(100, l_ftab_val); cmc_assert_not_equals(ptr, NULL, l); @@ -88,11 +95,11 @@ CMC_CREATE_UNIT(list_test, true, { cmc_assert_lesser_equals(size_t, l_capacity(l), l_count(l)); - l_free(l, NULL); + l_free(l); }); CMC_CREATE_TEST(push_front[item preservation], { - struct list *l = l_new(100); + struct list *l = l_new(100, l_ftab_val); cmc_assert_not_equals(ptr, NULL, l); @@ -102,11 +109,11 @@ CMC_CREATE_UNIT(list_test, true, { for (size_t i = 0; i < l_count(l); i++) cmc_assert_equals(size_t, l_get(l, i), l_count(l) - i - 1); - l_free(l, NULL); + l_free(l); }); CMC_CREATE_TEST(push_at[count], { - struct list *l = l_new(100); + struct list *l = l_new(100, l_ftab_val); cmc_assert_not_equals(ptr, NULL, l); @@ -118,11 +125,11 @@ CMC_CREATE_UNIT(list_test, true, { cmc_assert_equals(size_t, 250, l_count(l)); - l_free(l, NULL); + l_free(l); }); CMC_CREATE_TEST(push_at[capacity], { - struct list *l = l_new(100); + struct list *l = l_new(100, l_ftab_val); cmc_assert_not_equals(ptr, NULL, l); @@ -134,11 +141,11 @@ CMC_CREATE_UNIT(list_test, true, { cmc_assert_lesser_equals(size_t, l_capacity(l), l_count(l)); - l_free(l, NULL); + l_free(l); }); CMC_CREATE_TEST(push_at[item preservation], { - struct list *l = l_new(100); + struct list *l = l_new(100, l_ftab_val); cmc_assert_not_equals(ptr, NULL, l); @@ -151,11 +158,11 @@ CMC_CREATE_UNIT(list_test, true, { for (size_t i = 0; i < l_count(l); i++) cmc_assert_equals(size_t, l_get(l, i), i); - l_free(l, NULL); + l_free(l); }); CMC_CREATE_TEST(push_back[count], { - struct list *l = l_new(100); + struct list *l = l_new(100, l_ftab_val); cmc_assert_not_equals(ptr, NULL, l); @@ -164,11 +171,11 @@ CMC_CREATE_UNIT(list_test, true, { cmc_assert_equals(size_t, 250, l_count(l)); - l_free(l, NULL); + l_free(l); }); CMC_CREATE_TEST(push_back[capacity], { - struct list *l = l_new(100); + struct list *l = l_new(100, l_ftab_val); cmc_assert_not_equals(ptr, NULL, l); @@ -177,11 +184,11 @@ CMC_CREATE_UNIT(list_test, true, { cmc_assert_lesser_equals(size_t, l_capacity(l), l_count(l)); - l_free(l, NULL); + l_free(l); }); CMC_CREATE_TEST(push_back[item preservation], { - struct list *l = l_new(100); + struct list *l = l_new(100, l_ftab_val); cmc_assert_not_equals(ptr, NULL, l); @@ -191,11 +198,11 @@ CMC_CREATE_UNIT(list_test, true, { for (size_t i = 0; i < l_count(l); i++) cmc_assert_equals(size_t, l_get(l, i), i); - l_free(l, NULL); + l_free(l); }); CMC_CREATE_TEST(pop_front[count], { - struct list *l = l_new(100); + struct list *l = l_new(100, l_ftab_val); cmc_assert_not_equals(ptr, NULL, l); @@ -204,11 +211,11 @@ CMC_CREATE_UNIT(list_test, true, { cmc_assert(l_pop_front(l)); - l_free(l, NULL); + l_free(l); }); CMC_CREATE_TEST(pop_front[item preservation], { - struct list *l = l_new(100); + struct list *l = l_new(100, l_ftab_val); cmc_assert_not_equals(ptr, NULL, l); @@ -220,30 +227,30 @@ CMC_CREATE_UNIT(list_test, true, { for (size_t i = 0; i < l_count(l); i++) cmc_assert_equals(size_t, l_get(l, i), i + 1); - l_free(l, NULL); + l_free(l); }); CMC_CREATE_TEST(pop_front[count = 0], { - struct list *l = l_new(100); + struct list *l = l_new(100, l_ftab_val); cmc_assert_not_equals(ptr, NULL, l); cmc_assert(!l_pop_front(l)); - l_free(l, NULL); + l_free(l); }); CMC_CREATE_TEST(pop_front[count = 1], { - struct list *l = l_new(100); + struct list *l = l_new(100, l_ftab_val); cmc_assert_not_equals(ptr, NULL, l); cmc_assert(l_push_back(l, 10)); cmc_assert(l_pop_front(l)); - l_free(l, NULL); + l_free(l); }); CMC_CREATE_TEST(pop_front[buffer_clear], { - struct list *l = l_new(100); + struct list *l = l_new(100, l_ftab_val); cmc_assert_not_equals(ptr, NULL, l); cmc_assert(l_push_back(l, 1)); @@ -253,20 +260,20 @@ CMC_CREATE_UNIT(list_test, true, { cmc_assert_equals(size_t, 0, l->buffer[1]); - l_free(l, NULL); + l_free(l); }); CMC_CREATE_TEST(pop_at[count = 0], { - struct list *l = l_new(100); + struct list *l = l_new(100, l_ftab_val); cmc_assert_not_equals(ptr, NULL, l); cmc_assert(!l_pop_at(l, 1)); - l_free(l, NULL); + l_free(l); }); CMC_CREATE_TEST(pop_at[count = 1], { - struct list *l = l_new(100); + struct list *l = l_new(100, l_ftab_val); cmc_assert_not_equals(ptr, NULL, l); cmc_assert(l_push_back(l, 1)); @@ -274,11 +281,11 @@ CMC_CREATE_UNIT(list_test, true, { cmc_assert_equals(size_t, 0, l->buffer[0]); - l_free(l, NULL); + l_free(l); }); CMC_CREATE_TEST(pop_at[buffer_clear], { - struct list *l = l_new(100); + struct list *l = l_new(100, l_ftab_val); cmc_assert_not_equals(ptr, NULL, l); cmc_assert(l_push_back(l, 1)); @@ -286,25 +293,25 @@ CMC_CREATE_UNIT(list_test, true, { cmc_assert(l_push_back(l, 3)); cmc_assert(l_pop_at(l, 1)); - l_free(l, NULL); + l_free(l); }); CMC_CREATE_TEST(pop_back[count = 0], { - struct list *l = l_new(100); + struct list *l = l_new(100, l_ftab_val); cmc_assert_not_equals(ptr, NULL, l); cmc_assert(!l_pop_back(l)); - l_free(l, NULL); + l_free(l); }); CMC_CREATE_TEST(pop_back[count = 1], { - struct list *l = l_new(100); + struct list *l = l_new(100, l_ftab_val); cmc_assert_not_equals(ptr, NULL, l); cmc_assert(l_push_back(l, 10)); cmc_assert(l_pop_back(l)); - l_free(l, NULL); + l_free(l); }); })