void
queue_tail_del(struct queue * q)
{
    if (!queue_is_empty(q)) {
        queue_item_del(q->elems[q->tail]);
        free(q->elems[q->tail]);
        q->elems[q->tail] = NULL;
        q->tail = (q->tail + 1) % q->max_size;
        pthread_mutex_lock(&q->mux);
        {
            q->nr_elems--;
            if (queue_is_empty(q))
                pthread_cond_wait(&q->not_empty, &q->mux);
            pthread_cond_signal(&q->not_full);
        }
        pthread_mutex_unlock(&q->mux);
    }
}

} END_TEST


/* ************************************************************ */
/* bug tests                                                    */
/* ************************************************************ */
START_TEST(test_bug005562) {
	/*
	 * BUG 005562: Segfault after sending REGISTER to an invalid address (no registrar aat this address) and waiting >30sec
	 */

	sipstack_event *event;

	sipstack_init();

	int counter = 0;

	/* send REGISTER */
	int regId =
		sipstack_send_register("sip:"TEST_SIPSTACK_USER"@192.168.0.1", "sip:192.168.0.99", 1800);
	fail_unless(regId > -1, "Sending REGISTER failed. (result = %i)", regId);

	/* receive response */
	while (queue_is_empty(event_queue) && counter < 60) {
		sleep(1);
		counter++;
	}

	fail_unless(!queue_is_empty(event_queue), TEST_SIPSTACK_PREFIX "No response for registering received.");

	event = queue_front_and_dequeue(event_queue);

	/* expect REGISTRATION_FAILURE (2) */
	/* test failed*/
	if(event->type != 2) {
		/* free allocated memory before test fails */
		sipstack_event_free(event);
	}
	fail_unless(event->type == 2,
				"No event of type REGISTRATION_FAILURE received. (type = %i)", event->type);

	sipstack_event_free(event);
	sipstack_quit();
} END_TEST

void
floodfill(unsigned long * pixels, int x, int y, int width, int height,unsigned long color) {

    printf("\nEntrando to floodfill\n");
    queue *lista_xy;
    
    lista_xy = queue_init();

    int color_start = pixels[x + y * width];
   
    if (color != color_start) {
        queue_enqueue(x, lista_xy);
        queue_enqueue(y, lista_xy);

        pixels[x + y * width] = color;

        while (!queue_is_empty(lista_xy)) {
            if (x + 1 < width) {
                if (pixels[(x + 1) + y * width] == color_start) {
                    pixels[(x + 1) + y * width] = color;
                    queue_enqueue(x+1, lista_xy);
                    queue_enqueue(y, lista_xy);
                }
            }

            if (x - 1 >= 0){
                if (pixels[(x - 1) + y * width] == color_start) {
                    pixels[(x - 1) + y * width] = color;
                    queue_enqueue(x-1, lista_xy);
                    queue_enqueue(y, lista_xy);
                }
            }

            if (y + 1 < height){
                if (pixels[x + (y + 1) * width] == color_start) {
                    pixels[x + (y + 1) * width] = color;
                    queue_enqueue(x, lista_xy);
                    queue_enqueue(y+1, lista_xy);
                }
            }

            if (y - 1 >= 0){
                if (pixels[x + (y - 1) * width] == color_start){
                    pixels[x + (y - 1) * width] = color;
                    queue_enqueue(x, lista_xy);
                    queue_enqueue(y-1, lista_xy);
                }
            }
            x = lista_xy->front->info;
            queue_dequeue(lista_xy);
            y = lista_xy->front->info;
            queue_dequeue(lista_xy);
       }
   }
   queue_destroy(lista_xy);
} 

void
queue_invert (queue *q)
{
    if (queue_is_empty(q))
        return;

    pos c = queue_dequeue(q);
    queue_invert(q);
    queue_enqueue(q, c);
}

static void queue_insert_node(Queue *queue, 
						struct node *key) {
	if (queue_is_empty(queue)) {
		queue->head = key;
		queue->tail = key;
	} else {
		queue->tail->next = key;
		queue->tail = key;
	}
}

/*!
  * \brief
  *    Returns the key to the caller.
  *    If we have bt_wait flag set, it waits for the user choice.
  *
  * \param  wait  Wait for key flag
  * \retval key pressed or -1(EOF) if none.
  */
keys_t btn_getkey (uint8_t wait)
{
   keys_t ret=BTN_NULL;

   // wait for user's action
   while (wait && queue_is_empty (&btn_q))
      ;
   queue_get (&btn_q, (void*)&ret);
   return ret;
}

void *recExec() {
	while (1) {
		if (!queue_is_empty(pColaReady) && !queue_is_empty(pColaCpu)) {

			sem_wait(&mut_r);
			ptmp = queue_pop(pColaReady);
			sem_post(&mut_r);
			sem_wait(&mut_c);
			pcpu = queue_pop(pColaCpu);
			sem_post(&mut_c);
			ptmp->cpuexec = pcpu;

			//printf("Exec  proceso %d tiempo cpu %d\n",ptmp->pid,tact);
			sem_wait(&mut_e);
			queue_push(pColaExec, ptmp);
			sem_post(&mut_e);
		}
	}
}

/*!
  * \brief
  *   This function gets a byte from queue.
  * \param  pointer to byte
  * \return
  *   \arg  0  Empty queue
  *   \arg  1  Done
 */
__Os__ int queue_get (queue_t *queue, void *b)
{
   if ( queue_is_empty (queue) )    //Empty queue
      return 0;
   memcpy (b, (const void*)&queue->buf[queue->head*queue->item_size], queue->item_size);
   //rotate pointers
   if ( ++queue->head >= queue->items )
      queue->head = 0;
   return 1;
}

