diff --git a/src/cmc/heap.h b/src/cmc/heap.h index dd899f1..596c1f4 100644 --- a/src/cmc/heap.h +++ b/src/cmc/heap.h @@ -168,7 +168,7 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " struct cmc_callbacks *callbacks); \ /* Collection Input and Output */ \ bool PFX##_insert(struct SNAME *_heap_, V element); \ - bool PFX##_remove(struct SNAME *_heap_, V *result); \ + bool PFX##_remove(struct SNAME *_heap_); \ /* Element Access */ \ V PFX##_peek(struct SNAME *_heap_); \ /* Collection State */ \ @@ -212,8 +212,8 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " #define CMC_GENERATE_HEAP_SOURCE(PFX, SNAME, V) \ \ /* Implementation Detail Functions */ \ - static bool PFX##_impl_float_up(struct SNAME *_heap_, size_t index); \ - static bool PFX##_impl_float_down(struct SNAME *_heap_, size_t index); \ + static void PFX##_impl_float_up(struct SNAME *_heap_, size_t index); \ + static void PFX##_impl_float_down(struct SNAME *_heap_, size_t index); \ static struct SNAME##_iter PFX##_impl_it_start(struct SNAME *_heap_); \ static struct SNAME##_iter PFX##_impl_it_end(struct SNAME *_heap_); \ \ @@ -350,29 +350,22 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " return false; \ } \ \ - if (PFX##_empty(_heap_)) \ - { \ - _heap_->buffer[_heap_->count++] = element; \ - \ - _heap_->flag = cmc_flags.OK; \ - \ - return true; \ - } \ - \ _heap_->buffer[_heap_->count++] = element; \ \ - if (!PFX##_impl_float_up(_heap_, _heap_->count - 1)) \ + if (!PFX##_empty(_heap_)) \ { \ - _heap_->flag = cmc_flags.ERROR; \ - return false; \ + PFX##_impl_float_up(_heap_, _heap_->count - 1); \ } \ \ _heap_->flag = cmc_flags.OK; \ \ + if (_heap_->callbacks && _heap_->callbacks->create) \ + _heap_->callbacks->create(); \ + \ return true; \ } \ \ - bool PFX##_remove(struct SNAME *_heap_, V *result) \ + bool PFX##_remove(struct SNAME *_heap_) \ { \ if (PFX##_empty(_heap_)) \ { \ @@ -380,22 +373,18 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " return false; \ } \ \ - if (result) \ - *result = _heap_->buffer[0]; \ - \ _heap_->buffer[0] = _heap_->buffer[_heap_->count - 1]; \ _heap_->buffer[_heap_->count - 1] = (V){ 0 }; \ \ _heap_->count--; \ \ - if (!PFX##_impl_float_down(_heap_, 0)) \ - { \ - _heap_->flag = cmc_flags.ERROR; \ - return false; \ - } \ + PFX##_impl_float_down(_heap_, 0); \ \ _heap_->flag = cmc_flags.OK; \ \ + if (_heap_->callbacks && _heap_->callbacks->delete) \ + _heap_->callbacks->delete (); \ + \ return true; \ } \ \ @@ -409,6 +398,9 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " \ _heap_->flag = cmc_flags.OK; \ \ + if (_heap_->callbacks && _heap_->callbacks->read) \ + _heap_->callbacks->read(); \ + \ return _heap_->buffer[0]; \ } \ \ @@ -416,13 +408,21 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " { \ _heap_->flag = cmc_flags.OK; \ \ + bool result = false; \ + \ for (size_t i = 0; i < _heap_->count; i++) \ { \ if (_heap_->f_val->cmp(_heap_->buffer[i], element) == 0) \ - return true; \ + { \ + result = true; \ + break; \ + } \ } \ \ - return false; \ + if (_heap_->callbacks && _heap_->callbacks->read) \ + _heap_->callbacks->read(); \ + \ + return result; \ } \ \ bool PFX##_empty(struct SNAME *_heap_) \ @@ -455,7 +455,7 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " _heap_->flag = cmc_flags.OK; \ \ if (_heap_->capacity == capacity) \ - return true; \ + goto success; \ \ if (capacity < _heap_->count) \ { \ @@ -477,6 +477,11 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " _heap_->buffer = new_buffer; \ _heap_->capacity = capacity; \ \ + success: \ + \ + if (_heap_->callbacks && _heap_->callbacks->resize) \ + _heap_->callbacks->resize(); \ + \ return true; \ } \ \ @@ -716,7 +721,7 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " return iter->cursor; \ } \ \ - static bool PFX##_impl_float_up(struct SNAME *_heap_, size_t index) \ + static void PFX##_impl_float_up(struct SNAME *_heap_, size_t index) \ { \ /* Current index */ \ size_t C = index; \ @@ -738,11 +743,9 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " child = _heap_->buffer[C]; \ parent = _heap_->buffer[(C - 1) / 2]; \ } \ - \ - return true; \ } \ \ - static bool PFX##_impl_float_down(struct SNAME *_heap_, size_t index) \ + static void PFX##_impl_float_down(struct SNAME *_heap_, size_t index) \ { \ int mod = _heap_->HO; \ \ @@ -781,8 +784,6 @@ static const char *cmc_string_fmt_heap = "struct %s<%s> " else \ break; \ } \ - \ - return true; \ } \ \ static struct SNAME##_iter PFX##_impl_it_start(struct SNAME *_heap_) \ diff --git a/src/cmc/intervalheap.h b/src/cmc/intervalheap.h index 07d7f57..0fbadb5 100644 --- a/src/cmc/intervalheap.h +++ b/src/cmc/intervalheap.h @@ -155,8 +155,8 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " bool PFX##_update_max(struct SNAME *_heap_, V element); \ bool PFX##_update_min(struct SNAME *_heap_, V element); \ /* Element Access */ \ - bool PFX##_max(struct SNAME *_heap_, V *value); \ - bool PFX##_min(struct SNAME *_heap_, V *value); \ + V PFX##_max(struct SNAME *_heap_); \ + V PFX##_min(struct SNAME *_heap_); \ /* Collection State */ \ bool PFX##_contains(struct SNAME *_heap_, V element); \ bool PFX##_empty(struct SNAME *_heap_); \ @@ -250,7 +250,7 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " size_t capacity, struct SNAME##_ftab_val *f_val, \ struct cmc_alloc_node *alloc, struct cmc_callbacks *callbacks) \ { \ - if (capacity == 0 || capacity == UINT64_MAX) \ + if (capacity == 0 || capacity == UINTMAX_MAX) \ return NULL; \ \ if (!f_val) \ @@ -371,18 +371,22 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " _heap_->count++; \ _heap_->flag = cmc_flags.OK; \ \ - if (_heap_->count <= 2) \ - return true; \ + if (_heap_->count > 2) \ + { \ + /* Determine wheather to do a MaxHeap insert or a MinHeap insert \ + */ \ + struct SNAME##_node *parent = \ + &(_heap_->buffer[(_heap_->size - 1) / 2]); \ \ - /* Determine wheather to do a MaxHeap insert or a MinHeap insert */ \ - struct SNAME##_node *parent = \ - &(_heap_->buffer[(_heap_->size - 1) / 2]); \ + if (_heap_->f_val->cmp(parent->data[0], element) > 0) \ + PFX##_impl_float_up_min(_heap_); \ + else if (_heap_->f_val->cmp(parent->data[1], element) < 0) \ + PFX##_impl_float_up_max(_heap_); \ + /* else no float up required */ \ + } \ \ - if (_heap_->f_val->cmp(parent->data[0], element) > 0) \ - PFX##_impl_float_up_min(_heap_); \ - else if (_heap_->f_val->cmp(parent->data[1], element) < 0) \ - PFX##_impl_float_up_max(_heap_); \ - /* else no float up required */ \ + if (_heap_->callbacks && _heap_->callbacks->create) \ + _heap_->callbacks->create(); \ \ return true; \ } \ @@ -402,9 +406,7 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " _heap_->count--; \ _heap_->size--; \ \ - _heap_->flag = cmc_flags.OK; \ - \ - return true; \ + goto success; \ } \ \ /* Swap the result with the last element in the MaxHeap and float */ \ @@ -428,11 +430,17 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " } \ \ _heap_->count--; \ - _heap_->flag = cmc_flags.OK; \ \ /* FLoat Down on the MaxHeap */ \ PFX##_impl_float_down_max(_heap_); \ \ + success: \ + \ + _heap_->flag = cmc_flags.OK; \ + \ + if (_heap_->callbacks && _heap_->callbacks->delete) \ + _heap_->callbacks->delete (); \ + \ return true; \ } \ \ @@ -451,9 +459,7 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " _heap_->count--; \ _heap_->size--; \ \ - _heap_->flag = cmc_flags.OK; \ - \ - return true; \ + goto success; \ } \ \ /* Swap the result with the last element in the MinHeap and float */ \ @@ -477,11 +483,17 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " } \ \ _heap_->count--; \ - _heap_->flag = cmc_flags.OK; \ \ /* FLoat Down on the MinHeap */ \ PFX##_impl_float_down_min(_heap_); \ \ + success: \ + \ + _heap_->flag = cmc_flags.OK; \ + \ + if (_heap_->callbacks && _heap_->callbacks->delete) \ + _heap_->callbacks->delete (); \ + \ return true; \ } \ \ @@ -516,6 +528,9 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " \ _heap_->flag = cmc_flags.OK; \ \ + if (_heap_->callbacks && _heap_->callbacks->update) \ + _heap_->callbacks->update(); \ + \ return true; \ } \ \ @@ -550,56 +565,69 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " \ _heap_->flag = cmc_flags.OK; \ \ + if (_heap_->callbacks && _heap_->callbacks->update) \ + _heap_->callbacks->update(); \ + \ return true; \ } \ \ - bool PFX##_max(struct SNAME *_heap_, V *value) \ + V PFX##_max(struct SNAME *_heap_) \ { \ if (PFX##_empty(_heap_)) \ { \ _heap_->flag = cmc_flags.EMPTY; \ - return false; \ + return (V){ 0 }; \ } \ \ + _heap_->flag = cmc_flags.OK; \ + \ + if (_heap_->callbacks && _heap_->callbacks->read) \ + _heap_->callbacks->read(); \ + \ /* If there is only one element, then the maximum element is the */ \ /* same as the one in the MinHeap */ \ if (_heap_->count == 1) \ - *value = _heap_->buffer[0].data[0]; \ - else \ - *value = _heap_->buffer[0].data[1]; \ + return _heap_->buffer[0].data[0]; \ \ - _heap_->flag = cmc_flags.OK; \ - \ - return true; \ + return _heap_->buffer[0].data[1]; \ } \ \ - bool PFX##_min(struct SNAME *_heap_, V *value) \ + V PFX##_min(struct SNAME *_heap_) \ { \ if (PFX##_empty(_heap_)) \ { \ _heap_->flag = cmc_flags.EMPTY; \ - return false; \ + return (V){ 0 }; \ } \ \ - *value = _heap_->buffer[0].data[0]; \ - \ _heap_->flag = cmc_flags.OK; \ \ - return true; \ + if (_heap_->callbacks && _heap_->callbacks->read) \ + _heap_->callbacks->read(); \ + \ + return _heap_->buffer[0].data[0]; \ } \ \ bool PFX##_contains(struct SNAME *_heap_, V element) \ { \ _heap_->flag = cmc_flags.OK; \ \ + bool result = false; \ + \ for (size_t i = 0; i < _heap_->count; i++) \ { \ if (_heap_->f_val->cmp(_heap_->buffer[i / 2].data[i % 2], \ element) == 0) \ - return true; \ + { \ + result = true; \ + break; \ + } \ } \ \ - return false; \ + if (_heap_->callbacks && _heap_->callbacks->read) \ + _heap_->callbacks->read(); \ + \ + return result; \ } \ \ bool PFX##_empty(struct SNAME *_heap_) \ @@ -630,10 +658,8 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " \ bool PFX##_resize(struct SNAME *_heap_, size_t capacity) \ { \ - _heap_->flag = cmc_flags.OK; \ - \ if (_heap_->capacity == capacity) \ - return true; \ + goto success; \ \ if (capacity < _heap_->count) \ { \ @@ -659,12 +685,23 @@ static const char *cmc_string_fmt_intervalheap = "struct %s<%s> " return false; \ } \ \ - memset(new_buffer + _heap_->capacity, 0, \ - sizeof(struct SNAME##_node) * _heap_->capacity); \ + if (capacity > _heap_->capacity) \ + { \ + memset(new_buffer + _heap_->capacity, 0, \ + sizeof(struct SNAME##_node) * \ + (capacity - _heap_->capacity)); \ + } \ \ _heap_->buffer = new_buffer; \ _heap_->capacity = capacity; \ \ + success: \ + \ + _heap_->flag = cmc_flags.OK; \ + \ + if (_heap_->callbacks && _heap_->callbacks->resize) \ + _heap_->callbacks->resize(); \ + \ return true; \ } \ \ diff --git a/src/cmc/sortedlist.h b/src/cmc/sortedlist.h index ca72acf..fa293d2 100644 --- a/src/cmc/sortedlist.h +++ b/src/cmc/sortedlist.h @@ -144,8 +144,8 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " bool PFX##_insert(struct SNAME *_list_, V element); \ bool PFX##_remove(struct SNAME *_list_, size_t index); \ /* Element Access */ \ - bool PFX##_max(struct SNAME *_list_, V *result); \ - bool PFX##_min(struct SNAME *_list_, V *result); \ + V PFX##_max(struct SNAME *_list_); \ + V PFX##_min(struct SNAME *_list_); \ V PFX##_get(struct SNAME *_list_, size_t index); \ size_t PFX##_index_of(struct SNAME *_list_, V element, bool from_start); \ /* Collection State */ \ @@ -351,40 +351,34 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " return true; \ } \ \ - bool PFX##_max(struct SNAME *_list_, V *result) \ + V PFX##_max(struct SNAME *_list_) \ { \ if (PFX##_empty(_list_)) \ { \ _list_->flag = cmc_flags.EMPTY; \ - return false; \ + return (V){ 0 }; \ } \ \ PFX##_sort(_list_); \ \ - if (result) \ - *result = _list_->buffer[_list_->count - 1]; \ - \ _list_->flag = cmc_flags.OK; \ \ - return true; \ + return _list_->buffer[_list_->count - 1]; \ } \ \ - bool PFX##_min(struct SNAME *_list_, V *result) \ + V PFX##_min(struct SNAME *_list_) \ { \ if (PFX##_empty(_list_)) \ { \ _list_->flag = cmc_flags.EMPTY; \ - return false; \ + return (V){ 0 }; \ } \ \ PFX##_sort(_list_); \ \ - if (result) \ - *result = _list_->buffer[0]; \ - \ _list_->flag = cmc_flags.OK; \ \ - return true; \ + return _list_->buffer[0]; \ } \ \ V PFX##_get(struct SNAME *_list_, size_t index) \ diff --git a/tests/main/unt/bidimap.c b/tests/main/unt/bidimap.c index 24bff78..7208c29 100644 --- a/tests/main/unt/bidimap.c +++ b/tests/main/unt/bidimap.c @@ -512,7 +512,8 @@ CMC_CREATE_UNIT(bidimap_test, true, { }); CMC_CREATE_TEST(callbacks, { - struct bidimap *map = bm_new_custom(100, 0.7, bm_ftab_key, bm_ftab_val, NULL, callbacks); + struct bidimap *map = + bm_new_custom(100, 0.7, bm_ftab_key, bm_ftab_val, NULL, callbacks); cmc_assert_not_equals(ptr, NULL, map); cmc_assert_equals(ptr, callbacks, map->callbacks); diff --git a/tests/main/unt/deque.c b/tests/main/unt/deque.c index 113da24..02ae64d 100644 --- a/tests/main/unt/deque.c +++ b/tests/main/unt/deque.c @@ -660,8 +660,7 @@ CMC_CREATE_UNIT(deque_test, true, { // customize d->flag = cmc_flags.ERROR; - d_customize(d, &cmc_alloc_node_default, - &(struct cmc_callbacks){ 0 }); + d_customize(d, &cmc_alloc_node_default, &(struct cmc_callbacks){ 0 }); cmc_assert_equals(int32_t, cmc_flags.OK, d_flag(d)); // push_front diff --git a/tests/main/unt/hashmap.c b/tests/main/unt/hashmap.c index d9ad5fb..7d15efd 100644 --- a/tests/main/unt/hashmap.c +++ b/tests/main/unt/hashmap.c @@ -604,7 +604,8 @@ CMC_CREATE_UNIT(hashmap_test, true, { }); CMC_CREATE_TEST(callbacks, { - struct hashmap *map = hm_new_custom(100, 0.6, hm_ftab_key, hm_ftab_val, NULL, callbacks); + struct hashmap *map = + hm_new_custom(100, 0.6, hm_ftab_key, hm_ftab_val, NULL, callbacks); total_create = 0; total_read = 0; diff --git a/tests/main/unt/hashset.c b/tests/main/unt/hashset.c index 4d512e0..67c88c2 100644 --- a/tests/main/unt/hashset.c +++ b/tests/main/unt/hashset.c @@ -458,7 +458,7 @@ CMC_CREATE_UNIT(hashset_test, true, { cmc_assert_equals(int32_t, cmc_flags.OK, hs_flag(set)); // copy - set->flag = cmc_flags.ERROR;\ + set->flag = cmc_flags.ERROR; struct hashset *set2 = hs_copy_of(set); cmc_assert_equals(int32_t, cmc_flags.OK, hs_flag(set)); @@ -483,7 +483,8 @@ CMC_CREATE_UNIT(hashset_test, true, { }); CMC_CREATE_TEST(callbacks, { - struct hashset *set = hs_new_custom(100, 0.6, hs_ftab_val, NULL, callbacks); + struct hashset *set = + hs_new_custom(100, 0.6, hs_ftab_val, NULL, callbacks); total_create = 0; total_read = 0; diff --git a/tests/main/unt/heap.c b/tests/main/unt/heap.c index a0371d1..97a5f19 100644 --- a/tests/main/unt/heap.c +++ b/tests/main/unt/heap.c @@ -104,10 +104,9 @@ CMC_CREATE_UNIT(heap_test, true, { for (size_t i = 0; i <= 100; i++) cmc_assert(h_insert(h, i)); - size_t r; - cmc_assert(h_remove(h, &r)); - - cmc_assert_equals(size_t, 100, r); + cmc_assert_equals(size_t, 100, h_peek(h)); + cmc_assert(h_remove(h)); + cmc_assert_equals(size_t, 99, h_peek(h)); h_free(h); }); @@ -117,8 +116,7 @@ CMC_CREATE_UNIT(heap_test, true, { cmc_assert_not_equals(ptr, NULL, h); - size_t _; - cmc_assert(!h_remove(h, &_)); + cmc_assert(!h_remove(h)); h_free(h); }); @@ -136,9 +134,8 @@ CMC_CREATE_UNIT(heap_test, true, { size_t arr[100]; while (!h_empty(h)) { - cmc_assert(h_remove(h, &r)); - - arr[i++] = r; + arr[i++] = h_peek(h); + cmc_assert(h_remove(h)); } cmc_assert_array_sorted_any(size_t, arr, cmp, 0, 99); @@ -184,17 +181,17 @@ CMC_CREATE_UNIT(heap_test, true, { h->flag = cmc_flags.ERROR; // remove - cmc_assert(h_remove(h, NULL)); + cmc_assert(h_remove(h)); cmc_assert_equals(int32_t, cmc_flags.OK, h_flag(h)); - cmc_assert(!h_remove(h, NULL)); + cmc_assert(!h_remove(h)); cmc_assert_equals(int32_t, cmc_flags.EMPTY, h_flag(h)); // peek cmc_assert(h_insert(h, 10)); h_peek(h); cmc_assert_equals(int32_t, cmc_flags.OK, h_flag(h)); - cmc_assert(h_remove(h, NULL)); + cmc_assert(h_remove(h)); h_peek(h); cmc_assert_equals(int32_t, cmc_flags.EMPTY, h_flag(h)); @@ -226,4 +223,38 @@ CMC_CREATE_UNIT(heap_test, true, { h_free(h); h_free(h2); }); + + CMC_CREATE_TEST(callbacks, { + struct heap *h = + h_new_custom(100, cmc_max_heap, h_ftab_val, NULL, callbacks); + + total_create = 0; + total_read = 0; + total_update = 0; + total_delete = 0; + total_resize = 0; + + cmc_assert(h_insert(h, 10)); + cmc_assert_equals(int32_t, 1, total_create); + + cmc_assert(h_remove(h)); + cmc_assert_equals(int32_t, 1, total_delete); + + cmc_assert(h_insert(h, 10)); + cmc_assert_equals(int32_t, 2, total_create); + + cmc_assert_equals(size_t, 10, h_peek(h)); + cmc_assert_equals(int32_t, 1, total_read); + + cmc_assert(h_contains(h, 10)); + cmc_assert_equals(int32_t, 2, total_read); + + cmc_assert(h_resize(h, 1000)); + cmc_assert_equals(int32_t, 1, total_resize); + + cmc_assert(h_resize(h, 100)); + cmc_assert_equals(int32_t, 2, total_resize); + + h_free(h); + }); }); diff --git a/tests/main/unt/intervalheap.c b/tests/main/unt/intervalheap.c index 6ba1422..41f02f2 100644 --- a/tests/main/unt/intervalheap.c +++ b/tests/main/unt/intervalheap.c @@ -127,10 +127,7 @@ CMC_CREATE_UNIT(intervalheap_test, true, { cmc_assert(ih_insert(ih, 1)); cmc_assert(ih_insert(ih, 2)); - size_t r; - cmc_assert(ih_max(ih, &r)); - - cmc_assert_equals(size_t, 2, r); + cmc_assert_equals(size_t, 2, ih_max(ih)); ih_free(ih); }); @@ -142,10 +139,7 @@ CMC_CREATE_UNIT(intervalheap_test, true, { cmc_assert(ih_insert(ih, 1)); cmc_assert(ih_insert(ih, 2)); - size_t r; - cmc_assert(ih_min(ih, &r)); - - cmc_assert_equals(size_t, 0, r); + cmc_assert_equals(size_t, 0, ih_min(ih)); ih_free(ih); }); @@ -228,22 +222,21 @@ CMC_CREATE_UNIT(intervalheap_test, true, { cmc_assert_equals(int32_t, cmc_flags.EMPTY, ih_flag(ih)); // max min - size_t r; ih->flag = cmc_flags.ERROR; - cmc_assert(!ih_max(ih, &r)); + cmc_assert_equals(size_t, (size_t){ 0 }, ih_max(ih)); cmc_assert_equals(int32_t, cmc_flags.EMPTY, ih_flag(ih)); ih->flag = cmc_flags.ERROR; - cmc_assert(!ih_min(ih, &r)); + cmc_assert_equals(size_t, (size_t){ 0 }, ih_min(ih)); cmc_assert_equals(int32_t, cmc_flags.EMPTY, ih_flag(ih)); cmc_assert(ih_insert(ih, 10)); ih->flag = cmc_flags.ERROR; - cmc_assert(ih_max(ih, &r)); + cmc_assert_equals(size_t, 10, ih_max(ih)); cmc_assert_equals(int32_t, cmc_flags.OK, ih_flag(ih)); ih->flag = cmc_flags.ERROR; - cmc_assert(ih_max(ih, &r)); + cmc_assert_equals(size_t, 10, ih_min(ih)); cmc_assert_equals(int32_t, cmc_flags.OK, ih_flag(ih)); // contains @@ -267,4 +260,54 @@ CMC_CREATE_UNIT(intervalheap_test, true, { ih_free(ih); ih_free(ih2); }); + + CMC_CREATE_TEST(callbacks, { + struct intervalheap *ih = + ih_new_custom(100, ih_ftab_val, NULL, callbacks); + + total_create = 0; + total_read = 0; + total_update = 0; + total_delete = 0; + total_resize = 0; + + cmc_assert(ih_insert(ih, 10)); + cmc_assert_equals(int32_t, 1, total_create); + + cmc_assert(ih_remove_max(ih)); + cmc_assert_equals(int32_t, 1, total_delete); + + cmc_assert(ih_insert(ih, 10)); + cmc_assert_equals(int32_t, 2, total_create); + + cmc_assert(ih_remove_min(ih)); + cmc_assert_equals(int32_t, 2, total_delete); + + cmc_assert(ih_insert(ih, 1)); + cmc_assert(ih_insert(ih, 2)); + cmc_assert_equals(int32_t, 4, total_create); + + cmc_assert(ih_update_max(ih, 1)); + cmc_assert_equals(int32_t, 1, total_update); + + cmc_assert(ih_update_min(ih, 2)); + cmc_assert_equals(int32_t, 2, total_update); + + cmc_assert_equals(size_t, 2, ih_max(ih)); + cmc_assert_equals(int32_t, 1, total_read); + + cmc_assert_equals(size_t, 1, ih_min(ih)); + cmc_assert_equals(int32_t, 2, total_read); + + cmc_assert(ih_contains(ih, 1)); + cmc_assert_equals(int32_t, 3, total_read); + + cmc_assert(ih_resize(ih, 1000)); + cmc_assert_equals(int32_t, 1, total_resize); + + cmc_assert(ih_resize(ih, 50)); + cmc_assert_equals(int32_t, 2, total_resize); + + ih_free(ih); + }); }); diff --git a/tests/main/unt/sortedlist.c b/tests/main/unt/sortedlist.c index af30ed4..8f1afc8 100644 --- a/tests/main/unt/sortedlist.c +++ b/tests/main/unt/sortedlist.c @@ -179,18 +179,18 @@ CMC_CREATE_UNIT(sortedlist_test, true, { // max min sl->flag = cmc_flags.ERROR; - cmc_assert(!sl_max(sl, NULL)); + cmc_assert_equals(size_t, (size_t){ 0 }, sl_max(sl)); cmc_assert_equals(int32_t, cmc_flags.EMPTY, sl_flag(sl)); sl->flag = cmc_flags.ERROR; - cmc_assert(!sl_min(sl, NULL)); + cmc_assert_equals(size_t, (size_t){ 0 }, sl_min(sl)); cmc_assert_equals(int32_t, cmc_flags.EMPTY, sl_flag(sl)); cmc_assert(sl_insert(sl, 1)); sl->flag = cmc_flags.ERROR; - cmc_assert(sl_max(sl, NULL)); + cmc_assert_equals(size_t, 1, sl_max(sl)); cmc_assert_equals(int32_t, cmc_flags.OK, sl_flag(sl)); sl->flag = cmc_flags.ERROR; - cmc_assert(sl_min(sl, NULL)); + cmc_assert_equals(size_t, 1, sl_min(sl)); cmc_assert_equals(int32_t, cmc_flags.OK, sl_flag(sl)); // get diff --git a/tests/main/unt/utl.c b/tests/main/unt/utl.c index c55baee..3d2a8f7 100644 --- a/tests/main/unt/utl.c +++ b/tests/main/unt/utl.c @@ -98,12 +98,11 @@ void callback_resize(void) total_resize++; } -struct cmc_callbacks *callbacks = &(struct cmc_callbacks) { - .create = callback_create, - .read = callback_read, - .update = callback_update, - .delete = callback_delete, - .resize = callback_resize -}; +struct cmc_callbacks *callbacks = + &(struct cmc_callbacks){ .create = callback_create, + .read = callback_read, + .update = callback_update, + .delete = callback_delete, + .resize = callback_resize }; #endif /* CMC_UNIT_TEST_UTL__ */