admin/C-Macro-Collections
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added new functions to deque and changed iterator functions

Browse Source 
New functions: init, init_custom, release
Added DequeIter unit tests
This commit is contained in:
Leonardo committed 2020-04-27 20:19:47 -03:00
1 parent db6f12d3e8
commit 27ac934ab6
4 files changed
+408 -156
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/cmc/deque.h
+96 -88
View File
@@ -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 */
tests/main/main.c
+1
View File
@@ -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);
tests/main/src/deque.c
+78 -66
View File
@@ -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;
}
tests/main/unt/deque.c
+233 -2
View File
@@ -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);
});
});