void
playlist_update_queued_song(struct playlist *playlist,
			    struct player_control *pc,
			    const struct song *prev)
{
	int next_order;
	const struct song *next_song;

	if (!playlist->playing)
		return;

	assert(!queue_is_empty(&playlist->queue));
	assert((playlist->queued < 0) == (prev == NULL));

	next_order = playlist->current >= 0
		? queue_next_order(&playlist->queue, playlist->current)
		: 0;

	if (next_order == 0 && playlist->queue.random &&
	    !playlist->queue.single) {
		/* shuffle the song order again, so we get a different
		   order each time the playlist is played
		   completely */
		unsigned current_position =
			queue_order_to_position(&playlist->queue,
						playlist->current);

		queue_shuffle_order(&playlist->queue);

		/* make sure that the playlist->current still points to
		   the current song, after the song order has been
		   shuffled */
		playlist->current =
			queue_position_to_order(&playlist->queue,
						current_position);
	}

	if (next_order >= 0)
		next_song = queue_get_order(&playlist->queue, next_order);
	else
		next_song = NULL;

	if (prev != NULL && next_song != prev) {
		/* clear the currently queued song */
		pc_cancel(pc);
		playlist->queued = -1;
	}

	if (next_order >= 0) {
		if (next_song != prev)
			playlist_queue_song_order(playlist, pc, next_order);
		else
			playlist->queued = next_order;
	}
}

uint32_t queue_get_ptr(queue_t * queue, uint8_t ** element)
{
    if (queue_is_empty(queue))
        return ERROR_NOT_FOUND;

    *element = &queue->elements[queue->head * queue->element_size];

    queue->head = (queue->head + 1u) % queue->size;

    return SUCCESS;
}

void queue_cleanup(queue* q)
{
    while(!queue_is_empty(q)){
	queue_pop(q);
    }

    free(q->array);
    sem_destroy(q->content_sem);
    sem_destroy(q->freespace_sem);
    pthread_mutex_destroy(q->mutex);
}

void queue_free (Queue* queue) {
  /* Empty the queue */

  while (!queue_is_empty (queue)) {
    queue_pop_head (queue);
    }

  /* Free back the queue */

  free (queue);
  }

//-----------------------------------------------------------------
//  need to use free() to free up memory
//-----------------------------------------------------------------
boolean_t queue_remove(queue_t q, queue_element_t * e) {
    queue_link_t oldHead;
    assert(q != NULL);
    if(queue_is_empty(q))
        return FALSE;
    *e = q->head->e;
    oldHead = q->head;
    q->head = q->head->next;

    return TRUE;
}

bool empty_queue(Queue *self) {
	if (!self) {
		return false;
	}
	while (!queue_is_empty(self)) {
		int *popped = queue_pop_tail(self);
		//printf("popped %d from queue\n", *popped);
		free(popped);
	}
	return true;
}

int main()
{
	int i;
	queue q = queue_create();
	assert(queue_is_empty(q));
	queue_enqueue(q, 3);
	assert(queue_dequeue(q) == 3);
	assert(queue_is_empty(q));
	for (i= 0; i < 99; i++) {
		queue_enqueue(q, i);
	}
	assert(queue_is_full(q));
	assert(queue_dequeue(q) == 0);
	queue_enqueue(q, 1);
	queue_enqueue(q, 1);
	assert(queue_is_full(q));
	queue_destroy(&q);
	assert(q == NULL);
	return 0;
}

void queue_reverse(queue* q) {
  assert(q != NULL);

  // If empty, do nothing.
  if (queue_is_empty(q)) {
    return;
  }

  queue_link* end = queue_reverse_helper(q, q->head);
  end->next = NULL;
}

/*
 * Dequeueing.
 */
void *dequeue() {
    if(queue_is_empty()) {
        printf("Fatal error: The queue is empty.\n");
        exit(-1);
    }

    void *item;
    item = queue[out_index];
    out_index = (out_index+1) % memory_size;
    return item;
}

int h2o_http2_scheduler_run(h2o_http2_scheduler_node_t *root, h2o_http2_scheduler_run_cb cb, void *cb_arg)
{
    if (root->_queue != NULL) {
        while (!queue_is_empty(root->_queue)) {
            int bail_out = proceed(root, cb, cb_arg);
            if (bail_out)
                return bail_out;
        }
    }
    return 0;
}

uint32_t queue_get(queue_t * queue, uint8_t * element)
{
    if (queue_is_empty(queue))
        return ERROR_NOT_FOUND;

    memcpy(element, &queue->elements[queue->head * queue->element_size], queue->element_size);

    queue->head = (queue->head + 1u) % queue->size;

    return SUCCESS;
}

static void *
async_queue_timed_pop_unlocked(UAsyncQueue *queue, uint64_t end_time)
{
    if (queue_is_empty(queue->queue)) {
        assert(!queue->is_waiting);
        ++queue->is_waiting;
        if (!end_time)
            pthread_cond_wait(&queue->cond, &queue->mutex);
        else {
            struct timespec timeout;
            timeout.tv_sec  = end_time / 1000000;
            timeout.tv_nsec = 1000 * (end_time % 1000000);
            pthread_cond_timedwait(&queue->cond, &queue->mutex, &timeout);
        }
        --queue->is_waiting;
        if (queue_is_empty(queue->queue))
            return NULL;
    }
    return queue_pop(queue->queue);
}