From 360e08b6b331df16bc494f409ae95622869569f0 Mon Sep 17 00:00:00 2001 From: Leonardo Date: Tue, 12 May 2020 13:53:28 -0300 Subject: [PATCH] Updating sortedlist iterators --- src/cmc/sortedlist.h | 100 ++++------ tests/main/main.c | 1 + tests/main/src/sortedlist.c | 86 ++++---- tests/main/unt/sortedlist.c | 383 ++++++++++++++++++++++++++++++++++++ 4 files changed, 456 insertions(+), 114 deletions(-) diff --git a/src/cmc/sortedlist.h b/src/cmc/sortedlist.h index 640464c..47edbc7 100644 --- a/src/cmc/sortedlist.h +++ b/src/cmc/sortedlist.h @@ -83,12 +83,6 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " \ /* Custom callback functions */ \ struct cmc_callbacks *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 *); \ }; \ \ /* Value struct function table */ \ @@ -164,17 +158,15 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " bool PFX##_print(struct SNAME *_list_, FILE *fptr); \ \ /* Iterator Functions */ \ - /* Iterator Allocation and Deallocation */ \ - struct SNAME##_iter *PFX##_iter_new(struct SNAME *target); \ - void PFX##_iter_free(struct SNAME##_iter *iter); \ /* Iterator Initialization */ \ - void PFX##_iter_init(struct SNAME##_iter *iter, struct SNAME *target); \ + struct SNAME##_iter PFX##_iter_start(struct SNAME *target); \ + struct SNAME##_iter PFX##_iter_end(struct SNAME *target); \ /* Iterator State */ \ - bool PFX##_iter_start(struct SNAME##_iter *iter); \ - bool PFX##_iter_end(struct SNAME##_iter *iter); \ + bool PFX##_iter_at_start(struct SNAME##_iter *iter); \ + bool PFX##_iter_at_end(struct SNAME##_iter *iter); \ /* Iterator Movement */ \ - void PFX##_iter_to_start(struct SNAME##_iter *iter); \ - void PFX##_iter_to_end(struct SNAME##_iter *iter); \ + bool PFX##_iter_to_start(struct SNAME##_iter *iter); \ + bool PFX##_iter_to_end(struct SNAME##_iter *iter); \ bool PFX##_iter_next(struct SNAME##_iter *iter); \ bool PFX##_iter_prev(struct SNAME##_iter *iter); \ bool PFX##_iter_advance(struct SNAME##_iter *iter, size_t steps); \ @@ -198,8 +190,6 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " size_t high); \ void PFX##_impl_sort_insertion(V *array, int (*cmp)(V, V), size_t low, \ size_t high); \ - 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##_fval *f_val) \ { \ @@ -231,8 +221,6 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " _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_; \ } \ @@ -267,8 +255,6 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " _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_; \ } \ @@ -594,63 +580,73 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " return true; \ } \ \ - struct SNAME##_iter *PFX##_iter_new(struct SNAME *target) \ + struct SNAME##_iter PFX##_iter_start(struct SNAME *target) \ { \ - struct SNAME##_iter *iter = \ - target->alloc->malloc(sizeof(struct SNAME##_iter)); \ + PFX##_sort(target); \ \ - if (!iter) \ - return NULL; \ + struct SNAME##_iter iter; \ \ - PFX##_iter_init(iter, target); \ + iter.target = target; \ + iter.cursor = 0; \ + iter.start = true; \ + iter.end = PFX##_empty(target); \ \ return iter; \ } \ \ - void PFX##_iter_free(struct SNAME##_iter *iter) \ - { \ - iter->target->alloc->free(iter); \ - } \ - \ - void PFX##_iter_init(struct SNAME##_iter *iter, struct SNAME *target) \ + struct SNAME##_iter PFX##_iter_end(struct SNAME *target) \ { \ PFX##_sort(target); \ \ - iter->target = target; \ - iter->cursor = 0; \ - iter->start = true; \ - iter->end = PFX##_empty(target); \ + struct SNAME##_iter iter; \ + \ + iter.target = target; \ + iter.cursor = 0; \ + iter.start = PFX##_empty(target); \ + iter.end = true; \ + \ + if (!PFX##_empty(target)) \ + iter.cursor = target->count - 1; \ + \ + return iter; \ } \ \ - bool PFX##_iter_start(struct SNAME##_iter *iter) \ + bool PFX##_iter_at_start(struct SNAME##_iter *iter) \ { \ return PFX##_empty(iter->target) || iter->start; \ } \ \ - bool PFX##_iter_end(struct SNAME##_iter *iter) \ + bool PFX##_iter_at_end(struct SNAME##_iter *iter) \ { \ return PFX##_empty(iter->target) || iter->end; \ } \ \ - void PFX##_iter_to_start(struct SNAME##_iter *iter) \ + bool PFX##_iter_to_start(struct SNAME##_iter *iter) \ { \ if (!PFX##_empty(iter->target)) \ { \ iter->cursor = 0; \ iter->start = true; \ iter->end = PFX##_empty(iter->target); \ + \ + return true; \ } \ + \ + return false; \ } \ \ - void PFX##_iter_to_end(struct SNAME##_iter *iter) \ + bool PFX##_iter_to_end(struct SNAME##_iter *iter) \ { \ if (!PFX##_empty(iter->target)) \ { \ iter->start = PFX##_empty(iter->target); \ - iter->cursor = \ - PFX##_empty(iter->target) ? 0 : iter->target->count - 1; \ + iter->cursor = iter->target->count - 1; \ iter->end = true; \ + \ + return true; \ } \ + \ + return false; \ } \ \ bool PFX##_iter_next(struct SNAME##_iter *iter) \ @@ -884,26 +880,6 @@ static const char *cmc_string_fmt_sortedlist = "struct %s<%s> " \ array[j] = _tmp_; \ } \ - } \ - \ - static struct SNAME##_iter PFX##_impl_it_start(struct SNAME *_list_) \ - { \ - struct SNAME##_iter iter; \ - \ - PFX##_iter_init(&iter, _list_); \ - PFX##_iter_to_start(&iter); \ - \ - return iter; \ - } \ - \ - static struct SNAME##_iter PFX##_impl_it_end(struct SNAME *_list_) \ - { \ - struct SNAME##_iter iter; \ - \ - PFX##_iter_init(&iter, _list_); \ - PFX##_iter_to_end(&iter); \ - \ - return iter; \ } #endif /* CMC_SORTEDLIST_H */ diff --git a/tests/main/main.c b/tests/main/main.c index d6c93fd..a55106f 100644 --- a/tests/main/main.c +++ b/tests/main/main.c @@ -52,6 +52,7 @@ int main(void) cmc_run(Deque, units, tests); cmc_run(DequeIter, units, tests); cmc_run(HashBidiMap, units, tests); + cmc_run(HashBidiMapIter, units, tests); cmc_run(HashMap, units, tests); cmc_run(HashMapIter, units, tests); cmc_run(HashMultiMap, units, tests); diff --git a/tests/main/src/sortedlist.c b/tests/main/src/sortedlist.c index 73344bd..06ecf1c 100644 --- a/tests/main/src/sortedlist.c +++ b/tests/main/src/sortedlist.c @@ -10,8 +10,6 @@ struct sortedlist struct sortedlist_fval *f_val; struct cmc_alloc_node *alloc; struct cmc_callbacks *callbacks; - struct sortedlist_iter (*it_start)(struct sortedlist *); - struct sortedlist_iter (*it_end)(struct sortedlist *); }; struct sortedlist_fval { @@ -55,13 +53,12 @@ struct sortedlist *sl_copy_of(struct sortedlist *_list_); _Bool sl_equals(struct sortedlist *_list1_, struct sortedlist *_list2_); struct cmc_string sl_to_string(struct sortedlist *_list_); _Bool sl_print(struct sortedlist *_list_, FILE *fptr); -struct sortedlist_iter *sl_iter_new(struct sortedlist *target); -void sl_iter_free(struct sortedlist_iter *iter); -void sl_iter_init(struct sortedlist_iter *iter, struct sortedlist *target); -_Bool sl_iter_start(struct sortedlist_iter *iter); -_Bool sl_iter_end(struct sortedlist_iter *iter); -void sl_iter_to_start(struct sortedlist_iter *iter); -void sl_iter_to_end(struct sortedlist_iter *iter); +struct sortedlist_iter sl_iter_start(struct sortedlist *target); +struct sortedlist_iter sl_iter_end(struct sortedlist *target); +_Bool sl_iter_at_start(struct sortedlist_iter *iter); +_Bool sl_iter_at_end(struct sortedlist_iter *iter); +_Bool sl_iter_to_start(struct sortedlist_iter *iter); +_Bool sl_iter_to_end(struct sortedlist_iter *iter); _Bool sl_iter_next(struct sortedlist_iter *iter); _Bool sl_iter_prev(struct sortedlist_iter *iter); _Bool sl_iter_advance(struct sortedlist_iter *iter, size_t steps); @@ -77,8 +74,6 @@ void sl_impl_sort_quicksort(size_t *array, int (*cmp)(size_t, size_t), size_t low, size_t high); void sl_impl_sort_insertion(size_t *array, int (*cmp)(size_t, size_t), size_t low, size_t high); -static struct sortedlist_iter sl_impl_it_start(struct sortedlist *_list_); -static struct sortedlist_iter sl_impl_it_end(struct sortedlist *_list_); struct sortedlist *sl_new(size_t capacity, struct sortedlist_fval *f_val) { struct cmc_alloc_node *alloc = &cmc_alloc_node_default; @@ -102,8 +97,6 @@ struct sortedlist *sl_new(size_t capacity, struct sortedlist_fval *f_val) _list_->f_val = f_val; _list_->alloc = alloc; _list_->callbacks = ((void *)0); - _list_->it_start = sl_impl_it_start; - _list_->it_end = sl_impl_it_end; return _list_; } struct sortedlist *sl_new_custom(size_t capacity, struct sortedlist_fval *f_val, @@ -130,8 +123,6 @@ struct sortedlist *sl_new_custom(size_t capacity, struct sortedlist_fval *f_val, _list_->f_val = f_val; _list_->alloc = alloc; _list_->callbacks = callbacks; - _list_->it_start = sl_impl_it_start; - _list_->it_end = sl_impl_it_end; return _list_; } void sl_clear(struct sortedlist *_list_) @@ -372,52 +363,57 @@ _Bool sl_print(struct sortedlist *_list_, FILE *fptr) } return 1; } -struct sortedlist_iter *sl_iter_new(struct sortedlist *target) -{ - struct sortedlist_iter *iter = - target->alloc->malloc(sizeof(struct sortedlist_iter)); - if (!iter) - return ((void *)0); - sl_iter_init(iter, target); - return iter; -} -void sl_iter_free(struct sortedlist_iter *iter) -{ - iter->target->alloc->free(iter); -} -void sl_iter_init(struct sortedlist_iter *iter, struct sortedlist *target) +struct sortedlist_iter sl_iter_start(struct sortedlist *target) { sl_sort(target); - iter->target = target; - iter->cursor = 0; - iter->start = 1; - iter->end = sl_empty(target); + struct sortedlist_iter iter; + iter.target = target; + iter.cursor = 0; + iter.start = 1; + iter.end = sl_empty(target); + return iter; } -_Bool sl_iter_start(struct sortedlist_iter *iter) +struct sortedlist_iter sl_iter_end(struct sortedlist *target) +{ + sl_sort(target); + struct sortedlist_iter iter; + iter.target = target; + iter.cursor = 0; + iter.start = sl_empty(target); + iter.end = 1; + if (!sl_empty(target)) + iter.cursor = target->count - 1; + return iter; +} +_Bool sl_iter_at_start(struct sortedlist_iter *iter) { return sl_empty(iter->target) || iter->start; } -_Bool sl_iter_end(struct sortedlist_iter *iter) +_Bool sl_iter_at_end(struct sortedlist_iter *iter) { return sl_empty(iter->target) || iter->end; } -void sl_iter_to_start(struct sortedlist_iter *iter) +_Bool sl_iter_to_start(struct sortedlist_iter *iter) { if (!sl_empty(iter->target)) { iter->cursor = 0; iter->start = 1; iter->end = sl_empty(iter->target); + return 1; } + return 0; } -void sl_iter_to_end(struct sortedlist_iter *iter) +_Bool sl_iter_to_end(struct sortedlist_iter *iter) { if (!sl_empty(iter->target)) { iter->start = sl_empty(iter->target); - iter->cursor = sl_empty(iter->target) ? 0 : iter->target->count - 1; + iter->cursor = iter->target->count - 1; iter->end = 1; + return 1; } + return 0; } _Bool sl_iter_next(struct sortedlist_iter *iter) { @@ -588,17 +584,3 @@ void sl_impl_sort_insertion(size_t *array, int (*cmp)(size_t, size_t), array[j] = _tmp_; } } -static struct sortedlist_iter sl_impl_it_start(struct sortedlist *_list_) -{ - struct sortedlist_iter iter; - sl_iter_init(&iter, _list_); - sl_iter_to_start(&iter); - return iter; -} -static struct sortedlist_iter sl_impl_it_end(struct sortedlist *_list_) -{ - struct sortedlist_iter iter; - sl_iter_init(&iter, _list_); - sl_iter_to_end(&iter); - return iter; -} diff --git a/tests/main/unt/sortedlist.c b/tests/main/unt/sortedlist.c index b7b493e..0ab4bff 100644 --- a/tests/main/unt/sortedlist.c +++ b/tests/main/unt/sortedlist.c @@ -314,7 +314,390 @@ CMC_CREATE_UNIT(SortedList, true, { }); CMC_CREATE_UNIT(SortedListIter, true, { + CMC_CREATE_TEST(PFX##_iter_start(), { + struct sortedlist *sl = sl_new(100, sl_fval); + cmc_assert_not_equals(ptr, NULL, sl); + + struct sortedlist_iter it = sl_iter_start(sl); + + cmc_assert_equals(ptr, sl, it.target); + cmc_assert_equals(size_t, 0, it.cursor); + cmc_assert_equals(bool, true, it.start); + cmc_assert_equals(bool, true, it.end); + + cmc_assert(sl_iter_at_start(&it)); + cmc_assert(sl_iter_at_end(&it)); + + cmc_assert(sl_insert(sl, 1)); + cmc_assert(sl_insert(sl, 2)); + + it = sl_iter_start(sl); + + cmc_assert_equals(size_t, 0, it.cursor); + cmc_assert_equals(bool, false, it.end); + + sl_free(sl); + }); + + CMC_CREATE_TEST(PFX##_iter_end(), { + struct sortedlist *sl = sl_new(100, sl_fval); + + cmc_assert_not_equals(ptr, NULL, sl); + + struct sortedlist_iter it = sl_iter_end(sl); + + cmc_assert_equals(ptr, sl, it.target); + cmc_assert_equals(size_t, 0, it.cursor); + cmc_assert_equals(bool, true, it.start); + cmc_assert_equals(bool, true, it.end); + + cmc_assert(sl_iter_at_start(&it)); + cmc_assert(sl_iter_at_end(&it)); + + cmc_assert(sl_insert(sl, 1)); + cmc_assert(sl_insert(sl, 2)); + cmc_assert(sl_insert(sl, 3)); + + it = sl_iter_end(sl); + + cmc_assert_equals(size_t, sl->count - 1, it.cursor); + cmc_assert_equals(bool, false, it.start); + + sl_free(sl); + }); + + CMC_CREATE_TEST(PFX##_iter_at_start(), { + struct sortedlist *sl = sl_new(100, sl_fval); + + cmc_assert_not_equals(ptr, NULL, sl); + + struct sortedlist_iter it = sl_iter_start(sl); + + // Empty checks + cmc_assert(sl_iter_at_start(&it)); + it = sl_iter_end(sl); + cmc_assert(sl_iter_at_start(&it)); + + // Non-empty checks + cmc_assert(sl_insert(sl, 1)); + it = sl_iter_end(sl); + cmc_assert(!sl_iter_at_start(&it)); + it = sl_iter_start(sl); + cmc_assert(sl_iter_at_start(&it)); + + sl_free(sl); + }); + + CMC_CREATE_TEST(PFX##_iter_at_end(), { + struct sortedlist *sl = sl_new(100, sl_fval); + + cmc_assert_not_equals(ptr, NULL, sl); + + struct sortedlist_iter it = sl_iter_start(sl); + + // Empty check + cmc_assert(sl_iter_at_end(&it)); + it = sl_iter_end(sl); + cmc_assert(sl_iter_at_end(&it)); + + // Non-empty checks + cmc_assert(sl_insert(sl, 1)); + it = sl_iter_end(sl); + cmc_assert(sl_iter_at_end(&it)); + it = sl_iter_start(sl); + cmc_assert(!sl_iter_at_end(&it)); + + sl_free(sl); + }); + + CMC_CREATE_TEST(PFX##_iter_to_start(), { + struct sortedlist *sl = sl_new(100, sl_fval); + + cmc_assert_not_equals(ptr, NULL, sl); + + struct sortedlist_iter it = sl_iter_start(sl); + + cmc_assert(!sl_iter_to_start(&it)); + + for (size_t i = 1; i <= 100; i++) + sl_insert(sl, i); + + cmc_assert_equals(size_t, 100, sl->count); + + it = sl_iter_end(sl); + + cmc_assert(!sl_iter_at_start(&it)); + cmc_assert(sl_iter_at_end(&it)); + + cmc_assert_equals(size_t, 100, sl_iter_value(&it)); + + cmc_assert(sl_iter_to_start(&it)); + + cmc_assert(sl_iter_at_start(&it)); + cmc_assert(!sl_iter_at_end(&it)); + + cmc_assert_equals(size_t, 1, sl_iter_value(&it)); + + sl_free(sl); + }); + + CMC_CREATE_TEST(PFX##_iter_to_end(), { + struct sortedlist *sl = sl_new(100, sl_fval); + + cmc_assert_not_equals(ptr, NULL, sl); + + struct sortedlist_iter it = sl_iter_end(sl); + + cmc_assert(!sl_iter_to_end(&it)); + + for (size_t i = 1; i <= 100; i++) + sl_insert(sl, i); + + it = sl_iter_start(sl); + + cmc_assert(sl_iter_at_start(&it)); + cmc_assert(!sl_iter_at_end(&it)); + + cmc_assert_equals(size_t, 1, sl_iter_value(&it)); + + cmc_assert(sl_iter_to_end(&it)); + + cmc_assert(!sl_iter_at_start(&it)); + cmc_assert(sl_iter_at_end(&it)); + + cmc_assert_equals(size_t, 100, sl_iter_value(&it)); + + sl_free(sl); + }); + + CMC_CREATE_TEST(PFX##_iter_next(), { + struct sortedlist *sl = sl_new(100, sl_fval); + + cmc_assert_not_equals(ptr, NULL, sl); + + struct sortedlist_iter it = sl_iter_start(sl); + + cmc_assert(!sl_iter_next(&it)); + + for (size_t i = 1; i <= 1000; i++) + sl_insert(sl, i); + + size_t sum = 0; + for (it = sl_iter_start(sl); !sl_iter_at_end(&it); sl_iter_next(&it)) + { + sum += sl_iter_value(&it); + } + + cmc_assert_equals(size_t, 500500, sum); + + sum = 0; + + sl_iter_to_start(&it); + do + { + sum += sl_iter_value(&it); + } while (sl_iter_next(&it)); + + cmc_assert_equals(size_t, 500500, sum); + + sl_free(sl); + }); + + CMC_CREATE_TEST(PFX##_iter_prev(), { + struct sortedlist *sl = sl_new(100, sl_fval); + + cmc_assert_not_equals(ptr, NULL, sl); + + struct sortedlist_iter it = sl_iter_end(sl); + + cmc_assert(!sl_iter_prev(&it)); + + for (size_t i = 1; i <= 1000; i++) + sl_insert(sl, i); + + size_t sum = 0; + for (it = sl_iter_end(sl); !sl_iter_at_start(&it); sl_iter_prev(&it)) + { + sum += sl_iter_value(&it); + } + + cmc_assert_equals(size_t, 500500, sum); + + sum = 0; + + sl_iter_to_end(&it); + do + { + sum += sl_iter_value(&it); + } while (sl_iter_prev(&it)); + + cmc_assert_equals(size_t, 500500, sum); + + sl_free(sl); + }); + + CMC_CREATE_TEST(PFX##_iter_advance(), { + struct sortedlist *sl = sl_new(100, sl_fval); + + cmc_assert_not_equals(ptr, NULL, sl); + + struct sortedlist_iter it = sl_iter_start(sl); + + cmc_assert(!sl_iter_advance(&it, 1)); + + for (size_t i = 0; i <= 1000; i++) + sl_insert(sl, i); + + it = sl_iter_start(sl); + + cmc_assert(!sl_iter_advance(&it, 0)); + cmc_assert(!sl_iter_advance(&it, sl->count)); + + size_t sum = 0; + for (it = sl_iter_start(sl);;) + { + sum += sl_iter_value(&it); + + if (!sl_iter_advance(&it, 2)) + break; + } + + cmc_assert_equals(size_t, 250500, sum); + + sl_iter_to_start(&it); + cmc_assert(sl_iter_advance(&it, sl->count - 1)); + + sl_free(sl); + }); + + CMC_CREATE_TEST(PFX##_iter_rewind(), { + struct sortedlist *sl = sl_new(100, sl_fval); + + cmc_assert_not_equals(ptr, NULL, sl); + + struct sortedlist_iter it = sl_iter_end(sl); + + cmc_assert(!sl_iter_rewind(&it, 1)); + + for (size_t i = 0; i <= 1000; i++) + sl_insert(sl, i); + + it = sl_iter_end(sl); + + cmc_assert(!sl_iter_rewind(&it, 0)); + cmc_assert(!sl_iter_rewind(&it, sl->count)); + + size_t sum = 0; + for (it = sl_iter_end(sl);;) + { + sum += sl_iter_value(&it); + + if (!sl_iter_rewind(&it, 2)) + break; + } + + cmc_assert_equals(size_t, 250500, sum); + + sl_iter_to_end(&it); + cmc_assert(sl_iter_rewind(&it, sl->count - 1)); + + sl_free(sl); + }); + + CMC_CREATE_TEST(PFX##_iter_go_to(), { + struct sortedlist *sl = sl_new(100, sl_fval); + + cmc_assert_not_equals(ptr, NULL, sl); + + struct sortedlist_iter it = sl_iter_end(sl); + cmc_assert(!sl_iter_go_to(&it, 0)); + + it = sl_iter_start(sl); + cmc_assert(!sl_iter_go_to(&it, 0)); + + for (size_t i = 0; i <= 1000; i++) + sl_insert(sl, i); + + it = sl_iter_start(sl); + + size_t sum = 0; + for (size_t i = 0; i < 1001; i++) + { + sl_iter_go_to(&it, i); + + sum += sl_iter_value(&it); + } + + cmc_assert_equals(size_t, 500500, sum); + + sum = 0; + for (size_t i = 1001; i > 0; i--) + { + cmc_assert(sl_iter_go_to(&it, i - 1)); + + sum += sl_iter_value(&it); + } + + cmc_assert_equals(size_t, 500500, sum); + + sum = 0; + for (size_t i = 0; i < 1001; i += 100) + { + cmc_assert(sl_iter_go_to(&it, i)); + cmc_assert_equals(size_t, i, sl_iter_index(&it)); + + sum += sl_iter_value(&it); + } + + cmc_assert_equals(size_t, 5500, sum); + + sl_free(sl); + }); + + CMC_CREATE_TEST(PFX##_iter_value(), { + struct sortedlist *sl = sl_new(100, sl_fval); + + cmc_assert_not_equals(ptr, NULL, sl); + + struct sortedlist_iter it = sl_iter_end(sl); + + cmc_assert_equals(size_t, (size_t){ 0 }, sl_iter_value(&it)); + + cmc_assert(sl_insert(sl, 10)); + + it = sl_iter_start(sl); + + cmc_assert_equals(size_t, 10, sl_iter_value(&it)); + + sl_free(sl); + }); + + CMC_CREATE_TEST(PFX##_iter_index(), { + struct sortedlist *sl = sl_new(100, sl_fval); + + cmc_assert_not_equals(ptr, NULL, sl); + + for (size_t i = 0; i <= 1000; i++) + sl_insert(sl, i); + + struct sortedlist_iter it = sl_iter_start(sl); + + for (size_t i = 0; i < 1001; i++) + { + cmc_assert_equals(size_t, i, sl_iter_index(&it)); + sl_iter_next(&it); + } + + it = sl_iter_end(sl); + for (size_t i = 1001; i > 0; i--) + { + cmc_assert_equals(size_t, i - 1, sl_iter_index(&it)); + sl_iter_prev(&it); + } + + sl_free(sl); + }); }); #ifdef CMC_TEST_MAIN