diff --git a/src/cmc/deque.h b/src/cmc/deque.h index 09e0de5..b33b2df 100644 --- a/src/cmc/deque.h +++ b/src/cmc/deque.h @@ -95,12 +95,6 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " \ /* Custom callback functions */ \ struct cmc_callbacks *callbacks; \ - \ - /* Function that returns an iterator to the start of the deque */ \ - struct SNAME##_iter (*it_start)(struct SNAME *); \ - \ - /* Function that returns an iterator to the end of the deque */ \ - struct SNAME##_iter (*it_end)(struct SNAME *); \ }; \ \ struct SNAME##_fval \ @@ -149,8 +143,13 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " struct SNAME *PFX##_new_custom( \ size_t capacity, struct SNAME##_fval *f_val, \ struct cmc_alloc_node *alloc, struct cmc_callbacks *callbacks); \ + struct SNAME PFX##_init(size_t capacity, struct SNAME##_fval *f_val); \ + struct SNAME PFX##_init_custom( \ + size_t capacity, struct SNAME##_fval *f_val, \ + struct cmc_alloc_node *alloc, struct cmc_callbacks *callbacks); \ void PFX##_clear(struct SNAME *_deque_); \ void PFX##_free(struct SNAME *_deque_); \ + void PFX##_release(struct SNAME _deque_); \ /* Customization of Allocation and Callbacks */ \ void PFX##_customize(struct SNAME *_deque_, struct cmc_alloc_node *alloc, \ struct cmc_callbacks *callbacks); \ @@ -177,14 +176,12 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " bool PFX##_print(struct SNAME *_deque_, 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); \ @@ -204,44 +201,11 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " #define CMC_GENERATE_DEQUE_SOURCE(PFX, SNAME, V) \ \ /* Implementation Detail Functions */ \ - static struct SNAME##_iter PFX##_impl_it_start(struct SNAME *_deque_); \ - static struct SNAME##_iter PFX##_impl_it_end(struct SNAME *_deque_); \ + /* None */ \ \ struct SNAME *PFX##_new(size_t capacity, struct SNAME##_fval *f_val) \ { \ - struct cmc_alloc_node *alloc = &cmc_alloc_node_default; \ - \ - if (capacity < 1) \ - return NULL; \ - \ - if (!f_val) \ - return NULL; \ - \ - struct SNAME *_deque_ = alloc->malloc(sizeof(struct SNAME)); \ - \ - if (!_deque_) \ - return NULL; \ - \ - _deque_->buffer = alloc->calloc(capacity, sizeof(V)); \ - \ - if (!_deque_->buffer) \ - { \ - alloc->free(_deque_); \ - return NULL; \ - } \ - \ - _deque_->capacity = capacity; \ - _deque_->count = 0; \ - _deque_->front = 0; \ - _deque_->back = 0; \ - _deque_->flag = cmc_flags.OK; \ - _deque_->f_val = f_val; \ - _deque_->alloc = alloc; \ - _deque_->callbacks = NULL; \ - _deque_->it_start = PFX##_impl_it_start; \ - _deque_->it_end = PFX##_impl_it_end; \ - \ - return _deque_; \ + return PFX##_new_custom(capacity, f_val, NULL, NULL); \ } \ \ struct SNAME *PFX##_new_custom( \ @@ -278,8 +242,43 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " _deque_->f_val = f_val; \ _deque_->alloc = alloc; \ _deque_->callbacks = callbacks; \ - _deque_->it_start = PFX##_impl_it_start; \ - _deque_->it_end = PFX##_impl_it_end; \ + \ + return _deque_; \ + } \ + \ + struct SNAME PFX##_init(size_t capacity, struct SNAME##_fval *f_val) \ + { \ + return PFX##_init_custom(capacity, f_val, NULL, NULL); \ + } \ + \ + struct SNAME PFX##_init_custom( \ + size_t capacity, struct SNAME##_fval *f_val, \ + struct cmc_alloc_node *alloc, struct cmc_callbacks *callbacks) \ + { \ + struct SNAME _deque_ = { 0 }; \ + \ + if (capacity < 1) \ + return _deque_; \ + \ + if (!f_val) \ + return _deque_; \ + \ + if (!alloc) \ + alloc = &cmc_alloc_node_default; \ + \ + _deque_.buffer = alloc->calloc(capacity, sizeof(V)); \ + \ + if (!_deque_.buffer) \ + return _deque_; \ + \ + _deque_.capacity = capacity; \ + _deque_.count = 0; \ + _deque_.front = 0; \ + _deque_.back = 0; \ + _deque_.flag = cmc_flags.OK; \ + _deque_.f_val = f_val; \ + _deque_.alloc = alloc; \ + _deque_.callbacks = callbacks; \ \ return _deque_; \ } \ @@ -321,6 +320,21 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " _deque_->alloc->free(_deque_); \ } \ \ + void PFX##_release(struct SNAME _deque_) \ + { \ + if (_deque_.f_val->free) \ + { \ + for (size_t i = _deque_.front, j = 0; j < _deque_.count; j++) \ + { \ + _deque_.f_val->free(_deque_.buffer[i]); \ + \ + i = (i + 1) % _deque_.capacity; \ + } \ + } \ + \ + _deque_.alloc->free(_deque_.buffer); \ + } \ + \ void PFX##_customize(struct SNAME *_deque_, struct cmc_alloc_node *alloc, \ struct cmc_callbacks *callbacks) \ { \ @@ -636,39 +650,52 @@ static const char *cmc_string_fmt_deque = "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)); \ + struct SNAME##_iter iter; \ \ - if (!iter) \ - return NULL; \ - \ - PFX##_iter_init(iter, target); \ + iter.target = target; \ + iter.cursor = target->front; \ + iter.index = 0; \ + iter.start = true; \ + iter.end = PFX##_empty(target); \ \ return iter; \ } \ \ - void PFX##_iter_free(struct SNAME##_iter *iter) \ + struct SNAME##_iter PFX##_iter_end(struct SNAME *target) \ { \ - iter->target->alloc->free(iter); \ + struct SNAME##_iter iter; \ + \ + iter.target = target; \ + \ + if (!PFX##_empty(target)) \ + { \ + if (iter.target->back == 0) \ + iter.cursor = iter.target->capacity - 1; \ + else \ + iter.cursor = iter.target->back - 1; \ + \ + iter.index = iter.target->count - 1; \ + } \ + else \ + { \ + iter.cursor = 0; \ + iter.index = 0; \ + } \ + \ + iter.start = PFX##_empty(target); \ + iter.end = true; \ + \ + return iter; \ } \ \ - void PFX##_iter_init(struct SNAME##_iter *iter, struct SNAME *target) \ - { \ - iter->target = target; \ - iter->cursor = target->front; \ - iter->index = 0; \ - iter->start = true; \ - iter->end = PFX##_empty(target); \ - } \ - \ - 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; \ } \ @@ -824,25 +851,6 @@ static const char *cmc_string_fmt_deque = "struct %s<%s> " size_t PFX##_iter_index(struct SNAME##_iter *iter) \ { \ return iter->index; \ - } \ - \ - static struct SNAME##_iter PFX##_impl_it_start(struct SNAME *_deque_) \ - { \ - struct SNAME##_iter iter; \ - \ - PFX##_iter_init(&iter, _deque_); \ - \ - return iter; \ - } \ - \ - static struct SNAME##_iter PFX##_impl_it_end(struct SNAME *_deque_) \ - { \ - struct SNAME##_iter iter; \ - \ - PFX##_iter_init(&iter, _deque_); \ - PFX##_iter_to_end(&iter); \ - \ - return iter; \ } #endif /* CMC_DEQUE_H */ diff --git a/tests/main/main.c b/tests/main/main.c index 9e792f0..92b5c49 100644 --- a/tests/main/main.c +++ b/tests/main/main.c @@ -48,6 +48,7 @@ int main(void) cmc_run(BidiMap, units, tests); cmc_run(Deque, units, tests); + cmc_run(DequeIter, units, tests); cmc_run(HashMap, units, tests); cmc_run(HashSet, units, tests); cmc_run(Heap, units, tests); diff --git a/tests/main/src/deque.c b/tests/main/src/deque.c index 5277a79..c2f6ea5 100644 --- a/tests/main/src/deque.c +++ b/tests/main/src/deque.c @@ -11,8 +11,6 @@ struct deque struct deque_fval *f_val; struct cmc_alloc_node *alloc; struct cmc_callbacks *callbacks; - struct deque_iter (*it_start)(struct deque *); - struct deque_iter (*it_end)(struct deque *); }; struct deque_fval { @@ -35,8 +33,13 @@ struct deque *d_new(size_t capacity, struct deque_fval *f_val); struct deque *d_new_custom(size_t capacity, struct deque_fval *f_val, struct cmc_alloc_node *alloc, struct cmc_callbacks *callbacks); +struct deque d_init(size_t capacity, struct deque_fval *f_val); +struct deque d_init_custom(size_t capacity, struct deque_fval *f_val, + struct cmc_alloc_node *alloc, + struct cmc_callbacks *callbacks); void d_clear(struct deque *_deque_); void d_free(struct deque *_deque_); +void d_release(struct deque _deque_); void d_customize(struct deque *_deque_, struct cmc_alloc_node *alloc, struct cmc_callbacks *callbacks); _Bool d_push_front(struct deque *_deque_, size_t value); @@ -56,11 +59,10 @@ struct deque *d_copy_of(struct deque *_deque_); _Bool d_equals(struct deque *_deque1_, struct deque *_deque2_); struct cmc_string d_to_string(struct deque *_deque_); _Bool d_print(struct deque *_deque_, FILE *fptr); -struct deque_iter *d_iter_new(struct deque *target); -void d_iter_free(struct deque_iter *iter); -void d_iter_init(struct deque_iter *iter, struct deque *target); -_Bool d_iter_start(struct deque_iter *iter); -_Bool d_iter_end(struct deque_iter *iter); +struct deque_iter d_iter_start(struct deque *target); +struct deque_iter d_iter_end(struct deque *target); +_Bool d_iter_at_start(struct deque_iter *iter); +_Bool d_iter_at_end(struct deque_iter *iter); void d_iter_to_start(struct deque_iter *iter); void d_iter_to_end(struct deque_iter *iter); _Bool d_iter_next(struct deque_iter *iter); @@ -71,35 +73,9 @@ _Bool d_iter_go_to(struct deque_iter *iter, size_t index); size_t d_iter_value(struct deque_iter *iter); size_t *d_iter_rvalue(struct deque_iter *iter); size_t d_iter_index(struct deque_iter *iter); -static struct deque_iter d_impl_it_start(struct deque *_deque_); -static struct deque_iter d_impl_it_end(struct deque *_deque_); struct deque *d_new(size_t capacity, struct deque_fval *f_val) { - struct cmc_alloc_node *alloc = &cmc_alloc_node_default; - if (capacity < 1) - return ((void *)0); - if (!f_val) - return ((void *)0); - struct deque *_deque_ = alloc->malloc(sizeof(struct deque)); - if (!_deque_) - return ((void *)0); - _deque_->buffer = alloc->calloc(capacity, sizeof(size_t)); - if (!_deque_->buffer) - { - alloc->free(_deque_); - return ((void *)0); - } - _deque_->capacity = capacity; - _deque_->count = 0; - _deque_->front = 0; - _deque_->back = 0; - _deque_->flag = cmc_flags.OK; - _deque_->f_val = f_val; - _deque_->alloc = alloc; - _deque_->callbacks = ((void *)0); - _deque_->it_start = d_impl_it_start; - _deque_->it_end = d_impl_it_end; - return _deque_; + return d_new_custom(capacity, f_val, ((void *)0), ((void *)0)); } struct deque *d_new_custom(size_t capacity, struct deque_fval *f_val, struct cmc_alloc_node *alloc, @@ -128,8 +104,34 @@ struct deque *d_new_custom(size_t capacity, struct deque_fval *f_val, _deque_->f_val = f_val; _deque_->alloc = alloc; _deque_->callbacks = callbacks; - _deque_->it_start = d_impl_it_start; - _deque_->it_end = d_impl_it_end; + return _deque_; +} +struct deque d_init(size_t capacity, struct deque_fval *f_val) +{ + return d_init_custom(capacity, f_val, ((void *)0), ((void *)0)); +} +struct deque d_init_custom(size_t capacity, struct deque_fval *f_val, + struct cmc_alloc_node *alloc, + struct cmc_callbacks *callbacks) +{ + struct deque _deque_ = { 0 }; + if (capacity < 1) + return _deque_; + if (!f_val) + return _deque_; + if (!alloc) + alloc = &cmc_alloc_node_default; + _deque_.buffer = alloc->calloc(capacity, sizeof(size_t)); + if (!_deque_.buffer) + return _deque_; + _deque_.capacity = capacity; + _deque_.count = 0; + _deque_.front = 0; + _deque_.back = 0; + _deque_.flag = cmc_flags.OK; + _deque_.f_val = f_val; + _deque_.alloc = alloc; + _deque_.callbacks = callbacks; return _deque_; } void d_clear(struct deque *_deque_) @@ -161,6 +163,18 @@ void d_free(struct deque *_deque_) _deque_->alloc->free(_deque_->buffer); _deque_->alloc->free(_deque_); } +void d_release(struct deque _deque_) +{ + if (_deque_.f_val->free) + { + for (size_t i = _deque_.front, j = 0; j < _deque_.count; j++) + { + _deque_.f_val->free(_deque_.buffer[i]); + i = (i + 1) % _deque_.capacity; + } + } + _deque_.alloc->free(_deque_.buffer); +} void d_customize(struct deque *_deque_, struct cmc_alloc_node *alloc, struct cmc_callbacks *callbacks) { @@ -396,31 +410,42 @@ _Bool d_print(struct deque *_deque_, FILE *fptr) } return 1; } -struct deque_iter *d_iter_new(struct deque *target) +struct deque_iter d_iter_start(struct deque *target) { - struct deque_iter *iter = target->alloc->malloc(sizeof(struct deque_iter)); - if (!iter) - return ((void *)0); - d_iter_init(iter, target); + struct deque_iter iter; + iter.target = target; + iter.cursor = target->front; + iter.index = 0; + iter.start = 1; + iter.end = d_empty(target); return iter; } -void d_iter_free(struct deque_iter *iter) +struct deque_iter d_iter_end(struct deque *target) { - iter->target->alloc->free(iter); + struct deque_iter iter; + iter.target = target; + if (!d_empty(target)) + { + if (iter.target->back == 0) + iter.cursor = iter.target->capacity - 1; + else + iter.cursor = iter.target->back - 1; + iter.index = iter.target->count - 1; + } + else + { + iter.cursor = 0; + iter.index = 0; + } + iter.start = d_empty(target); + iter.end = 1; + return iter; } -void d_iter_init(struct deque_iter *iter, struct deque *target) -{ - iter->target = target; - iter->cursor = target->front; - iter->index = 0; - iter->start = 1; - iter->end = d_empty(target); -} -_Bool d_iter_start(struct deque_iter *iter) +_Bool d_iter_at_start(struct deque_iter *iter) { return d_empty(iter->target) || iter->start; } -_Bool d_iter_end(struct deque_iter *iter) +_Bool d_iter_at_end(struct deque_iter *iter) { return d_empty(iter->target) || iter->end; } @@ -536,16 +561,3 @@ size_t d_iter_index(struct deque_iter *iter) { return iter->index; } -static struct deque_iter d_impl_it_start(struct deque *_deque_) -{ - struct deque_iter iter; - d_iter_init(&iter, _deque_); - return iter; -} -static struct deque_iter d_impl_it_end(struct deque *_deque_) -{ - struct deque_iter iter; - d_iter_init(&iter, _deque_); - d_iter_to_end(&iter); - return iter; -} diff --git a/tests/main/unt/deque.c b/tests/main/unt/deque.c index 08a68c0..ad124b3 100644 --- a/tests/main/unt/deque.c +++ b/tests/main/unt/deque.c @@ -30,7 +30,13 @@ CMC_CREATE_UNIT(Deque, true, { cmc_assert_not_equals(ptr, NULL, d); cmc_assert_not_equals(ptr, NULL, d->buffer); cmc_assert_equals(size_t, 1000000, d->capacity); - cmc_assert_equals(size_t, 0, d_count(d)); + cmc_assert_equals(size_t, 0, d->count); + cmc_assert_equals(size_t, 0, d->front); + cmc_assert_equals(size_t, 0, d->back); + cmc_assert_equals(int32_t, cmc_flags.OK, d->flag); + cmc_assert_equals(ptr, d_fval, d->f_val); + cmc_assert_equals(ptr, &cmc_alloc_node_default, d->alloc); + cmc_assert_equals(ptr, NULL, d->callbacks); d_free(d); @@ -51,9 +57,17 @@ CMC_CREATE_UNIT(Deque, true, { }); CMC_CREATE_TEST(PFX##_new_custom(), { - struct deque *d = d_new_custom(100, d_fval, d_alloc_node, callbacks); + struct deque *d = + d_new_custom(1000000, d_fval, d_alloc_node, callbacks); cmc_assert_not_equals(ptr, NULL, d); + cmc_assert_not_equals(ptr, NULL, d->buffer); + cmc_assert_equals(size_t, 1000000, d->capacity); + cmc_assert_equals(size_t, 0, d->count); + cmc_assert_equals(size_t, 0, d->front); + cmc_assert_equals(size_t, 0, d->back); + cmc_assert_equals(int32_t, cmc_flags.OK, d->flag); + cmc_assert_equals(ptr, d_fval, d->f_val); cmc_assert_equals(ptr, d_alloc_node, d->alloc); cmc_assert_equals(ptr, callbacks, d->callbacks); @@ -75,6 +89,75 @@ CMC_CREATE_UNIT(Deque, true, { d_free(d); }); + CMC_CREATE_TEST(PFX##_init(), { + struct deque d = d_init(1000000, d_fval); + + cmc_assert_not_equals(ptr, NULL, d.buffer); + cmc_assert_equals(size_t, 1000000, d.capacity); + cmc_assert_equals(size_t, 0, d.count); + cmc_assert_equals(size_t, 0, d.front); + cmc_assert_equals(size_t, 0, d.back); + cmc_assert_equals(int32_t, cmc_flags.OK, d.flag); + cmc_assert_equals(ptr, d_fval, d.f_val); + cmc_assert_equals(ptr, &cmc_alloc_node_default, d.alloc); + cmc_assert_equals(ptr, NULL, d.callbacks); + + d_release(d); + + d = d_init(0, d_fval); + + cmc_assert_equals(size_t, 0, d.capacity); + cmc_assert_equals(ptr, NULL, d.buffer); + + d = d_init(1000, NULL); + + cmc_assert_equals(size_t, 0, d.capacity); + cmc_assert_equals(ptr, NULL, d.buffer); + + d = d_init(UINT64_MAX, d_fval); + + cmc_assert_equals(size_t, 0, d.capacity); + cmc_assert_equals(ptr, NULL, d.buffer); + + if (d.buffer) + d_release(d); + }); + + CMC_CREATE_TEST(PFX##_init_custom(), { + struct deque d = + d_init_custom(1000000, d_fval, d_alloc_node, callbacks); + + cmc_assert_not_equals(ptr, NULL, d.buffer); + cmc_assert_equals(size_t, 1000000, d.capacity); + cmc_assert_equals(size_t, 0, d.count); + cmc_assert_equals(size_t, 0, d.front); + cmc_assert_equals(size_t, 0, d.back); + cmc_assert_equals(int32_t, cmc_flags.OK, d.flag); + cmc_assert_equals(ptr, d_fval, d.f_val); + cmc_assert_equals(ptr, d_alloc_node, d.alloc); + cmc_assert_equals(ptr, callbacks, d.callbacks); + + d_release(d); + + d = d_init_custom(0, d_fval, d_alloc_node, callbacks); + + cmc_assert_equals(size_t, 0, d.capacity); + cmc_assert_equals(ptr, NULL, d.buffer); + + d = d_init_custom(1000, NULL, d_alloc_node, callbacks); + + cmc_assert_equals(size_t, 0, d.capacity); + cmc_assert_equals(ptr, NULL, d.buffer); + + d = d_init_custom(UINT64_MAX, d_fval, d_alloc_node, callbacks); + + cmc_assert_equals(size_t, 0, d.capacity); + cmc_assert_equals(ptr, NULL, d.buffer); + + if (d.buffer) + d_release(d); + }); + CMC_CREATE_TEST(PFX##_clear(), { v_total_free = 0; struct deque *d = d_new(100, d_fval_counter); @@ -162,6 +245,37 @@ CMC_CREATE_UNIT(Deque, true, { v_total_free = 0; }); + CMC_CREATE_TEST(PFX##_destroy(), { + v_total_free = 0; + + struct deque d = d_init(100, d_fval_counter); + + cmc_assert_not_equals(ptr, NULL, d.buffer); + + for (size_t i = 1; i <= 1000; i++) + { + if (i % 2 == 0) + d_push_front(&d, i); + else + d_push_back(&d, i); + } + + cmc_assert_equals(size_t, 1000, d_count(&d)); + + size_t sum = 0; + for (size_t i = d.front, j = 0; j < d.count; + i = (i + 1) % d.capacity, j++) + sum += d.buffer[i]; + + cmc_assert_equals(size_t, 500500, sum); + + d_release(d); + + cmc_assert_equals(size_t, 1000, v_total_free); + + v_total_free = 0; + }); + CMC_CREATE_TEST(PFX##_customize(), { struct deque *d = d_new(100, d_fval); @@ -1082,3 +1196,120 @@ CMC_CREATE_UNIT(Deque, true, { total_resize = 0; }); }); + +CMC_CREATE_UNIT(DequeIter, true, { + CMC_CREATE_TEST(PFX##_iter_start(), { + struct deque *d = d_new(100, d_fval); + + cmc_assert_not_equals(ptr, NULL, d); + + struct deque_iter it = d_iter_start(d); + + cmc_assert_equals(ptr, d, it.target); + cmc_assert_equals(size_t, d->front, it.cursor); + cmc_assert_equals(size_t, 0, it.index); + cmc_assert_equals(bool, true, it.start); + cmc_assert_equals(bool, true, it.end); + + cmc_assert(d_iter_at_start(&it)); + cmc_assert(d_iter_at_end(&it)); + + cmc_assert(d_push_front(d, 1)); + cmc_assert(d_push_front(d, 2)); + + it = d_iter_start(d); + + cmc_assert_equals(size_t, 0, it.index); + cmc_assert_equals(size_t, d->front, it.cursor); + + d_free(d); + }); + + CMC_CREATE_TEST(PFX##_iter_end(), { + struct deque *d = d_new(100, d_fval); + + cmc_assert_not_equals(ptr, NULL, d); + + struct deque_iter it = d_iter_end(d); + + cmc_assert_equals(ptr, d, it.target); + cmc_assert_equals(size_t, d->back, it.cursor); + cmc_assert_equals(size_t, 0, it.index); + cmc_assert_equals(bool, true, it.start); + cmc_assert_equals(bool, true, it.end); + + cmc_assert(d_iter_at_start(&it)); + cmc_assert(d_iter_at_end(&it)); + + cmc_assert(d_push_back(d, 1)); + cmc_assert(d_push_back(d, 2)); + cmc_assert(d_push_back(d, 3)); + + it = d_iter_end(d); + + cmc_assert_equals(size_t, d->count - 1, it.index); + cmc_assert_equals(size_t, d->back - 1, it.cursor); + + d_free(d); + }); + + CMC_CREATE_TEST(PFX##_iter_at_start(), { + struct deque *d = d_new(100, d_fval); + + cmc_assert_not_equals(ptr, NULL, d); + + struct deque_iter it = d_iter_start(d); + + // Empty checks + cmc_assert(d_iter_at_start(&it)); + it = d_iter_end(d); + cmc_assert(d_iter_at_start(&it)); + + // Non-empty checks + cmc_assert(d_push_back(d, 1)); + it = d_iter_end(d); + cmc_assert(!d_iter_at_start(&it)); + it = d_iter_start(d); + cmc_assert(d_iter_at_start(&it)); + + d_clear(d); + + cmc_assert(d_push_front(d, 1)); + it = d_iter_end(d); + cmc_assert(!d_iter_at_start(&it)); + it = d_iter_start(d); + cmc_assert(d_iter_at_start(&it)); + + d_free(d); + }); + + CMC_CREATE_TEST(PFX##_iter_at_end(), { + struct deque *d = d_new(100, d_fval); + + cmc_assert_not_equals(ptr, NULL, d); + + struct deque_iter it = d_iter_start(d); + + // Empty check + cmc_assert(d_iter_at_end(&it)); + it = d_iter_end(d); + cmc_assert(d_iter_at_end(&it)); + + // Non-empty checks + cmc_assert(d_push_back(d, 1)); + it = d_iter_end(d); + cmc_assert(d_iter_at_end(&it)); + it = d_iter_start(d); + cmc_assert(!d_iter_at_end(&it)); + + d_clear(d); + + cmc_assert(d_push_front(d, 1)); + it = d_iter_end(d); + cmc_assert(d_iter_at_end(&it)); + it = d_iter_start(d); + cmc_assert(!d_iter_at_end(&it)); + + d_free(d); + }); +});