TEST_C(DequeTests, DequeAddAt1)
{
/* index < (size / 2) && index_raw > first_raw */
int a = 1;
int b = 2;
int c = 3;
int d = 4;
int e = 5;
int f = 6;
int g = 999;
deque_add_last(deque, &a);
deque_add_last(deque, &b);
deque_add_last(deque, &c);
deque_add_last(deque, &d);
deque_add_last(deque, &e);
deque_add_last(deque, &f);
deque_add_at(deque, &g, 4);
const void * const* buff = deque_get_buffer(deque);
CHECK_EQUAL_C_POINTER(buff[4], &g);
CHECK_EQUAL_C_POINTER(buff[5], &e);
const void *elem = buff[6];
CHECK_EQUAL_C_POINTER(elem, &f);
};
TEST_C(DequeTests, DequeAddAt5)
{
/* f == 0*/
int a = 1;
int b = 2;
int c = 3;
int d = 4;
int e = 5;
int f = 6;
int g = 7;
deque_add_last(deque, &a);
deque_add_last(deque, &b);
deque_add_last(deque, &c);
deque_add_last(deque, &d);
deque_add_last(deque, &e);
deque_add_last(deque, &f);
deque_add_at(deque, &g, 1);
const void * const* buff = deque_get_buffer(deque);
const int elem = *((int*) buff[7]);
CHECK_EQUAL_C_INT(elem, a);
const int elem1 = *((int*) buff[0]);
CHECK_EQUAL_C_INT(elem1, b);
const int elem2 = *((int*) buff[5]);
CHECK_EQUAL_C_INT(elem2, f);
const int elem3 = *((int*) buff[1]);
CHECK_EQUAL_C_INT(elem3, g);
};
TEST_C(DequeTests, DequeAddAt4)
{
/* index < size / 2 && index_raw < last_raw*/
int a = 1;
int b = 2;
int c = 3;
int d = 4;
int e = 5;
int f = 6;
int g = 999;
deque_add_last(deque, &a);
deque_add_last(deque, &b);
deque_add_last(deque, &c);
deque_add_last(deque, &d);
deque_add_last(deque, &e);
deque_add_first(deque, &f);
deque_add_at(deque, &g, 1);
const void * const*buff = deque_get_buffer(deque);
const int elem = *((int*) buff[0]);
CHECK_EQUAL_C_INT(elem, g);
const int elem1 = *((int*) buff[4]);
CHECK_EQUAL_C_INT(elem1, e);
const int elem2 = *((int*) buff[6]);
CHECK_EQUAL_C_INT(elem2, f);
const int elem3 = *((int*) buff[7]);
CHECK_EQUAL_C_INT(elem3, a);
};
TEST_C(DequeTests, DequeAddAt3)
{
/* index >= size / 2 && index_raw > last_raw */
int a = 1;
int b = 2;
int c = 3;
int d = 4;
int e = 5;
int f = 6;
int g = 999;
deque_add_last(deque, &a);
deque_add_first(deque, &b);
deque_add_first(deque, &c);
deque_add_first(deque, &d);
deque_add_first(deque, &e);
deque_add_first(deque, &f);
deque_add_at(deque, &g, 3);
const void * const* buff = deque_get_buffer(deque);
const void *elem = buff[6];
CHECK_EQUAL_C_POINTER(elem, &g);
const void *elem1 = buff[0];
CHECK_EQUAL_C_POINTER(elem1, &b);
const void *elem2 = buff[7];
CHECK_EQUAL_C_POINTER(elem2, &c);
const void *elem3 = buff[1];
CHECK_EQUAL_C_POINTER(elem3, &a);
};
/**
* Adds a new element to the Deque after the last returned element by
* <code>deque_iter_next()</code> function without invalidating the
* iterator.
*
* @note This function should only ever be called after a call to <code>
* deque_iter_next()</code>
*
* @param[in] iter the iterator on which this operation is being performed
* @param[in] element the element being added
*
* @return CC_OK if the element was successfully added, or CC_ERR_ALLOC
* if the memory allocation for the new element failed.
*/
enum cc_stat deque_iter_add(DequeIter *iter, void *element)
{
enum cc_stat status = deque_add_at(iter->deque, element, iter->index);
if (status == CC_OK)
iter->index++;
return status;
}
/**
* Adds a new element tothe deque after the last returned element by
* <code>deque_iter_next()</code> without invalidating the iterator.
*
* @param[in] iter the iterator on which this operation is being performed
* @param[in] element the element being added
*
* @return true if the elmenet was successfully added or false if the allocation
* for the new element failed.
*/
bool deque_iter_add(DequeIter *iter, void *element)
{
bool rm = deque_add_at(iter->deque, element, iter->index);
if (rm)
iter->index++;
return rm;
}
/**
* Adds a new element pair to the deques after the last returned element pair by
* <code>deque_zip_iter_next()</code> and immediately before an element pair
* that would be returned by a subsequent call to <code>deque_zip_iter_next()</code>
* without invalidating the iterator.
*
* @param[in] iter Iterator on which this operation is being performed
* @param[in] e1 element added to the first deque
* @param[in] e2 element added to the second deque
*
* @return CC_OK if the element pair was successfully added to the deques, or
* CC_ERR_ALLOC if the memory allocation for the new elements failed.
*/
enum cc_stat deque_zip_iter_add(DequeZipIter *iter, void *e1, void *e2)
{
if (iter->index >= iter->d1->size || iter->index >= iter->d2->size)
return CC_ERR_OUT_OF_RANGE;
/* While this check is performed by a call to deque_add_at, it is necessary to know
in advance whether both deque buffers have enough room before inserting new elements
because this operation must insert either both elements, or none.*/
if ((iter->d1->capacity == iter->d1->size && expand_capacity(iter->d1) != CC_OK) &&
(iter->d2->capacity == iter->d2->size && expand_capacity(iter->d2) != CC_OK)) {
return CC_ERR_ALLOC;
}
/* The retun status can be ignored since the checks have already been made. */
deque_add_at(iter->d1, e1, iter->index);
deque_add_at(iter->d2, e2, iter->index);
iter->index++;
return CC_OK;
}
