void TestarrayQueue_new_is_empty(
CuTest * tc
)
{
void *qu = aqueue_new(10, 1);
CuAssertTrue(tc, aqueue_is_empty(qu));
aqueue_free(qu);
}
void TestarrayQueue_empty_empties_queue(
CuTest * tc
)
{
char *item = "testitem";
void *qu = aqueue_new(10, 8);
aqueue_offer(qu, item);
aqueue_empty(qu);
CuAssertTrue(tc, 0 == aqueue_count(qu));
CuAssertTrue(tc, aqueue_is_empty(qu));
aqueue_free(qu);
}
static char const* test_aqueue(void) {
Aqueue aq;
Aqueue* const p = &aq;
aqueue_init(p, sizeof(int), MAX_CAPACITY, NULL);
MIN_UNIT_ASSERT("aqueue_init is wrong.", aqueue_is_empty(p) == true);
MIN_UNIT_ASSERT("aqueue_init is wrong.", aqueue_get_capacity(p) == MAX_CAPACITY);
MIN_UNIT_ASSERT("aqueue_init is wrong.", aqueue_get_size(p) == 0);
for (int i = 0; i < MAX_CAPACITY; i++) {
aqueue_insert(p, &i);
MIN_UNIT_ASSERT("aqueue_insert is wrong.", aqueue_get(int, p) == 0);
}
MIN_UNIT_ASSERT("aqueue_insert result is wrong.", aqueue_get_size(p) == MAX_CAPACITY);
for (int i = 0; i < MAX_CAPACITY; i++) {
int* t = (int*)aqueue_get_first(p);
MIN_UNIT_ASSERT("aqueue_get is wrong.", *t == i);
aqueue_delete_first(p);
}
MIN_UNIT_ASSERT("aqueue_delete_first is wrong", aqueue_is_empty(p) == true);
aqueue_destruct(p);
aqueue_init(p, sizeof(char*), MAX_CAPACITY, release_str);
for (int i = 0; i < STR_NUM; i++) {
aqueue_insert(p, &sample_str_data[i]);
MIN_UNIT_ASSERT("aqueue_insert is wrong", 0 == strcmp(sample_str_data[0], aqueue_get(char const*, p)));
}
MIN_UNIT_ASSERT("aqueue_insert result is wrong.", aqueue_get_size(p) == STR_NUM);
MIN_UNIT_ASSERT("aqueue_insert result is wrong.", aqueue_is_empty(p) == false);
aqueue_destruct(p);
MIN_UNIT_ASSERT("aqueue_destruct is wrong.", p->data != NULL);
printf("All Test Passed.\n");
return NULL;
}
static int __load(dqueue_t* me)
{
unsigned int pos = 0;
while (pos < me->size)
{
int e, start_pos;
header_t h;
start_pos = pos;
/* 1. read first header */
e = read(me->fd, &h, sizeof(header_t));
if (e < (int)sizeof(header_t))
return -1;
pos += sizeof(header_t);
/* check header is ok */
if (h.type != HEADER || 0 != memcmp(h.stamp, STAMP, strlen(STAMP)))
continue;
unsigned int check_id = h.id;
/* 2. read 2nd header */
/* put on sizeof(header_t) offset */
size_t offset = sizeof(header_t) - ntohl(h.len) % sizeof(header_t);
e = lseek(me->fd, ntohl(h.len) + offset, SEEK_CUR);
pos += ntohl(h.len);
e = read(me->fd, &h, sizeof(header_t));
if (e < (int)sizeof(header_t))
{
perror("couldn't read file\n");
return -1;
}
pos += __padding_required(ntohl(h.len));
pos += sizeof(header_t);
if (h.id != check_id || ntohl(h.type) != FOOTER || 0 !=
memcmp(h.stamp, STAMP, strlen(STAMP)))
continue;
/* found a valid queue item */
item_t item;
item.pos = start_pos;
item.len = ntohl(h.len);
item.space_used = ntohl(h.len) + ITEM_METADATA_SIZE +
__padding_required(ntohl(h.len));
item.id = h.id;
aqueue_offerensure((void*)&me->items, &item);
h.id = ntohl(h.id);
}
if (0 == aqueue_count(me->items))
return 0;
/* get lowest */
unsigned int lowest_id = UINT_MAX;
unsigned int highest_id = 0;
arrayqueue_iter_t iter;
for (aqueue_iter(me->items, &iter);
aqueue_iter_has_next(me->items, &iter); )
{
item_t* item = aqueue_iter_next(me->items, &iter);
if (item->id < lowest_id)
{
lowest_id = item->id;
me->head = item->pos;
}
/* set tail */
if (highest_id < item->id)
{
highest_id = item->id;
me->tail = item->pos + item->len + ITEM_METADATA_SIZE +
__padding_required(item->len);
me->item_id = item->id + 1;
}
}
arrayqueue_t* stowaway = aqueue_new(16, sizeof(item_t));
/* put lowest at front of queue */
while (!aqueue_is_empty(me->items))
{
item_t* item = aqueue_peek(me->items);
if (item->id == lowest_id)
break;
aqueue_offerensure(&stowaway, aqueue_peek(me->items));
aqueue_poll(me->items);
}
/* empty out stowaway */
while (!aqueue_is_empty(stowaway))
{
aqueue_offerensure((void*)&me->items, aqueue_peek(stowaway));
aqueue_poll(stowaway);
}
aqueue_free(stowaway);
return 0;
}
